diff --git a/ast/encode_test.go b/ast/encode_test.go
index a63e1f85f..022e717c2 100644
--- a/ast/encode_test.go
+++ b/ast/encode_test.go
@@ -17,215 +17,217 @@
 package ast
 
 import (
-    `encoding/json`
-    `runtime`
-    `sync`
-    `testing`
+	"encoding/json"
+	"runtime"
+	"sync"
+	"testing"
 
-    `github.com/bytedance/sonic/internal/native/types`
-    `github.com/stretchr/testify/assert`
-    `github.com/stretchr/testify/require`
+	"github.com/bytedance/sonic/internal/native/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestGC_Encode(t *testing.T) {
-    if debugSyncGC {
-        return
-    }
-    root, err := NewSearcher(_TwitterJson).GetByPath()
-    if err != nil {
-        t.Fatal(err)
-    }
-    root.LoadAll()
-    _, err = root.MarshalJSON()
-    if err != nil {
-        t.Fatal(err)
-    }
-    wg := &sync.WaitGroup{}
-    N := 10000
-    for i:=0; i<N; i++ {
-        wg.Add(1)
-        go func (wg *sync.WaitGroup)  {
-            defer wg.Done()
-            root, err := NewSearcher(_TwitterJson).GetByPath()
-            if err != nil {
-                t.Fatal(err)
-            }
-            root.Load()
-            _, err = root.MarshalJSON()
-            if err != nil {
-                t.Fatal(err)
-            }
-            runtime.GC()
-        }(wg)
-    }
-    wg.Wait()
+	if debugSyncGC {
+		return
+	}
+	root, err := NewSearcher(_TwitterJson).GetByPath()
+	if err != nil {
+		t.Fatal(err)
+	}
+	root.LoadAll()
+	_, err = root.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+	wg := &sync.WaitGroup{}
+	N := 10000
+	for i := 0; i < N; i++ {
+		wg.Add(1)
+		go func(wg *sync.WaitGroup) {
+			defer wg.Done()
+			root, err := NewSearcher(_TwitterJson).GetByPath()
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			root.Load()
+			_, err = root.MarshalJSON()
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			runtime.GC()
+		}(wg)
+	}
+	wg.Wait()
 }
 
 func TestEncodeValue(t *testing.T) {
-    obj := new(_TwitterStruct)
-    if err := json.Unmarshal([]byte(_TwitterJson), obj); err != nil {
-        t.Fatal(err)
-    }
-    // buf, err := encoder.Encode(obj, encoder.EscapeHTML|encoder.SortMapKeys)
-    buf, err := json.Marshal(obj)
-    if err != nil {
-        t.Fatal(err)
-    }
-    quote, err := json.Marshal(_TwitterJson)
-    if err != nil {
-        t.Fatal(err)
-    }
-    type Case struct {
-        node Node
-        exp string
-        err bool
-    }
-    input := []Case{
-        {NewNull(), "null", false},
-        {NewBool(true), "true", false},
-        {NewBool(false), "false", false},
-        {NewNumber("0.0"), "0.0", false},
-        {NewString(""), `""`, false},
-        {NewString(`\"\"`), `"\\\"\\\""`, false},
-        {NewString(_TwitterJson), string(quote), false},
-        {NewArray([]Node{}), "[]", false},
-        {NewArray([]Node{NewString(""), NewNull()}), `["",null]`, false},
-        {NewArray([]Node{NewBool(true), NewString("true"), NewString("\t")}), `[true,"true","\t"]`, false},
-        {NewObject([]Pair{Pair{"a", NewNull()}, Pair{"b", NewNumber("0")}}), `{"a":null,"b":0}`, false},
-        {NewObject([]Pair{Pair{"\ta", NewString("\t")}, Pair{"\bb", NewString("\b")}, Pair{"\nb", NewString("\n")}, Pair{"\ra", NewString("\r")}}),`{"\ta":"\t","\u0008b":"\u0008","\nb":"\n","\ra":"\r"}`, false},
-        {NewObject([]Pair{}), `{}`, false},
-        {NewObject([]Pair{Pair{Key: "", Value: NewNull()}}), `{"":null}`, false},
-        {NewBytes([]byte("hello, world")), `"aGVsbG8sIHdvcmxk"`, false},
-        {NewAny(obj), string(buf), false},
-        {NewRaw(`[{ }]`), "[{}]", false},
-        {Node{}, "", true},
-        {Node{t: types.ValueType(1)}, "", true},
-    }
-    for i, c := range input {
-        t.Log(i)
-        buf, err := json.Marshal(&c.node)
-        if c.err {
-            if err == nil {
-                t.Fatal(i)
-            }
-            continue
-        }
-        if err != nil {
-            t.Fatal(i, err)
-        }
-        assert.Equal(t, c.exp, string(buf))
-    }
+	obj := new(_TwitterStruct)
+	if err := json.Unmarshal([]byte(_TwitterJson), obj); err != nil {
+		t.Fatal(err)
+	}
+	// buf, err := encoder.Encode(obj, encoder.EscapeHTML|encoder.SortMapKeys)
+	buf, err := json.Marshal(obj)
+	if err != nil {
+		t.Fatal(err)
+	}
+	quote, err := json.Marshal(_TwitterJson)
+	if err != nil {
+		t.Fatal(err)
+	}
+	type Case struct {
+		node Node
+		exp  string
+		err  bool
+	}
+	input := []Case{
+		{NewNull(), "null", false},
+		{NewBool(true), "true", false},
+		{NewBool(false), "false", false},
+		{NewNumber("0.0"), "0.0", false},
+		{NewString(""), `""`, false},
+		{NewString(`\"\"`), `"\\\"\\\""`, false},
+		{NewString(_TwitterJson), string(quote), false},
+		{NewArray([]Node{}), "[]", false},
+		{NewArray([]Node{NewString(""), NewNull()}), `["",null]`, false},
+		{NewArray([]Node{NewBool(true), NewString("true"), NewString("\t")}), `[true,"true","\t"]`, false},
+		{NewObject([]Pair{Pair{"a", NewNull()}, Pair{"b", NewNumber("0")}}), `{"a":null,"b":0}`, false},
+		{NewObject([]Pair{Pair{"\ta", NewString("\t")}, Pair{"\bb", NewString("\b")}, Pair{"\nb", NewString("\n")}, Pair{"\ra", NewString("\r")}}), `{"\ta":"\t","\u0008b":"\u0008","\nb":"\n","\ra":"\r"}`, false},
+		{NewObject([]Pair{}), `{}`, false},
+		{NewObject([]Pair{Pair{Key: "", Value: NewNull()}}), `{"":null}`, false},
+		{NewBytes([]byte("hello, world")), `"aGVsbG8sIHdvcmxk"`, false},
+		{NewAny(obj), string(buf), false},
+		{NewRaw(`[{ }]`), "[{}]", false},
+		{Node{}, "", true},
+		{Node{t: types.ValueType(1)}, "", true},
+	}
+	for i, c := range input {
+		t.Log(i)
+		buf, err := json.Marshal(&c.node)
+		if c.err {
+			if err == nil {
+				t.Fatal(i)
+			}
+			continue
+		}
+		if err != nil {
+			t.Fatal(i, err)
+		}
+		assert.Equal(t, c.exp, string(buf))
+	}
 }
 
 func TestEncodeNode(t *testing.T) {
-    data := `{"a":[{},[],-0.1,true,false,null,""],"b":0,"c":true,"d":false,"e":null,"g":""}`
-    root, e := NewSearcher(data).GetByPath()
-    if e != nil {
-        t.Fatal(root)
-    }
-    ret, err := root.MarshalJSON()
-    if err != nil {
-        t.Fatal(err)
-    }
-    if string(ret) != data {
-        t.Fatal(string(ret))
-    }
-    root.skipAllKey()
-    ret, err = root.MarshalJSON()
-    if err != nil {
-        t.Fatal(err)
-    }
-    if string(ret) != data {
-        t.Fatal(string(ret))
-    }
-    root.loadAllKey()
-    ret, err = root.MarshalJSON()
-    if err != nil {
-        t.Fatal(err)
-    }
-    if string(ret) != data {
-        t.Fatal(string(ret))
-    }
+	data := `{"a":[{},[],-0.1,true,false,null,""],"b":0,"c":true,"d":false,"e":null,"g":""}`
+	root, e := NewSearcher(data).GetByPath()
+	if e != nil {
+		t.Fatal(root)
+	}
+	ret, err := root.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(ret) != data {
+		t.Fatal(string(ret))
+	}
+	root.skipAllKey()
+	ret, err = root.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(ret) != data {
+		t.Fatal(string(ret))
+	}
+	root.loadAllKey()
+	ret, err = root.MarshalJSON()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(ret) != data {
+		t.Fatal(string(ret))
+	}
 }
 
 func BenchmarkEncodeRaw_Sonic(b *testing.B) {
-    data := _TwitterJson
-    root, e := NewSearcher(data).GetByPath()
-    if e != nil {
-        b.Fatal(root)
-    }
-    _, err := root.MarshalJSON()
-    if err != nil {
-        b.Fatal(err)
-    }
-    b.SetBytes(int64(len(data)))
-    b.ResetTimer()
-    for i:=0; i<b.N; i++ {
-        _, err := root.MarshalJSON()
-        if err != nil {
-            b.Fatal(err)
-        }
-    }
+	data := _TwitterJson
+	root, e := NewSearcher(data).GetByPath()
+	if e != nil {
+		b.Fatal(root)
+	}
+	_, err := root.MarshalJSON()
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(len(data)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := root.MarshalJSON()
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
 }
 
 func BenchmarkEncodeSkip_Sonic(b *testing.B) {
-    data := _TwitterJson
-    root, e := NewParser(data).Parse()
-    if e != 0 {
-        b.Fatal(root)
-    }
-    root.skipAllKey()
-    _, err := root.MarshalJSON()
-    if err != nil {
-        b.Fatal(err)
-    }
-    b.SetBytes(int64(len(data)))
-    b.ResetTimer()
-    for i:=0; i<b.N; i++ {
-        _, err := root.MarshalJSON()
-        if err != nil {
-            b.Fatal(err)
-        }
-    }
+	data := _TwitterJson
+	root, e := NewParser(data).Parse()
+	if e != 0 {
+		b.Fatal(root)
+	}
+	root.skipAllKey()
+	_, err := root.MarshalJSON()
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(len(data)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := root.MarshalJSON()
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
 }
 
 func BenchmarkEncodeLoad_Sonic(b *testing.B) {
-    data := _TwitterJson
-    root, e := NewParser(data).Parse()
-    if e != 0 {
-        b.Fatal(root)
-    }
-    root.loadAllKey()
-    _, err := root.MarshalJSON()
-    if err != nil {
-        b.Fatal(err)
-    }
-    b.SetBytes(int64(len(data)))
-    b.ResetTimer()
-    for i:=0; i<b.N; i++ {
-        _, err := root.MarshalJSON()
-        if err != nil {
-            b.Fatal(err)
-        }
-    }
+	data := _TwitterJson
+	root, e := NewParser(data).Parse()
+	if e != 0 {
+		b.Fatal(root)
+	}
+	root.loadAllKey()
+	_, err := root.MarshalJSON()
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(len(data)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, err := root.MarshalJSON()
+		if err != nil {
+			b.Fatal(err)
+		}
+	}
 }
 
 func TestEncodeNone(t *testing.T) {
-    n := NewObject([]Pair{{Key:"a", Value:Node{}}})
-    out, err := n.MarshalJSON()
-    require.NoError(t, err)
-    require.Equal(t, "{}", string(out))
-    n = NewObject([]Pair{{Key:"a", Value:NewNull()}, {Key:"b", Value:Node{}}})
-    out, err = n.MarshalJSON()
-    require.NoError(t, err)
-    require.Equal(t, `{"a":null}`, string(out))
+	n := NewObject([]Pair{{Key: "a", Value: Node{}}})
+	out, err := n.MarshalJSON()
+	require.NoError(t, err)
+	require.Equal(t, "{}", string(out))
+	n = NewObject([]Pair{{Key: "a", Value: NewNull()}, {Key: "b", Value: Node{}}})
+	out, err = n.MarshalJSON()
+	require.NoError(t, err)
+	require.Equal(t, `{"a":null}`, string(out))
 
-    n = NewArray([]Node{Node{}})
-    out, err = n.MarshalJSON()
-    require.NoError(t, err)
-    require.Equal(t, "[]", string(out))
-    n = NewArray([]Node{NewNull(), Node{}})
-    out, err = n.MarshalJSON()
-    require.NoError(t, err)
-    require.Equal(t, `[null]`, string(out))
-}
\ No newline at end of file
+	n = NewArray([]Node{Node{}})
+	out, err = n.MarshalJSON()
+	require.NoError(t, err)
+	require.Equal(t, "[]", string(out))
+	n = NewArray([]Node{NewNull(), Node{}})
+	out, err = n.MarshalJSON()
+	require.NoError(t, err)
+	require.Equal(t, `[null]`, string(out))
+}
diff --git a/ast/parser_test.go b/ast/parser_test.go
index 037ca2d37..cfc184e5c 100644
--- a/ast/parser_test.go
+++ b/ast/parser_test.go
@@ -17,338 +17,343 @@
 package ast
 
 import (
-    `encoding/json`
-    `os`
-    `runtime`
-    `runtime/debug`
-    `sync`
-    `testing`
-    `time`
+	"encoding/json"
+	"os"
+	"runtime"
+	"runtime/debug"
+	"sync"
+	"testing"
+	"time"
 
-    `github.com/stretchr/testify/assert`
-    `github.com/stretchr/testify/require`
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 var (
-    debugSyncGC  = os.Getenv("SONIC_SYNC_GC")  != ""
-    debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == ""
+	debugSyncGC  = os.Getenv("SONIC_SYNC_GC") != ""
+	debugAsyncGC = os.Getenv("SONIC_NO_ASYNC_GC") == ""
 )
 
 func TestMain(m *testing.M) {
-    go func ()  {
-        if !debugAsyncGC {
-            return
-        }
-        println("Begin GC looping...")
-        for {
-            runtime.GC()
-            debug.FreeOSMemory()
-        }
-        println("stop GC looping!")
-    }()
-    time.Sleep(time.Millisecond)
-    m.Run()
+	go func() {
+		if !debugAsyncGC {
+			return
+		}
+		println("Begin GC looping...")
+		for {
+			runtime.GC()
+			debug.FreeOSMemory()
+		}
+		println("stop GC looping!")
+	}()
+	time.Sleep(time.Millisecond)
+	m.Run()
 }
 
 func TestGC_Parse(t *testing.T) {
-    if debugSyncGC {
-        return
-    }
-    _, _, err := Loads(_TwitterJson)
-    if err != nil {
-        t.Fatal(err)
-    }
-    wg := &sync.WaitGroup{}
-    N := 1000
-    for i:=0; i<N; i++ {
-        wg.Add(1)
-        go func (wg *sync.WaitGroup)  {
-            defer wg.Done()
-            _, _, err := Loads(_TwitterJson)
-            if err != nil {
-                t.Fatal(err)
-            }
-            runtime.GC()
-        }(wg)
-    }
-    wg.Wait()
+	if debugSyncGC {
+		return
+	}
+	_, _, err := Loads(_TwitterJson)
+	if err != nil {
+		t.Fatal(err)
+	}
+	wg := &sync.WaitGroup{}
+	N := 1000
+	for i := 0; i < N; i++ {
+		wg.Add(1)
+		go func(wg *sync.WaitGroup) {
+			defer wg.Done()
+			_, _, err := Loads(_TwitterJson)
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			runtime.GC()
+		}(wg)
+	}
+	wg.Wait()
 }
 
 func runDecoderTest(t *testing.T, src string, expect interface{}) {
-    vv, err := NewParser(src).Parse()
-    if err != 0 { panic(err) }
-    x, _ := vv.Interface()
-    assert.Equal(t, expect, x)
+	vv, err := NewParser(src).Parse()
+	if err != 0 {
+		panic(err)
+	}
+	x, _ := vv.Interface()
+	assert.Equal(t, expect, x)
 }
 
 func runDecoderTestUseNumber(t *testing.T, src string, expect interface{}) {
-    vv, err := NewParser(src).Parse()
-    if err != 0 { panic(err) }
-    vvv, _ := vv.InterfaceUseNumber()
-    switch vvv.(type) {
-    case json.Number:
-        assert.Equal(t, expect, n2f64(vvv.(json.Number)))
-    case []interface{}:
-        x := vvv.([]interface{})
-        for i, e := range x {
-            if ev,ok := e.(json.Number);ok {
-                x[i] = n2f64(ev)
-            }
-        }
-        assert.Equal(t, expect, x)
-    case map[string]interface{}:
-        x := vvv.(map[string]interface{})
-        for k,v := range x {
-            if ev, ok := v.(json.Number); ok {
-                x[k] = n2f64(ev)
-            }
-        }
-        assert.Equal(t, expect, x)
-    }
+	vv, err := NewParser(src).Parse()
+	if err != 0 {
+		panic(err)
+	}
+	vvv, _ := vv.InterfaceUseNumber()
+	switch vvv.(type) {
+	case json.Number:
+		assert.Equal(t, expect, n2f64(vvv.(json.Number)))
+	case []interface{}:
+		x := vvv.([]interface{})
+		for i, e := range x {
+			if ev, ok := e.(json.Number); ok {
+				x[i] = n2f64(ev)
+			}
+		}
+		assert.Equal(t, expect, x)
+	case map[string]interface{}:
+		x := vvv.(map[string]interface{})
+		for k, v := range x {
+			if ev, ok := v.(json.Number); ok {
+				x[k] = n2f64(ev)
+			}
+		}
+		assert.Equal(t, expect, x)
+	}
 }
 
-func n2f64(i json.Number) float64{
-    x, err := i.Float64()
-    if err != nil {
-        panic(err)
-    }
-    return x
+func n2f64(i json.Number) float64 {
+	x, err := i.Float64()
+	if err != nil {
+		panic(err)
+	}
+	return x
 }
 
 func TestParser_Basic(t *testing.T) {
-    runDecoderTest(t, `null`, nil)
-    runDecoderTest(t, `true`, true)
-    runDecoderTest(t, `false`, false)
-    runDecoderTest(t, `"hello, world \\ \/ \b \f \n \r \t \u666f 测试中文"`, "hello, world \\ / \b \f \n \r \t \u666f 测试中文")
-    runDecoderTest(t, `"\ud83d\ude00"`, "😀")
-    runDecoderTest(t, `0`, float64(0))
-    runDecoderTest(t, `-0`, float64(0))
-    runDecoderTest(t, `123456`, float64(123456))
-    runDecoderTest(t, `-12345`, float64(-12345))
-    runDecoderTest(t, `0.2`, 0.2)
-    runDecoderTest(t, `1.2`, 1.2)
-    runDecoderTest(t, `-0.2`, -0.2)
-    runDecoderTest(t, `-1.2`, -1.2)
-    runDecoderTest(t, `0e12`, 0e12)
-    runDecoderTest(t, `0e+12`, 0e+12)
-    runDecoderTest(t, `0e-12`, 0e-12)
-    runDecoderTest(t, `-0e12`, -0e12)
-    runDecoderTest(t, `-0e+12`, -0e+12)
-    runDecoderTest(t, `-0e-12`, -0e-12)
-    runDecoderTest(t, `2e12`, 2e12)
-    runDecoderTest(t, `2E12`, 2e12)
-    runDecoderTest(t, `2e+12`, 2e+12)
-    runDecoderTest(t, `2e-12`, 2e-12)
-    runDecoderTest(t, `-2e12`, -2e12)
-    runDecoderTest(t, `-2e+12`, -2e+12)
-    runDecoderTest(t, `-2e-12`, -2e-12)
-    runDecoderTest(t, `0.2e12`, 0.2e12)
-    runDecoderTest(t, `0.2e+12`, 0.2e+12)
-    runDecoderTest(t, `0.2e-12`, 0.2e-12)
-    runDecoderTest(t, `-0.2e12`, -0.2e12)
-    runDecoderTest(t, `-0.2e+12`, -0.2e+12)
-    runDecoderTest(t, `-0.2e-12`, -0.2e-12)
-    runDecoderTest(t, `1.2e12`, 1.2e12)
-    runDecoderTest(t, `1.2e+12`, 1.2e+12)
-    runDecoderTest(t, `1.2e-12`, 1.2e-12)
-    runDecoderTest(t, `-1.2e12`, -1.2e12)
-    runDecoderTest(t, `-1.2e+12`, -1.2e+12)
-    runDecoderTest(t, `-1.2e-12`, -1.2e-12)
-    runDecoderTest(t, `-1.2E-12`, -1.2e-12)
-    runDecoderTest(t, `[]`, []interface{}{})
-    runDecoderTest(t, `{}`, map[string]interface{}{})
-    runDecoderTest(t, `["asd", "123", true, false, null, 2.4, 1.2e15]`, []interface{}{"asd", "123", true, false, nil, 2.4, 1.2e15})
-    runDecoderTest(t, `{"asdf": "qwer", "zxcv": true}`, map[string]interface{}{"asdf": "qwer", "zxcv": true})
-    runDecoderTest(t, `{"a": "123", "b": true, "c": false, "d": null, "e": 2.4, "f": 1.2e15, "g": 1}`, map[string]interface{}{"a":"123", "b":true, "c":false, "d":nil, "e": 2.4, "f": 1.2e15, "g":float64(1)})
+	runDecoderTest(t, `null`, nil)
+	runDecoderTest(t, `true`, true)
+	runDecoderTest(t, `false`, false)
+	runDecoderTest(t, `"hello, world \\ \/ \b \f \n \r \t \u666f 测试中文"`, "hello, world \\ / \b \f \n \r \t \u666f 测试中文")
+	runDecoderTest(t, `"\ud83d\ude00"`, "😀")
+	runDecoderTest(t, `0`, float64(0))
+	runDecoderTest(t, `-0`, float64(0))
+	runDecoderTest(t, `123456`, float64(123456))
+	runDecoderTest(t, `-12345`, float64(-12345))
+	runDecoderTest(t, `0.2`, 0.2)
+	runDecoderTest(t, `1.2`, 1.2)
+	runDecoderTest(t, `-0.2`, -0.2)
+	runDecoderTest(t, `-1.2`, -1.2)
+	runDecoderTest(t, `0e12`, 0e12)
+	runDecoderTest(t, `0e+12`, 0e+12)
+	runDecoderTest(t, `0e-12`, 0e-12)
+	runDecoderTest(t, `-0e12`, -0e12)
+	runDecoderTest(t, `-0e+12`, -0e+12)
+	runDecoderTest(t, `-0e-12`, -0e-12)
+	runDecoderTest(t, `2e12`, 2e12)
+	runDecoderTest(t, `2E12`, 2e12)
+	runDecoderTest(t, `2e+12`, 2e+12)
+	runDecoderTest(t, `2e-12`, 2e-12)
+	runDecoderTest(t, `-2e12`, -2e12)
+	runDecoderTest(t, `-2e+12`, -2e+12)
+	runDecoderTest(t, `-2e-12`, -2e-12)
+	runDecoderTest(t, `0.2e12`, 0.2e12)
+	runDecoderTest(t, `0.2e+12`, 0.2e+12)
+	runDecoderTest(t, `0.2e-12`, 0.2e-12)
+	runDecoderTest(t, `-0.2e12`, -0.2e12)
+	runDecoderTest(t, `-0.2e+12`, -0.2e+12)
+	runDecoderTest(t, `-0.2e-12`, -0.2e-12)
+	runDecoderTest(t, `1.2e12`, 1.2e12)
+	runDecoderTest(t, `1.2e+12`, 1.2e+12)
+	runDecoderTest(t, `1.2e-12`, 1.2e-12)
+	runDecoderTest(t, `-1.2e12`, -1.2e12)
+	runDecoderTest(t, `-1.2e+12`, -1.2e+12)
+	runDecoderTest(t, `-1.2e-12`, -1.2e-12)
+	runDecoderTest(t, `-1.2E-12`, -1.2e-12)
+	runDecoderTest(t, `[]`, []interface{}{})
+	runDecoderTest(t, `{}`, map[string]interface{}{})
+	runDecoderTest(t, `["asd", "123", true, false, null, 2.4, 1.2e15]`, []interface{}{"asd", "123", true, false, nil, 2.4, 1.2e15})
+	runDecoderTest(t, `{"asdf": "qwer", "zxcv": true}`, map[string]interface{}{"asdf": "qwer", "zxcv": true})
+	runDecoderTest(t, `{"a": "123", "b": true, "c": false, "d": null, "e": 2.4, "f": 1.2e15, "g": 1}`, map[string]interface{}{"a": "123", "b": true, "c": false, "d": nil, "e": 2.4, "f": 1.2e15, "g": float64(1)})
 
-    runDecoderTestUseNumber(t, `null`, nil)
-    runDecoderTestUseNumber(t, `true`, true)
-    runDecoderTestUseNumber(t, `false`, false)
-    runDecoderTestUseNumber(t, `"hello, world \\ \/ \b \f \n \r \t \u666f 测试中文"`, "hello, world \\ / \b \f \n \r \t \u666f 测试中文")
-    runDecoderTestUseNumber(t, `"\ud83d\ude00"`, "😀")
-    runDecoderTestUseNumber(t, `0`, float64(0))
-    runDecoderTestUseNumber(t, `-0`, float64(0))
-    runDecoderTestUseNumber(t, `123456`, float64(123456))
-    runDecoderTestUseNumber(t, `-12345`, float64(-12345))
-    runDecoderTestUseNumber(t, `0.2`, 0.2)
-    runDecoderTestUseNumber(t, `1.2`, 1.2)
-    runDecoderTestUseNumber(t, `-0.2`, -0.2)
-    runDecoderTestUseNumber(t, `-1.2`, -1.2)
-    runDecoderTestUseNumber(t, `0e12`, 0e12)
-    runDecoderTestUseNumber(t, `0e+12`, 0e+12)
-    runDecoderTestUseNumber(t, `0e-12`, 0e-12)
-    runDecoderTestUseNumber(t, `-0e12`, -0e12)
-    runDecoderTestUseNumber(t, `-0e+12`, -0e+12)
-    runDecoderTestUseNumber(t, `-0e-12`, -0e-12)
-    runDecoderTestUseNumber(t, `2e12`, 2e12)
-    runDecoderTestUseNumber(t, `2E12`, 2e12)
-    runDecoderTestUseNumber(t, `2e+12`, 2e+12)
-    runDecoderTestUseNumber(t, `2e-12`, 2e-12)
-    runDecoderTestUseNumber(t, `-2e12`, -2e12)
-    runDecoderTestUseNumber(t, `-2e+12`, -2e+12)
-    runDecoderTestUseNumber(t, `-2e-12`, -2e-12)
-    runDecoderTestUseNumber(t, `0.2e12`, 0.2e12)
-    runDecoderTestUseNumber(t, `0.2e+12`, 0.2e+12)
-    runDecoderTestUseNumber(t, `0.2e-12`, 0.2e-12)
-    runDecoderTestUseNumber(t, `-0.2e12`, -0.2e12)
-    runDecoderTestUseNumber(t, `-0.2e+12`, -0.2e+12)
-    runDecoderTestUseNumber(t, `-0.2e-12`, -0.2e-12)
-    runDecoderTestUseNumber(t, `1.2e12`, 1.2e12)
-    runDecoderTestUseNumber(t, `1.2e+12`, 1.2e+12)
-    runDecoderTestUseNumber(t, `1.2e-12`, 1.2e-12)
-    runDecoderTestUseNumber(t, `-1.2e12`, -1.2e12)
-    runDecoderTestUseNumber(t, `-1.2e+12`, -1.2e+12)
-    runDecoderTestUseNumber(t, `-1.2e-12`, -1.2e-12)
-    runDecoderTestUseNumber(t, `-1.2E-12`, -1.2e-12)
-    runDecoderTestUseNumber(t, `["asd", "123", true, false, null, 2.4, 1.2e15, 1]`, []interface{}{"asd", "123", true, false, nil, 2.4, 1.2e15, float64(1)})
-    runDecoderTestUseNumber(t, `{"a": "123", "b": true, "c": false, "d": null, "e": 2.4, "f": 1.2e15, "g": 1}`, map[string]interface{}{"a":"123", "b":true, "c":false, "d":nil, "e": 2.4, "f": 1.2e15, "g":float64(1)})
+	runDecoderTestUseNumber(t, `null`, nil)
+	runDecoderTestUseNumber(t, `true`, true)
+	runDecoderTestUseNumber(t, `false`, false)
+	runDecoderTestUseNumber(t, `"hello, world \\ \/ \b \f \n \r \t \u666f 测试中文"`, "hello, world \\ / \b \f \n \r \t \u666f 测试中文")
+	runDecoderTestUseNumber(t, `"\ud83d\ude00"`, "😀")
+	runDecoderTestUseNumber(t, `0`, float64(0))
+	runDecoderTestUseNumber(t, `-0`, float64(0))
+	runDecoderTestUseNumber(t, `123456`, float64(123456))
+	runDecoderTestUseNumber(t, `-12345`, float64(-12345))
+	runDecoderTestUseNumber(t, `0.2`, 0.2)
+	runDecoderTestUseNumber(t, `1.2`, 1.2)
+	runDecoderTestUseNumber(t, `-0.2`, -0.2)
+	runDecoderTestUseNumber(t, `-1.2`, -1.2)
+	runDecoderTestUseNumber(t, `0e12`, 0e12)
+	runDecoderTestUseNumber(t, `0e+12`, 0e+12)
+	runDecoderTestUseNumber(t, `0e-12`, 0e-12)
+	runDecoderTestUseNumber(t, `-0e12`, -0e12)
+	runDecoderTestUseNumber(t, `-0e+12`, -0e+12)
+	runDecoderTestUseNumber(t, `-0e-12`, -0e-12)
+	runDecoderTestUseNumber(t, `2e12`, 2e12)
+	runDecoderTestUseNumber(t, `2E12`, 2e12)
+	runDecoderTestUseNumber(t, `2e+12`, 2e+12)
+	runDecoderTestUseNumber(t, `2e-12`, 2e-12)
+	runDecoderTestUseNumber(t, `-2e12`, -2e12)
+	runDecoderTestUseNumber(t, `-2e+12`, -2e+12)
+	runDecoderTestUseNumber(t, `-2e-12`, -2e-12)
+	runDecoderTestUseNumber(t, `0.2e12`, 0.2e12)
+	runDecoderTestUseNumber(t, `0.2e+12`, 0.2e+12)
+	runDecoderTestUseNumber(t, `0.2e-12`, 0.2e-12)
+	runDecoderTestUseNumber(t, `-0.2e12`, -0.2e12)
+	runDecoderTestUseNumber(t, `-0.2e+12`, -0.2e+12)
+	runDecoderTestUseNumber(t, `-0.2e-12`, -0.2e-12)
+	runDecoderTestUseNumber(t, `1.2e12`, 1.2e12)
+	runDecoderTestUseNumber(t, `1.2e+12`, 1.2e+12)
+	runDecoderTestUseNumber(t, `1.2e-12`, 1.2e-12)
+	runDecoderTestUseNumber(t, `-1.2e12`, -1.2e12)
+	runDecoderTestUseNumber(t, `-1.2e+12`, -1.2e+12)
+	runDecoderTestUseNumber(t, `-1.2e-12`, -1.2e-12)
+	runDecoderTestUseNumber(t, `-1.2E-12`, -1.2e-12)
+	runDecoderTestUseNumber(t, `["asd", "123", true, false, null, 2.4, 1.2e15, 1]`, []interface{}{"asd", "123", true, false, nil, 2.4, 1.2e15, float64(1)})
+	runDecoderTestUseNumber(t, `{"a": "123", "b": true, "c": false, "d": null, "e": 2.4, "f": 1.2e15, "g": 1}`, map[string]interface{}{"a": "123", "b": true, "c": false, "d": nil, "e": 2.4, "f": 1.2e15, "g": float64(1)})
 }
 
 func TestLoads(t *testing.T) {
-    _,i,e := Loads(`{"a": "123", "b": true, "c": false, "d": null, "e": 2.4, "f": 1.2e15, "g": 1}`)
-    if e != nil {
-        t.Fatal(e)
-    }
-    assert.Equal(t, map[string]interface{}{"a": "123", "b": true, "c": false, "d": nil, "e": 2.4, "f": 1.2e15, "g": float64(1)}, i)
-    _,i,e = LoadsUseNumber(`{"a": "123", "b": true, "c": false, "d": null, "e": 2.4, "f": 1.2e15, "g": 1}`)
-    if e != nil {
-        t.Fatal(e)
-    }
-    assert.Equal(t, map[string]interface{}{"a": "123", "b": true, "c": false, "d": nil, "e": json.Number("2.4"), "f": json.Number("1.2e15"), "g": json.Number("1")}, i)
+	_, i, e := Loads(`{"a": "123", "b": true, "c": false, "d": null, "e": 2.4, "f": 1.2e15, "g": 1}`)
+	if e != nil {
+		t.Fatal(e)
+	}
+	assert.Equal(t, map[string]interface{}{"a": "123", "b": true, "c": false, "d": nil, "e": 2.4, "f": 1.2e15, "g": float64(1)}, i)
+	_, i, e = LoadsUseNumber(`{"a": "123", "b": true, "c": false, "d": null, "e": 2.4, "f": 1.2e15, "g": 1}`)
+	if e != nil {
+		t.Fatal(e)
+	}
+	assert.Equal(t, map[string]interface{}{"a": "123", "b": true, "c": false, "d": nil, "e": json.Number("2.4"), "f": json.Number("1.2e15"), "g": json.Number("1")}, i)
 }
 
 func TestParsehNotExist(t *testing.T) {
-    s,err := NewParser(` { "xx" : [ 0, "" ] ,"yy" :{ "2": "" } } `).Parse()
-    if err != 0 {
-        t.Fatal(err)
-    }
-    node := s.GetByPath("xx", 2)
-    if node.Exists() {
-        t.Fatalf("node: %v", node)
-    }
-    node = s.GetByPath("xx", 1)
-    if !node.Exists() {
-        t.Fatalf("node: %v", nil)
-    }
-    node = s.GetByPath("yy", "3")
-    if node.Exists() {
-        t.Fatalf("node: %v", node)
-    }
-    node = s.GetByPath("yy", "2")
-    if !node.Exists() {
-        t.Fatalf("node: %v", nil)
-    }
+	s, err := NewParser(` { "xx" : [ 0, "" ] ,"yy" :{ "2": "" } } `).Parse()
+	if err != 0 {
+		t.Fatal(err)
+	}
+	node := s.GetByPath("xx", 2)
+	if node.Exists() {
+		t.Fatalf("node: %v", node)
+	}
+	node = s.GetByPath("xx", 1)
+	if !node.Exists() {
+		t.Fatalf("node: %v", nil)
+	}
+	node = s.GetByPath("yy", "3")
+	if node.Exists() {
+		t.Fatalf("node: %v", node)
+	}
+	node = s.GetByPath("yy", "2")
+	if !node.Exists() {
+		t.Fatalf("node: %v", nil)
+	}
 }
 
 func BenchmarkParser_Sonic(b *testing.B) {
-    r, err := NewParser(_TwitterJson).Parse()
-    if err != 0 {
-        b.Fatal(err)
-    }
-    if err := r.LoadAll(); err != nil {
-        b.Fatal(err)
-    }
-    b.SetBytes(int64(len(_TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        r, _ = NewParser(_TwitterJson).Parse()
-        _ = r.LoadAll()
-    }
+	r, err := NewParser(_TwitterJson).Parse()
+	if err != 0 {
+		b.Fatal(err)
+	}
+	if err := r.LoadAll(); err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(len(_TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		r, _ = NewParser(_TwitterJson).Parse()
+		_ = r.LoadAll()
+	}
 }
 
 func BenchmarkParser_Parallel_Sonic(b *testing.B) {
-    r, _ := NewParser(_TwitterJson).Parse()
-    if err := r.LoadAll(); err != nil {
-        b.Fatal(err)
-    }
-    b.SetBytes(int64(len(_TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            r, _ := NewParser(_TwitterJson).Parse()
-            _ = r.LoadAll()
-        }
-    })
+	r, _ := NewParser(_TwitterJson).Parse()
+	if err := r.LoadAll(); err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(len(_TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			r, _ := NewParser(_TwitterJson).Parse()
+			_ = r.LoadAll()
+		}
+	})
 }
 
 func BenchmarkParseEmpty_Sonic(b *testing.B) {
-    var emptySample = `{"a":[],"b":{},"c":[{},{},{},{}],"d":{"e":[],"f":[],"g":[],"h":[]}}`
-    p := NewParserObj(emptySample)
-    ast, _ := p.Parse()
-    require.NoError(b, ast.LoadAll())
-    b.SetBytes(int64(len(_TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        p := NewParserObj(emptySample)
-        ast, _ := p.Parse()
-        _ = ast.LoadAll()
-    }
+	var emptySample = `{"a":[],"b":{},"c":[{},{},{},{}],"d":{"e":[],"f":[],"g":[],"h":[]}}`
+	p := NewParserObj(emptySample)
+	ast, _ := p.Parse()
+	require.NoError(b, ast.LoadAll())
+	b.SetBytes(int64(len(_TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		p := NewParserObj(emptySample)
+		ast, _ := p.Parse()
+		_ = ast.LoadAll()
+	}
 }
 
 func BenchmarkParseOne_Sonic(b *testing.B) {
-    ast, _ := NewParser(_TwitterJson).Parse()
-    node, _ := ast.Get("statuses").Index(2).Get("id").Int64()
-    if node != 249289491129438208 {
-        b.Fail()
-    }
-    b.SetBytes(int64(len(_TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        ast, _ := NewParser(_TwitterJson).Parse()
-        _, _ = ast.Get("statuses").Index(2).Get("id").Int64()
-    }
+	ast, _ := NewParser(_TwitterJson).Parse()
+	node, _ := ast.Get("statuses").Index(2).Get("id").Int64()
+	if node != 249289491129438208 {
+		b.Fail()
+	}
+	b.SetBytes(int64(len(_TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ast, _ := NewParser(_TwitterJson).Parse()
+		_, _ = ast.Get("statuses").Index(2).Get("id").Int64()
+	}
 }
 
 func BenchmarkParseOne_Parallel_Sonic(b *testing.B) {
-    ast, _ := NewParser(_TwitterJson).Parse()
-    node, _ := ast.Get("statuses").Index(2).Get("id").Int64()
-    if node != 249289491129438208 {
-        b.Fail()
-    }
-    b.SetBytes(int64(len(_TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            ast, _ := NewParser(_TwitterJson).Parse()
-            _, _ = ast.Get("statuses").Index(2).Get("id").Int64()
-        }
-    })
+	ast, _ := NewParser(_TwitterJson).Parse()
+	node, _ := ast.Get("statuses").Index(2).Get("id").Int64()
+	if node != 249289491129438208 {
+		b.Fail()
+	}
+	b.SetBytes(int64(len(_TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			ast, _ := NewParser(_TwitterJson).Parse()
+			_, _ = ast.Get("statuses").Index(2).Get("id").Int64()
+		}
+	})
 }
 
 func BenchmarkParseSeven_Sonic(b *testing.B) {
-    b.SetBytes(int64(len(_TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        ast, _ := NewParser(_TwitterJson).Parse()
-        node := ast.GetByPath("statuses", 3, "id")
-        node = ast.GetByPath("statuses",  3, "user", "entities","description")
-        node = ast.GetByPath("statuses",  3, "user", "entities","url","urls")
-        node = ast.GetByPath("statuses",  3, "user", "entities","url")
-        node = ast.GetByPath("statuses",  3, "user", "created_at")
-        node = ast.GetByPath("statuses",  3, "user", "name")
-        node = ast.GetByPath("statuses",  3, "text")
-        if node.Check() != nil {
-            b.Fail()
-        }
-    }
+	b.SetBytes(int64(len(_TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		ast, _ := NewParser(_TwitterJson).Parse()
+		node := ast.GetByPath("statuses", 3, "id")
+		node = ast.GetByPath("statuses", 3, "user", "entities", "description")
+		node = ast.GetByPath("statuses", 3, "user", "entities", "url", "urls")
+		node = ast.GetByPath("statuses", 3, "user", "entities", "url")
+		node = ast.GetByPath("statuses", 3, "user", "created_at")
+		node = ast.GetByPath("statuses", 3, "user", "name")
+		node = ast.GetByPath("statuses", 3, "text")
+		if node.Check() != nil {
+			b.Fail()
+		}
+	}
 }
 
 func BenchmarkParseSeven_Parallel_Sonic(b *testing.B) {
-    b.SetBytes(int64(len(_TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            ast, _ := NewParser(_TwitterJson).Parse()
-            node := ast.GetByPath("statuses", 3, "id")
-            node = ast.GetByPath("statuses",  3, "user", "entities","description")
-            node = ast.GetByPath("statuses",  3, "user", "entities","url","urls")
-            node = ast.GetByPath("statuses",  3, "user", "entities","url")
-            node = ast.GetByPath("statuses",  3, "user", "created_at")
-            node = ast.GetByPath("statuses",  3, "user", "name")
-            node = ast.GetByPath("statuses",  3, "text")
-            if node.Check() != nil {
-                b.Fail()
-            }
-        }
-    })
-}
\ No newline at end of file
+	b.SetBytes(int64(len(_TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			ast, _ := NewParser(_TwitterJson).Parse()
+			node := ast.GetByPath("statuses", 3, "id")
+			node = ast.GetByPath("statuses", 3, "user", "entities", "description")
+			node = ast.GetByPath("statuses", 3, "user", "entities", "url", "urls")
+			node = ast.GetByPath("statuses", 3, "user", "entities", "url")
+			node = ast.GetByPath("statuses", 3, "user", "created_at")
+			node = ast.GetByPath("statuses", 3, "user", "name")
+			node = ast.GetByPath("statuses", 3, "text")
+			if node.Check() != nil {
+				b.Fail()
+			}
+		}
+	})
+}
diff --git a/ast/search_test.go b/ast/search_test.go
index 2721176b3..6cbacc500 100644
--- a/ast/search_test.go
+++ b/ast/search_test.go
@@ -17,395 +17,395 @@
 package ast
 
 import (
-    `math`
-    `runtime`
-    `strconv`
-    `strings`
-    `sync`
-    `testing`
-
-    `github.com/stretchr/testify/assert`
+	"math"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
-
 func TestGC_Search(t *testing.T) {
-    if debugSyncGC {
-        return
-    }
-    _, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0, "id")
-    if err != nil {
-        t.Fatal(err)
-    }
-    wg := &sync.WaitGroup{}
-    // A limitation of the race detecting is 8128.
-    // See https://github.com/golang/go/issues/43898
-    N := 5000
-    for i:=0; i<N; i++ {
-        wg.Add(1)
-        go func (wg *sync.WaitGroup)  {
-            defer wg.Done()
-            _, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0, "id")
-            if err != nil {
-                t.Fatal(err)
-            }
-            runtime.GC()
-        }(wg)
-    }
-    wg.Wait()
+	if debugSyncGC {
+		return
+	}
+	_, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0, "id")
+	if err != nil {
+		t.Fatal(err)
+	}
+	wg := &sync.WaitGroup{}
+	// A limitation of the race detecting is 8128.
+	// See https://github.com/golang/go/issues/43898
+	N := 5000
+	for i := 0; i < N; i++ {
+		wg.Add(1)
+		go func(wg *sync.WaitGroup) {
+			defer wg.Done()
+			_, err := NewSearcher(_TwitterJson).GetByPath("statuses", 0, "id")
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			runtime.GC()
+		}(wg)
+	}
+	wg.Wait()
 }
 
 func TestExportErrorInvalidChar(t *testing.T) {
-    data := `{"a":]`
-    p := NewSearcher(data)
-    _, err := p.GetByPath("a")
-    if err == nil {
-        t.Fatal()
-    }
-    if strings.Index(err.Error(), `"Syntax error at `) != 0 {
-        t.Fatal(err)
-    }
-
-    data = `:"b"]`
-    p = NewSearcher(data)
-    _, err = p.GetByPath("a")
-    if err == nil {
-        t.Fatal()
-    }
-    if err.Error() != `"Syntax error at index 0: invalid char\n\n\t:\"b\"]\n\t^....\n"` {
-        t.Fatal(err)
-    }
-
-    data = `{:"b"]`
-    p = NewSearcher(data)
-    _, err = p.GetByPath("a")
-    if err == nil {
-        t.Fatal()
-    }
-    if err.Error() != `"Syntax error at index 1: invalid char\n\n\t{:\"b\"]\n\t.^....\n"` {
-        t.Fatal(err)
-    }
-
-    data = `{`
-    p = NewSearcher(data)
-    _, err = p.GetByPath("he")
-    if err == nil {
-        t.Fatal()
-    }
-    if err == ErrNotExist {
-        t.Fatal(err)
-    }
-
-    data = `[`
-    p = NewSearcher(data)
-    _, err = p.GetByPath(0)
-    if err == nil {
-        t.Fatal()
-    }
-    if err == ErrNotExist {
-        t.Fatal(err)
-    }
+	data := `{"a":]`
+	p := NewSearcher(data)
+	_, err := p.GetByPath("a")
+	if err == nil {
+		t.Fatal()
+	}
+	if strings.Index(err.Error(), `"Syntax error at `) != 0 {
+		t.Fatal(err)
+	}
+
+	data = `:"b"]`
+	p = NewSearcher(data)
+	_, err = p.GetByPath("a")
+	if err == nil {
+		t.Fatal()
+	}
+	if err.Error() != `"Syntax error at index 0: invalid char\n\n\t:\"b\"]\n\t^....\n"` {
+		t.Fatal(err)
+	}
+
+	data = `{:"b"]`
+	p = NewSearcher(data)
+	_, err = p.GetByPath("a")
+	if err == nil {
+		t.Fatal()
+	}
+	if err.Error() != `"Syntax error at index 1: invalid char\n\n\t{:\"b\"]\n\t.^....\n"` {
+		t.Fatal(err)
+	}
+
+	data = `{`
+	p = NewSearcher(data)
+	_, err = p.GetByPath("he")
+	if err == nil {
+		t.Fatal()
+	}
+	if err == ErrNotExist {
+		t.Fatal(err)
+	}
+
+	data = `[`
+	p = NewSearcher(data)
+	_, err = p.GetByPath(0)
+	if err == nil {
+		t.Fatal()
+	}
+	if err == ErrNotExist {
+		t.Fatal(err)
+	}
 }
 
 type testExportError struct {
-    data string
-    path []interface{}
-    err  error
+	data string
+	path []interface{}
+	err  error
 }
 
-func TestExportErrNotExist(t *testing.T)  {
-    tests := []testExportError{
-        // object
-        {`{}`, []interface{}{"b"}, ErrNotExist},
-        {` {  } `, []interface{}{"b"}, ErrNotExist},
-        {`{"a":null}`, []interface{}{"b"}, ErrNotExist},
-        // This should be invalid char errors.
-        // {`{"a":null}`, []interface{}{"a", "b"}, ErrNotExist},
-        // {`{"a":null}`, []interface{}{"a", 0}, ErrNotExist},
-        // {`{"a":null}`, []interface{}{"a", "b", 0}, ErrNotExist},
-        {`{"":{"b":123}}`, []interface{}{"b"}, ErrNotExist},
-        {`{"":{"b":123}}`, []interface{}{"", ""}, ErrNotExist},
-        {`{"a":{"b":123}}`, []interface{}{"b"}, ErrNotExist},
-        {`{"a":{"b":123}}`, []interface{}{"a", "c"}, ErrNotExist},
-        {`{"a":{"c": null, "b":{}}}`, []interface{}{"a", "b", "c"}, ErrNotExist},
-        {`{"a":{"b":123}}`, []interface{}{"b", "b"}, ErrNotExist},
-        {`{"\"\\":{"b":123}}`, []interface{}{"\"", "b"}, ErrNotExist},
-        {`{"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"\\":{"b":123}}`, 
-            []interface{}{"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"", "b"}, ErrNotExist},
-
-        // array
-        {`[]`, []interface{}{0}, ErrNotExist},
-        {`[]`, []interface{}{1}, ErrNotExist},
-        {` [ ] `, []interface{}{0}, ErrNotExist},
-        {`[null]`, []interface{}{1}, ErrNotExist},
-        {`[null, ["null", 123]]`, []interface{}{2}, ErrNotExist},
-        {`[null, true , false, 14, 2.35, -46, "hello7", "\"8"]`, []interface{}{8}, ErrNotExist},
-        {`[{}]`, []interface{}{1}, ErrNotExist},
-        {`[[]]`, []interface{}{1}, ErrNotExist},
-        {`[[],[{},{}, []],{}]`, []interface{}{3}, ErrNotExist},
-    }
-    
-    for _, test := range tests {
-        f := func(t *testing.T) {
-            p := NewSearcher(test.data)
-            node, err := p.GetByPath(test.path...)
-            if err !=  test.err || node.Exists(){
-                t.Fatal(err)
-            }
-        }
-        t.Run(test.data, f)
-    }
+func TestExportErrNotExist(t *testing.T) {
+	tests := []testExportError{
+		// object
+		{`{}`, []interface{}{"b"}, ErrNotExist},
+		{` {  } `, []interface{}{"b"}, ErrNotExist},
+		{`{"a":null}`, []interface{}{"b"}, ErrNotExist},
+		// This should be invalid char errors.
+		// {`{"a":null}`, []interface{}{"a", "b"}, ErrNotExist},
+		// {`{"a":null}`, []interface{}{"a", 0}, ErrNotExist},
+		// {`{"a":null}`, []interface{}{"a", "b", 0}, ErrNotExist},
+		{`{"":{"b":123}}`, []interface{}{"b"}, ErrNotExist},
+		{`{"":{"b":123}}`, []interface{}{"", ""}, ErrNotExist},
+		{`{"a":{"b":123}}`, []interface{}{"b"}, ErrNotExist},
+		{`{"a":{"b":123}}`, []interface{}{"a", "c"}, ErrNotExist},
+		{`{"a":{"c": null, "b":{}}}`, []interface{}{"a", "b", "c"}, ErrNotExist},
+		{`{"a":{"b":123}}`, []interface{}{"b", "b"}, ErrNotExist},
+		{`{"\"\\":{"b":123}}`, []interface{}{"\"", "b"}, ErrNotExist},
+		{`{"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"\\":{"b":123}}`,
+			[]interface{}{"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\"", "b"}, ErrNotExist},
+
+		// array
+		{`[]`, []interface{}{0}, ErrNotExist},
+		{`[]`, []interface{}{1}, ErrNotExist},
+		{` [ ] `, []interface{}{0}, ErrNotExist},
+		{`[null]`, []interface{}{1}, ErrNotExist},
+		{`[null, ["null", 123]]`, []interface{}{2}, ErrNotExist},
+		{`[null, true , false, 14, 2.35, -46, "hello7", "\"8"]`, []interface{}{8}, ErrNotExist},
+		{`[{}]`, []interface{}{1}, ErrNotExist},
+		{`[[]]`, []interface{}{1}, ErrNotExist},
+		{`[[],[{},{}, []],{}]`, []interface{}{3}, ErrNotExist},
+	}
+
+	for _, test := range tests {
+		f := func(t *testing.T) {
+			p := NewSearcher(test.data)
+			node, err := p.GetByPath(test.path...)
+			if err != test.err || node.Exists() {
+				t.Fatal(err)
+			}
+		}
+		t.Run(test.data, f)
+	}
 }
 
 func TestSearcher_GetByPath(t *testing.T) {
-    s := NewSearcher(` { "xx" : [] ,"yy" :{ }, "test" : [ true , 0.1 , "abc", ["h"], {"a":"bc"} ] } `)
-
-    node, e := s.GetByPath("test", 0)
-    a, _ := node.Bool()
-    if e != nil || a != true {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-
-    node, e = s.GetByPath("test", 1)
-    b, _ := node.Float64()
-    if e != nil || b != 0.1 {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-
-    node, e = s.GetByPath("test", 2)
-    c, _ := node.String()
-    if e != nil || c != "abc" {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-
-    node, e = s.GetByPath("test", 3)
-    arr, _ := node.Array()
-    if e != nil || arr[0] != "h" {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-
-    node, e = s.GetByPath("test", 4, "a")
-    d, _ := node.String()
-    if e != nil || d != "bc" {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
+	s := NewSearcher(` { "xx" : [] ,"yy" :{ }, "test" : [ true , 0.1 , "abc", ["h"], {"a":"bc"} ] } `)
+
+	node, e := s.GetByPath("test", 0)
+	a, _ := node.Bool()
+	if e != nil || a != true {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+
+	node, e = s.GetByPath("test", 1)
+	b, _ := node.Float64()
+	if e != nil || b != 0.1 {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+
+	node, e = s.GetByPath("test", 2)
+	c, _ := node.String()
+	if e != nil || c != "abc" {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+
+	node, e = s.GetByPath("test", 3)
+	arr, _ := node.Array()
+	if e != nil || arr[0] != "h" {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+
+	node, e = s.GetByPath("test", 4, "a")
+	d, _ := node.String()
+	if e != nil || d != "bc" {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
 }
 
 type testGetByPath struct {
-    json  string
-    path  []interface{}
-    value interface{}
-    ok    bool
+	json  string
+	path  []interface{}
+	value interface{}
+	ok    bool
 }
 
 func TestSearcher_GetByPathSingle(t *testing.T) {
-    type Path   = []interface{}
-    const Ok    = true
-    const Error = false
-    tests := []testGetByPath{
-        {`true`, Path{}, true, Ok},
-        {`false`, Path{}, false, Ok},
-        {`null`, Path{}, nil, Ok},
-        {`12345`, Path{}, 12345.0, Ok},
-        {`12345.6789`, Path{}, 12345.6789, Ok},
-        {`"abc"`, Path{}, "abc", Ok},
-        {`"a\"\\bc"`, Path{}, "a\"\\bc", Ok},
-        {`{"a":1}`, Path{"a"}, 1.0, Ok},
-        {`{"":1}`, Path{""}, 1.0, Ok},
-        {`{"":{"":1}}`, Path{"", ""}, 1.0, Ok},
-        {`[1,2,3]`, Path{0}, 1.0, Ok},
-        {`[1,2,3]`, Path{1}, 2.0, Ok},
-        {`[1,2,3]`, Path{2}, 3.0, Ok},
-
-        {`tru`, Path{}, nil, Error},
-        {`fal`, Path{}, nil, Error},
-        {`nul`, Path{}, nil, Error},
-        {`{"a":1`, Path{}, nil, Error},
-        {`x12345.6789`, Path{}, nil, Error},
-        {`"abc`, Path{}, nil, Error},
-        {`"a\"\\bc`, Path{}, nil, Error},
-        {`"a\"\`, Path{}, nil, Error},
-        {`{"a":`, Path{"a"}, nil, Error},
-        {`[1,2,3]`, Path{4}, nil, Error},
-        {`[1,2,3]`, Path{"a"}, nil, Error},
-    }
-    for _, test := range tests {
-        t.Run(test.json, func(t *testing.T) {
-            s := NewSearcher(test.json)
-            node, err1  := s.GetByPath(test.path...)
-            assert.Equal(t, test.ok, err1 == nil)
-
-            value, err2 := node.Interface()
-            assert.Equal(t, test.value, value)
-            assert.Equal(t, test.ok, err2 == nil)
-        })
-    }
+	type Path = []interface{}
+	const Ok = true
+	const Error = false
+	tests := []testGetByPath{
+		{`true`, Path{}, true, Ok},
+		{`false`, Path{}, false, Ok},
+		{`null`, Path{}, nil, Ok},
+		{`12345`, Path{}, 12345.0, Ok},
+		{`12345.6789`, Path{}, 12345.6789, Ok},
+		{`"abc"`, Path{}, "abc", Ok},
+		{`"a\"\\bc"`, Path{}, "a\"\\bc", Ok},
+		{`{"a":1}`, Path{"a"}, 1.0, Ok},
+		{`{"":1}`, Path{""}, 1.0, Ok},
+		{`{"":{"":1}}`, Path{"", ""}, 1.0, Ok},
+		{`[1,2,3]`, Path{0}, 1.0, Ok},
+		{`[1,2,3]`, Path{1}, 2.0, Ok},
+		{`[1,2,3]`, Path{2}, 3.0, Ok},
+
+		{`tru`, Path{}, nil, Error},
+		{`fal`, Path{}, nil, Error},
+		{`nul`, Path{}, nil, Error},
+		{`{"a":1`, Path{}, nil, Error},
+		{`x12345.6789`, Path{}, nil, Error},
+		{`"abc`, Path{}, nil, Error},
+		{`"a\"\\bc`, Path{}, nil, Error},
+		{`"a\"\`, Path{}, nil, Error},
+		{`{"a":`, Path{"a"}, nil, Error},
+		{`[1,2,3]`, Path{4}, nil, Error},
+		{`[1,2,3]`, Path{"a"}, nil, Error},
+	}
+	for _, test := range tests {
+		t.Run(test.json, func(t *testing.T) {
+			s := NewSearcher(test.json)
+			node, err1 := s.GetByPath(test.path...)
+			assert.Equal(t, test.ok, err1 == nil)
+
+			value, err2 := node.Interface()
+			assert.Equal(t, test.value, value)
+			assert.Equal(t, test.ok, err2 == nil)
+		})
+	}
 }
 
 func TestSearcher_GetByPathErr(t *testing.T) {
-    s := NewSearcher(` { "xx" : [] ,"yy" :{ }, "test" : [ true , 0.1 , "abc", ["h"], {"a":"bc"} ], "err1":[a, ] , "err2":{ ,"x":"xx"} } `)
-    node, e := s.GetByPath("zz")
-    if e == nil {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-    s.parser.p = 0
-    node, e = s.GetByPath("xx", 4)
-    if e == nil {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-    s.parser.p = 0
-    node, e = s.GetByPath("yy", "a")
-    if e == nil {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-    s.parser.p = 0
-    node, e = s.GetByPath("test", 2, "x")
-    if e == nil {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-    s.parser.p = 0
-    node, e = s.GetByPath("err1", 0)
-    if e == nil {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-    s.parser.p = 0
-    node, e = s.GetByPath("err2", "x")
-    if e == nil {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
+	s := NewSearcher(` { "xx" : [] ,"yy" :{ }, "test" : [ true , 0.1 , "abc", ["h"], {"a":"bc"} ], "err1":[a, ] , "err2":{ ,"x":"xx"} } `)
+	node, e := s.GetByPath("zz")
+	if e == nil {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+	s.parser.p = 0
+	node, e = s.GetByPath("xx", 4)
+	if e == nil {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+	s.parser.p = 0
+	node, e = s.GetByPath("yy", "a")
+	if e == nil {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+	s.parser.p = 0
+	node, e = s.GetByPath("test", 2, "x")
+	if e == nil {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+	s.parser.p = 0
+	node, e = s.GetByPath("err1", 0)
+	if e == nil {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+	s.parser.p = 0
+	node, e = s.GetByPath("err2", "x")
+	if e == nil {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
 }
 
 func TestLoadIndex(t *testing.T) {
-    node, err := NewSearcher(`{"a":[-0, 1, -1.2, -1.2e-10]}`).GetByPath("a")
-    if err != nil {
-        t.Fatal(err)
-    }
-    a, _ := node.Index(3).Float64()
-    assert.Equal(t, -1.2e-10, a)
-    m, _ := node.Array()
-    assert.Equal(t, m, []interface{}{
-        float64(0),    
-        float64(1),
-        -1.2,
-        -1.2e-10,
-    })
+	node, err := NewSearcher(`{"a":[-0, 1, -1.2, -1.2e-10]}`).GetByPath("a")
+	if err != nil {
+		t.Fatal(err)
+	}
+	a, _ := node.Index(3).Float64()
+	assert.Equal(t, -1.2e-10, a)
+	m, _ := node.Array()
+	assert.Equal(t, m, []interface{}{
+		float64(0),
+		float64(1),
+		-1.2,
+		-1.2e-10,
+	})
 }
 
 func TestSearchNotExist(t *testing.T) {
-    s := NewSearcher(` { "xx" : [ 0, "" ] ,"yy" :{ "2": "" } } `)
-    node, e := s.GetByPath("xx", 2)
-    if node.Exists() {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-    node, e = s.GetByPath("xx", 1)
-    if e != nil || !node.Exists() {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-    node, e = s.GetByPath("yy", "3")
-    if node.Exists() {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
-    node, e = s.GetByPath("yy", "2")
-    if e != nil || !node.Exists() {
-        t.Fatalf("node: %v, err: %v", node, e)
-    }
+	s := NewSearcher(` { "xx" : [ 0, "" ] ,"yy" :{ "2": "" } } `)
+	node, e := s.GetByPath("xx", 2)
+	if node.Exists() {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+	node, e = s.GetByPath("xx", 1)
+	if e != nil || !node.Exists() {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+	node, e = s.GetByPath("yy", "3")
+	if node.Exists() {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
+	node, e = s.GetByPath("yy", "2")
+	if e != nil || !node.Exists() {
+		t.Fatalf("node: %v, err: %v", node, e)
+	}
 }
 
 func BenchmarkGetOne_Sonic(b *testing.B) {
-    b.SetBytes(int64(len(_TwitterJson)))
-    ast := NewSearcher(_TwitterJson)
-    for i := 0; i < b.N; i++ {
-        node, err := ast.GetByPath("statuses", 3, "id")
-        if err != nil {
-            b.Fatal(err)
-        }
-        x, _ := node.Int64()
-        if x != 249279667666817024 {
-            b.Fatal(node.Interface())
-        }
-    }
+	b.SetBytes(int64(len(_TwitterJson)))
+	ast := NewSearcher(_TwitterJson)
+	for i := 0; i < b.N; i++ {
+		node, err := ast.GetByPath("statuses", 3, "id")
+		if err != nil {
+			b.Fatal(err)
+		}
+		x, _ := node.Int64()
+		if x != 249279667666817024 {
+			b.Fatal(node.Interface())
+		}
+	}
 }
 
 func BenchmarkGetFull_Sonic(b *testing.B) {
-    ast := NewSearcher(_TwitterJson)
-    b.SetBytes(int64(len(_TwitterJson)))
-    b.ReportAllocs()
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        node, err := ast.GetByPath()
-        if err != nil || node.Type() != V_OBJECT {
-            b.Fatal(err)
-        }
-    }
+	ast := NewSearcher(_TwitterJson)
+	b.SetBytes(int64(len(_TwitterJson)))
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		node, err := ast.GetByPath()
+		if err != nil || node.Type() != V_OBJECT {
+			b.Fatal(err)
+		}
+	}
 }
 
 func BenchmarkGetWithManyCompare_Sonic(b *testing.B) {
-    b.SetBytes(int64(len(_LotsCompare)))
-    ast := NewSearcher(_LotsCompare)
-    for i := 0; i < b.N; i++ {
-        node, err := ast.GetByPath("is")
-        if err != nil {
-            b.Fatal(err)
-        }
-        x, _ := node.Int64()
-        if x != 1 {
-            b.Fatal(node.Interface())
-        }
-    }
+	b.SetBytes(int64(len(_LotsCompare)))
+	ast := NewSearcher(_LotsCompare)
+	for i := 0; i < b.N; i++ {
+		node, err := ast.GetByPath("is")
+		if err != nil {
+			b.Fatal(err)
+		}
+		x, _ := node.Int64()
+		if x != 1 {
+			b.Fatal(node.Interface())
+		}
+	}
 }
 
 func BenchmarkGetOne_Parallel_Sonic(b *testing.B) {
-    b.SetBytes(int64(len(_TwitterJson)))
-    b.RunParallel(func(pb *testing.PB) {
-        ast := NewSearcher(_TwitterJson)
-        for pb.Next() {
-            node, err := ast.GetByPath("statuses", 3, "id")
-            if err != nil {
-                b.Fatal(err)
-            }
-            x, _ := node.Int64()
-            if x != 249279667666817024 {
-                b.Fatal(node.Interface())
-            }
-        }
-    })
+	b.SetBytes(int64(len(_TwitterJson)))
+	b.RunParallel(func(pb *testing.PB) {
+		ast := NewSearcher(_TwitterJson)
+		for pb.Next() {
+			node, err := ast.GetByPath("statuses", 3, "id")
+			if err != nil {
+				b.Fatal(err)
+			}
+			x, _ := node.Int64()
+			if x != 249279667666817024 {
+				b.Fatal(node.Interface())
+			}
+		}
+	})
 }
 
 func BenchmarkSetOne_Sonic(b *testing.B) {
-    node, err := NewSearcher(_TwitterJson).GetByPath("statuses", 3)
-    if err != nil {
-        b.Fatal(err)
-    }
-    n := NewNumber(strconv.Itoa(math.MaxInt32))
-    _, err = node.Set("id", n)
-    if err != nil {
-        b.Fatal(err)
-    }
-    b.SetBytes(int64(len(_TwitterJson)))
-    b.ReportAllocs()
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        node, _ := NewSearcher(_TwitterJson).GetByPath("statuses", 3)
-        _, _ = node.Set("id", n)
-    }
+	node, err := NewSearcher(_TwitterJson).GetByPath("statuses", 3)
+	if err != nil {
+		b.Fatal(err)
+	}
+	n := NewNumber(strconv.Itoa(math.MaxInt32))
+	_, err = node.Set("id", n)
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(len(_TwitterJson)))
+	b.ReportAllocs()
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		node, _ := NewSearcher(_TwitterJson).GetByPath("statuses", 3)
+		_, _ = node.Set("id", n)
+	}
 }
 
 func BenchmarkSetOne_Parallel_Sonic(b *testing.B) {
-    node, err := NewSearcher(_TwitterJson).GetByPath("statuses", 3)
-    if err != nil {
-        b.Fatal(err)
-    }
-    n := NewNumber(strconv.Itoa(math.MaxInt32))
-    _, err = node.Set("id", n)
-    if err != nil {
-        b.Fatal(err)
-    }
-    b.SetBytes(int64(len(_TwitterJson)))
-    b.ReportAllocs()
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            node, _ := NewSearcher(_TwitterJson).GetByPath("statuses", 3)
-            _, _ = node.Set("id", n)
-        }
-    })
-}
\ No newline at end of file
+	node, err := NewSearcher(_TwitterJson).GetByPath("statuses", 3)
+	if err != nil {
+		b.Fatal(err)
+	}
+	n := NewNumber(strconv.Itoa(math.MaxInt32))
+	_, err = node.Set("id", n)
+	if err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(len(_TwitterJson)))
+	b.ReportAllocs()
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			node, _ := NewSearcher(_TwitterJson).GetByPath("statuses", 3)
+			_, _ = node.Set("id", n)
+		}
+	})
+}
diff --git a/decoder/decoder_test.go b/decoder/decoder_test.go
index 65a333b0a..4eece8d27 100644
--- a/decoder/decoder_test.go
+++ b/decoder/decoder_test.go
@@ -17,399 +17,397 @@
 package decoder
 
 import (
-    `encoding/json`
-    `runtime`
-    `runtime/debug`
-    `strings`
-    `sync`
-    `testing`
-    `time`
-
-    `github.com/davecgh/go-spew/spew`
-    `github.com/stretchr/testify/assert`
-    `github.com/stretchr/testify/require`
+	"encoding/json"
+	"runtime"
+	"runtime/debug"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/davecgh/go-spew/spew"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMain(m *testing.M) {
-    go func ()  {
-        if !debugAsyncGC {
-            return
-        }
-        println("Begin GC looping...")
-        for {
-           runtime.GC()
-           debug.FreeOSMemory() 
-        }
-        println("stop GC looping!")
-    }()
-    time.Sleep(time.Millisecond)
-    m.Run()
+	go func() {
+		if !debugAsyncGC {
+			return
+		}
+		println("Begin GC looping...")
+		for {
+			runtime.GC()
+			debug.FreeOSMemory()
+		}
+		println("stop GC looping!")
+	}()
+	time.Sleep(time.Millisecond)
+	m.Run()
 }
 
 func TestGC(t *testing.T) {
-    if debugSyncGC {
-        return 
-    }
-    var w interface{}
-    out, err := decode(TwitterJson, &w, true)
-    if err != nil {
-        t.Fatal(err)
-    }
-    if out != len(TwitterJson) {
-        t.Fatal(out)
-    }
-    wg := &sync.WaitGroup{}
-    N := 10000
-    for i:=0; i<N; i++ {
-        wg.Add(1)
-        go func (wg *sync.WaitGroup)  {
-            defer wg.Done()
-            var w interface{}
-            out, err := decode(TwitterJson, &w, true)
-            if err != nil {
-                t.Fatal(err)
-            }
-            if out != len(TwitterJson) {
-                t.Fatal(out)
-            }
-            runtime.GC()
-        }(wg)
-    }
-    wg.Wait()
+	if debugSyncGC {
+		return
+	}
+	var w interface{}
+	out, err := decode(TwitterJson, &w, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if out != len(TwitterJson) {
+		t.Fatal(out)
+	}
+	wg := &sync.WaitGroup{}
+	N := 10000
+	for i := 0; i < N; i++ {
+		wg.Add(1)
+		go func(wg *sync.WaitGroup) {
+			defer wg.Done()
+			var w interface{}
+			out, err := decode(TwitterJson, &w, true)
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			if out != len(TwitterJson) {
+				t.Error(out)
+				return
+			}
+			runtime.GC()
+		}(wg)
+	}
+	wg.Wait()
 }
 
 var _BindingValue TwitterStruct
 
 func init() {
-    _ = json.Unmarshal([]byte(TwitterJson), &_BindingValue)
+	_ = json.Unmarshal([]byte(TwitterJson), &_BindingValue)
 }
 
-
 func TestSkipMismatchTypeError(t *testing.T) {
-    t.Run("struct", func(t *testing.T) {
-        println("TestSkipError")
-        type skiptype struct {
-            A int `json:"a"`
-            B string `json:"b"`
-
-            Pass *int `json:"pass"`
-
-            C struct{
-
-                Pass4 interface{} `json:"pass4"`
-
-                D struct{
-                    E float32 `json:"e"`
-                } `json:"d"`
-
-                Pass2 int `json:"pass2"`
-
-            } `json:"c"`
-
-            E bool `json:"e"`
-            F []int `json:"f"`
-            G map[string]int `json:"g"`
-            H bool `json:"h,string"`
-
-            Pass3 int `json:"pass2"`
-
-            I json.Number `json:"i"`
-        }
-        var obj, obj2 = &skiptype{Pass:new(int)}, &skiptype{Pass:new(int)}
-        var data = `{"a":"","b":1,"c":{"d":true,"pass2":1,"pass4":true},"e":{},"f":"","g":[],"pass":null,"h":"1.0","i":true,"pass3":1}`
-        d := NewDecoder(data)
-        err := d.Decode(obj)
-        err2 := json.Unmarshal([]byte(data), obj2)
-        println(err2.Error())
-        assert.Equal(t, err2 == nil, err == nil)
-        // assert.Equal(t, len(data), d.i)
-        assert.Equal(t, obj2, obj)
-        if err == nil {
-            t.Fatal("invalid error")
-        }
-    })
-    t.Run("short array", func(t *testing.T) {
-        var obj, obj2 = &[]int{}, &[]int{}
-        var data = `[""]`
-        d := NewDecoder(data)
-        err := d.Decode(obj)
-        err2 := json.Unmarshal([]byte(data), obj2)
-        // println(err2.Error())
-        assert.Equal(t, err2 == nil, err == nil)
-        // assert.Equal(t, len(data), d.i)
-        assert.Equal(t, obj2, obj)
-    })
-
-    t.Run("int ", func(t *testing.T) {
-        var obj int = 123
-        var obj2 int = 123
-        var data = `[""]`
-        d := NewDecoder(data)
-        err := d.Decode(&obj)
-        err2 := json.Unmarshal([]byte(data), &obj2)
-        println(err.Error(), obj, obj2)
-        assert.Equal(t, err2 == nil, err == nil)
-        // assert.Equal(t, len(data), d.i)
-        assert.Equal(t, obj2, obj)
-    })
-
-    t.Run("array", func(t *testing.T) {
-        var obj, obj2 = &[]int{}, &[]int{}
-        var data = `["",true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true]`
-        d := NewDecoder(data)
-        err := d.Decode(obj)
-        err2 := json.Unmarshal([]byte(data), obj2)
-        // println(err2.Error())
-        assert.Equal(t, err2 == nil, err == nil)
-        // assert.Equal(t, len(data), d.i)
-        assert.Equal(t, obj2, obj)
-    })
-
-    t.Run("map", func(t *testing.T) {
-        var obj, obj2 = &map[int]int{}, &map[int]int{}
-        var data = `{"true" : { },"1":1,"2" : true,"3":3}`
-        d := NewDecoder(data)
-        err := d.Decode(obj)
-        err2 := json.Unmarshal([]byte(data), obj2)
-        assert.Equal(t, err2 == nil, err == nil)
-        // assert.Equal(t, len(data), d.i)
-        assert.Equal(t, obj2, obj)
-    })
-    t.Run("map error", func(t *testing.T) {
-        var obj, obj2 = &map[int]int{}, &map[int]int{}
-        var data = `{"true" : { ],"1":1,"2" : true,"3":3}`
-        d := NewDecoder(data)
-        err := d.Decode(obj)
-        err2 := json.Unmarshal([]byte(data), obj2)
-        println(err.Error())
-        println(err2.Error())
-        assert.Equal(t, err2 == nil, err == nil)
-        // assert.Equal(t, len(data), d.i)
-        // assert.Equal(t, obj2, obj)
-    })
+	t.Run("struct", func(t *testing.T) {
+		println("TestSkipError")
+		type skiptype struct {
+			A int    `json:"a"`
+			B string `json:"b"`
+
+			Pass *int `json:"pass"`
+
+			C struct {
+				Pass4 interface{} `json:"pass4"`
+
+				D struct {
+					E float32 `json:"e"`
+				} `json:"d"`
+
+				Pass2 int `json:"pass2"`
+			} `json:"c"`
+
+			E bool           `json:"e"`
+			F []int          `json:"f"`
+			G map[string]int `json:"g"`
+			H bool           `json:"h,string"`
+
+			Pass3 int `json:"pass2"`
+
+			I json.Number `json:"i"`
+		}
+		var obj, obj2 = &skiptype{Pass: new(int)}, &skiptype{Pass: new(int)}
+		var data = `{"a":"","b":1,"c":{"d":true,"pass2":1,"pass4":true},"e":{},"f":"","g":[],"pass":null,"h":"1.0","i":true,"pass3":1}`
+		d := NewDecoder(data)
+		err := d.Decode(obj)
+		err2 := json.Unmarshal([]byte(data), obj2)
+		println(err2.Error())
+		assert.Equal(t, err2 == nil, err == nil)
+		// assert.Equal(t, len(data), d.i)
+		assert.Equal(t, obj2, obj)
+		if err == nil {
+			t.Fatal("invalid error")
+		}
+	})
+	t.Run("short array", func(t *testing.T) {
+		var obj, obj2 = &[]int{}, &[]int{}
+		var data = `[""]`
+		d := NewDecoder(data)
+		err := d.Decode(obj)
+		err2 := json.Unmarshal([]byte(data), obj2)
+		// println(err2.Error())
+		assert.Equal(t, err2 == nil, err == nil)
+		// assert.Equal(t, len(data), d.i)
+		assert.Equal(t, obj2, obj)
+	})
+
+	t.Run("int ", func(t *testing.T) {
+		var obj int = 123
+		var obj2 int = 123
+		var data = `[""]`
+		d := NewDecoder(data)
+		err := d.Decode(&obj)
+		err2 := json.Unmarshal([]byte(data), &obj2)
+		println(err.Error(), obj, obj2)
+		assert.Equal(t, err2 == nil, err == nil)
+		// assert.Equal(t, len(data), d.i)
+		assert.Equal(t, obj2, obj)
+	})
+
+	t.Run("array", func(t *testing.T) {
+		var obj, obj2 = &[]int{}, &[]int{}
+		var data = `["",true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true,true]`
+		d := NewDecoder(data)
+		err := d.Decode(obj)
+		err2 := json.Unmarshal([]byte(data), obj2)
+		// println(err2.Error())
+		assert.Equal(t, err2 == nil, err == nil)
+		// assert.Equal(t, len(data), d.i)
+		assert.Equal(t, obj2, obj)
+	})
+
+	t.Run("map", func(t *testing.T) {
+		var obj, obj2 = &map[int]int{}, &map[int]int{}
+		var data = `{"true" : { },"1":1,"2" : true,"3":3}`
+		d := NewDecoder(data)
+		err := d.Decode(obj)
+		err2 := json.Unmarshal([]byte(data), obj2)
+		assert.Equal(t, err2 == nil, err == nil)
+		// assert.Equal(t, len(data), d.i)
+		assert.Equal(t, obj2, obj)
+	})
+	t.Run("map error", func(t *testing.T) {
+		var obj, obj2 = &map[int]int{}, &map[int]int{}
+		var data = `{"true" : { ],"1":1,"2" : true,"3":3}`
+		d := NewDecoder(data)
+		err := d.Decode(obj)
+		err2 := json.Unmarshal([]byte(data), obj2)
+		println(err.Error())
+		println(err2.Error())
+		assert.Equal(t, err2 == nil, err == nil)
+		// assert.Equal(t, len(data), d.i)
+		// assert.Equal(t, obj2, obj)
+	})
 }
 
 func TestDecodeCorrupt(t *testing.T) {
-    var ds = []string{
-        `{,}`,
-        `{,"a"}`,
-        `{"a":}`,
-        `{"a":1,}`,
-        `{"a":1,"b"}`,
-        `{"a":1,"b":}`,
-        `{,"a":1 "b":2}`,
-        `{"a",:1 "b":2}`,
-        `{"a":,1 "b":2}`,
-        `{"a":1 "b",:2}`,
-        `{"a":1 "b":,2}`,
-        `{"a":1 "b":2,}`,
-        `{"a":1 "b":2}`,
-        `[,]`,
-        `[,1]`,
-        `[1,]`,
-        `[,1,2]`,
-        `[1,2,]`,
-    }
-    for _, d := range ds {
-        var o interface{}
-        _, err := decode(d, &o, false)
-        if err == nil {
-            t.Fatalf("%#v", d)
-        }
-        if !strings.Contains(err.Error(), "invalid char"){
-            t.Fatal(err.Error())
-        }
-    }
+	var ds = []string{
+		`{,}`,
+		`{,"a"}`,
+		`{"a":}`,
+		`{"a":1,}`,
+		`{"a":1,"b"}`,
+		`{"a":1,"b":}`,
+		`{,"a":1 "b":2}`,
+		`{"a",:1 "b":2}`,
+		`{"a":,1 "b":2}`,
+		`{"a":1 "b",:2}`,
+		`{"a":1 "b":,2}`,
+		`{"a":1 "b":2,}`,
+		`{"a":1 "b":2}`,
+		`[,]`,
+		`[,1]`,
+		`[1,]`,
+		`[,1,2]`,
+		`[1,2,]`,
+	}
+	for _, d := range ds {
+		var o interface{}
+		_, err := decode(d, &o, false)
+		if err == nil {
+			t.Fatalf("%#v", d)
+		}
+		if !strings.Contains(err.Error(), "invalid char") {
+			t.Fatal(err.Error())
+		}
+	}
 }
 
 func decode(s string, v interface{}, copy bool) (int, error) {
-    d := NewDecoder(s)
-    if copy {
-        d.CopyString()
-    }
-    err := d.Decode(v)
-    if err != nil {
-        return 0, err
-    }
-    return len(s), err
+	d := NewDecoder(s)
+	if copy {
+		d.CopyString()
+	}
+	err := d.Decode(v)
+	if err != nil {
+		return 0, err
+	}
+	return len(s), err
 }
 
 func TestDecoder_Basic(t *testing.T) {
-    var v int
-    pos, err := decode("12345", &v, false)
-    assert.NoError(t, err)
-    assert.Equal(t, 5, pos)
-    assert.Equal(t, 12345, v)
+	var v int
+	pos, err := decode("12345", &v, false)
+	assert.NoError(t, err)
+	assert.Equal(t, 5, pos)
+	assert.Equal(t, 12345, v)
 }
 
 func TestDecoder_Generic(t *testing.T) {
-    var v interface{}
-    pos, err := decode(TwitterJson, &v, false)
-    assert.NoError(t, err)
-    assert.Equal(t, len(TwitterJson), pos)
+	var v interface{}
+	pos, err := decode(TwitterJson, &v, false)
+	assert.NoError(t, err)
+	assert.Equal(t, len(TwitterJson), pos)
 }
 
 func TestDecoder_Binding(t *testing.T) {
-    var v TwitterStruct
-    pos, err := decode(TwitterJson, &v, false)
-    assert.NoError(t, err)
-    assert.Equal(t, len(TwitterJson), pos)
-    assert.Equal(t, _BindingValue, v, 0)
-    spew.Dump(v)
+	var v TwitterStruct
+	pos, err := decode(TwitterJson, &v, false)
+	assert.NoError(t, err)
+	assert.Equal(t, len(TwitterJson), pos)
+	assert.Equal(t, _BindingValue, v, 0)
+	spew.Dump(v)
 }
 
-
 func TestDecoder_MapWithIndirectElement(t *testing.T) {
-    var v map[string]struct { A [129]byte }
-    _, err := decode(`{"":{"A":[1,2,3,4,5]}}`, &v, false)
-    require.NoError(t, err)
-    assert.Equal(t, [129]byte{1, 2, 3, 4, 5}, v[""].A)
+	var v map[string]struct{ A [129]byte }
+	_, err := decode(`{"":{"A":[1,2,3,4,5]}}`, &v, false)
+	require.NoError(t, err)
+	assert.Equal(t, [129]byte{1, 2, 3, 4, 5}, v[""].A)
 }
 
 func BenchmarkDecoder_Generic_Sonic(b *testing.B) {
-    var w interface{}
-    _, _ = decode(TwitterJson, &w, true)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        var v interface{}
-        _, _ = decode(TwitterJson, &v, true)
-    }
+	var w interface{}
+	_, _ = decode(TwitterJson, &w, true)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		var v interface{}
+		_, _ = decode(TwitterJson, &v, true)
+	}
 }
 
 func BenchmarkDecoder_Generic_Sonic_Fast(b *testing.B) {
-    var w interface{}
-    _, _ = decode(TwitterJson, &w, false)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        var v interface{}
-        _, _ = decode(TwitterJson, &v, false)
-    }
+	var w interface{}
+	_, _ = decode(TwitterJson, &w, false)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		var v interface{}
+		_, _ = decode(TwitterJson, &v, false)
+	}
 }
 
 func BenchmarkDecoder_Generic_StdLib(b *testing.B) {
-    var w interface{}
-    m := []byte(TwitterJson)
-    _ = json.Unmarshal(m, &w)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        var v interface{}
-        _ = json.Unmarshal(m, &v)
-    }
+	var w interface{}
+	m := []byte(TwitterJson)
+	_ = json.Unmarshal(m, &w)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		var v interface{}
+		_ = json.Unmarshal(m, &v)
+	}
 }
 
 func BenchmarkDecoder_Binding_Sonic(b *testing.B) {
-    var w TwitterStruct
-    _, _ = decode(TwitterJson, &w, true)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        var v TwitterStruct
-        _, _ = decode(TwitterJson, &v, true)
-    }
+	var w TwitterStruct
+	_, _ = decode(TwitterJson, &w, true)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		var v TwitterStruct
+		_, _ = decode(TwitterJson, &v, true)
+	}
 }
 
 func BenchmarkDecoder_Binding_Sonic_Fast(b *testing.B) {
-    var w TwitterStruct
-    _, _ = decode(TwitterJson, &w, false)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        var v TwitterStruct
-        _, _ = decode(TwitterJson, &v, false)
-    }
+	var w TwitterStruct
+	_, _ = decode(TwitterJson, &w, false)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		var v TwitterStruct
+		_, _ = decode(TwitterJson, &v, false)
+	}
 }
 
 func BenchmarkDecoder_Binding_StdLib(b *testing.B) {
-    var w TwitterStruct
-    m := []byte(TwitterJson)
-    _ = json.Unmarshal(m, &w)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        var v TwitterStruct
-        _ = json.Unmarshal(m, &v)
-    }
+	var w TwitterStruct
+	m := []byte(TwitterJson)
+	_ = json.Unmarshal(m, &w)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		var v TwitterStruct
+		_ = json.Unmarshal(m, &v)
+	}
 }
 
 func BenchmarkDecoder_Parallel_Generic_Sonic(b *testing.B) {
-    var w interface{}
-    _, _ = decode(TwitterJson, &w, true)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            var v interface{}
-            _, _ = decode(TwitterJson, &v, true)
-        }
-    })
+	var w interface{}
+	_, _ = decode(TwitterJson, &w, true)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var v interface{}
+			_, _ = decode(TwitterJson, &v, true)
+		}
+	})
 }
 
 func BenchmarkDecoder_Parallel_Generic_Sonic_Fast(b *testing.B) {
-    var w interface{}
-    _, _ = decode(TwitterJson, &w, false)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            var v interface{}
-            _, _ = decode(TwitterJson, &v, false)
-        }
-    })
+	var w interface{}
+	_, _ = decode(TwitterJson, &w, false)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var v interface{}
+			_, _ = decode(TwitterJson, &v, false)
+		}
+	})
 }
 
 func BenchmarkDecoder_Parallel_Generic_StdLib(b *testing.B) {
-    var w interface{}
-    m := []byte(TwitterJson)
-    _ = json.Unmarshal(m, &w)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            var v interface{}
-            _ = json.Unmarshal(m, &v)
-        }
-    })
+	var w interface{}
+	m := []byte(TwitterJson)
+	_ = json.Unmarshal(m, &w)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var v interface{}
+			_ = json.Unmarshal(m, &v)
+		}
+	})
 }
 
 func BenchmarkDecoder_Parallel_Binding_Sonic(b *testing.B) {
-    var w TwitterStruct
-    _, _ = decode(TwitterJson, &w, true)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            var v TwitterStruct
-            _, _ = decode(TwitterJson, &v, true)
-        }
-    })
+	var w TwitterStruct
+	_, _ = decode(TwitterJson, &w, true)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var v TwitterStruct
+			_, _ = decode(TwitterJson, &v, true)
+		}
+	})
 }
 
 func BenchmarkDecoder_Parallel_Binding_Sonic_Fast(b *testing.B) {
-    var w TwitterStruct
-    _, _ = decode(TwitterJson, &w, false)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            var v TwitterStruct
-            _, _ = decode(TwitterJson, &v, false)
-        }
-    })
+	var w TwitterStruct
+	_, _ = decode(TwitterJson, &w, false)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var v TwitterStruct
+			_, _ = decode(TwitterJson, &v, false)
+		}
+	})
 }
 
 func BenchmarkDecoder_Parallel_Binding_StdLib(b *testing.B) {
-    var w TwitterStruct
-    m := []byte(TwitterJson)
-    _ = json.Unmarshal(m, &w)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            var v TwitterStruct
-            _ = json.Unmarshal(m, &v)
-        }
-    })
+	var w TwitterStruct
+	m := []byte(TwitterJson)
+	_ = json.Unmarshal(m, &w)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			var v TwitterStruct
+			_ = json.Unmarshal(m, &v)
+		}
+	})
 }
diff --git a/encoder/encoder_test.go b/encoder/encoder_test.go
index f11905de0..f5dfad8d2 100644
--- a/encoder/encoder_test.go
+++ b/encoder/encoder_test.go
@@ -17,530 +17,552 @@
 package encoder
 
 import (
-    `bytes`
-    `encoding`
-    `encoding/json`
-    `runtime`
-    `runtime/debug`
-    `strconv`
-    `sync`
-    `testing`
-    `time`
-
-    `github.com/bytedance/sonic/internal/rt`
-    `github.com/stretchr/testify/require`
+	"bytes"
+	"encoding"
+	"encoding/json"
+	"runtime"
+	"runtime/debug"
+	"strconv"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/bytedance/sonic/internal/rt"
+	"github.com/stretchr/testify/require"
 )
 
 func TestMain(m *testing.M) {
-    go func ()  {
-        if !debugAsyncGC {
-            return
-        }
-        println("Begin GC looping...")
-        for {
-            runtime.GC()
-            debug.FreeOSMemory()
-        }
-        println("stop GC looping!")
-    }()
-    time.Sleep(time.Millisecond)
-    m.Run()
+	go func() {
+		if !debugAsyncGC {
+			return
+		}
+		println("Begin GC looping...")
+		for {
+			runtime.GC()
+			debug.FreeOSMemory()
+		}
+		println("stop GC looping!")
+	}()
+	time.Sleep(time.Millisecond)
+	m.Run()
 }
 
 func TestGC(t *testing.T) {
-    if debugSyncGC {
-        return
-    }
-    out, err := Encode(_GenericValue, 0)
-    if err != nil {
-        t.Fatal(err)
-    }
-    n := len(out)
-    wg := &sync.WaitGroup{}
-    N := 10000
-    for i:=0; i<N; i++ {
-        wg.Add(1)
-        go func (wg *sync.WaitGroup, size int)  {
-            defer wg.Done()
-            out, err := Encode(_GenericValue, 0)
-            if err != nil {
-                t.Fatal(err)
-            }
-            if len(out) != size {
-                t.Fatal(len(out), size)
-            }
-            runtime.GC()
-        }(wg, n)
-    }
-    wg.Wait()
+	if debugSyncGC {
+		return
+	}
+	out, err := Encode(_GenericValue, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	n := len(out)
+	wg := &sync.WaitGroup{}
+	N := 10000
+	for i := 0; i < N; i++ {
+		wg.Add(1)
+		go func(wg *sync.WaitGroup, size int) {
+			defer wg.Done()
+			out, err := Encode(_GenericValue, 0)
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			if len(out) != size {
+				t.Error(len(out), size)
+				return
+			}
+			runtime.GC()
+		}(wg, n)
+	}
+	wg.Wait()
 }
 
 type sample struct {
-    M map[string]interface{}
-    S []interface{}
-    A [0]interface{}
-    MP *map[string]interface{}
-    SP *[]interface{}
-    AP *[0]interface{}
+	M  map[string]interface{}
+	S  []interface{}
+	A  [0]interface{}
+	MP *map[string]interface{}
+	SP *[]interface{}
+	AP *[0]interface{}
 }
 
 func BenchmarkOptionSliceOrMapNoNull(b *testing.B) {
-    b.Run("true", func (b *testing.B) {
-        obj := sample{}
-        _, err := Encode(obj, NoNullSliceOrMap)
-        if err != nil {
-            b.Fatal(err)
-        }
-        b.ResetTimer()
-        for i:=0;i<b.N;i++{
-            _, _ = Encode(obj, NoNullSliceOrMap)
-        }
-    })
-
-    b.Run("false", func (b *testing.B) {
-        obj2 := sample{}
-        _, err := Encode(obj2, 0)
-        if err != nil {
-            b.Fatal(err)
-        }
-        for i:=0;i<b.N;i++{
-            _, _ = Encode(obj2, 0)
-        }
-    })
-}
-
-func runEncoderTest(t *testing.T, fn func(string)string, exp string, arg string) {
-    require.Equal(t, exp, fn(arg))
+	b.Run("true", func(b *testing.B) {
+		obj := sample{}
+		_, err := Encode(obj, NoNullSliceOrMap)
+		if err != nil {
+			b.Fatal(err)
+		}
+		b.ResetTimer()
+		for i := 0; i < b.N; i++ {
+			_, _ = Encode(obj, NoNullSliceOrMap)
+		}
+	})
+
+	b.Run("false", func(b *testing.B) {
+		obj2 := sample{}
+		_, err := Encode(obj2, 0)
+		if err != nil {
+			b.Fatal(err)
+		}
+		for i := 0; i < b.N; i++ {
+			_, _ = Encode(obj2, 0)
+		}
+	})
+}
+
+func runEncoderTest(t *testing.T, fn func(string) string, exp string, arg string) {
+	require.Equal(t, exp, fn(arg))
 }
 
 func TestEncoder_String(t *testing.T) {
-    runEncoderTest(t, Quote, `""`                                                 , "")
-    runEncoderTest(t, Quote, `"hello, world"`                                     , "hello, world")
-    runEncoderTest(t, Quote, `"hello啊啊啊aa"`                                    , "hello啊啊啊aa")
-    runEncoderTest(t, Quote, `"hello\\\"world"`                                   , "hello\\\"world")
-    runEncoderTest(t, Quote, `"hello\n\tworld"`                                   , "hello\n\tworld")
-    runEncoderTest(t, Quote, `"hello\u0000\u0001world"`                           , "hello\x00\x01world")
-    runEncoderTest(t, Quote, `"hello\u0000\u0001world"`                           , "hello\x00\x01world")
-    runEncoderTest(t, Quote, `"Cartoonist, Illustrator, and T-Shirt connoisseur"` , "Cartoonist, Illustrator, and T-Shirt connoisseur")
+	runEncoderTest(t, Quote, `""`, "")
+	runEncoderTest(t, Quote, `"hello, world"`, "hello, world")
+	runEncoderTest(t, Quote, `"hello啊啊啊aa"`, "hello啊啊啊aa")
+	runEncoderTest(t, Quote, `"hello\\\"world"`, "hello\\\"world")
+	runEncoderTest(t, Quote, `"hello\n\tworld"`, "hello\n\tworld")
+	runEncoderTest(t, Quote, `"hello\u0000\u0001world"`, "hello\x00\x01world")
+	runEncoderTest(t, Quote, `"hello\u0000\u0001world"`, "hello\x00\x01world")
+	runEncoderTest(t, Quote, `"Cartoonist, Illustrator, and T-Shirt connoisseur"`, "Cartoonist, Illustrator, and T-Shirt connoisseur")
 }
 
 type StringStruct struct {
-    X *int        `json:"x,string,omitempty"`
-    Y []int       `json:"y"`
-    Z json.Number `json:"z,string"`
-    W string      `json:"w,string"`
+	X *int        `json:"x,string,omitempty"`
+	Y []int       `json:"y"`
+	Z json.Number `json:"z,string"`
+	W string      `json:"w,string"`
 }
 
 func TestEncoder_FieldStringize(t *testing.T) {
-    x := 12345
-    v := StringStruct{X: &x, Y: []int{1, 2, 3}, Z: "4567456", W: "asdf"}
-    r, e := Encode(v, 0)
-    require.NoError(t, e)
-    println(string(r))
+	x := 12345
+	v := StringStruct{X: &x, Y: []int{1, 2, 3}, Z: "4567456", W: "asdf"}
+	r, e := Encode(v, 0)
+	require.NoError(t, e)
+	println(string(r))
 }
 
 func TestEncodeErrorAndScratchBuf(t *testing.T) {
-    var obj = map[string]interface{}{
-        "a": json.RawMessage(" [} "),
-    }
-    buf := make([]byte, 0, 10)
-    _ = EncodeInto(&buf, obj, 0)
-    if len(buf) < 0 || len(buf) > 10 {
-        t.Fatal()
-    }
+	var obj = map[string]interface{}{
+		"a": json.RawMessage(" [} "),
+	}
+	buf := make([]byte, 0, 10)
+	_ = EncodeInto(&buf, obj, 0)
+	if len(buf) < 0 || len(buf) > 10 {
+		t.Fatal()
+	}
 }
 
 type MarshalerImpl struct {
-    X int
+	X int
 }
 
 func (self *MarshalerImpl) MarshalJSON() ([]byte, error) {
-    ret := []byte(strconv.Itoa(self.X))
-    return append(ret, "    "...), nil
+	ret := []byte(strconv.Itoa(self.X))
+	return append(ret, "    "...), nil
 }
 
 type MarshalerStruct struct {
-    V MarshalerImpl
+	V MarshalerImpl
 }
 
 type MarshalerErrorStruct struct {
-    V MarshalerImpl
+	V MarshalerImpl
 }
 
 func (self *MarshalerErrorStruct) MarshalJSON() ([]byte, error) {
-    return []byte(`[""] {`), nil
+	return []byte(`[""] {`), nil
 }
 
 type RawMessageStruct struct {
-    X json.RawMessage
+	X json.RawMessage
 }
 
 type TextMarshalerImpl struct {
-    X string
+	X string
 }
 
 func (self *TextMarshalerImpl) MarshalText() ([]byte, error) {
-    return []byte(self.X), nil
+	return []byte(self.X), nil
 }
 
 type TextMarshalerImplV struct {
-    X string
+	X string
 }
 
 func (self TextMarshalerImplV) MarshalText() ([]byte, error) {
-    return []byte(self.X), nil
+	return []byte(self.X), nil
 }
 
 type TextMarshalerStruct struct {
-    V TextMarshalerImpl
+	V TextMarshalerImpl
 }
 
 func TestTextMarshalTextKey_SortKeys(t *testing.T) {
-    v := map[*TextMarshalerImpl]string{
-        {"b"}: "b",
-        {"c"}: "c",
-        {"a"}: "a",
-    }
-    ret, err := Encode(v, SortMapKeys)
-    require.NoError(t, err)
-    require.Equal(t, `{"a":"a","b":"b","c":"c"}`, string(ret))
-
-    v2 := map[TextMarshalerImplV]string{
-        {"b"}: "b",
-        {"c"}: "c",
-        {"a"}: "a",
-    }
-    ret, err = Encode(v2, SortMapKeys)
-    require.NoError(t, err)
-    require.Equal(t, `{"a":"a","b":"b","c":"c"}`, string(ret))
-
-    v3 := map[encoding.TextMarshaler]string{
-        TextMarshalerImplV{"b"}: "b",
-        &TextMarshalerImpl{"c"}: "c",
-        TextMarshalerImplV{"a"}: "a",
-    }
-    ret, err = Encode(v3, SortMapKeys)
-    require.NoError(t, err)
-    require.Equal(t, `{"a":"a","b":"b","c":"c"}`, string(ret))
+	v := map[*TextMarshalerImpl]string{
+		{"b"}: "b",
+		{"c"}: "c",
+		{"a"}: "a",
+	}
+	ret, err := Encode(v, SortMapKeys)
+	require.NoError(t, err)
+	require.Equal(t, `{"a":"a","b":"b","c":"c"}`, string(ret))
+
+	v2 := map[TextMarshalerImplV]string{
+		{"b"}: "b",
+		{"c"}: "c",
+		{"a"}: "a",
+	}
+	ret, err = Encode(v2, SortMapKeys)
+	require.NoError(t, err)
+	require.Equal(t, `{"a":"a","b":"b","c":"c"}`, string(ret))
+
+	v3 := map[encoding.TextMarshaler]string{
+		TextMarshalerImplV{"b"}: "b",
+		&TextMarshalerImpl{"c"}: "c",
+		TextMarshalerImplV{"a"}: "a",
+	}
+	ret, err = Encode(v3, SortMapKeys)
+	require.NoError(t, err)
+	require.Equal(t, `{"a":"a","b":"b","c":"c"}`, string(ret))
 }
 
 func TestEncoder_EscapeHTML(t *testing.T) {
-    // test data from libfuzzer
-    test := []string{
-        "&&&&&&&&&&&&&&&&&&&&&&&\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&",
-        "{\"\"\u2028\x94\xe2\x00\x00\x00\x00\x00\x00\x00\x00\u2028\x80\u2028\x80\u2028\xe2\u2028\x8a\u2028⑀\xa8\x8a\xa8\xe2\u2028\xe2\u2028\xe2\u2028\xe2\u2000\x8d\xe2\u2028\xe2\u2028\xe2\xe2\xa8\"}",
-    }
-    for _, s := range(test) {
-        data := []byte(s)
-        sdst := HTMLEscape(nil, data)
-        var dst bytes.Buffer
-        json.HTMLEscape(&dst, data)
-        require.Equal(t, string(sdst), dst.String())
-    }
+	// test data from libfuzzer
+	test := []string{
+		"&&&&&&&&&&&&&&&&&&&&&&&\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2\xe2&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&",
+		"{\"\"\u2028\x94\xe2\x00\x00\x00\x00\x00\x00\x00\x00\u2028\x80\u2028\x80\u2028\xe2\u2028\x8a\u2028⑀\xa8\x8a\xa8\xe2\u2028\xe2\u2028\xe2\u2028\xe2\u2000\x8d\xe2\u2028\xe2\u2028\xe2\xe2\xa8\"}",
+	}
+	for _, s := range test {
+		data := []byte(s)
+		sdst := HTMLEscape(nil, data)
+		var dst bytes.Buffer
+		json.HTMLEscape(&dst, data)
+		require.Equal(t, string(sdst), dst.String())
+	}
 }
 
 func TestEncoder_Marshal_EscapeHTML_LargeJson(t *testing.T) {
-    buf1, err1 := Encode(&_BindingValue, SortMapKeys | EscapeHTML)
-    require.NoError(t, err1)
-    buf2, err2 :=json.Marshal(&_BindingValue)
-    require.NoError(t, err2)
-    require.Equal(t, buf1, buf2)
+	buf1, err1 := Encode(&_BindingValue, SortMapKeys|EscapeHTML)
+	require.NoError(t, err1)
+	buf2, err2 := json.Marshal(&_BindingValue)
+	require.NoError(t, err2)
+	require.Equal(t, buf1, buf2)
 }
 
 var _GenericValue interface{}
 var _BindingValue TwitterStruct
 
 func init() {
-    _ = json.Unmarshal([]byte(TwitterJson), &_GenericValue)
-    _ = json.Unmarshal([]byte(TwitterJson), &_BindingValue)
+	_ = json.Unmarshal([]byte(TwitterJson), &_GenericValue)
+	_ = json.Unmarshal([]byte(TwitterJson), &_BindingValue)
 }
 
 func TestEncoder_Generic(t *testing.T) {
-    v, e := Encode(_GenericValue, 0)
-    require.NoError(t, e)
-    println(string(v))
+	v, e := Encode(_GenericValue, 0)
+	require.NoError(t, e)
+	println(string(v))
 }
 
 func TestEncoder_Binding(t *testing.T) {
-    v, e := Encode(_BindingValue, 0)
-    require.NoError(t, e)
-    println(string(v))
+	v, e := Encode(_BindingValue, 0)
+	require.NoError(t, e)
+	println(string(v))
 }
 
 func TestEncoder_MapSortKey(t *testing.T) {
-    m := map[string]string {
-        "C": "third",
-        "D": "forth",
-        "A": "first",
-        "F": "sixth",
-        "E": "fifth",
-        "B": "second",
-    }
-    v, e := Encode(m, SortMapKeys)
-    require.NoError(t, e)
-    require.Equal(t, `{"A":"first","B":"second","C":"third","D":"forth","E":"fifth","F":"sixth"}`, string(v))
+	m := map[string]string{
+		"C": "third",
+		"D": "forth",
+		"A": "first",
+		"F": "sixth",
+		"E": "fifth",
+		"B": "second",
+	}
+	v, e := Encode(m, SortMapKeys)
+	require.NoError(t, e)
+	require.Equal(t, `{"A":"first","B":"second","C":"third","D":"forth","E":"fifth","F":"sixth"}`, string(v))
 }
 
 func BenchmarkEncoder_Generic_Sonic(b *testing.B) {
-    _, _ = Encode(_GenericValue, SortMapKeys | EscapeHTML | CompactMarshaler)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        _, _ = Encode(_GenericValue, SortMapKeys | EscapeHTML | CompactMarshaler)
-    }
+	_, _ = Encode(_GenericValue, SortMapKeys|EscapeHTML|CompactMarshaler)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = Encode(_GenericValue, SortMapKeys|EscapeHTML|CompactMarshaler)
+	}
 }
 
 func BenchmarkEncoder_Generic_Sonic_Fast(b *testing.B) {
-    _, _ = Encode(_GenericValue, 0)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        _, _ = Encode(_GenericValue, 0)
-    }
+	_, _ = Encode(_GenericValue, 0)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = Encode(_GenericValue, 0)
+	}
 }
 
 func BenchmarkEncoder_Generic_StdLib(b *testing.B) {
-    _, _ = json.Marshal(_GenericValue)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        _, _ = json.Marshal(_GenericValue)
-    }
+	_, _ = json.Marshal(_GenericValue)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = json.Marshal(_GenericValue)
+	}
 }
 
 func BenchmarkEncoder_Binding_Sonic(b *testing.B) {
-    _, _ = Encode(&_BindingValue, SortMapKeys | EscapeHTML | CompactMarshaler)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        _, _ = Encode(&_BindingValue, SortMapKeys | EscapeHTML | CompactMarshaler)
-    }
+	_, _ = Encode(&_BindingValue, SortMapKeys|EscapeHTML|CompactMarshaler)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = Encode(&_BindingValue, SortMapKeys|EscapeHTML|CompactMarshaler)
+	}
 }
 
 func BenchmarkEncoder_Binding_Sonic_Fast(b *testing.B) {
-    _, _ = Encode(&_BindingValue, NoQuoteTextMarshaler)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        _, _ = Encode(&_BindingValue, NoQuoteTextMarshaler)
-    }
+	_, _ = Encode(&_BindingValue, NoQuoteTextMarshaler)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = Encode(&_BindingValue, NoQuoteTextMarshaler)
+	}
 }
 
 func BenchmarkEncoder_Binding_StdLib(b *testing.B) {
-    _, _ = json.Marshal(&_BindingValue)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i := 0; i < b.N; i++ {
-        _, _ = json.Marshal(&_BindingValue)
-    }
+	_, _ = json.Marshal(&_BindingValue)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = json.Marshal(&_BindingValue)
+	}
 }
 
 func BenchmarkEncoder_Parallel_Generic_Sonic(b *testing.B) {
-    _, _ = Encode(_GenericValue, SortMapKeys | EscapeHTML | CompactMarshaler)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            _, _ = Encode(_GenericValue, SortMapKeys | EscapeHTML | CompactMarshaler)
-        }
-    })
+	_, _ = Encode(_GenericValue, SortMapKeys|EscapeHTML|CompactMarshaler)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, _ = Encode(_GenericValue, SortMapKeys|EscapeHTML|CompactMarshaler)
+		}
+	})
 }
 
 func BenchmarkEncoder_Parallel_Generic_Sonic_Fast(b *testing.B) {
-    _, _ = Encode(_GenericValue, NoQuoteTextMarshaler)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            _, _ = Encode(_GenericValue, NoQuoteTextMarshaler)
-        }
-    })
+	_, _ = Encode(_GenericValue, NoQuoteTextMarshaler)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, _ = Encode(_GenericValue, NoQuoteTextMarshaler)
+		}
+	})
 }
 
 func BenchmarkEncoder_Parallel_Generic_StdLib(b *testing.B) {
-    _, _ = json.Marshal(_GenericValue)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            _, _ = json.Marshal(_GenericValue)
-        }
-    })
+	_, _ = json.Marshal(_GenericValue)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, _ = json.Marshal(_GenericValue)
+		}
+	})
 }
 
 func BenchmarkEncoder_Parallel_Binding_Sonic(b *testing.B) {
-    _, _ = Encode(&_BindingValue, SortMapKeys | EscapeHTML | CompactMarshaler)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            _, _ = Encode(&_BindingValue, SortMapKeys | EscapeHTML | CompactMarshaler)
-        }
-    })
+	_, _ = Encode(&_BindingValue, SortMapKeys|EscapeHTML|CompactMarshaler)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, _ = Encode(&_BindingValue, SortMapKeys|EscapeHTML|CompactMarshaler)
+		}
+	})
 }
 
 func BenchmarkEncoder_Parallel_Binding_Sonic_Fast(b *testing.B) {
-    _, _ = Encode(&_BindingValue, NoQuoteTextMarshaler)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            _, _ = Encode(&_BindingValue, NoQuoteTextMarshaler)
-        }
-    })
+	_, _ = Encode(&_BindingValue, NoQuoteTextMarshaler)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, _ = Encode(&_BindingValue, NoQuoteTextMarshaler)
+		}
+	})
 }
 
 func BenchmarkEncoder_Parallel_Binding_StdLib(b *testing.B) {
-    _, _ = json.Marshal(&_BindingValue)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    b.RunParallel(func(pb *testing.PB) {
-        for pb.Next() {
-            _, _ = json.Marshal(&_BindingValue)
-        }
-    })
+	_, _ = json.Marshal(&_BindingValue)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			_, _ = json.Marshal(&_BindingValue)
+		}
+	})
 }
 
 func BenchmarkHTMLEscape_Sonic(b *testing.B) {
-    jsonByte := []byte(TwitterJson)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    var buf []byte
-    for i := 0; i < b.N; i++ {
-        buf = HTMLEscape(nil, jsonByte)
-    }
-    _ = buf
+	jsonByte := []byte(TwitterJson)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	var buf []byte
+	for i := 0; i < b.N; i++ {
+		buf = HTMLEscape(nil, jsonByte)
+	}
+	_ = buf
 }
 
 func BenchmarkHTMLEscape_StdLib(b *testing.B) {
-    jsonByte := []byte(TwitterJson)
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    var buf []byte
-    for i := 0; i < b.N; i++ {
-        out := bytes.NewBuffer(make([]byte, 0, len(TwitterJson) * 6 / 5))
-        json.HTMLEscape(out, jsonByte)
-        buf = out.Bytes()
-    }
-    _ = buf
+	jsonByte := []byte(TwitterJson)
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	var buf []byte
+	for i := 0; i < b.N; i++ {
+		out := bytes.NewBuffer(make([]byte, 0, len(TwitterJson)*6/5))
+		json.HTMLEscape(out, jsonByte)
+		buf = out.Bytes()
+	}
+	_ = buf
 }
 
-
 func BenchmarkValidate_Sonic(b *testing.B) {
-    var data = rt.Str2Mem(TwitterJson)
-    ok, s := Valid(data)
-    if !ok {
-        b.Fatal(s)
-    }
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i:=0; i<b.N; i++ {
-        _, _ = Valid(data)
-    }
+	var data = rt.Str2Mem(TwitterJson)
+	ok, s := Valid(data)
+	if !ok {
+		b.Fatal(s)
+	}
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = Valid(data)
+	}
 }
 
 func BenchmarkValidate_Std(b *testing.B) {
-    var data = rt.Str2Mem(TwitterJson)
-    if !json.Valid(data) {
-        b.Fatal()
-    }
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i:=0; i<b.N; i++ {
-        _ = json.Valid(data)
-    }
+	var data = rt.Str2Mem(TwitterJson)
+	if !json.Valid(data) {
+		b.Fatal()
+	}
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = json.Valid(data)
+	}
 }
 
 func BenchmarkCompact_Std(b *testing.B) {
-    var data = rt.Str2Mem(TwitterJson)
-    var dst = bytes.NewBuffer(nil)
-    if err := json.Compact(dst, data); err != nil {
-        b.Fatal(err)
-    }
-    b.SetBytes(int64(len(TwitterJson)))
-    b.ResetTimer()
-    for i:=0; i<b.N; i++ {
-        dst.Reset()
-        _ = json.Compact(dst, data)
-    }
+	var data = rt.Str2Mem(TwitterJson)
+	var dst = bytes.NewBuffer(nil)
+	if err := json.Compact(dst, data); err != nil {
+		b.Fatal(err)
+	}
+	b.SetBytes(int64(len(TwitterJson)))
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		dst.Reset()
+		_ = json.Compact(dst, data)
+	}
 }
 
 type f64Bench struct {
-    name    string
-    float   float64
+	name  string
+	float float64
 }
+
 func BenchmarkEncode_Float64(b *testing.B) {
-    var bench = []f64Bench{
-        {"Zero", 0},
-        {"ShortDecimal", 1000},
-        {"Decimal", 33909},
-        {"Float", 339.7784},
-        {"Exp", -5.09e75},
-        {"NegExp", -5.11e-95},
-        {"LongExp", 1.234567890123456e-78},
-        {"Big", 123456789123456789123456789},
-    
-    }
-    maxUint := "18446744073709551615"
-    for i := 1; i <= len(maxUint); i++ {
-        name := strconv.FormatInt(int64(i), 10) + "-Digs"
-        num, _ := strconv.ParseUint(string(maxUint[:i]), 10, 64)
-        bench = append(bench, f64Bench{name, float64(num)})
-    }
-    for _, c := range bench {
-        libs := []struct {
-            name string
-            test func(*testing.B)
-        }{{
-            name: "StdLib",
-            test: func(b *testing.B) {  _, _ = json.Marshal(c.float); for i := 0; i < b.N; i++ { _, _ = json.Marshal(c.float) }},
-        }, {
-            name: "Sonic",
-            test: func(b *testing.B) { _, _ = Encode(c.float, 0); for i := 0; i < b.N; i++ { _, _ = Encode(c.float, 0) }},
-        }}
-        for _, lib := range libs {
-            name := lib.name + "_" + c.name
-            b.Run(name, lib.test)
-        }  
-    }
+	var bench = []f64Bench{
+		{"Zero", 0},
+		{"ShortDecimal", 1000},
+		{"Decimal", 33909},
+		{"Float", 339.7784},
+		{"Exp", -5.09e75},
+		{"NegExp", -5.11e-95},
+		{"LongExp", 1.234567890123456e-78},
+		{"Big", 123456789123456789123456789},
+	}
+	maxUint := "18446744073709551615"
+	for i := 1; i <= len(maxUint); i++ {
+		name := strconv.FormatInt(int64(i), 10) + "-Digs"
+		num, _ := strconv.ParseUint(string(maxUint[:i]), 10, 64)
+		bench = append(bench, f64Bench{name, float64(num)})
+	}
+	for _, c := range bench {
+		libs := []struct {
+			name string
+			test func(*testing.B)
+		}{{
+			name: "StdLib",
+			test: func(b *testing.B) {
+				_, _ = json.Marshal(c.float)
+				for i := 0; i < b.N; i++ {
+					_, _ = json.Marshal(c.float)
+				}
+			},
+		}, {
+			name: "Sonic",
+			test: func(b *testing.B) {
+				_, _ = Encode(c.float, 0)
+				for i := 0; i < b.N; i++ {
+					_, _ = Encode(c.float, 0)
+				}
+			},
+		}}
+		for _, lib := range libs {
+			name := lib.name + "_" + c.name
+			b.Run(name, lib.test)
+		}
+	}
 }
 
 type f32Bench struct {
-    name    string
-    float   float32
+	name  string
+	float float32
 }
+
 func BenchmarkEncode_Float32(b *testing.B) {
-    var bench = []f32Bench{
-        {"Zero", 0},
-        {"ShortDecimal", 1000},
-        {"Decimal", 33909},
-        {"ExactFraction", 3.375},
-        {"Point", 339.7784},
-        {"Exp", -5.09e25},
-        {"NegExp", -5.11e-25},
-        {"Shortest", 1.234567e-8},
-    }
-
-    maxUint := "18446744073709551615"
-    for i := 1; i <= len(maxUint); i++ {
-        name := strconv.FormatInt(int64(i), 10) + "-Digs"
-        num, _ := strconv.ParseUint(string(maxUint[:i]), 10, 64)
-        bench = append(bench, f32Bench{name, float32(num)})
-    }
-    for _, c := range bench {
-        libs := []struct {
-            name string
-            test func(*testing.B)
-        }{{
-            name: "StdLib",
-            test: func(b *testing.B) {  _, _ = json.Marshal(c.float); for i := 0; i < b.N; i++ { _, _ = json.Marshal(c.float) }},
-        }, {
-            name: "Sonic",
-            test: func(b *testing.B) { _, _ = Encode(c.float, 0); for i := 0; i < b.N; i++ { _, _ = Encode(c.float, 0) }},
-        }}
-        for _, lib := range libs {
-            name := lib.name + "_" + c.name
-            b.Run(name, lib.test)
-        }  
-    }
-}
\ No newline at end of file
+	var bench = []f32Bench{
+		{"Zero", 0},
+		{"ShortDecimal", 1000},
+		{"Decimal", 33909},
+		{"ExactFraction", 3.375},
+		{"Point", 339.7784},
+		{"Exp", -5.09e25},
+		{"NegExp", -5.11e-25},
+		{"Shortest", 1.234567e-8},
+	}
+
+	maxUint := "18446744073709551615"
+	for i := 1; i <= len(maxUint); i++ {
+		name := strconv.FormatInt(int64(i), 10) + "-Digs"
+		num, _ := strconv.ParseUint(string(maxUint[:i]), 10, 64)
+		bench = append(bench, f32Bench{name, float32(num)})
+	}
+	for _, c := range bench {
+		libs := []struct {
+			name string
+			test func(*testing.B)
+		}{{
+			name: "StdLib",
+			test: func(b *testing.B) {
+				_, _ = json.Marshal(c.float)
+				for i := 0; i < b.N; i++ {
+					_, _ = json.Marshal(c.float)
+				}
+			},
+		}, {
+			name: "Sonic",
+			test: func(b *testing.B) {
+				_, _ = Encode(c.float, 0)
+				for i := 0; i < b.N; i++ {
+					_, _ = Encode(c.float, 0)
+				}
+			},
+		}}
+		for _, lib := range libs {
+			name := lib.name + "_" + c.name
+			b.Run(name, lib.test)
+		}
+	}
+}