diff --git a/.github/workflows/cifuzz.yml b/.github/workflows/cifuzz.yml
new file mode 100644
index 0000000..7af25ab
--- /dev/null
+++ b/.github/workflows/cifuzz.yml
@@ -0,0 +1,26 @@
+name: CIFuzz
+on: [pull_request]
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Build Fuzzers
+      id: build
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'jsonparser'
+        dry-run: false
+        language: go
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'jsonparser'
+        fuzz-seconds: 600
+        dry-run: false
+        language: go
+    - name: Upload Crash
+      uses: actions/upload-artifact@v1
+      if: failure() && steps.build.outcome == 'success'
+      with:
+        name: artifacts
+        path: ./out/artifacts
diff --git a/.travis.yml b/.travis.yml
index dbfb7cf..46efadc 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -3,9 +3,7 @@ arch:
     - amd64
     - ppc64le
 go:
-    - 1.7.x
-    - 1.8.x
-    - 1.9.x
-    - 1.10.x
-    - 1.11.x
+    - 1.13.x
+    - 1.14.x
+    - 1.15.x
 script: go test -v ./.
diff --git a/README.md b/README.md
index d7e0ec3..0b2f1fb 100644
--- a/README.md
+++ b/README.md
@@ -90,10 +90,6 @@ jsonparser.EachKey(data, func(idx int, value []byte, vt jsonparser.ValueType, er
 // For more information see docs below
 ```
 
-## Need to speedup your app?
-
-I'm available for consulting and can help you push your app performance to the limits. Ping me at: leonsbox@gmail.com.
-
 ## Reference
 
 Library API is really simple. You just need the `Get` method to perform any operation. The rest is just helpers around it.
diff --git a/bytes.go b/bytes.go
index 0bb0ff3..9d6e701 100644
--- a/bytes.go
+++ b/bytes.go
@@ -1,11 +1,8 @@
 package jsonparser
 
-import (
-	bio "bytes"
-)
-
-// minInt64 '-9223372036854775808' is the smallest representable number in int64
-const minInt64 = `9223372036854775808`
+const absMinInt64 = 1 << 63
+const maxInt64 = 1<<63 - 1
+const maxUint64 = 1<<64 - 1
 
 // About 2x faster then strconv.ParseInt because it only supports base 10, which is enough for JSON
 func parseInt(bytes []byte) (v int64, ok bool, overflow bool) {
@@ -19,29 +16,32 @@ func parseInt(bytes []byte) (v int64, ok bool, overflow bool) {
 		bytes = bytes[1:]
 	}
 
-	var b int64 = 0
+	var n uint64 = 0
 	for _, c := range bytes {
-		if c >= '0' && c <= '9' {
-			b = (10 * v) + int64(c-'0')
-		} else {
+		if c < '0' || c > '9' {
 			return 0, false, false
 		}
-		if overflow = (b < v); overflow {
-			break
+		if n > maxUint64/10 {
+			return 0, false, true
+		}
+		n *= 10
+		n1 := n + uint64(c-'0')
+		if n1 < n {
+			return 0, false, true
 		}
-		v = b
+		n = n1
 	}
 
-	if overflow {
-		if neg && bio.Equal(bytes, []byte(minInt64)) {
-			return b, true, false
+	if n > maxInt64 {
+		if neg && n == absMinInt64 {
+			return -absMinInt64, true, false
 		}
 		return 0, false, true
 	}
 
 	if neg {
-		return -v, true, false
+		return -int64(n), true, false
 	} else {
-		return v, true, false
+		return int64(n), true, false
 	}
 }
diff --git a/bytes_test.go b/bytes_test.go
index 6287ee3..435103a 100644
--- a/bytes_test.go
+++ b/bytes_test.go
@@ -86,6 +86,18 @@ var parseIntTests = []ParseIntTest{
 		in:    "9223372036854775807x",
 		isErr: true,
 	},
+	{
+		in:         "27670116110564327410",
+		out:        0,
+		isErr:      true,
+		isOverflow: true,
+	},
+	{
+		in:         "-27670116110564327410",
+		out:        0,
+		isErr:      true,
+		isOverflow: true,
+	},
 }
 
 func TestBytesParseInt(t *testing.T) {
diff --git a/parser.go b/parser.go
index 14b80bc..d0ec989 100644
--- a/parser.go
+++ b/parser.go
@@ -18,6 +18,7 @@ var (
 	MalformedValueError        = errors.New("Value looks like Number/Boolean/None, but can't find its end: ',' or '}' symbol")
 	OverflowIntegerError       = errors.New("Value is number, but overflowed while parsing")
 	MalformedStringEscapeError = errors.New("Encountered an invalid escape sequence in a string")
+	NullValueError             = errors.New("Value is null")
 )
 
 // How much stack space to allocate for unescaping JSON strings; if a string longer
@@ -49,10 +50,13 @@ func findTokenStart(data []byte, token byte) int {
 }
 
 func findKeyStart(data []byte, key string) (int, error) {
-	i := 0
+	i := nextToken(data)
+	if i == -1 {
+		return i, KeyPathNotFoundError
+	}
 	ln := len(data)
-	if ln > 0 && (data[0] == '{' || data[0] == '[') {
-		i = 1
+	if ln > 0 && (data[i] == '{' || data[i] == '[') {
+		i += 1
 	}
 	var stackbuf [unescapeStackBufSize]byte // stack-allocated array for allocation-free unescaping of small strings
 
@@ -308,7 +312,7 @@ func searchKeys(data []byte, keys ...string) int {
 		case '[':
 			// If we want to get array element by index
 			if keyLevel == level && keys[level][0] == '[' {
-				var keyLen = len(keys[level])
+				keyLen := len(keys[level])
 				if keyLen < 3 || keys[level][0] != '[' || keys[level][keyLen-1] != ']' {
 					return -1
 				}
@@ -319,7 +323,7 @@ func searchKeys(data []byte, keys ...string) int {
 				var curIdx int
 				var valueFound []byte
 				var valueOffset int
-				var curI = i
+				curI := i
 				ArrayEach(data[i:], func(value []byte, dataType ValueType, offset int, err error) {
 					if curIdx == aIdx {
 						valueFound = value
@@ -374,12 +378,19 @@ func sameTree(p1, p2 []string) bool {
 	return true
 }
 
+const stackArraySize = 128
+
 func EachKey(data []byte, cb func(int, []byte, ValueType, error), paths ...[]string) int {
 	var x struct{}
-	pathFlags := make([]bool, len(paths))
 	var level, pathsMatched, i int
 	ln := len(data)
 
+	pathFlags := make([]bool, stackArraySize)[:]
+	if len(paths) > cap(pathFlags) {
+		pathFlags = make([]bool, len(paths))[:]
+	}
+	pathFlags = pathFlags[0:len(paths)]
+
 	var maxPath int
 	for _, p := range paths {
 		if len(p) > maxPath {
@@ -387,7 +398,11 @@ func EachKey(data []byte, cb func(int, []byte, ValueType, error), paths ...[]str
 		}
 	}
 
-	pathsBuf := make([]string, maxPath)
+	pathsBuf := make([]string, stackArraySize)[:]
+	if maxPath > cap(pathsBuf) {
+		pathsBuf = make([]string, maxPath)[:]
+	}
+	pathsBuf = pathsBuf[0:maxPath]
 
 	for i < ln {
 		switch data[i] {
@@ -662,7 +677,6 @@ func calcAllocateSpace(keys []string, setValue []byte, comma, object bool) int {
 		}
 	}
 
-
 	lk += len(setValue)
 	for i := 1; i < len(keys); i++ {
 		if string(keys[i][0]) == "[" {
@@ -1178,6 +1192,9 @@ func GetString(data []byte, keys ...string) (val string, err error) {
 	}
 
 	if t != String {
+		if t == Null {
+			return "", NullValueError
+		}
 		return "", fmt.Errorf("Value is not a string: %s", string(v))
 	}
 
@@ -1200,6 +1217,9 @@ func GetFloat(data []byte, keys ...string) (val float64, err error) {
 	}
 
 	if t != Number {
+		if t == Null {
+			return 0, NullValueError
+		}
 		return 0, fmt.Errorf("Value is not a number: %s", string(v))
 	}
 
@@ -1216,6 +1236,9 @@ func GetInt(data []byte, keys ...string) (val int64, err error) {
 	}
 
 	if t != Number {
+		if t == Null {
+			return 0, NullValueError
+		}
 		return 0, fmt.Errorf("Value is not a number: %s", string(v))
 	}
 
@@ -1233,6 +1256,9 @@ func GetBoolean(data []byte, keys ...string) (val bool, err error) {
 	}
 
 	if t != Boolean {
+		if t == Null {
+			return false, NullValueError
+		}
 		return false, fmt.Errorf("Value is not a boolean: %s", string(v))
 	}
 
diff --git a/parser_test.go b/parser_test.go
index 11b3e66..7036feb 100644
--- a/parser_test.go
+++ b/parser_test.go
@@ -221,6 +221,12 @@ var deleteTests = []DeleteTest{
 		path: []string{""},
 		data: `^_�^C^A^@{`,
 	},
+	{
+		desc: "Issue #150: leading space",
+		json: `   {"test":"input"}`,
+		path: []string{"test"},
+		data: `   {}`,
+	},
 }
 
 var setTests = []SetTest{
@@ -907,6 +913,12 @@ var getIntTests = []GetTest{
 		path:  []string{"c"},
 		isErr: true,
 	},
+	{
+		desc:  `null test`,
+		json:  `{"a": "b", "c": null}`,
+		path:  []string{"c"},
+		isErr: true,
+	},
 }
 
 var getFloatTests = []GetTest{
@@ -930,6 +942,12 @@ var getFloatTests = []GetTest{
 		path:  []string{"c"},
 		isErr: true,
 	},
+	{
+		desc:  `null test`,
+		json:  `{"a": "b", "c": null}`,
+		path:  []string{"c"},
+		isErr: true,
+	},
 }
 
 var getStringTests = []GetTest{
@@ -989,17 +1007,23 @@ var getStringTests = []GetTest{
 		isErr: true,
 	},
 	{
-		desc:  `empty array index`,
-		json:  `[""]`,
-		path:  []string{"[]"},
+		desc:    `empty array index`,
+		json:    `[""]`,
+		path:    []string{"[]"},
 		isFound: false,
 	},
 	{
-		desc:  `malformed array index`,
-		json:  `[""]`,
-		path:  []string{"["},
+		desc:    `malformed array index`,
+		json:    `[""]`,
+		path:    []string{"["},
 		isFound: false,
 	},
+	{
+		desc:  `null test`,
+		json:  `{"c": null}`,
+		path:  []string{"c"},
+		isErr: true,
+	},
 }
 
 var getUnsafeStringTests = []GetTest{
@@ -1081,6 +1105,13 @@ var getBoolTests = []GetTest{
 		isFound: true,
 		data:    true,
 	},
+	{
+		desc:    `null test`,
+		json:    `{"a": "b", "c": null}`,
+		path:    []string{"c"},
+		isFound: false,
+		isErr:   true,
+	},
 }
 
 var getArrayTests = []GetTest{
@@ -1402,7 +1433,7 @@ func TestArrayEach(t *testing.T) {
 }
 
 func TestArrayEachWithWhiteSpace(t *testing.T) {
-	//Issue #159
+	// Issue #159
 	count := 0
 	funcError := func([]byte, ValueType, int, error) { t.Errorf("Run func not allow") }
 	funcSuccess := func(value []byte, dataType ValueType, index int, err error) {