Split lib/support into lib/gpr and lib/gpr++.

18 files changed, 6549 insertions, 0 deletions

diff --git a/test/core/gpr/BUILD b/test/core/gpr/BUILD
new file mode 100644
index 0000000000..1be1036d04
--- /dev/null
+++ b/test/core/gpr/BUILD
@@ -0,0 +1,179 @@
+# Copyright 2016 gRPC authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+load("//bazel:grpc_build_system.bzl", "grpc_cc_library", "grpc_cc_test", "grpc_cc_binary", "grpc_package")
+
+licenses(["notice"])  # Apache v2
+
+grpc_package(name = "test/core/gpr")
+
+grpc_cc_test(
+    name = "alloc_test",
+    srcs = ["alloc_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "avl_test",
+    srcs = ["avl_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "cmdline_test",
+    srcs = ["cmdline_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "cpu_test",
+    srcs = ["cpu_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "env_test",
+    srcs = ["env_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "host_port_test",
+    srcs = ["host_port_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "log_test",
+    srcs = ["log_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "mpscq_test",
+    srcs = ["mpscq_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "murmur_hash_test",
+    srcs = ["murmur_hash_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "string_test",
+    srcs = ["string_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "spinlock_test",
+    srcs = ["spinlock_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "sync_test",
+    srcs = ["sync_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "thd_test",
+    srcs = ["thd_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "time_test",
+    srcs = ["time_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "tls_test",
+    srcs = ["tls_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
+
+grpc_cc_test(
+    name = "useful_test",
+    srcs = ["useful_test.cc"],
+    language = "C++",
+    deps = [
+        "//:gpr",
+        "//test/core/util:gpr_test_util",
+    ],
+)
diff --git a/test/core/gpr/alloc_test.cc b/test/core/gpr/alloc_test.cc
new file mode 100644
index 0000000000..6074c6e6e7
--- /dev/null
+++ b/test/core/gpr/alloc_test.cc
@@ -0,0 +1,55 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+static void* fake_malloc(size_t size) { return (void*)size; }
+
+static void* fake_realloc(void* addr, size_t size) { return (void*)size; }
+
+static void fake_free(void* addr) { *((intptr_t*)addr) = (intptr_t)0xdeadd00d; }
+
+static void test_custom_allocs() {
+  const gpr_allocation_functions default_fns = gpr_get_allocation_functions();
+  intptr_t addr_to_free = 0;
+  char* i;
+  gpr_allocation_functions fns = {fake_malloc, nullptr, fake_realloc,
+                                  fake_free};
+
+  gpr_set_allocation_functions(fns);
+  GPR_ASSERT((void*)(size_t)0xdeadbeef == gpr_malloc(0xdeadbeef));
+  GPR_ASSERT((void*)(size_t)0xcafed00d == gpr_realloc(nullptr, 0xcafed00d));
+
+  gpr_free(&addr_to_free);
+  GPR_ASSERT(addr_to_free == (intptr_t)0xdeadd00d);
+
+  /* Restore and check we don't get funky values and that we don't leak */
+  gpr_set_allocation_functions(default_fns);
+  GPR_ASSERT((void*)sizeof(*i) !=
+             (i = static_cast<char*>(gpr_malloc(sizeof(*i)))));
+  GPR_ASSERT((void*)2 != (i = static_cast<char*>(gpr_realloc(i, 2))));
+  gpr_free(i);
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  test_custom_allocs();
+  return 0;
+}
diff --git a/test/core/gpr/arena_test.cc b/test/core/gpr/arena_test.cc
new file mode 100644
index 0000000000..59ea04c0ed
--- /dev/null
+++ b/test/core/gpr/arena_test.cc
@@ -0,0 +1,129 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/gpr/arena.h"
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/useful.h>
+#include <inttypes.h>
+#include <string.h>
+
+#include "src/core/lib/gpr/string.h"
+#include "test/core/util/test_config.h"
+
+static void test_noop(void) { gpr_arena_destroy(gpr_arena_create(1)); }
+
+static void test(const char* name, size_t init_size, const size_t* allocs,
+                 size_t nallocs) {
+  gpr_strvec v;
+  char* s;
+  gpr_strvec_init(&v);
+  gpr_asprintf(&s, "test '%s': %" PRIdPTR " <- {", name, init_size);
+  gpr_strvec_add(&v, s);
+  for (size_t i = 0; i < nallocs; i++) {
+    gpr_asprintf(&s, "%" PRIdPTR ",", allocs[i]);
+    gpr_strvec_add(&v, s);
+  }
+  gpr_strvec_add(&v, gpr_strdup("}"));
+  s = gpr_strvec_flatten(&v, nullptr);
+  gpr_strvec_destroy(&v);
+  gpr_log(GPR_INFO, "%s", s);
+  gpr_free(s);
+
+  gpr_arena* a = gpr_arena_create(init_size);
+  void** ps = static_cast<void**>(gpr_zalloc(sizeof(*ps) * nallocs));
+  for (size_t i = 0; i < nallocs; i++) {
+    ps[i] = gpr_arena_alloc(a, allocs[i]);
+    // ensure no duplicate results
+    for (size_t j = 0; j < i; j++) {
+      GPR_ASSERT(ps[i] != ps[j]);
+    }
+    // ensure writable
+    memset(ps[i], 1, allocs[i]);
+  }
+  gpr_arena_destroy(a);
+  gpr_free(ps);
+}
+
+#define TEST(name, init_size, ...)                     \
+  static const size_t allocs_##name[] = {__VA_ARGS__}; \
+  test(#name, init_size, allocs_##name, GPR_ARRAY_SIZE(allocs_##name))
+
+#define CONCURRENT_TEST_THREADS 100
+
+size_t concurrent_test_iterations() {
+  if (sizeof(void*) < 8) return 1000;
+  return 100000;
+}
+
+typedef struct {
+  gpr_event ev_start;
+  gpr_arena* arena;
+} concurrent_test_args;
+
+static void concurrent_test_body(void* arg) {
+  concurrent_test_args* a = static_cast<concurrent_test_args*>(arg);
+  gpr_event_wait(&a->ev_start, gpr_inf_future(GPR_CLOCK_REALTIME));
+  for (size_t i = 0; i < concurrent_test_iterations(); i++) {
+    *(char*)gpr_arena_alloc(a->arena, 1) = (char)i;
+  }
+}
+
+static void concurrent_test(void) {
+  gpr_log(GPR_DEBUG, "concurrent_test");
+
+  concurrent_test_args args;
+  gpr_event_init(&args.ev_start);
+  args.arena = gpr_arena_create(1024);
+
+  gpr_thd_id thds[CONCURRENT_TEST_THREADS];
+
+  for (int i = 0; i < CONCURRENT_TEST_THREADS; i++) {
+    gpr_thd_options opt = gpr_thd_options_default();
+    gpr_thd_options_set_joinable(&opt);
+    gpr_thd_new(&thds[i], "grpc_concurrent_test", concurrent_test_body, &args,
+                &opt);
+  }
+
+  gpr_event_set(&args.ev_start, (void*)1);
+
+  for (int i = 0; i < CONCURRENT_TEST_THREADS; i++) {
+    gpr_thd_join(thds[i]);
+  }
+
+  gpr_arena_destroy(args.arena);
+}
+
+int main(int argc, char* argv[]) {
+  grpc_test_init(argc, argv);
+
+  test_noop();
+  TEST(0_1, 0, 1);
+  TEST(1_1, 1, 1);
+  TEST(1_2, 1, 2);
+  TEST(1_3, 1, 3);
+  TEST(1_inc, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11);
+  TEST(6_123, 6, 1, 2, 3);
+  concurrent_test();
+
+  return 0;
+}
diff --git a/test/core/gpr/avl_test.cc b/test/core/gpr/avl_test.cc
new file mode 100644
index 0000000000..345db557b9
--- /dev/null
+++ b/test/core/gpr/avl_test.cc
@@ -0,0 +1,3659 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/avl.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/useful.h>
+
+#include "test/core/util/test_config.h"
+
+static int* box(int x) {
+  int* b = static_cast<int*>(gpr_malloc(sizeof(*b)));
+  *b = x;
+  return b;
+}
+
+static long int_compare(void* int1, void* int2, void* unused) {
+  return (*(int*)int1) - (*(int*)int2);
+}
+static void* int_copy(void* p, void* unused) { return box(*(int*)p); }
+
+static void destroy(void* p, void* unused) { gpr_free(p); }
+
+static const gpr_avl_vtable int_int_vtable = {destroy, int_copy, int_compare,
+                                              destroy, int_copy};
+
+static void check_get(gpr_avl avl, int key, int value) {
+  int* k = box(key);
+  GPR_ASSERT(*(int*)gpr_avl_get(avl, k, nullptr) == value);
+  gpr_free(k);
+}
+
+static void check_negget(gpr_avl avl, int key) {
+  int* k = box(key);
+  GPR_ASSERT(gpr_avl_get(avl, k, nullptr) == nullptr);
+  gpr_free(k);
+}
+
+static gpr_avl remove_int(gpr_avl avl, int key) {
+  int* k = box(key);
+  avl = gpr_avl_remove(avl, k, nullptr);
+  gpr_free(k);
+  return avl;
+}
+
+static void test_get(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_get");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(1), box(11), nullptr);
+  avl = gpr_avl_add(avl, box(2), box(22), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(33), nullptr);
+  check_get(avl, 1, 11);
+  check_get(avl, 2, 22);
+  check_get(avl, 3, 33);
+  check_negget(avl, 4);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_ll(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_ll");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(5), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(3), nullptr);
+  GPR_ASSERT(*(int*)avl.root->key == 4);
+  GPR_ASSERT(*(int*)avl.root->left->key == 3);
+  GPR_ASSERT(*(int*)avl.root->right->key == 5);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_lr(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_lr");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(5), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(3), nullptr);
+  GPR_ASSERT(*(int*)avl.root->key == 4);
+  GPR_ASSERT(*(int*)avl.root->left->key == 3);
+  GPR_ASSERT(*(int*)avl.root->right->key == 5);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_rr(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_rr");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(3), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(5), box(3), nullptr);
+  GPR_ASSERT(*(int*)avl.root->key == 4);
+  GPR_ASSERT(*(int*)avl.root->left->key == 3);
+  GPR_ASSERT(*(int*)avl.root->right->key == 5);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_rl(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_rl");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(3), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(5), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(3), nullptr);
+  GPR_ASSERT(*(int*)avl.root->key == 4);
+  GPR_ASSERT(*(int*)avl.root->left->key == 3);
+  GPR_ASSERT(*(int*)avl.root->right->key == 5);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_unbalanced(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_unbalanced");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(5), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(3), nullptr);
+  avl = gpr_avl_add(avl, box(2), box(4), nullptr);
+  avl = gpr_avl_add(avl, box(1), box(5), nullptr);
+  GPR_ASSERT(*(int*)avl.root->key == 4);
+  GPR_ASSERT(*(int*)avl.root->left->key == 2);
+  GPR_ASSERT(*(int*)avl.root->left->left->key == 1);
+  GPR_ASSERT(*(int*)avl.root->left->right->key == 3);
+  GPR_ASSERT(*(int*)avl.root->right->key == 5);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_replace(void) {
+  gpr_avl avl;
+  gpr_log(GPR_DEBUG, "test_replace");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(1), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(1), box(2), nullptr);
+  check_get(avl, 1, 2);
+  check_negget(avl, 2);
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_remove(void) {
+  gpr_avl avl;
+  gpr_avl avl3, avl4, avl5, avln;
+  gpr_log(GPR_DEBUG, "test_remove");
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(3), box(1), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(5), box(3), nullptr);
+
+  avl3 = remove_int(gpr_avl_ref(avl, nullptr), 3);
+  avl4 = remove_int(gpr_avl_ref(avl, nullptr), 4);
+  avl5 = remove_int(gpr_avl_ref(avl, nullptr), 5);
+  avln = remove_int(gpr_avl_ref(avl, nullptr), 1);
+
+  gpr_avl_unref(avl, nullptr);
+
+  check_negget(avl3, 3);
+  check_get(avl3, 4, 2);
+  check_get(avl3, 5, 3);
+  gpr_avl_unref(avl3, nullptr);
+
+  check_get(avl4, 3, 1);
+  check_negget(avl4, 4);
+  check_get(avl4, 5, 3);
+  gpr_avl_unref(avl4, nullptr);
+
+  check_get(avl5, 3, 1);
+  check_get(avl5, 4, 2);
+  check_negget(avl5, 5);
+  gpr_avl_unref(avl5, nullptr);
+
+  check_get(avln, 3, 1);
+  check_get(avln, 4, 2);
+  check_get(avln, 5, 3);
+  gpr_avl_unref(avln, nullptr);
+}
+
+static void test_badcase1(void) {
+  gpr_avl avl;
+
+  gpr_log(GPR_DEBUG, "test_badcase1");
+
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(88), box(1), nullptr);
+  avl = remove_int(avl, 643);
+  avl = remove_int(avl, 983);
+  avl = gpr_avl_add(avl, box(985), box(4), nullptr);
+  avl = gpr_avl_add(avl, box(640), box(5), nullptr);
+  avl = gpr_avl_add(avl, box(41), box(6), nullptr);
+  avl = gpr_avl_add(avl, box(112), box(7), nullptr);
+  avl = gpr_avl_add(avl, box(342), box(8), nullptr);
+  avl = remove_int(avl, 1013);
+  avl = gpr_avl_add(avl, box(434), box(10), nullptr);
+  avl = gpr_avl_add(avl, box(520), box(11), nullptr);
+  avl = gpr_avl_add(avl, box(231), box(12), nullptr);
+  avl = gpr_avl_add(avl, box(852), box(13), nullptr);
+  avl = remove_int(avl, 461);
+  avl = gpr_avl_add(avl, box(108), box(15), nullptr);
+  avl = gpr_avl_add(avl, box(806), box(16), nullptr);
+  avl = gpr_avl_add(avl, box(827), box(17), nullptr);
+  avl = remove_int(avl, 796);
+  avl = gpr_avl_add(avl, box(340), box(19), nullptr);
+  avl = gpr_avl_add(avl, box(498), box(20), nullptr);
+  avl = gpr_avl_add(avl, box(203), box(21), nullptr);
+  avl = gpr_avl_add(avl, box(751), box(22), nullptr);
+  avl = gpr_avl_add(avl, box(150), box(23), nullptr);
+  avl = remove_int(avl, 237);
+  avl = gpr_avl_add(avl, box(830), box(25), nullptr);
+  avl = remove_int(avl, 1007);
+  avl = remove_int(avl, 394);
+  avl = gpr_avl_add(avl, box(65), box(28), nullptr);
+  avl = remove_int(avl, 904);
+  avl = remove_int(avl, 123);
+  avl = gpr_avl_add(avl, box(238), box(31), nullptr);
+  avl = gpr_avl_add(avl, box(184), box(32), nullptr);
+  avl = remove_int(avl, 331);
+  avl = gpr_avl_add(avl, box(827), box(34), nullptr);
+
+  check_get(avl, 830, 25);
+
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_badcase2(void) {
+  gpr_avl avl;
+
+  gpr_log(GPR_DEBUG, "test_badcase2");
+
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = gpr_avl_add(avl, box(288), box(1), nullptr);
+  avl = remove_int(avl, 415);
+  avl = gpr_avl_add(avl, box(953), box(3), nullptr);
+  avl = gpr_avl_add(avl, box(101), box(4), nullptr);
+  avl = gpr_avl_add(avl, box(516), box(5), nullptr);
+  avl = gpr_avl_add(avl, box(547), box(6), nullptr);
+  avl = gpr_avl_add(avl, box(467), box(7), nullptr);
+  avl = gpr_avl_add(avl, box(793), box(8), nullptr);
+  avl = remove_int(avl, 190);
+  avl = gpr_avl_add(avl, box(687), box(10), nullptr);
+  avl = gpr_avl_add(avl, box(242), box(11), nullptr);
+  avl = gpr_avl_add(avl, box(142), box(12), nullptr);
+  avl = remove_int(avl, 705);
+  avl = remove_int(avl, 578);
+  avl = remove_int(avl, 767);
+  avl = remove_int(avl, 183);
+  avl = gpr_avl_add(avl, box(950), box(17), nullptr);
+  avl = gpr_avl_add(avl, box(622), box(18), nullptr);
+  avl = remove_int(avl, 513);
+  avl = remove_int(avl, 429);
+  avl = gpr_avl_add(avl, box(205), box(21), nullptr);
+  avl = remove_int(avl, 663);
+  avl = remove_int(avl, 953);
+  avl = remove_int(avl, 892);
+  avl = gpr_avl_add(avl, box(236), box(25), nullptr);
+  avl = remove_int(avl, 982);
+  avl = remove_int(avl, 201);
+  avl = remove_int(avl, 684);
+  avl = gpr_avl_add(avl, box(572), box(29), nullptr);
+  avl = remove_int(avl, 817);
+  avl = gpr_avl_add(avl, box(970), box(31), nullptr);
+  avl = remove_int(avl, 347);
+  avl = remove_int(avl, 574);
+  avl = gpr_avl_add(avl, box(752), box(34), nullptr);
+  avl = gpr_avl_add(avl, box(670), box(35), nullptr);
+  avl = gpr_avl_add(avl, box(69), box(36), nullptr);
+  avl = remove_int(avl, 111);
+  avl = remove_int(avl, 523);
+  avl = gpr_avl_add(avl, box(141), box(39), nullptr);
+  avl = remove_int(avl, 159);
+  avl = gpr_avl_add(avl, box(947), box(41), nullptr);
+  avl = gpr_avl_add(avl, box(855), box(42), nullptr);
+  avl = remove_int(avl, 218);
+  avl = remove_int(avl, 6);
+  avl = gpr_avl_add(avl, box(753), box(45), nullptr);
+  avl = remove_int(avl, 82);
+  avl = remove_int(avl, 799);
+  avl = gpr_avl_add(avl, box(572), box(48), nullptr);
+  avl = remove_int(avl, 376);
+  avl = remove_int(avl, 413);
+  avl = gpr_avl_add(avl, box(458), box(51), nullptr);
+  avl = remove_int(avl, 897);
+  avl = gpr_avl_add(avl, box(191), box(53), nullptr);
+  avl = gpr_avl_add(avl, box(609), box(54), nullptr);
+  avl = remove_int(avl, 787);
+  avl = remove_int(avl, 710);
+  avl = remove_int(avl, 886);
+  avl = remove_int(avl, 835);
+  avl = remove_int(avl, 33);
+  avl = gpr_avl_add(avl, box(871), box(60), nullptr);
+  avl = remove_int(avl, 641);
+  avl = gpr_avl_add(avl, box(462), box(62), nullptr);
+  avl = remove_int(avl, 359);
+  avl = remove_int(avl, 767);
+  avl = gpr_avl_add(avl, box(310), box(65), nullptr);
+  avl = remove_int(avl, 757);
+  avl = remove_int(avl, 639);
+  avl = remove_int(avl, 314);
+  avl = gpr_avl_add(avl, box(2), box(69), nullptr);
+  avl = remove_int(avl, 138);
+  avl = gpr_avl_add(avl, box(669), box(71), nullptr);
+  avl = remove_int(avl, 477);
+  avl = gpr_avl_add(avl, box(366), box(73), nullptr);
+  avl = gpr_avl_add(avl, box(612), box(74), nullptr);
+  avl = gpr_avl_add(avl, box(106), box(75), nullptr);
+  avl = remove_int(avl, 161);
+  avl = gpr_avl_add(avl, box(388), box(77), nullptr);
+  avl = gpr_avl_add(avl, box(141), box(78), nullptr);
+  avl = remove_int(avl, 633);
+  avl = remove_int(avl, 459);
+  avl = gpr_avl_add(avl, box(40), box(81), nullptr);
+  avl = remove_int(avl, 689);
+  avl = gpr_avl_add(avl, box(823), box(83), nullptr);
+  avl = remove_int(avl, 485);
+  avl = gpr_avl_add(avl, box(903), box(85), nullptr);
+  avl = gpr_avl_add(avl, box(592), box(86), nullptr);
+  avl = remove_int(avl, 448);
+  avl = gpr_avl_add(avl, box(56), box(88), nullptr);
+  avl = remove_int(avl, 333);
+  avl = gpr_avl_add(avl, box(189), box(90), nullptr);
+  avl = gpr_avl_add(avl, box(103), box(91), nullptr);
+  avl = remove_int(avl, 164);
+  avl = remove_int(avl, 974);
+  avl = gpr_avl_add(avl, box(215), box(94), nullptr);
+  avl = remove_int(avl, 189);
+  avl = remove_int(avl, 504);
+  avl = gpr_avl_add(avl, box(868), box(97), nullptr);
+  avl = remove_int(avl, 909);
+  avl = remove_int(avl, 148);
+  avl = remove_int(avl, 469);
+  avl = gpr_avl_add(avl, box(994), box(101), nullptr);
+  avl = gpr_avl_add(avl, box(576), box(102), nullptr);
+  avl = remove_int(avl, 82);
+  avl = remove_int(avl, 209);
+  avl = gpr_avl_add(avl, box(276), box(105), nullptr);
+  avl = remove_int(avl, 856);
+  avl = gpr_avl_add(avl, box(750), box(107), nullptr);
+  avl = remove_int(avl, 871);
+  avl = gpr_avl_add(avl, box(301), box(109), nullptr);
+  avl = remove_int(avl, 260);
+  avl = remove_int(avl, 737);
+  avl = remove_int(avl, 719);
+  avl = gpr_avl_add(avl, box(933), box(113), nullptr);
+  avl = gpr_avl_add(avl, box(225), box(114), nullptr);
+  avl = gpr_avl_add(avl, box(975), box(115), nullptr);
+  avl = gpr_avl_add(avl, box(86), box(116), nullptr);
+  avl = remove_int(avl, 732);
+  avl = gpr_avl_add(avl, box(340), box(118), nullptr);
+  avl = gpr_avl_add(avl, box(271), box(119), nullptr);
+  avl = remove_int(avl, 206);
+  avl = gpr_avl_add(avl, box(949), box(121), nullptr);
+  avl = gpr_avl_add(avl, box(927), box(122), nullptr);
+  avl = gpr_avl_add(avl, box(34), box(123), nullptr);
+  avl = gpr_avl_add(avl, box(351), box(124), nullptr);
+  avl = remove_int(avl, 836);
+  avl = gpr_avl_add(avl, box(825), box(126), nullptr);
+  avl = gpr_avl_add(avl, box(352), box(127), nullptr);
+  avl = remove_int(avl, 107);
+  avl = remove_int(avl, 101);
+  avl = gpr_avl_add(avl, box(320), box(130), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(131), nullptr);
+  avl = remove_int(avl, 998);
+  avl = remove_int(avl, 44);
+  avl = gpr_avl_add(avl, box(525), box(134), nullptr);
+  avl = gpr_avl_add(avl, box(864), box(135), nullptr);
+  avl = gpr_avl_add(avl, box(863), box(136), nullptr);
+  avl = remove_int(avl, 770);
+  avl = gpr_avl_add(avl, box(440), box(138), nullptr);
+  avl = remove_int(avl, 516);
+  avl = gpr_avl_add(avl, box(116), box(140), nullptr);
+  avl = remove_int(avl, 380);
+  avl = gpr_avl_add(avl, box(878), box(142), nullptr);
+  avl = remove_int(avl, 439);
+  avl = gpr_avl_add(avl, box(994), box(144), nullptr);
+  avl = remove_int(avl, 294);
+  avl = remove_int(avl, 593);
+  avl = gpr_avl_add(avl, box(696), box(147), nullptr);
+  avl = remove_int(avl, 8);
+  avl = gpr_avl_add(avl, box(881), box(149), nullptr);
+  avl = remove_int(avl, 32);
+  avl = remove_int(avl, 242);
+  avl = gpr_avl_add(avl, box(487), box(152), nullptr);
+  avl = gpr_avl_add(avl, box(637), box(153), nullptr);
+  avl = gpr_avl_add(avl, box(793), box(154), nullptr);
+  avl = gpr_avl_add(avl, box(696), box(155), nullptr);
+  avl = remove_int(avl, 458);
+  avl = gpr_avl_add(avl, box(828), box(157), nullptr);
+  avl = remove_int(avl, 784);
+  avl = remove_int(avl, 274);
+  avl = gpr_avl_add(avl, box(783), box(160), nullptr);
+  avl = remove_int(avl, 21);
+  avl = gpr_avl_add(avl, box(866), box(162), nullptr);
+  avl = remove_int(avl, 919);
+  avl = gpr_avl_add(avl, box(435), box(164), nullptr);
+  avl = remove_int(avl, 385);
+  avl = gpr_avl_add(avl, box(475), box(166), nullptr);
+  avl = remove_int(avl, 339);
+  avl = gpr_avl_add(avl, box(615), box(168), nullptr);
+  avl = remove_int(avl, 866);
+  avl = remove_int(avl, 82);
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(590), box(172), nullptr);
+  avl = gpr_avl_add(avl, box(852), box(173), nullptr);
+  avl = remove_int(avl, 318);
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(672), box(176), nullptr);
+  avl = remove_int(avl, 430);
+  avl = gpr_avl_add(avl, box(821), box(178), nullptr);
+  avl = gpr_avl_add(avl, box(365), box(179), nullptr);
+  avl = remove_int(avl, 78);
+  avl = gpr_avl_add(avl, box(700), box(181), nullptr);
+  avl = gpr_avl_add(avl, box(353), box(182), nullptr);
+  avl = remove_int(avl, 492);
+  avl = gpr_avl_add(avl, box(991), box(184), nullptr);
+  avl = remove_int(avl, 330);
+  avl = gpr_avl_add(avl, box(873), box(186), nullptr);
+  avl = remove_int(avl, 589);
+  avl = gpr_avl_add(avl, box(676), box(188), nullptr);
+  avl = gpr_avl_add(avl, box(790), box(189), nullptr);
+  avl = remove_int(avl, 521);
+  avl = remove_int(avl, 47);
+  avl = gpr_avl_add(avl, box(976), box(192), nullptr);
+  avl = gpr_avl_add(avl, box(683), box(193), nullptr);
+  avl = remove_int(avl, 803);
+  avl = remove_int(avl, 1006);
+  avl = gpr_avl_add(avl, box(775), box(196), nullptr);
+  avl = gpr_avl_add(avl, box(411), box(197), nullptr);
+  avl = gpr_avl_add(avl, box(697), box(198), nullptr);
+  avl = remove_int(avl, 50);
+  avl = gpr_avl_add(avl, box(213), box(200), nullptr);
+  avl = remove_int(avl, 714);
+  avl = gpr_avl_add(avl, box(981), box(202), nullptr);
+  avl = gpr_avl_add(avl, box(502), box(203), nullptr);
+  avl = gpr_avl_add(avl, box(697), box(204), nullptr);
+  avl = gpr_avl_add(avl, box(603), box(205), nullptr);
+  avl = gpr_avl_add(avl, box(117), box(206), nullptr);
+  avl = remove_int(avl, 363);
+  avl = gpr_avl_add(avl, box(104), box(208), nullptr);
+  avl = remove_int(avl, 842);
+  avl = gpr_avl_add(avl, box(48), box(210), nullptr);
+  avl = remove_int(avl, 764);
+  avl = gpr_avl_add(avl, box(482), box(212), nullptr);
+  avl = gpr_avl_add(avl, box(928), box(213), nullptr);
+  avl = gpr_avl_add(avl, box(30), box(214), nullptr);
+  avl = gpr_avl_add(avl, box(820), box(215), nullptr);
+  avl = gpr_avl_add(avl, box(334), box(216), nullptr);
+  avl = remove_int(avl, 306);
+  avl = gpr_avl_add(avl, box(789), box(218), nullptr);
+  avl = remove_int(avl, 924);
+  avl = gpr_avl_add(avl, box(53), box(220), nullptr);
+  avl = remove_int(avl, 657);
+  avl = gpr_avl_add(avl, box(130), box(222), nullptr);
+  avl = gpr_avl_add(avl, box(239), box(223), nullptr);
+  avl = remove_int(avl, 20);
+  avl = gpr_avl_add(avl, box(117), box(225), nullptr);
+  avl = remove_int(avl, 882);
+  avl = remove_int(avl, 891);
+  avl = gpr_avl_add(avl, box(9), box(228), nullptr);
+  avl = gpr_avl_add(avl, box(496), box(229), nullptr);
+  avl = gpr_avl_add(avl, box(750), box(230), nullptr);
+  avl = gpr_avl_add(avl, box(283), box(231), nullptr);
+  avl = gpr_avl_add(avl, box(802), box(232), nullptr);
+  avl = remove_int(avl, 352);
+  avl = gpr_avl_add(avl, box(374), box(234), nullptr);
+  avl = gpr_avl_add(avl, box(6), box(235), nullptr);
+  avl = gpr_avl_add(avl, box(756), box(236), nullptr);
+  avl = gpr_avl_add(avl, box(597), box(237), nullptr);
+  avl = gpr_avl_add(avl, box(661), box(238), nullptr);
+  avl = remove_int(avl, 96);
+  avl = gpr_avl_add(avl, box(894), box(240), nullptr);
+  avl = remove_int(avl, 749);
+  avl = gpr_avl_add(avl, box(71), box(242), nullptr);
+  avl = remove_int(avl, 68);
+  avl = gpr_avl_add(avl, box(388), box(244), nullptr);
+  avl = remove_int(avl, 119);
+  avl = remove_int(avl, 856);
+  avl = gpr_avl_add(avl, box(176), box(247), nullptr);
+  avl = gpr_avl_add(avl, box(993), box(248), nullptr);
+  avl = remove_int(avl, 178);
+  avl = remove_int(avl, 781);
+  avl = remove_int(avl, 771);
+  avl = remove_int(avl, 848);
+  avl = remove_int(avl, 376);
+  avl = remove_int(avl, 157);
+  avl = remove_int(avl, 142);
+  avl = remove_int(avl, 686);
+  avl = gpr_avl_add(avl, box(779), box(257), nullptr);
+  avl = gpr_avl_add(avl, box(484), box(258), nullptr);
+  avl = remove_int(avl, 837);
+  avl = gpr_avl_add(avl, box(388), box(260), nullptr);
+  avl = remove_int(avl, 987);
+  avl = gpr_avl_add(avl, box(336), box(262), nullptr);
+  avl = remove_int(avl, 855);
+  avl = gpr_avl_add(avl, box(668), box(264), nullptr);
+  avl = remove_int(avl, 648);
+  avl = gpr_avl_add(avl, box(193), box(266), nullptr);
+  avl = remove_int(avl, 939);
+  avl = gpr_avl_add(avl, box(740), box(268), nullptr);
+  avl = gpr_avl_add(avl, box(503), box(269), nullptr);
+  avl = gpr_avl_add(avl, box(765), box(270), nullptr);
+  avl = remove_int(avl, 924);
+  avl = remove_int(avl, 513);
+  avl = gpr_avl_add(avl, box(161), box(273), nullptr);
+  avl = gpr_avl_add(avl, box(502), box(274), nullptr);
+  avl = gpr_avl_add(avl, box(846), box(275), nullptr);
+  avl = remove_int(avl, 931);
+  avl = gpr_avl_add(avl, box(87), box(277), nullptr);
+  avl = gpr_avl_add(avl, box(949), box(278), nullptr);
+  avl = gpr_avl_add(avl, box(548), box(279), nullptr);
+  avl = gpr_avl_add(avl, box(951), box(280), nullptr);
+  avl = remove_int(avl, 1018);
+  avl = remove_int(avl, 568);
+  avl = gpr_avl_add(avl, box(138), box(283), nullptr);
+  avl = gpr_avl_add(avl, box(202), box(284), nullptr);
+  avl = gpr_avl_add(avl, box(157), box(285), nullptr);
+  avl = gpr_avl_add(avl, box(264), box(286), nullptr);
+  avl = gpr_avl_add(avl, box(370), box(287), nullptr);
+  avl = remove_int(avl, 736);
+  avl = remove_int(avl, 751);
+  avl = remove_int(avl, 506);
+  avl = remove_int(avl, 81);
+  avl = remove_int(avl, 358);
+  avl = remove_int(avl, 657);
+  avl = remove_int(avl, 86);
+  avl = gpr_avl_add(avl, box(876), box(295), nullptr);
+  avl = remove_int(avl, 354);
+  avl = gpr_avl_add(avl, box(134), box(297), nullptr);
+  avl = remove_int(avl, 781);
+  avl = remove_int(avl, 183);
+  avl = gpr_avl_add(avl, box(914), box(300), nullptr);
+  avl = remove_int(avl, 926);
+  avl = remove_int(avl, 398);
+  avl = remove_int(avl, 932);
+  avl = remove_int(avl, 804);
+  avl = remove_int(avl, 326);
+  avl = gpr_avl_add(avl, box(208), box(306), nullptr);
+  avl = gpr_avl_add(avl, box(699), box(307), nullptr);
+  avl = remove_int(avl, 576);
+  avl = remove_int(avl, 850);
+  avl = remove_int(avl, 514);
+  avl = remove_int(avl, 676);
+  avl = remove_int(avl, 549);
+  avl = remove_int(avl, 767);
+  avl = gpr_avl_add(avl, box(58), box(314), nullptr);
+  avl = gpr_avl_add(avl, box(265), box(315), nullptr);
+  avl = gpr_avl_add(avl, box(268), box(316), nullptr);
+  avl = gpr_avl_add(avl, box(103), box(317), nullptr);
+  avl = gpr_avl_add(avl, box(440), box(318), nullptr);
+  avl = remove_int(avl, 777);
+  avl = gpr_avl_add(avl, box(670), box(320), nullptr);
+  avl = remove_int(avl, 506);
+  avl = remove_int(avl, 487);
+  avl = gpr_avl_add(avl, box(421), box(323), nullptr);
+  avl = remove_int(avl, 514);
+  avl = gpr_avl_add(avl, box(701), box(325), nullptr);
+  avl = remove_int(avl, 949);
+  avl = remove_int(avl, 872);
+  avl = remove_int(avl, 139);
+  avl = gpr_avl_add(avl, box(781), box(329), nullptr);
+  avl = gpr_avl_add(avl, box(543), box(330), nullptr);
+  avl = gpr_avl_add(avl, box(147), box(331), nullptr);
+  avl = remove_int(avl, 190);
+  avl = gpr_avl_add(avl, box(453), box(333), nullptr);
+  avl = remove_int(avl, 262);
+  avl = remove_int(avl, 850);
+  avl = remove_int(avl, 286);
+  avl = remove_int(avl, 787);
+  avl = gpr_avl_add(avl, box(514), box(338), nullptr);
+  avl = remove_int(avl, 812);
+  avl = gpr_avl_add(avl, box(431), box(340), nullptr);
+  avl = gpr_avl_add(avl, box(8), box(341), nullptr);
+  avl = remove_int(avl, 843);
+  avl = gpr_avl_add(avl, box(831), box(343), nullptr);
+  avl = remove_int(avl, 472);
+  avl = remove_int(avl, 157);
+  avl = gpr_avl_add(avl, box(612), box(346), nullptr);
+  avl = gpr_avl_add(avl, box(802), box(347), nullptr);
+  avl = remove_int(avl, 554);
+  avl = gpr_avl_add(avl, box(409), box(349), nullptr);
+  avl = gpr_avl_add(avl, box(439), box(350), nullptr);
+  avl = gpr_avl_add(avl, box(725), box(351), nullptr);
+  avl = gpr_avl_add(avl, box(568), box(352), nullptr);
+  avl = remove_int(avl, 475);
+  avl = remove_int(avl, 672);
+  avl = remove_int(avl, 62);
+  avl = remove_int(avl, 753);
+  avl = gpr_avl_add(avl, box(435), box(357), nullptr);
+  avl = gpr_avl_add(avl, box(950), box(358), nullptr);
+  avl = gpr_avl_add(avl, box(532), box(359), nullptr);
+  avl = gpr_avl_add(avl, box(832), box(360), nullptr);
+  avl = remove_int(avl, 390);
+  avl = gpr_avl_add(avl, box(993), box(362), nullptr);
+  avl = remove_int(avl, 198);
+  avl = remove_int(avl, 401);
+  avl = gpr_avl_add(avl, box(316), box(365), nullptr);
+  avl = remove_int(avl, 843);
+  avl = gpr_avl_add(avl, box(541), box(367), nullptr);
+  avl = gpr_avl_add(avl, box(505), box(368), nullptr);
+  avl = remove_int(avl, 445);
+  avl = remove_int(avl, 256);
+  avl = gpr_avl_add(avl, box(232), box(371), nullptr);
+  avl = remove_int(avl, 577);
+  avl = remove_int(avl, 558);
+  avl = gpr_avl_add(avl, box(910), box(374), nullptr);
+  avl = remove_int(avl, 902);
+  avl = remove_int(avl, 755);
+  avl = remove_int(avl, 114);
+  avl = remove_int(avl, 438);
+  avl = remove_int(avl, 224);
+  avl = gpr_avl_add(avl, box(920), box(380), nullptr);
+  avl = gpr_avl_add(avl, box(655), box(381), nullptr);
+  avl = remove_int(avl, 557);
+  avl = remove_int(avl, 102);
+  avl = remove_int(avl, 165);
+  avl = gpr_avl_add(avl, box(191), box(385), nullptr);
+  avl = remove_int(avl, 30);
+  avl = gpr_avl_add(avl, box(406), box(387), nullptr);
+  avl = gpr_avl_add(avl, box(66), box(388), nullptr);
+  avl = gpr_avl_add(avl, box(87), box(389), nullptr);
+  avl = remove_int(avl, 7);
+  avl = remove_int(avl, 671);
+  avl = gpr_avl_add(avl, box(234), box(392), nullptr);
+  avl = remove_int(avl, 463);
+  avl = gpr_avl_add(avl, box(75), box(394), nullptr);
+  avl = gpr_avl_add(avl, box(487), box(395), nullptr);
+  avl = remove_int(avl, 203);
+  avl = gpr_avl_add(avl, box(711), box(397), nullptr);
+  avl = remove_int(avl, 291);
+  avl = remove_int(avl, 798);
+  avl = remove_int(avl, 337);
+  avl = gpr_avl_add(avl, box(877), box(401), nullptr);
+  avl = gpr_avl_add(avl, box(388), box(402), nullptr);
+  avl = remove_int(avl, 975);
+  avl = gpr_avl_add(avl, box(200), box(404), nullptr);
+  avl = gpr_avl_add(avl, box(408), box(405), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(406), nullptr);
+  avl = gpr_avl_add(avl, box(971), box(407), nullptr);
+  avl = remove_int(avl, 841);
+  avl = remove_int(avl, 910);
+  avl = remove_int(avl, 74);
+  avl = remove_int(avl, 888);
+  avl = gpr_avl_add(avl, box(492), box(412), nullptr);
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 364);
+  avl = gpr_avl_add(avl, box(215), box(415), nullptr);
+  avl = remove_int(avl, 778);
+  avl = remove_int(avl, 45);
+  avl = gpr_avl_add(avl, box(328), box(418), nullptr);
+  avl = gpr_avl_add(avl, box(597), box(419), nullptr);
+  avl = remove_int(avl, 34);
+  avl = gpr_avl_add(avl, box(736), box(421), nullptr);
+  avl = remove_int(avl, 37);
+  avl = gpr_avl_add(avl, box(275), box(423), nullptr);
+  avl = gpr_avl_add(avl, box(70), box(424), nullptr);
+  avl = gpr_avl_add(avl, box(771), box(425), nullptr);
+  avl = remove_int(avl, 536);
+  avl = remove_int(avl, 421);
+  avl = gpr_avl_add(avl, box(186), box(428), nullptr);
+  avl = gpr_avl_add(avl, box(788), box(429), nullptr);
+  avl = gpr_avl_add(avl, box(224), box(430), nullptr);
+  avl = remove_int(avl, 228);
+  avl = gpr_avl_add(avl, box(48), box(432), nullptr);
+  avl = gpr_avl_add(avl, box(120), box(433), nullptr);
+  avl = gpr_avl_add(avl, box(269), box(434), nullptr);
+  avl = gpr_avl_add(avl, box(904), box(435), nullptr);
+  avl = remove_int(avl, 699);
+  avl = gpr_avl_add(avl, box(340), box(437), nullptr);
+  avl = remove_int(avl, 276);
+  avl = gpr_avl_add(avl, box(591), box(439), nullptr);
+  avl = gpr_avl_add(avl, box(778), box(440), nullptr);
+  avl = remove_int(avl, 490);
+  avl = remove_int(avl, 973);
+  avl = gpr_avl_add(avl, box(294), box(443), nullptr);
+  avl = gpr_avl_add(avl, box(323), box(444), nullptr);
+  avl = remove_int(avl, 685);
+  avl = gpr_avl_add(avl, box(38), box(446), nullptr);
+  avl = gpr_avl_add(avl, box(525), box(447), nullptr);
+  avl = remove_int(avl, 162);
+  avl = gpr_avl_add(avl, box(462), box(449), nullptr);
+  avl = gpr_avl_add(avl, box(340), box(450), nullptr);
+  avl = remove_int(avl, 734);
+  avl = remove_int(avl, 959);
+  avl = gpr_avl_add(avl, box(752), box(453), nullptr);
+  avl = gpr_avl_add(avl, box(667), box(454), nullptr);
+  avl = remove_int(avl, 558);
+  avl = remove_int(avl, 657);
+  avl = gpr_avl_add(avl, box(711), box(457), nullptr);
+  avl = remove_int(avl, 937);
+  avl = gpr_avl_add(avl, box(741), box(459), nullptr);
+  avl = gpr_avl_add(avl, box(40), box(460), nullptr);
+  avl = remove_int(avl, 784);
+  avl = gpr_avl_add(avl, box(292), box(462), nullptr);
+  avl = remove_int(avl, 164);
+  avl = remove_int(avl, 931);
+  avl = remove_int(avl, 886);
+  avl = gpr_avl_add(avl, box(968), box(466), nullptr);
+  avl = remove_int(avl, 263);
+  avl = gpr_avl_add(avl, box(647), box(468), nullptr);
+  avl = gpr_avl_add(avl, box(92), box(469), nullptr);
+  avl = remove_int(avl, 310);
+  avl = gpr_avl_add(avl, box(711), box(471), nullptr);
+  avl = gpr_avl_add(avl, box(675), box(472), nullptr);
+  avl = remove_int(avl, 549);
+  avl = gpr_avl_add(avl, box(380), box(474), nullptr);
+  avl = remove_int(avl, 825);
+  avl = gpr_avl_add(avl, box(668), box(476), nullptr);
+  avl = remove_int(avl, 498);
+  avl = gpr_avl_add(avl, box(870), box(478), nullptr);
+  avl = gpr_avl_add(avl, box(391), box(479), nullptr);
+  avl = gpr_avl_add(avl, box(264), box(480), nullptr);
+  avl = remove_int(avl, 1);
+  avl = remove_int(avl, 849);
+  avl = remove_int(avl, 88);
+  avl = remove_int(avl, 255);
+  avl = remove_int(avl, 763);
+  avl = remove_int(avl, 831);
+  avl = gpr_avl_add(avl, box(508), box(487), nullptr);
+  avl = remove_int(avl, 849);
+  avl = remove_int(avl, 47);
+  avl = gpr_avl_add(avl, box(299), box(490), nullptr);
+  avl = remove_int(avl, 625);
+  avl = remove_int(avl, 433);
+  avl = remove_int(avl, 904);
+  avl = remove_int(avl, 761);
+  avl = gpr_avl_add(avl, box(33), box(495), nullptr);
+  avl = gpr_avl_add(avl, box(524), box(496), nullptr);
+  avl = remove_int(avl, 210);
+  avl = remove_int(avl, 299);
+  avl = gpr_avl_add(avl, box(823), box(499), nullptr);
+  avl = remove_int(avl, 479);
+  avl = remove_int(avl, 96);
+  avl = remove_int(avl, 1013);
+  avl = gpr_avl_add(avl, box(768), box(503), nullptr);
+  avl = remove_int(avl, 638);
+  avl = remove_int(avl, 20);
+  avl = gpr_avl_add(avl, box(663), box(506), nullptr);
+  avl = remove_int(avl, 882);
+  avl = gpr_avl_add(avl, box(745), box(508), nullptr);
+  avl = remove_int(avl, 352);
+  avl = gpr_avl_add(avl, box(10), box(510), nullptr);
+  avl = remove_int(avl, 484);
+  avl = gpr_avl_add(avl, box(420), box(512), nullptr);
+  avl = gpr_avl_add(avl, box(884), box(513), nullptr);
+  avl = gpr_avl_add(avl, box(993), box(514), nullptr);
+  avl = gpr_avl_add(avl, box(251), box(515), nullptr);
+  avl = remove_int(avl, 222);
+  avl = gpr_avl_add(avl, box(734), box(517), nullptr);
+  avl = gpr_avl_add(avl, box(952), box(518), nullptr);
+  avl = remove_int(avl, 26);
+  avl = remove_int(avl, 270);
+  avl = remove_int(avl, 481);
+  avl = remove_int(avl, 693);
+  avl = remove_int(avl, 1006);
+  avl = gpr_avl_add(avl, box(77), box(524), nullptr);
+  avl = remove_int(avl, 897);
+  avl = gpr_avl_add(avl, box(719), box(526), nullptr);
+  avl = gpr_avl_add(avl, box(622), box(527), nullptr);
+  avl = remove_int(avl, 28);
+  avl = remove_int(avl, 836);
+  avl = remove_int(avl, 142);
+  avl = gpr_avl_add(avl, box(445), box(531), nullptr);
+  avl = gpr_avl_add(avl, box(410), box(532), nullptr);
+  avl = remove_int(avl, 575);
+  avl = gpr_avl_add(avl, box(634), box(534), nullptr);
+  avl = gpr_avl_add(avl, box(906), box(535), nullptr);
+  avl = remove_int(avl, 649);
+  avl = gpr_avl_add(avl, box(813), box(537), nullptr);
+  avl = remove_int(avl, 702);
+  avl = remove_int(avl, 732);
+  avl = gpr_avl_add(avl, box(105), box(540), nullptr);
+  avl = gpr_avl_add(avl, box(867), box(541), nullptr);
+  avl = remove_int(avl, 964);
+  avl = remove_int(avl, 941);
+  avl = gpr_avl_add(avl, box(947), box(544), nullptr);
+  avl = remove_int(avl, 990);
+  avl = gpr_avl_add(avl, box(816), box(546), nullptr);
+  avl = remove_int(avl, 429);
+  avl = remove_int(avl, 567);
+  avl = remove_int(avl, 541);
+  avl = remove_int(avl, 583);
+  avl = gpr_avl_add(avl, box(57), box(551), nullptr);
+  avl = gpr_avl_add(avl, box(786), box(552), nullptr);
+  avl = gpr_avl_add(avl, box(526), box(553), nullptr);
+  avl = remove_int(avl, 642);
+  avl = remove_int(avl, 220);
+  avl = remove_int(avl, 840);
+  avl = remove_int(avl, 548);
+  avl = gpr_avl_add(avl, box(528), box(558), nullptr);
+  avl = gpr_avl_add(avl, box(749), box(559), nullptr);
+  avl = gpr_avl_add(avl, box(194), box(560), nullptr);
+  avl = remove_int(avl, 517);
+  avl = gpr_avl_add(avl, box(102), box(562), nullptr);
+  avl = remove_int(avl, 189);
+  avl = gpr_avl_add(avl, box(927), box(564), nullptr);
+  avl = remove_int(avl, 846);
+  avl = remove_int(avl, 130);
+  avl = gpr_avl_add(avl, box(694), box(567), nullptr);
+  avl = remove_int(avl, 750);
+  avl = gpr_avl_add(avl, box(357), box(569), nullptr);
+  avl = remove_int(avl, 431);
+  avl = remove_int(avl, 91);
+  avl = gpr_avl_add(avl, box(640), box(572), nullptr);
+  avl = remove_int(avl, 4);
+  avl = gpr_avl_add(avl, box(81), box(574), nullptr);
+  avl = gpr_avl_add(avl, box(595), box(575), nullptr);
+  avl = remove_int(avl, 444);
+  avl = remove_int(avl, 262);
+  avl = remove_int(avl, 11);
+  avl = gpr_avl_add(avl, box(192), box(579), nullptr);
+  avl = gpr_avl_add(avl, box(158), box(580), nullptr);
+  avl = remove_int(avl, 401);
+  avl = remove_int(avl, 918);
+  avl = gpr_avl_add(avl, box(180), box(583), nullptr);
+  avl = remove_int(avl, 268);
+  avl = gpr_avl_add(avl, box(1012), box(585), nullptr);
+  avl = gpr_avl_add(avl, box(90), box(586), nullptr);
+  avl = gpr_avl_add(avl, box(946), box(587), nullptr);
+  avl = remove_int(avl, 719);
+  avl = gpr_avl_add(avl, box(874), box(589), nullptr);
+  avl = gpr_avl_add(avl, box(679), box(590), nullptr);
+  avl = remove_int(avl, 53);
+  avl = remove_int(avl, 534);
+  avl = gpr_avl_add(avl, box(646), box(593), nullptr);
+  avl = gpr_avl_add(avl, box(767), box(594), nullptr);
+  avl = gpr_avl_add(avl, box(460), box(595), nullptr);
+  avl = gpr_avl_add(avl, box(852), box(596), nullptr);
+  avl = gpr_avl_add(avl, box(189), box(597), nullptr);
+  avl = remove_int(avl, 932);
+  avl = remove_int(avl, 366);
+  avl = remove_int(avl, 907);
+  avl = gpr_avl_add(avl, box(875), box(601), nullptr);
+  avl = gpr_avl_add(avl, box(434), box(602), nullptr);
+  avl = gpr_avl_add(avl, box(704), box(603), nullptr);
+  avl = gpr_avl_add(avl, box(724), box(604), nullptr);
+  avl = gpr_avl_add(avl, box(930), box(605), nullptr);
+  avl = gpr_avl_add(avl, box(1000), box(606), nullptr);
+  avl = remove_int(avl, 479);
+  avl = gpr_avl_add(avl, box(275), box(608), nullptr);
+  avl = remove_int(avl, 32);
+  avl = gpr_avl_add(avl, box(939), box(610), nullptr);
+  avl = remove_int(avl, 943);
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(490), box(613), nullptr);
+  avl = remove_int(avl, 477);
+  avl = remove_int(avl, 414);
+  avl = remove_int(avl, 187);
+  avl = remove_int(avl, 334);
+  avl = gpr_avl_add(avl, box(40), box(618), nullptr);
+  avl = remove_int(avl, 751);
+  avl = gpr_avl_add(avl, box(568), box(620), nullptr);
+  avl = gpr_avl_add(avl, box(120), box(621), nullptr);
+  avl = gpr_avl_add(avl, box(617), box(622), nullptr);
+  avl = gpr_avl_add(avl, box(32), box(623), nullptr);
+  avl = remove_int(avl, 701);
+  avl = gpr_avl_add(avl, box(910), box(625), nullptr);
+  avl = remove_int(avl, 557);
+  avl = remove_int(avl, 361);
+  avl = remove_int(avl, 937);
+  avl = remove_int(avl, 100);
+  avl = remove_int(avl, 684);
+  avl = gpr_avl_add(avl, box(751), box(631), nullptr);
+  avl = remove_int(avl, 781);
+  avl = remove_int(avl, 469);
+  avl = remove_int(avl, 75);
+  avl = remove_int(avl, 561);
+  avl = gpr_avl_add(avl, box(854), box(636), nullptr);
+  avl = remove_int(avl, 164);
+  avl = remove_int(avl, 258);
+  avl = remove_int(avl, 315);
+  avl = remove_int(avl, 261);
+  avl = gpr_avl_add(avl, box(552), box(641), nullptr);
+  avl = gpr_avl_add(avl, box(6), box(642), nullptr);
+  avl = gpr_avl_add(avl, box(680), box(643), nullptr);
+  avl = remove_int(avl, 741);
+  avl = remove_int(avl, 309);
+  avl = remove_int(avl, 272);
+  avl = gpr_avl_add(avl, box(249), box(647), nullptr);
+  avl = remove_int(avl, 97);
+  avl = remove_int(avl, 850);
+  avl = gpr_avl_add(avl, box(915), box(650), nullptr);
+  avl = gpr_avl_add(avl, box(816), box(651), nullptr);
+  avl = gpr_avl_add(avl, box(45), box(652), nullptr);
+  avl = gpr_avl_add(avl, box(168), box(653), nullptr);
+  avl = remove_int(avl, 153);
+  avl = remove_int(avl, 239);
+  avl = gpr_avl_add(avl, box(684), box(656), nullptr);
+  avl = gpr_avl_add(avl, box(208), box(657), nullptr);
+  avl = gpr_avl_add(avl, box(681), box(658), nullptr);
+  avl = gpr_avl_add(avl, box(609), box(659), nullptr);
+  avl = gpr_avl_add(avl, box(645), box(660), nullptr);
+  avl = remove_int(avl, 799);
+  avl = gpr_avl_add(avl, box(955), box(662), nullptr);
+  avl = gpr_avl_add(avl, box(946), box(663), nullptr);
+  avl = gpr_avl_add(avl, box(744), box(664), nullptr);
+  avl = gpr_avl_add(avl, box(201), box(665), nullptr);
+  avl = gpr_avl_add(avl, box(136), box(666), nullptr);
+  avl = remove_int(avl, 357);
+  avl = gpr_avl_add(avl, box(974), box(668), nullptr);
+  avl = remove_int(avl, 485);
+  avl = gpr_avl_add(avl, box(1009), box(670), nullptr);
+  avl = gpr_avl_add(avl, box(517), box(671), nullptr);
+  avl = remove_int(avl, 491);
+  avl = gpr_avl_add(avl, box(336), box(673), nullptr);
+  avl = gpr_avl_add(avl, box(589), box(674), nullptr);
+  avl = remove_int(avl, 546);
+  avl = remove_int(avl, 840);
+  avl = remove_int(avl, 104);
+  avl = remove_int(avl, 347);
+  avl = gpr_avl_add(avl, box(801), box(679), nullptr);
+  avl = remove_int(avl, 799);
+  avl = remove_int(avl, 702);
+  avl = remove_int(avl, 996);
+  avl = remove_int(avl, 93);
+  avl = gpr_avl_add(avl, box(561), box(684), nullptr);
+  avl = gpr_avl_add(avl, box(25), box(685), nullptr);
+  avl = remove_int(avl, 278);
+  avl = gpr_avl_add(avl, box(191), box(687), nullptr);
+  avl = remove_int(avl, 243);
+  avl = remove_int(avl, 918);
+  avl = remove_int(avl, 449);
+  avl = gpr_avl_add(avl, box(19), box(691), nullptr);
+  avl = gpr_avl_add(avl, box(762), box(692), nullptr);
+  avl = gpr_avl_add(avl, box(13), box(693), nullptr);
+  avl = gpr_avl_add(avl, box(151), box(694), nullptr);
+  avl = gpr_avl_add(avl, box(152), box(695), nullptr);
+  avl = gpr_avl_add(avl, box(793), box(696), nullptr);
+  avl = remove_int(avl, 862);
+  avl = remove_int(avl, 890);
+  avl = gpr_avl_add(avl, box(687), box(699), nullptr);
+  avl = gpr_avl_add(avl, box(509), box(700), nullptr);
+  avl = gpr_avl_add(avl, box(973), box(701), nullptr);
+  avl = remove_int(avl, 230);
+  avl = gpr_avl_add(avl, box(532), box(703), nullptr);
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(281), box(705), nullptr);
+  avl = gpr_avl_add(avl, box(867), box(706), nullptr);
+  avl = gpr_avl_add(avl, box(359), box(707), nullptr);
+  avl = remove_int(avl, 425);
+  avl = gpr_avl_add(avl, box(691), box(709), nullptr);
+  avl = gpr_avl_add(avl, box(163), box(710), nullptr);
+  avl = gpr_avl_add(avl, box(502), box(711), nullptr);
+  avl = remove_int(avl, 674);
+  avl = gpr_avl_add(avl, box(697), box(713), nullptr);
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(968), box(715), nullptr);
+  avl = gpr_avl_add(avl, box(48), box(716), nullptr);
+  avl = remove_int(avl, 543);
+  avl = gpr_avl_add(avl, box(35), box(718), nullptr);
+  avl = gpr_avl_add(avl, box(751), box(719), nullptr);
+  avl = gpr_avl_add(avl, box(478), box(720), nullptr);
+  avl = remove_int(avl, 797);
+  avl = remove_int(avl, 309);
+  avl = gpr_avl_add(avl, box(927), box(723), nullptr);
+  avl = remove_int(avl, 504);
+  avl = gpr_avl_add(avl, box(286), box(725), nullptr);
+  avl = gpr_avl_add(avl, box(413), box(726), nullptr);
+  avl = gpr_avl_add(avl, box(599), box(727), nullptr);
+  avl = remove_int(avl, 105);
+  avl = remove_int(avl, 605);
+  avl = gpr_avl_add(avl, box(632), box(730), nullptr);
+  avl = gpr_avl_add(avl, box(133), box(731), nullptr);
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(958), box(733), nullptr);
+  avl = gpr_avl_add(avl, box(729), box(734), nullptr);
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(694), box(736), nullptr);
+  avl = gpr_avl_add(avl, box(505), box(737), nullptr);
+  avl = remove_int(avl, 63);
+  avl = remove_int(avl, 714);
+  avl = gpr_avl_add(avl, box(1002), box(740), nullptr);
+  avl = remove_int(avl, 211);
+  avl = gpr_avl_add(avl, box(765), box(742), nullptr);
+  avl = gpr_avl_add(avl, box(455), box(743), nullptr);
+  avl = remove_int(avl, 59);
+  avl = remove_int(avl, 224);
+  avl = gpr_avl_add(avl, box(586), box(746), nullptr);
+  avl = gpr_avl_add(avl, box(348), box(747), nullptr);
+  avl = remove_int(avl, 10);
+  avl = remove_int(avl, 484);
+  avl = gpr_avl_add(avl, box(968), box(750), nullptr);
+  avl = gpr_avl_add(avl, box(923), box(751), nullptr);
+  avl = remove_int(avl, 573);
+  avl = remove_int(avl, 617);
+  avl = gpr_avl_add(avl, box(812), box(754), nullptr);
+  avl = gpr_avl_add(avl, box(179), box(755), nullptr);
+  avl = remove_int(avl, 284);
+  avl = remove_int(avl, 157);
+  avl = remove_int(avl, 177);
+  avl = remove_int(avl, 896);
+  avl = gpr_avl_add(avl, box(649), box(760), nullptr);
+  avl = gpr_avl_add(avl, box(927), box(761), nullptr);
+  avl = gpr_avl_add(avl, box(454), box(762), nullptr);
+  avl = gpr_avl_add(avl, box(217), box(763), nullptr);
+  avl = remove_int(avl, 534);
+  avl = gpr_avl_add(avl, box(180), box(765), nullptr);
+  avl = gpr_avl_add(avl, box(319), box(766), nullptr);
+  avl = remove_int(avl, 92);
+  avl = gpr_avl_add(avl, box(483), box(768), nullptr);
+  avl = remove_int(avl, 504);
+  avl = remove_int(avl, 1017);
+  avl = remove_int(avl, 37);
+  avl = remove_int(avl, 50);
+  avl = gpr_avl_add(avl, box(302), box(773), nullptr);
+  avl = remove_int(avl, 807);
+  avl = gpr_avl_add(avl, box(463), box(775), nullptr);
+  avl = gpr_avl_add(avl, box(271), box(776), nullptr);
+  avl = gpr_avl_add(avl, box(644), box(777), nullptr);
+  avl = remove_int(avl, 618);
+  avl = gpr_avl_add(avl, box(166), box(779), nullptr);
+  avl = gpr_avl_add(avl, box(538), box(780), nullptr);
+  avl = remove_int(avl, 606);
+  avl = gpr_avl_add(avl, box(425), box(782), nullptr);
+  avl = remove_int(avl, 725);
+  avl = remove_int(avl, 383);
+  avl = gpr_avl_add(avl, box(155), box(785), nullptr);
+  avl = remove_int(avl, 889);
+  avl = gpr_avl_add(avl, box(653), box(787), nullptr);
+  avl = remove_int(avl, 386);
+  avl = gpr_avl_add(avl, box(142), box(789), nullptr);
+  avl = remove_int(avl, 107);
+  avl = remove_int(avl, 603);
+  avl = remove_int(avl, 971);
+  avl = gpr_avl_add(avl, box(80), box(793), nullptr);
+  avl = gpr_avl_add(avl, box(61), box(794), nullptr);
+  avl = gpr_avl_add(avl, box(693), box(795), nullptr);
+  avl = gpr_avl_add(avl, box(592), box(796), nullptr);
+  avl = gpr_avl_add(avl, box(433), box(797), nullptr);
+  avl = gpr_avl_add(avl, box(973), box(798), nullptr);
+  avl = remove_int(avl, 901);
+  avl = remove_int(avl, 340);
+  avl = remove_int(avl, 709);
+  avl = gpr_avl_add(avl, box(224), box(802), nullptr);
+  avl = remove_int(avl, 120);
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(780), box(805), nullptr);
+  avl = gpr_avl_add(avl, box(867), box(806), nullptr);
+  avl = gpr_avl_add(avl, box(756), box(807), nullptr);
+  avl = gpr_avl_add(avl, box(583), box(808), nullptr);
+  avl = gpr_avl_add(avl, box(356), box(809), nullptr);
+  avl = gpr_avl_add(avl, box(58), box(810), nullptr);
+  avl = remove_int(avl, 219);
+  avl = gpr_avl_add(avl, box(301), box(812), nullptr);
+  avl = remove_int(avl, 643);
+  avl = remove_int(avl, 787);
+  avl = remove_int(avl, 583);
+  avl = remove_int(avl, 552);
+  avl = remove_int(avl, 308);
+  avl = remove_int(avl, 608);
+  avl = remove_int(avl, 363);
+  avl = remove_int(avl, 690);
+  avl = gpr_avl_add(avl, box(233), box(821), nullptr);
+  avl = gpr_avl_add(avl, box(479), box(822), nullptr);
+  avl = gpr_avl_add(avl, box(323), box(823), nullptr);
+  avl = gpr_avl_add(avl, box(802), box(824), nullptr);
+  avl = remove_int(avl, 682);
+  avl = remove_int(avl, 705);
+  avl = remove_int(avl, 487);
+  avl = gpr_avl_add(avl, box(530), box(828), nullptr);
+  avl = gpr_avl_add(avl, box(232), box(829), nullptr);
+  avl = remove_int(avl, 627);
+  avl = gpr_avl_add(avl, box(396), box(831), nullptr);
+  avl = gpr_avl_add(avl, box(61), box(832), nullptr);
+  avl = gpr_avl_add(avl, box(932), box(833), nullptr);
+  avl = gpr_avl_add(avl, box(108), box(834), nullptr);
+  avl = gpr_avl_add(avl, box(524), box(835), nullptr);
+  avl = remove_int(avl, 390);
+  avl = remove_int(avl, 307);
+  avl = gpr_avl_add(avl, box(722), box(838), nullptr);
+  avl = gpr_avl_add(avl, box(907), box(839), nullptr);
+  avl = remove_int(avl, 286);
+  avl = remove_int(avl, 337);
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(973), box(843), nullptr);
+  avl = remove_int(avl, 930);
+  avl = remove_int(avl, 242);
+  avl = gpr_avl_add(avl, box(997), box(846), nullptr);
+  avl = gpr_avl_add(avl, box(689), box(847), nullptr);
+  avl = remove_int(avl, 318);
+  avl = gpr_avl_add(avl, box(703), box(849), nullptr);
+  avl = gpr_avl_add(avl, box(868), box(850), nullptr);
+  avl = gpr_avl_add(avl, box(200), box(851), nullptr);
+  avl = gpr_avl_add(avl, box(960), box(852), nullptr);
+  avl = gpr_avl_add(avl, box(80), box(853), nullptr);
+  avl = remove_int(avl, 113);
+  avl = gpr_avl_add(avl, box(135), box(855), nullptr);
+  avl = remove_int(avl, 529);
+  avl = gpr_avl_add(avl, box(366), box(857), nullptr);
+  avl = remove_int(avl, 272);
+  avl = gpr_avl_add(avl, box(921), box(859), nullptr);
+  avl = remove_int(avl, 497);
+  avl = gpr_avl_add(avl, box(712), box(861), nullptr);
+  avl = remove_int(avl, 777);
+  avl = remove_int(avl, 505);
+  avl = remove_int(avl, 974);
+  avl = remove_int(avl, 497);
+  avl = gpr_avl_add(avl, box(388), box(866), nullptr);
+  avl = gpr_avl_add(avl, box(29), box(867), nullptr);
+  avl = gpr_avl_add(avl, box(180), box(868), nullptr);
+  avl = gpr_avl_add(avl, box(983), box(869), nullptr);
+  avl = gpr_avl_add(avl, box(72), box(870), nullptr);
+  avl = gpr_avl_add(avl, box(693), box(871), nullptr);
+  avl = gpr_avl_add(avl, box(567), box(872), nullptr);
+  avl = remove_int(avl, 549);
+  avl = remove_int(avl, 351);
+  avl = gpr_avl_add(avl, box(1019), box(875), nullptr);
+  avl = remove_int(avl, 585);
+  avl = remove_int(avl, 294);
+  avl = remove_int(avl, 61);
+  avl = gpr_avl_add(avl, box(409), box(879), nullptr);
+  avl = gpr_avl_add(avl, box(984), box(880), nullptr);
+  avl = gpr_avl_add(avl, box(830), box(881), nullptr);
+  avl = remove_int(avl, 579);
+  avl = gpr_avl_add(avl, box(672), box(883), nullptr);
+  avl = remove_int(avl, 968);
+
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_badcase3(void) {
+  gpr_avl avl;
+
+  gpr_log(GPR_DEBUG, "test_badcase3");
+
+  avl = gpr_avl_create(&int_int_vtable);
+  avl = remove_int(avl, 624);
+  avl = gpr_avl_add(avl, box(59), box(2), nullptr);
+  avl = gpr_avl_add(avl, box(494), box(3), nullptr);
+  avl = gpr_avl_add(avl, box(226), box(4), nullptr);
+  avl = remove_int(avl, 524);
+  avl = gpr_avl_add(avl, box(540), box(6), nullptr);
+  avl = remove_int(avl, 1008);
+  avl = gpr_avl_add(avl, box(502), box(8), nullptr);
+  avl = remove_int(avl, 267);
+  avl = remove_int(avl, 764);
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(8), box(12), nullptr);
+  avl = remove_int(avl, 291);
+  avl = remove_int(avl, 796);
+  avl = remove_int(avl, 1002);
+  avl = gpr_avl_add(avl, box(778), box(16), nullptr);
+  avl = remove_int(avl, 621);
+  avl = remove_int(avl, 891);
+  avl = remove_int(avl, 880);
+  avl = gpr_avl_add(avl, box(197), box(20), nullptr);
+  avl = gpr_avl_add(avl, box(441), box(21), nullptr);
+  avl = gpr_avl_add(avl, box(719), box(22), nullptr);
+  avl = remove_int(avl, 109);
+  avl = gpr_avl_add(avl, box(458), box(24), nullptr);
+  avl = remove_int(avl, 86);
+  avl = gpr_avl_add(avl, box(897), box(26), nullptr);
+  avl = gpr_avl_add(avl, box(997), box(27), nullptr);
+  avl = remove_int(avl, 235);
+  avl = remove_int(avl, 425);
+  avl = remove_int(avl, 186);
+  avl = gpr_avl_add(avl, box(887), box(31), nullptr);
+  avl = gpr_avl_add(avl, box(1005), box(32), nullptr);
+  avl = gpr_avl_add(avl, box(778), box(33), nullptr);
+  avl = gpr_avl_add(avl, box(575), box(34), nullptr);
+  avl = remove_int(avl, 966);
+  avl = remove_int(avl, 1015);
+  avl = gpr_avl_add(avl, box(486), box(37), nullptr);
+  avl = gpr_avl_add(avl, box(809), box(38), nullptr);
+  avl = gpr_avl_add(avl, box(907), box(39), nullptr);
+  avl = gpr_avl_add(avl, box(971), box(40), nullptr);
+  avl = remove_int(avl, 441);
+  avl = remove_int(avl, 498);
+  avl = gpr_avl_add(avl, box(727), box(43), nullptr);
+  avl = remove_int(avl, 679);
+  avl = remove_int(avl, 740);
+  avl = remove_int(avl, 532);
+  avl = gpr_avl_add(avl, box(805), box(47), nullptr);
+  avl = remove_int(avl, 64);
+  avl = gpr_avl_add(avl, box(362), box(49), nullptr);
+  avl = gpr_avl_add(avl, box(170), box(50), nullptr);
+  avl = gpr_avl_add(avl, box(389), box(51), nullptr);
+  avl = gpr_avl_add(avl, box(689), box(52), nullptr);
+  avl = remove_int(avl, 871);
+  avl = gpr_avl_add(avl, box(447), box(54), nullptr);
+  avl = remove_int(avl, 718);
+  avl = gpr_avl_add(avl, box(724), box(56), nullptr);
+  avl = remove_int(avl, 215);
+  avl = gpr_avl_add(avl, box(550), box(58), nullptr);
+  avl = remove_int(avl, 932);
+  avl = gpr_avl_add(avl, box(47), box(60), nullptr);
+  avl = remove_int(avl, 46);
+  avl = remove_int(avl, 229);
+  avl = gpr_avl_add(avl, box(68), box(63), nullptr);
+  avl = gpr_avl_add(avl, box(387), box(64), nullptr);
+  avl = remove_int(avl, 933);
+  avl = remove_int(avl, 736);
+  avl = remove_int(avl, 719);
+  avl = gpr_avl_add(avl, box(150), box(68), nullptr);
+  avl = remove_int(avl, 875);
+  avl = remove_int(avl, 298);
+  avl = gpr_avl_add(avl, box(991), box(71), nullptr);
+  avl = remove_int(avl, 705);
+  avl = gpr_avl_add(avl, box(197), box(73), nullptr);
+  avl = gpr_avl_add(avl, box(101), box(74), nullptr);
+  avl = remove_int(avl, 436);
+  avl = gpr_avl_add(avl, box(755), box(76), nullptr);
+  avl = gpr_avl_add(avl, box(727), box(77), nullptr);
+  avl = remove_int(avl, 309);
+  avl = remove_int(avl, 253);
+  avl = gpr_avl_add(avl, box(203), box(80), nullptr);
+  avl = remove_int(avl, 231);
+  avl = gpr_avl_add(avl, box(461), box(82), nullptr);
+  avl = remove_int(avl, 316);
+  avl = remove_int(avl, 493);
+  avl = gpr_avl_add(avl, box(184), box(85), nullptr);
+  avl = remove_int(avl, 737);
+  avl = gpr_avl_add(avl, box(790), box(87), nullptr);
+  avl = gpr_avl_add(avl, box(335), box(88), nullptr);
+  avl = remove_int(avl, 649);
+  avl = gpr_avl_add(avl, box(69), box(90), nullptr);
+  avl = remove_int(avl, 585);
+  avl = remove_int(avl, 543);
+  avl = gpr_avl_add(avl, box(784), box(93), nullptr);
+  avl = gpr_avl_add(avl, box(60), box(94), nullptr);
+  avl = gpr_avl_add(avl, box(525), box(95), nullptr);
+  avl = gpr_avl_add(avl, box(177), box(96), nullptr);
+  avl = gpr_avl_add(avl, box(178), box(97), nullptr);
+  avl = gpr_avl_add(avl, box(683), box(98), nullptr);
+  avl = gpr_avl_add(avl, box(226), box(99), nullptr);
+  avl = gpr_avl_add(avl, box(662), box(100), nullptr);
+  avl = remove_int(avl, 944);
+  avl = gpr_avl_add(avl, box(562), box(102), nullptr);
+  avl = gpr_avl_add(avl, box(793), box(103), nullptr);
+  avl = remove_int(avl, 673);
+  avl = gpr_avl_add(avl, box(310), box(105), nullptr);
+  avl = remove_int(avl, 479);
+  avl = remove_int(avl, 543);
+  avl = remove_int(avl, 159);
+  avl = remove_int(avl, 850);
+  avl = gpr_avl_add(avl, box(318), box(110), nullptr);
+  avl = gpr_avl_add(avl, box(483), box(111), nullptr);
+  avl = gpr_avl_add(avl, box(84), box(112), nullptr);
+  avl = remove_int(avl, 109);
+  avl = gpr_avl_add(avl, box(132), box(114), nullptr);
+  avl = gpr_avl_add(avl, box(920), box(115), nullptr);
+  avl = remove_int(avl, 746);
+  avl = gpr_avl_add(avl, box(145), box(117), nullptr);
+  avl = gpr_avl_add(avl, box(526), box(118), nullptr);
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(332), box(120), nullptr);
+  avl = gpr_avl_add(avl, box(918), box(121), nullptr);
+  avl = remove_int(avl, 339);
+  avl = gpr_avl_add(avl, box(809), box(123), nullptr);
+  avl = gpr_avl_add(avl, box(742), box(124), nullptr);
+  avl = gpr_avl_add(avl, box(718), box(125), nullptr);
+  avl = remove_int(avl, 988);
+  avl = remove_int(avl, 531);
+  avl = remove_int(avl, 840);
+  avl = gpr_avl_add(avl, box(816), box(129), nullptr);
+  avl = gpr_avl_add(avl, box(976), box(130), nullptr);
+  avl = remove_int(avl, 743);
+  avl = remove_int(avl, 528);
+  avl = remove_int(avl, 982);
+  avl = gpr_avl_add(avl, box(803), box(134), nullptr);
+  avl = gpr_avl_add(avl, box(205), box(135), nullptr);
+  avl = gpr_avl_add(avl, box(584), box(136), nullptr);
+  avl = remove_int(avl, 923);
+  avl = remove_int(avl, 538);
+  avl = remove_int(avl, 398);
+  avl = remove_int(avl, 320);
+  avl = remove_int(avl, 292);
+  avl = gpr_avl_add(avl, box(270), box(142), nullptr);
+  avl = gpr_avl_add(avl, box(333), box(143), nullptr);
+  avl = remove_int(avl, 439);
+  avl = gpr_avl_add(avl, box(35), box(145), nullptr);
+  avl = gpr_avl_add(avl, box(837), box(146), nullptr);
+  avl = remove_int(avl, 65);
+  avl = remove_int(avl, 642);
+  avl = remove_int(avl, 371);
+  avl = remove_int(avl, 140);
+  avl = remove_int(avl, 533);
+  avl = remove_int(avl, 676);
+  avl = gpr_avl_add(avl, box(624), box(153), nullptr);
+  avl = gpr_avl_add(avl, box(116), box(154), nullptr);
+  avl = gpr_avl_add(avl, box(446), box(155), nullptr);
+  avl = remove_int(avl, 91);
+  avl = remove_int(avl, 721);
+  avl = remove_int(avl, 537);
+  avl = gpr_avl_add(avl, box(448), box(159), nullptr);
+  avl = remove_int(avl, 155);
+  avl = remove_int(avl, 344);
+  avl = remove_int(avl, 237);
+  avl = gpr_avl_add(avl, box(309), box(163), nullptr);
+  avl = gpr_avl_add(avl, box(434), box(164), nullptr);
+  avl = gpr_avl_add(avl, box(277), box(165), nullptr);
+  avl = remove_int(avl, 233);
+  avl = gpr_avl_add(avl, box(275), box(167), nullptr);
+  avl = gpr_avl_add(avl, box(218), box(168), nullptr);
+  avl = gpr_avl_add(avl, box(76), box(169), nullptr);
+  avl = gpr_avl_add(avl, box(898), box(170), nullptr);
+  avl = remove_int(avl, 771);
+  avl = gpr_avl_add(avl, box(237), box(172), nullptr);
+  avl = remove_int(avl, 327);
+  avl = gpr_avl_add(avl, box(499), box(174), nullptr);
+  avl = remove_int(avl, 727);
+  avl = remove_int(avl, 234);
+  avl = remove_int(avl, 623);
+  avl = remove_int(avl, 458);
+  avl = remove_int(avl, 326);
+  avl = remove_int(avl, 589);
+  avl = gpr_avl_add(avl, box(442), box(181), nullptr);
+  avl = remove_int(avl, 389);
+  avl = gpr_avl_add(avl, box(708), box(183), nullptr);
+  avl = gpr_avl_add(avl, box(594), box(184), nullptr);
+  avl = gpr_avl_add(avl, box(942), box(185), nullptr);
+  avl = gpr_avl_add(avl, box(282), box(186), nullptr);
+  avl = remove_int(avl, 434);
+  avl = remove_int(avl, 134);
+  avl = remove_int(avl, 270);
+  avl = remove_int(avl, 512);
+  avl = remove_int(avl, 265);
+  avl = remove_int(avl, 21);
+  avl = remove_int(avl, 193);
+  avl = remove_int(avl, 797);
+  avl = remove_int(avl, 347);
+  avl = gpr_avl_add(avl, box(99), box(196), nullptr);
+  avl = gpr_avl_add(avl, box(161), box(197), nullptr);
+  avl = remove_int(avl, 484);
+  avl = gpr_avl_add(avl, box(72), box(199), nullptr);
+  avl = remove_int(avl, 629);
+  avl = gpr_avl_add(avl, box(522), box(201), nullptr);
+  avl = remove_int(avl, 679);
+  avl = gpr_avl_add(avl, box(407), box(203), nullptr);
+  avl = remove_int(avl, 693);
+  avl = gpr_avl_add(avl, box(424), box(205), nullptr);
+  avl = gpr_avl_add(avl, box(651), box(206), nullptr);
+  avl = gpr_avl_add(avl, box(927), box(207), nullptr);
+  avl = remove_int(avl, 553);
+  avl = gpr_avl_add(avl, box(128), box(209), nullptr);
+  avl = gpr_avl_add(avl, box(616), box(210), nullptr);
+  avl = gpr_avl_add(avl, box(690), box(211), nullptr);
+  avl = remove_int(avl, 241);
+  avl = remove_int(avl, 179);
+  avl = gpr_avl_add(avl, box(697), box(214), nullptr);
+  avl = remove_int(avl, 779);
+  avl = gpr_avl_add(avl, box(241), box(216), nullptr);
+  avl = remove_int(avl, 190);
+  avl = remove_int(avl, 210);
+  avl = gpr_avl_add(avl, box(711), box(219), nullptr);
+  avl = remove_int(avl, 251);
+  avl = remove_int(avl, 61);
+  avl = gpr_avl_add(avl, box(800), box(222), nullptr);
+  avl = remove_int(avl, 551);
+  avl = gpr_avl_add(avl, box(61), box(224), nullptr);
+  avl = gpr_avl_add(avl, box(656), box(225), nullptr);
+  avl = remove_int(avl, 130);
+  avl = remove_int(avl, 368);
+  avl = remove_int(avl, 150);
+  avl = remove_int(avl, 73);
+  avl = gpr_avl_add(avl, box(799), box(230), nullptr);
+  avl = gpr_avl_add(avl, box(125), box(231), nullptr);
+  avl = remove_int(avl, 107);
+  avl = gpr_avl_add(avl, box(938), box(233), nullptr);
+  avl = gpr_avl_add(avl, box(914), box(234), nullptr);
+  avl = gpr_avl_add(avl, box(197), box(235), nullptr);
+  avl = remove_int(avl, 736);
+  avl = gpr_avl_add(avl, box(20), box(237), nullptr);
+  avl = remove_int(avl, 224);
+  avl = remove_int(avl, 841);
+  avl = gpr_avl_add(avl, box(226), box(240), nullptr);
+  avl = remove_int(avl, 963);
+  avl = remove_int(avl, 796);
+  avl = remove_int(avl, 728);
+  avl = gpr_avl_add(avl, box(855), box(244), nullptr);
+  avl = gpr_avl_add(avl, box(769), box(245), nullptr);
+  avl = gpr_avl_add(avl, box(631), box(246), nullptr);
+  avl = remove_int(avl, 648);
+  avl = gpr_avl_add(avl, box(187), box(248), nullptr);
+  avl = gpr_avl_add(avl, box(31), box(249), nullptr);
+  avl = remove_int(avl, 163);
+  avl = gpr_avl_add(avl, box(218), box(251), nullptr);
+  avl = gpr_avl_add(avl, box(488), box(252), nullptr);
+  avl = gpr_avl_add(avl, box(387), box(253), nullptr);
+  avl = gpr_avl_add(avl, box(809), box(254), nullptr);
+  avl = gpr_avl_add(avl, box(997), box(255), nullptr);
+  avl = remove_int(avl, 678);
+  avl = gpr_avl_add(avl, box(368), box(257), nullptr);
+  avl = gpr_avl_add(avl, box(220), box(258), nullptr);
+  avl = gpr_avl_add(avl, box(373), box(259), nullptr);
+  avl = remove_int(avl, 874);
+  avl = remove_int(avl, 682);
+  avl = remove_int(avl, 1014);
+  avl = remove_int(avl, 195);
+  avl = gpr_avl_add(avl, box(868), box(264), nullptr);
+  avl = remove_int(avl, 254);
+  avl = remove_int(avl, 456);
+  avl = gpr_avl_add(avl, box(906), box(267), nullptr);
+  avl = remove_int(avl, 711);
+  avl = gpr_avl_add(avl, box(632), box(269), nullptr);
+  avl = remove_int(avl, 474);
+  avl = gpr_avl_add(avl, box(508), box(271), nullptr);
+  avl = gpr_avl_add(avl, box(518), box(272), nullptr);
+  avl = remove_int(avl, 579);
+  avl = remove_int(avl, 948);
+  avl = gpr_avl_add(avl, box(789), box(275), nullptr);
+  avl = gpr_avl_add(avl, box(48), box(276), nullptr);
+  avl = gpr_avl_add(avl, box(256), box(277), nullptr);
+  avl = gpr_avl_add(avl, box(754), box(278), nullptr);
+  avl = remove_int(avl, 215);
+  avl = gpr_avl_add(avl, box(679), box(280), nullptr);
+  avl = gpr_avl_add(avl, box(606), box(281), nullptr);
+  avl = remove_int(avl, 941);
+  avl = remove_int(avl, 31);
+  avl = gpr_avl_add(avl, box(758), box(284), nullptr);
+  avl = remove_int(avl, 101);
+  avl = gpr_avl_add(avl, box(244), box(286), nullptr);
+  avl = gpr_avl_add(avl, box(337), box(287), nullptr);
+  avl = gpr_avl_add(avl, box(461), box(288), nullptr);
+  avl = remove_int(avl, 476);
+  avl = gpr_avl_add(avl, box(845), box(290), nullptr);
+  avl = remove_int(avl, 160);
+  avl = gpr_avl_add(avl, box(690), box(292), nullptr);
+  avl = remove_int(avl, 931);
+  avl = gpr_avl_add(avl, box(869), box(294), nullptr);
+  avl = gpr_avl_add(avl, box(1019), box(295), nullptr);
+  avl = remove_int(avl, 591);
+  avl = remove_int(avl, 635);
+  avl = remove_int(avl, 67);
+  avl = gpr_avl_add(avl, box(113), box(299), nullptr);
+  avl = remove_int(avl, 305);
+  avl = gpr_avl_add(avl, box(10), box(301), nullptr);
+  avl = remove_int(avl, 823);
+  avl = remove_int(avl, 288);
+  avl = remove_int(avl, 239);
+  avl = gpr_avl_add(avl, box(646), box(305), nullptr);
+  avl = gpr_avl_add(avl, box(1006), box(306), nullptr);
+  avl = gpr_avl_add(avl, box(954), box(307), nullptr);
+  avl = gpr_avl_add(avl, box(199), box(308), nullptr);
+  avl = gpr_avl_add(avl, box(69), box(309), nullptr);
+  avl = gpr_avl_add(avl, box(984), box(310), nullptr);
+  avl = remove_int(avl, 568);
+  avl = remove_int(avl, 666);
+  avl = remove_int(avl, 37);
+  avl = gpr_avl_add(avl, box(845), box(314), nullptr);
+  avl = remove_int(avl, 535);
+  avl = remove_int(avl, 365);
+  avl = remove_int(avl, 676);
+  avl = remove_int(avl, 892);
+  avl = remove_int(avl, 425);
+  avl = remove_int(avl, 704);
+  avl = remove_int(avl, 168);
+  avl = gpr_avl_add(avl, box(853), box(322), nullptr);
+  avl = gpr_avl_add(avl, box(335), box(323), nullptr);
+  avl = gpr_avl_add(avl, box(961), box(324), nullptr);
+  avl = gpr_avl_add(avl, box(73), box(325), nullptr);
+  avl = remove_int(avl, 469);
+  avl = gpr_avl_add(avl, box(449), box(327), nullptr);
+  avl = remove_int(avl, 821);
+  avl = gpr_avl_add(avl, box(845), box(329), nullptr);
+  avl = remove_int(avl, 637);
+  avl = gpr_avl_add(avl, box(769), box(331), nullptr);
+  avl = gpr_avl_add(avl, box(901), box(332), nullptr);
+  avl = remove_int(avl, 142);
+  avl = remove_int(avl, 361);
+  avl = remove_int(avl, 876);
+  avl = gpr_avl_add(avl, box(614), box(336), nullptr);
+  avl = gpr_avl_add(avl, box(729), box(337), nullptr);
+  avl = remove_int(avl, 120);
+  avl = remove_int(avl, 473);
+  avl = remove_int(avl, 445);
+  avl = gpr_avl_add(avl, box(978), box(341), nullptr);
+  avl = gpr_avl_add(avl, box(164), box(342), nullptr);
+  avl = gpr_avl_add(avl, box(1), box(343), nullptr);
+  avl = remove_int(avl, 890);
+  avl = gpr_avl_add(avl, box(605), box(345), nullptr);
+  avl = gpr_avl_add(avl, box(178), box(346), nullptr);
+  avl = gpr_avl_add(avl, box(481), box(347), nullptr);
+  avl = gpr_avl_add(avl, box(772), box(348), nullptr);
+  avl = remove_int(avl, 824);
+  avl = remove_int(avl, 167);
+  avl = remove_int(avl, 151);
+  avl = gpr_avl_add(avl, box(698), box(352), nullptr);
+  avl = gpr_avl_add(avl, box(202), box(353), nullptr);
+  avl = gpr_avl_add(avl, box(921), box(354), nullptr);
+  avl = gpr_avl_add(avl, box(875), box(355), nullptr);
+  avl = remove_int(avl, 197);
+  avl = remove_int(avl, 232);
+  avl = gpr_avl_add(avl, box(209), box(358), nullptr);
+  avl = remove_int(avl, 324);
+  avl = remove_int(avl, 56);
+  avl = remove_int(avl, 579);
+  avl = remove_int(avl, 255);
+  avl = remove_int(avl, 290);
+  avl = gpr_avl_add(avl, box(661), box(364), nullptr);
+  avl = gpr_avl_add(avl, box(113), box(365), nullptr);
+  avl = remove_int(avl, 767);
+  avl = gpr_avl_add(avl, box(586), box(367), nullptr);
+  avl = gpr_avl_add(avl, box(121), box(368), nullptr);
+  avl = remove_int(avl, 235);
+  avl = remove_int(avl, 439);
+  avl = remove_int(avl, 360);
+  avl = gpr_avl_add(avl, box(916), box(372), nullptr);
+  avl = remove_int(avl, 999);
+  avl = gpr_avl_add(avl, box(825), box(374), nullptr);
+  avl = gpr_avl_add(avl, box(177), box(375), nullptr);
+  avl = remove_int(avl, 204);
+  avl = remove_int(avl, 92);
+  avl = gpr_avl_add(avl, box(794), box(378), nullptr);
+  avl = gpr_avl_add(avl, box(463), box(379), nullptr);
+  avl = gpr_avl_add(avl, box(472), box(380), nullptr);
+  avl = remove_int(avl, 235);
+  avl = gpr_avl_add(avl, box(840), box(382), nullptr);
+  avl = remove_int(avl, 657);
+  avl = gpr_avl_add(avl, box(586), box(384), nullptr);
+  avl = gpr_avl_add(avl, box(979), box(385), nullptr);
+  avl = remove_int(avl, 979);
+  avl = gpr_avl_add(avl, box(639), box(387), nullptr);
+  avl = remove_int(avl, 907);
+  avl = remove_int(avl, 973);
+  avl = gpr_avl_add(avl, box(913), box(390), nullptr);
+  avl = gpr_avl_add(avl, box(566), box(391), nullptr);
+  avl = gpr_avl_add(avl, box(883), box(392), nullptr);
+  avl = gpr_avl_add(avl, box(552), box(393), nullptr);
+  avl = gpr_avl_add(avl, box(16), box(394), nullptr);
+  avl = remove_int(avl, 60);
+  avl = gpr_avl_add(avl, box(567), box(396), nullptr);
+  avl = gpr_avl_add(avl, box(705), box(397), nullptr);
+  avl = gpr_avl_add(avl, box(94), box(398), nullptr);
+  avl = remove_int(avl, 321);
+  avl = gpr_avl_add(avl, box(207), box(400), nullptr);
+  avl = gpr_avl_add(avl, box(682), box(401), nullptr);
+  avl = gpr_avl_add(avl, box(592), box(402), nullptr);
+  avl = gpr_avl_add(avl, box(10), box(403), nullptr);
+  avl = remove_int(avl, 911);
+  avl = remove_int(avl, 161);
+  avl = gpr_avl_add(avl, box(86), box(406), nullptr);
+  avl = remove_int(avl, 893);
+  avl = remove_int(avl, 362);
+  avl = gpr_avl_add(avl, box(599), box(409), nullptr);
+  avl = remove_int(avl, 413);
+  avl = gpr_avl_add(avl, box(867), box(411), nullptr);
+  avl = remove_int(avl, 955);
+  avl = gpr_avl_add(avl, box(341), box(413), nullptr);
+  avl = gpr_avl_add(avl, box(887), box(414), nullptr);
+  avl = remove_int(avl, 706);
+  avl = gpr_avl_add(avl, box(939), box(416), nullptr);
+  avl = remove_int(avl, 233);
+  avl = remove_int(avl, 662);
+  avl = remove_int(avl, 984);
+  avl = remove_int(avl, 203);
+  avl = gpr_avl_add(avl, box(326), box(421), nullptr);
+  avl = remove_int(avl, 848);
+  avl = gpr_avl_add(avl, box(235), box(423), nullptr);
+  avl = remove_int(avl, 617);
+  avl = gpr_avl_add(avl, box(565), box(425), nullptr);
+  avl = remove_int(avl, 469);
+  avl = gpr_avl_add(avl, box(988), box(427), nullptr);
+  avl = remove_int(avl, 957);
+  avl = gpr_avl_add(avl, box(426), box(429), nullptr);
+  avl = remove_int(avl, 967);
+  avl = gpr_avl_add(avl, box(890), box(431), nullptr);
+  avl = gpr_avl_add(avl, box(473), box(432), nullptr);
+  avl = remove_int(avl, 367);
+  avl = remove_int(avl, 344);
+  avl = remove_int(avl, 660);
+  avl = remove_int(avl, 448);
+  avl = remove_int(avl, 837);
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(459), box(439), nullptr);
+  avl = remove_int(avl, 882);
+  avl = remove_int(avl, 782);
+  avl = gpr_avl_add(avl, box(408), box(442), nullptr);
+  avl = gpr_avl_add(avl, box(728), box(443), nullptr);
+  avl = remove_int(avl, 27);
+  avl = gpr_avl_add(avl, box(137), box(445), nullptr);
+  avl = gpr_avl_add(avl, box(239), box(446), nullptr);
+  avl = remove_int(avl, 854);
+  avl = gpr_avl_add(avl, box(104), box(448), nullptr);
+  avl = gpr_avl_add(avl, box(823), box(449), nullptr);
+  avl = gpr_avl_add(avl, box(524), box(450), nullptr);
+  avl = gpr_avl_add(avl, box(995), box(451), nullptr);
+  avl = remove_int(avl, 422);
+  avl = remove_int(avl, 220);
+  avl = gpr_avl_add(avl, box(856), box(454), nullptr);
+  avl = remove_int(avl, 332);
+  avl = gpr_avl_add(avl, box(679), box(456), nullptr);
+  avl = remove_int(avl, 18);
+  avl = gpr_avl_add(avl, box(837), box(458), nullptr);
+  avl = remove_int(avl, 405);
+  avl = remove_int(avl, 877);
+  avl = remove_int(avl, 835);
+  avl = gpr_avl_add(avl, box(547), box(462), nullptr);
+  avl = remove_int(avl, 805);
+  avl = remove_int(avl, 862);
+  avl = gpr_avl_add(avl, box(75), box(465), nullptr);
+  avl = remove_int(avl, 41);
+  avl = gpr_avl_add(avl, box(310), box(467), nullptr);
+  avl = remove_int(avl, 855);
+  avl = gpr_avl_add(avl, box(20), box(469), nullptr);
+  avl = remove_int(avl, 186);
+  avl = remove_int(avl, 378);
+  avl = remove_int(avl, 442);
+  avl = remove_int(avl, 930);
+  avl = gpr_avl_add(avl, box(118), box(474), nullptr);
+  avl = gpr_avl_add(avl, box(96), box(475), nullptr);
+  avl = remove_int(avl, 854);
+  avl = gpr_avl_add(avl, box(65), box(477), nullptr);
+  avl = gpr_avl_add(avl, box(573), box(478), nullptr);
+  avl = gpr_avl_add(avl, box(4), box(479), nullptr);
+  avl = gpr_avl_add(avl, box(451), box(480), nullptr);
+  avl = gpr_avl_add(avl, box(774), box(481), nullptr);
+  avl = gpr_avl_add(avl, box(126), box(482), nullptr);
+  avl = remove_int(avl, 956);
+  avl = remove_int(avl, 591);
+  avl = remove_int(avl, 644);
+  avl = gpr_avl_add(avl, box(304), box(486), nullptr);
+  avl = remove_int(avl, 620);
+  avl = remove_int(avl, 394);
+  avl = gpr_avl_add(avl, box(1002), box(489), nullptr);
+  avl = gpr_avl_add(avl, box(837), box(490), nullptr);
+  avl = remove_int(avl, 485);
+  avl = gpr_avl_add(avl, box(1005), box(492), nullptr);
+  avl = remove_int(avl, 21);
+  avl = gpr_avl_add(avl, box(396), box(494), nullptr);
+  avl = remove_int(avl, 966);
+  avl = gpr_avl_add(avl, box(105), box(496), nullptr);
+  avl = gpr_avl_add(avl, box(316), box(497), nullptr);
+  avl = remove_int(avl, 776);
+  avl = gpr_avl_add(avl, box(188), box(499), nullptr);
+  avl = remove_int(avl, 200);
+  avl = gpr_avl_add(avl, box(98), box(501), nullptr);
+  avl = gpr_avl_add(avl, box(831), box(502), nullptr);
+  avl = gpr_avl_add(avl, box(227), box(503), nullptr);
+  avl = gpr_avl_add(avl, box(220), box(504), nullptr);
+  avl = remove_int(avl, 715);
+  avl = remove_int(avl, 279);
+  avl = gpr_avl_add(avl, box(701), box(507), nullptr);
+  avl = gpr_avl_add(avl, box(726), box(508), nullptr);
+  avl = gpr_avl_add(avl, box(815), box(509), nullptr);
+  avl = gpr_avl_add(avl, box(749), box(510), nullptr);
+  avl = remove_int(avl, 946);
+  avl = remove_int(avl, 449);
+  avl = remove_int(avl, 62);
+  avl = remove_int(avl, 487);
+  avl = gpr_avl_add(avl, box(545), box(515), nullptr);
+  avl = remove_int(avl, 59);
+  avl = gpr_avl_add(avl, box(168), box(517), nullptr);
+  avl = remove_int(avl, 337);
+  avl = gpr_avl_add(avl, box(69), box(519), nullptr);
+  avl = remove_int(avl, 600);
+  avl = gpr_avl_add(avl, box(591), box(521), nullptr);
+  avl = gpr_avl_add(avl, box(960), box(522), nullptr);
+  avl = gpr_avl_add(avl, box(116), box(523), nullptr);
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(760), box(525), nullptr);
+  avl = gpr_avl_add(avl, box(664), box(526), nullptr);
+  avl = gpr_avl_add(avl, box(547), box(527), nullptr);
+  avl = remove_int(avl, 922);
+  avl = gpr_avl_add(avl, box(290), box(529), nullptr);
+  avl = gpr_avl_add(avl, box(859), box(530), nullptr);
+  avl = gpr_avl_add(avl, box(49), box(531), nullptr);
+  avl = remove_int(avl, 455);
+  avl = remove_int(avl, 786);
+  avl = gpr_avl_add(avl, box(613), box(534), nullptr);
+  avl = gpr_avl_add(avl, box(326), box(535), nullptr);
+  avl = remove_int(avl, 615);
+  avl = gpr_avl_add(avl, box(45), box(537), nullptr);
+  avl = gpr_avl_add(avl, box(162), box(538), nullptr);
+  avl = gpr_avl_add(avl, box(189), box(539), nullptr);
+  avl = remove_int(avl, 68);
+  avl = remove_int(avl, 846);
+  avl = gpr_avl_add(avl, box(608), box(542), nullptr);
+  avl = remove_int(avl, 821);
+  avl = gpr_avl_add(avl, box(978), box(544), nullptr);
+  avl = gpr_avl_add(avl, box(892), box(545), nullptr);
+  avl = remove_int(avl, 924);
+  avl = gpr_avl_add(avl, box(708), box(547), nullptr);
+  avl = remove_int(avl, 135);
+  avl = remove_int(avl, 124);
+  avl = gpr_avl_add(avl, box(301), box(550), nullptr);
+  avl = gpr_avl_add(avl, box(939), box(551), nullptr);
+  avl = gpr_avl_add(avl, box(344), box(552), nullptr);
+  avl = remove_int(avl, 443);
+  avl = remove_int(avl, 122);
+  avl = gpr_avl_add(avl, box(636), box(555), nullptr);
+  avl = remove_int(avl, 558);
+  avl = gpr_avl_add(avl, box(923), box(557), nullptr);
+  avl = remove_int(avl, 827);
+  avl = gpr_avl_add(avl, box(649), box(559), nullptr);
+  avl = gpr_avl_add(avl, box(808), box(560), nullptr);
+  avl = remove_int(avl, 570);
+  avl = remove_int(avl, 434);
+  avl = gpr_avl_add(avl, box(40), box(563), nullptr);
+  avl = gpr_avl_add(avl, box(725), box(564), nullptr);
+  avl = remove_int(avl, 295);
+  avl = remove_int(avl, 615);
+  avl = remove_int(avl, 919);
+  avl = remove_int(avl, 170);
+  avl = remove_int(avl, 442);
+  avl = remove_int(avl, 971);
+  avl = gpr_avl_add(avl, box(483), box(571), nullptr);
+  avl = gpr_avl_add(avl, box(512), box(572), nullptr);
+  avl = remove_int(avl, 648);
+  avl = remove_int(avl, 78);
+  avl = remove_int(avl, 72);
+  avl = remove_int(avl, 790);
+  avl = remove_int(avl, 571);
+  avl = gpr_avl_add(avl, box(898), box(578), nullptr);
+  avl = remove_int(avl, 770);
+  avl = remove_int(avl, 776);
+  avl = gpr_avl_add(avl, box(602), box(581), nullptr);
+  avl = remove_int(avl, 251);
+  avl = gpr_avl_add(avl, box(303), box(583), nullptr);
+  avl = remove_int(avl, 837);
+  avl = gpr_avl_add(avl, box(714), box(585), nullptr);
+  avl = remove_int(avl, 800);
+  avl = gpr_avl_add(avl, box(266), box(587), nullptr);
+  avl = gpr_avl_add(avl, box(555), box(588), nullptr);
+  avl = remove_int(avl, 604);
+  avl = remove_int(avl, 163);
+  avl = remove_int(avl, 497);
+  avl = gpr_avl_add(avl, box(296), box(592), nullptr);
+  avl = remove_int(avl, 129);
+  avl = gpr_avl_add(avl, box(656), box(594), nullptr);
+  avl = remove_int(avl, 769);
+  avl = remove_int(avl, 941);
+  avl = gpr_avl_add(avl, box(775), box(597), nullptr);
+  avl = gpr_avl_add(avl, box(846), box(598), nullptr);
+  avl = remove_int(avl, 591);
+  avl = remove_int(avl, 801);
+  avl = remove_int(avl, 419);
+  avl = remove_int(avl, 455);
+  avl = gpr_avl_add(avl, box(866), box(603), nullptr);
+  avl = gpr_avl_add(avl, box(575), box(604), nullptr);
+  avl = gpr_avl_add(avl, box(620), box(605), nullptr);
+  avl = remove_int(avl, 100);
+  avl = remove_int(avl, 667);
+  avl = gpr_avl_add(avl, box(138), box(608), nullptr);
+  avl = gpr_avl_add(avl, box(566), box(609), nullptr);
+  avl = gpr_avl_add(avl, box(673), box(610), nullptr);
+  avl = gpr_avl_add(avl, box(178), box(611), nullptr);
+  avl = remove_int(avl, 659);
+  avl = gpr_avl_add(avl, box(759), box(613), nullptr);
+  avl = gpr_avl_add(avl, box(1008), box(614), nullptr);
+  avl = remove_int(avl, 116);
+  avl = gpr_avl_add(avl, box(608), box(616), nullptr);
+  avl = gpr_avl_add(avl, box(339), box(617), nullptr);
+  avl = gpr_avl_add(avl, box(197), box(618), nullptr);
+  avl = remove_int(avl, 25);
+  avl = remove_int(avl, 628);
+  avl = gpr_avl_add(avl, box(487), box(621), nullptr);
+  avl = remove_int(avl, 739);
+  avl = remove_int(avl, 100);
+  avl = remove_int(avl, 928);
+  avl = gpr_avl_add(avl, box(647), box(625), nullptr);
+  avl = remove_int(avl, 978);
+  avl = remove_int(avl, 143);
+  avl = remove_int(avl, 755);
+  avl = gpr_avl_add(avl, box(71), box(629), nullptr);
+  avl = remove_int(avl, 205);
+  avl = gpr_avl_add(avl, box(501), box(631), nullptr);
+  avl = remove_int(avl, 723);
+  avl = remove_int(avl, 852);
+  avl = remove_int(avl, 1021);
+  avl = remove_int(avl, 670);
+  avl = remove_int(avl, 500);
+  avl = gpr_avl_add(avl, box(330), box(637), nullptr);
+  avl = remove_int(avl, 264);
+  avl = gpr_avl_add(avl, box(69), box(639), nullptr);
+  avl = remove_int(avl, 73);
+  avl = gpr_avl_add(avl, box(745), box(641), nullptr);
+  avl = remove_int(avl, 518);
+  avl = remove_int(avl, 641);
+  avl = remove_int(avl, 768);
+  avl = gpr_avl_add(avl, box(988), box(645), nullptr);
+  avl = gpr_avl_add(avl, box(899), box(646), nullptr);
+  avl = remove_int(avl, 763);
+  avl = remove_int(avl, 281);
+  avl = remove_int(avl, 496);
+  avl = gpr_avl_add(avl, box(445), box(650), nullptr);
+  avl = remove_int(avl, 905);
+  avl = gpr_avl_add(avl, box(275), box(652), nullptr);
+  avl = gpr_avl_add(avl, box(137), box(653), nullptr);
+  avl = remove_int(avl, 642);
+  avl = gpr_avl_add(avl, box(708), box(655), nullptr);
+  avl = remove_int(avl, 922);
+  avl = gpr_avl_add(avl, box(743), box(657), nullptr);
+  avl = remove_int(avl, 295);
+  avl = remove_int(avl, 665);
+  avl = remove_int(avl, 48);
+  avl = gpr_avl_add(avl, box(1012), box(661), nullptr);
+  avl = remove_int(avl, 71);
+  avl = remove_int(avl, 523);
+  avl = gpr_avl_add(avl, box(319), box(664), nullptr);
+  avl = remove_int(avl, 632);
+  avl = gpr_avl_add(avl, box(137), box(666), nullptr);
+  avl = gpr_avl_add(avl, box(686), box(667), nullptr);
+  avl = gpr_avl_add(avl, box(724), box(668), nullptr);
+  avl = gpr_avl_add(avl, box(952), box(669), nullptr);
+  avl = gpr_avl_add(avl, box(5), box(670), nullptr);
+  avl = remove_int(avl, 35);
+  avl = gpr_avl_add(avl, box(43), box(672), nullptr);
+  avl = gpr_avl_add(avl, box(320), box(673), nullptr);
+  avl = gpr_avl_add(avl, box(115), box(674), nullptr);
+  avl = remove_int(avl, 377);
+  avl = remove_int(avl, 591);
+  avl = remove_int(avl, 87);
+  avl = remove_int(avl, 93);
+  avl = gpr_avl_add(avl, box(1016), box(679), nullptr);
+  avl = gpr_avl_add(avl, box(605), box(680), nullptr);
+  avl = gpr_avl_add(avl, box(152), box(681), nullptr);
+  avl = gpr_avl_add(avl, box(113), box(682), nullptr);
+  avl = remove_int(avl, 131);
+  avl = remove_int(avl, 637);
+  avl = gpr_avl_add(avl, box(156), box(685), nullptr);
+  avl = remove_int(avl, 696);
+  avl = gpr_avl_add(avl, box(546), box(687), nullptr);
+  avl = remove_int(avl, 970);
+  avl = remove_int(avl, 53);
+  avl = remove_int(avl, 827);
+  avl = remove_int(avl, 224);
+  avl = remove_int(avl, 796);
+  avl = remove_int(avl, 34);
+  avl = remove_int(avl, 922);
+  avl = remove_int(avl, 277);
+  avl = remove_int(avl, 650);
+  avl = remove_int(avl, 222);
+  avl = remove_int(avl, 244);
+  avl = remove_int(avl, 576);
+  avl = remove_int(avl, 413);
+  avl = gpr_avl_add(avl, box(500), box(701), nullptr);
+  avl = remove_int(avl, 924);
+  avl = gpr_avl_add(avl, box(825), box(703), nullptr);
+  avl = remove_int(avl, 888);
+  avl = remove_int(avl, 931);
+  avl = gpr_avl_add(avl, box(285), box(706), nullptr);
+  avl = remove_int(avl, 62);
+  avl = remove_int(avl, 444);
+  avl = remove_int(avl, 946);
+  avl = gpr_avl_add(avl, box(122), box(710), nullptr);
+  avl = gpr_avl_add(avl, box(846), box(711), nullptr);
+  avl = remove_int(avl, 628);
+  avl = gpr_avl_add(avl, box(511), box(713), nullptr);
+  avl = gpr_avl_add(avl, box(398), box(714), nullptr);
+  avl = remove_int(avl, 730);
+  avl = gpr_avl_add(avl, box(797), box(716), nullptr);
+  avl = remove_int(avl, 897);
+  avl = remove_int(avl, 228);
+  avl = remove_int(avl, 544);
+  avl = remove_int(avl, 552);
+  avl = remove_int(avl, 783);
+  avl = remove_int(avl, 583);
+  avl = remove_int(avl, 894);
+  avl = remove_int(avl, 942);
+  avl = gpr_avl_add(avl, box(346), box(725), nullptr);
+  avl = gpr_avl_add(avl, box(1015), box(726), nullptr);
+  avl = remove_int(avl, 813);
+  avl = gpr_avl_add(avl, box(213), box(728), nullptr);
+  avl = remove_int(avl, 468);
+  avl = remove_int(avl, 365);
+  avl = remove_int(avl, 399);
+  avl = gpr_avl_add(avl, box(380), box(732), nullptr);
+  avl = remove_int(avl, 835);
+  avl = remove_int(avl, 970);
+  avl = gpr_avl_add(avl, box(700), box(735), nullptr);
+  avl = gpr_avl_add(avl, box(807), box(736), nullptr);
+  avl = remove_int(avl, 312);
+  avl = remove_int(avl, 282);
+  avl = remove_int(avl, 370);
+  avl = remove_int(avl, 999);
+  avl = remove_int(avl, 241);
+  avl = remove_int(avl, 884);
+  avl = gpr_avl_add(avl, box(587), box(743), nullptr);
+  avl = gpr_avl_add(avl, box(332), box(744), nullptr);
+  avl = remove_int(avl, 686);
+  avl = remove_int(avl, 206);
+  avl = remove_int(avl, 835);
+  avl = gpr_avl_add(avl, box(334), box(748), nullptr);
+  avl = remove_int(avl, 171);
+  avl = gpr_avl_add(avl, box(1002), box(750), nullptr);
+  avl = gpr_avl_add(avl, box(779), box(751), nullptr);
+  avl = gpr_avl_add(avl, box(307), box(752), nullptr);
+  avl = gpr_avl_add(avl, box(127), box(753), nullptr);
+  avl = gpr_avl_add(avl, box(251), box(754), nullptr);
+  avl = remove_int(avl, 790);
+  avl = remove_int(avl, 189);
+  avl = remove_int(avl, 193);
+  avl = remove_int(avl, 38);
+  avl = remove_int(avl, 124);
+  avl = gpr_avl_add(avl, box(812), box(760), nullptr);
+  avl = remove_int(avl, 43);
+  avl = gpr_avl_add(avl, box(871), box(762), nullptr);
+  avl = gpr_avl_add(avl, box(580), box(763), nullptr);
+  avl = remove_int(avl, 501);
+  avl = remove_int(avl, 462);
+  avl = remove_int(avl, 599);
+  avl = gpr_avl_add(avl, box(240), box(767), nullptr);
+  avl = gpr_avl_add(avl, box(285), box(768), nullptr);
+  avl = gpr_avl_add(avl, box(472), box(769), nullptr);
+  avl = remove_int(avl, 865);
+  avl = remove_int(avl, 763);
+  avl = remove_int(avl, 245);
+  avl = remove_int(avl, 80);
+  avl = remove_int(avl, 713);
+  avl = remove_int(avl, 654);
+  avl = remove_int(avl, 1014);
+  avl = gpr_avl_add(avl, box(495), box(777), nullptr);
+  avl = gpr_avl_add(avl, box(552), box(778), nullptr);
+  avl = remove_int(avl, 19);
+  avl = remove_int(avl, 803);
+  avl = gpr_avl_add(avl, box(508), box(781), nullptr);
+  avl = remove_int(avl, 699);
+  avl = remove_int(avl, 260);
+  avl = remove_int(avl, 92);
+  avl = remove_int(avl, 497);
+  avl = gpr_avl_add(avl, box(970), box(786), nullptr);
+  avl = remove_int(avl, 987);
+  avl = remove_int(avl, 168);
+  avl = remove_int(avl, 476);
+  avl = remove_int(avl, 248);
+  avl = gpr_avl_add(avl, box(358), box(791), nullptr);
+  avl = remove_int(avl, 804);
+  avl = remove_int(avl, 77);
+  avl = remove_int(avl, 905);
+  avl = remove_int(avl, 362);
+  avl = gpr_avl_add(avl, box(578), box(796), nullptr);
+  avl = remove_int(avl, 38);
+  avl = remove_int(avl, 595);
+  avl = gpr_avl_add(avl, box(213), box(799), nullptr);
+  avl = remove_int(avl, 7);
+  avl = remove_int(avl, 620);
+  avl = gpr_avl_add(avl, box(946), box(802), nullptr);
+  avl = remove_int(avl, 145);
+  avl = gpr_avl_add(avl, box(628), box(804), nullptr);
+  avl = remove_int(avl, 972);
+  avl = gpr_avl_add(avl, box(728), box(806), nullptr);
+  avl = remove_int(avl, 91);
+  avl = gpr_avl_add(avl, box(136), box(808), nullptr);
+  avl = gpr_avl_add(avl, box(841), box(809), nullptr);
+  avl = gpr_avl_add(avl, box(265), box(810), nullptr);
+  avl = gpr_avl_add(avl, box(701), box(811), nullptr);
+  avl = gpr_avl_add(avl, box(27), box(812), nullptr);
+  avl = remove_int(avl, 72);
+  avl = remove_int(avl, 14);
+  avl = gpr_avl_add(avl, box(286), box(815), nullptr);
+  avl = remove_int(avl, 996);
+  avl = remove_int(avl, 998);
+  avl = gpr_avl_add(avl, box(466), box(818), nullptr);
+  avl = remove_int(avl, 1009);
+  avl = remove_int(avl, 741);
+  avl = remove_int(avl, 947);
+  avl = remove_int(avl, 241);
+  avl = remove_int(avl, 954);
+  avl = remove_int(avl, 183);
+  avl = remove_int(avl, 395);
+  avl = remove_int(avl, 951);
+  avl = gpr_avl_add(avl, box(267), box(827), nullptr);
+  avl = remove_int(avl, 812);
+  avl = gpr_avl_add(avl, box(577), box(829), nullptr);
+  avl = remove_int(avl, 624);
+  avl = remove_int(avl, 847);
+  avl = remove_int(avl, 745);
+  avl = gpr_avl_add(avl, box(491), box(833), nullptr);
+  avl = gpr_avl_add(avl, box(941), box(834), nullptr);
+  avl = remove_int(avl, 258);
+  avl = gpr_avl_add(avl, box(410), box(836), nullptr);
+  avl = gpr_avl_add(avl, box(80), box(837), nullptr);
+  avl = gpr_avl_add(avl, box(196), box(838), nullptr);
+  avl = gpr_avl_add(avl, box(5), box(839), nullptr);
+  avl = remove_int(avl, 782);
+  avl = gpr_avl_add(avl, box(827), box(841), nullptr);
+  avl = remove_int(avl, 472);
+  avl = remove_int(avl, 664);
+  avl = gpr_avl_add(avl, box(409), box(844), nullptr);
+  avl = gpr_avl_add(avl, box(62), box(845), nullptr);
+  avl = remove_int(avl, 56);
+  avl = remove_int(avl, 606);
+  avl = remove_int(avl, 707);
+  avl = remove_int(avl, 989);
+  avl = remove_int(avl, 549);
+  avl = remove_int(avl, 259);
+  avl = gpr_avl_add(avl, box(405), box(852), nullptr);
+  avl = remove_int(avl, 587);
+  avl = remove_int(avl, 350);
+  avl = gpr_avl_add(avl, box(980), box(855), nullptr);
+  avl = gpr_avl_add(avl, box(992), box(856), nullptr);
+  avl = gpr_avl_add(avl, box(818), box(857), nullptr);
+  avl = remove_int(avl, 853);
+  avl = remove_int(avl, 701);
+  avl = gpr_avl_add(avl, box(675), box(860), nullptr);
+  avl = remove_int(avl, 248);
+  avl = remove_int(avl, 649);
+  avl = gpr_avl_add(avl, box(508), box(863), nullptr);
+  avl = remove_int(avl, 927);
+  avl = gpr_avl_add(avl, box(957), box(865), nullptr);
+  avl = gpr_avl_add(avl, box(698), box(866), nullptr);
+  avl = gpr_avl_add(avl, box(388), box(867), nullptr);
+  avl = gpr_avl_add(avl, box(532), box(868), nullptr);
+  avl = gpr_avl_add(avl, box(681), box(869), nullptr);
+  avl = remove_int(avl, 544);
+  avl = remove_int(avl, 991);
+  avl = remove_int(avl, 397);
+  avl = gpr_avl_add(avl, box(954), box(873), nullptr);
+  avl = gpr_avl_add(avl, box(219), box(874), nullptr);
+  avl = gpr_avl_add(avl, box(465), box(875), nullptr);
+  avl = remove_int(avl, 371);
+  avl = gpr_avl_add(avl, box(601), box(877), nullptr);
+  avl = gpr_avl_add(avl, box(543), box(878), nullptr);
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(560), box(880), nullptr);
+  avl = remove_int(avl, 898);
+  avl = gpr_avl_add(avl, box(455), box(882), nullptr);
+  avl = remove_int(avl, 313);
+  avl = gpr_avl_add(avl, box(215), box(884), nullptr);
+  avl = remove_int(avl, 846);
+  avl = gpr_avl_add(avl, box(608), box(886), nullptr);
+  avl = remove_int(avl, 248);
+  avl = gpr_avl_add(avl, box(575), box(888), nullptr);
+  avl = remove_int(avl, 207);
+  avl = remove_int(avl, 810);
+  avl = remove_int(avl, 665);
+  avl = remove_int(avl, 361);
+  avl = gpr_avl_add(avl, box(154), box(893), nullptr);
+  avl = gpr_avl_add(avl, box(329), box(894), nullptr);
+  avl = gpr_avl_add(avl, box(326), box(895), nullptr);
+  avl = remove_int(avl, 746);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(464), box(898), nullptr);
+  avl = gpr_avl_add(avl, box(141), box(899), nullptr);
+  avl = remove_int(avl, 383);
+  avl = gpr_avl_add(avl, box(414), box(901), nullptr);
+  avl = gpr_avl_add(avl, box(777), box(902), nullptr);
+  avl = remove_int(avl, 972);
+  avl = remove_int(avl, 841);
+  avl = remove_int(avl, 100);
+  avl = gpr_avl_add(avl, box(828), box(906), nullptr);
+  avl = remove_int(avl, 785);
+  avl = gpr_avl_add(avl, box(1008), box(908), nullptr);
+  avl = gpr_avl_add(avl, box(46), box(909), nullptr);
+  avl = remove_int(avl, 399);
+  avl = gpr_avl_add(avl, box(178), box(911), nullptr);
+  avl = gpr_avl_add(avl, box(573), box(912), nullptr);
+  avl = remove_int(avl, 299);
+  avl = gpr_avl_add(avl, box(690), box(914), nullptr);
+  avl = gpr_avl_add(avl, box(692), box(915), nullptr);
+  avl = remove_int(avl, 404);
+  avl = remove_int(avl, 16);
+  avl = remove_int(avl, 746);
+  avl = remove_int(avl, 486);
+  avl = remove_int(avl, 119);
+  avl = gpr_avl_add(avl, box(167), box(921), nullptr);
+  avl = remove_int(avl, 328);
+  avl = gpr_avl_add(avl, box(89), box(923), nullptr);
+  avl = remove_int(avl, 867);
+  avl = remove_int(avl, 626);
+  avl = remove_int(avl, 507);
+  avl = gpr_avl_add(avl, box(365), box(927), nullptr);
+  avl = gpr_avl_add(avl, box(58), box(928), nullptr);
+  avl = gpr_avl_add(avl, box(70), box(929), nullptr);
+  avl = remove_int(avl, 81);
+  avl = remove_int(avl, 797);
+  avl = gpr_avl_add(avl, box(846), box(932), nullptr);
+  avl = remove_int(avl, 642);
+  avl = gpr_avl_add(avl, box(777), box(934), nullptr);
+  avl = remove_int(avl, 107);
+  avl = gpr_avl_add(avl, box(691), box(936), nullptr);
+  avl = gpr_avl_add(avl, box(820), box(937), nullptr);
+  avl = gpr_avl_add(avl, box(202), box(938), nullptr);
+  avl = gpr_avl_add(avl, box(308), box(939), nullptr);
+  avl = gpr_avl_add(avl, box(20), box(940), nullptr);
+  avl = remove_int(avl, 289);
+  avl = gpr_avl_add(avl, box(714), box(942), nullptr);
+  avl = gpr_avl_add(avl, box(584), box(943), nullptr);
+  avl = remove_int(avl, 294);
+  avl = gpr_avl_add(avl, box(496), box(945), nullptr);
+  avl = gpr_avl_add(avl, box(394), box(946), nullptr);
+  avl = gpr_avl_add(avl, box(860), box(947), nullptr);
+  avl = gpr_avl_add(avl, box(58), box(948), nullptr);
+  avl = remove_int(avl, 784);
+  avl = remove_int(avl, 584);
+  avl = remove_int(avl, 708);
+  avl = gpr_avl_add(avl, box(142), box(952), nullptr);
+  avl = gpr_avl_add(avl, box(247), box(953), nullptr);
+  avl = gpr_avl_add(avl, box(389), box(954), nullptr);
+  avl = remove_int(avl, 390);
+  avl = gpr_avl_add(avl, box(465), box(956), nullptr);
+  avl = gpr_avl_add(avl, box(936), box(957), nullptr);
+  avl = gpr_avl_add(avl, box(309), box(958), nullptr);
+  avl = remove_int(avl, 928);
+  avl = remove_int(avl, 128);
+  avl = remove_int(avl, 979);
+  avl = remove_int(avl, 670);
+  avl = remove_int(avl, 738);
+  avl = remove_int(avl, 271);
+  avl = remove_int(avl, 540);
+  avl = gpr_avl_add(avl, box(365), box(966), nullptr);
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(728), box(968), nullptr);
+  avl = remove_int(avl, 852);
+  avl = gpr_avl_add(avl, box(884), box(970), nullptr);
+  avl = gpr_avl_add(avl, box(502), box(971), nullptr);
+  avl = remove_int(avl, 898);
+  avl = remove_int(avl, 481);
+  avl = gpr_avl_add(avl, box(911), box(974), nullptr);
+  avl = remove_int(avl, 787);
+  avl = remove_int(avl, 785);
+  avl = remove_int(avl, 537);
+  avl = remove_int(avl, 535);
+  avl = remove_int(avl, 136);
+  avl = remove_int(avl, 749);
+  avl = remove_int(avl, 637);
+  avl = remove_int(avl, 900);
+  avl = gpr_avl_add(avl, box(598), box(983), nullptr);
+  avl = remove_int(avl, 25);
+  avl = remove_int(avl, 697);
+  avl = gpr_avl_add(avl, box(645), box(986), nullptr);
+  avl = gpr_avl_add(avl, box(211), box(987), nullptr);
+  avl = gpr_avl_add(avl, box(589), box(988), nullptr);
+  avl = remove_int(avl, 702);
+  avl = gpr_avl_add(avl, box(53), box(990), nullptr);
+  avl = remove_int(avl, 492);
+  avl = remove_int(avl, 185);
+  avl = remove_int(avl, 246);
+  avl = remove_int(avl, 257);
+  avl = remove_int(avl, 502);
+  avl = remove_int(avl, 34);
+  avl = gpr_avl_add(avl, box(74), box(997), nullptr);
+  avl = gpr_avl_add(avl, box(834), box(998), nullptr);
+  avl = gpr_avl_add(avl, box(514), box(999), nullptr);
+  avl = gpr_avl_add(avl, box(75), box(1000), nullptr);
+  avl = remove_int(avl, 745);
+  avl = gpr_avl_add(avl, box(362), box(1002), nullptr);
+  avl = remove_int(avl, 215);
+  avl = gpr_avl_add(avl, box(624), box(1004), nullptr);
+  avl = remove_int(avl, 404);
+  avl = remove_int(avl, 359);
+  avl = remove_int(avl, 491);
+  avl = gpr_avl_add(avl, box(903), box(1008), nullptr);
+  avl = gpr_avl_add(avl, box(240), box(1009), nullptr);
+  avl = remove_int(avl, 95);
+  avl = gpr_avl_add(avl, box(119), box(1011), nullptr);
+  avl = gpr_avl_add(avl, box(857), box(1012), nullptr);
+  avl = remove_int(avl, 39);
+  avl = remove_int(avl, 866);
+  avl = gpr_avl_add(avl, box(503), box(1015), nullptr);
+  avl = gpr_avl_add(avl, box(740), box(1016), nullptr);
+  avl = remove_int(avl, 637);
+  avl = remove_int(avl, 156);
+  avl = remove_int(avl, 6);
+  avl = remove_int(avl, 745);
+  avl = remove_int(avl, 433);
+  avl = remove_int(avl, 283);
+  avl = gpr_avl_add(avl, box(625), box(1023), nullptr);
+  avl = remove_int(avl, 638);
+  avl = gpr_avl_add(avl, box(299), box(1025), nullptr);
+  avl = gpr_avl_add(avl, box(584), box(1026), nullptr);
+  avl = remove_int(avl, 863);
+  avl = gpr_avl_add(avl, box(612), box(1028), nullptr);
+  avl = gpr_avl_add(avl, box(62), box(1029), nullptr);
+  avl = gpr_avl_add(avl, box(432), box(1030), nullptr);
+  avl = remove_int(avl, 371);
+  avl = remove_int(avl, 790);
+  avl = remove_int(avl, 227);
+  avl = remove_int(avl, 836);
+  avl = gpr_avl_add(avl, box(703), box(1035), nullptr);
+  avl = gpr_avl_add(avl, box(644), box(1036), nullptr);
+  avl = remove_int(avl, 638);
+  avl = gpr_avl_add(avl, box(13), box(1038), nullptr);
+  avl = remove_int(avl, 66);
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(362), box(1041), nullptr);
+  avl = gpr_avl_add(avl, box(783), box(1042), nullptr);
+  avl = remove_int(avl, 60);
+  avl = gpr_avl_add(avl, box(80), box(1044), nullptr);
+  avl = gpr_avl_add(avl, box(825), box(1045), nullptr);
+  avl = gpr_avl_add(avl, box(688), box(1046), nullptr);
+  avl = gpr_avl_add(avl, box(662), box(1047), nullptr);
+  avl = remove_int(avl, 156);
+  avl = remove_int(avl, 376);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(526), box(1051), nullptr);
+  avl = gpr_avl_add(avl, box(168), box(1052), nullptr);
+  avl = remove_int(avl, 646);
+  avl = remove_int(avl, 380);
+  avl = remove_int(avl, 833);
+  avl = gpr_avl_add(avl, box(53), box(1056), nullptr);
+  avl = remove_int(avl, 105);
+  avl = gpr_avl_add(avl, box(373), box(1058), nullptr);
+  avl = gpr_avl_add(avl, box(184), box(1059), nullptr);
+  avl = remove_int(avl, 288);
+  avl = gpr_avl_add(avl, box(966), box(1061), nullptr);
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(406), box(1063), nullptr);
+  avl = remove_int(avl, 470);
+  avl = gpr_avl_add(avl, box(283), box(1065), nullptr);
+  avl = gpr_avl_add(avl, box(838), box(1066), nullptr);
+  avl = gpr_avl_add(avl, box(288), box(1067), nullptr);
+  avl = gpr_avl_add(avl, box(950), box(1068), nullptr);
+  avl = gpr_avl_add(avl, box(163), box(1069), nullptr);
+  avl = remove_int(avl, 623);
+  avl = remove_int(avl, 769);
+  avl = gpr_avl_add(avl, box(144), box(1072), nullptr);
+  avl = gpr_avl_add(avl, box(489), box(1073), nullptr);
+  avl = remove_int(avl, 15);
+  avl = gpr_avl_add(avl, box(971), box(1075), nullptr);
+  avl = remove_int(avl, 660);
+  avl = gpr_avl_add(avl, box(255), box(1077), nullptr);
+  avl = remove_int(avl, 494);
+  avl = gpr_avl_add(avl, box(109), box(1079), nullptr);
+  avl = gpr_avl_add(avl, box(420), box(1080), nullptr);
+  avl = gpr_avl_add(avl, box(509), box(1081), nullptr);
+  avl = remove_int(avl, 178);
+  avl = gpr_avl_add(avl, box(216), box(1083), nullptr);
+  avl = gpr_avl_add(avl, box(707), box(1084), nullptr);
+  avl = gpr_avl_add(avl, box(411), box(1085), nullptr);
+  avl = gpr_avl_add(avl, box(352), box(1086), nullptr);
+  avl = remove_int(avl, 983);
+  avl = gpr_avl_add(avl, box(6), box(1088), nullptr);
+  avl = gpr_avl_add(avl, box(1014), box(1089), nullptr);
+  avl = remove_int(avl, 98);
+  avl = remove_int(avl, 325);
+  avl = gpr_avl_add(avl, box(851), box(1092), nullptr);
+  avl = remove_int(avl, 553);
+  avl = gpr_avl_add(avl, box(218), box(1094), nullptr);
+  avl = gpr_avl_add(avl, box(261), box(1095), nullptr);
+  avl = remove_int(avl, 31);
+  avl = gpr_avl_add(avl, box(872), box(1097), nullptr);
+  avl = remove_int(avl, 543);
+  avl = remove_int(avl, 314);
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(533), box(1101), nullptr);
+  avl = remove_int(avl, 881);
+  avl = remove_int(avl, 269);
+  avl = remove_int(avl, 940);
+  avl = remove_int(avl, 909);
+  avl = remove_int(avl, 197);
+  avl = remove_int(avl, 773);
+  avl = remove_int(avl, 790);
+  avl = remove_int(avl, 345);
+  avl = gpr_avl_add(avl, box(965), box(1110), nullptr);
+  avl = remove_int(avl, 622);
+  avl = gpr_avl_add(avl, box(352), box(1112), nullptr);
+  avl = remove_int(avl, 182);
+  avl = gpr_avl_add(avl, box(534), box(1114), nullptr);
+  avl = gpr_avl_add(avl, box(97), box(1115), nullptr);
+  avl = gpr_avl_add(avl, box(198), box(1116), nullptr);
+  avl = remove_int(avl, 750);
+  avl = gpr_avl_add(avl, box(98), box(1118), nullptr);
+  avl = remove_int(avl, 943);
+  avl = gpr_avl_add(avl, box(254), box(1120), nullptr);
+  avl = gpr_avl_add(avl, box(30), box(1121), nullptr);
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 475);
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(789), box(1125), nullptr);
+  avl = gpr_avl_add(avl, box(402), box(1126), nullptr);
+  avl = remove_int(avl, 1019);
+  avl = gpr_avl_add(avl, box(858), box(1128), nullptr);
+  avl = gpr_avl_add(avl, box(625), box(1129), nullptr);
+  avl = remove_int(avl, 675);
+  avl = remove_int(avl, 323);
+  avl = gpr_avl_add(avl, box(329), box(1132), nullptr);
+  avl = remove_int(avl, 929);
+  avl = remove_int(avl, 44);
+  avl = gpr_avl_add(avl, box(443), box(1135), nullptr);
+  avl = gpr_avl_add(avl, box(653), box(1136), nullptr);
+  avl = gpr_avl_add(avl, box(750), box(1137), nullptr);
+  avl = gpr_avl_add(avl, box(252), box(1138), nullptr);
+  avl = gpr_avl_add(avl, box(449), box(1139), nullptr);
+  avl = remove_int(avl, 1022);
+  avl = remove_int(avl, 357);
+  avl = remove_int(avl, 602);
+  avl = remove_int(avl, 131);
+  avl = gpr_avl_add(avl, box(531), box(1144), nullptr);
+  avl = remove_int(avl, 806);
+  avl = gpr_avl_add(avl, box(455), box(1146), nullptr);
+  avl = remove_int(avl, 31);
+  avl = gpr_avl_add(avl, box(154), box(1148), nullptr);
+  avl = gpr_avl_add(avl, box(189), box(1149), nullptr);
+  avl = remove_int(avl, 786);
+  avl = gpr_avl_add(avl, box(496), box(1151), nullptr);
+  avl = gpr_avl_add(avl, box(81), box(1152), nullptr);
+  avl = gpr_avl_add(avl, box(59), box(1153), nullptr);
+  avl = remove_int(avl, 424);
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(723), box(1156), nullptr);
+  avl = gpr_avl_add(avl, box(822), box(1157), nullptr);
+  avl = gpr_avl_add(avl, box(354), box(1158), nullptr);
+  avl = remove_int(avl, 738);
+  avl = gpr_avl_add(avl, box(686), box(1160), nullptr);
+  avl = gpr_avl_add(avl, box(43), box(1161), nullptr);
+  avl = gpr_avl_add(avl, box(625), box(1162), nullptr);
+  avl = gpr_avl_add(avl, box(902), box(1163), nullptr);
+  avl = gpr_avl_add(avl, box(12), box(1164), nullptr);
+  avl = gpr_avl_add(avl, box(977), box(1165), nullptr);
+  avl = gpr_avl_add(avl, box(699), box(1166), nullptr);
+  avl = gpr_avl_add(avl, box(189), box(1167), nullptr);
+  avl = remove_int(avl, 672);
+  avl = remove_int(avl, 90);
+  avl = remove_int(avl, 757);
+  avl = remove_int(avl, 494);
+  avl = gpr_avl_add(avl, box(759), box(1172), nullptr);
+  avl = remove_int(avl, 758);
+  avl = remove_int(avl, 222);
+  avl = gpr_avl_add(avl, box(975), box(1175), nullptr);
+  avl = remove_int(avl, 993);
+  avl = gpr_avl_add(avl, box(2), box(1177), nullptr);
+  avl = gpr_avl_add(avl, box(70), box(1178), nullptr);
+  avl = remove_int(avl, 350);
+  avl = remove_int(avl, 972);
+  avl = remove_int(avl, 880);
+  avl = gpr_avl_add(avl, box(753), box(1182), nullptr);
+  avl = remove_int(avl, 404);
+  avl = gpr_avl_add(avl, box(294), box(1184), nullptr);
+  avl = remove_int(avl, 474);
+  avl = gpr_avl_add(avl, box(228), box(1186), nullptr);
+  avl = gpr_avl_add(avl, box(484), box(1187), nullptr);
+  avl = remove_int(avl, 238);
+  avl = remove_int(avl, 53);
+  avl = remove_int(avl, 691);
+  avl = gpr_avl_add(avl, box(345), box(1191), nullptr);
+  avl = remove_int(avl, 0);
+  avl = gpr_avl_add(avl, box(230), box(1193), nullptr);
+  avl = remove_int(avl, 227);
+  avl = remove_int(avl, 152);
+  avl = gpr_avl_add(avl, box(884), box(1196), nullptr);
+  avl = remove_int(avl, 823);
+  avl = remove_int(avl, 53);
+  avl = gpr_avl_add(avl, box(1015), box(1199), nullptr);
+  avl = gpr_avl_add(avl, box(697), box(1200), nullptr);
+  avl = gpr_avl_add(avl, box(376), box(1201), nullptr);
+  avl = remove_int(avl, 411);
+  avl = gpr_avl_add(avl, box(888), box(1203), nullptr);
+  avl = remove_int(avl, 55);
+  avl = gpr_avl_add(avl, box(85), box(1205), nullptr);
+  avl = remove_int(avl, 947);
+  avl = remove_int(avl, 382);
+  avl = remove_int(avl, 777);
+  avl = gpr_avl_add(avl, box(1017), box(1209), nullptr);
+  avl = gpr_avl_add(avl, box(169), box(1210), nullptr);
+  avl = gpr_avl_add(avl, box(156), box(1211), nullptr);
+  avl = remove_int(avl, 153);
+  avl = remove_int(avl, 642);
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(554), box(1215), nullptr);
+  avl = gpr_avl_add(avl, box(76), box(1216), nullptr);
+  avl = gpr_avl_add(avl, box(756), box(1217), nullptr);
+  avl = remove_int(avl, 767);
+  avl = remove_int(avl, 112);
+  avl = remove_int(avl, 539);
+  avl = remove_int(avl, 544);
+  avl = remove_int(avl, 628);
+  avl = remove_int(avl, 385);
+  avl = remove_int(avl, 514);
+  avl = remove_int(avl, 362);
+  avl = gpr_avl_add(avl, box(523), box(1226), nullptr);
+  avl = gpr_avl_add(avl, box(712), box(1227), nullptr);
+  avl = gpr_avl_add(avl, box(474), box(1228), nullptr);
+  avl = gpr_avl_add(avl, box(882), box(1229), nullptr);
+  avl = gpr_avl_add(avl, box(965), box(1230), nullptr);
+  avl = remove_int(avl, 464);
+  avl = gpr_avl_add(avl, box(319), box(1232), nullptr);
+  avl = gpr_avl_add(avl, box(504), box(1233), nullptr);
+  avl = remove_int(avl, 818);
+  avl = gpr_avl_add(avl, box(884), box(1235), nullptr);
+  avl = gpr_avl_add(avl, box(813), box(1236), nullptr);
+  avl = gpr_avl_add(avl, box(795), box(1237), nullptr);
+  avl = remove_int(avl, 306);
+  avl = gpr_avl_add(avl, box(799), box(1239), nullptr);
+  avl = remove_int(avl, 534);
+  avl = gpr_avl_add(avl, box(480), box(1241), nullptr);
+  avl = gpr_avl_add(avl, box(656), box(1242), nullptr);
+  avl = gpr_avl_add(avl, box(709), box(1243), nullptr);
+  avl = gpr_avl_add(avl, box(500), box(1244), nullptr);
+  avl = remove_int(avl, 740);
+  avl = gpr_avl_add(avl, box(980), box(1246), nullptr);
+  avl = gpr_avl_add(avl, box(458), box(1247), nullptr);
+  avl = remove_int(avl, 377);
+  avl = remove_int(avl, 338);
+  avl = gpr_avl_add(avl, box(554), box(1250), nullptr);
+  avl = gpr_avl_add(avl, box(504), box(1251), nullptr);
+  avl = gpr_avl_add(avl, box(603), box(1252), nullptr);
+  avl = gpr_avl_add(avl, box(761), box(1253), nullptr);
+  avl = remove_int(avl, 431);
+  avl = gpr_avl_add(avl, box(707), box(1255), nullptr);
+  avl = gpr_avl_add(avl, box(673), box(1256), nullptr);
+  avl = remove_int(avl, 998);
+  avl = remove_int(avl, 332);
+  avl = remove_int(avl, 413);
+  avl = remove_int(avl, 227);
+  avl = remove_int(avl, 249);
+  avl = remove_int(avl, 309);
+  avl = remove_int(avl, 459);
+  avl = gpr_avl_add(avl, box(645), box(1264), nullptr);
+  avl = remove_int(avl, 858);
+  avl = remove_int(avl, 997);
+  avl = gpr_avl_add(avl, box(519), box(1267), nullptr);
+  avl = remove_int(avl, 614);
+  avl = remove_int(avl, 462);
+  avl = remove_int(avl, 792);
+  avl = gpr_avl_add(avl, box(987), box(1271), nullptr);
+  avl = gpr_avl_add(avl, box(309), box(1272), nullptr);
+  avl = remove_int(avl, 747);
+  avl = gpr_avl_add(avl, box(621), box(1274), nullptr);
+  avl = gpr_avl_add(avl, box(450), box(1275), nullptr);
+  avl = remove_int(avl, 265);
+  avl = remove_int(avl, 8);
+  avl = remove_int(avl, 383);
+  avl = gpr_avl_add(avl, box(238), box(1279), nullptr);
+  avl = remove_int(avl, 241);
+  avl = gpr_avl_add(avl, box(180), box(1281), nullptr);
+  avl = gpr_avl_add(avl, box(411), box(1282), nullptr);
+  avl = gpr_avl_add(avl, box(791), box(1283), nullptr);
+  avl = gpr_avl_add(avl, box(955), box(1284), nullptr);
+  avl = remove_int(avl, 24);
+  avl = remove_int(avl, 375);
+  avl = gpr_avl_add(avl, box(140), box(1287), nullptr);
+  avl = remove_int(avl, 949);
+  avl = gpr_avl_add(avl, box(301), box(1289), nullptr);
+  avl = gpr_avl_add(avl, box(0), box(1290), nullptr);
+  avl = remove_int(avl, 371);
+  avl = remove_int(avl, 427);
+  avl = remove_int(avl, 841);
+  avl = remove_int(avl, 847);
+  avl = gpr_avl_add(avl, box(814), box(1295), nullptr);
+  avl = gpr_avl_add(avl, box(127), box(1296), nullptr);
+  avl = gpr_avl_add(avl, box(279), box(1297), nullptr);
+  avl = remove_int(avl, 669);
+  avl = remove_int(avl, 541);
+  avl = remove_int(avl, 275);
+  avl = remove_int(avl, 299);
+  avl = remove_int(avl, 552);
+  avl = gpr_avl_add(avl, box(310), box(1303), nullptr);
+  avl = gpr_avl_add(avl, box(304), box(1304), nullptr);
+  avl = gpr_avl_add(avl, box(1), box(1305), nullptr);
+  avl = gpr_avl_add(avl, box(339), box(1306), nullptr);
+  avl = remove_int(avl, 570);
+  avl = remove_int(avl, 752);
+  avl = remove_int(avl, 552);
+  avl = remove_int(avl, 442);
+  avl = remove_int(avl, 639);
+  avl = gpr_avl_add(avl, box(313), box(1312), nullptr);
+  avl = remove_int(avl, 85);
+  avl = gpr_avl_add(avl, box(964), box(1314), nullptr);
+  avl = gpr_avl_add(avl, box(559), box(1315), nullptr);
+  avl = remove_int(avl, 167);
+  avl = gpr_avl_add(avl, box(866), box(1317), nullptr);
+  avl = remove_int(avl, 275);
+  avl = gpr_avl_add(avl, box(173), box(1319), nullptr);
+  avl = gpr_avl_add(avl, box(765), box(1320), nullptr);
+  avl = remove_int(avl, 883);
+  avl = gpr_avl_add(avl, box(547), box(1322), nullptr);
+  avl = gpr_avl_add(avl, box(847), box(1323), nullptr);
+  avl = remove_int(avl, 817);
+  avl = remove_int(avl, 850);
+  avl = remove_int(avl, 718);
+  avl = gpr_avl_add(avl, box(806), box(1327), nullptr);
+  avl = gpr_avl_add(avl, box(360), box(1328), nullptr);
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(493), box(1330), nullptr);
+  avl = remove_int(avl, 516);
+  avl = gpr_avl_add(avl, box(361), box(1332), nullptr);
+  avl = remove_int(avl, 355);
+  avl = gpr_avl_add(avl, box(512), box(1334), nullptr);
+  avl = gpr_avl_add(avl, box(191), box(1335), nullptr);
+  avl = remove_int(avl, 703);
+  avl = gpr_avl_add(avl, box(333), box(1337), nullptr);
+  avl = remove_int(avl, 481);
+  avl = gpr_avl_add(avl, box(501), box(1339), nullptr);
+  avl = remove_int(avl, 532);
+  avl = remove_int(avl, 510);
+  avl = gpr_avl_add(avl, box(793), box(1342), nullptr);
+  avl = gpr_avl_add(avl, box(234), box(1343), nullptr);
+  avl = remove_int(avl, 159);
+  avl = remove_int(avl, 429);
+  avl = remove_int(avl, 728);
+  avl = remove_int(avl, 288);
+  avl = gpr_avl_add(avl, box(281), box(1348), nullptr);
+  avl = gpr_avl_add(avl, box(702), box(1349), nullptr);
+  avl = gpr_avl_add(avl, box(149), box(1350), nullptr);
+  avl = remove_int(avl, 22);
+  avl = remove_int(avl, 944);
+  avl = remove_int(avl, 55);
+  avl = remove_int(avl, 512);
+  avl = remove_int(avl, 676);
+  avl = remove_int(avl, 884);
+  avl = gpr_avl_add(avl, box(246), box(1357), nullptr);
+  avl = gpr_avl_add(avl, box(455), box(1358), nullptr);
+  avl = remove_int(avl, 782);
+  avl = remove_int(avl, 682);
+  avl = gpr_avl_add(avl, box(243), box(1361), nullptr);
+  avl = gpr_avl_add(avl, box(109), box(1362), nullptr);
+  avl = gpr_avl_add(avl, box(452), box(1363), nullptr);
+  avl = remove_int(avl, 151);
+  avl = gpr_avl_add(avl, box(159), box(1365), nullptr);
+  avl = remove_int(avl, 1023);
+  avl = gpr_avl_add(avl, box(129), box(1367), nullptr);
+  avl = gpr_avl_add(avl, box(537), box(1368), nullptr);
+  avl = remove_int(avl, 321);
+  avl = gpr_avl_add(avl, box(740), box(1370), nullptr);
+  avl = remove_int(avl, 45);
+  avl = remove_int(avl, 136);
+  avl = gpr_avl_add(avl, box(229), box(1373), nullptr);
+  avl = remove_int(avl, 772);
+  avl = gpr_avl_add(avl, box(181), box(1375), nullptr);
+  avl = remove_int(avl, 175);
+  avl = gpr_avl_add(avl, box(817), box(1377), nullptr);
+  avl = remove_int(avl, 956);
+  avl = gpr_avl_add(avl, box(675), box(1379), nullptr);
+  avl = gpr_avl_add(avl, box(375), box(1380), nullptr);
+  avl = remove_int(avl, 384);
+  avl = gpr_avl_add(avl, box(1016), box(1382), nullptr);
+  avl = remove_int(avl, 295);
+  avl = remove_int(avl, 697);
+  avl = remove_int(avl, 554);
+  avl = remove_int(avl, 590);
+  avl = remove_int(avl, 1014);
+  avl = gpr_avl_add(avl, box(890), box(1388), nullptr);
+  avl = gpr_avl_add(avl, box(293), box(1389), nullptr);
+  avl = remove_int(avl, 207);
+  avl = remove_int(avl, 46);
+  avl = gpr_avl_add(avl, box(899), box(1392), nullptr);
+  avl = gpr_avl_add(avl, box(666), box(1393), nullptr);
+  avl = gpr_avl_add(avl, box(85), box(1394), nullptr);
+  avl = gpr_avl_add(avl, box(914), box(1395), nullptr);
+  avl = gpr_avl_add(avl, box(128), box(1396), nullptr);
+  avl = gpr_avl_add(avl, box(835), box(1397), nullptr);
+  avl = gpr_avl_add(avl, box(787), box(1398), nullptr);
+  avl = gpr_avl_add(avl, box(649), box(1399), nullptr);
+  avl = gpr_avl_add(avl, box(723), box(1400), nullptr);
+  avl = remove_int(avl, 874);
+  avl = gpr_avl_add(avl, box(778), box(1402), nullptr);
+  avl = gpr_avl_add(avl, box(1015), box(1403), nullptr);
+  avl = gpr_avl_add(avl, box(59), box(1404), nullptr);
+  avl = gpr_avl_add(avl, box(259), box(1405), nullptr);
+  avl = gpr_avl_add(avl, box(758), box(1406), nullptr);
+  avl = remove_int(avl, 648);
+  avl = gpr_avl_add(avl, box(145), box(1408), nullptr);
+  avl = gpr_avl_add(avl, box(440), box(1409), nullptr);
+  avl = remove_int(avl, 608);
+  avl = remove_int(avl, 690);
+  avl = gpr_avl_add(avl, box(605), box(1412), nullptr);
+  avl = remove_int(avl, 856);
+  avl = remove_int(avl, 608);
+  avl = gpr_avl_add(avl, box(829), box(1415), nullptr);
+  avl = gpr_avl_add(avl, box(660), box(1416), nullptr);
+  avl = remove_int(avl, 596);
+  avl = gpr_avl_add(avl, box(519), box(1418), nullptr);
+  avl = gpr_avl_add(avl, box(35), box(1419), nullptr);
+  avl = gpr_avl_add(avl, box(871), box(1420), nullptr);
+  avl = remove_int(avl, 845);
+  avl = gpr_avl_add(avl, box(600), box(1422), nullptr);
+  avl = gpr_avl_add(avl, box(215), box(1423), nullptr);
+  avl = remove_int(avl, 761);
+  avl = gpr_avl_add(avl, box(975), box(1425), nullptr);
+  avl = remove_int(avl, 987);
+  avl = gpr_avl_add(avl, box(58), box(1427), nullptr);
+  avl = remove_int(avl, 119);
+  avl = gpr_avl_add(avl, box(937), box(1429), nullptr);
+  avl = gpr_avl_add(avl, box(372), box(1430), nullptr);
+  avl = gpr_avl_add(avl, box(11), box(1431), nullptr);
+  avl = gpr_avl_add(avl, box(398), box(1432), nullptr);
+  avl = gpr_avl_add(avl, box(423), box(1433), nullptr);
+  avl = remove_int(avl, 171);
+  avl = gpr_avl_add(avl, box(473), box(1435), nullptr);
+  avl = remove_int(avl, 752);
+  avl = remove_int(avl, 625);
+  avl = remove_int(avl, 764);
+  avl = remove_int(avl, 49);
+  avl = gpr_avl_add(avl, box(472), box(1440), nullptr);
+  avl = remove_int(avl, 847);
+  avl = remove_int(avl, 642);
+  avl = remove_int(avl, 1004);
+  avl = remove_int(avl, 795);
+  avl = remove_int(avl, 465);
+  avl = gpr_avl_add(avl, box(636), box(1446), nullptr);
+  avl = remove_int(avl, 152);
+  avl = gpr_avl_add(avl, box(61), box(1448), nullptr);
+  avl = remove_int(avl, 929);
+  avl = remove_int(avl, 9);
+  avl = gpr_avl_add(avl, box(251), box(1451), nullptr);
+  avl = gpr_avl_add(avl, box(672), box(1452), nullptr);
+  avl = gpr_avl_add(avl, box(66), box(1453), nullptr);
+  avl = remove_int(avl, 693);
+  avl = remove_int(avl, 914);
+  avl = remove_int(avl, 116);
+  avl = remove_int(avl, 577);
+  avl = gpr_avl_add(avl, box(618), box(1458), nullptr);
+  avl = gpr_avl_add(avl, box(495), box(1459), nullptr);
+  avl = remove_int(avl, 450);
+  avl = gpr_avl_add(avl, box(533), box(1461), nullptr);
+  avl = gpr_avl_add(avl, box(414), box(1462), nullptr);
+  avl = remove_int(avl, 74);
+  avl = remove_int(avl, 236);
+  avl = gpr_avl_add(avl, box(707), box(1465), nullptr);
+  avl = gpr_avl_add(avl, box(357), box(1466), nullptr);
+  avl = gpr_avl_add(avl, box(1007), box(1467), nullptr);
+  avl = gpr_avl_add(avl, box(811), box(1468), nullptr);
+  avl = gpr_avl_add(avl, box(418), box(1469), nullptr);
+  avl = gpr_avl_add(avl, box(164), box(1470), nullptr);
+  avl = gpr_avl_add(avl, box(622), box(1471), nullptr);
+  avl = remove_int(avl, 22);
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 732);
+  avl = remove_int(avl, 7);
+  avl = remove_int(avl, 447);
+  avl = gpr_avl_add(avl, box(221), box(1477), nullptr);
+  avl = gpr_avl_add(avl, box(202), box(1478), nullptr);
+  avl = gpr_avl_add(avl, box(312), box(1479), nullptr);
+  avl = remove_int(avl, 274);
+  avl = gpr_avl_add(avl, box(684), box(1481), nullptr);
+  avl = gpr_avl_add(avl, box(954), box(1482), nullptr);
+  avl = gpr_avl_add(avl, box(637), box(1483), nullptr);
+  avl = remove_int(avl, 716);
+  avl = gpr_avl_add(avl, box(198), box(1485), nullptr);
+  avl = remove_int(avl, 340);
+  avl = remove_int(avl, 137);
+  avl = remove_int(avl, 995);
+  avl = remove_int(avl, 1004);
+  avl = gpr_avl_add(avl, box(661), box(1490), nullptr);
+  avl = gpr_avl_add(avl, box(862), box(1491), nullptr);
+  avl = remove_int(avl, 527);
+  avl = gpr_avl_add(avl, box(945), box(1493), nullptr);
+  avl = remove_int(avl, 355);
+  avl = remove_int(avl, 144);
+  avl = gpr_avl_add(avl, box(229), box(1496), nullptr);
+  avl = gpr_avl_add(avl, box(237), box(1497), nullptr);
+  avl = remove_int(avl, 471);
+  avl = remove_int(avl, 901);
+  avl = gpr_avl_add(avl, box(905), box(1500), nullptr);
+  avl = remove_int(avl, 19);
+  avl = remove_int(avl, 896);
+  avl = remove_int(avl, 585);
+  avl = remove_int(avl, 308);
+  avl = gpr_avl_add(avl, box(547), box(1505), nullptr);
+  avl = gpr_avl_add(avl, box(552), box(1506), nullptr);
+  avl = gpr_avl_add(avl, box(30), box(1507), nullptr);
+  avl = gpr_avl_add(avl, box(445), box(1508), nullptr);
+  avl = remove_int(avl, 785);
+  avl = remove_int(avl, 185);
+  avl = gpr_avl_add(avl, box(405), box(1511), nullptr);
+  avl = gpr_avl_add(avl, box(733), box(1512), nullptr);
+  avl = gpr_avl_add(avl, box(573), box(1513), nullptr);
+  avl = gpr_avl_add(avl, box(492), box(1514), nullptr);
+  avl = gpr_avl_add(avl, box(343), box(1515), nullptr);
+  avl = gpr_avl_add(avl, box(527), box(1516), nullptr);
+  avl = gpr_avl_add(avl, box(596), box(1517), nullptr);
+  avl = gpr_avl_add(avl, box(519), box(1518), nullptr);
+  avl = remove_int(avl, 243);
+  avl = remove_int(avl, 722);
+  avl = gpr_avl_add(avl, box(772), box(1521), nullptr);
+  avl = remove_int(avl, 152);
+  avl = remove_int(avl, 305);
+  avl = gpr_avl_add(avl, box(754), box(1524), nullptr);
+  avl = gpr_avl_add(avl, box(373), box(1525), nullptr);
+  avl = remove_int(avl, 995);
+  avl = gpr_avl_add(avl, box(329), box(1527), nullptr);
+  avl = remove_int(avl, 397);
+  avl = gpr_avl_add(avl, box(884), box(1529), nullptr);
+  avl = remove_int(avl, 329);
+  avl = remove_int(avl, 240);
+  avl = gpr_avl_add(avl, box(566), box(1532), nullptr);
+  avl = gpr_avl_add(avl, box(232), box(1533), nullptr);
+  avl = remove_int(avl, 993);
+  avl = gpr_avl_add(avl, box(888), box(1535), nullptr);
+  avl = remove_int(avl, 242);
+  avl = gpr_avl_add(avl, box(941), box(1537), nullptr);
+  avl = remove_int(avl, 415);
+  avl = gpr_avl_add(avl, box(992), box(1539), nullptr);
+  avl = remove_int(avl, 289);
+  avl = gpr_avl_add(avl, box(60), box(1541), nullptr);
+  avl = gpr_avl_add(avl, box(97), box(1542), nullptr);
+  avl = remove_int(avl, 965);
+  avl = remove_int(avl, 267);
+  avl = remove_int(avl, 360);
+  avl = gpr_avl_add(avl, box(5), box(1546), nullptr);
+  avl = remove_int(avl, 429);
+  avl = gpr_avl_add(avl, box(412), box(1548), nullptr);
+  avl = remove_int(avl, 632);
+  avl = remove_int(avl, 113);
+  avl = gpr_avl_add(avl, box(48), box(1551), nullptr);
+  avl = gpr_avl_add(avl, box(108), box(1552), nullptr);
+  avl = gpr_avl_add(avl, box(750), box(1553), nullptr);
+  avl = remove_int(avl, 188);
+  avl = gpr_avl_add(avl, box(668), box(1555), nullptr);
+  avl = remove_int(avl, 37);
+  avl = remove_int(avl, 737);
+  avl = gpr_avl_add(avl, box(93), box(1558), nullptr);
+  avl = gpr_avl_add(avl, box(628), box(1559), nullptr);
+  avl = gpr_avl_add(avl, box(480), box(1560), nullptr);
+  avl = remove_int(avl, 958);
+  avl = remove_int(avl, 565);
+  avl = remove_int(avl, 32);
+  avl = remove_int(avl, 1);
+  avl = remove_int(avl, 335);
+  avl = gpr_avl_add(avl, box(136), box(1566), nullptr);
+  avl = gpr_avl_add(avl, box(469), box(1567), nullptr);
+  avl = remove_int(avl, 349);
+  avl = gpr_avl_add(avl, box(768), box(1569), nullptr);
+  avl = gpr_avl_add(avl, box(915), box(1570), nullptr);
+  avl = remove_int(avl, 1014);
+  avl = gpr_avl_add(avl, box(117), box(1572), nullptr);
+  avl = remove_int(avl, 62);
+  avl = gpr_avl_add(avl, box(382), box(1574), nullptr);
+  avl = remove_int(avl, 571);
+  avl = gpr_avl_add(avl, box(655), box(1576), nullptr);
+  avl = gpr_avl_add(avl, box(323), box(1577), nullptr);
+  avl = remove_int(avl, 869);
+  avl = remove_int(avl, 151);
+  avl = gpr_avl_add(avl, box(1019), box(1580), nullptr);
+  avl = gpr_avl_add(avl, box(984), box(1581), nullptr);
+  avl = gpr_avl_add(avl, box(870), box(1582), nullptr);
+  avl = gpr_avl_add(avl, box(376), box(1583), nullptr);
+  avl = remove_int(avl, 625);
+  avl = gpr_avl_add(avl, box(733), box(1585), nullptr);
+  avl = remove_int(avl, 532);
+  avl = remove_int(avl, 444);
+  avl = gpr_avl_add(avl, box(428), box(1588), nullptr);
+  avl = gpr_avl_add(avl, box(860), box(1589), nullptr);
+  avl = gpr_avl_add(avl, box(173), box(1590), nullptr);
+  avl = remove_int(avl, 649);
+  avl = remove_int(avl, 913);
+  avl = remove_int(avl, 1);
+  avl = remove_int(avl, 304);
+  avl = gpr_avl_add(avl, box(604), box(1595), nullptr);
+  avl = gpr_avl_add(avl, box(639), box(1596), nullptr);
+  avl = remove_int(avl, 431);
+  avl = gpr_avl_add(avl, box(993), box(1598), nullptr);
+  avl = remove_int(avl, 681);
+  avl = remove_int(avl, 927);
+  avl = gpr_avl_add(avl, box(87), box(1601), nullptr);
+  avl = gpr_avl_add(avl, box(91), box(1602), nullptr);
+  avl = remove_int(avl, 61);
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 305);
+  avl = remove_int(avl, 304);
+  avl = remove_int(avl, 1016);
+  avl = gpr_avl_add(avl, box(903), box(1608), nullptr);
+  avl = gpr_avl_add(avl, box(951), box(1609), nullptr);
+  avl = gpr_avl_add(avl, box(146), box(1610), nullptr);
+  avl = gpr_avl_add(avl, box(482), box(1611), nullptr);
+  avl = gpr_avl_add(avl, box(71), box(1612), nullptr);
+  avl = remove_int(avl, 246);
+  avl = remove_int(avl, 696);
+  avl = gpr_avl_add(avl, box(636), box(1615), nullptr);
+  avl = gpr_avl_add(avl, box(295), box(1616), nullptr);
+  avl = remove_int(avl, 11);
+  avl = remove_int(avl, 231);
+  avl = gpr_avl_add(avl, box(905), box(1619), nullptr);
+  avl = gpr_avl_add(avl, box(993), box(1620), nullptr);
+  avl = gpr_avl_add(avl, box(433), box(1621), nullptr);
+  avl = gpr_avl_add(avl, box(117), box(1622), nullptr);
+  avl = gpr_avl_add(avl, box(467), box(1623), nullptr);
+  avl = remove_int(avl, 419);
+  avl = gpr_avl_add(avl, box(179), box(1625), nullptr);
+  avl = remove_int(avl, 926);
+  avl = remove_int(avl, 326);
+  avl = gpr_avl_add(avl, box(551), box(1628), nullptr);
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 476);
+  avl = remove_int(avl, 823);
+  avl = gpr_avl_add(avl, box(350), box(1632), nullptr);
+  avl = gpr_avl_add(avl, box(133), box(1633), nullptr);
+  avl = remove_int(avl, 906);
+  avl = gpr_avl_add(avl, box(827), box(1635), nullptr);
+  avl = gpr_avl_add(avl, box(201), box(1636), nullptr);
+  avl = remove_int(avl, 124);
+  avl = remove_int(avl, 662);
+  avl = gpr_avl_add(avl, box(314), box(1639), nullptr);
+  avl = gpr_avl_add(avl, box(986), box(1640), nullptr);
+  avl = gpr_avl_add(avl, box(622), box(1641), nullptr);
+  avl = remove_int(avl, 130);
+  avl = gpr_avl_add(avl, box(861), box(1643), nullptr);
+  avl = remove_int(avl, 497);
+  avl = remove_int(avl, 905);
+  avl = gpr_avl_add(avl, box(502), box(1646), nullptr);
+  avl = remove_int(avl, 721);
+  avl = gpr_avl_add(avl, box(514), box(1648), nullptr);
+  avl = gpr_avl_add(avl, box(410), box(1649), nullptr);
+  avl = remove_int(avl, 869);
+  avl = remove_int(avl, 247);
+  avl = gpr_avl_add(avl, box(450), box(1652), nullptr);
+  avl = remove_int(avl, 364);
+  avl = gpr_avl_add(avl, box(963), box(1654), nullptr);
+  avl = gpr_avl_add(avl, box(146), box(1655), nullptr);
+  avl = remove_int(avl, 147);
+  avl = remove_int(avl, 789);
+  avl = gpr_avl_add(avl, box(693), box(1658), nullptr);
+  avl = gpr_avl_add(avl, box(959), box(1659), nullptr);
+  avl = remove_int(avl, 478);
+  avl = gpr_avl_add(avl, box(116), box(1661), nullptr);
+  avl = gpr_avl_add(avl, box(520), box(1662), nullptr);
+  avl = gpr_avl_add(avl, box(809), box(1663), nullptr);
+  avl = gpr_avl_add(avl, box(667), box(1664), nullptr);
+  avl = gpr_avl_add(avl, box(406), box(1665), nullptr);
+  avl = remove_int(avl, 409);
+  avl = gpr_avl_add(avl, box(558), box(1667), nullptr);
+  avl = gpr_avl_add(avl, box(0), box(1668), nullptr);
+  avl = gpr_avl_add(avl, box(948), box(1669), nullptr);
+  avl = gpr_avl_add(avl, box(576), box(1670), nullptr);
+  avl = remove_int(avl, 864);
+  avl = remove_int(avl, 840);
+  avl = remove_int(avl, 1001);
+  avl = gpr_avl_add(avl, box(232), box(1674), nullptr);
+  avl = remove_int(avl, 676);
+  avl = remove_int(avl, 752);
+  avl = remove_int(avl, 667);
+  avl = remove_int(avl, 605);
+  avl = gpr_avl_add(avl, box(258), box(1679), nullptr);
+  avl = gpr_avl_add(avl, box(648), box(1680), nullptr);
+  avl = gpr_avl_add(avl, box(761), box(1681), nullptr);
+  avl = remove_int(avl, 293);
+  avl = remove_int(avl, 893);
+  avl = gpr_avl_add(avl, box(194), box(1684), nullptr);
+  avl = remove_int(avl, 233);
+  avl = gpr_avl_add(avl, box(888), box(1686), nullptr);
+  avl = remove_int(avl, 470);
+  avl = remove_int(avl, 703);
+  avl = remove_int(avl, 190);
+  avl = remove_int(avl, 359);
+  avl = gpr_avl_add(avl, box(621), box(1691), nullptr);
+  avl = remove_int(avl, 634);
+  avl = remove_int(avl, 335);
+  avl = gpr_avl_add(avl, box(718), box(1694), nullptr);
+  avl = gpr_avl_add(avl, box(463), box(1695), nullptr);
+  avl = gpr_avl_add(avl, box(233), box(1696), nullptr);
+  avl = remove_int(avl, 376);
+  avl = remove_int(avl, 496);
+  avl = remove_int(avl, 819);
+  avl = remove_int(avl, 38);
+  avl = remove_int(avl, 436);
+  avl = remove_int(avl, 102);
+  avl = gpr_avl_add(avl, box(607), box(1703), nullptr);
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(716), box(1705), nullptr);
+  avl = remove_int(avl, 639);
+  avl = remove_int(avl, 775);
+  avl = remove_int(avl, 578);
+  avl = remove_int(avl, 464);
+  avl = remove_int(avl, 679);
+  avl = remove_int(avl, 615);
+  avl = remove_int(avl, 104);
+  avl = gpr_avl_add(avl, box(414), box(1713), nullptr);
+  avl = gpr_avl_add(avl, box(212), box(1714), nullptr);
+  avl = gpr_avl_add(avl, box(266), box(1715), nullptr);
+  avl = gpr_avl_add(avl, box(238), box(1716), nullptr);
+  avl = remove_int(avl, 153);
+  avl = gpr_avl_add(avl, box(585), box(1718), nullptr);
+  avl = remove_int(avl, 121);
+  avl = gpr_avl_add(avl, box(534), box(1720), nullptr);
+  avl = remove_int(avl, 579);
+  avl = gpr_avl_add(avl, box(127), box(1722), nullptr);
+  avl = gpr_avl_add(avl, box(399), box(1723), nullptr);
+  avl = remove_int(avl, 417);
+  avl = gpr_avl_add(avl, box(978), box(1725), nullptr);
+  avl = gpr_avl_add(avl, box(768), box(1726), nullptr);
+  avl = remove_int(avl, 985);
+  avl = gpr_avl_add(avl, box(536), box(1728), nullptr);
+  avl = gpr_avl_add(avl, box(449), box(1729), nullptr);
+  avl = gpr_avl_add(avl, box(586), box(1730), nullptr);
+  avl = remove_int(avl, 998);
+  avl = remove_int(avl, 394);
+  avl = remove_int(avl, 141);
+  avl = gpr_avl_add(avl, box(889), box(1734), nullptr);
+  avl = gpr_avl_add(avl, box(871), box(1735), nullptr);
+  avl = gpr_avl_add(avl, box(76), box(1736), nullptr);
+  avl = gpr_avl_add(avl, box(549), box(1737), nullptr);
+  avl = gpr_avl_add(avl, box(757), box(1738), nullptr);
+  avl = remove_int(avl, 908);
+  avl = gpr_avl_add(avl, box(789), box(1740), nullptr);
+  avl = remove_int(avl, 224);
+  avl = gpr_avl_add(avl, box(407), box(1742), nullptr);
+  avl = gpr_avl_add(avl, box(381), box(1743), nullptr);
+  avl = gpr_avl_add(avl, box(561), box(1744), nullptr);
+  avl = gpr_avl_add(avl, box(667), box(1745), nullptr);
+  avl = gpr_avl_add(avl, box(522), box(1746), nullptr);
+  avl = gpr_avl_add(avl, box(948), box(1747), nullptr);
+  avl = remove_int(avl, 770);
+  avl = gpr_avl_add(avl, box(872), box(1749), nullptr);
+  avl = gpr_avl_add(avl, box(327), box(1750), nullptr);
+  avl = remove_int(avl, 10);
+  avl = gpr_avl_add(avl, box(122), box(1752), nullptr);
+  avl = remove_int(avl, 606);
+  avl = gpr_avl_add(avl, box(485), box(1754), nullptr);
+  avl = remove_int(avl, 6);
+  avl = gpr_avl_add(avl, box(329), box(1756), nullptr);
+  avl = gpr_avl_add(avl, box(783), box(1757), nullptr);
+  avl = remove_int(avl, 416);
+  avl = gpr_avl_add(avl, box(656), box(1759), nullptr);
+  avl = gpr_avl_add(avl, box(971), box(1760), nullptr);
+  avl = gpr_avl_add(avl, box(77), box(1761), nullptr);
+  avl = gpr_avl_add(avl, box(942), box(1762), nullptr);
+  avl = remove_int(avl, 361);
+  avl = gpr_avl_add(avl, box(66), box(1764), nullptr);
+  avl = gpr_avl_add(avl, box(299), box(1765), nullptr);
+  avl = gpr_avl_add(avl, box(929), box(1766), nullptr);
+  avl = gpr_avl_add(avl, box(797), box(1767), nullptr);
+  avl = remove_int(avl, 869);
+  avl = remove_int(avl, 907);
+  avl = gpr_avl_add(avl, box(870), box(1770), nullptr);
+  avl = remove_int(avl, 580);
+  avl = remove_int(avl, 120);
+  avl = gpr_avl_add(avl, box(913), box(1773), nullptr);
+  avl = remove_int(avl, 480);
+  avl = gpr_avl_add(avl, box(489), box(1775), nullptr);
+  avl = remove_int(avl, 845);
+  avl = gpr_avl_add(avl, box(896), box(1777), nullptr);
+  avl = remove_int(avl, 567);
+  avl = remove_int(avl, 427);
+  avl = gpr_avl_add(avl, box(443), box(1780), nullptr);
+  avl = gpr_avl_add(avl, box(3), box(1781), nullptr);
+  avl = remove_int(avl, 12);
+  avl = gpr_avl_add(avl, box(376), box(1783), nullptr);
+  avl = gpr_avl_add(avl, box(155), box(1784), nullptr);
+  avl = gpr_avl_add(avl, box(188), box(1785), nullptr);
+  avl = gpr_avl_add(avl, box(149), box(1786), nullptr);
+  avl = gpr_avl_add(avl, box(178), box(1787), nullptr);
+  avl = remove_int(avl, 84);
+  avl = gpr_avl_add(avl, box(805), box(1789), nullptr);
+  avl = gpr_avl_add(avl, box(612), box(1790), nullptr);
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(837), box(1792), nullptr);
+  avl = remove_int(avl, 173);
+  avl = remove_int(avl, 72);
+  avl = gpr_avl_add(avl, box(1014), box(1795), nullptr);
+  avl = remove_int(avl, 303);
+  avl = gpr_avl_add(avl, box(865), box(1797), nullptr);
+  avl = gpr_avl_add(avl, box(793), box(1798), nullptr);
+  avl = remove_int(avl, 173);
+  avl = remove_int(avl, 477);
+  avl = gpr_avl_add(avl, box(950), box(1801), nullptr);
+  avl = gpr_avl_add(avl, box(105), box(1802), nullptr);
+  avl = gpr_avl_add(avl, box(895), box(1803), nullptr);
+  avl = gpr_avl_add(avl, box(171), box(1804), nullptr);
+  avl = gpr_avl_add(avl, box(753), box(1805), nullptr);
+  avl = gpr_avl_add(avl, box(946), box(1806), nullptr);
+  avl = remove_int(avl, 194);
+  avl = remove_int(avl, 559);
+  avl = remove_int(avl, 116);
+  avl = gpr_avl_add(avl, box(968), box(1810), nullptr);
+  avl = remove_int(avl, 124);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(563), box(1813), nullptr);
+  avl = remove_int(avl, 182);
+  avl = gpr_avl_add(avl, box(816), box(1815), nullptr);
+  avl = remove_int(avl, 73);
+  avl = remove_int(avl, 261);
+  avl = gpr_avl_add(avl, box(847), box(1818), nullptr);
+  avl = gpr_avl_add(avl, box(368), box(1819), nullptr);
+  avl = gpr_avl_add(avl, box(808), box(1820), nullptr);
+  avl = gpr_avl_add(avl, box(779), box(1821), nullptr);
+  avl = remove_int(avl, 818);
+  avl = gpr_avl_add(avl, box(466), box(1823), nullptr);
+  avl = remove_int(avl, 316);
+  avl = gpr_avl_add(avl, box(986), box(1825), nullptr);
+  avl = gpr_avl_add(avl, box(688), box(1826), nullptr);
+  avl = gpr_avl_add(avl, box(509), box(1827), nullptr);
+  avl = gpr_avl_add(avl, box(51), box(1828), nullptr);
+  avl = remove_int(avl, 655);
+  avl = remove_int(avl, 785);
+  avl = remove_int(avl, 893);
+  avl = gpr_avl_add(avl, box(167), box(1832), nullptr);
+  avl = remove_int(avl, 13);
+  avl = remove_int(avl, 263);
+  avl = gpr_avl_add(avl, box(1009), box(1835), nullptr);
+  avl = remove_int(avl, 480);
+  avl = remove_int(avl, 778);
+  avl = remove_int(avl, 713);
+  avl = remove_int(avl, 628);
+  avl = gpr_avl_add(avl, box(803), box(1840), nullptr);
+  avl = remove_int(avl, 267);
+  avl = gpr_avl_add(avl, box(676), box(1842), nullptr);
+  avl = gpr_avl_add(avl, box(231), box(1843), nullptr);
+  avl = gpr_avl_add(avl, box(824), box(1844), nullptr);
+  avl = remove_int(avl, 961);
+  avl = gpr_avl_add(avl, box(311), box(1846), nullptr);
+  avl = gpr_avl_add(avl, box(420), box(1847), nullptr);
+  avl = gpr_avl_add(avl, box(960), box(1848), nullptr);
+  avl = gpr_avl_add(avl, box(468), box(1849), nullptr);
+  avl = gpr_avl_add(avl, box(815), box(1850), nullptr);
+  avl = remove_int(avl, 247);
+  avl = remove_int(avl, 194);
+  avl = gpr_avl_add(avl, box(546), box(1853), nullptr);
+  avl = remove_int(avl, 222);
+  avl = remove_int(avl, 914);
+  avl = remove_int(avl, 741);
+  avl = gpr_avl_add(avl, box(470), box(1857), nullptr);
+  avl = gpr_avl_add(avl, box(933), box(1858), nullptr);
+  avl = gpr_avl_add(avl, box(97), box(1859), nullptr);
+  avl = remove_int(avl, 564);
+  avl = remove_int(avl, 295);
+  avl = gpr_avl_add(avl, box(864), box(1862), nullptr);
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(124), box(1864), nullptr);
+  avl = gpr_avl_add(avl, box(1000), box(1865), nullptr);
+  avl = gpr_avl_add(avl, box(228), box(1866), nullptr);
+  avl = gpr_avl_add(avl, box(187), box(1867), nullptr);
+  avl = remove_int(avl, 224);
+  avl = remove_int(avl, 306);
+  avl = remove_int(avl, 884);
+  avl = gpr_avl_add(avl, box(449), box(1871), nullptr);
+  avl = gpr_avl_add(avl, box(353), box(1872), nullptr);
+  avl = gpr_avl_add(avl, box(994), box(1873), nullptr);
+  avl = gpr_avl_add(avl, box(596), box(1874), nullptr);
+  avl = gpr_avl_add(avl, box(996), box(1875), nullptr);
+  avl = gpr_avl_add(avl, box(101), box(1876), nullptr);
+  avl = gpr_avl_add(avl, box(1012), box(1877), nullptr);
+  avl = gpr_avl_add(avl, box(982), box(1878), nullptr);
+  avl = gpr_avl_add(avl, box(742), box(1879), nullptr);
+  avl = remove_int(avl, 92);
+  avl = remove_int(avl, 1022);
+  avl = gpr_avl_add(avl, box(941), box(1882), nullptr);
+  avl = remove_int(avl, 742);
+  avl = remove_int(avl, 919);
+  avl = gpr_avl_add(avl, box(588), box(1885), nullptr);
+  avl = remove_int(avl, 221);
+  avl = gpr_avl_add(avl, box(356), box(1887), nullptr);
+  avl = gpr_avl_add(avl, box(932), box(1888), nullptr);
+  avl = remove_int(avl, 837);
+  avl = gpr_avl_add(avl, box(394), box(1890), nullptr);
+  avl = gpr_avl_add(avl, box(642), box(1891), nullptr);
+  avl = gpr_avl_add(avl, box(52), box(1892), nullptr);
+  avl = gpr_avl_add(avl, box(437), box(1893), nullptr);
+  avl = gpr_avl_add(avl, box(948), box(1894), nullptr);
+  avl = gpr_avl_add(avl, box(93), box(1895), nullptr);
+  avl = remove_int(avl, 873);
+  avl = remove_int(avl, 336);
+  avl = remove_int(avl, 277);
+  avl = remove_int(avl, 932);
+  avl = gpr_avl_add(avl, box(80), box(1900), nullptr);
+  avl = gpr_avl_add(avl, box(952), box(1901), nullptr);
+  avl = gpr_avl_add(avl, box(510), box(1902), nullptr);
+  avl = remove_int(avl, 876);
+  avl = remove_int(avl, 612);
+  avl = gpr_avl_add(avl, box(923), box(1905), nullptr);
+  avl = gpr_avl_add(avl, box(475), box(1906), nullptr);
+  avl = remove_int(avl, 478);
+  avl = remove_int(avl, 148);
+  avl = gpr_avl_add(avl, box(538), box(1909), nullptr);
+  avl = remove_int(avl, 47);
+  avl = gpr_avl_add(avl, box(89), box(1911), nullptr);
+  avl = remove_int(avl, 723);
+  avl = gpr_avl_add(avl, box(687), box(1913), nullptr);
+  avl = gpr_avl_add(avl, box(480), box(1914), nullptr);
+  avl = gpr_avl_add(avl, box(149), box(1915), nullptr);
+  avl = remove_int(avl, 68);
+  avl = remove_int(avl, 862);
+  avl = remove_int(avl, 363);
+  avl = gpr_avl_add(avl, box(996), box(1919), nullptr);
+  avl = remove_int(avl, 380);
+  avl = gpr_avl_add(avl, box(957), box(1921), nullptr);
+  avl = remove_int(avl, 413);
+  avl = gpr_avl_add(avl, box(360), box(1923), nullptr);
+  avl = gpr_avl_add(avl, box(304), box(1924), nullptr);
+  avl = gpr_avl_add(avl, box(634), box(1925), nullptr);
+  avl = gpr_avl_add(avl, box(506), box(1926), nullptr);
+  avl = remove_int(avl, 248);
+  avl = gpr_avl_add(avl, box(124), box(1928), nullptr);
+  avl = gpr_avl_add(avl, box(181), box(1929), nullptr);
+  avl = remove_int(avl, 507);
+  avl = gpr_avl_add(avl, box(141), box(1931), nullptr);
+  avl = remove_int(avl, 409);
+  avl = remove_int(avl, 129);
+  avl = remove_int(avl, 694);
+  avl = remove_int(avl, 723);
+  avl = gpr_avl_add(avl, box(998), box(1936), nullptr);
+  avl = gpr_avl_add(avl, box(906), box(1937), nullptr);
+  avl = gpr_avl_add(avl, box(44), box(1938), nullptr);
+  avl = remove_int(avl, 949);
+  avl = remove_int(avl, 117);
+  avl = gpr_avl_add(avl, box(700), box(1941), nullptr);
+  avl = gpr_avl_add(avl, box(258), box(1942), nullptr);
+  avl = remove_int(avl, 828);
+  avl = gpr_avl_add(avl, box(860), box(1944), nullptr);
+  avl = gpr_avl_add(avl, box(987), box(1945), nullptr);
+  avl = gpr_avl_add(avl, box(316), box(1946), nullptr);
+  avl = gpr_avl_add(avl, box(919), box(1947), nullptr);
+  avl = remove_int(avl, 84);
+  avl = gpr_avl_add(avl, box(473), box(1949), nullptr);
+  avl = remove_int(avl, 127);
+  avl = remove_int(avl, 829);
+  avl = remove_int(avl, 829);
+  avl = gpr_avl_add(avl, box(488), box(1953), nullptr);
+  avl = gpr_avl_add(avl, box(954), box(1954), nullptr);
+  avl = remove_int(avl, 198);
+  avl = remove_int(avl, 972);
+  avl = remove_int(avl, 670);
+  avl = gpr_avl_add(avl, box(822), box(1958), nullptr);
+  avl = remove_int(avl, 589);
+  avl = remove_int(avl, 459);
+  avl = gpr_avl_add(avl, box(1003), box(1961), nullptr);
+  avl = gpr_avl_add(avl, box(657), box(1962), nullptr);
+  avl = gpr_avl_add(avl, box(477), box(1963), nullptr);
+  avl = gpr_avl_add(avl, box(923), box(1964), nullptr);
+  avl = remove_int(avl, 496);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(127), box(1967), nullptr);
+  avl = gpr_avl_add(avl, box(1013), box(1968), nullptr);
+  avl = gpr_avl_add(avl, box(778), box(1969), nullptr);
+  avl = remove_int(avl, 5);
+  avl = remove_int(avl, 990);
+  avl = remove_int(avl, 850);
+  avl = remove_int(avl, 160);
+  avl = remove_int(avl, 86);
+  avl = gpr_avl_add(avl, box(283), box(1975), nullptr);
+  avl = remove_int(avl, 278);
+  avl = remove_int(avl, 297);
+  avl = remove_int(avl, 137);
+  avl = remove_int(avl, 653);
+  avl = gpr_avl_add(avl, box(702), box(1980), nullptr);
+  avl = remove_int(avl, 63);
+  avl = remove_int(avl, 427);
+  avl = remove_int(avl, 706);
+  avl = remove_int(avl, 806);
+  avl = gpr_avl_add(avl, box(335), box(1985), nullptr);
+  avl = gpr_avl_add(avl, box(412), box(1986), nullptr);
+  avl = remove_int(avl, 766);
+  avl = remove_int(avl, 937);
+  avl = remove_int(avl, 886);
+  avl = remove_int(avl, 652);
+  avl = gpr_avl_add(avl, box(545), box(1991), nullptr);
+  avl = gpr_avl_add(avl, box(408), box(1992), nullptr);
+  avl = gpr_avl_add(avl, box(841), box(1993), nullptr);
+  avl = remove_int(avl, 593);
+  avl = gpr_avl_add(avl, box(582), box(1995), nullptr);
+  avl = gpr_avl_add(avl, box(597), box(1996), nullptr);
+  avl = remove_int(avl, 49);
+  avl = remove_int(avl, 835);
+  avl = gpr_avl_add(avl, box(417), box(1999), nullptr);
+  avl = gpr_avl_add(avl, box(191), box(2000), nullptr);
+  avl = remove_int(avl, 406);
+  avl = gpr_avl_add(avl, box(30), box(2002), nullptr);
+  avl = remove_int(avl, 841);
+  avl = remove_int(avl, 50);
+  avl = gpr_avl_add(avl, box(967), box(2005), nullptr);
+  avl = gpr_avl_add(avl, box(849), box(2006), nullptr);
+  avl = remove_int(avl, 608);
+  avl = gpr_avl_add(avl, box(306), box(2008), nullptr);
+  avl = remove_int(avl, 779);
+  avl = gpr_avl_add(avl, box(897), box(2010), nullptr);
+  avl = gpr_avl_add(avl, box(147), box(2011), nullptr);
+  avl = remove_int(avl, 982);
+  avl = gpr_avl_add(avl, box(470), box(2013), nullptr);
+  avl = remove_int(avl, 951);
+  avl = gpr_avl_add(avl, box(388), box(2015), nullptr);
+  avl = remove_int(avl, 616);
+  avl = remove_int(avl, 721);
+  avl = remove_int(avl, 942);
+  avl = remove_int(avl, 589);
+  avl = gpr_avl_add(avl, box(218), box(2020), nullptr);
+  avl = remove_int(avl, 671);
+  avl = gpr_avl_add(avl, box(1020), box(2022), nullptr);
+  avl = remove_int(avl, 277);
+  avl = gpr_avl_add(avl, box(681), box(2024), nullptr);
+  avl = gpr_avl_add(avl, box(179), box(2025), nullptr);
+  avl = gpr_avl_add(avl, box(370), box(2026), nullptr);
+  avl = gpr_avl_add(avl, box(0), box(2027), nullptr);
+  avl = remove_int(avl, 523);
+  avl = gpr_avl_add(avl, box(99), box(2029), nullptr);
+  avl = gpr_avl_add(avl, box(334), box(2030), nullptr);
+  avl = gpr_avl_add(avl, box(569), box(2031), nullptr);
+  avl = gpr_avl_add(avl, box(257), box(2032), nullptr);
+  avl = remove_int(avl, 572);
+  avl = gpr_avl_add(avl, box(805), box(2034), nullptr);
+  avl = gpr_avl_add(avl, box(143), box(2035), nullptr);
+  avl = gpr_avl_add(avl, box(670), box(2036), nullptr);
+  avl = remove_int(avl, 42);
+  avl = gpr_avl_add(avl, box(46), box(2038), nullptr);
+  avl = remove_int(avl, 970);
+  avl = gpr_avl_add(avl, box(353), box(2040), nullptr);
+  avl = remove_int(avl, 258);
+  avl = gpr_avl_add(avl, box(451), box(2042), nullptr);
+  avl = gpr_avl_add(avl, box(28), box(2043), nullptr);
+  avl = gpr_avl_add(avl, box(729), box(2044), nullptr);
+  avl = gpr_avl_add(avl, box(401), box(2045), nullptr);
+  avl = gpr_avl_add(avl, box(614), box(2046), nullptr);
+  avl = remove_int(avl, 990);
+  avl = remove_int(avl, 212);
+  avl = remove_int(avl, 22);
+  avl = remove_int(avl, 677);
+  avl = gpr_avl_add(avl, box(1016), box(2051), nullptr);
+  avl = gpr_avl_add(avl, box(980), box(2052), nullptr);
+  avl = gpr_avl_add(avl, box(990), box(2053), nullptr);
+  avl = gpr_avl_add(avl, box(355), box(2054), nullptr);
+  avl = remove_int(avl, 730);
+  avl = remove_int(avl, 37);
+  avl = gpr_avl_add(avl, box(407), box(2057), nullptr);
+  avl = gpr_avl_add(avl, box(222), box(2058), nullptr);
+  avl = gpr_avl_add(avl, box(439), box(2059), nullptr);
+  avl = gpr_avl_add(avl, box(563), box(2060), nullptr);
+  avl = remove_int(avl, 992);
+  avl = remove_int(avl, 786);
+  avl = gpr_avl_add(avl, box(1), box(2063), nullptr);
+  avl = gpr_avl_add(avl, box(473), box(2064), nullptr);
+  avl = gpr_avl_add(avl, box(992), box(2065), nullptr);
+  avl = remove_int(avl, 190);
+  avl = remove_int(avl, 450);
+  avl = remove_int(avl, 1020);
+  avl = remove_int(avl, 149);
+  avl = gpr_avl_add(avl, box(329), box(2070), nullptr);
+  avl = gpr_avl_add(avl, box(35), box(2071), nullptr);
+  avl = remove_int(avl, 843);
+  avl = gpr_avl_add(avl, box(855), box(2073), nullptr);
+  avl = remove_int(avl, 878);
+  avl = gpr_avl_add(avl, box(993), box(2075), nullptr);
+  avl = gpr_avl_add(avl, box(87), box(2076), nullptr);
+  avl = gpr_avl_add(avl, box(572), box(2077), nullptr);
+  avl = remove_int(avl, 896);
+  avl = gpr_avl_add(avl, box(849), box(2079), nullptr);
+  avl = remove_int(avl, 597);
+  avl = gpr_avl_add(avl, box(472), box(2081), nullptr);
+  avl = remove_int(avl, 778);
+  avl = remove_int(avl, 934);
+  avl = remove_int(avl, 314);
+  avl = gpr_avl_add(avl, box(101), box(2085), nullptr);
+  avl = remove_int(avl, 938);
+  avl = remove_int(avl, 1010);
+  avl = gpr_avl_add(avl, box(579), box(2088), nullptr);
+  avl = remove_int(avl, 798);
+  avl = remove_int(avl, 88);
+  avl = gpr_avl_add(avl, box(851), box(2091), nullptr);
+  avl = remove_int(avl, 705);
+  avl = gpr_avl_add(avl, box(26), box(2093), nullptr);
+  avl = remove_int(avl, 973);
+  avl = gpr_avl_add(avl, box(923), box(2095), nullptr);
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(310), box(2097), nullptr);
+  avl = gpr_avl_add(avl, box(269), box(2098), nullptr);
+  avl = remove_int(avl, 173);
+  avl = gpr_avl_add(avl, box(279), box(2100), nullptr);
+  avl = remove_int(avl, 203);
+  avl = gpr_avl_add(avl, box(411), box(2102), nullptr);
+  avl = remove_int(avl, 950);
+  avl = gpr_avl_add(avl, box(6), box(2104), nullptr);
+  avl = remove_int(avl, 400);
+  avl = remove_int(avl, 468);
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(627), box(2108), nullptr);
+  avl = remove_int(avl, 727);
+  avl = remove_int(avl, 148);
+  avl = remove_int(avl, 98);
+  avl = remove_int(avl, 997);
+  avl = remove_int(avl, 215);
+  avl = remove_int(avl, 628);
+  avl = remove_int(avl, 826);
+  avl = remove_int(avl, 664);
+  avl = gpr_avl_add(avl, box(76), box(2117), nullptr);
+  avl = remove_int(avl, 194);
+  avl = remove_int(avl, 18);
+  avl = gpr_avl_add(avl, box(727), box(2120), nullptr);
+  avl = remove_int(avl, 295);
+  avl = gpr_avl_add(avl, box(645), box(2122), nullptr);
+  avl = remove_int(avl, 321);
+  avl = remove_int(avl, 863);
+  avl = gpr_avl_add(avl, box(824), box(2125), nullptr);
+  avl = gpr_avl_add(avl, box(651), box(2126), nullptr);
+  avl = gpr_avl_add(avl, box(804), box(2127), nullptr);
+  avl = remove_int(avl, 307);
+  avl = gpr_avl_add(avl, box(867), box(2129), nullptr);
+  avl = remove_int(avl, 384);
+  avl = gpr_avl_add(avl, box(819), box(2131), nullptr);
+  avl = remove_int(avl, 674);
+  avl = gpr_avl_add(avl, box(76), box(2133), nullptr);
+  avl = remove_int(avl, 898);
+  avl = gpr_avl_add(avl, box(45), box(2135), nullptr);
+  avl = gpr_avl_add(avl, box(512), box(2136), nullptr);
+  avl = remove_int(avl, 773);
+  avl = remove_int(avl, 907);
+  avl = remove_int(avl, 382);
+  avl = remove_int(avl, 95);
+  avl = remove_int(avl, 734);
+  avl = remove_int(avl, 81);
+  avl = gpr_avl_add(avl, box(348), box(2143), nullptr);
+  avl = remove_int(avl, 509);
+  avl = remove_int(avl, 301);
+  avl = gpr_avl_add(avl, box(861), box(2146), nullptr);
+  avl = gpr_avl_add(avl, box(918), box(2147), nullptr);
+  avl = remove_int(avl, 992);
+  avl = gpr_avl_add(avl, box(356), box(2149), nullptr);
+  avl = remove_int(avl, 64);
+  avl = remove_int(avl, 444);
+  avl = remove_int(avl, 741);
+  avl = gpr_avl_add(avl, box(710), box(2153), nullptr);
+  avl = gpr_avl_add(avl, box(264), box(2154), nullptr);
+  avl = remove_int(avl, 347);
+  avl = remove_int(avl, 250);
+  avl = gpr_avl_add(avl, box(82), box(2157), nullptr);
+  avl = gpr_avl_add(avl, box(571), box(2158), nullptr);
+  avl = remove_int(avl, 721);
+  avl = remove_int(avl, 622);
+  avl = gpr_avl_add(avl, box(950), box(2161), nullptr);
+  avl = gpr_avl_add(avl, box(94), box(2162), nullptr);
+  avl = remove_int(avl, 970);
+  avl = gpr_avl_add(avl, box(815), box(2164), nullptr);
+  avl = remove_int(avl, 930);
+  avl = remove_int(avl, 703);
+  avl = gpr_avl_add(avl, box(432), box(2167), nullptr);
+  avl = remove_int(avl, 544);
+  avl = gpr_avl_add(avl, box(21), box(2169), nullptr);
+  avl = gpr_avl_add(avl, box(186), box(2170), nullptr);
+  avl = remove_int(avl, 143);
+  avl = gpr_avl_add(avl, box(425), box(2172), nullptr);
+  avl = remove_int(avl, 769);
+  avl = gpr_avl_add(avl, box(656), box(2174), nullptr);
+  avl = remove_int(avl, 29);
+  avl = gpr_avl_add(avl, box(464), box(2176), nullptr);
+  avl = remove_int(avl, 713);
+  avl = gpr_avl_add(avl, box(800), box(2178), nullptr);
+  avl = remove_int(avl, 621);
+  avl = gpr_avl_add(avl, box(962), box(2180), nullptr);
+  avl = remove_int(avl, 448);
+  avl = gpr_avl_add(avl, box(878), box(2182), nullptr);
+  avl = remove_int(avl, 39);
+  avl = remove_int(avl, 999);
+  avl = gpr_avl_add(avl, box(182), box(2185), nullptr);
+  avl = gpr_avl_add(avl, box(429), box(2186), nullptr);
+  avl = gpr_avl_add(avl, box(598), box(2187), nullptr);
+  avl = remove_int(avl, 551);
+  avl = gpr_avl_add(avl, box(827), box(2189), nullptr);
+  avl = gpr_avl_add(avl, box(809), box(2190), nullptr);
+  avl = remove_int(avl, 438);
+  avl = remove_int(avl, 811);
+  avl = gpr_avl_add(avl, box(808), box(2193), nullptr);
+  avl = gpr_avl_add(avl, box(788), box(2194), nullptr);
+  avl = remove_int(avl, 156);
+  avl = gpr_avl_add(avl, box(933), box(2196), nullptr);
+  avl = gpr_avl_add(avl, box(344), box(2197), nullptr);
+  avl = remove_int(avl, 460);
+  avl = gpr_avl_add(avl, box(161), box(2199), nullptr);
+  avl = gpr_avl_add(avl, box(444), box(2200), nullptr);
+  avl = remove_int(avl, 597);
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(703), box(2203), nullptr);
+  avl = remove_int(avl, 515);
+  avl = gpr_avl_add(avl, box(380), box(2205), nullptr);
+  avl = gpr_avl_add(avl, box(338), box(2206), nullptr);
+  avl = remove_int(avl, 550);
+  avl = remove_int(avl, 946);
+  avl = remove_int(avl, 714);
+  avl = remove_int(avl, 739);
+  avl = gpr_avl_add(avl, box(413), box(2211), nullptr);
+  avl = remove_int(avl, 450);
+  avl = gpr_avl_add(avl, box(411), box(2213), nullptr);
+  avl = gpr_avl_add(avl, box(117), box(2214), nullptr);
+  avl = gpr_avl_add(avl, box(322), box(2215), nullptr);
+  avl = gpr_avl_add(avl, box(915), box(2216), nullptr);
+  avl = gpr_avl_add(avl, box(410), box(2217), nullptr);
+  avl = gpr_avl_add(avl, box(66), box(2218), nullptr);
+  avl = remove_int(avl, 756);
+  avl = remove_int(avl, 596);
+  avl = gpr_avl_add(avl, box(882), box(2221), nullptr);
+  avl = gpr_avl_add(avl, box(930), box(2222), nullptr);
+  avl = gpr_avl_add(avl, box(36), box(2223), nullptr);
+  avl = remove_int(avl, 742);
+  avl = gpr_avl_add(avl, box(539), box(2225), nullptr);
+  avl = gpr_avl_add(avl, box(596), box(2226), nullptr);
+  avl = remove_int(avl, 82);
+  avl = remove_int(avl, 686);
+  avl = remove_int(avl, 933);
+  avl = remove_int(avl, 42);
+  avl = remove_int(avl, 340);
+  avl = gpr_avl_add(avl, box(126), box(2232), nullptr);
+  avl = gpr_avl_add(avl, box(493), box(2233), nullptr);
+  avl = gpr_avl_add(avl, box(839), box(2234), nullptr);
+  avl = remove_int(avl, 774);
+  avl = gpr_avl_add(avl, box(337), box(2236), nullptr);
+  avl = remove_int(avl, 322);
+  avl = gpr_avl_add(avl, box(16), box(2238), nullptr);
+  avl = remove_int(avl, 73);
+  avl = remove_int(avl, 85);
+  avl = remove_int(avl, 191);
+  avl = remove_int(avl, 541);
+  avl = gpr_avl_add(avl, box(704), box(2243), nullptr);
+  avl = remove_int(avl, 767);
+  avl = remove_int(avl, 1006);
+  avl = remove_int(avl, 844);
+  avl = remove_int(avl, 742);
+  avl = gpr_avl_add(avl, box(48), box(2248), nullptr);
+  avl = gpr_avl_add(avl, box(138), box(2249), nullptr);
+  avl = gpr_avl_add(avl, box(437), box(2250), nullptr);
+  avl = gpr_avl_add(avl, box(275), box(2251), nullptr);
+  avl = remove_int(avl, 520);
+  avl = gpr_avl_add(avl, box(1019), box(2253), nullptr);
+  avl = remove_int(avl, 955);
+  avl = gpr_avl_add(avl, box(270), box(2255), nullptr);
+  avl = remove_int(avl, 680);
+  avl = remove_int(avl, 698);
+  avl = gpr_avl_add(avl, box(735), box(2258), nullptr);
+  avl = gpr_avl_add(avl, box(400), box(2259), nullptr);
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(263), box(2261), nullptr);
+  avl = remove_int(avl, 704);
+  avl = gpr_avl_add(avl, box(757), box(2263), nullptr);
+  avl = remove_int(avl, 194);
+  avl = remove_int(avl, 616);
+  avl = remove_int(avl, 784);
+  avl = gpr_avl_add(avl, box(382), box(2267), nullptr);
+  avl = gpr_avl_add(avl, box(464), box(2268), nullptr);
+  avl = gpr_avl_add(avl, box(817), box(2269), nullptr);
+  avl = remove_int(avl, 445);
+  avl = gpr_avl_add(avl, box(412), box(2271), nullptr);
+  avl = remove_int(avl, 525);
+  avl = gpr_avl_add(avl, box(299), box(2273), nullptr);
+  avl = gpr_avl_add(avl, box(464), box(2274), nullptr);
+  avl = gpr_avl_add(avl, box(715), box(2275), nullptr);
+  avl = remove_int(avl, 58);
+  avl = remove_int(avl, 218);
+  avl = gpr_avl_add(avl, box(961), box(2278), nullptr);
+  avl = gpr_avl_add(avl, box(491), box(2279), nullptr);
+  avl = remove_int(avl, 846);
+  avl = gpr_avl_add(avl, box(762), box(2281), nullptr);
+  avl = remove_int(avl, 974);
+  avl = remove_int(avl, 887);
+  avl = gpr_avl_add(avl, box(498), box(2284), nullptr);
+  avl = remove_int(avl, 810);
+  avl = remove_int(avl, 743);
+  avl = remove_int(avl, 22);
+  avl = remove_int(avl, 284);
+  avl = gpr_avl_add(avl, box(482), box(2289), nullptr);
+  avl = gpr_avl_add(avl, box(1021), box(2290), nullptr);
+  avl = remove_int(avl, 155);
+  avl = remove_int(avl, 128);
+  avl = gpr_avl_add(avl, box(819), box(2293), nullptr);
+  avl = gpr_avl_add(avl, box(324), box(2294), nullptr);
+  avl = remove_int(avl, 196);
+  avl = remove_int(avl, 370);
+  avl = remove_int(avl, 753);
+  avl = remove_int(avl, 56);
+  avl = remove_int(avl, 735);
+  avl = gpr_avl_add(avl, box(272), box(2300), nullptr);
+  avl = gpr_avl_add(avl, box(474), box(2301), nullptr);
+  avl = gpr_avl_add(avl, box(719), box(2302), nullptr);
+  avl = gpr_avl_add(avl, box(236), box(2303), nullptr);
+  avl = remove_int(avl, 818);
+  avl = gpr_avl_add(avl, box(727), box(2305), nullptr);
+  avl = remove_int(avl, 892);
+  avl = remove_int(avl, 871);
+  avl = remove_int(avl, 231);
+  avl = gpr_avl_add(avl, box(62), box(2309), nullptr);
+  avl = gpr_avl_add(avl, box(953), box(2310), nullptr);
+  avl = remove_int(avl, 701);
+  avl = gpr_avl_add(avl, box(193), box(2312), nullptr);
+  avl = remove_int(avl, 619);
+  avl = remove_int(avl, 22);
+  avl = remove_int(avl, 804);
+  avl = remove_int(avl, 851);
+  avl = gpr_avl_add(avl, box(286), box(2317), nullptr);
+  avl = gpr_avl_add(avl, box(751), box(2318), nullptr);
+  avl = remove_int(avl, 525);
+  avl = gpr_avl_add(avl, box(217), box(2320), nullptr);
+  avl = remove_int(avl, 336);
+  avl = gpr_avl_add(avl, box(86), box(2322), nullptr);
+  avl = gpr_avl_add(avl, box(81), box(2323), nullptr);
+  avl = gpr_avl_add(avl, box(850), box(2324), nullptr);
+  avl = remove_int(avl, 872);
+  avl = gpr_avl_add(avl, box(402), box(2326), nullptr);
+  avl = gpr_avl_add(avl, box(54), box(2327), nullptr);
+  avl = gpr_avl_add(avl, box(980), box(2328), nullptr);
+  avl = gpr_avl_add(avl, box(845), box(2329), nullptr);
+  avl = remove_int(avl, 1004);
+  avl = remove_int(avl, 273);
+  avl = remove_int(avl, 879);
+  avl = gpr_avl_add(avl, box(354), box(2333), nullptr);
+  avl = gpr_avl_add(avl, box(58), box(2334), nullptr);
+  avl = gpr_avl_add(avl, box(127), box(2335), nullptr);
+  avl = remove_int(avl, 84);
+  avl = gpr_avl_add(avl, box(360), box(2337), nullptr);
+  avl = remove_int(avl, 648);
+  avl = remove_int(avl, 488);
+  avl = remove_int(avl, 585);
+  avl = remove_int(avl, 230);
+  avl = gpr_avl_add(avl, box(887), box(2342), nullptr);
+  avl = remove_int(avl, 558);
+  avl = remove_int(avl, 958);
+  avl = gpr_avl_add(avl, box(822), box(2345), nullptr);
+  avl = remove_int(avl, 1004);
+  avl = remove_int(avl, 747);
+  avl = gpr_avl_add(avl, box(631), box(2348), nullptr);
+  avl = gpr_avl_add(avl, box(442), box(2349), nullptr);
+  avl = remove_int(avl, 957);
+  avl = remove_int(avl, 964);
+  avl = gpr_avl_add(avl, box(10), box(2352), nullptr);
+  avl = remove_int(avl, 189);
+  avl = gpr_avl_add(avl, box(742), box(2354), nullptr);
+  avl = remove_int(avl, 108);
+  avl = gpr_avl_add(avl, box(1014), box(2356), nullptr);
+  avl = remove_int(avl, 266);
+  avl = remove_int(avl, 623);
+  avl = remove_int(avl, 697);
+  avl = gpr_avl_add(avl, box(180), box(2360), nullptr);
+  avl = remove_int(avl, 472);
+  avl = gpr_avl_add(avl, box(567), box(2362), nullptr);
+  avl = remove_int(avl, 1020);
+  avl = remove_int(avl, 273);
+  avl = gpr_avl_add(avl, box(864), box(2365), nullptr);
+  avl = gpr_avl_add(avl, box(1009), box(2366), nullptr);
+  avl = remove_int(avl, 224);
+  avl = remove_int(avl, 81);
+  avl = gpr_avl_add(avl, box(653), box(2369), nullptr);
+  avl = remove_int(avl, 67);
+  avl = remove_int(avl, 102);
+  avl = remove_int(avl, 76);
+  avl = remove_int(avl, 935);
+  avl = remove_int(avl, 169);
+  avl = remove_int(avl, 232);
+  avl = remove_int(avl, 79);
+  avl = gpr_avl_add(avl, box(509), box(2377), nullptr);
+  avl = remove_int(avl, 900);
+  avl = remove_int(avl, 822);
+  avl = remove_int(avl, 945);
+  avl = remove_int(avl, 356);
+  avl = gpr_avl_add(avl, box(443), box(2382), nullptr);
+  avl = gpr_avl_add(avl, box(925), box(2383), nullptr);
+  avl = remove_int(avl, 994);
+  avl = remove_int(avl, 324);
+  avl = gpr_avl_add(avl, box(291), box(2386), nullptr);
+  avl = remove_int(avl, 94);
+  avl = remove_int(avl, 795);
+  avl = remove_int(avl, 42);
+  avl = gpr_avl_add(avl, box(613), box(2390), nullptr);
+  avl = remove_int(avl, 289);
+  avl = gpr_avl_add(avl, box(980), box(2392), nullptr);
+  avl = remove_int(avl, 316);
+  avl = gpr_avl_add(avl, box(281), box(2394), nullptr);
+  avl = gpr_avl_add(avl, box(1006), box(2395), nullptr);
+  avl = remove_int(avl, 776);
+  avl = gpr_avl_add(avl, box(108), box(2397), nullptr);
+  avl = gpr_avl_add(avl, box(918), box(2398), nullptr);
+  avl = remove_int(avl, 721);
+  avl = remove_int(avl, 563);
+  avl = gpr_avl_add(avl, box(925), box(2401), nullptr);
+  avl = remove_int(avl, 448);
+  avl = remove_int(avl, 198);
+  avl = remove_int(avl, 1);
+  avl = gpr_avl_add(avl, box(160), box(2405), nullptr);
+  avl = remove_int(avl, 515);
+  avl = gpr_avl_add(avl, box(284), box(2407), nullptr);
+  avl = gpr_avl_add(avl, box(225), box(2408), nullptr);
+  avl = remove_int(avl, 304);
+  avl = gpr_avl_add(avl, box(714), box(2410), nullptr);
+  avl = gpr_avl_add(avl, box(708), box(2411), nullptr);
+  avl = gpr_avl_add(avl, box(624), box(2412), nullptr);
+  avl = remove_int(avl, 662);
+  avl = remove_int(avl, 825);
+  avl = remove_int(avl, 383);
+  avl = remove_int(avl, 381);
+  avl = gpr_avl_add(avl, box(194), box(2417), nullptr);
+  avl = remove_int(avl, 280);
+  avl = remove_int(avl, 25);
+  avl = remove_int(avl, 633);
+  avl = gpr_avl_add(avl, box(897), box(2421), nullptr);
+  avl = remove_int(avl, 636);
+  avl = remove_int(avl, 596);
+  avl = remove_int(avl, 757);
+  avl = remove_int(avl, 343);
+  avl = remove_int(avl, 162);
+  avl = remove_int(avl, 913);
+  avl = remove_int(avl, 843);
+  avl = remove_int(avl, 280);
+  avl = remove_int(avl, 911);
+  avl = gpr_avl_add(avl, box(1008), box(2431), nullptr);
+  avl = remove_int(avl, 948);
+  avl = remove_int(avl, 74);
+  avl = remove_int(avl, 571);
+  avl = gpr_avl_add(avl, box(486), box(2435), nullptr);
+  avl = gpr_avl_add(avl, box(285), box(2436), nullptr);
+  avl = remove_int(avl, 304);
+  avl = remove_int(avl, 516);
+  avl = gpr_avl_add(avl, box(758), box(2439), nullptr);
+  avl = gpr_avl_add(avl, box(776), box(2440), nullptr);
+  avl = remove_int(avl, 696);
+  avl = gpr_avl_add(avl, box(104), box(2442), nullptr);
+  avl = gpr_avl_add(avl, box(700), box(2443), nullptr);
+  avl = gpr_avl_add(avl, box(114), box(2444), nullptr);
+  avl = gpr_avl_add(avl, box(567), box(2445), nullptr);
+  avl = remove_int(avl, 620);
+  avl = gpr_avl_add(avl, box(270), box(2447), nullptr);
+  avl = remove_int(avl, 730);
+  avl = gpr_avl_add(avl, box(749), box(2449), nullptr);
+  avl = gpr_avl_add(avl, box(443), box(2450), nullptr);
+  avl = remove_int(avl, 457);
+  avl = gpr_avl_add(avl, box(571), box(2452), nullptr);
+  avl = gpr_avl_add(avl, box(626), box(2453), nullptr);
+  avl = remove_int(avl, 638);
+  avl = remove_int(avl, 313);
+
+  gpr_avl_unref(avl, nullptr);
+}
+
+static void test_stress(int amount_of_stress) {
+  int added[1024];
+  int i, j;
+  int deletions = 0;
+  gpr_avl avl;
+
+  unsigned seed = (unsigned)time(nullptr);
+
+  gpr_log(GPR_DEBUG, "test_stress amount=%d seed=%u", amount_of_stress, seed);
+
+  srand((unsigned)time(nullptr));
+  avl = gpr_avl_create(&int_int_vtable);
+
+  memset(added, 0, sizeof(added));
+
+  for (i = 1; deletions < amount_of_stress; i++) {
+    int idx = rand() % (int)GPR_ARRAY_SIZE(added);
+    GPR_ASSERT(i);
+    if (rand() < RAND_MAX / 2) {
+      added[idx] = i;
+      printf("avl = gpr_avl_add(avl, box(%d), box(%d), NULL); /* d=%d */\n",
+             idx, i, deletions);
+      avl = gpr_avl_add(avl, box(idx), box(i), nullptr);
+    } else {
+      deletions += (added[idx] != 0);
+      added[idx] = 0;
+      printf("avl = remove_int(avl, %d); /* d=%d */\n", idx, deletions);
+      avl = remove_int(avl, idx);
+    }
+    for (j = 0; j < (int)GPR_ARRAY_SIZE(added); j++) {
+      if (added[j] != 0) {
+        check_get(avl, j, added[j]);
+      } else {
+        check_negget(avl, j);
+      }
+    }
+  }
+
+  gpr_avl_unref(avl, nullptr);
+}
+
+int main(int argc, char* argv[]) {
+  grpc_test_init(argc, argv);
+
+  test_get();
+  test_ll();
+  test_lr();
+  test_rr();
+  test_rl();
+  test_unbalanced();
+  test_replace();
+  test_remove();
+  test_badcase1();
+  test_badcase2();
+  test_badcase3();
+  test_stress(10);
+
+  return 0;
+}
diff --git a/test/core/gpr/cmdline_test.cc b/test/core/gpr/cmdline_test.cc
new file mode 100644
index 0000000000..172efda8a0
--- /dev/null
+++ b/test/core/gpr/cmdline_test.cc
@@ -0,0 +1,491 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/cmdline.h>
+
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST() gpr_log(GPR_INFO, "test at %s:%d", __FILE__, __LINE__)
+
+static void test_simple_int(void) {
+  int x = 1;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("-foo"),
+                  const_cast<char*>("3")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_int(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 3);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_eq_int(void) {
+  int x = 1;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("-foo=3")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_int(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 3);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_2dash_int(void) {
+  int x = 1;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo"),
+                  const_cast<char*>("3")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_int(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 3);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_2dash_eq_int(void) {
+  int x = 1;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=3")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_int(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 3);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_simple_string(void) {
+  const char* x = nullptr;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("-foo"),
+                  const_cast<char*>("3")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == nullptr);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(0 == strcmp(x, "3"));
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_eq_string(void) {
+  const char* x = nullptr;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("-foo=3")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == nullptr);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(0 == strcmp(x, "3"));
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_2dash_string(void) {
+  const char* x = nullptr;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo"),
+                  const_cast<char*>("3")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == nullptr);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(0 == strcmp(x, "3"));
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_2dash_eq_string(void) {
+  const char* x = nullptr;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=3")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == nullptr);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(0 == strcmp(x, "3"));
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_on(void) {
+  int x = 2;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_no(void) {
+  int x = 2;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--no-foo")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 0);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_val_1(void) {
+  int x = 2;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=1")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_val_0(void) {
+  int x = 2;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=0")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 0);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_val_true(void) {
+  int x = 2;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=true")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 1);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_flag_val_false(void) {
+  int x = 2;
+  gpr_cmdline* cl;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--foo=false")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_flag(cl, "foo", nullptr, &x);
+  GPR_ASSERT(x == 2);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 0);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_many(void) {
+  const char* str = nullptr;
+  int x = 0;
+  int flag = 2;
+  gpr_cmdline* cl;
+
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--str"),
+                  const_cast<char*>("hello"), const_cast<char*>("-x=4"),
+                  const_cast<char*>("-no-flag")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(x == 4);
+  GPR_ASSERT(0 == strcmp(str, "hello"));
+  GPR_ASSERT(flag == 0);
+  gpr_cmdline_destroy(cl);
+}
+
+static void extra_arg_cb(void* user_data, const char* arg) {
+  int* count = static_cast<int*>(user_data);
+  GPR_ASSERT(arg != nullptr);
+  GPR_ASSERT(strlen(arg) == 1);
+  GPR_ASSERT(arg[0] == 'a' + *count);
+  ++*count;
+}
+
+static void test_extra(void) {
+  gpr_cmdline* cl;
+  int count = 0;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("a"),
+                  const_cast<char*>("b"), const_cast<char*>("c")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
+                           &count);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(count == 3);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_extra_dashdash(void) {
+  gpr_cmdline* cl;
+  int count = 0;
+  char* args[] = {(char*)__FILE__, const_cast<char*>("--"),
+                  const_cast<char*>("a"), const_cast<char*>("b"),
+                  const_cast<char*>("c")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
+                           &count);
+  gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(args), args);
+  GPR_ASSERT(count == 3);
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_usage(void) {
+  gpr_cmdline* cl;
+  char* usage;
+
+  const char* str = nullptr;
+  int x = 0;
+  int flag = 2;
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
+  gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
+                           nullptr);
+
+  usage = gpr_cmdline_usage_string(cl, "test");
+  GPR_ASSERT(0 == strcmp(usage,
+                         "Usage: test [--str=string] [--x=int] "
+                         "[--flag|--no-flag] [file...]\n"));
+  gpr_free(usage);
+
+  usage = gpr_cmdline_usage_string(cl, "/foo/test");
+  GPR_ASSERT(0 == strcmp(usage,
+                         "Usage: test [--str=string] [--x=int] "
+                         "[--flag|--no-flag] [file...]\n"));
+  gpr_free(usage);
+
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_help(void) {
+  gpr_cmdline* cl;
+
+  const char* str = nullptr;
+  int x = 0;
+  int flag = 2;
+
+  char* help[] = {(char*)__FILE__, const_cast<char*>("-h")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_set_survive_failure(cl);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
+  gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
+                           nullptr);
+
+  GPR_ASSERT(0 == gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(help), help));
+
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_badargs1(void) {
+  gpr_cmdline* cl;
+
+  const char* str = nullptr;
+  int x = 0;
+  int flag = 2;
+
+  char* bad_arg_name[] = {(char*)__FILE__, const_cast<char*>("--y")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_set_survive_failure(cl);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
+  gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
+                           nullptr);
+
+  GPR_ASSERT(0 ==
+             gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(bad_arg_name), bad_arg_name));
+
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_badargs2(void) {
+  gpr_cmdline* cl;
+
+  const char* str = nullptr;
+  int x = 0;
+  int flag = 2;
+
+  char* bad_int_value[] = {(char*)__FILE__, const_cast<char*>("--x"),
+                           const_cast<char*>("henry")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_set_survive_failure(cl);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
+  gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
+                           nullptr);
+
+  GPR_ASSERT(
+      0 == gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(bad_int_value), bad_int_value));
+
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_badargs3(void) {
+  gpr_cmdline* cl;
+
+  const char* str = nullptr;
+  int x = 0;
+  int flag = 2;
+
+  char* bad_bool_value[] = {(char*)__FILE__, const_cast<char*>("--flag=henry")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_set_survive_failure(cl);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
+  gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
+                           nullptr);
+
+  GPR_ASSERT(0 == gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(bad_bool_value),
+                                    bad_bool_value));
+
+  gpr_cmdline_destroy(cl);
+}
+
+static void test_badargs4(void) {
+  gpr_cmdline* cl;
+
+  const char* str = nullptr;
+  int x = 0;
+  int flag = 2;
+
+  char* bad_bool_value[] = {(char*)__FILE__, const_cast<char*>("--no-str")};
+
+  LOG_TEST();
+
+  cl = gpr_cmdline_create(nullptr);
+  gpr_cmdline_set_survive_failure(cl);
+  gpr_cmdline_add_string(cl, "str", nullptr, &str);
+  gpr_cmdline_add_int(cl, "x", nullptr, &x);
+  gpr_cmdline_add_flag(cl, "flag", nullptr, &flag);
+  gpr_cmdline_on_extra_arg(cl, "file", "filenames to process", extra_arg_cb,
+                           nullptr);
+
+  GPR_ASSERT(0 == gpr_cmdline_parse(cl, GPR_ARRAY_SIZE(bad_bool_value),
+                                    bad_bool_value));
+
+  gpr_cmdline_destroy(cl);
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  test_simple_int();
+  test_eq_int();
+  test_2dash_int();
+  test_2dash_eq_int();
+  test_simple_string();
+  test_eq_string();
+  test_2dash_string();
+  test_2dash_eq_string();
+  test_flag_on();
+  test_flag_no();
+  test_flag_val_1();
+  test_flag_val_0();
+  test_flag_val_true();
+  test_flag_val_false();
+  test_many();
+  test_extra();
+  test_extra_dashdash();
+  test_usage();
+  test_help();
+  test_badargs1();
+  test_badargs2();
+  test_badargs3();
+  test_badargs4();
+  return 0;
+}
diff --git a/test/core/gpr/cpu_test.cc b/test/core/gpr/cpu_test.cc
new file mode 100644
index 0000000000..87cdc0fb50
--- /dev/null
+++ b/test/core/gpr/cpu_test.cc
@@ -0,0 +1,139 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* Test gpr per-cpu support:
+   gpr_cpu_num_cores()
+   gpr_cpu_current_cpu()
+*/
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/cpu.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+#include <stdio.h>
+#include <string.h>
+#include "test/core/util/test_config.h"
+
+/* Test structure is essentially:
+   1) Figure out how many cores are present on the test system
+   2) Create 3 times that many threads
+   3) Have each thread do some amount of work (basically want to
+      gaurantee that all threads are running at once, and enough of them
+      to run on all cores).
+   4) Each thread checks what core it is running on, and marks that core
+      as "used" in the test.
+   5) Count number of "used" cores.
+
+   The test will fail if:
+   1) gpr_cpu_num_cores() == 0
+   2) Any result from gpr_cpu_current_cpu() >= gpr_cpu_num_cores()
+   3) Ideally, we would fail if not all cores were seen as used. Unfortunately,
+      this is only probabilistically true, and depends on the OS, it's
+      scheduler, etc. So we just print out an indication of how many were seen;
+      hopefully developers can use this to sanity check their system.
+*/
+
+/* Status shared across threads */
+struct cpu_test {
+  gpr_mu mu;
+  int nthreads;
+  uint32_t ncores;
+  int is_done;
+  gpr_cv done_cv;
+  int* used;  /* is this core used? */
+  unsigned r; /* random number */
+};
+
+static void worker_thread(void* arg) {
+  struct cpu_test* ct = (struct cpu_test*)arg;
+  uint32_t cpu;
+  unsigned r = 12345678;
+  unsigned i, j;
+  /* Avoid repetitive division calculations */
+  int64_t max_i = 1000 / grpc_test_slowdown_factor();
+  int64_t max_j = 1000 / grpc_test_slowdown_factor();
+  for (i = 0; i < max_i; i++) {
+    /* run for a bit - just calculate something random. */
+    for (j = 0; j < max_j; j++) {
+      r = (r * 17) & ((r - i) | (r * i));
+    }
+    cpu = gpr_cpu_current_cpu();
+    GPR_ASSERT(cpu < ct->ncores);
+    gpr_mu_lock(&ct->mu);
+    ct->used[cpu] = 1;
+    for (j = 0; j < ct->ncores; j++) {
+      if (!ct->used[j]) break;
+    }
+    gpr_mu_unlock(&ct->mu);
+    if (j == ct->ncores) {
+      break; /* all cpus have been used - no further use in running this test */
+    }
+  }
+  gpr_mu_lock(&ct->mu);
+  ct->r = r; /* make it look like we care about r's value... */
+  ct->nthreads--;
+  if (ct->nthreads == 0) {
+    ct->is_done = 1;
+    gpr_cv_signal(&ct->done_cv);
+  }
+  gpr_mu_unlock(&ct->mu);
+}
+
+static void cpu_test(void) {
+  uint32_t i;
+  int cores_seen = 0;
+  struct cpu_test ct;
+  gpr_thd_id thd;
+  ct.ncores = gpr_cpu_num_cores();
+  GPR_ASSERT(ct.ncores > 0);
+  ct.nthreads = (int)ct.ncores * 3;
+  ct.used = static_cast<int*>(gpr_malloc(ct.ncores * sizeof(int)));
+  memset(ct.used, 0, ct.ncores * sizeof(int));
+  gpr_mu_init(&ct.mu);
+  gpr_cv_init(&ct.done_cv);
+  ct.is_done = 0;
+  for (i = 0; i < ct.ncores * 3; i++) {
+    GPR_ASSERT(
+        gpr_thd_new(&thd, "grpc_cpu_test", &worker_thread, &ct, nullptr));
+  }
+  gpr_mu_lock(&ct.mu);
+  while (!ct.is_done) {
+    gpr_cv_wait(&ct.done_cv, &ct.mu, gpr_inf_future(GPR_CLOCK_MONOTONIC));
+  }
+  gpr_mu_unlock(&ct.mu);
+  fprintf(stderr, "Saw cores [");
+  fflush(stderr);
+  for (i = 0; i < ct.ncores; i++) {
+    if (ct.used[i]) {
+      fprintf(stderr, "%d,", i);
+      fflush(stderr);
+      cores_seen++;
+    }
+  }
+  fprintf(stderr, "] (%d/%d)\n", cores_seen, ct.ncores);
+  fflush(stderr);
+  gpr_free(ct.used);
+}
+
+int main(int argc, char* argv[]) {
+  grpc_test_init(argc, argv);
+  cpu_test();
+  return 0;
+}
diff --git a/test/core/gpr/env_test.cc b/test/core/gpr/env_test.cc
new file mode 100644
index 0000000000..3f4b493239
--- /dev/null
+++ b/test/core/gpr/env_test.cc
@@ -0,0 +1,49 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/string.h"
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST_NAME(x) gpr_log(GPR_INFO, "%s", x)
+
+static void test_setenv_getenv(void) {
+  const char* name = "FOO";
+  const char* value = "BAR";
+  char* retrieved_value;
+
+  LOG_TEST_NAME("test_setenv_getenv");
+
+  gpr_setenv(name, value);
+  retrieved_value = gpr_getenv(name);
+  GPR_ASSERT(retrieved_value != nullptr);
+  GPR_ASSERT(strcmp(value, retrieved_value) == 0);
+  gpr_free(retrieved_value);
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  test_setenv_getenv();
+  return 0;
+}
diff --git a/test/core/gpr/host_port_test.cc b/test/core/gpr/host_port_test.cc
new file mode 100644
index 0000000000..42dd56524f
--- /dev/null
+++ b/test/core/gpr/host_port_test.cc
@@ -0,0 +1,58 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include "test/core/util/test_config.h"
+
+static void join_host_port_expect(const char* host, int port,
+                                  const char* expected) {
+  char* buf;
+  int len;
+  len = gpr_join_host_port(&buf, host, port);
+  GPR_ASSERT(len >= 0);
+  GPR_ASSERT(strlen(expected) == (size_t)len);
+  GPR_ASSERT(strcmp(expected, buf) == 0);
+  gpr_free(buf);
+}
+
+static void test_join_host_port(void) {
+  join_host_port_expect("foo", 101, "foo:101");
+  join_host_port_expect("", 102, ":102");
+  join_host_port_expect("1::2", 103, "[1::2]:103");
+  join_host_port_expect("[::1]", 104, "[::1]:104");
+}
+
+/* Garbage in, garbage out. */
+static void test_join_host_port_garbage(void) {
+  join_host_port_expect("[foo]", 105, "[foo]:105");
+  join_host_port_expect("[::", 106, "[:::106");
+  join_host_port_expect("::]", 107, "[::]]:107");
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+
+  test_join_host_port();
+  test_join_host_port_garbage();
+
+  return 0;
+}
diff --git a/test/core/gpr/log_test.cc b/test/core/gpr/log_test.cc
new file mode 100644
index 0000000000..839ff0aef9
--- /dev/null
+++ b/test/core/gpr/log_test.cc
@@ -0,0 +1,108 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/log.h>
+
+#include <stdbool.h>
+#include <string.h>
+
+#include "src/core/lib/gpr/env.h"
+#include "test/core/util/test_config.h"
+
+static bool log_func_reached = false;
+
+static void test_callback(gpr_log_func_args* args) {
+  GPR_ASSERT(0 == strcmp(__FILE__, args->file));
+  GPR_ASSERT(args->severity == GPR_LOG_SEVERITY_INFO);
+  GPR_ASSERT(0 == strcmp(args->message, "hello 1 2 3"));
+}
+
+static void test_should_log(gpr_log_func_args* args) {
+  log_func_reached = true;
+}
+
+static void test_should_not_log(gpr_log_func_args* args) { GPR_ASSERT(false); }
+
+#define test_log_function_reached(SEVERITY)     \
+  gpr_set_log_function(test_should_log);        \
+  log_func_reached = false;                     \
+  gpr_log_message(SEVERITY, "hello 1 2 3");     \
+  GPR_ASSERT(log_func_reached);                 \
+  log_func_reached = false;                     \
+  gpr_log(SEVERITY, "hello %d %d %d", 1, 2, 3); \
+  GPR_ASSERT(log_func_reached);
+
+#define test_log_function_unreached(SEVERITY) \
+  gpr_set_log_function(test_should_not_log);  \
+  gpr_log_message(SEVERITY, "hello 1 2 3");   \
+  gpr_log(SEVERITY, "hello %d %d %d", 1, 2, 3);
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  /* test logging at various verbosity levels */
+  gpr_log(GPR_DEBUG, "%s", "hello world");
+  gpr_log(GPR_INFO, "%s", "hello world");
+  gpr_log(GPR_ERROR, "%s", "hello world");
+  /* should succeed */
+  GPR_ASSERT(1);
+  gpr_set_log_function(test_callback);
+  gpr_log_message(GPR_INFO, "hello 1 2 3");
+  gpr_log(GPR_INFO, "hello %d %d %d", 1, 2, 3);
+  gpr_set_log_function(nullptr);
+
+  /* gpr_log_verbosity_init() will be effective only once, and only before
+   * gpr_set_log_verbosity() is called */
+  gpr_setenv("GRPC_VERBOSITY", "ERROR");
+  gpr_log_verbosity_init();
+
+  test_log_function_reached(GPR_ERROR);
+  test_log_function_unreached(GPR_INFO);
+  test_log_function_unreached(GPR_DEBUG);
+
+  /* gpr_log_verbosity_init() should not be effective */
+  gpr_setenv("GRPC_VERBOSITY", "DEBUG");
+  gpr_log_verbosity_init();
+  test_log_function_reached(GPR_ERROR);
+  test_log_function_unreached(GPR_INFO);
+  test_log_function_unreached(GPR_DEBUG);
+
+  gpr_set_log_verbosity(GPR_LOG_SEVERITY_DEBUG);
+  test_log_function_reached(GPR_ERROR);
+  test_log_function_reached(GPR_INFO);
+  test_log_function_reached(GPR_DEBUG);
+
+  gpr_set_log_verbosity(GPR_LOG_SEVERITY_INFO);
+  test_log_function_reached(GPR_ERROR);
+  test_log_function_reached(GPR_INFO);
+  test_log_function_unreached(GPR_DEBUG);
+
+  gpr_set_log_verbosity(GPR_LOG_SEVERITY_ERROR);
+  test_log_function_reached(GPR_ERROR);
+  test_log_function_unreached(GPR_INFO);
+  test_log_function_unreached(GPR_DEBUG);
+
+  /* gpr_log_verbosity_init() should not be effective */
+  gpr_setenv("GRPC_VERBOSITY", "DEBUG");
+  gpr_log_verbosity_init();
+  test_log_function_reached(GPR_ERROR);
+  test_log_function_unreached(GPR_INFO);
+  test_log_function_unreached(GPR_DEBUG);
+
+  /* TODO(ctiller): should we add a GPR_ASSERT failure test here */
+  return 0;
+}
diff --git a/test/core/gpr/mpscq_test.cc b/test/core/gpr/mpscq_test.cc
new file mode 100644
index 0000000000..5a8177543c
--- /dev/null
+++ b/test/core/gpr/mpscq_test.cc
@@ -0,0 +1,194 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/gpr/mpscq.h"
+
+#include <stdlib.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/test_config.h"
+
+typedef struct test_node {
+  gpr_mpscq_node node;
+  size_t i;
+  size_t* ctr;
+} test_node;
+
+static test_node* new_node(size_t i, size_t* ctr) {
+  test_node* n = static_cast<test_node*>(gpr_malloc(sizeof(test_node)));
+  n->i = i;
+  n->ctr = ctr;
+  return n;
+}
+
+static void test_serial(void) {
+  gpr_log(GPR_DEBUG, "test_serial");
+  gpr_mpscq q;
+  gpr_mpscq_init(&q);
+  for (size_t i = 0; i < 10000000; i++) {
+    gpr_mpscq_push(&q, &new_node(i, nullptr)->node);
+  }
+  for (size_t i = 0; i < 10000000; i++) {
+    test_node* n = (test_node*)gpr_mpscq_pop(&q);
+    GPR_ASSERT(n);
+    GPR_ASSERT(n->i == i);
+    gpr_free(n);
+  }
+}
+
+typedef struct {
+  size_t ctr;
+  gpr_mpscq* q;
+  gpr_event* start;
+} thd_args;
+
+#define THREAD_ITERATIONS 10000
+
+static void test_thread(void* args) {
+  thd_args* a = static_cast<thd_args*>(args);
+  gpr_event_wait(a->start, gpr_inf_future(GPR_CLOCK_REALTIME));
+  for (size_t i = 1; i <= THREAD_ITERATIONS; i++) {
+    gpr_mpscq_push(a->q, &new_node(i, &a->ctr)->node);
+  }
+}
+
+static void test_mt(void) {
+  gpr_log(GPR_DEBUG, "test_mt");
+  gpr_event start;
+  gpr_event_init(&start);
+  gpr_thd_id thds[100];
+  thd_args ta[GPR_ARRAY_SIZE(thds)];
+  gpr_mpscq q;
+  gpr_mpscq_init(&q);
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
+    gpr_thd_options options = gpr_thd_options_default();
+    gpr_thd_options_set_joinable(&options);
+    ta[i].ctr = 0;
+    ta[i].q = &q;
+    ta[i].start = &start;
+    GPR_ASSERT(
+        gpr_thd_new(&thds[i], "grpc_mt_test", test_thread, &ta[i], &options));
+  }
+  size_t num_done = 0;
+  size_t spins = 0;
+  gpr_event_set(&start, (void*)1);
+  while (num_done != GPR_ARRAY_SIZE(thds)) {
+    gpr_mpscq_node* n;
+    while ((n = gpr_mpscq_pop(&q)) == nullptr) {
+      spins++;
+    }
+    test_node* tn = (test_node*)n;
+    GPR_ASSERT(*tn->ctr == tn->i - 1);
+    *tn->ctr = tn->i;
+    if (tn->i == THREAD_ITERATIONS) num_done++;
+    gpr_free(tn);
+  }
+  gpr_log(GPR_DEBUG, "spins: %" PRIdPTR, spins);
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
+    gpr_thd_join(thds[i]);
+  }
+  gpr_mpscq_destroy(&q);
+}
+
+typedef struct {
+  thd_args* ta;
+  size_t num_thds;
+  gpr_mu mu;
+  size_t num_done;
+  size_t spins;
+  gpr_mpscq* q;
+  gpr_event* start;
+} pull_args;
+
+static void pull_thread(void* arg) {
+  pull_args* pa = static_cast<pull_args*>(arg);
+  gpr_event_wait(pa->start, gpr_inf_future(GPR_CLOCK_REALTIME));
+
+  for (;;) {
+    gpr_mu_lock(&pa->mu);
+    if (pa->num_done == pa->num_thds) {
+      gpr_mu_unlock(&pa->mu);
+      return;
+    }
+    gpr_mpscq_node* n;
+    while ((n = gpr_mpscq_pop(pa->q)) == nullptr) {
+      pa->spins++;
+    }
+    test_node* tn = (test_node*)n;
+    GPR_ASSERT(*tn->ctr == tn->i - 1);
+    *tn->ctr = tn->i;
+    if (tn->i == THREAD_ITERATIONS) pa->num_done++;
+    gpr_free(tn);
+    gpr_mu_unlock(&pa->mu);
+  }
+}
+
+static void test_mt_multipop(void) {
+  gpr_log(GPR_DEBUG, "test_mt_multipop");
+  gpr_event start;
+  gpr_event_init(&start);
+  gpr_thd_id thds[100];
+  gpr_thd_id pull_thds[100];
+  thd_args ta[GPR_ARRAY_SIZE(thds)];
+  gpr_mpscq q;
+  gpr_mpscq_init(&q);
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
+    gpr_thd_options options = gpr_thd_options_default();
+    gpr_thd_options_set_joinable(&options);
+    ta[i].ctr = 0;
+    ta[i].q = &q;
+    ta[i].start = &start;
+    GPR_ASSERT(gpr_thd_new(&thds[i], "grpc_multipop_test", test_thread, &ta[i],
+                           &options));
+  }
+  pull_args pa;
+  pa.ta = ta;
+  pa.num_thds = GPR_ARRAY_SIZE(thds);
+  pa.spins = 0;
+  pa.num_done = 0;
+  pa.q = &q;
+  pa.start = &start;
+  gpr_mu_init(&pa.mu);
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(pull_thds); i++) {
+    gpr_thd_options options = gpr_thd_options_default();
+    gpr_thd_options_set_joinable(&options);
+    GPR_ASSERT(gpr_thd_new(&pull_thds[i], "grpc_multipop_pull", pull_thread,
+                           &pa, &options));
+  }
+  gpr_event_set(&start, (void*)1);
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(pull_thds); i++) {
+    gpr_thd_join(pull_thds[i]);
+  }
+  gpr_log(GPR_DEBUG, "spins: %" PRIdPTR, pa.spins);
+  for (size_t i = 0; i < GPR_ARRAY_SIZE(thds); i++) {
+    gpr_thd_join(thds[i]);
+  }
+  gpr_mpscq_destroy(&q);
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  test_serial();
+  test_mt();
+  test_mt_multipop();
+  return 0;
+}
diff --git a/test/core/gpr/murmur_hash_test.cc b/test/core/gpr/murmur_hash_test.cc
new file mode 100644
index 0000000000..d920dd3f95
--- /dev/null
+++ b/test/core/gpr/murmur_hash_test.cc
@@ -0,0 +1,73 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/gpr/murmur_hash.h"
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include "test/core/util/test_config.h"
+
+#include <string.h>
+
+typedef uint32_t (*hash_func)(const void* key, size_t len, uint32_t seed);
+
+/* From smhasher:
+   This should hopefully be a thorough and uambiguous test of whether a hash
+   is correctly implemented on a given platform */
+
+static void verification_test(hash_func hash, uint32_t expected) {
+  uint8_t key[256];
+  uint32_t hashes[256];
+  uint32_t final = 0;
+  size_t i;
+
+  memset(key, 0, sizeof(key));
+  memset(hashes, 0, sizeof(hashes));
+
+  /* Hash keys of the form {0}, {0,1}, {0,1,2}... up to N=255,using 256-N as
+     the seed */
+
+  for (i = 0; i < 256; i++) {
+    key[i] = (uint8_t)i;
+    hashes[i] = hash(key, i, (uint32_t)(256u - i));
+  }
+
+  /* Then hash the result array */
+
+  final = hash(hashes, sizeof(hashes), 0);
+
+  /* The first four bytes of that hash, interpreted as a little-endian integer,
+     is our
+     verification value */
+
+  if (expected != final) {
+    gpr_log(GPR_INFO, "Verification value 0x%08X : Failed! (Expected 0x%08x)",
+            final, expected);
+    abort();
+  } else {
+    gpr_log(GPR_INFO, "Verification value 0x%08X : Passed!", final);
+  }
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  /* basic tests to verify that things don't crash */
+  gpr_murmur_hash3("", 0, 0);
+  gpr_murmur_hash3("xyz", 3, 0);
+  verification_test(gpr_murmur_hash3, 0xB0F57EE3);
+  return 0;
+}
diff --git a/test/core/gpr/spinlock_test.cc b/test/core/gpr/spinlock_test.cc
new file mode 100644
index 0000000000..77e3dfbede
--- /dev/null
+++ b/test/core/gpr/spinlock_test.cc
@@ -0,0 +1,152 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* Test of gpr synchronization support. */
+
+#include "src/core/lib/gpr/spinlock.h"
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "test/core/util/test_config.h"
+
+/* ------------------------------------------------- */
+/* Tests for gpr_spinlock. */
+struct test {
+  int thread_count; /* number of threads */
+  gpr_thd_id* threads;
+
+  int64_t iterations; /* number of iterations per thread */
+  int64_t counter;
+  int incr_step; /* how much to increment/decrement refcount each time */
+
+  gpr_spinlock mu; /* protects iterations, counter */
+};
+
+/* Return pointer to a new struct test. */
+static struct test* test_new(int threads, int64_t iterations, int incr_step) {
+  struct test* m = static_cast<struct test*>(gpr_malloc(sizeof(*m)));
+  m->thread_count = threads;
+  m->threads = static_cast<gpr_thd_id*>(
+      gpr_malloc(sizeof(*m->threads) * (size_t)threads));
+  m->iterations = iterations;
+  m->counter = 0;
+  m->thread_count = 0;
+  m->incr_step = incr_step;
+  m->mu = GPR_SPINLOCK_INITIALIZER;
+  return m;
+}
+
+/* Return pointer to a new struct test. */
+static void test_destroy(struct test* m) {
+  gpr_free(m->threads);
+  gpr_free(m);
+}
+
+/* Create m->threads threads, each running (*body)(m) */
+static void test_create_threads(struct test* m, void (*body)(void* arg)) {
+  int i;
+  for (i = 0; i != m->thread_count; i++) {
+    gpr_thd_options opt = gpr_thd_options_default();
+    gpr_thd_options_set_joinable(&opt);
+    GPR_ASSERT(
+        gpr_thd_new(&m->threads[i], "grpc_create_threads", body, m, &opt));
+  }
+}
+
+/* Wait until all threads report done. */
+static void test_wait(struct test* m) {
+  int i;
+  for (i = 0; i != m->thread_count; i++) {
+    gpr_thd_join(m->threads[i]);
+  }
+}
+
+/* Test several threads running (*body)(struct test *m) for increasing settings
+   of m->iterations, until about timeout_s to 2*timeout_s seconds have elapsed.
+   If extra!=NULL, run (*extra)(m) in an additional thread.
+   incr_step controls by how much m->refcount should be incremented/decremented
+   (if at all) each time in the tests.
+   */
+static void test(const char* name, void (*body)(void* m), int timeout_s,
+                 int incr_step) {
+  int64_t iterations = 1024;
+  struct test* m;
+  gpr_timespec start = gpr_now(GPR_CLOCK_REALTIME);
+  gpr_timespec time_taken;
+  gpr_timespec deadline = gpr_time_add(
+      start, gpr_time_from_micros((int64_t)timeout_s * 1000000, GPR_TIMESPAN));
+  fprintf(stderr, "%s:", name);
+  fflush(stderr);
+  while (gpr_time_cmp(gpr_now(GPR_CLOCK_REALTIME), deadline) < 0) {
+    if (iterations < INT64_MAX / 2) iterations <<= 1;
+    fprintf(stderr, " %ld", (long)iterations);
+    fflush(stderr);
+    m = test_new(10, iterations, incr_step);
+    test_create_threads(m, body);
+    test_wait(m);
+    if (m->counter != m->thread_count * m->iterations * m->incr_step) {
+      fprintf(stderr, "counter %ld  threads %d  iterations %ld\n",
+              (long)m->counter, m->thread_count, (long)m->iterations);
+      fflush(stderr);
+      GPR_ASSERT(0);
+    }
+    test_destroy(m);
+  }
+  time_taken = gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), start);
+  fprintf(stderr, " done %lld.%09d s\n", (long long)time_taken.tv_sec,
+          (int)time_taken.tv_nsec);
+  fflush(stderr);
+}
+
+/* Increment m->counter on each iteration; then mark thread as done.  */
+static void inc(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t i;
+  for (i = 0; i != m->iterations; i++) {
+    gpr_spinlock_lock(&m->mu);
+    m->counter++;
+    gpr_spinlock_unlock(&m->mu);
+  }
+}
+
+/* Increment m->counter under lock acquired with trylock, m->iterations times;
+   then mark thread as done.  */
+static void inctry(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t i;
+  for (i = 0; i != m->iterations;) {
+    if (gpr_spinlock_trylock(&m->mu)) {
+      m->counter++;
+      gpr_spinlock_unlock(&m->mu);
+      i++;
+    }
+  }
+}
+
+/* ------------------------------------------------- */
+
+int main(int argc, char* argv[]) {
+  grpc_test_init(argc, argv);
+  test("spinlock", &inc, 1, 1);
+  test("spinlock try", &inctry, 1, 1);
+  return 0;
+}
diff --git a/test/core/gpr/string_test.cc b/test/core/gpr/string_test.cc
new file mode 100644
index 0000000000..57068eb2c9
--- /dev/null
+++ b/test/core/gpr/string_test.cc
@@ -0,0 +1,312 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "src/core/lib/gpr/string.h"
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/string_util.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/test_config.h"
+
+#define LOG_TEST_NAME(x) gpr_log(GPR_INFO, "%s", x)
+
+static void test_strdup(void) {
+  static const char* src1 = "hello world";
+  char* dst1;
+
+  LOG_TEST_NAME("test_strdup");
+
+  dst1 = gpr_strdup(src1);
+  GPR_ASSERT(0 == strcmp(src1, dst1));
+  gpr_free(dst1);
+
+  GPR_ASSERT(nullptr == gpr_strdup(nullptr));
+}
+
+static void expect_dump(const char* buf, size_t len, uint32_t flags,
+                        const char* result) {
+  char* got = gpr_dump(buf, len, flags);
+  GPR_ASSERT(0 == strcmp(got, result));
+  gpr_free(got);
+}
+
+static void test_dump(void) {
+  LOG_TEST_NAME("test_dump");
+  expect_dump("\x01", 1, GPR_DUMP_HEX, "01");
+  expect_dump("\x01", 1, GPR_DUMP_HEX | GPR_DUMP_ASCII, "01 '.'");
+  expect_dump("\x01\x02", 2, GPR_DUMP_HEX, "01 02");
+  expect_dump("\x01\x23\x45\x67\x89\xab\xcd\xef", 8, GPR_DUMP_HEX,
+              "01 23 45 67 89 ab cd ef");
+  expect_dump("ab", 2, GPR_DUMP_HEX | GPR_DUMP_ASCII, "61 62 'ab'");
+}
+
+static void test_pu32_fail(const char* s) {
+  uint32_t out;
+  GPR_ASSERT(!gpr_parse_bytes_to_uint32(s, strlen(s), &out));
+}
+
+static void test_pu32_succeed(const char* s, uint32_t want) {
+  uint32_t out;
+  GPR_ASSERT(gpr_parse_bytes_to_uint32(s, strlen(s), &out));
+  GPR_ASSERT(out == want);
+}
+
+static void test_parse_uint32(void) {
+  LOG_TEST_NAME("test_parse_uint32");
+
+  test_pu32_fail("-1");
+  test_pu32_fail("a");
+  test_pu32_fail("");
+  test_pu32_succeed("0", 0);
+  test_pu32_succeed("1", 1);
+  test_pu32_succeed("2", 2);
+  test_pu32_succeed("3", 3);
+  test_pu32_succeed("4", 4);
+  test_pu32_succeed("5", 5);
+  test_pu32_succeed("6", 6);
+  test_pu32_succeed("7", 7);
+  test_pu32_succeed("8", 8);
+  test_pu32_succeed("9", 9);
+  test_pu32_succeed("10", 10);
+  test_pu32_succeed("11", 11);
+  test_pu32_succeed("12", 12);
+  test_pu32_succeed("13", 13);
+  test_pu32_succeed("14", 14);
+  test_pu32_succeed("15", 15);
+  test_pu32_succeed("16", 16);
+  test_pu32_succeed("17", 17);
+  test_pu32_succeed("18", 18);
+  test_pu32_succeed("19", 19);
+  test_pu32_succeed("1234567890", 1234567890);
+  test_pu32_succeed("4294967295", 4294967295u);
+  test_pu32_fail("4294967296");
+  test_pu32_fail("4294967297");
+  test_pu32_fail("4294967298");
+  test_pu32_fail("4294967299");
+}
+
+static void test_asprintf(void) {
+  char* buf;
+  int i, j;
+
+  LOG_TEST_NAME("test_asprintf");
+
+  /* Print an empty string. */
+  GPR_ASSERT(gpr_asprintf(&buf, "%s", "") == 0);
+  GPR_ASSERT(buf[0] == '\0');
+  gpr_free(buf);
+
+  /* Print strings of various lengths. */
+  for (i = 1; i < 100; i++) {
+    GPR_ASSERT(gpr_asprintf(&buf, "%0*d", i, 1) == i);
+
+    /* The buffer should resemble "000001\0". */
+    for (j = 0; j < i - 2; j++) {
+      GPR_ASSERT(buf[j] == '0');
+    }
+    GPR_ASSERT(buf[i - 1] == '1');
+    GPR_ASSERT(buf[i] == '\0');
+    gpr_free(buf);
+  }
+}
+
+static void test_strjoin(void) {
+  const char* parts[4] = {"one", "two", "three", "four"};
+  size_t joined_len;
+  char* joined;
+
+  LOG_TEST_NAME("test_strjoin");
+
+  joined = gpr_strjoin(parts, 4, &joined_len);
+  GPR_ASSERT(0 == strcmp("onetwothreefour", joined));
+  gpr_free(joined);
+
+  joined = gpr_strjoin(parts, 0, &joined_len);
+  GPR_ASSERT(0 == strcmp("", joined));
+  gpr_free(joined);
+
+  joined = gpr_strjoin(parts, 1, &joined_len);
+  GPR_ASSERT(0 == strcmp("one", joined));
+  gpr_free(joined);
+}
+
+static void test_strjoin_sep(void) {
+  const char* parts[4] = {"one", "two", "three", "four"};
+  size_t joined_len;
+  char* joined;
+
+  LOG_TEST_NAME("test_strjoin_sep");
+
+  joined = gpr_strjoin_sep(parts, 4, ", ", &joined_len);
+  GPR_ASSERT(0 == strcmp("one, two, three, four", joined));
+  gpr_free(joined);
+
+  /* empty separator */
+  joined = gpr_strjoin_sep(parts, 4, "", &joined_len);
+  GPR_ASSERT(0 == strcmp("onetwothreefour", joined));
+  gpr_free(joined);
+
+  /* degenerated case specifying zero input parts */
+  joined = gpr_strjoin_sep(parts, 0, ", ", &joined_len);
+  GPR_ASSERT(0 == strcmp("", joined));
+  gpr_free(joined);
+
+  /* single part should have no separator */
+  joined = gpr_strjoin_sep(parts, 1, ", ", &joined_len);
+  GPR_ASSERT(0 == strcmp("one", joined));
+  gpr_free(joined);
+}
+
+static void test_ltoa() {
+  char* str;
+  char buf[GPR_LTOA_MIN_BUFSIZE];
+
+  LOG_TEST_NAME("test_ltoa");
+
+  /* zero */
+  GPR_ASSERT(1 == gpr_ltoa(0, buf));
+  GPR_ASSERT(0 == strcmp("0", buf));
+
+  /* positive number */
+  GPR_ASSERT(3 == gpr_ltoa(123, buf));
+  GPR_ASSERT(0 == strcmp("123", buf));
+
+  /* negative number */
+  GPR_ASSERT(6 == gpr_ltoa(-12345, buf));
+  GPR_ASSERT(0 == strcmp("-12345", buf));
+
+  /* large negative - we don't know the size of long in advance */
+  GPR_ASSERT(gpr_asprintf(&str, "%lld", (long long)LONG_MIN));
+  GPR_ASSERT(strlen(str) == (size_t)gpr_ltoa(LONG_MIN, buf));
+  GPR_ASSERT(0 == strcmp(str, buf));
+  gpr_free(str);
+}
+
+static void test_int64toa() {
+  char buf[GPR_INT64TOA_MIN_BUFSIZE];
+
+  LOG_TEST_NAME("test_int64toa");
+
+  /* zero */
+  GPR_ASSERT(1 == int64_ttoa(0, buf));
+  GPR_ASSERT(0 == strcmp("0", buf));
+
+  /* positive */
+  GPR_ASSERT(3 == int64_ttoa(123, buf));
+  GPR_ASSERT(0 == strcmp("123", buf));
+
+  /* large positive */
+  GPR_ASSERT(19 == int64_ttoa(9223372036854775807LL, buf));
+  GPR_ASSERT(0 == strcmp("9223372036854775807", buf));
+
+  /* large negative */
+  GPR_ASSERT(20 == int64_ttoa(-9223372036854775807LL - 1, buf));
+  GPR_ASSERT(0 == strcmp("-9223372036854775808", buf));
+}
+
+static void test_leftpad() {
+  char* padded;
+
+  LOG_TEST_NAME("test_leftpad");
+
+  padded = gpr_leftpad("foo", ' ', 5);
+  GPR_ASSERT(0 == strcmp("  foo", padded));
+  gpr_free(padded);
+
+  padded = gpr_leftpad("foo", ' ', 4);
+  GPR_ASSERT(0 == strcmp(" foo", padded));
+  gpr_free(padded);
+
+  padded = gpr_leftpad("foo", ' ', 3);
+  GPR_ASSERT(0 == strcmp("foo", padded));
+  gpr_free(padded);
+
+  padded = gpr_leftpad("foo", ' ', 2);
+  GPR_ASSERT(0 == strcmp("foo", padded));
+  gpr_free(padded);
+
+  padded = gpr_leftpad("foo", ' ', 1);
+  GPR_ASSERT(0 == strcmp("foo", padded));
+  gpr_free(padded);
+
+  padded = gpr_leftpad("foo", ' ', 0);
+  GPR_ASSERT(0 == strcmp("foo", padded));
+  gpr_free(padded);
+
+  padded = gpr_leftpad("foo", '0', 5);
+  GPR_ASSERT(0 == strcmp("00foo", padded));
+  gpr_free(padded);
+}
+
+static void test_stricmp(void) {
+  LOG_TEST_NAME("test_stricmp");
+
+  GPR_ASSERT(0 == gpr_stricmp("hello", "hello"));
+  GPR_ASSERT(0 == gpr_stricmp("HELLO", "hello"));
+  GPR_ASSERT(gpr_stricmp("a", "b") < 0);
+  GPR_ASSERT(gpr_stricmp("b", "a") > 0);
+}
+
+static void test_memrchr(void) {
+  LOG_TEST_NAME("test_memrchr");
+
+  GPR_ASSERT(nullptr == gpr_memrchr(nullptr, 'a', 0));
+  GPR_ASSERT(nullptr == gpr_memrchr("", 'a', 0));
+  GPR_ASSERT(nullptr == gpr_memrchr("hello", 'b', 5));
+  GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'h', 5), "hello"));
+  GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'o', 5), "o"));
+  GPR_ASSERT(0 == strcmp((const char*)gpr_memrchr("hello", 'l', 5), "lo"));
+}
+
+static void test_is_true(void) {
+  LOG_TEST_NAME("test_is_true");
+
+  GPR_ASSERT(true == gpr_is_true("True"));
+  GPR_ASSERT(true == gpr_is_true("true"));
+  GPR_ASSERT(true == gpr_is_true("TRUE"));
+  GPR_ASSERT(true == gpr_is_true("Yes"));
+  GPR_ASSERT(true == gpr_is_true("yes"));
+  GPR_ASSERT(true == gpr_is_true("YES"));
+  GPR_ASSERT(true == gpr_is_true("1"));
+  GPR_ASSERT(false == gpr_is_true(nullptr));
+  GPR_ASSERT(false == gpr_is_true(""));
+  GPR_ASSERT(false == gpr_is_true("0"));
+}
+
+int main(int argc, char** argv) {
+  grpc_test_init(argc, argv);
+  test_strdup();
+  test_dump();
+  test_parse_uint32();
+  test_asprintf();
+  test_strjoin();
+  test_strjoin_sep();
+  test_ltoa();
+  test_int64toa();
+  test_leftpad();
+  test_stricmp();
+  test_memrchr();
+  test_is_true();
+  return 0;
+}
diff --git a/test/core/gpr/sync_test.cc b/test/core/gpr/sync_test.cc
new file mode 100644
index 0000000000..768f96d093
--- /dev/null
+++ b/test/core/gpr/sync_test.cc
@@ -0,0 +1,457 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* Test of gpr synchronization support. */
+
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "test/core/util/test_config.h"
+
+/* ==================Example use of interface===================
+
+   A producer-consumer queue of up to N integers,
+   illustrating the use of the calls in this interface.  */
+
+#define N 4
+
+typedef struct queue {
+  gpr_cv non_empty; /* Signalled when length becomes non-zero. */
+  gpr_cv non_full;  /* Signalled when length becomes non-N. */
+  gpr_mu mu;        /* Protects all fields below.
+                       (That is, except during initialization or
+                       destruction, the fields below should be accessed
+                       only by a thread that holds mu.) */
+  int head;         /* Index of head of queue 0..N-1. */
+  int length;       /* Number of valid elements in queue 0..N. */
+  int elem[N];      /* elem[head .. head+length-1] are queue elements. */
+} queue;
+
+/* Initialize *q. */
+void queue_init(queue* q) {
+  gpr_mu_init(&q->mu);
+  gpr_cv_init(&q->non_empty);
+  gpr_cv_init(&q->non_full);
+  q->head = 0;
+  q->length = 0;
+}
+
+/* Free storage associated with *q. */
+void queue_destroy(queue* q) {
+  gpr_mu_destroy(&q->mu);
+  gpr_cv_destroy(&q->non_empty);
+  gpr_cv_destroy(&q->non_full);
+}
+
+/* Wait until there is room in *q, then append x to *q. */
+void queue_append(queue* q, int x) {
+  gpr_mu_lock(&q->mu);
+  /* To wait for a predicate without a deadline, loop on the negation of the
+     predicate, and use gpr_cv_wait(..., gpr_inf_future(GPR_CLOCK_REALTIME))
+     inside the loop
+     to release the lock, wait, and reacquire on each iteration.  Code that
+     makes the condition true should use gpr_cv_broadcast() on the
+     corresponding condition variable.  The predicate must be on state
+     protected by the lock.  */
+  while (q->length == N) {
+    gpr_cv_wait(&q->non_full, &q->mu, gpr_inf_future(GPR_CLOCK_MONOTONIC));
+  }
+  if (q->length == 0) { /* Wake threads blocked in queue_remove(). */
+    /* It's normal to use gpr_cv_broadcast() or gpr_signal() while
+       holding the lock. */
+    gpr_cv_broadcast(&q->non_empty);
+  }
+  q->elem[(q->head + q->length) % N] = x;
+  q->length++;
+  gpr_mu_unlock(&q->mu);
+}
+
+/* If it can be done without blocking, append x to *q and return non-zero.
+   Otherwise return 0. */
+int queue_try_append(queue* q, int x) {
+  int result = 0;
+  if (gpr_mu_trylock(&q->mu)) {
+    if (q->length != N) {
+      if (q->length == 0) { /* Wake threads blocked in queue_remove(). */
+        gpr_cv_broadcast(&q->non_empty);
+      }
+      q->elem[(q->head + q->length) % N] = x;
+      q->length++;
+      result = 1;
+    }
+    gpr_mu_unlock(&q->mu);
+  }
+  return result;
+}
+
+/* Wait until the *q is non-empty or deadline abs_deadline passes.  If the
+   queue is non-empty, remove its head entry, place it in *head, and return
+   non-zero.  Otherwise return 0.  */
+int queue_remove(queue* q, int* head, gpr_timespec abs_deadline) {
+  int result = 0;
+  gpr_mu_lock(&q->mu);
+  /* To wait for a predicate with a deadline, loop on the negation of the
+     predicate or until gpr_cv_wait() returns true.  Code that makes
+     the condition true should use gpr_cv_broadcast() on the corresponding
+     condition variable.  The predicate must be on state protected by the
+     lock. */
+  while (q->length == 0 && !gpr_cv_wait(&q->non_empty, &q->mu, abs_deadline)) {
+  }
+  if (q->length != 0) { /* Queue is non-empty. */
+    result = 1;
+    if (q->length == N) { /* Wake threads blocked in queue_append(). */
+      gpr_cv_broadcast(&q->non_full);
+    }
+    *head = q->elem[q->head];
+    q->head = (q->head + 1) % N;
+    q->length--;
+  } /* else deadline exceeded */
+  gpr_mu_unlock(&q->mu);
+  return result;
+}
+
+/* ------------------------------------------------- */
+/* Tests for gpr_mu and gpr_cv, and the queue example. */
+struct test {
+  int threads; /* number of threads */
+
+  int64_t iterations; /* number of iterations per thread */
+  int64_t counter;
+  int thread_count; /* used to allocate thread ids */
+  int done;         /* threads not yet completed */
+  int incr_step;    /* how much to increment/decrement refcount each time */
+
+  gpr_mu mu; /* protects iterations, counter, thread_count, done */
+
+  gpr_cv cv; /* signalling depends on test */
+
+  gpr_cv done_cv; /* signalled when done == 0 */
+
+  queue q;
+
+  gpr_stats_counter stats_counter;
+
+  gpr_refcount refcount;
+  gpr_refcount thread_refcount;
+  gpr_event event;
+};
+
+/* Return pointer to a new struct test. */
+static struct test* test_new(int threads, int64_t iterations, int incr_step) {
+  struct test* m = static_cast<struct test*>(gpr_malloc(sizeof(*m)));
+  m->threads = threads;
+  m->iterations = iterations;
+  m->counter = 0;
+  m->thread_count = 0;
+  m->done = threads;
+  m->incr_step = incr_step;
+  gpr_mu_init(&m->mu);
+  gpr_cv_init(&m->cv);
+  gpr_cv_init(&m->done_cv);
+  queue_init(&m->q);
+  gpr_stats_init(&m->stats_counter, 0);
+  gpr_ref_init(&m->refcount, 0);
+  gpr_ref_init(&m->thread_refcount, threads);
+  gpr_event_init(&m->event);
+  return m;
+}
+
+/* Return pointer to a new struct test. */
+static void test_destroy(struct test* m) {
+  gpr_mu_destroy(&m->mu);
+  gpr_cv_destroy(&m->cv);
+  gpr_cv_destroy(&m->done_cv);
+  queue_destroy(&m->q);
+  gpr_free(m);
+}
+
+/* Create m->threads threads, each running (*body)(m) */
+static void test_create_threads(struct test* m, void (*body)(void* arg)) {
+  gpr_thd_id id;
+  int i;
+  for (i = 0; i != m->threads; i++) {
+    GPR_ASSERT(gpr_thd_new(&id, "grpc_create_threads", body, m, nullptr));
+  }
+}
+
+/* Wait until all threads report done. */
+static void test_wait(struct test* m) {
+  gpr_mu_lock(&m->mu);
+  while (m->done != 0) {
+    gpr_cv_wait(&m->done_cv, &m->mu, gpr_inf_future(GPR_CLOCK_MONOTONIC));
+  }
+  gpr_mu_unlock(&m->mu);
+}
+
+/* Get an integer thread id in the raneg 0..threads-1 */
+static int thread_id(struct test* m) {
+  int id;
+  gpr_mu_lock(&m->mu);
+  id = m->thread_count++;
+  gpr_mu_unlock(&m->mu);
+  return id;
+}
+
+/* Indicate that a thread is done, by decrementing m->done
+   and signalling done_cv if m->done==0. */
+static void mark_thread_done(struct test* m) {
+  gpr_mu_lock(&m->mu);
+  GPR_ASSERT(m->done != 0);
+  m->done--;
+  if (m->done == 0) {
+    gpr_cv_signal(&m->done_cv);
+  }
+  gpr_mu_unlock(&m->mu);
+}
+
+/* Test several threads running (*body)(struct test *m) for increasing settings
+   of m->iterations, until about timeout_s to 2*timeout_s seconds have elapsed.
+   If extra!=NULL, run (*extra)(m) in an additional thread.
+   incr_step controls by how much m->refcount should be incremented/decremented
+   (if at all) each time in the tests.
+   */
+static void test(const char* name, void (*body)(void* m),
+                 void (*extra)(void* m), int timeout_s, int incr_step) {
+  int64_t iterations = 256;
+  struct test* m;
+  gpr_timespec start = gpr_now(GPR_CLOCK_REALTIME);
+  gpr_timespec time_taken;
+  gpr_timespec deadline = gpr_time_add(
+      start, gpr_time_from_micros((int64_t)timeout_s * 1000000, GPR_TIMESPAN));
+  fprintf(stderr, "%s:", name);
+  fflush(stderr);
+  while (gpr_time_cmp(gpr_now(GPR_CLOCK_REALTIME), deadline) < 0) {
+    fprintf(stderr, " %ld", (long)iterations);
+    fflush(stderr);
+    m = test_new(10, iterations, incr_step);
+    if (extra != nullptr) {
+      gpr_thd_id id;
+      GPR_ASSERT(gpr_thd_new(&id, name, extra, m, nullptr));
+      m->done++; /* one more thread to wait for */
+    }
+    test_create_threads(m, body);
+    test_wait(m);
+    if (m->counter != m->threads * m->iterations * m->incr_step) {
+      fprintf(stderr, "counter %ld  threads %d  iterations %ld\n",
+              (long)m->counter, m->threads, (long)m->iterations);
+      fflush(stderr);
+      GPR_ASSERT(0);
+    }
+    test_destroy(m);
+    iterations <<= 1;
+  }
+  time_taken = gpr_time_sub(gpr_now(GPR_CLOCK_REALTIME), start);
+  fprintf(stderr, " done %lld.%09d s\n", (long long)time_taken.tv_sec,
+          (int)time_taken.tv_nsec);
+  fflush(stderr);
+}
+
+/* Increment m->counter on each iteration; then mark thread as done.  */
+static void inc(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t i;
+  for (i = 0; i != m->iterations; i++) {
+    gpr_mu_lock(&m->mu);
+    m->counter++;
+    gpr_mu_unlock(&m->mu);
+  }
+  mark_thread_done(m);
+}
+
+/* Increment m->counter under lock acquired with trylock, m->iterations times;
+   then mark thread as done.  */
+static void inctry(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t i;
+  for (i = 0; i != m->iterations;) {
+    if (gpr_mu_trylock(&m->mu)) {
+      m->counter++;
+      gpr_mu_unlock(&m->mu);
+      i++;
+    }
+  }
+  mark_thread_done(m);
+}
+
+/* Increment counter only when (m->counter%m->threads)==m->thread_id; then mark
+   thread as done.  */
+static void inc_by_turns(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t i;
+  int id = thread_id(m);
+  for (i = 0; i != m->iterations; i++) {
+    gpr_mu_lock(&m->mu);
+    while ((m->counter % m->threads) != id) {
+      gpr_cv_wait(&m->cv, &m->mu, gpr_inf_future(GPR_CLOCK_MONOTONIC));
+    }
+    m->counter++;
+    gpr_cv_broadcast(&m->cv);
+    gpr_mu_unlock(&m->mu);
+  }
+  mark_thread_done(m);
+}
+
+/* Wait a millisecond and increment counter on each iteration;
+   then mark thread as done. */
+static void inc_with_1ms_delay(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t i;
+  for (i = 0; i != m->iterations; i++) {
+    gpr_timespec deadline;
+    gpr_mu_lock(&m->mu);
+    deadline = gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
+                            gpr_time_from_micros(1000, GPR_TIMESPAN));
+    while (!gpr_cv_wait(&m->cv, &m->mu, deadline)) {
+    }
+    m->counter++;
+    gpr_mu_unlock(&m->mu);
+  }
+  mark_thread_done(m);
+}
+
+/* Wait a millisecond and increment counter on each iteration, using an event
+   for timing; then mark thread as done. */
+static void inc_with_1ms_delay_event(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t i;
+  for (i = 0; i != m->iterations; i++) {
+    gpr_timespec deadline;
+    deadline = gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
+                            gpr_time_from_micros(1000, GPR_TIMESPAN));
+    GPR_ASSERT(gpr_event_wait(&m->event, deadline) == nullptr);
+    gpr_mu_lock(&m->mu);
+    m->counter++;
+    gpr_mu_unlock(&m->mu);
+  }
+  mark_thread_done(m);
+}
+
+/* Produce m->iterations elements on queue m->q, then mark thread as done.
+   Even threads use queue_append(), and odd threads use queue_try_append()
+   until it succeeds. */
+static void many_producers(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t i;
+  int x = thread_id(m);
+  if ((x & 1) == 0) {
+    for (i = 0; i != m->iterations; i++) {
+      queue_append(&m->q, 1);
+    }
+  } else {
+    for (i = 0; i != m->iterations; i++) {
+      while (!queue_try_append(&m->q, 1)) {
+      }
+    }
+  }
+  mark_thread_done(m);
+}
+
+/* Consume elements from m->q until m->threads*m->iterations are seen,
+   wait an extra second to confirm that no more elements are arriving,
+   then mark thread as done. */
+static void consumer(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t n = m->iterations * m->threads;
+  int64_t i;
+  int value;
+  for (i = 0; i != n; i++) {
+    queue_remove(&m->q, &value, gpr_inf_future(GPR_CLOCK_MONOTONIC));
+  }
+  gpr_mu_lock(&m->mu);
+  m->counter = n;
+  gpr_mu_unlock(&m->mu);
+  GPR_ASSERT(
+      !queue_remove(&m->q, &value,
+                    gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
+                                 gpr_time_from_micros(1000000, GPR_TIMESPAN))));
+  mark_thread_done(m);
+}
+
+/* Increment m->stats_counter m->iterations times, transfer counter value to
+   m->counter, then mark thread as done.  */
+static void statsinc(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t i;
+  for (i = 0; i != m->iterations; i++) {
+    gpr_stats_inc(&m->stats_counter, 1);
+  }
+  gpr_mu_lock(&m->mu);
+  m->counter = gpr_stats_read(&m->stats_counter);
+  gpr_mu_unlock(&m->mu);
+  mark_thread_done(m);
+}
+
+/* Increment m->refcount by m->incr_step for m->iterations times. Decrement
+   m->thread_refcount once, and if it reaches zero, set m->event to (void*)1;
+   then mark thread as done.  */
+static void refinc(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t i;
+  for (i = 0; i != m->iterations; i++) {
+    if (m->incr_step == 1) {
+      gpr_ref(&m->refcount);
+    } else {
+      gpr_refn(&m->refcount, m->incr_step);
+    }
+  }
+  if (gpr_unref(&m->thread_refcount)) {
+    gpr_event_set(&m->event, (void*)1);
+  }
+  mark_thread_done(m);
+}
+
+/* Wait until m->event is set to (void *)1, then decrement m->refcount by 1
+   (m->threads * m->iterations * m->incr_step) times, and ensure that the last
+   decrement caused the counter to reach zero, then mark thread as done.  */
+static void refcheck(void* v /*=m*/) {
+  struct test* m = static_cast<struct test*>(v);
+  int64_t n = m->iterations * m->threads * m->incr_step;
+  int64_t i;
+  GPR_ASSERT(gpr_event_wait(&m->event, gpr_inf_future(GPR_CLOCK_REALTIME)) ==
+             (void*)1);
+  GPR_ASSERT(gpr_event_get(&m->event) == (void*)1);
+  for (i = 1; i != n; i++) {
+    GPR_ASSERT(!gpr_unref(&m->refcount));
+    m->counter++;
+  }
+  GPR_ASSERT(gpr_unref(&m->refcount));
+  m->counter++;
+  mark_thread_done(m);
+}
+
+/* ------------------------------------------------- */
+
+int main(int argc, char* argv[]) {
+  grpc_test_init(argc, argv);
+  test("mutex", &inc, nullptr, 1, 1);
+  test("mutex try", &inctry, nullptr, 1, 1);
+  test("cv", &inc_by_turns, nullptr, 1, 1);
+  test("timedcv", &inc_with_1ms_delay, nullptr, 1, 1);
+  test("queue", &many_producers, &consumer, 10, 1);
+  test("stats_counter", &statsinc, nullptr, 1, 1);
+  test("refcount by 1", &refinc, &refcheck, 1, 1);
+  test("refcount by 3", &refinc, &refcheck, 1, 3); /* incr_step of 3 is an
+                                                      arbitrary choice. Any
+                                                      number > 1 is okay here */
+  test("timedevent", &inc_with_1ms_delay_event, nullptr, 1, 1);
+  return 0;
+}
diff --git a/test/core/gpr/thd_test.cc b/test/core/gpr/thd_test.cc
new file mode 100644
index 0000000000..b755bf18f3
--- /dev/null
+++ b/test/core/gpr/thd_test.cc
@@ -0,0 +1,102 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* Test of gpr thread support. */
+
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "test/core/util/test_config.h"
+
+#define NUM_THREADS 300
+
+struct test {
+  gpr_mu mu;
+  int n;
+  int is_done;
+  gpr_cv done_cv;
+};
+
+/* A Thread body.   Decrement t->n, and if is becomes zero, set t->done. */
+static void thd_body(void* v) {
+  struct test* t = static_cast<struct test*>(v);
+  gpr_mu_lock(&t->mu);
+  t->n--;
+  if (t->n == 0) {
+    t->is_done = 1;
+    gpr_cv_signal(&t->done_cv);
+  }
+  gpr_mu_unlock(&t->mu);
+}
+
+static void thd_body_joinable(void* v) {}
+
+/* Test thread options work as expected */
+static void test_options(void) {
+  gpr_thd_options options = gpr_thd_options_default();
+  GPR_ASSERT(!gpr_thd_options_is_joinable(&options));
+  GPR_ASSERT(gpr_thd_options_is_detached(&options));
+  gpr_thd_options_set_joinable(&options);
+  GPR_ASSERT(gpr_thd_options_is_joinable(&options));
+  GPR_ASSERT(!gpr_thd_options_is_detached(&options));
+  gpr_thd_options_set_detached(&options);
+  GPR_ASSERT(!gpr_thd_options_is_joinable(&options));
+  GPR_ASSERT(gpr_thd_options_is_detached(&options));
+}
+
+/* Test that we can create a number of threads and wait for them. */
+static void test(void) {
+  int i;
+  gpr_thd_id thd;
+  gpr_thd_id thds[NUM_THREADS];
+  struct test t;
+  gpr_thd_options options = gpr_thd_options_default();
+  gpr_mu_init(&t.mu);
+  gpr_cv_init(&t.done_cv);
+  t.n = NUM_THREADS;
+  t.is_done = 0;
+  for (i = 0; i < NUM_THREADS; i++) {
+    GPR_ASSERT(gpr_thd_new(&thd, "grpc_thread_test", &thd_body, &t, nullptr));
+  }
+  gpr_mu_lock(&t.mu);
+  while (!t.is_done) {
+    gpr_cv_wait(&t.done_cv, &t.mu, gpr_inf_future(GPR_CLOCK_REALTIME));
+  }
+  gpr_mu_unlock(&t.mu);
+  GPR_ASSERT(t.n == 0);
+  gpr_thd_options_set_joinable(&options);
+  for (i = 0; i < NUM_THREADS; i++) {
+    GPR_ASSERT(gpr_thd_new(&thds[i], "grpc_joinable_thread_test",
+                           &thd_body_joinable, nullptr, &options));
+  }
+  for (i = 0; i < NUM_THREADS; i++) {
+    gpr_thd_join(thds[i]);
+  }
+}
+
+/* ------------------------------------------------- */
+
+int main(int argc, char* argv[]) {
+  grpc_test_init(argc, argv);
+  test_options();
+  test();
+  return 0;
+}
diff --git a/test/core/gpr/time_test.cc b/test/core/gpr/time_test.cc
new file mode 100644
index 0000000000..b2b4dce58e
--- /dev/null
+++ b/test/core/gpr/time_test.cc
@@ -0,0 +1,266 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* Test of gpr time support. */
+
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/time.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "test/core/util/test_config.h"
+
+static void to_fp(void* arg, const char* buf, size_t len) {
+  fwrite(buf, 1, len, (FILE*)arg);
+}
+
+/* Convert gpr_intmax x to ascii base b (2..16), and write with
+   (*writer)(arg, ...), zero padding to "chars" digits).  */
+static void i_to_s(intmax_t x, int base, int chars,
+                   void (*writer)(void* arg, const char* buf, size_t len),
+                   void* arg) {
+  char buf[64];
+  char fmt[32];
+  GPR_ASSERT(base == 16 || base == 10);
+  sprintf(fmt, "%%0%d%s", chars, base == 16 ? PRIxMAX : PRIdMAX);
+  sprintf(buf, fmt, x);
+  (*writer)(arg, buf, strlen(buf));
+}
+
+/* Convert ts to ascii, and write with (*writer)(arg, ...).  */
+static void ts_to_s(gpr_timespec t,
+                    void (*writer)(void* arg, const char* buf, size_t len),
+                    void* arg) {
+  if (t.tv_sec < 0 && t.tv_nsec != 0) {
+    t.tv_sec++;
+    t.tv_nsec = GPR_NS_PER_SEC - t.tv_nsec;
+  }
+  i_to_s(t.tv_sec, 10, 0, writer, arg);
+  (*writer)(arg, ".", 1);
+  i_to_s(t.tv_nsec, 10, 9, writer, arg);
+}
+
+static void test_values(void) {
+  int i;
+
+  gpr_timespec x = gpr_time_0(GPR_CLOCK_REALTIME);
+  GPR_ASSERT(x.tv_sec == 0 && x.tv_nsec == 0);
+
+  x = gpr_inf_future(GPR_CLOCK_REALTIME);
+  fprintf(stderr, "far future ");
+  fflush(stderr);
+  i_to_s(x.tv_sec, 16, 16, &to_fp, stderr);
+  fprintf(stderr, "\n");
+  GPR_ASSERT(x.tv_sec == INT64_MAX);
+  fprintf(stderr, "far future ");
+  fflush(stderr);
+  ts_to_s(x, &to_fp, stderr);
+  fprintf(stderr, "\n");
+  fflush(stderr);
+
+  x = gpr_inf_past(GPR_CLOCK_REALTIME);
+  fprintf(stderr, "far past   ");
+  fflush(stderr);
+  i_to_s(x.tv_sec, 16, 16, &to_fp, stderr);
+  fprintf(stderr, "\n");
+  fflush(stderr);
+  GPR_ASSERT(x.tv_sec == INT64_MIN);
+  fprintf(stderr, "far past   ");
+  fflush(stderr);
+  ts_to_s(x, &to_fp, stderr);
+  fprintf(stderr, "\n");
+  fflush(stderr);
+
+  for (i = 1; i != 1000 * 1000 * 1000; i *= 10) {
+    x = gpr_time_from_micros(i, GPR_TIMESPAN);
+    GPR_ASSERT(x.tv_sec == i / GPR_US_PER_SEC &&
+               x.tv_nsec == (i % GPR_US_PER_SEC) * GPR_NS_PER_US);
+    x = gpr_time_from_nanos(i, GPR_TIMESPAN);
+    GPR_ASSERT(x.tv_sec == i / GPR_NS_PER_SEC &&
+               x.tv_nsec == (i % GPR_NS_PER_SEC));
+    x = gpr_time_from_millis(i, GPR_TIMESPAN);
+    GPR_ASSERT(x.tv_sec == i / GPR_MS_PER_SEC &&
+               x.tv_nsec == (i % GPR_MS_PER_SEC) * GPR_NS_PER_MS);
+  }
+
+  /* Test possible overflow in conversion of -ve values. */
+  x = gpr_time_from_micros(-(INT64_MAX - 999997), GPR_TIMESPAN);
+  GPR_ASSERT(x.tv_sec < 0);
+  GPR_ASSERT(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
+
+  x = gpr_time_from_nanos(-(INT64_MAX - 999999997), GPR_TIMESPAN);
+  GPR_ASSERT(x.tv_sec < 0);
+  GPR_ASSERT(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
+
+  x = gpr_time_from_millis(-(INT64_MAX - 997), GPR_TIMESPAN);
+  GPR_ASSERT(x.tv_sec < 0);
+  GPR_ASSERT(x.tv_nsec >= 0 && x.tv_nsec < GPR_NS_PER_SEC);
+
+  /* Test general -ve values. */
+  for (i = -1; i > -1000 * 1000 * 1000; i *= 7) {
+    x = gpr_time_from_micros(i, GPR_TIMESPAN);
+    GPR_ASSERT(x.tv_sec * GPR_US_PER_SEC + x.tv_nsec / GPR_NS_PER_US == i);
+    x = gpr_time_from_nanos(i, GPR_TIMESPAN);
+    GPR_ASSERT(x.tv_sec * GPR_NS_PER_SEC + x.tv_nsec == i);
+    x = gpr_time_from_millis(i, GPR_TIMESPAN);
+    GPR_ASSERT(x.tv_sec * GPR_MS_PER_SEC + x.tv_nsec / GPR_NS_PER_MS == i);
+  }
+}
+
+static void test_add_sub(void) {
+  int i;
+  int j;
+  int k;
+  /* Basic addition and subtraction. */
+  for (i = -100; i <= 100; i++) {
+    for (j = -100; j <= 100; j++) {
+      for (k = 1; k <= 10000000; k *= 10) {
+        int sum = i + j;
+        int diff = i - j;
+        gpr_timespec it = gpr_time_from_micros(i * k, GPR_TIMESPAN);
+        gpr_timespec jt = gpr_time_from_micros(j * k, GPR_TIMESPAN);
+        gpr_timespec sumt = gpr_time_add(it, jt);
+        gpr_timespec difft = gpr_time_sub(it, jt);
+        if (gpr_time_cmp(gpr_time_from_micros(sum * k, GPR_TIMESPAN), sumt) !=
+            0) {
+          fprintf(stderr, "i %d  j %d  sum %d    sumt ", i, j, sum);
+          fflush(stderr);
+          ts_to_s(sumt, &to_fp, stderr);
+          fprintf(stderr, "\n");
+          fflush(stderr);
+          GPR_ASSERT(0);
+        }
+        if (gpr_time_cmp(gpr_time_from_micros(diff * k, GPR_TIMESPAN), difft) !=
+            0) {
+          fprintf(stderr, "i %d  j %d  diff %d    diff ", i, j, diff);
+          fflush(stderr);
+          ts_to_s(sumt, &to_fp, stderr);
+          fprintf(stderr, "\n");
+          fflush(stderr);
+          GPR_ASSERT(0);
+        }
+      }
+    }
+  }
+}
+
+static void test_overflow(void) {
+  /* overflow */
+  gpr_timespec x = gpr_time_from_micros(1, GPR_TIMESPAN);
+  do {
+    x = gpr_time_add(x, x);
+  } while (gpr_time_cmp(x, gpr_inf_future(GPR_TIMESPAN)) < 0);
+  GPR_ASSERT(gpr_time_cmp(x, gpr_inf_future(GPR_TIMESPAN)) == 0);
+  x = gpr_time_from_micros(-1, GPR_TIMESPAN);
+  do {
+    x = gpr_time_add(x, x);
+  } while (gpr_time_cmp(x, gpr_inf_past(GPR_TIMESPAN)) > 0);
+  GPR_ASSERT(gpr_time_cmp(x, gpr_inf_past(GPR_TIMESPAN)) == 0);
+}
+
+static void test_sticky_infinities(void) {
+  int i;
+  int j;
+  int k;
+  gpr_timespec infinity[2];
+  gpr_timespec addend[3];
+  infinity[0] = gpr_inf_future(GPR_TIMESPAN);
+  infinity[1] = gpr_inf_past(GPR_TIMESPAN);
+  addend[0] = gpr_inf_future(GPR_TIMESPAN);
+  addend[1] = gpr_inf_past(GPR_TIMESPAN);
+  addend[2] = gpr_time_0(GPR_TIMESPAN);
+
+  /* Infinities are sticky */
+  for (i = 0; i != sizeof(infinity) / sizeof(infinity[0]); i++) {
+    for (j = 0; j != sizeof(addend) / sizeof(addend[0]); j++) {
+      gpr_timespec x = gpr_time_add(infinity[i], addend[j]);
+      GPR_ASSERT(gpr_time_cmp(x, infinity[i]) == 0);
+      x = gpr_time_sub(infinity[i], addend[j]);
+      GPR_ASSERT(gpr_time_cmp(x, infinity[i]) == 0);
+    }
+    for (k = -200; k <= 200; k++) {
+      gpr_timespec y = gpr_time_from_micros(k * 100000, GPR_TIMESPAN);
+      gpr_timespec x = gpr_time_add(infinity[i], y);
+      GPR_ASSERT(gpr_time_cmp(x, infinity[i]) == 0);
+      x = gpr_time_sub(infinity[i], y);
+      GPR_ASSERT(gpr_time_cmp(x, infinity[i]) == 0);
+    }
+  }
+}
+
+static void test_similar(void) {
+  GPR_ASSERT(1 == gpr_time_similar(gpr_inf_future(GPR_TIMESPAN),
+                                   gpr_inf_future(GPR_TIMESPAN),
+                                   gpr_time_0(GPR_TIMESPAN)));
+  GPR_ASSERT(1 == gpr_time_similar(gpr_inf_past(GPR_TIMESPAN),
+                                   gpr_inf_past(GPR_TIMESPAN),
+                                   gpr_time_0(GPR_TIMESPAN)));
+  GPR_ASSERT(0 == gpr_time_similar(gpr_inf_past(GPR_TIMESPAN),
+                                   gpr_inf_future(GPR_TIMESPAN),
+                                   gpr_time_0(GPR_TIMESPAN)));
+  GPR_ASSERT(0 == gpr_time_similar(gpr_inf_future(GPR_TIMESPAN),
+                                   gpr_inf_past(GPR_TIMESPAN),
+                                   gpr_time_0(GPR_TIMESPAN)));
+  GPR_ASSERT(1 == gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
+                                   gpr_time_from_micros(10, GPR_TIMESPAN),
+                                   gpr_time_0(GPR_TIMESPAN)));
+  GPR_ASSERT(1 == gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
+                                   gpr_time_from_micros(15, GPR_TIMESPAN),
+                                   gpr_time_from_micros(10, GPR_TIMESPAN)));
+  GPR_ASSERT(1 == gpr_time_similar(gpr_time_from_micros(15, GPR_TIMESPAN),
+                                   gpr_time_from_micros(10, GPR_TIMESPAN),
+                                   gpr_time_from_micros(10, GPR_TIMESPAN)));
+  GPR_ASSERT(0 == gpr_time_similar(gpr_time_from_micros(10, GPR_TIMESPAN),
+                                   gpr_time_from_micros(25, GPR_TIMESPAN),
+                                   gpr_time_from_micros(10, GPR_TIMESPAN)));
+  GPR_ASSERT(0 == gpr_time_similar(gpr_time_from_micros(25, GPR_TIMESPAN),
+                                   gpr_time_from_micros(10, GPR_TIMESPAN),
+                                   gpr_time_from_micros(10, GPR_TIMESPAN)));
+}
+
+static void test_convert_extreme(void) {
+  gpr_timespec realtime = {INT64_MAX, 1, GPR_CLOCK_REALTIME};
+  gpr_timespec monotime = gpr_convert_clock_type(realtime, GPR_CLOCK_MONOTONIC);
+  GPR_ASSERT(monotime.tv_sec == realtime.tv_sec);
+  GPR_ASSERT(monotime.clock_type == GPR_CLOCK_MONOTONIC);
+}
+
+static void test_cmp_extreme(void) {
+  gpr_timespec t1 = {INT64_MAX, 1, GPR_CLOCK_REALTIME};
+  gpr_timespec t2 = {INT64_MAX, 2, GPR_CLOCK_REALTIME};
+  GPR_ASSERT(gpr_time_cmp(t1, t2) == 0);
+  t1.tv_sec = INT64_MIN;
+  t2.tv_sec = INT64_MIN;
+  GPR_ASSERT(gpr_time_cmp(t1, t2) == 0);
+}
+
+int main(int argc, char* argv[]) {
+  grpc_test_init(argc, argv);
+
+  test_values();
+  test_add_sub();
+  test_overflow();
+  test_sticky_infinities();
+  test_similar();
+  test_convert_extreme();
+  test_cmp_extreme();
+  return 0;
+}
diff --git a/test/core/gpr/tls_test.cc b/test/core/gpr/tls_test.cc
new file mode 100644
index 0000000000..743b10f090
--- /dev/null
+++ b/test/core/gpr/tls_test.cc
@@ -0,0 +1,68 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+/* Test of gpr thread local storage support. */
+
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/thd.h>
+#include <grpc/support/tls.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "test/core/util/test_config.h"
+
+#define NUM_THREADS 100
+
+GPR_TLS_DECL(test_var);
+
+static void thd_body(void* arg) {
+  intptr_t i;
+
+  GPR_ASSERT(gpr_tls_get(&test_var) == 0);
+
+  for (i = 0; i < 100000; i++) {
+    gpr_tls_set(&test_var, i);
+    GPR_ASSERT(gpr_tls_get(&test_var) == i);
+  }
+  gpr_tls_set(&test_var, 0);
+}
+
+/* ------------------------------------------------- */
+
+int main(int argc, char* argv[]) {
+  gpr_thd_options opt = gpr_thd_options_default();
+  int i;
+  gpr_thd_id threads[NUM_THREADS];
+
+  grpc_test_init(argc, argv);
+
+  gpr_tls_init(&test_var);
+
+  gpr_thd_options_set_joinable(&opt);
+
+  for (i = 0; i < NUM_THREADS; i++) {
+    gpr_thd_new(&threads[i], "grpc_tls_test", thd_body, nullptr, &opt);
+  }
+  for (i = 0; i < NUM_THREADS; i++) {
+    gpr_thd_join(threads[i]);
+  }
+
+  gpr_tls_destroy(&test_var);
+
+  return 0;
+}
diff --git a/test/core/gpr/useful_test.cc b/test/core/gpr/useful_test.cc
new file mode 100644
index 0000000000..2f86010d77
--- /dev/null
+++ b/test/core/gpr/useful_test.cc
@@ -0,0 +1,58 @@
+/*
+ *
+ * Copyright 2015 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <grpc/support/log.h>
+#include <grpc/support/port_platform.h>
+#include <grpc/support/useful.h>
+#include "test/core/util/test_config.h"
+
+int main(int argc, char** argv) {
+  int four[4];
+  int five[5];
+  uint32_t bitset = 0;
+  grpc_test_init(argc, argv);
+
+  GPR_ASSERT(GPR_MIN(1, 2) == 1);
+  GPR_ASSERT(GPR_MAX(1, 2) == 2);
+  GPR_ASSERT(GPR_MIN(2, 1) == 1);
+  GPR_ASSERT(GPR_MAX(2, 1) == 2);
+  GPR_ASSERT(GPR_CLAMP(1, 0, 2) == 1);
+  GPR_ASSERT(GPR_CLAMP(0, 0, 2) == 0);
+  GPR_ASSERT(GPR_CLAMP(2, 0, 2) == 2);
+  GPR_ASSERT(GPR_CLAMP(-1, 0, 2) == 0);
+  GPR_ASSERT(GPR_CLAMP(3, 0, 2) == 2);
+  GPR_ASSERT(GPR_ROTL((uint32_t)0x80000001, 1) == 3);
+  GPR_ASSERT(GPR_ROTR((uint32_t)0x80000001, 1) == 0xc0000000);
+  GPR_ASSERT(GPR_ARRAY_SIZE(four) == 4);
+  GPR_ASSERT(GPR_ARRAY_SIZE(five) == 5);
+
+  GPR_ASSERT(GPR_BITCOUNT((1u << 31) - 1) == 31);
+  GPR_ASSERT(GPR_BITCOUNT(1u << 3) == 1);
+  GPR_ASSERT(GPR_BITCOUNT(0) == 0);
+
+  GPR_ASSERT(GPR_BITSET(&bitset, 3) == 8);
+  GPR_ASSERT(GPR_BITCOUNT(bitset) == 1);
+  GPR_ASSERT(GPR_BITGET(bitset, 3) == 1);
+  GPR_ASSERT(GPR_BITSET(&bitset, 1) == 10);
+  GPR_ASSERT(GPR_BITCOUNT(bitset) == 2);
+  GPR_ASSERT(GPR_BITCLEAR(&bitset, 3) == 2);
+  GPR_ASSERT(GPR_BITCOUNT(bitset) == 1);
+  GPR_ASSERT(GPR_BITGET(bitset, 3) == 0);
+
+  return 0;
+}