diff --git a/src/builtin.c b/src/builtin.c
index cf4792c446..04dae75acc 100644
--- a/src/builtin.c
+++ b/src/builtin.c
@@ -7,6 +7,7 @@
 #endif
 #include <sys/time.h>
 #include <stdlib.h>
+#include <stdio.h>
 #include <stddef.h>
 #ifdef HAVE_ALLOCA_H
 # include <alloca.h>
@@ -46,7 +47,6 @@ void *alloca (size_t);
 #include "jv_private.h"
 #include "util.h"
 
-
 #define BINOP(name) \
 static jv f_ ## name(jq_state *jq, jv input, jv a, jv b) { \
   jv_free(input); \
@@ -807,6 +807,62 @@ static jv f_sort_by_impl(jq_state *jq, jv input, jv keys) {
   }
 }
 
+/* Assuming the input array is sorted, bsearch/1 returns */
+/* the index of the target if the target is in the input array; and otherwise */
+/*  (-1 - ix), where ix is the insertion point that would leave the array sorted. */
+/* If the input is not sorted, bsearch will terminate but with irrelevant results. */
+static jv f_bsearch(jq_state *jq, jv input, jv target) {
+    assert(jv_get_kind(input) == JV_KIND_ARRAY);
+    assert(jv_get_kind(target) == JV_KIND_NUMBER);
+    int len = jv_array_length(jv_copy(input));
+    if (len == 0) {
+        jv_free(input);
+        jv_free(target);
+        return jv_number(-1);
+    } else if (len == 1) {
+        int result = jv_cmp(target, jv_array_get(input, 0));
+        if (result == 0 ) {
+            return jv_number(0);
+        } else if (result > 0) {
+            return jv_number(-2);
+        } else {
+            return jv_number(-1);
+        }
+    }
+
+    int start = 0;
+    int end = len - 1;
+    jv answer = jv_null();
+    while (start <end) {
+        int mid = (start + end) / 2;
+        int result = jv_cmp(jv_copy(target), jv_array_get(jv_copy(input), mid));
+        if (result == 0) {
+            answer = jv_number(mid);
+            break;
+        } else if (start == end ) {
+            answer = jv_number(-1);
+            break;
+        } else if (result < 0 ) {
+            end = mid -1;
+        } else {
+            start = mid +1;
+        }
+    }
+    if (jv_get_kind(answer) == JV_KIND_NULL) {
+        int result = jv_cmp(target, jv_array_get(jv_copy(input), start));
+        if (result < 0) {
+            answer =  jv_number(-1 - start);
+        }else {
+            answer =  jv_number(-2 - start);
+        }
+    } else {
+        jv_free(target);
+    }
+
+    jv_free(input);
+    return answer;
+}
+
 static jv f_group_by_impl(jq_state *jq, jv input, jv keys) {
   if (jv_get_kind(input) == JV_KIND_ARRAY &&
       jv_get_kind(keys) == JV_KIND_ARRAY &&
@@ -1754,6 +1810,7 @@ BINOPS
   {f_sort, "sort", 1},
   {f_sort_by_impl, "_sort_by_impl", 2},
   {f_group_by_impl, "_group_by_impl", 2},
+  {f_bsearch, "bsearch", 2},
   {f_min, "min", 1},
   {f_max, "max", 1},
   {f_min_by_impl, "_min_by_impl", 2},
diff --git a/src/builtin.jq b/src/builtin.jq
index 1e23a2ed66..be6003b5cd 100644
--- a/src/builtin.jq
+++ b/src/builtin.jq
@@ -213,37 +213,6 @@ def tostream:
   getpath($p) |
   reduce path(.[]?) as $q ([$p, .]; [$p+$q]);
 
-# Assuming the input array is sorted, bsearch/1 returns
-# the index of the target if the target is in the input array; and otherwise
-#  (-1 - ix), where ix is the insertion point that would leave the array sorted.
-# If the input is not sorted, bsearch will terminate but with irrelevant results.
-def bsearch($target):
-  if length == 0 then -1
-  elif length == 1 then
-     if $target == .[0] then 0 elif $target < .[0] then -1 else -2 end
-  else . as $in
-    # state variable: [start, end, answer]
-    # where start and end are the upper and lower offsets to use.
-    | [0, length-1, null]
-    | until( .[0] > .[1] ;
-             if .[2] != null then (.[1] = -1)               # i.e. break
-             else
-               ( ( (.[1] + .[0]) / 2 ) | floor ) as $mid
-               | $in[$mid] as $monkey
-               | if $monkey == $target  then (.[2] = $mid)   # success
-                 elif .[0] == .[1]     then (.[1] = -1)     # failure
-                 elif $monkey < $target then (.[0] = ($mid + 1))
-                 else (.[1] = ($mid - 1))
-                 end
-             end )
-    | if .[2] == null then          # compute the insertion point
-         if $in[ .[0] ] < $target then (-2 -.[0])
-         else (-1 -.[0])
-         end
-      else .[2]
-      end
-  end;
-
 # Apply f to composite entities recursively, and to atoms
 def walk(f):
   def w: