Merge github.com:grpc/grpc into no-transport-metadata

author: Craig Tiller <craig.tiller@gmail.com> 2015-11-25 15:32:59 -0800
committer: Craig Tiller <craig.tiller@gmail.com> 2015-11-25 15:32:59 -0800
commit: de83121308bfa816dd9c093a5d316af2ac46f422 (patch)
tree: 20ba34affbfc460249e104bf3e6370c9f00e9046 /test/core
parent: 6d3b229209a12437b7abf813b5dc74b64dc55876 (diff)
parent: 945836eade7d8f12f6eb84bc209da13ae7c89b38 (diff)
9 files changed, 4095 insertions, 60 deletions
diff --git a/test/core/client_config/lb_policies_test.c b/test/core/client_config/lb_policies_test.c
index 6f218e7f08..5aa8140e08 100644
--- a/test/core/client_config/lb_policies_test.c
+++ b/test/core/client_config/lb_policies_test.c
@@ -135,8 +135,9 @@ static void kill_server(const servers_fixture *f, size_t i) {
   gpr_log(GPR_INFO, "KILLING SERVER %d", i);
   GPR_ASSERT(f->servers[i] != NULL);
   grpc_server_shutdown_and_notify(f->servers[i], f->cq, tag(10000));
-  GPR_ASSERT(grpc_completion_queue_pluck(f->cq, tag(10000), n_millis_time(5000),
-                                         NULL).type == GRPC_OP_COMPLETE);
+  GPR_ASSERT(
+      grpc_completion_queue_pluck(f->cq, tag(10000), n_millis_time(5000), NULL)
+          .type == GRPC_OP_COMPLETE);
   grpc_server_destroy(f->servers[i]);
   f->servers[i] = NULL;
 }
@@ -202,8 +203,8 @@ static void teardown_servers(servers_fixture *f) {
     if (f->servers[i] == NULL) continue;
     grpc_server_shutdown_and_notify(f->servers[i], f->cq, tag(10000));
     GPR_ASSERT(grpc_completion_queue_pluck(f->cq, tag(10000),
-                                           n_millis_time(5000),
-                                           NULL).type == GRPC_OP_COMPLETE);
+                                           n_millis_time(5000), NULL)
+                   .type == GRPC_OP_COMPLETE);
     grpc_server_destroy(f->servers[i]);
   }
   grpc_completion_queue_shutdown(f->cq);
@@ -303,8 +304,8 @@ int *perform_request(servers_fixture *f, grpc_channel *client,
 
     s_idx = -1;
     while ((ev = grpc_completion_queue_next(
-                f->cq, GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1), NULL)).type !=
-           GRPC_QUEUE_TIMEOUT) {
+                f->cq, GRPC_TIMEOUT_SECONDS_TO_DEADLINE(1), NULL))
+               .type != GRPC_QUEUE_TIMEOUT) {
       GPR_ASSERT(ev.type == GRPC_OP_COMPLETE);
       read_tag = ((int)(gpr_intptr)ev.tag);
       gpr_log(GPR_DEBUG, "EVENT: success:%d, type:%d, tag:%d iter:%d",
diff --git a/test/core/client_config/set_initial_connect_string_test.c b/test/core/client_config/set_initial_connect_string_test.c
new file mode 100644
index 0000000000..13517b7c1f
--- /dev/null
+++ b/test/core/client_config/set_initial_connect_string_test.c
@@ -0,0 +1,221 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+#include <string.h>
+
+#include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include <grpc/support/slice.h>
+
+#include "src/core/client_config/initial_connect_string.h"
+#include "src/core/iomgr/sockaddr.h"
+#include "src/core/security/credentials.h"
+#include "src/core/support/string.h"
+#include "test/core/util/port.h"
+#include "test/core/util/test_config.h"
+#include "test/core/util/test_tcp_server.h"
+
+struct rpc_state {
+  char *target;
+  grpc_channel_credentials *creds;
+  grpc_completion_queue *cq;
+  grpc_channel *channel;
+  grpc_call *call;
+  grpc_op op;
+  gpr_slice_buffer incoming_buffer;
+  gpr_slice_buffer temp_incoming_buffer;
+  grpc_endpoint *tcp;
+  int done;
+};
+
+static const char *magic_connect_string = "magic initial string";
+static int server_port;
+static struct rpc_state state;
+static grpc_closure on_read;
+
+static void handle_read(grpc_exec_ctx *exec_ctx, void *arg, int success) {
+  GPR_ASSERT(success);
+  gpr_slice_buffer_move_into(
+    &state.temp_incoming_buffer, &state.incoming_buffer);
+  if (state.incoming_buffer.length > strlen(magic_connect_string)) {
+    state.done = 1;
+    grpc_endpoint_shutdown(exec_ctx, state.tcp);
+    grpc_endpoint_destroy(exec_ctx, state.tcp);
+  } else {
+    grpc_endpoint_read(
+      exec_ctx, state.tcp, &state.temp_incoming_buffer, &on_read);
+  }
+}
+
+static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp) {
+  test_tcp_server *server = arg;
+  grpc_closure_init(&on_read, handle_read, NULL);
+  gpr_slice_buffer_init(&state.incoming_buffer);
+  gpr_slice_buffer_init(&state.temp_incoming_buffer);
+  state.tcp = tcp;
+  grpc_endpoint_add_to_pollset(exec_ctx, tcp, &server->pollset);
+  grpc_endpoint_read(exec_ctx, tcp, &state.temp_incoming_buffer, &on_read);
+}
+
+static void set_magic_initial_string(struct sockaddr **addr, size_t *addr_len,
+                                     gpr_slice *connect_string) {
+  GPR_ASSERT(addr);
+  GPR_ASSERT(addr_len);
+  *connect_string = gpr_slice_from_copied_string(magic_connect_string);
+}
+
+static void reset_addr_and_set_magic_string(struct sockaddr **addr,
+                                            size_t *addr_len,
+                                            gpr_slice *connect_string) {
+  struct sockaddr_in target;
+  *connect_string = gpr_slice_from_copied_string(magic_connect_string);
+  gpr_free(*addr);
+  target.sin_family = AF_INET;
+  target.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+  target.sin_port = htons((uint16_t)server_port);
+  *addr_len = sizeof(target);
+  *addr = (struct sockaddr *)gpr_malloc(sizeof(target));
+  memcpy(*addr, &target, sizeof(target));
+}
+
+static gpr_timespec n_sec_deadline(int seconds) {
+  return gpr_time_add(gpr_now(GPR_CLOCK_REALTIME),
+                      gpr_time_from_seconds(seconds, GPR_TIMESPAN));
+}
+
+static void start_rpc(int use_creds, int target_port) {
+  state.done = 0;
+  state.cq = grpc_completion_queue_create(NULL);
+  if (use_creds) {
+    state.creds = grpc_fake_transport_security_credentials_create();
+  } else {
+    state.creds = NULL;
+  }
+  gpr_join_host_port(&state.target, "127.0.0.1", target_port);
+  if (use_creds) {
+    state.channel =
+        grpc_secure_channel_create(state.creds, state.target, NULL, NULL);
+  } else {
+    state.channel = grpc_insecure_channel_create(state.target, NULL, NULL);
+  }
+  state.call = grpc_channel_create_call(
+      state.channel, NULL, GRPC_PROPAGATE_DEFAULTS, state.cq, "/Service/Method",
+      "localhost", gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
+  state.op.op = GRPC_OP_SEND_INITIAL_METADATA;
+  state.op.data.send_initial_metadata.count = 0;
+  state.op.flags = 0;
+  state.op.reserved = NULL;
+  GPR_ASSERT(GRPC_CALL_OK == grpc_call_start_batch(state.call, &state.op,
+                                                   (size_t)(1), NULL, NULL));
+  grpc_completion_queue_next(state.cq, n_sec_deadline(1), NULL);
+}
+
+static void cleanup_rpc(void) {
+  grpc_event ev;
+  gpr_slice_buffer_destroy(&state.incoming_buffer);
+  gpr_slice_buffer_destroy(&state.temp_incoming_buffer);
+  grpc_channel_credentials_unref(state.creds);
+  grpc_call_destroy(state.call);
+  grpc_completion_queue_shutdown(state.cq);
+  do {
+    ev = grpc_completion_queue_next(state.cq, n_sec_deadline(1), NULL);
+  } while (ev.type != GRPC_QUEUE_SHUTDOWN);
+  grpc_completion_queue_destroy(state.cq);
+  grpc_channel_destroy(state.channel);
+  gpr_free(state.target);
+}
+
+static void poll_server_until_read_done(test_tcp_server *server) {
+  gpr_timespec deadline = n_sec_deadline(5);
+  while (state.done == 0 &&
+         gpr_time_cmp(gpr_now(GPR_CLOCK_REALTIME), deadline) < 0) {
+    test_tcp_server_poll(server, 1);
+  }
+}
+
+static void match_initial_magic_string(gpr_slice_buffer *buffer) {
+  size_t i, j, cmp_length;
+  size_t magic_length = strlen(magic_connect_string);
+  GPR_ASSERT(buffer->length >= magic_length);
+  for (i = 0, j = 0; i < state.incoming_buffer.count && j < magic_length; i++) {
+    char *dump =
+        gpr_dump_slice(state.incoming_buffer.slices[i], GPR_DUMP_ASCII);
+    cmp_length = GPR_MIN(strlen(dump), magic_length - j);
+    GPR_ASSERT(strncmp(dump, magic_connect_string + j, cmp_length) == 0);
+    j += cmp_length;
+    gpr_free(dump);
+  }
+}
+
+static void test_initial_string(test_tcp_server *server, int secure) {
+  grpc_test_set_initial_connect_string_function(set_magic_initial_string);
+  start_rpc(secure, server_port);
+  poll_server_until_read_done(server);
+  match_initial_magic_string(&state.incoming_buffer);
+  cleanup_rpc();
+}
+
+static void test_initial_string_with_redirect(test_tcp_server *server,
+                                              int secure) {
+  int another_port = grpc_pick_unused_port_or_die();
+  grpc_test_set_initial_connect_string_function(
+      reset_addr_and_set_magic_string);
+  start_rpc(secure, another_port);
+  poll_server_until_read_done(server);
+  match_initial_magic_string(&state.incoming_buffer);
+  cleanup_rpc();
+}
+
+static void run_test(void (*test)(test_tcp_server *server, int secure),
+                     int secure) {
+  test_tcp_server test_server;
+  server_port = grpc_pick_unused_port_or_die();
+  test_tcp_server_init(&test_server, on_connect, &test_server);
+  test_tcp_server_start(&test_server, server_port);
+  test(&test_server, secure);
+  test_tcp_server_destroy(&test_server);
+}
+
+int main(int argc, char **argv) {
+  grpc_test_init(argc, argv);
+  grpc_init();
+
+  run_test(test_initial_string, 0);
+  run_test(test_initial_string, 1);
+  run_test(test_initial_string_with_redirect, 0);
+  run_test(test_initial_string_with_redirect, 1);
+
+  grpc_shutdown();
+  return 0;
+}
diff --git a/test/core/fling/client.c b/test/core/fling/client.c
index a53411c2f5..99b30d6c4a 100644
--- a/test/core/fling/client.c
+++ b/test/core/fling/client.c
@@ -41,6 +41,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
 #include <grpc/support/useful.h>
+#include "src/core/profiling/timers.h"
 #include "test/core/util/grpc_profiler.h"
 #include "test/core/util/test_config.h"
 
@@ -89,6 +90,7 @@ static void init_ping_pong_request(void) {
 }
 
 static void step_ping_pong_request(void) {
+  GPR_TIMER_BEGIN("ping_pong", 1);
   call = grpc_channel_create_call(channel, NULL, GRPC_PROPAGATE_DEFAULTS, cq,
                                   "/Reflector/reflectUnary", "localhost",
                                   gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
@@ -99,6 +101,7 @@ static void step_ping_pong_request(void) {
   grpc_call_destroy(call);
   grpc_byte_buffer_destroy(response_payload_recv);
   call = NULL;
+  GPR_TIMER_END("ping_pong", 1);
 }
 
 static void init_ping_pong_stream(void) {
@@ -122,10 +125,12 @@ static void init_ping_pong_stream(void) {
 
 static void step_ping_pong_stream(void) {
   grpc_call_error error;
+  GPR_TIMER_BEGIN("ping_pong", 1);
   error = grpc_call_start_batch(call, stream_step_ops, 2, (void *)1, NULL);
   GPR_ASSERT(GRPC_CALL_OK == error);
   grpc_completion_queue_next(cq, gpr_inf_future(GPR_CLOCK_REALTIME), NULL);
   grpc_byte_buffer_destroy(response_payload_recv);
+  GPR_TIMER_END("ping_pong", 1);
 }
 
 static double now(void) {
@@ -159,12 +164,14 @@ int main(int argc, char **argv) {
   char *scenario_name = "ping-pong-request";
   scenario sc = {NULL, NULL, NULL};
 
+  gpr_timers_set_log_filename("latency_trace.fling_client.txt");
+
+  grpc_init();
+
   GPR_ASSERT(argc >= 1);
   fake_argv[0] = argv[0];
   grpc_test_init(1, fake_argv);
 
-  grpc_init();
-
   cl = gpr_cmdline_create("fling client");
   gpr_cmdline_add_int(cl, "payload_size", "Size of the payload to send",
                       &payload_size);
diff --git a/test/core/fling/server.c b/test/core/fling/server.c
index 67631e5a07..14a1a815bc 100644
--- a/test/core/fling/server.c
+++ b/test/core/fling/server.c
@@ -44,15 +44,16 @@
 #include <unistd.h>
 #endif
 
-#include "test/core/util/grpc_profiler.h"
-#include "test/core/util/test_config.h"
 #include <grpc/support/alloc.h>
 #include <grpc/support/cmdline.h>
 #include <grpc/support/host_port.h>
 #include <grpc/support/log.h>
 #include <grpc/support/time.h>
+#include "src/core/profiling/timers.h"
 #include "test/core/util/port.h"
 #include "test/core/end2end/data/ssl_test_data.h"
+#include "test/core/util/grpc_profiler.h"
+#include "test/core/util/test_config.h"
 
 static grpc_completion_queue *cq;
 static grpc_server *server;
@@ -192,6 +193,8 @@ int main(int argc, char **argv) {
 
   char *fake_argv[1];
 
+  gpr_timers_set_log_filename("latency_trace.fling_server.txt");
+
   GPR_ASSERT(argc >= 1);
   fake_argv[0] = argv[0];
   grpc_test_init(1, fake_argv);
diff --git a/test/core/support/avl_test.c b/test/core/support/avl_test.c
new file mode 100644
index 0000000000..6530fe4269
--- /dev/null
+++ b/test/core/support/avl_test.c
@@ -0,0 +1,3671 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#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 = gpr_malloc(sizeof(*b));
+  *b = x;
+  return b;
+}
+
+static long int_compare(void *int1, void *int2) {
+  return (*(int *)int1) - (*(int *)int2);
+}
+static void *int_copy(void *p) { return box(*(int *)p); }
+
+static const gpr_avl_vtable int_int_vtable = {gpr_free, int_copy, int_compare,
+                                              gpr_free, 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) == value);
+  gpr_free(k);
+}
+
+static void check_negget(gpr_avl avl, int key) {
+  int *k = box(key);
+  GPR_ASSERT(gpr_avl_get(avl, k) == NULL);
+  gpr_free(k);
+}
+
+static gpr_avl remove_int(gpr_avl avl, int key) {
+  int *k = box(key);
+  avl = gpr_avl_remove(avl, k);
+  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));
+  avl = gpr_avl_add(avl, box(2), box(22));
+  avl = gpr_avl_add(avl, box(3), box(33));
+  check_get(avl, 1, 11);
+  check_get(avl, 2, 22);
+  check_get(avl, 3, 33);
+  check_negget(avl, 4);
+  gpr_avl_unref(avl);
+}
+
+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));
+  avl = gpr_avl_add(avl, box(4), box(2));
+  avl = gpr_avl_add(avl, box(3), box(3));
+  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);
+}
+
+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));
+  avl = gpr_avl_add(avl, box(3), box(2));
+  avl = gpr_avl_add(avl, box(4), box(3));
+  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);
+}
+
+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));
+  avl = gpr_avl_add(avl, box(4), box(2));
+  avl = gpr_avl_add(avl, box(5), box(3));
+  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);
+}
+
+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));
+  avl = gpr_avl_add(avl, box(5), box(2));
+  avl = gpr_avl_add(avl, box(4), box(3));
+  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);
+}
+
+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));
+  avl = gpr_avl_add(avl, box(4), box(2));
+  avl = gpr_avl_add(avl, box(3), box(3));
+  avl = gpr_avl_add(avl, box(2), box(4));
+  avl = gpr_avl_add(avl, box(1), box(5));
+  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);
+}
+
+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));
+  avl = gpr_avl_add(avl, box(1), box(2));
+  check_get(avl, 1, 2);
+  check_negget(avl, 2);
+  gpr_avl_unref(avl);
+}
+
+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));
+  avl = gpr_avl_add(avl, box(4), box(2));
+  avl = gpr_avl_add(avl, box(5), box(3));
+
+  avl3 = remove_int(gpr_avl_ref(avl), 3);
+  avl4 = remove_int(gpr_avl_ref(avl), 4);
+  avl5 = remove_int(gpr_avl_ref(avl), 5);
+  avln = remove_int(gpr_avl_ref(avl), 1);
+
+  gpr_avl_unref(avl);
+
+  check_negget(avl3, 3);
+  check_get(avl3, 4, 2);
+  check_get(avl3, 5, 3);
+  gpr_avl_unref(avl3);
+
+  check_get(avl4, 3, 1);
+  check_negget(avl4, 4);
+  check_get(avl4, 5, 3);
+  gpr_avl_unref(avl4);
+
+  check_get(avl5, 3, 1);
+  check_get(avl5, 4, 2);
+  check_negget(avl5, 5);
+  gpr_avl_unref(avl5);
+
+  check_get(avln, 3, 1);
+  check_get(avln, 4, 2);
+  check_get(avln, 5, 3);
+  gpr_avl_unref(avln);
+}
+
+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));
+  avl = remove_int(avl, 643);
+  avl = remove_int(avl, 983);
+  avl = gpr_avl_add(avl, box(985), box(4));
+  avl = gpr_avl_add(avl, box(640), box(5));
+  avl = gpr_avl_add(avl, box(41), box(6));
+  avl = gpr_avl_add(avl, box(112), box(7));
+  avl = gpr_avl_add(avl, box(342), box(8));
+  avl = remove_int(avl, 1013);
+  avl = gpr_avl_add(avl, box(434), box(10));
+  avl = gpr_avl_add(avl, box(520), box(11));
+  avl = gpr_avl_add(avl, box(231), box(12));
+  avl = gpr_avl_add(avl, box(852), box(13));
+  avl = remove_int(avl, 461);
+  avl = gpr_avl_add(avl, box(108), box(15));
+  avl = gpr_avl_add(avl, box(806), box(16));
+  avl = gpr_avl_add(avl, box(827), box(17));
+  avl = remove_int(avl, 796);
+  avl = gpr_avl_add(avl, box(340), box(19));
+  avl = gpr_avl_add(avl, box(498), box(20));
+  avl = gpr_avl_add(avl, box(203), box(21));
+  avl = gpr_avl_add(avl, box(751), box(22));
+  avl = gpr_avl_add(avl, box(150), box(23));
+  avl = remove_int(avl, 237);
+  avl = gpr_avl_add(avl, box(830), box(25));
+  avl = remove_int(avl, 1007);
+  avl = remove_int(avl, 394);
+  avl = gpr_avl_add(avl, box(65), box(28));
+  avl = remove_int(avl, 904);
+  avl = remove_int(avl, 123);
+  avl = gpr_avl_add(avl, box(238), box(31));
+  avl = gpr_avl_add(avl, box(184), box(32));
+  avl = remove_int(avl, 331);
+  avl = gpr_avl_add(avl, box(827), box(34));
+
+  check_get(avl, 830, 25);
+
+  gpr_avl_unref(avl);
+}
+
+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));
+  avl = remove_int(avl, 415);
+  avl = gpr_avl_add(avl, box(953), box(3));
+  avl = gpr_avl_add(avl, box(101), box(4));
+  avl = gpr_avl_add(avl, box(516), box(5));
+  avl = gpr_avl_add(avl, box(547), box(6));
+  avl = gpr_avl_add(avl, box(467), box(7));
+  avl = gpr_avl_add(avl, box(793), box(8));
+  avl = remove_int(avl, 190);
+  avl = gpr_avl_add(avl, box(687), box(10));
+  avl = gpr_avl_add(avl, box(242), box(11));
+  avl = gpr_avl_add(avl, box(142), box(12));
+  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));
+  avl = gpr_avl_add(avl, box(622), box(18));
+  avl = remove_int(avl, 513);
+  avl = remove_int(avl, 429);
+  avl = gpr_avl_add(avl, box(205), box(21));
+  avl = remove_int(avl, 663);
+  avl = remove_int(avl, 953);
+  avl = remove_int(avl, 892);
+  avl = gpr_avl_add(avl, box(236), box(25));
+  avl = remove_int(avl, 982);
+  avl = remove_int(avl, 201);
+  avl = remove_int(avl, 684);
+  avl = gpr_avl_add(avl, box(572), box(29));
+  avl = remove_int(avl, 817);
+  avl = gpr_avl_add(avl, box(970), box(31));
+  avl = remove_int(avl, 347);
+  avl = remove_int(avl, 574);
+  avl = gpr_avl_add(avl, box(752), box(34));
+  avl = gpr_avl_add(avl, box(670), box(35));
+  avl = gpr_avl_add(avl, box(69), box(36));
+  avl = remove_int(avl, 111);
+  avl = remove_int(avl, 523);
+  avl = gpr_avl_add(avl, box(141), box(39));
+  avl = remove_int(avl, 159);
+  avl = gpr_avl_add(avl, box(947), box(41));
+  avl = gpr_avl_add(avl, box(855), box(42));
+  avl = remove_int(avl, 218);
+  avl = remove_int(avl, 6);
+  avl = gpr_avl_add(avl, box(753), box(45));
+  avl = remove_int(avl, 82);
+  avl = remove_int(avl, 799);
+  avl = gpr_avl_add(avl, box(572), box(48));
+  avl = remove_int(avl, 376);
+  avl = remove_int(avl, 413);
+  avl = gpr_avl_add(avl, box(458), box(51));
+  avl = remove_int(avl, 897);
+  avl = gpr_avl_add(avl, box(191), box(53));
+  avl = gpr_avl_add(avl, box(609), box(54));
+  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));
+  avl = remove_int(avl, 641);
+  avl = gpr_avl_add(avl, box(462), box(62));
+  avl = remove_int(avl, 359);
+  avl = remove_int(avl, 767);
+  avl = gpr_avl_add(avl, box(310), box(65));
+  avl = remove_int(avl, 757);
+  avl = remove_int(avl, 639);
+  avl = remove_int(avl, 314);
+  avl = gpr_avl_add(avl, box(2), box(69));
+  avl = remove_int(avl, 138);
+  avl = gpr_avl_add(avl, box(669), box(71));
+  avl = remove_int(avl, 477);
+  avl = gpr_avl_add(avl, box(366), box(73));
+  avl = gpr_avl_add(avl, box(612), box(74));
+  avl = gpr_avl_add(avl, box(106), box(75));
+  avl = remove_int(avl, 161);
+  avl = gpr_avl_add(avl, box(388), box(77));
+  avl = gpr_avl_add(avl, box(141), box(78));
+  avl = remove_int(avl, 633);
+  avl = remove_int(avl, 459);
+  avl = gpr_avl_add(avl, box(40), box(81));
+  avl = remove_int(avl, 689);
+  avl = gpr_avl_add(avl, box(823), box(83));
+  avl = remove_int(avl, 485);
+  avl = gpr_avl_add(avl, box(903), box(85));
+  avl = gpr_avl_add(avl, box(592), box(86));
+  avl = remove_int(avl, 448);
+  avl = gpr_avl_add(avl, box(56), box(88));
+  avl = remove_int(avl, 333);
+  avl = gpr_avl_add(avl, box(189), box(90));
+  avl = gpr_avl_add(avl, box(103), box(91));
+  avl = remove_int(avl, 164);
+  avl = remove_int(avl, 974);
+  avl = gpr_avl_add(avl, box(215), box(94));
+  avl = remove_int(avl, 189);
+  avl = remove_int(avl, 504);
+  avl = gpr_avl_add(avl, box(868), box(97));
+  avl = remove_int(avl, 909);
+  avl = remove_int(avl, 148);
+  avl = remove_int(avl, 469);
+  avl = gpr_avl_add(avl, box(994), box(101));
+  avl = gpr_avl_add(avl, box(576), box(102));
+  avl = remove_int(avl, 82);
+  avl = remove_int(avl, 209);
+  avl = gpr_avl_add(avl, box(276), box(105));
+  avl = remove_int(avl, 856);
+  avl = gpr_avl_add(avl, box(750), box(107));
+  avl = remove_int(avl, 871);
+  avl = gpr_avl_add(avl, box(301), box(109));
+  avl = remove_int(avl, 260);
+  avl = remove_int(avl, 737);
+  avl = remove_int(avl, 719);
+  avl = gpr_avl_add(avl, box(933), box(113));
+  avl = gpr_avl_add(avl, box(225), box(114));
+  avl = gpr_avl_add(avl, box(975), box(115));
+  avl = gpr_avl_add(avl, box(86), box(116));
+  avl = remove_int(avl, 732);
+  avl = gpr_avl_add(avl, box(340), box(118));
+  avl = gpr_avl_add(avl, box(271), box(119));
+  avl = remove_int(avl, 206);
+  avl = gpr_avl_add(avl, box(949), box(121));
+  avl = gpr_avl_add(avl, box(927), box(122));
+  avl = gpr_avl_add(avl, box(34), box(123));
+  avl = gpr_avl_add(avl, box(351), box(124));
+  avl = remove_int(avl, 836);
+  avl = gpr_avl_add(avl, box(825), box(126));
+  avl = gpr_avl_add(avl, box(352), box(127));
+  avl = remove_int(avl, 107);
+  avl = remove_int(avl, 101);
+  avl = gpr_avl_add(avl, box(320), box(130));
+  avl = gpr_avl_add(avl, box(3), box(131));
+  avl = remove_int(avl, 998);
+  avl = remove_int(avl, 44);
+  avl = gpr_avl_add(avl, box(525), box(134));
+  avl = gpr_avl_add(avl, box(864), box(135));
+  avl = gpr_avl_add(avl, box(863), box(136));
+  avl = remove_int(avl, 770);
+  avl = gpr_avl_add(avl, box(440), box(138));
+  avl = remove_int(avl, 516);
+  avl = gpr_avl_add(avl, box(116), box(140));
+  avl = remove_int(avl, 380);
+  avl = gpr_avl_add(avl, box(878), box(142));
+  avl = remove_int(avl, 439);
+  avl = gpr_avl_add(avl, box(994), box(144));
+  avl = remove_int(avl, 294);
+  avl = remove_int(avl, 593);
+  avl = gpr_avl_add(avl, box(696), box(147));
+  avl = remove_int(avl, 8);
+  avl = gpr_avl_add(avl, box(881), box(149));
+  avl = remove_int(avl, 32);
+  avl = remove_int(avl, 242);
+  avl = gpr_avl_add(avl, box(487), box(152));
+  avl = gpr_avl_add(avl, box(637), box(153));
+  avl = gpr_avl_add(avl, box(793), box(154));
+  avl = gpr_avl_add(avl, box(696), box(155));
+  avl = remove_int(avl, 458);
+  avl = gpr_avl_add(avl, box(828), box(157));
+  avl = remove_int(avl, 784);
+  avl = remove_int(avl, 274);
+  avl = gpr_avl_add(avl, box(783), box(160));
+  avl = remove_int(avl, 21);
+  avl = gpr_avl_add(avl, box(866), box(162));
+  avl = remove_int(avl, 919);
+  avl = gpr_avl_add(avl, box(435), box(164));
+  avl = remove_int(avl, 385);
+  avl = gpr_avl_add(avl, box(475), box(166));
+  avl = remove_int(avl, 339);
+  avl = gpr_avl_add(avl, box(615), box(168));
+  avl = remove_int(avl, 866);
+  avl = remove_int(avl, 82);
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(590), box(172));
+  avl = gpr_avl_add(avl, box(852), box(173));
+  avl = remove_int(avl, 318);
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(672), box(176));
+  avl = remove_int(avl, 430);
+  avl = gpr_avl_add(avl, box(821), box(178));
+  avl = gpr_avl_add(avl, box(365), box(179));
+  avl = remove_int(avl, 78);
+  avl = gpr_avl_add(avl, box(700), box(181));
+  avl = gpr_avl_add(avl, box(353), box(182));
+  avl = remove_int(avl, 492);
+  avl = gpr_avl_add(avl, box(991), box(184));
+  avl = remove_int(avl, 330);
+  avl = gpr_avl_add(avl, box(873), box(186));
+  avl = remove_int(avl, 589);
+  avl = gpr_avl_add(avl, box(676), box(188));
+  avl = gpr_avl_add(avl, box(790), box(189));
+  avl = remove_int(avl, 521);
+  avl = remove_int(avl, 47);
+  avl = gpr_avl_add(avl, box(976), box(192));
+  avl = gpr_avl_add(avl, box(683), box(193));
+  avl = remove_int(avl, 803);
+  avl = remove_int(avl, 1006);
+  avl = gpr_avl_add(avl, box(775), box(196));
+  avl = gpr_avl_add(avl, box(411), box(197));
+  avl = gpr_avl_add(avl, box(697), box(198));
+  avl = remove_int(avl, 50);
+  avl = gpr_avl_add(avl, box(213), box(200));
+  avl = remove_int(avl, 714);
+  avl = gpr_avl_add(avl, box(981), box(202));
+  avl = gpr_avl_add(avl, box(502), box(203));
+  avl = gpr_avl_add(avl, box(697), box(204));
+  avl = gpr_avl_add(avl, box(603), box(205));
+  avl = gpr_avl_add(avl, box(117), box(206));
+  avl = remove_int(avl, 363);
+  avl = gpr_avl_add(avl, box(104), box(208));
+  avl = remove_int(avl, 842);
+  avl = gpr_avl_add(avl, box(48), box(210));
+  avl = remove_int(avl, 764);
+  avl = gpr_avl_add(avl, box(482), box(212));
+  avl = gpr_avl_add(avl, box(928), box(213));
+  avl = gpr_avl_add(avl, box(30), box(214));
+  avl = gpr_avl_add(avl, box(820), box(215));
+  avl = gpr_avl_add(avl, box(334), box(216));
+  avl = remove_int(avl, 306);
+  avl = gpr_avl_add(avl, box(789), box(218));
+  avl = remove_int(avl, 924);
+  avl = gpr_avl_add(avl, box(53), box(220));
+  avl = remove_int(avl, 657);
+  avl = gpr_avl_add(avl, box(130), box(222));
+  avl = gpr_avl_add(avl, box(239), box(223));
+  avl = remove_int(avl, 20);
+  avl = gpr_avl_add(avl, box(117), box(225));
+  avl = remove_int(avl, 882);
+  avl = remove_int(avl, 891);
+  avl = gpr_avl_add(avl, box(9), box(228));
+  avl = gpr_avl_add(avl, box(496), box(229));
+  avl = gpr_avl_add(avl, box(750), box(230));
+  avl = gpr_avl_add(avl, box(283), box(231));
+  avl = gpr_avl_add(avl, box(802), box(232));
+  avl = remove_int(avl, 352);
+  avl = gpr_avl_add(avl, box(374), box(234));
+  avl = gpr_avl_add(avl, box(6), box(235));
+  avl = gpr_avl_add(avl, box(756), box(236));
+  avl = gpr_avl_add(avl, box(597), box(237));
+  avl = gpr_avl_add(avl, box(661), box(238));
+  avl = remove_int(avl, 96);
+  avl = gpr_avl_add(avl, box(894), box(240));
+  avl = remove_int(avl, 749);
+  avl = gpr_avl_add(avl, box(71), box(242));
+  avl = remove_int(avl, 68);
+  avl = gpr_avl_add(avl, box(388), box(244));
+  avl = remove_int(avl, 119);
+  avl = remove_int(avl, 856);
+  avl = gpr_avl_add(avl, box(176), box(247));
+  avl = gpr_avl_add(avl, box(993), box(248));
+  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));
+  avl = gpr_avl_add(avl, box(484), box(258));
+  avl = remove_int(avl, 837);
+  avl = gpr_avl_add(avl, box(388), box(260));
+  avl = remove_int(avl, 987);
+  avl = gpr_avl_add(avl, box(336), box(262));
+  avl = remove_int(avl, 855);
+  avl = gpr_avl_add(avl, box(668), box(264));
+  avl = remove_int(avl, 648);
+  avl = gpr_avl_add(avl, box(193), box(266));
+  avl = remove_int(avl, 939);
+  avl = gpr_avl_add(avl, box(740), box(268));
+  avl = gpr_avl_add(avl, box(503), box(269));
+  avl = gpr_avl_add(avl, box(765), box(270));
+  avl = remove_int(avl, 924);
+  avl = remove_int(avl, 513);
+  avl = gpr_avl_add(avl, box(161), box(273));
+  avl = gpr_avl_add(avl, box(502), box(274));
+  avl = gpr_avl_add(avl, box(846), box(275));
+  avl = remove_int(avl, 931);
+  avl = gpr_avl_add(avl, box(87), box(277));
+  avl = gpr_avl_add(avl, box(949), box(278));
+  avl = gpr_avl_add(avl, box(548), box(279));
+  avl = gpr_avl_add(avl, box(951), box(280));
+  avl = remove_int(avl, 1018);
+  avl = remove_int(avl, 568);
+  avl = gpr_avl_add(avl, box(138), box(283));
+  avl = gpr_avl_add(avl, box(202), box(284));
+  avl = gpr_avl_add(avl, box(157), box(285));
+  avl = gpr_avl_add(avl, box(264), box(286));
+  avl = gpr_avl_add(avl, box(370), box(287));
+  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));
+  avl = remove_int(avl, 354);
+  avl = gpr_avl_add(avl, box(134), box(297));
+  avl = remove_int(avl, 781);
+  avl = remove_int(avl, 183);
+  avl = gpr_avl_add(avl, box(914), box(300));
+  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));
+  avl = gpr_avl_add(avl, box(699), box(307));
+  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));
+  avl = gpr_avl_add(avl, box(265), box(315));
+  avl = gpr_avl_add(avl, box(268), box(316));
+  avl = gpr_avl_add(avl, box(103), box(317));
+  avl = gpr_avl_add(avl, box(440), box(318));
+  avl = remove_int(avl, 777);
+  avl = gpr_avl_add(avl, box(670), box(320));
+  avl = remove_int(avl, 506);
+  avl = remove_int(avl, 487);
+  avl = gpr_avl_add(avl, box(421), box(323));
+  avl = remove_int(avl, 514);
+  avl = gpr_avl_add(avl, box(701), box(325));
+  avl = remove_int(avl, 949);
+  avl = remove_int(avl, 872);
+  avl = remove_int(avl, 139);
+  avl = gpr_avl_add(avl, box(781), box(329));
+  avl = gpr_avl_add(avl, box(543), box(330));
+  avl = gpr_avl_add(avl, box(147), box(331));
+  avl = remove_int(avl, 190);
+  avl = gpr_avl_add(avl, box(453), box(333));
+  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));
+  avl = remove_int(avl, 812);
+  avl = gpr_avl_add(avl, box(431), box(340));
+  avl = gpr_avl_add(avl, box(8), box(341));
+  avl = remove_int(avl, 843);
+  avl = gpr_avl_add(avl, box(831), box(343));
+  avl = remove_int(avl, 472);
+  avl = remove_int(avl, 157);
+  avl = gpr_avl_add(avl, box(612), box(346));
+  avl = gpr_avl_add(avl, box(802), box(347));
+  avl = remove_int(avl, 554);
+  avl = gpr_avl_add(avl, box(409), box(349));
+  avl = gpr_avl_add(avl, box(439), box(350));
+  avl = gpr_avl_add(avl, box(725), box(351));
+  avl = gpr_avl_add(avl, box(568), box(352));
+  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));
+  avl = gpr_avl_add(avl, box(950), box(358));
+  avl = gpr_avl_add(avl, box(532), box(359));
+  avl = gpr_avl_add(avl, box(832), box(360));
+  avl = remove_int(avl, 390);
+  avl = gpr_avl_add(avl, box(993), box(362));
+  avl = remove_int(avl, 198);
+  avl = remove_int(avl, 401);
+  avl = gpr_avl_add(avl, box(316), box(365));
+  avl = remove_int(avl, 843);
+  avl = gpr_avl_add(avl, box(541), box(367));
+  avl = gpr_avl_add(avl, box(505), box(368));
+  avl = remove_int(avl, 445);
+  avl = remove_int(avl, 256);
+  avl = gpr_avl_add(avl, box(232), box(371));
+  avl = remove_int(avl, 577);
+  avl = remove_int(avl, 558);
+  avl = gpr_avl_add(avl, box(910), box(374));
+  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));
+  avl = gpr_avl_add(avl, box(655), box(381));
+  avl = remove_int(avl, 557);
+  avl = remove_int(avl, 102);
+  avl = remove_int(avl, 165);
+  avl = gpr_avl_add(avl, box(191), box(385));
+  avl = remove_int(avl, 30);
+  avl = gpr_avl_add(avl, box(406), box(387));
+  avl = gpr_avl_add(avl, box(66), box(388));
+  avl = gpr_avl_add(avl, box(87), box(389));
+  avl = remove_int(avl, 7);
+  avl = remove_int(avl, 671);
+  avl = gpr_avl_add(avl, box(234), box(392));
+  avl = remove_int(avl, 463);
+  avl = gpr_avl_add(avl, box(75), box(394));
+  avl = gpr_avl_add(avl, box(487), box(395));
+  avl = remove_int(avl, 203);
+  avl = gpr_avl_add(avl, box(711), box(397));
+  avl = remove_int(avl, 291);
+  avl = remove_int(avl, 798);
+  avl = remove_int(avl, 337);
+  avl = gpr_avl_add(avl, box(877), box(401));
+  avl = gpr_avl_add(avl, box(388), box(402));
+  avl = remove_int(avl, 975);
+  avl = gpr_avl_add(avl, box(200), box(404));
+  avl = gpr_avl_add(avl, box(408), box(405));
+  avl = gpr_avl_add(avl, box(3), box(406));
+  avl = gpr_avl_add(avl, box(971), box(407));
+  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));
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 364);
+  avl = gpr_avl_add(avl, box(215), box(415));
+  avl = remove_int(avl, 778);
+  avl = remove_int(avl, 45);
+  avl = gpr_avl_add(avl, box(328), box(418));
+  avl = gpr_avl_add(avl, box(597), box(419));
+  avl = remove_int(avl, 34);
+  avl = gpr_avl_add(avl, box(736), box(421));
+  avl = remove_int(avl, 37);
+  avl = gpr_avl_add(avl, box(275), box(423));
+  avl = gpr_avl_add(avl, box(70), box(424));
+  avl = gpr_avl_add(avl, box(771), box(425));
+  avl = remove_int(avl, 536);
+  avl = remove_int(avl, 421);
+  avl = gpr_avl_add(avl, box(186), box(428));
+  avl = gpr_avl_add(avl, box(788), box(429));
+  avl = gpr_avl_add(avl, box(224), box(430));
+  avl = remove_int(avl, 228);
+  avl = gpr_avl_add(avl, box(48), box(432));
+  avl = gpr_avl_add(avl, box(120), box(433));
+  avl = gpr_avl_add(avl, box(269), box(434));
+  avl = gpr_avl_add(avl, box(904), box(435));
+  avl = remove_int(avl, 699);
+  avl = gpr_avl_add(avl, box(340), box(437));
+  avl = remove_int(avl, 276);
+  avl = gpr_avl_add(avl, box(591), box(439));
+  avl = gpr_avl_add(avl, box(778), box(440));
+  avl = remove_int(avl, 490);
+  avl = remove_int(avl, 973);
+  avl = gpr_avl_add(avl, box(294), box(443));
+  avl = gpr_avl_add(avl, box(323), box(444));
+  avl = remove_int(avl, 685);
+  avl = gpr_avl_add(avl, box(38), box(446));
+  avl = gpr_avl_add(avl, box(525), box(447));
+  avl = remove_int(avl, 162);
+  avl = gpr_avl_add(avl, box(462), box(449));
+  avl = gpr_avl_add(avl, box(340), box(450));
+  avl = remove_int(avl, 734);
+  avl = remove_int(avl, 959);
+  avl = gpr_avl_add(avl, box(752), box(453));
+  avl = gpr_avl_add(avl, box(667), box(454));
+  avl = remove_int(avl, 558);
+  avl = remove_int(avl, 657);
+  avl = gpr_avl_add(avl, box(711), box(457));
+  avl = remove_int(avl, 937);
+  avl = gpr_avl_add(avl, box(741), box(459));
+  avl = gpr_avl_add(avl, box(40), box(460));
+  avl = remove_int(avl, 784);
+  avl = gpr_avl_add(avl, box(292), box(462));
+  avl = remove_int(avl, 164);
+  avl = remove_int(avl, 931);
+  avl = remove_int(avl, 886);
+  avl = gpr_avl_add(avl, box(968), box(466));
+  avl = remove_int(avl, 263);
+  avl = gpr_avl_add(avl, box(647), box(468));
+  avl = gpr_avl_add(avl, box(92), box(469));
+  avl = remove_int(avl, 310);
+  avl = gpr_avl_add(avl, box(711), box(471));
+  avl = gpr_avl_add(avl, box(675), box(472));
+  avl = remove_int(avl, 549);
+  avl = gpr_avl_add(avl, box(380), box(474));
+  avl = remove_int(avl, 825);
+  avl = gpr_avl_add(avl, box(668), box(476));
+  avl = remove_int(avl, 498);
+  avl = gpr_avl_add(avl, box(870), box(478));
+  avl = gpr_avl_add(avl, box(391), box(479));
+  avl = gpr_avl_add(avl, box(264), box(480));
+  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));
+  avl = remove_int(avl, 849);
+  avl = remove_int(avl, 47);
+  avl = gpr_avl_add(avl, box(299), box(490));
+  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));
+  avl = gpr_avl_add(avl, box(524), box(496));
+  avl = remove_int(avl, 210);
+  avl = remove_int(avl, 299);
+  avl = gpr_avl_add(avl, box(823), box(499));
+  avl = remove_int(avl, 479);
+  avl = remove_int(avl, 96);
+  avl = remove_int(avl, 1013);
+  avl = gpr_avl_add(avl, box(768), box(503));
+  avl = remove_int(avl, 638);
+  avl = remove_int(avl, 20);
+  avl = gpr_avl_add(avl, box(663), box(506));
+  avl = remove_int(avl, 882);
+  avl = gpr_avl_add(avl, box(745), box(508));
+  avl = remove_int(avl, 352);
+  avl = gpr_avl_add(avl, box(10), box(510));
+  avl = remove_int(avl, 484);
+  avl = gpr_avl_add(avl, box(420), box(512));
+  avl = gpr_avl_add(avl, box(884), box(513));
+  avl = gpr_avl_add(avl, box(993), box(514));
+  avl = gpr_avl_add(avl, box(251), box(515));
+  avl = remove_int(avl, 222);
+  avl = gpr_avl_add(avl, box(734), box(517));
+  avl = gpr_avl_add(avl, box(952), box(518));
+  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));
+  avl = remove_int(avl, 897);
+  avl = gpr_avl_add(avl, box(719), box(526));
+  avl = gpr_avl_add(avl, box(622), box(527));
+  avl = remove_int(avl, 28);
+  avl = remove_int(avl, 836);
+  avl = remove_int(avl, 142);
+  avl = gpr_avl_add(avl, box(445), box(531));
+  avl = gpr_avl_add(avl, box(410), box(532));
+  avl = remove_int(avl, 575);
+  avl = gpr_avl_add(avl, box(634), box(534));
+  avl = gpr_avl_add(avl, box(906), box(535));
+  avl = remove_int(avl, 649);
+  avl = gpr_avl_add(avl, box(813), box(537));
+  avl = remove_int(avl, 702);
+  avl = remove_int(avl, 732);
+  avl = gpr_avl_add(avl, box(105), box(540));
+  avl = gpr_avl_add(avl, box(867), box(541));
+  avl = remove_int(avl, 964);
+  avl = remove_int(avl, 941);
+  avl = gpr_avl_add(avl, box(947), box(544));
+  avl = remove_int(avl, 990);
+  avl = gpr_avl_add(avl, box(816), box(546));
+  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));
+  avl = gpr_avl_add(avl, box(786), box(552));
+  avl = gpr_avl_add(avl, box(526), box(553));
+  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));
+  avl = gpr_avl_add(avl, box(749), box(559));
+  avl = gpr_avl_add(avl, box(194), box(560));
+  avl = remove_int(avl, 517);
+  avl = gpr_avl_add(avl, box(102), box(562));
+  avl = remove_int(avl, 189);
+  avl = gpr_avl_add(avl, box(927), box(564));
+  avl = remove_int(avl, 846);
+  avl = remove_int(avl, 130);
+  avl = gpr_avl_add(avl, box(694), box(567));
+  avl = remove_int(avl, 750);
+  avl = gpr_avl_add(avl, box(357), box(569));
+  avl = remove_int(avl, 431);
+  avl = remove_int(avl, 91);
+  avl = gpr_avl_add(avl, box(640), box(572));
+  avl = remove_int(avl, 4);
+  avl = gpr_avl_add(avl, box(81), box(574));
+  avl = gpr_avl_add(avl, box(595), box(575));
+  avl = remove_int(avl, 444);
+  avl = remove_int(avl, 262);
+  avl = remove_int(avl, 11);
+  avl = gpr_avl_add(avl, box(192), box(579));
+  avl = gpr_avl_add(avl, box(158), box(580));
+  avl = remove_int(avl, 401);
+  avl = remove_int(avl, 918);
+  avl = gpr_avl_add(avl, box(180), box(583));
+  avl = remove_int(avl, 268);
+  avl = gpr_avl_add(avl, box(1012), box(585));
+  avl = gpr_avl_add(avl, box(90), box(586));
+  avl = gpr_avl_add(avl, box(946), box(587));
+  avl = remove_int(avl, 719);
+  avl = gpr_avl_add(avl, box(874), box(589));
+  avl = gpr_avl_add(avl, box(679), box(590));
+  avl = remove_int(avl, 53);
+  avl = remove_int(avl, 534);
+  avl = gpr_avl_add(avl, box(646), box(593));
+  avl = gpr_avl_add(avl, box(767), box(594));
+  avl = gpr_avl_add(avl, box(460), box(595));
+  avl = gpr_avl_add(avl, box(852), box(596));
+  avl = gpr_avl_add(avl, box(189), box(597));
+  avl = remove_int(avl, 932);
+  avl = remove_int(avl, 366);
+  avl = remove_int(avl, 907);
+  avl = gpr_avl_add(avl, box(875), box(601));
+  avl = gpr_avl_add(avl, box(434), box(602));
+  avl = gpr_avl_add(avl, box(704), box(603));
+  avl = gpr_avl_add(avl, box(724), box(604));
+  avl = gpr_avl_add(avl, box(930), box(605));
+  avl = gpr_avl_add(avl, box(1000), box(606));
+  avl = remove_int(avl, 479);
+  avl = gpr_avl_add(avl, box(275), box(608));
+  avl = remove_int(avl, 32);
+  avl = gpr_avl_add(avl, box(939), box(610));
+  avl = remove_int(avl, 943);
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(490), box(613));
+  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));
+  avl = remove_int(avl, 751);
+  avl = gpr_avl_add(avl, box(568), box(620));
+  avl = gpr_avl_add(avl, box(120), box(621));
+  avl = gpr_avl_add(avl, box(617), box(622));
+  avl = gpr_avl_add(avl, box(32), box(623));
+  avl = remove_int(avl, 701);
+  avl = gpr_avl_add(avl, box(910), box(625));
+  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));
+  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));
+  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));
+  avl = gpr_avl_add(avl, box(6), box(642));
+  avl = gpr_avl_add(avl, box(680), box(643));
+  avl = remove_int(avl, 741);
+  avl = remove_int(avl, 309);
+  avl = remove_int(avl, 272);
+  avl = gpr_avl_add(avl, box(249), box(647));
+  avl = remove_int(avl, 97);
+  avl = remove_int(avl, 850);
+  avl = gpr_avl_add(avl, box(915), box(650));
+  avl = gpr_avl_add(avl, box(816), box(651));
+  avl = gpr_avl_add(avl, box(45), box(652));
+  avl = gpr_avl_add(avl, box(168), box(653));
+  avl = remove_int(avl, 153);
+  avl = remove_int(avl, 239);
+  avl = gpr_avl_add(avl, box(684), box(656));
+  avl = gpr_avl_add(avl, box(208), box(657));
+  avl = gpr_avl_add(avl, box(681), box(658));
+  avl = gpr_avl_add(avl, box(609), box(659));
+  avl = gpr_avl_add(avl, box(645), box(660));
+  avl = remove_int(avl, 799);
+  avl = gpr_avl_add(avl, box(955), box(662));
+  avl = gpr_avl_add(avl, box(946), box(663));
+  avl = gpr_avl_add(avl, box(744), box(664));
+  avl = gpr_avl_add(avl, box(201), box(665));
+  avl = gpr_avl_add(avl, box(136), box(666));
+  avl = remove_int(avl, 357);
+  avl = gpr_avl_add(avl, box(974), box(668));
+  avl = remove_int(avl, 485);
+  avl = gpr_avl_add(avl, box(1009), box(670));
+  avl = gpr_avl_add(avl, box(517), box(671));
+  avl = remove_int(avl, 491);
+  avl = gpr_avl_add(avl, box(336), box(673));
+  avl = gpr_avl_add(avl, box(589), box(674));
+  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));
+  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));
+  avl = gpr_avl_add(avl, box(25), box(685));
+  avl = remove_int(avl, 278);
+  avl = gpr_avl_add(avl, box(191), box(687));
+  avl = remove_int(avl, 243);
+  avl = remove_int(avl, 918);
+  avl = remove_int(avl, 449);
+  avl = gpr_avl_add(avl, box(19), box(691));
+  avl = gpr_avl_add(avl, box(762), box(692));
+  avl = gpr_avl_add(avl, box(13), box(693));
+  avl = gpr_avl_add(avl, box(151), box(694));
+  avl = gpr_avl_add(avl, box(152), box(695));
+  avl = gpr_avl_add(avl, box(793), box(696));
+  avl = remove_int(avl, 862);
+  avl = remove_int(avl, 890);
+  avl = gpr_avl_add(avl, box(687), box(699));
+  avl = gpr_avl_add(avl, box(509), box(700));
+  avl = gpr_avl_add(avl, box(973), box(701));
+  avl = remove_int(avl, 230);
+  avl = gpr_avl_add(avl, box(532), box(703));
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(281), box(705));
+  avl = gpr_avl_add(avl, box(867), box(706));
+  avl = gpr_avl_add(avl, box(359), box(707));
+  avl = remove_int(avl, 425);
+  avl = gpr_avl_add(avl, box(691), box(709));
+  avl = gpr_avl_add(avl, box(163), box(710));
+  avl = gpr_avl_add(avl, box(502), box(711));
+  avl = remove_int(avl, 674);
+  avl = gpr_avl_add(avl, box(697), box(713));
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(968), box(715));
+  avl = gpr_avl_add(avl, box(48), box(716));
+  avl = remove_int(avl, 543);
+  avl = gpr_avl_add(avl, box(35), box(718));
+  avl = gpr_avl_add(avl, box(751), box(719));
+  avl = gpr_avl_add(avl, box(478), box(720));
+  avl = remove_int(avl, 797);
+  avl = remove_int(avl, 309);
+  avl = gpr_avl_add(avl, box(927), box(723));
+  avl = remove_int(avl, 504);
+  avl = gpr_avl_add(avl, box(286), box(725));
+  avl = gpr_avl_add(avl, box(413), box(726));
+  avl = gpr_avl_add(avl, box(599), box(727));
+  avl = remove_int(avl, 105);
+  avl = remove_int(avl, 605);
+  avl = gpr_avl_add(avl, box(632), box(730));
+  avl = gpr_avl_add(avl, box(133), box(731));
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(958), box(733));
+  avl = gpr_avl_add(avl, box(729), box(734));
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(694), box(736));
+  avl = gpr_avl_add(avl, box(505), box(737));
+  avl = remove_int(avl, 63);
+  avl = remove_int(avl, 714);
+  avl = gpr_avl_add(avl, box(1002), box(740));
+  avl = remove_int(avl, 211);
+  avl = gpr_avl_add(avl, box(765), box(742));
+  avl = gpr_avl_add(avl, box(455), box(743));
+  avl = remove_int(avl, 59);
+  avl = remove_int(avl, 224);
+  avl = gpr_avl_add(avl, box(586), box(746));
+  avl = gpr_avl_add(avl, box(348), box(747));
+  avl = remove_int(avl, 10);
+  avl = remove_int(avl, 484);
+  avl = gpr_avl_add(avl, box(968), box(750));
+  avl = gpr_avl_add(avl, box(923), box(751));
+  avl = remove_int(avl, 573);
+  avl = remove_int(avl, 617);
+  avl = gpr_avl_add(avl, box(812), box(754));
+  avl = gpr_avl_add(avl, box(179), box(755));
+  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));
+  avl = gpr_avl_add(avl, box(927), box(761));
+  avl = gpr_avl_add(avl, box(454), box(762));
+  avl = gpr_avl_add(avl, box(217), box(763));
+  avl = remove_int(avl, 534);
+  avl = gpr_avl_add(avl, box(180), box(765));
+  avl = gpr_avl_add(avl, box(319), box(766));
+  avl = remove_int(avl, 92);
+  avl = gpr_avl_add(avl, box(483), box(768));
+  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));
+  avl = remove_int(avl, 807);
+  avl = gpr_avl_add(avl, box(463), box(775));
+  avl = gpr_avl_add(avl, box(271), box(776));
+  avl = gpr_avl_add(avl, box(644), box(777));
+  avl = remove_int(avl, 618);
+  avl = gpr_avl_add(avl, box(166), box(779));
+  avl = gpr_avl_add(avl, box(538), box(780));
+  avl = remove_int(avl, 606);
+  avl = gpr_avl_add(avl, box(425), box(782));
+  avl = remove_int(avl, 725);
+  avl = remove_int(avl, 383);
+  avl = gpr_avl_add(avl, box(155), box(785));
+  avl = remove_int(avl, 889);
+  avl = gpr_avl_add(avl, box(653), box(787));
+  avl = remove_int(avl, 386);
+  avl = gpr_avl_add(avl, box(142), box(789));
+  avl = remove_int(avl, 107);
+  avl = remove_int(avl, 603);
+  avl = remove_int(avl, 971);
+  avl = gpr_avl_add(avl, box(80), box(793));
+  avl = gpr_avl_add(avl, box(61), box(794));
+  avl = gpr_avl_add(avl, box(693), box(795));
+  avl = gpr_avl_add(avl, box(592), box(796));
+  avl = gpr_avl_add(avl, box(433), box(797));
+  avl = gpr_avl_add(avl, box(973), box(798));
+  avl = remove_int(avl, 901);
+  avl = remove_int(avl, 340);
+  avl = remove_int(avl, 709);
+  avl = gpr_avl_add(avl, box(224), box(802));
+  avl = remove_int(avl, 120);
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(780), box(805));
+  avl = gpr_avl_add(avl, box(867), box(806));
+  avl = gpr_avl_add(avl, box(756), box(807));
+  avl = gpr_avl_add(avl, box(583), box(808));
+  avl = gpr_avl_add(avl, box(356), box(809));
+  avl = gpr_avl_add(avl, box(58), box(810));
+  avl = remove_int(avl, 219);
+  avl = gpr_avl_add(avl, box(301), box(812));
+  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));
+  avl = gpr_avl_add(avl, box(479), box(822));
+  avl = gpr_avl_add(avl, box(323), box(823));
+  avl = gpr_avl_add(avl, box(802), box(824));
+  avl = remove_int(avl, 682);
+  avl = remove_int(avl, 705);
+  avl = remove_int(avl, 487);
+  avl = gpr_avl_add(avl, box(530), box(828));
+  avl = gpr_avl_add(avl, box(232), box(829));
+  avl = remove_int(avl, 627);
+  avl = gpr_avl_add(avl, box(396), box(831));
+  avl = gpr_avl_add(avl, box(61), box(832));
+  avl = gpr_avl_add(avl, box(932), box(833));
+  avl = gpr_avl_add(avl, box(108), box(834));
+  avl = gpr_avl_add(avl, box(524), box(835));
+  avl = remove_int(avl, 390);
+  avl = remove_int(avl, 307);
+  avl = gpr_avl_add(avl, box(722), box(838));
+  avl = gpr_avl_add(avl, box(907), box(839));
+  avl = remove_int(avl, 286);
+  avl = remove_int(avl, 337);
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(973), box(843));
+  avl = remove_int(avl, 930);
+  avl = remove_int(avl, 242);
+  avl = gpr_avl_add(avl, box(997), box(846));
+  avl = gpr_avl_add(avl, box(689), box(847));
+  avl = remove_int(avl, 318);
+  avl = gpr_avl_add(avl, box(703), box(849));
+  avl = gpr_avl_add(avl, box(868), box(850));
+  avl = gpr_avl_add(avl, box(200), box(851));
+  avl = gpr_avl_add(avl, box(960), box(852));
+  avl = gpr_avl_add(avl, box(80), box(853));
+  avl = remove_int(avl, 113);
+  avl = gpr_avl_add(avl, box(135), box(855));
+  avl = remove_int(avl, 529);
+  avl = gpr_avl_add(avl, box(366), box(857));
+  avl = remove_int(avl, 272);
+  avl = gpr_avl_add(avl, box(921), box(859));
+  avl = remove_int(avl, 497);
+  avl = gpr_avl_add(avl, box(712), box(861));
+  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));
+  avl = gpr_avl_add(avl, box(29), box(867));
+  avl = gpr_avl_add(avl, box(180), box(868));
+  avl = gpr_avl_add(avl, box(983), box(869));
+  avl = gpr_avl_add(avl, box(72), box(870));
+  avl = gpr_avl_add(avl, box(693), box(871));
+  avl = gpr_avl_add(avl, box(567), box(872));
+  avl = remove_int(avl, 549);
+  avl = remove_int(avl, 351);
+  avl = gpr_avl_add(avl, box(1019), box(875));
+  avl = remove_int(avl, 585);
+  avl = remove_int(avl, 294);
+  avl = remove_int(avl, 61);
+  avl = gpr_avl_add(avl, box(409), box(879));
+  avl = gpr_avl_add(avl, box(984), box(880));
+  avl = gpr_avl_add(avl, box(830), box(881));
+  avl = remove_int(avl, 579);
+  avl = gpr_avl_add(avl, box(672), box(883));
+  avl = remove_int(avl, 968);
+
+  gpr_avl_unref(avl);
+}
+
+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));
+  avl = gpr_avl_add(avl, box(494), box(3));
+  avl = gpr_avl_add(avl, box(226), box(4));
+  avl = remove_int(avl, 524);
+  avl = gpr_avl_add(avl, box(540), box(6));
+  avl = remove_int(avl, 1008);
+  avl = gpr_avl_add(avl, box(502), box(8));
+  avl = remove_int(avl, 267);
+  avl = remove_int(avl, 764);
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(8), box(12));
+  avl = remove_int(avl, 291);
+  avl = remove_int(avl, 796);
+  avl = remove_int(avl, 1002);
+  avl = gpr_avl_add(avl, box(778), box(16));
+  avl = remove_int(avl, 621);
+  avl = remove_int(avl, 891);
+  avl = remove_int(avl, 880);
+  avl = gpr_avl_add(avl, box(197), box(20));
+  avl = gpr_avl_add(avl, box(441), box(21));
+  avl = gpr_avl_add(avl, box(719), box(22));
+  avl = remove_int(avl, 109);
+  avl = gpr_avl_add(avl, box(458), box(24));
+  avl = remove_int(avl, 86);
+  avl = gpr_avl_add(avl, box(897), box(26));
+  avl = gpr_avl_add(avl, box(997), box(27));
+  avl = remove_int(avl, 235);
+  avl = remove_int(avl, 425);
+  avl = remove_int(avl, 186);
+  avl = gpr_avl_add(avl, box(887), box(31));
+  avl = gpr_avl_add(avl, box(1005), box(32));
+  avl = gpr_avl_add(avl, box(778), box(33));
+  avl = gpr_avl_add(avl, box(575), box(34));
+  avl = remove_int(avl, 966);
+  avl = remove_int(avl, 1015);
+  avl = gpr_avl_add(avl, box(486), box(37));
+  avl = gpr_avl_add(avl, box(809), box(38));
+  avl = gpr_avl_add(avl, box(907), box(39));
+  avl = gpr_avl_add(avl, box(971), box(40));
+  avl = remove_int(avl, 441);
+  avl = remove_int(avl, 498);
+  avl = gpr_avl_add(avl, box(727), box(43));
+  avl = remove_int(avl, 679);
+  avl = remove_int(avl, 740);
+  avl = remove_int(avl, 532);
+  avl = gpr_avl_add(avl, box(805), box(47));
+  avl = remove_int(avl, 64);
+  avl = gpr_avl_add(avl, box(362), box(49));
+  avl = gpr_avl_add(avl, box(170), box(50));
+  avl = gpr_avl_add(avl, box(389), box(51));
+  avl = gpr_avl_add(avl, box(689), box(52));
+  avl = remove_int(avl, 871);
+  avl = gpr_avl_add(avl, box(447), box(54));
+  avl = remove_int(avl, 718);
+  avl = gpr_avl_add(avl, box(724), box(56));
+  avl = remove_int(avl, 215);
+  avl = gpr_avl_add(avl, box(550), box(58));
+  avl = remove_int(avl, 932);
+  avl = gpr_avl_add(avl, box(47), box(60));
+  avl = remove_int(avl, 46);
+  avl = remove_int(avl, 229);
+  avl = gpr_avl_add(avl, box(68), box(63));
+  avl = gpr_avl_add(avl, box(387), box(64));
+  avl = remove_int(avl, 933);
+  avl = remove_int(avl, 736);
+  avl = remove_int(avl, 719);
+  avl = gpr_avl_add(avl, box(150), box(68));
+  avl = remove_int(avl, 875);
+  avl = remove_int(avl, 298);
+  avl = gpr_avl_add(avl, box(991), box(71));
+  avl = remove_int(avl, 705);
+  avl = gpr_avl_add(avl, box(197), box(73));
+  avl = gpr_avl_add(avl, box(101), box(74));
+  avl = remove_int(avl, 436);
+  avl = gpr_avl_add(avl, box(755), box(76));
+  avl = gpr_avl_add(avl, box(727), box(77));
+  avl = remove_int(avl, 309);
+  avl = remove_int(avl, 253);
+  avl = gpr_avl_add(avl, box(203), box(80));
+  avl = remove_int(avl, 231);
+  avl = gpr_avl_add(avl, box(461), box(82));
+  avl = remove_int(avl, 316);
+  avl = remove_int(avl, 493);
+  avl = gpr_avl_add(avl, box(184), box(85));
+  avl = remove_int(avl, 737);
+  avl = gpr_avl_add(avl, box(790), box(87));
+  avl = gpr_avl_add(avl, box(335), box(88));
+  avl = remove_int(avl, 649);
+  avl = gpr_avl_add(avl, box(69), box(90));
+  avl = remove_int(avl, 585);
+  avl = remove_int(avl, 543);
+  avl = gpr_avl_add(avl, box(784), box(93));
+  avl = gpr_avl_add(avl, box(60), box(94));
+  avl = gpr_avl_add(avl, box(525), box(95));
+  avl = gpr_avl_add(avl, box(177), box(96));
+  avl = gpr_avl_add(avl, box(178), box(97));
+  avl = gpr_avl_add(avl, box(683), box(98));
+  avl = gpr_avl_add(avl, box(226), box(99));
+  avl = gpr_avl_add(avl, box(662), box(100));
+  avl = remove_int(avl, 944);
+  avl = gpr_avl_add(avl, box(562), box(102));
+  avl = gpr_avl_add(avl, box(793), box(103));
+  avl = remove_int(avl, 673);
+  avl = gpr_avl_add(avl, box(310), box(105));
+  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));
+  avl = gpr_avl_add(avl, box(483), box(111));
+  avl = gpr_avl_add(avl, box(84), box(112));
+  avl = remove_int(avl, 109);
+  avl = gpr_avl_add(avl, box(132), box(114));
+  avl = gpr_avl_add(avl, box(920), box(115));
+  avl = remove_int(avl, 746);
+  avl = gpr_avl_add(avl, box(145), box(117));
+  avl = gpr_avl_add(avl, box(526), box(118));
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(332), box(120));
+  avl = gpr_avl_add(avl, box(918), box(121));
+  avl = remove_int(avl, 339);
+  avl = gpr_avl_add(avl, box(809), box(123));
+  avl = gpr_avl_add(avl, box(742), box(124));
+  avl = gpr_avl_add(avl, box(718), box(125));
+  avl = remove_int(avl, 988);
+  avl = remove_int(avl, 531);
+  avl = remove_int(avl, 840);
+  avl = gpr_avl_add(avl, box(816), box(129));
+  avl = gpr_avl_add(avl, box(976), box(130));
+  avl = remove_int(avl, 743);
+  avl = remove_int(avl, 528);
+  avl = remove_int(avl, 982);
+  avl = gpr_avl_add(avl, box(803), box(134));
+  avl = gpr_avl_add(avl, box(205), box(135));
+  avl = gpr_avl_add(avl, box(584), box(136));
+  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));
+  avl = gpr_avl_add(avl, box(333), box(143));
+  avl = remove_int(avl, 439);
+  avl = gpr_avl_add(avl, box(35), box(145));
+  avl = gpr_avl_add(avl, box(837), box(146));
+  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));
+  avl = gpr_avl_add(avl, box(116), box(154));
+  avl = gpr_avl_add(avl, box(446), box(155));
+  avl = remove_int(avl, 91);
+  avl = remove_int(avl, 721);
+  avl = remove_int(avl, 537);
+  avl = gpr_avl_add(avl, box(448), box(159));
+  avl = remove_int(avl, 155);
+  avl = remove_int(avl, 344);
+  avl = remove_int(avl, 237);
+  avl = gpr_avl_add(avl, box(309), box(163));
+  avl = gpr_avl_add(avl, box(434), box(164));
+  avl = gpr_avl_add(avl, box(277), box(165));
+  avl = remove_int(avl, 233);
+  avl = gpr_avl_add(avl, box(275), box(167));
+  avl = gpr_avl_add(avl, box(218), box(168));
+  avl = gpr_avl_add(avl, box(76), box(169));
+  avl = gpr_avl_add(avl, box(898), box(170));
+  avl = remove_int(avl, 771);
+  avl = gpr_avl_add(avl, box(237), box(172));
+  avl = remove_int(avl, 327);
+  avl = gpr_avl_add(avl, box(499), box(174));
+  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));
+  avl = remove_int(avl, 389);
+  avl = gpr_avl_add(avl, box(708), box(183));
+  avl = gpr_avl_add(avl, box(594), box(184));
+  avl = gpr_avl_add(avl, box(942), box(185));
+  avl = gpr_avl_add(avl, box(282), box(186));
+  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));
+  avl = gpr_avl_add(avl, box(161), box(197));
+  avl = remove_int(avl, 484);
+  avl = gpr_avl_add(avl, box(72), box(199));
+  avl = remove_int(avl, 629);
+  avl = gpr_avl_add(avl, box(522), box(201));
+  avl = remove_int(avl, 679);
+  avl = gpr_avl_add(avl, box(407), box(203));
+  avl = remove_int(avl, 693);
+  avl = gpr_avl_add(avl, box(424), box(205));
+  avl = gpr_avl_add(avl, box(651), box(206));
+  avl = gpr_avl_add(avl, box(927), box(207));
+  avl = remove_int(avl, 553);
+  avl = gpr_avl_add(avl, box(128), box(209));
+  avl = gpr_avl_add(avl, box(616), box(210));
+  avl = gpr_avl_add(avl, box(690), box(211));
+  avl = remove_int(avl, 241);
+  avl = remove_int(avl, 179);
+  avl = gpr_avl_add(avl, box(697), box(214));
+  avl = remove_int(avl, 779);
+  avl = gpr_avl_add(avl, box(241), box(216));
+  avl = remove_int(avl, 190);
+  avl = remove_int(avl, 210);
+  avl = gpr_avl_add(avl, box(711), box(219));
+  avl = remove_int(avl, 251);
+  avl = remove_int(avl, 61);
+  avl = gpr_avl_add(avl, box(800), box(222));
+  avl = remove_int(avl, 551);
+  avl = gpr_avl_add(avl, box(61), box(224));
+  avl = gpr_avl_add(avl, box(656), box(225));
+  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));
+  avl = gpr_avl_add(avl, box(125), box(231));
+  avl = remove_int(avl, 107);
+  avl = gpr_avl_add(avl, box(938), box(233));
+  avl = gpr_avl_add(avl, box(914), box(234));
+  avl = gpr_avl_add(avl, box(197), box(235));
+  avl = remove_int(avl, 736);
+  avl = gpr_avl_add(avl, box(20), box(237));
+  avl = remove_int(avl, 224);
+  avl = remove_int(avl, 841);
+  avl = gpr_avl_add(avl, box(226), box(240));
+  avl = remove_int(avl, 963);
+  avl = remove_int(avl, 796);
+  avl = remove_int(avl, 728);
+  avl = gpr_avl_add(avl, box(855), box(244));
+  avl = gpr_avl_add(avl, box(769), box(245));
+  avl = gpr_avl_add(avl, box(631), box(246));
+  avl = remove_int(avl, 648);
+  avl = gpr_avl_add(avl, box(187), box(248));
+  avl = gpr_avl_add(avl, box(31), box(249));
+  avl = remove_int(avl, 163);
+  avl = gpr_avl_add(avl, box(218), box(251));
+  avl = gpr_avl_add(avl, box(488), box(252));
+  avl = gpr_avl_add(avl, box(387), box(253));
+  avl = gpr_avl_add(avl, box(809), box(254));
+  avl = gpr_avl_add(avl, box(997), box(255));
+  avl = remove_int(avl, 678);
+  avl = gpr_avl_add(avl, box(368), box(257));
+  avl = gpr_avl_add(avl, box(220), box(258));
+  avl = gpr_avl_add(avl, box(373), box(259));
+  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));
+  avl = remove_int(avl, 254);
+  avl = remove_int(avl, 456);
+  avl = gpr_avl_add(avl, box(906), box(267));
+  avl = remove_int(avl, 711);
+  avl = gpr_avl_add(avl, box(632), box(269));
+  avl = remove_int(avl, 474);
+  avl = gpr_avl_add(avl, box(508), box(271));
+  avl = gpr_avl_add(avl, box(518), box(272));
+  avl = remove_int(avl, 579);
+  avl = remove_int(avl, 948);
+  avl = gpr_avl_add(avl, box(789), box(275));
+  avl = gpr_avl_add(avl, box(48), box(276));
+  avl = gpr_avl_add(avl, box(256), box(277));
+  avl = gpr_avl_add(avl, box(754), box(278));
+  avl = remove_int(avl, 215);
+  avl = gpr_avl_add(avl, box(679), box(280));
+  avl = gpr_avl_add(avl, box(606), box(281));
+  avl = remove_int(avl, 941);
+  avl = remove_int(avl, 31);
+  avl = gpr_avl_add(avl, box(758), box(284));
+  avl = remove_int(avl, 101);
+  avl = gpr_avl_add(avl, box(244), box(286));
+  avl = gpr_avl_add(avl, box(337), box(287));
+  avl = gpr_avl_add(avl, box(461), box(288));
+  avl = remove_int(avl, 476);
+  avl = gpr_avl_add(avl, box(845), box(290));
+  avl = remove_int(avl, 160);
+  avl = gpr_avl_add(avl, box(690), box(292));
+  avl = remove_int(avl, 931);
+  avl = gpr_avl_add(avl, box(869), box(294));
+  avl = gpr_avl_add(avl, box(1019), box(295));
+  avl = remove_int(avl, 591);
+  avl = remove_int(avl, 635);
+  avl = remove_int(avl, 67);
+  avl = gpr_avl_add(avl, box(113), box(299));
+  avl = remove_int(avl, 305);
+  avl = gpr_avl_add(avl, box(10), box(301));
+  avl = remove_int(avl, 823);
+  avl = remove_int(avl, 288);
+  avl = remove_int(avl, 239);
+  avl = gpr_avl_add(avl, box(646), box(305));
+  avl = gpr_avl_add(avl, box(1006), box(306));
+  avl = gpr_avl_add(avl, box(954), box(307));
+  avl = gpr_avl_add(avl, box(199), box(308));
+  avl = gpr_avl_add(avl, box(69), box(309));
+  avl = gpr_avl_add(avl, box(984), box(310));
+  avl = remove_int(avl, 568);
+  avl = remove_int(avl, 666);
+  avl = remove_int(avl, 37);
+  avl = gpr_avl_add(avl, box(845), box(314));
+  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));
+  avl = gpr_avl_add(avl, box(335), box(323));
+  avl = gpr_avl_add(avl, box(961), box(324));
+  avl = gpr_avl_add(avl, box(73), box(325));
+  avl = remove_int(avl, 469);
+  avl = gpr_avl_add(avl, box(449), box(327));
+  avl = remove_int(avl, 821);
+  avl = gpr_avl_add(avl, box(845), box(329));
+  avl = remove_int(avl, 637);
+  avl = gpr_avl_add(avl, box(769), box(331));
+  avl = gpr_avl_add(avl, box(901), box(332));
+  avl = remove_int(avl, 142);
+  avl = remove_int(avl, 361);
+  avl = remove_int(avl, 876);
+  avl = gpr_avl_add(avl, box(614), box(336));
+  avl = gpr_avl_add(avl, box(729), box(337));
+  avl = remove_int(avl, 120);
+  avl = remove_int(avl, 473);
+  avl = remove_int(avl, 445);
+  avl = gpr_avl_add(avl, box(978), box(341));
+  avl = gpr_avl_add(avl, box(164), box(342));
+  avl = gpr_avl_add(avl, box(1), box(343));
+  avl = remove_int(avl, 890);
+  avl = gpr_avl_add(avl, box(605), box(345));
+  avl = gpr_avl_add(avl, box(178), box(346));
+  avl = gpr_avl_add(avl, box(481), box(347));
+  avl = gpr_avl_add(avl, box(772), box(348));
+  avl = remove_int(avl, 824);
+  avl = remove_int(avl, 167);
+  avl = remove_int(avl, 151);
+  avl = gpr_avl_add(avl, box(698), box(352));
+  avl = gpr_avl_add(avl, box(202), box(353));
+  avl = gpr_avl_add(avl, box(921), box(354));
+  avl = gpr_avl_add(avl, box(875), box(355));
+  avl = remove_int(avl, 197);
+  avl = remove_int(avl, 232);
+  avl = gpr_avl_add(avl, box(209), box(358));
+  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));
+  avl = gpr_avl_add(avl, box(113), box(365));
+  avl = remove_int(avl, 767);
+  avl = gpr_avl_add(avl, box(586), box(367));
+  avl = gpr_avl_add(avl, box(121), box(368));
+  avl = remove_int(avl, 235);
+  avl = remove_int(avl, 439);
+  avl = remove_int(avl, 360);
+  avl = gpr_avl_add(avl, box(916), box(372));
+  avl = remove_int(avl, 999);
+  avl = gpr_avl_add(avl, box(825), box(374));
+  avl = gpr_avl_add(avl, box(177), box(375));
+  avl = remove_int(avl, 204);
+  avl = remove_int(avl, 92);
+  avl = gpr_avl_add(avl, box(794), box(378));
+  avl = gpr_avl_add(avl, box(463), box(379));
+  avl = gpr_avl_add(avl, box(472), box(380));
+  avl = remove_int(avl, 235);
+  avl = gpr_avl_add(avl, box(840), box(382));
+  avl = remove_int(avl, 657);
+  avl = gpr_avl_add(avl, box(586), box(384));
+  avl = gpr_avl_add(avl, box(979), box(385));
+  avl = remove_int(avl, 979);
+  avl = gpr_avl_add(avl, box(639), box(387));
+  avl = remove_int(avl, 907);
+  avl = remove_int(avl, 973);
+  avl = gpr_avl_add(avl, box(913), box(390));
+  avl = gpr_avl_add(avl, box(566), box(391));
+  avl = gpr_avl_add(avl, box(883), box(392));
+  avl = gpr_avl_add(avl, box(552), box(393));
+  avl = gpr_avl_add(avl, box(16), box(394));
+  avl = remove_int(avl, 60);
+  avl = gpr_avl_add(avl, box(567), box(396));
+  avl = gpr_avl_add(avl, box(705), box(397));
+  avl = gpr_avl_add(avl, box(94), box(398));
+  avl = remove_int(avl, 321);
+  avl = gpr_avl_add(avl, box(207), box(400));
+  avl = gpr_avl_add(avl, box(682), box(401));
+  avl = gpr_avl_add(avl, box(592), box(402));
+  avl = gpr_avl_add(avl, box(10), box(403));
+  avl = remove_int(avl, 911);
+  avl = remove_int(avl, 161);
+  avl = gpr_avl_add(avl, box(86), box(406));
+  avl = remove_int(avl, 893);
+  avl = remove_int(avl, 362);
+  avl = gpr_avl_add(avl, box(599), box(409));
+  avl = remove_int(avl, 413);
+  avl = gpr_avl_add(avl, box(867), box(411));
+  avl = remove_int(avl, 955);
+  avl = gpr_avl_add(avl, box(341), box(413));
+  avl = gpr_avl_add(avl, box(887), box(414));
+  avl = remove_int(avl, 706);
+  avl = gpr_avl_add(avl, box(939), box(416));
+  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));
+  avl = remove_int(avl, 848);
+  avl = gpr_avl_add(avl, box(235), box(423));
+  avl = remove_int(avl, 617);
+  avl = gpr_avl_add(avl, box(565), box(425));
+  avl = remove_int(avl, 469);
+  avl = gpr_avl_add(avl, box(988), box(427));
+  avl = remove_int(avl, 957);
+  avl = gpr_avl_add(avl, box(426), box(429));
+  avl = remove_int(avl, 967);
+  avl = gpr_avl_add(avl, box(890), box(431));
+  avl = gpr_avl_add(avl, box(473), box(432));
+  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));
+  avl = remove_int(avl, 882);
+  avl = remove_int(avl, 782);
+  avl = gpr_avl_add(avl, box(408), box(442));
+  avl = gpr_avl_add(avl, box(728), box(443));
+  avl = remove_int(avl, 27);
+  avl = gpr_avl_add(avl, box(137), box(445));
+  avl = gpr_avl_add(avl, box(239), box(446));
+  avl = remove_int(avl, 854);
+  avl = gpr_avl_add(avl, box(104), box(448));
+  avl = gpr_avl_add(avl, box(823), box(449));
+  avl = gpr_avl_add(avl, box(524), box(450));
+  avl = gpr_avl_add(avl, box(995), box(451));
+  avl = remove_int(avl, 422);
+  avl = remove_int(avl, 220);
+  avl = gpr_avl_add(avl, box(856), box(454));
+  avl = remove_int(avl, 332);
+  avl = gpr_avl_add(avl, box(679), box(456));
+  avl = remove_int(avl, 18);
+  avl = gpr_avl_add(avl, box(837), box(458));
+  avl = remove_int(avl, 405);
+  avl = remove_int(avl, 877);
+  avl = remove_int(avl, 835);
+  avl = gpr_avl_add(avl, box(547), box(462));
+  avl = remove_int(avl, 805);
+  avl = remove_int(avl, 862);
+  avl = gpr_avl_add(avl, box(75), box(465));
+  avl = remove_int(avl, 41);
+  avl = gpr_avl_add(avl, box(310), box(467));
+  avl = remove_int(avl, 855);
+  avl = gpr_avl_add(avl, box(20), box(469));
+  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));
+  avl = gpr_avl_add(avl, box(96), box(475));
+  avl = remove_int(avl, 854);
+  avl = gpr_avl_add(avl, box(65), box(477));
+  avl = gpr_avl_add(avl, box(573), box(478));
+  avl = gpr_avl_add(avl, box(4), box(479));
+  avl = gpr_avl_add(avl, box(451), box(480));
+  avl = gpr_avl_add(avl, box(774), box(481));
+  avl = gpr_avl_add(avl, box(126), box(482));
+  avl = remove_int(avl, 956);
+  avl = remove_int(avl, 591);
+  avl = remove_int(avl, 644);
+  avl = gpr_avl_add(avl, box(304), box(486));
+  avl = remove_int(avl, 620);
+  avl = remove_int(avl, 394);
+  avl = gpr_avl_add(avl, box(1002), box(489));
+  avl = gpr_avl_add(avl, box(837), box(490));
+  avl = remove_int(avl, 485);
+  avl = gpr_avl_add(avl, box(1005), box(492));
+  avl = remove_int(avl, 21);
+  avl = gpr_avl_add(avl, box(396), box(494));
+  avl = remove_int(avl, 966);
+  avl = gpr_avl_add(avl, box(105), box(496));
+  avl = gpr_avl_add(avl, box(316), box(497));
+  avl = remove_int(avl, 776);
+  avl = gpr_avl_add(avl, box(188), box(499));
+  avl = remove_int(avl, 200);
+  avl = gpr_avl_add(avl, box(98), box(501));
+  avl = gpr_avl_add(avl, box(831), box(502));
+  avl = gpr_avl_add(avl, box(227), box(503));
+  avl = gpr_avl_add(avl, box(220), box(504));
+  avl = remove_int(avl, 715);
+  avl = remove_int(avl, 279);
+  avl = gpr_avl_add(avl, box(701), box(507));
+  avl = gpr_avl_add(avl, box(726), box(508));
+  avl = gpr_avl_add(avl, box(815), box(509));
+  avl = gpr_avl_add(avl, box(749), box(510));
+  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));
+  avl = remove_int(avl, 59);
+  avl = gpr_avl_add(avl, box(168), box(517));
+  avl = remove_int(avl, 337);
+  avl = gpr_avl_add(avl, box(69), box(519));
+  avl = remove_int(avl, 600);
+  avl = gpr_avl_add(avl, box(591), box(521));
+  avl = gpr_avl_add(avl, box(960), box(522));
+  avl = gpr_avl_add(avl, box(116), box(523));
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(760), box(525));
+  avl = gpr_avl_add(avl, box(664), box(526));
+  avl = gpr_avl_add(avl, box(547), box(527));
+  avl = remove_int(avl, 922);
+  avl = gpr_avl_add(avl, box(290), box(529));
+  avl = gpr_avl_add(avl, box(859), box(530));
+  avl = gpr_avl_add(avl, box(49), box(531));
+  avl = remove_int(avl, 455);
+  avl = remove_int(avl, 786);
+  avl = gpr_avl_add(avl, box(613), box(534));
+  avl = gpr_avl_add(avl, box(326), box(535));
+  avl = remove_int(avl, 615);
+  avl = gpr_avl_add(avl, box(45), box(537));
+  avl = gpr_avl_add(avl, box(162), box(538));
+  avl = gpr_avl_add(avl, box(189), box(539));
+  avl = remove_int(avl, 68);
+  avl = remove_int(avl, 846);
+  avl = gpr_avl_add(avl, box(608), box(542));
+  avl = remove_int(avl, 821);
+  avl = gpr_avl_add(avl, box(978), box(544));
+  avl = gpr_avl_add(avl, box(892), box(545));
+  avl = remove_int(avl, 924);
+  avl = gpr_avl_add(avl, box(708), box(547));
+  avl = remove_int(avl, 135);
+  avl = remove_int(avl, 124);
+  avl = gpr_avl_add(avl, box(301), box(550));
+  avl = gpr_avl_add(avl, box(939), box(551));
+  avl = gpr_avl_add(avl, box(344), box(552));
+  avl = remove_int(avl, 443);
+  avl = remove_int(avl, 122);
+  avl = gpr_avl_add(avl, box(636), box(555));
+  avl = remove_int(avl, 558);
+  avl = gpr_avl_add(avl, box(923), box(557));
+  avl = remove_int(avl, 827);
+  avl = gpr_avl_add(avl, box(649), box(559));
+  avl = gpr_avl_add(avl, box(808), box(560));
+  avl = remove_int(avl, 570);
+  avl = remove_int(avl, 434);
+  avl = gpr_avl_add(avl, box(40), box(563));
+  avl = gpr_avl_add(avl, box(725), box(564));
+  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));
+  avl = gpr_avl_add(avl, box(512), box(572));
+  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));
+  avl = remove_int(avl, 770);
+  avl = remove_int(avl, 776);
+  avl = gpr_avl_add(avl, box(602), box(581));
+  avl = remove_int(avl, 251);
+  avl = gpr_avl_add(avl, box(303), box(583));
+  avl = remove_int(avl, 837);
+  avl = gpr_avl_add(avl, box(714), box(585));
+  avl = remove_int(avl, 800);
+  avl = gpr_avl_add(avl, box(266), box(587));
+  avl = gpr_avl_add(avl, box(555), box(588));
+  avl = remove_int(avl, 604);
+  avl = remove_int(avl, 163);
+  avl = remove_int(avl, 497);
+  avl = gpr_avl_add(avl, box(296), box(592));
+  avl = remove_int(avl, 129);
+  avl = gpr_avl_add(avl, box(656), box(594));
+  avl = remove_int(avl, 769);
+  avl = remove_int(avl, 941);
+  avl = gpr_avl_add(avl, box(775), box(597));
+  avl = gpr_avl_add(avl, box(846), box(598));
+  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));
+  avl = gpr_avl_add(avl, box(575), box(604));
+  avl = gpr_avl_add(avl, box(620), box(605));
+  avl = remove_int(avl, 100);
+  avl = remove_int(avl, 667);
+  avl = gpr_avl_add(avl, box(138), box(608));
+  avl = gpr_avl_add(avl, box(566), box(609));
+  avl = gpr_avl_add(avl, box(673), box(610));
+  avl = gpr_avl_add(avl, box(178), box(611));
+  avl = remove_int(avl, 659);
+  avl = gpr_avl_add(avl, box(759), box(613));
+  avl = gpr_avl_add(avl, box(1008), box(614));
+  avl = remove_int(avl, 116);
+  avl = gpr_avl_add(avl, box(608), box(616));
+  avl = gpr_avl_add(avl, box(339), box(617));
+  avl = gpr_avl_add(avl, box(197), box(618));
+  avl = remove_int(avl, 25);
+  avl = remove_int(avl, 628);
+  avl = gpr_avl_add(avl, box(487), box(621));
+  avl = remove_int(avl, 739);
+  avl = remove_int(avl, 100);
+  avl = remove_int(avl, 928);
+  avl = gpr_avl_add(avl, box(647), box(625));
+  avl = remove_int(avl, 978);
+  avl = remove_int(avl, 143);
+  avl = remove_int(avl, 755);
+  avl = gpr_avl_add(avl, box(71), box(629));
+  avl = remove_int(avl, 205);
+  avl = gpr_avl_add(avl, box(501), box(631));
+  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));
+  avl = remove_int(avl, 264);
+  avl = gpr_avl_add(avl, box(69), box(639));
+  avl = remove_int(avl, 73);
+  avl = gpr_avl_add(avl, box(745), box(641));
+  avl = remove_int(avl, 518);
+  avl = remove_int(avl, 641);
+  avl = remove_int(avl, 768);
+  avl = gpr_avl_add(avl, box(988), box(645));
+  avl = gpr_avl_add(avl, box(899), box(646));
+  avl = remove_int(avl, 763);
+  avl = remove_int(avl, 281);
+  avl = remove_int(avl, 496);
+  avl = gpr_avl_add(avl, box(445), box(650));
+  avl = remove_int(avl, 905);
+  avl = gpr_avl_add(avl, box(275), box(652));
+  avl = gpr_avl_add(avl, box(137), box(653));
+  avl = remove_int(avl, 642);
+  avl = gpr_avl_add(avl, box(708), box(655));
+  avl = remove_int(avl, 922);
+  avl = gpr_avl_add(avl, box(743), box(657));
+  avl = remove_int(avl, 295);
+  avl = remove_int(avl, 665);
+  avl = remove_int(avl, 48);
+  avl = gpr_avl_add(avl, box(1012), box(661));
+  avl = remove_int(avl, 71);
+  avl = remove_int(avl, 523);
+  avl = gpr_avl_add(avl, box(319), box(664));
+  avl = remove_int(avl, 632);
+  avl = gpr_avl_add(avl, box(137), box(666));
+  avl = gpr_avl_add(avl, box(686), box(667));
+  avl = gpr_avl_add(avl, box(724), box(668));
+  avl = gpr_avl_add(avl, box(952), box(669));
+  avl = gpr_avl_add(avl, box(5), box(670));
+  avl = remove_int(avl, 35);
+  avl = gpr_avl_add(avl, box(43), box(672));
+  avl = gpr_avl_add(avl, box(320), box(673));
+  avl = gpr_avl_add(avl, box(115), box(674));
+  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));
+  avl = gpr_avl_add(avl, box(605), box(680));
+  avl = gpr_avl_add(avl, box(152), box(681));
+  avl = gpr_avl_add(avl, box(113), box(682));
+  avl = remove_int(avl, 131);
+  avl = remove_int(avl, 637);
+  avl = gpr_avl_add(avl, box(156), box(685));
+  avl = remove_int(avl, 696);
+  avl = gpr_avl_add(avl, box(546), box(687));
+  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));
+  avl = remove_int(avl, 924);
+  avl = gpr_avl_add(avl, box(825), box(703));
+  avl = remove_int(avl, 888);
+  avl = remove_int(avl, 931);
+  avl = gpr_avl_add(avl, box(285), box(706));
+  avl = remove_int(avl, 62);
+  avl = remove_int(avl, 444);
+  avl = remove_int(avl, 946);
+  avl = gpr_avl_add(avl, box(122), box(710));
+  avl = gpr_avl_add(avl, box(846), box(711));
+  avl = remove_int(avl, 628);
+  avl = gpr_avl_add(avl, box(511), box(713));
+  avl = gpr_avl_add(avl, box(398), box(714));
+  avl = remove_int(avl, 730);
+  avl = gpr_avl_add(avl, box(797), box(716));
+  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));
+  avl = gpr_avl_add(avl, box(1015), box(726));
+  avl = remove_int(avl, 813);
+  avl = gpr_avl_add(avl, box(213), box(728));
+  avl = remove_int(avl, 468);
+  avl = remove_int(avl, 365);
+  avl = remove_int(avl, 399);
+  avl = gpr_avl_add(avl, box(380), box(732));
+  avl = remove_int(avl, 835);
+  avl = remove_int(avl, 970);
+  avl = gpr_avl_add(avl, box(700), box(735));
+  avl = gpr_avl_add(avl, box(807), box(736));
+  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));
+  avl = gpr_avl_add(avl, box(332), box(744));
+  avl = remove_int(avl, 686);
+  avl = remove_int(avl, 206);
+  avl = remove_int(avl, 835);
+  avl = gpr_avl_add(avl, box(334), box(748));
+  avl = remove_int(avl, 171);
+  avl = gpr_avl_add(avl, box(1002), box(750));
+  avl = gpr_avl_add(avl, box(779), box(751));
+  avl = gpr_avl_add(avl, box(307), box(752));
+  avl = gpr_avl_add(avl, box(127), box(753));
+  avl = gpr_avl_add(avl, box(251), box(754));
+  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));
+  avl = remove_int(avl, 43);
+  avl = gpr_avl_add(avl, box(871), box(762));
+  avl = gpr_avl_add(avl, box(580), box(763));
+  avl = remove_int(avl, 501);
+  avl = remove_int(avl, 462);
+  avl = remove_int(avl, 599);
+  avl = gpr_avl_add(avl, box(240), box(767));
+  avl = gpr_avl_add(avl, box(285), box(768));
+  avl = gpr_avl_add(avl, box(472), box(769));
+  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));
+  avl = gpr_avl_add(avl, box(552), box(778));
+  avl = remove_int(avl, 19);
+  avl = remove_int(avl, 803);
+  avl = gpr_avl_add(avl, box(508), box(781));
+  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));
+  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));
+  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));
+  avl = remove_int(avl, 38);
+  avl = remove_int(avl, 595);
+  avl = gpr_avl_add(avl, box(213), box(799));
+  avl = remove_int(avl, 7);
+  avl = remove_int(avl, 620);
+  avl = gpr_avl_add(avl, box(946), box(802));
+  avl = remove_int(avl, 145);
+  avl = gpr_avl_add(avl, box(628), box(804));
+  avl = remove_int(avl, 972);
+  avl = gpr_avl_add(avl, box(728), box(806));
+  avl = remove_int(avl, 91);
+  avl = gpr_avl_add(avl, box(136), box(808));
+  avl = gpr_avl_add(avl, box(841), box(809));
+  avl = gpr_avl_add(avl, box(265), box(810));
+  avl = gpr_avl_add(avl, box(701), box(811));
+  avl = gpr_avl_add(avl, box(27), box(812));
+  avl = remove_int(avl, 72);
+  avl = remove_int(avl, 14);
+  avl = gpr_avl_add(avl, box(286), box(815));
+  avl = remove_int(avl, 996);
+  avl = remove_int(avl, 998);
+  avl = gpr_avl_add(avl, box(466), box(818));
+  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));
+  avl = remove_int(avl, 812);
+  avl = gpr_avl_add(avl, box(577), box(829));
+  avl = remove_int(avl, 624);
+  avl = remove_int(avl, 847);
+  avl = remove_int(avl, 745);
+  avl = gpr_avl_add(avl, box(491), box(833));
+  avl = gpr_avl_add(avl, box(941), box(834));
+  avl = remove_int(avl, 258);
+  avl = gpr_avl_add(avl, box(410), box(836));
+  avl = gpr_avl_add(avl, box(80), box(837));
+  avl = gpr_avl_add(avl, box(196), box(838));
+  avl = gpr_avl_add(avl, box(5), box(839));
+  avl = remove_int(avl, 782);
+  avl = gpr_avl_add(avl, box(827), box(841));
+  avl = remove_int(avl, 472);
+  avl = remove_int(avl, 664);
+  avl = gpr_avl_add(avl, box(409), box(844));
+  avl = gpr_avl_add(avl, box(62), box(845));
+  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));
+  avl = remove_int(avl, 587);
+  avl = remove_int(avl, 350);
+  avl = gpr_avl_add(avl, box(980), box(855));
+  avl = gpr_avl_add(avl, box(992), box(856));
+  avl = gpr_avl_add(avl, box(818), box(857));
+  avl = remove_int(avl, 853);
+  avl = remove_int(avl, 701);
+  avl = gpr_avl_add(avl, box(675), box(860));
+  avl = remove_int(avl, 248);
+  avl = remove_int(avl, 649);
+  avl = gpr_avl_add(avl, box(508), box(863));
+  avl = remove_int(avl, 927);
+  avl = gpr_avl_add(avl, box(957), box(865));
+  avl = gpr_avl_add(avl, box(698), box(866));
+  avl = gpr_avl_add(avl, box(388), box(867));
+  avl = gpr_avl_add(avl, box(532), box(868));
+  avl = gpr_avl_add(avl, box(681), box(869));
+  avl = remove_int(avl, 544);
+  avl = remove_int(avl, 991);
+  avl = remove_int(avl, 397);
+  avl = gpr_avl_add(avl, box(954), box(873));
+  avl = gpr_avl_add(avl, box(219), box(874));
+  avl = gpr_avl_add(avl, box(465), box(875));
+  avl = remove_int(avl, 371);
+  avl = gpr_avl_add(avl, box(601), box(877));
+  avl = gpr_avl_add(avl, box(543), box(878));
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(560), box(880));
+  avl = remove_int(avl, 898);
+  avl = gpr_avl_add(avl, box(455), box(882));
+  avl = remove_int(avl, 313);
+  avl = gpr_avl_add(avl, box(215), box(884));
+  avl = remove_int(avl, 846);
+  avl = gpr_avl_add(avl, box(608), box(886));
+  avl = remove_int(avl, 248);
+  avl = gpr_avl_add(avl, box(575), box(888));
+  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));
+  avl = gpr_avl_add(avl, box(329), box(894));
+  avl = gpr_avl_add(avl, box(326), box(895));
+  avl = remove_int(avl, 746);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(464), box(898));
+  avl = gpr_avl_add(avl, box(141), box(899));
+  avl = remove_int(avl, 383);
+  avl = gpr_avl_add(avl, box(414), box(901));
+  avl = gpr_avl_add(avl, box(777), box(902));
+  avl = remove_int(avl, 972);
+  avl = remove_int(avl, 841);
+  avl = remove_int(avl, 100);
+  avl = gpr_avl_add(avl, box(828), box(906));
+  avl = remove_int(avl, 785);
+  avl = gpr_avl_add(avl, box(1008), box(908));
+  avl = gpr_avl_add(avl, box(46), box(909));
+  avl = remove_int(avl, 399);
+  avl = gpr_avl_add(avl, box(178), box(911));
+  avl = gpr_avl_add(avl, box(573), box(912));
+  avl = remove_int(avl, 299);
+  avl = gpr_avl_add(avl, box(690), box(914));
+  avl = gpr_avl_add(avl, box(692), box(915));
+  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));
+  avl = remove_int(avl, 328);
+  avl = gpr_avl_add(avl, box(89), box(923));
+  avl = remove_int(avl, 867);
+  avl = remove_int(avl, 626);
+  avl = remove_int(avl, 507);
+  avl = gpr_avl_add(avl, box(365), box(927));
+  avl = gpr_avl_add(avl, box(58), box(928));
+  avl = gpr_avl_add(avl, box(70), box(929));
+  avl = remove_int(avl, 81);
+  avl = remove_int(avl, 797);
+  avl = gpr_avl_add(avl, box(846), box(932));
+  avl = remove_int(avl, 642);
+  avl = gpr_avl_add(avl, box(777), box(934));
+  avl = remove_int(avl, 107);
+  avl = gpr_avl_add(avl, box(691), box(936));
+  avl = gpr_avl_add(avl, box(820), box(937));
+  avl = gpr_avl_add(avl, box(202), box(938));
+  avl = gpr_avl_add(avl, box(308), box(939));
+  avl = gpr_avl_add(avl, box(20), box(940));
+  avl = remove_int(avl, 289);
+  avl = gpr_avl_add(avl, box(714), box(942));
+  avl = gpr_avl_add(avl, box(584), box(943));
+  avl = remove_int(avl, 294);
+  avl = gpr_avl_add(avl, box(496), box(945));
+  avl = gpr_avl_add(avl, box(394), box(946));
+  avl = gpr_avl_add(avl, box(860), box(947));
+  avl = gpr_avl_add(avl, box(58), box(948));
+  avl = remove_int(avl, 784);
+  avl = remove_int(avl, 584);
+  avl = remove_int(avl, 708);
+  avl = gpr_avl_add(avl, box(142), box(952));
+  avl = gpr_avl_add(avl, box(247), box(953));
+  avl = gpr_avl_add(avl, box(389), box(954));
+  avl = remove_int(avl, 390);
+  avl = gpr_avl_add(avl, box(465), box(956));
+  avl = gpr_avl_add(avl, box(936), box(957));
+  avl = gpr_avl_add(avl, box(309), box(958));
+  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));
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(728), box(968));
+  avl = remove_int(avl, 852);
+  avl = gpr_avl_add(avl, box(884), box(970));
+  avl = gpr_avl_add(avl, box(502), box(971));
+  avl = remove_int(avl, 898);
+  avl = remove_int(avl, 481);
+  avl = gpr_avl_add(avl, box(911), box(974));
+  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));
+  avl = remove_int(avl, 25);
+  avl = remove_int(avl, 697);
+  avl = gpr_avl_add(avl, box(645), box(986));
+  avl = gpr_avl_add(avl, box(211), box(987));
+  avl = gpr_avl_add(avl, box(589), box(988));
+  avl = remove_int(avl, 702);
+  avl = gpr_avl_add(avl, box(53), box(990));
+  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));
+  avl = gpr_avl_add(avl, box(834), box(998));
+  avl = gpr_avl_add(avl, box(514), box(999));
+  avl = gpr_avl_add(avl, box(75), box(1000));
+  avl = remove_int(avl, 745);
+  avl = gpr_avl_add(avl, box(362), box(1002));
+  avl = remove_int(avl, 215);
+  avl = gpr_avl_add(avl, box(624), box(1004));
+  avl = remove_int(avl, 404);
+  avl = remove_int(avl, 359);
+  avl = remove_int(avl, 491);
+  avl = gpr_avl_add(avl, box(903), box(1008));
+  avl = gpr_avl_add(avl, box(240), box(1009));
+  avl = remove_int(avl, 95);
+  avl = gpr_avl_add(avl, box(119), box(1011));
+  avl = gpr_avl_add(avl, box(857), box(1012));
+  avl = remove_int(avl, 39);
+  avl = remove_int(avl, 866);
+  avl = gpr_avl_add(avl, box(503), box(1015));
+  avl = gpr_avl_add(avl, box(740), box(1016));
+  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));
+  avl = remove_int(avl, 638);
+  avl = gpr_avl_add(avl, box(299), box(1025));
+  avl = gpr_avl_add(avl, box(584), box(1026));
+  avl = remove_int(avl, 863);
+  avl = gpr_avl_add(avl, box(612), box(1028));
+  avl = gpr_avl_add(avl, box(62), box(1029));
+  avl = gpr_avl_add(avl, box(432), box(1030));
+  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));
+  avl = gpr_avl_add(avl, box(644), box(1036));
+  avl = remove_int(avl, 638);
+  avl = gpr_avl_add(avl, box(13), box(1038));
+  avl = remove_int(avl, 66);
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(362), box(1041));
+  avl = gpr_avl_add(avl, box(783), box(1042));
+  avl = remove_int(avl, 60);
+  avl = gpr_avl_add(avl, box(80), box(1044));
+  avl = gpr_avl_add(avl, box(825), box(1045));
+  avl = gpr_avl_add(avl, box(688), box(1046));
+  avl = gpr_avl_add(avl, box(662), box(1047));
+  avl = remove_int(avl, 156);
+  avl = remove_int(avl, 376);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(526), box(1051));
+  avl = gpr_avl_add(avl, box(168), box(1052));
+  avl = remove_int(avl, 646);
+  avl = remove_int(avl, 380);
+  avl = remove_int(avl, 833);
+  avl = gpr_avl_add(avl, box(53), box(1056));
+  avl = remove_int(avl, 105);
+  avl = gpr_avl_add(avl, box(373), box(1058));
+  avl = gpr_avl_add(avl, box(184), box(1059));
+  avl = remove_int(avl, 288);
+  avl = gpr_avl_add(avl, box(966), box(1061));
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(406), box(1063));
+  avl = remove_int(avl, 470);
+  avl = gpr_avl_add(avl, box(283), box(1065));
+  avl = gpr_avl_add(avl, box(838), box(1066));
+  avl = gpr_avl_add(avl, box(288), box(1067));
+  avl = gpr_avl_add(avl, box(950), box(1068));
+  avl = gpr_avl_add(avl, box(163), box(1069));
+  avl = remove_int(avl, 623);
+  avl = remove_int(avl, 769);
+  avl = gpr_avl_add(avl, box(144), box(1072));
+  avl = gpr_avl_add(avl, box(489), box(1073));
+  avl = remove_int(avl, 15);
+  avl = gpr_avl_add(avl, box(971), box(1075));
+  avl = remove_int(avl, 660);
+  avl = gpr_avl_add(avl, box(255), box(1077));
+  avl = remove_int(avl, 494);
+  avl = gpr_avl_add(avl, box(109), box(1079));
+  avl = gpr_avl_add(avl, box(420), box(1080));
+  avl = gpr_avl_add(avl, box(509), box(1081));
+  avl = remove_int(avl, 178);
+  avl = gpr_avl_add(avl, box(216), box(1083));
+  avl = gpr_avl_add(avl, box(707), box(1084));
+  avl = gpr_avl_add(avl, box(411), box(1085));
+  avl = gpr_avl_add(avl, box(352), box(1086));
+  avl = remove_int(avl, 983);
+  avl = gpr_avl_add(avl, box(6), box(1088));
+  avl = gpr_avl_add(avl, box(1014), box(1089));
+  avl = remove_int(avl, 98);
+  avl = remove_int(avl, 325);
+  avl = gpr_avl_add(avl, box(851), box(1092));
+  avl = remove_int(avl, 553);
+  avl = gpr_avl_add(avl, box(218), box(1094));
+  avl = gpr_avl_add(avl, box(261), box(1095));
+  avl = remove_int(avl, 31);
+  avl = gpr_avl_add(avl, box(872), box(1097));
+  avl = remove_int(avl, 543);
+  avl = remove_int(avl, 314);
+  avl = remove_int(avl, 443);
+  avl = gpr_avl_add(avl, box(533), box(1101));
+  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));
+  avl = remove_int(avl, 622);
+  avl = gpr_avl_add(avl, box(352), box(1112));
+  avl = remove_int(avl, 182);
+  avl = gpr_avl_add(avl, box(534), box(1114));
+  avl = gpr_avl_add(avl, box(97), box(1115));
+  avl = gpr_avl_add(avl, box(198), box(1116));
+  avl = remove_int(avl, 750);
+  avl = gpr_avl_add(avl, box(98), box(1118));
+  avl = remove_int(avl, 943);
+  avl = gpr_avl_add(avl, box(254), box(1120));
+  avl = gpr_avl_add(avl, box(30), box(1121));
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 475);
+  avl = remove_int(avl, 82);
+  avl = gpr_avl_add(avl, box(789), box(1125));
+  avl = gpr_avl_add(avl, box(402), box(1126));
+  avl = remove_int(avl, 1019);
+  avl = gpr_avl_add(avl, box(858), box(1128));
+  avl = gpr_avl_add(avl, box(625), box(1129));
+  avl = remove_int(avl, 675);
+  avl = remove_int(avl, 323);
+  avl = gpr_avl_add(avl, box(329), box(1132));
+  avl = remove_int(avl, 929);
+  avl = remove_int(avl, 44);
+  avl = gpr_avl_add(avl, box(443), box(1135));
+  avl = gpr_avl_add(avl, box(653), box(1136));
+  avl = gpr_avl_add(avl, box(750), box(1137));
+  avl = gpr_avl_add(avl, box(252), box(1138));
+  avl = gpr_avl_add(avl, box(449), box(1139));
+  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));
+  avl = remove_int(avl, 806);
+  avl = gpr_avl_add(avl, box(455), box(1146));
+  avl = remove_int(avl, 31);
+  avl = gpr_avl_add(avl, box(154), box(1148));
+  avl = gpr_avl_add(avl, box(189), box(1149));
+  avl = remove_int(avl, 786);
+  avl = gpr_avl_add(avl, box(496), box(1151));
+  avl = gpr_avl_add(avl, box(81), box(1152));
+  avl = gpr_avl_add(avl, box(59), box(1153));
+  avl = remove_int(avl, 424);
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(723), box(1156));
+  avl = gpr_avl_add(avl, box(822), box(1157));
+  avl = gpr_avl_add(avl, box(354), box(1158));
+  avl = remove_int(avl, 738);
+  avl = gpr_avl_add(avl, box(686), box(1160));
+  avl = gpr_avl_add(avl, box(43), box(1161));
+  avl = gpr_avl_add(avl, box(625), box(1162));
+  avl = gpr_avl_add(avl, box(902), box(1163));
+  avl = gpr_avl_add(avl, box(12), box(1164));
+  avl = gpr_avl_add(avl, box(977), box(1165));
+  avl = gpr_avl_add(avl, box(699), box(1166));
+  avl = gpr_avl_add(avl, box(189), box(1167));
+  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));
+  avl = remove_int(avl, 758);
+  avl = remove_int(avl, 222);
+  avl = gpr_avl_add(avl, box(975), box(1175));
+  avl = remove_int(avl, 993);
+  avl = gpr_avl_add(avl, box(2), box(1177));
+  avl = gpr_avl_add(avl, box(70), box(1178));
+  avl = remove_int(avl, 350);
+  avl = remove_int(avl, 972);
+  avl = remove_int(avl, 880);
+  avl = gpr_avl_add(avl, box(753), box(1182));
+  avl = remove_int(avl, 404);
+  avl = gpr_avl_add(avl, box(294), box(1184));
+  avl = remove_int(avl, 474);
+  avl = gpr_avl_add(avl, box(228), box(1186));
+  avl = gpr_avl_add(avl, box(484), box(1187));
+  avl = remove_int(avl, 238);
+  avl = remove_int(avl, 53);
+  avl = remove_int(avl, 691);
+  avl = gpr_avl_add(avl, box(345), box(1191));
+  avl = remove_int(avl, 0);
+  avl = gpr_avl_add(avl, box(230), box(1193));
+  avl = remove_int(avl, 227);
+  avl = remove_int(avl, 152);
+  avl = gpr_avl_add(avl, box(884), box(1196));
+  avl = remove_int(avl, 823);
+  avl = remove_int(avl, 53);
+  avl = gpr_avl_add(avl, box(1015), box(1199));
+  avl = gpr_avl_add(avl, box(697), box(1200));
+  avl = gpr_avl_add(avl, box(376), box(1201));
+  avl = remove_int(avl, 411);
+  avl = gpr_avl_add(avl, box(888), box(1203));
+  avl = remove_int(avl, 55);
+  avl = gpr_avl_add(avl, box(85), box(1205));
+  avl = remove_int(avl, 947);
+  avl = remove_int(avl, 382);
+  avl = remove_int(avl, 777);
+  avl = gpr_avl_add(avl, box(1017), box(1209));
+  avl = gpr_avl_add(avl, box(169), box(1210));
+  avl = gpr_avl_add(avl, box(156), box(1211));
+  avl = remove_int(avl, 153);
+  avl = remove_int(avl, 642);
+  avl = remove_int(avl, 158);
+  avl = gpr_avl_add(avl, box(554), box(1215));
+  avl = gpr_avl_add(avl, box(76), box(1216));
+  avl = gpr_avl_add(avl, box(756), box(1217));
+  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));
+  avl = gpr_avl_add(avl, box(712), box(1227));
+  avl = gpr_avl_add(avl, box(474), box(1228));
+  avl = gpr_avl_add(avl, box(882), box(1229));
+  avl = gpr_avl_add(avl, box(965), box(1230));
+  avl = remove_int(avl, 464);
+  avl = gpr_avl_add(avl, box(319), box(1232));
+  avl = gpr_avl_add(avl, box(504), box(1233));
+  avl = remove_int(avl, 818);
+  avl = gpr_avl_add(avl, box(884), box(1235));
+  avl = gpr_avl_add(avl, box(813), box(1236));
+  avl = gpr_avl_add(avl, box(795), box(1237));
+  avl = remove_int(avl, 306);
+  avl = gpr_avl_add(avl, box(799), box(1239));
+  avl = remove_int(avl, 534);
+  avl = gpr_avl_add(avl, box(480), box(1241));
+  avl = gpr_avl_add(avl, box(656), box(1242));
+  avl = gpr_avl_add(avl, box(709), box(1243));
+  avl = gpr_avl_add(avl, box(500), box(1244));
+  avl = remove_int(avl, 740);
+  avl = gpr_avl_add(avl, box(980), box(1246));
+  avl = gpr_avl_add(avl, box(458), box(1247));
+  avl = remove_int(avl, 377);
+  avl = remove_int(avl, 338);
+  avl = gpr_avl_add(avl, box(554), box(1250));
+  avl = gpr_avl_add(avl, box(504), box(1251));
+  avl = gpr_avl_add(avl, box(603), box(1252));
+  avl = gpr_avl_add(avl, box(761), box(1253));
+  avl = remove_int(avl, 431);
+  avl = gpr_avl_add(avl, box(707), box(1255));
+  avl = gpr_avl_add(avl, box(673), box(1256));
+  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));
+  avl = remove_int(avl, 858);
+  avl = remove_int(avl, 997);
+  avl = gpr_avl_add(avl, box(519), box(1267));
+  avl = remove_int(avl, 614);
+  avl = remove_int(avl, 462);
+  avl = remove_int(avl, 792);
+  avl = gpr_avl_add(avl, box(987), box(1271));
+  avl = gpr_avl_add(avl, box(309), box(1272));
+  avl = remove_int(avl, 747);
+  avl = gpr_avl_add(avl, box(621), box(1274));
+  avl = gpr_avl_add(avl, box(450), box(1275));
+  avl = remove_int(avl, 265);
+  avl = remove_int(avl, 8);
+  avl = remove_int(avl, 383);
+  avl = gpr_avl_add(avl, box(238), box(1279));
+  avl = remove_int(avl, 241);
+  avl = gpr_avl_add(avl, box(180), box(1281));
+  avl = gpr_avl_add(avl, box(411), box(1282));
+  avl = gpr_avl_add(avl, box(791), box(1283));
+  avl = gpr_avl_add(avl, box(955), box(1284));
+  avl = remove_int(avl, 24);
+  avl = remove_int(avl, 375);
+  avl = gpr_avl_add(avl, box(140), box(1287));
+  avl = remove_int(avl, 949);
+  avl = gpr_avl_add(avl, box(301), box(1289));
+  avl = gpr_avl_add(avl, box(0), box(1290));
+  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));
+  avl = gpr_avl_add(avl, box(127), box(1296));
+  avl = gpr_avl_add(avl, box(279), box(1297));
+  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));
+  avl = gpr_avl_add(avl, box(304), box(1304));
+  avl = gpr_avl_add(avl, box(1), box(1305));
+  avl = gpr_avl_add(avl, box(339), box(1306));
+  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));
+  avl = remove_int(avl, 85);
+  avl = gpr_avl_add(avl, box(964), box(1314));
+  avl = gpr_avl_add(avl, box(559), box(1315));
+  avl = remove_int(avl, 167);
+  avl = gpr_avl_add(avl, box(866), box(1317));
+  avl = remove_int(avl, 275);
+  avl = gpr_avl_add(avl, box(173), box(1319));
+  avl = gpr_avl_add(avl, box(765), box(1320));
+  avl = remove_int(avl, 883);
+  avl = gpr_avl_add(avl, box(547), box(1322));
+  avl = gpr_avl_add(avl, box(847), box(1323));
+  avl = remove_int(avl, 817);
+  avl = remove_int(avl, 850);
+  avl = remove_int(avl, 718);
+  avl = gpr_avl_add(avl, box(806), box(1327));
+  avl = gpr_avl_add(avl, box(360), box(1328));
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(493), box(1330));
+  avl = remove_int(avl, 516);
+  avl = gpr_avl_add(avl, box(361), box(1332));
+  avl = remove_int(avl, 355);
+  avl = gpr_avl_add(avl, box(512), box(1334));
+  avl = gpr_avl_add(avl, box(191), box(1335));
+  avl = remove_int(avl, 703);
+  avl = gpr_avl_add(avl, box(333), box(1337));
+  avl = remove_int(avl, 481);
+  avl = gpr_avl_add(avl, box(501), box(1339));
+  avl = remove_int(avl, 532);
+  avl = remove_int(avl, 510);
+  avl = gpr_avl_add(avl, box(793), box(1342));
+  avl = gpr_avl_add(avl, box(234), box(1343));
+  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));
+  avl = gpr_avl_add(avl, box(702), box(1349));
+  avl = gpr_avl_add(avl, box(149), box(1350));
+  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));
+  avl = gpr_avl_add(avl, box(455), box(1358));
+  avl = remove_int(avl, 782);
+  avl = remove_int(avl, 682);
+  avl = gpr_avl_add(avl, box(243), box(1361));
+  avl = gpr_avl_add(avl, box(109), box(1362));
+  avl = gpr_avl_add(avl, box(452), box(1363));
+  avl = remove_int(avl, 151);
+  avl = gpr_avl_add(avl, box(159), box(1365));
+  avl = remove_int(avl, 1023);
+  avl = gpr_avl_add(avl, box(129), box(1367));
+  avl = gpr_avl_add(avl, box(537), box(1368));
+  avl = remove_int(avl, 321);
+  avl = gpr_avl_add(avl, box(740), box(1370));
+  avl = remove_int(avl, 45);
+  avl = remove_int(avl, 136);
+  avl = gpr_avl_add(avl, box(229), box(1373));
+  avl = remove_int(avl, 772);
+  avl = gpr_avl_add(avl, box(181), box(1375));
+  avl = remove_int(avl, 175);
+  avl = gpr_avl_add(avl, box(817), box(1377));
+  avl = remove_int(avl, 956);
+  avl = gpr_avl_add(avl, box(675), box(1379));
+  avl = gpr_avl_add(avl, box(375), box(1380));
+  avl = remove_int(avl, 384);
+  avl = gpr_avl_add(avl, box(1016), box(1382));
+  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));
+  avl = gpr_avl_add(avl, box(293), box(1389));
+  avl = remove_int(avl, 207);
+  avl = remove_int(avl, 46);
+  avl = gpr_avl_add(avl, box(899), box(1392));
+  avl = gpr_avl_add(avl, box(666), box(1393));
+  avl = gpr_avl_add(avl, box(85), box(1394));
+  avl = gpr_avl_add(avl, box(914), box(1395));
+  avl = gpr_avl_add(avl, box(128), box(1396));
+  avl = gpr_avl_add(avl, box(835), box(1397));
+  avl = gpr_avl_add(avl, box(787), box(1398));
+  avl = gpr_avl_add(avl, box(649), box(1399));
+  avl = gpr_avl_add(avl, box(723), box(1400));
+  avl = remove_int(avl, 874);
+  avl = gpr_avl_add(avl, box(778), box(1402));
+  avl = gpr_avl_add(avl, box(1015), box(1403));
+  avl = gpr_avl_add(avl, box(59), box(1404));
+  avl = gpr_avl_add(avl, box(259), box(1405));
+  avl = gpr_avl_add(avl, box(758), box(1406));
+  avl = remove_int(avl, 648);
+  avl = gpr_avl_add(avl, box(145), box(1408));
+  avl = gpr_avl_add(avl, box(440), box(1409));
+  avl = remove_int(avl, 608);
+  avl = remove_int(avl, 690);
+  avl = gpr_avl_add(avl, box(605), box(1412));
+  avl = remove_int(avl, 856);
+  avl = remove_int(avl, 608);
+  avl = gpr_avl_add(avl, box(829), box(1415));
+  avl = gpr_avl_add(avl, box(660), box(1416));
+  avl = remove_int(avl, 596);
+  avl = gpr_avl_add(avl, box(519), box(1418));
+  avl = gpr_avl_add(avl, box(35), box(1419));
+  avl = gpr_avl_add(avl, box(871), box(1420));
+  avl = remove_int(avl, 845);
+  avl = gpr_avl_add(avl, box(600), box(1422));
+  avl = gpr_avl_add(avl, box(215), box(1423));
+  avl = remove_int(avl, 761);
+  avl = gpr_avl_add(avl, box(975), box(1425));
+  avl = remove_int(avl, 987);
+  avl = gpr_avl_add(avl, box(58), box(1427));
+  avl = remove_int(avl, 119);
+  avl = gpr_avl_add(avl, box(937), box(1429));
+  avl = gpr_avl_add(avl, box(372), box(1430));
+  avl = gpr_avl_add(avl, box(11), box(1431));
+  avl = gpr_avl_add(avl, box(398), box(1432));
+  avl = gpr_avl_add(avl, box(423), box(1433));
+  avl = remove_int(avl, 171);
+  avl = gpr_avl_add(avl, box(473), box(1435));
+  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));
+  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));
+  avl = remove_int(avl, 152);
+  avl = gpr_avl_add(avl, box(61), box(1448));
+  avl = remove_int(avl, 929);
+  avl = remove_int(avl, 9);
+  avl = gpr_avl_add(avl, box(251), box(1451));
+  avl = gpr_avl_add(avl, box(672), box(1452));
+  avl = gpr_avl_add(avl, box(66), box(1453));
+  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));
+  avl = gpr_avl_add(avl, box(495), box(1459));
+  avl = remove_int(avl, 450);
+  avl = gpr_avl_add(avl, box(533), box(1461));
+  avl = gpr_avl_add(avl, box(414), box(1462));
+  avl = remove_int(avl, 74);
+  avl = remove_int(avl, 236);
+  avl = gpr_avl_add(avl, box(707), box(1465));
+  avl = gpr_avl_add(avl, box(357), box(1466));
+  avl = gpr_avl_add(avl, box(1007), box(1467));
+  avl = gpr_avl_add(avl, box(811), box(1468));
+  avl = gpr_avl_add(avl, box(418), box(1469));
+  avl = gpr_avl_add(avl, box(164), box(1470));
+  avl = gpr_avl_add(avl, box(622), box(1471));
+  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));
+  avl = gpr_avl_add(avl, box(202), box(1478));
+  avl = gpr_avl_add(avl, box(312), box(1479));
+  avl = remove_int(avl, 274);
+  avl = gpr_avl_add(avl, box(684), box(1481));
+  avl = gpr_avl_add(avl, box(954), box(1482));
+  avl = gpr_avl_add(avl, box(637), box(1483));
+  avl = remove_int(avl, 716);
+  avl = gpr_avl_add(avl, box(198), box(1485));
+  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));
+  avl = gpr_avl_add(avl, box(862), box(1491));
+  avl = remove_int(avl, 527);
+  avl = gpr_avl_add(avl, box(945), box(1493));
+  avl = remove_int(avl, 355);
+  avl = remove_int(avl, 144);
+  avl = gpr_avl_add(avl, box(229), box(1496));
+  avl = gpr_avl_add(avl, box(237), box(1497));
+  avl = remove_int(avl, 471);
+  avl = remove_int(avl, 901);
+  avl = gpr_avl_add(avl, box(905), box(1500));
+  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));
+  avl = gpr_avl_add(avl, box(552), box(1506));
+  avl = gpr_avl_add(avl, box(30), box(1507));
+  avl = gpr_avl_add(avl, box(445), box(1508));
+  avl = remove_int(avl, 785);
+  avl = remove_int(avl, 185);
+  avl = gpr_avl_add(avl, box(405), box(1511));
+  avl = gpr_avl_add(avl, box(733), box(1512));
+  avl = gpr_avl_add(avl, box(573), box(1513));
+  avl = gpr_avl_add(avl, box(492), box(1514));
+  avl = gpr_avl_add(avl, box(343), box(1515));
+  avl = gpr_avl_add(avl, box(527), box(1516));
+  avl = gpr_avl_add(avl, box(596), box(1517));
+  avl = gpr_avl_add(avl, box(519), box(1518));
+  avl = remove_int(avl, 243);
+  avl = remove_int(avl, 722);
+  avl = gpr_avl_add(avl, box(772), box(1521));
+  avl = remove_int(avl, 152);
+  avl = remove_int(avl, 305);
+  avl = gpr_avl_add(avl, box(754), box(1524));
+  avl = gpr_avl_add(avl, box(373), box(1525));
+  avl = remove_int(avl, 995);
+  avl = gpr_avl_add(avl, box(329), box(1527));
+  avl = remove_int(avl, 397);
+  avl = gpr_avl_add(avl, box(884), box(1529));
+  avl = remove_int(avl, 329);
+  avl = remove_int(avl, 240);
+  avl = gpr_avl_add(avl, box(566), box(1532));
+  avl = gpr_avl_add(avl, box(232), box(1533));
+  avl = remove_int(avl, 993);
+  avl = gpr_avl_add(avl, box(888), box(1535));
+  avl = remove_int(avl, 242);
+  avl = gpr_avl_add(avl, box(941), box(1537));
+  avl = remove_int(avl, 415);
+  avl = gpr_avl_add(avl, box(992), box(1539));
+  avl = remove_int(avl, 289);
+  avl = gpr_avl_add(avl, box(60), box(1541));
+  avl = gpr_avl_add(avl, box(97), box(1542));
+  avl = remove_int(avl, 965);
+  avl = remove_int(avl, 267);
+  avl = remove_int(avl, 360);
+  avl = gpr_avl_add(avl, box(5), box(1546));
+  avl = remove_int(avl, 429);
+  avl = gpr_avl_add(avl, box(412), box(1548));
+  avl = remove_int(avl, 632);
+  avl = remove_int(avl, 113);
+  avl = gpr_avl_add(avl, box(48), box(1551));
+  avl = gpr_avl_add(avl, box(108), box(1552));
+  avl = gpr_avl_add(avl, box(750), box(1553));
+  avl = remove_int(avl, 188);
+  avl = gpr_avl_add(avl, box(668), box(1555));
+  avl = remove_int(avl, 37);
+  avl = remove_int(avl, 737);
+  avl = gpr_avl_add(avl, box(93), box(1558));
+  avl = gpr_avl_add(avl, box(628), box(1559));
+  avl = gpr_avl_add(avl, box(480), box(1560));
+  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));
+  avl = gpr_avl_add(avl, box(469), box(1567));
+  avl = remove_int(avl, 349);
+  avl = gpr_avl_add(avl, box(768), box(1569));
+  avl = gpr_avl_add(avl, box(915), box(1570));
+  avl = remove_int(avl, 1014);
+  avl = gpr_avl_add(avl, box(117), box(1572));
+  avl = remove_int(avl, 62);
+  avl = gpr_avl_add(avl, box(382), box(1574));
+  avl = remove_int(avl, 571);
+  avl = gpr_avl_add(avl, box(655), box(1576));
+  avl = gpr_avl_add(avl, box(323), box(1577));
+  avl = remove_int(avl, 869);
+  avl = remove_int(avl, 151);
+  avl = gpr_avl_add(avl, box(1019), box(1580));
+  avl = gpr_avl_add(avl, box(984), box(1581));
+  avl = gpr_avl_add(avl, box(870), box(1582));
+  avl = gpr_avl_add(avl, box(376), box(1583));
+  avl = remove_int(avl, 625);
+  avl = gpr_avl_add(avl, box(733), box(1585));
+  avl = remove_int(avl, 532);
+  avl = remove_int(avl, 444);
+  avl = gpr_avl_add(avl, box(428), box(1588));
+  avl = gpr_avl_add(avl, box(860), box(1589));
+  avl = gpr_avl_add(avl, box(173), box(1590));
+  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));
+  avl = gpr_avl_add(avl, box(639), box(1596));
+  avl = remove_int(avl, 431);
+  avl = gpr_avl_add(avl, box(993), box(1598));
+  avl = remove_int(avl, 681);
+  avl = remove_int(avl, 927);
+  avl = gpr_avl_add(avl, box(87), box(1601));
+  avl = gpr_avl_add(avl, box(91), box(1602));
+  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));
+  avl = gpr_avl_add(avl, box(951), box(1609));
+  avl = gpr_avl_add(avl, box(146), box(1610));
+  avl = gpr_avl_add(avl, box(482), box(1611));
+  avl = gpr_avl_add(avl, box(71), box(1612));
+  avl = remove_int(avl, 246);
+  avl = remove_int(avl, 696);
+  avl = gpr_avl_add(avl, box(636), box(1615));
+  avl = gpr_avl_add(avl, box(295), box(1616));
+  avl = remove_int(avl, 11);
+  avl = remove_int(avl, 231);
+  avl = gpr_avl_add(avl, box(905), box(1619));
+  avl = gpr_avl_add(avl, box(993), box(1620));
+  avl = gpr_avl_add(avl, box(433), box(1621));
+  avl = gpr_avl_add(avl, box(117), box(1622));
+  avl = gpr_avl_add(avl, box(467), box(1623));
+  avl = remove_int(avl, 419);
+  avl = gpr_avl_add(avl, box(179), box(1625));
+  avl = remove_int(avl, 926);
+  avl = remove_int(avl, 326);
+  avl = gpr_avl_add(avl, box(551), box(1628));
+  avl = remove_int(avl, 14);
+  avl = remove_int(avl, 476);
+  avl = remove_int(avl, 823);
+  avl = gpr_avl_add(avl, box(350), box(1632));
+  avl = gpr_avl_add(avl, box(133), box(1633));
+  avl = remove_int(avl, 906);
+  avl = gpr_avl_add(avl, box(827), box(1635));
+  avl = gpr_avl_add(avl, box(201), box(1636));
+  avl = remove_int(avl, 124);
+  avl = remove_int(avl, 662);
+  avl = gpr_avl_add(avl, box(314), box(1639));
+  avl = gpr_avl_add(avl, box(986), box(1640));
+  avl = gpr_avl_add(avl, box(622), box(1641));
+  avl = remove_int(avl, 130);
+  avl = gpr_avl_add(avl, box(861), box(1643));
+  avl = remove_int(avl, 497);
+  avl = remove_int(avl, 905);
+  avl = gpr_avl_add(avl, box(502), box(1646));
+  avl = remove_int(avl, 721);
+  avl = gpr_avl_add(avl, box(514), box(1648));
+  avl = gpr_avl_add(avl, box(410), box(1649));
+  avl = remove_int(avl, 869);
+  avl = remove_int(avl, 247);
+  avl = gpr_avl_add(avl, box(450), box(1652));
+  avl = remove_int(avl, 364);
+  avl = gpr_avl_add(avl, box(963), box(1654));
+  avl = gpr_avl_add(avl, box(146), box(1655));
+  avl = remove_int(avl, 147);
+  avl = remove_int(avl, 789);
+  avl = gpr_avl_add(avl, box(693), box(1658));
+  avl = gpr_avl_add(avl, box(959), box(1659));
+  avl = remove_int(avl, 478);
+  avl = gpr_avl_add(avl, box(116), box(1661));
+  avl = gpr_avl_add(avl, box(520), box(1662));
+  avl = gpr_avl_add(avl, box(809), box(1663));
+  avl = gpr_avl_add(avl, box(667), box(1664));
+  avl = gpr_avl_add(avl, box(406), box(1665));
+  avl = remove_int(avl, 409);
+  avl = gpr_avl_add(avl, box(558), box(1667));
+  avl = gpr_avl_add(avl, box(0), box(1668));
+  avl = gpr_avl_add(avl, box(948), box(1669));
+  avl = gpr_avl_add(avl, box(576), box(1670));
+  avl = remove_int(avl, 864);
+  avl = remove_int(avl, 840);
+  avl = remove_int(avl, 1001);
+  avl = gpr_avl_add(avl, box(232), box(1674));
+  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));
+  avl = gpr_avl_add(avl, box(648), box(1680));
+  avl = gpr_avl_add(avl, box(761), box(1681));
+  avl = remove_int(avl, 293);
+  avl = remove_int(avl, 893);
+  avl = gpr_avl_add(avl, box(194), box(1684));
+  avl = remove_int(avl, 233);
+  avl = gpr_avl_add(avl, box(888), box(1686));
+  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));
+  avl = remove_int(avl, 634);
+  avl = remove_int(avl, 335);
+  avl = gpr_avl_add(avl, box(718), box(1694));
+  avl = gpr_avl_add(avl, box(463), box(1695));
+  avl = gpr_avl_add(avl, box(233), box(1696));
+  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));
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(716), box(1705));
+  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));
+  avl = gpr_avl_add(avl, box(212), box(1714));
+  avl = gpr_avl_add(avl, box(266), box(1715));
+  avl = gpr_avl_add(avl, box(238), box(1716));
+  avl = remove_int(avl, 153);
+  avl = gpr_avl_add(avl, box(585), box(1718));
+  avl = remove_int(avl, 121);
+  avl = gpr_avl_add(avl, box(534), box(1720));
+  avl = remove_int(avl, 579);
+  avl = gpr_avl_add(avl, box(127), box(1722));
+  avl = gpr_avl_add(avl, box(399), box(1723));
+  avl = remove_int(avl, 417);
+  avl = gpr_avl_add(avl, box(978), box(1725));
+  avl = gpr_avl_add(avl, box(768), box(1726));
+  avl = remove_int(avl, 985);
+  avl = gpr_avl_add(avl, box(536), box(1728));
+  avl = gpr_avl_add(avl, box(449), box(1729));
+  avl = gpr_avl_add(avl, box(586), box(1730));
+  avl = remove_int(avl, 998);
+  avl = remove_int(avl, 394);
+  avl = remove_int(avl, 141);
+  avl = gpr_avl_add(avl, box(889), box(1734));
+  avl = gpr_avl_add(avl, box(871), box(1735));
+  avl = gpr_avl_add(avl, box(76), box(1736));
+  avl = gpr_avl_add(avl, box(549), box(1737));
+  avl = gpr_avl_add(avl, box(757), box(1738));
+  avl = remove_int(avl, 908);
+  avl = gpr_avl_add(avl, box(789), box(1740));
+  avl = remove_int(avl, 224);
+  avl = gpr_avl_add(avl, box(407), box(1742));
+  avl = gpr_avl_add(avl, box(381), box(1743));
+  avl = gpr_avl_add(avl, box(561), box(1744));
+  avl = gpr_avl_add(avl, box(667), box(1745));
+  avl = gpr_avl_add(avl, box(522), box(1746));
+  avl = gpr_avl_add(avl, box(948), box(1747));
+  avl = remove_int(avl, 770);
+  avl = gpr_avl_add(avl, box(872), box(1749));
+  avl = gpr_avl_add(avl, box(327), box(1750));
+  avl = remove_int(avl, 10);
+  avl = gpr_avl_add(avl, box(122), box(1752));
+  avl = remove_int(avl, 606);
+  avl = gpr_avl_add(avl, box(485), box(1754));
+  avl = remove_int(avl, 6);
+  avl = gpr_avl_add(avl, box(329), box(1756));
+  avl = gpr_avl_add(avl, box(783), box(1757));
+  avl = remove_int(avl, 416);
+  avl = gpr_avl_add(avl, box(656), box(1759));
+  avl = gpr_avl_add(avl, box(971), box(1760));
+  avl = gpr_avl_add(avl, box(77), box(1761));
+  avl = gpr_avl_add(avl, box(942), box(1762));
+  avl = remove_int(avl, 361);
+  avl = gpr_avl_add(avl, box(66), box(1764));
+  avl = gpr_avl_add(avl, box(299), box(1765));
+  avl = gpr_avl_add(avl, box(929), box(1766));
+  avl = gpr_avl_add(avl, box(797), box(1767));
+  avl = remove_int(avl, 869);
+  avl = remove_int(avl, 907);
+  avl = gpr_avl_add(avl, box(870), box(1770));
+  avl = remove_int(avl, 580);
+  avl = remove_int(avl, 120);
+  avl = gpr_avl_add(avl, box(913), box(1773));
+  avl = remove_int(avl, 480);
+  avl = gpr_avl_add(avl, box(489), box(1775));
+  avl = remove_int(avl, 845);
+  avl = gpr_avl_add(avl, box(896), box(1777));
+  avl = remove_int(avl, 567);
+  avl = remove_int(avl, 427);
+  avl = gpr_avl_add(avl, box(443), box(1780));
+  avl = gpr_avl_add(avl, box(3), box(1781));
+  avl = remove_int(avl, 12);
+  avl = gpr_avl_add(avl, box(376), box(1783));
+  avl = gpr_avl_add(avl, box(155), box(1784));
+  avl = gpr_avl_add(avl, box(188), box(1785));
+  avl = gpr_avl_add(avl, box(149), box(1786));
+  avl = gpr_avl_add(avl, box(178), box(1787));
+  avl = remove_int(avl, 84);
+  avl = gpr_avl_add(avl, box(805), box(1789));
+  avl = gpr_avl_add(avl, box(612), box(1790));
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(837), box(1792));
+  avl = remove_int(avl, 173);
+  avl = remove_int(avl, 72);
+  avl = gpr_avl_add(avl, box(1014), box(1795));
+  avl = remove_int(avl, 303);
+  avl = gpr_avl_add(avl, box(865), box(1797));
+  avl = gpr_avl_add(avl, box(793), box(1798));
+  avl = remove_int(avl, 173);
+  avl = remove_int(avl, 477);
+  avl = gpr_avl_add(avl, box(950), box(1801));
+  avl = gpr_avl_add(avl, box(105), box(1802));
+  avl = gpr_avl_add(avl, box(895), box(1803));
+  avl = gpr_avl_add(avl, box(171), box(1804));
+  avl = gpr_avl_add(avl, box(753), box(1805));
+  avl = gpr_avl_add(avl, box(946), box(1806));
+  avl = remove_int(avl, 194);
+  avl = remove_int(avl, 559);
+  avl = remove_int(avl, 116);
+  avl = gpr_avl_add(avl, box(968), box(1810));
+  avl = remove_int(avl, 124);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(563), box(1813));
+  avl = remove_int(avl, 182);
+  avl = gpr_avl_add(avl, box(816), box(1815));
+  avl = remove_int(avl, 73);
+  avl = remove_int(avl, 261);
+  avl = gpr_avl_add(avl, box(847), box(1818));
+  avl = gpr_avl_add(avl, box(368), box(1819));
+  avl = gpr_avl_add(avl, box(808), box(1820));
+  avl = gpr_avl_add(avl, box(779), box(1821));
+  avl = remove_int(avl, 818);
+  avl = gpr_avl_add(avl, box(466), box(1823));
+  avl = remove_int(avl, 316);
+  avl = gpr_avl_add(avl, box(986), box(1825));
+  avl = gpr_avl_add(avl, box(688), box(1826));
+  avl = gpr_avl_add(avl, box(509), box(1827));
+  avl = gpr_avl_add(avl, box(51), box(1828));
+  avl = remove_int(avl, 655);
+  avl = remove_int(avl, 785);
+  avl = remove_int(avl, 893);
+  avl = gpr_avl_add(avl, box(167), box(1832));
+  avl = remove_int(avl, 13);
+  avl = remove_int(avl, 263);
+  avl = gpr_avl_add(avl, box(1009), box(1835));
+  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));
+  avl = remove_int(avl, 267);
+  avl = gpr_avl_add(avl, box(676), box(1842));
+  avl = gpr_avl_add(avl, box(231), box(1843));
+  avl = gpr_avl_add(avl, box(824), box(1844));
+  avl = remove_int(avl, 961);
+  avl = gpr_avl_add(avl, box(311), box(1846));
+  avl = gpr_avl_add(avl, box(420), box(1847));
+  avl = gpr_avl_add(avl, box(960), box(1848));
+  avl = gpr_avl_add(avl, box(468), box(1849));
+  avl = gpr_avl_add(avl, box(815), box(1850));
+  avl = remove_int(avl, 247);
+  avl = remove_int(avl, 194);
+  avl = gpr_avl_add(avl, box(546), box(1853));
+  avl = remove_int(avl, 222);
+  avl = remove_int(avl, 914);
+  avl = remove_int(avl, 741);
+  avl = gpr_avl_add(avl, box(470), box(1857));
+  avl = gpr_avl_add(avl, box(933), box(1858));
+  avl = gpr_avl_add(avl, box(97), box(1859));
+  avl = remove_int(avl, 564);
+  avl = remove_int(avl, 295);
+  avl = gpr_avl_add(avl, box(864), box(1862));
+  avl = remove_int(avl, 329);
+  avl = gpr_avl_add(avl, box(124), box(1864));
+  avl = gpr_avl_add(avl, box(1000), box(1865));
+  avl = gpr_avl_add(avl, box(228), box(1866));
+  avl = gpr_avl_add(avl, box(187), box(1867));
+  avl = remove_int(avl, 224);
+  avl = remove_int(avl, 306);
+  avl = remove_int(avl, 884);
+  avl = gpr_avl_add(avl, box(449), box(1871));
+  avl = gpr_avl_add(avl, box(353), box(1872));
+  avl = gpr_avl_add(avl, box(994), box(1873));
+  avl = gpr_avl_add(avl, box(596), box(1874));
+  avl = gpr_avl_add(avl, box(996), box(1875));
+  avl = gpr_avl_add(avl, box(101), box(1876));
+  avl = gpr_avl_add(avl, box(1012), box(1877));
+  avl = gpr_avl_add(avl, box(982), box(1878));
+  avl = gpr_avl_add(avl, box(742), box(1879));
+  avl = remove_int(avl, 92);
+  avl = remove_int(avl, 1022);
+  avl = gpr_avl_add(avl, box(941), box(1882));
+  avl = remove_int(avl, 742);
+  avl = remove_int(avl, 919);
+  avl = gpr_avl_add(avl, box(588), box(1885));
+  avl = remove_int(avl, 221);
+  avl = gpr_avl_add(avl, box(356), box(1887));
+  avl = gpr_avl_add(avl, box(932), box(1888));
+  avl = remove_int(avl, 837);
+  avl = gpr_avl_add(avl, box(394), box(1890));
+  avl = gpr_avl_add(avl, box(642), box(1891));
+  avl = gpr_avl_add(avl, box(52), box(1892));
+  avl = gpr_avl_add(avl, box(437), box(1893));
+  avl = gpr_avl_add(avl, box(948), box(1894));
+  avl = gpr_avl_add(avl, box(93), box(1895));
+  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));
+  avl = gpr_avl_add(avl, box(952), box(1901));
+  avl = gpr_avl_add(avl, box(510), box(1902));
+  avl = remove_int(avl, 876);
+  avl = remove_int(avl, 612);
+  avl = gpr_avl_add(avl, box(923), box(1905));
+  avl = gpr_avl_add(avl, box(475), box(1906));
+  avl = remove_int(avl, 478);
+  avl = remove_int(avl, 148);
+  avl = gpr_avl_add(avl, box(538), box(1909));
+  avl = remove_int(avl, 47);
+  avl = gpr_avl_add(avl, box(89), box(1911));
+  avl = remove_int(avl, 723);
+  avl = gpr_avl_add(avl, box(687), box(1913));
+  avl = gpr_avl_add(avl, box(480), box(1914));
+  avl = gpr_avl_add(avl, box(149), box(1915));
+  avl = remove_int(avl, 68);
+  avl = remove_int(avl, 862);
+  avl = remove_int(avl, 363);
+  avl = gpr_avl_add(avl, box(996), box(1919));
+  avl = remove_int(avl, 380);
+  avl = gpr_avl_add(avl, box(957), box(1921));
+  avl = remove_int(avl, 413);
+  avl = gpr_avl_add(avl, box(360), box(1923));
+  avl = gpr_avl_add(avl, box(304), box(1924));
+  avl = gpr_avl_add(avl, box(634), box(1925));
+  avl = gpr_avl_add(avl, box(506), box(1926));
+  avl = remove_int(avl, 248);
+  avl = gpr_avl_add(avl, box(124), box(1928));
+  avl = gpr_avl_add(avl, box(181), box(1929));
+  avl = remove_int(avl, 507);
+  avl = gpr_avl_add(avl, box(141), box(1931));
+  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));
+  avl = gpr_avl_add(avl, box(906), box(1937));
+  avl = gpr_avl_add(avl, box(44), box(1938));
+  avl = remove_int(avl, 949);
+  avl = remove_int(avl, 117);
+  avl = gpr_avl_add(avl, box(700), box(1941));
+  avl = gpr_avl_add(avl, box(258), box(1942));
+  avl = remove_int(avl, 828);
+  avl = gpr_avl_add(avl, box(860), box(1944));
+  avl = gpr_avl_add(avl, box(987), box(1945));
+  avl = gpr_avl_add(avl, box(316), box(1946));
+  avl = gpr_avl_add(avl, box(919), box(1947));
+  avl = remove_int(avl, 84);
+  avl = gpr_avl_add(avl, box(473), box(1949));
+  avl = remove_int(avl, 127);
+  avl = remove_int(avl, 829);
+  avl = remove_int(avl, 829);
+  avl = gpr_avl_add(avl, box(488), box(1953));
+  avl = gpr_avl_add(avl, box(954), box(1954));
+  avl = remove_int(avl, 198);
+  avl = remove_int(avl, 972);
+  avl = remove_int(avl, 670);
+  avl = gpr_avl_add(avl, box(822), box(1958));
+  avl = remove_int(avl, 589);
+  avl = remove_int(avl, 459);
+  avl = gpr_avl_add(avl, box(1003), box(1961));
+  avl = gpr_avl_add(avl, box(657), box(1962));
+  avl = gpr_avl_add(avl, box(477), box(1963));
+  avl = gpr_avl_add(avl, box(923), box(1964));
+  avl = remove_int(avl, 496);
+  avl = remove_int(avl, 99);
+  avl = gpr_avl_add(avl, box(127), box(1967));
+  avl = gpr_avl_add(avl, box(1013), box(1968));
+  avl = gpr_avl_add(avl, box(778), box(1969));
+  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));
+  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));
+  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));
+  avl = gpr_avl_add(avl, box(412), box(1986));
+  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));
+  avl = gpr_avl_add(avl, box(408), box(1992));
+  avl = gpr_avl_add(avl, box(841), box(1993));
+  avl = remove_int(avl, 593);
+  avl = gpr_avl_add(avl, box(582), box(1995));
+  avl = gpr_avl_add(avl, box(597), box(1996));
+  avl = remove_int(avl, 49);
+  avl = remove_int(avl, 835);
+  avl = gpr_avl_add(avl, box(417), box(1999));
+  avl = gpr_avl_add(avl, box(191), box(2000));
+  avl = remove_int(avl, 406);
+  avl = gpr_avl_add(avl, box(30), box(2002));
+  avl = remove_int(avl, 841);
+  avl = remove_int(avl, 50);
+  avl = gpr_avl_add(avl, box(967), box(2005));
+  avl = gpr_avl_add(avl, box(849), box(2006));
+  avl = remove_int(avl, 608);
+  avl = gpr_avl_add(avl, box(306), box(2008));
+  avl = remove_int(avl, 779);
+  avl = gpr_avl_add(avl, box(897), box(2010));
+  avl = gpr_avl_add(avl, box(147), box(2011));
+  avl = remove_int(avl, 982);
+  avl = gpr_avl_add(avl, box(470), box(2013));
+  avl = remove_int(avl, 951);
+  avl = gpr_avl_add(avl, box(388), box(2015));
+  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));
+  avl = remove_int(avl, 671);
+  avl = gpr_avl_add(avl, box(1020), box(2022));
+  avl = remove_int(avl, 277);
+  avl = gpr_avl_add(avl, box(681), box(2024));
+  avl = gpr_avl_add(avl, box(179), box(2025));
+  avl = gpr_avl_add(avl, box(370), box(2026));
+  avl = gpr_avl_add(avl, box(0), box(2027));
+  avl = remove_int(avl, 523);
+  avl = gpr_avl_add(avl, box(99), box(2029));
+  avl = gpr_avl_add(avl, box(334), box(2030));
+  avl = gpr_avl_add(avl, box(569), box(2031));
+  avl = gpr_avl_add(avl, box(257), box(2032));
+  avl = remove_int(avl, 572);
+  avl = gpr_avl_add(avl, box(805), box(2034));
+  avl = gpr_avl_add(avl, box(143), box(2035));
+  avl = gpr_avl_add(avl, box(670), box(2036));
+  avl = remove_int(avl, 42);
+  avl = gpr_avl_add(avl, box(46), box(2038));
+  avl = remove_int(avl, 970);
+  avl = gpr_avl_add(avl, box(353), box(2040));
+  avl = remove_int(avl, 258);
+  avl = gpr_avl_add(avl, box(451), box(2042));
+  avl = gpr_avl_add(avl, box(28), box(2043));
+  avl = gpr_avl_add(avl, box(729), box(2044));
+  avl = gpr_avl_add(avl, box(401), box(2045));
+  avl = gpr_avl_add(avl, box(614), box(2046));
+  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));
+  avl = gpr_avl_add(avl, box(980), box(2052));
+  avl = gpr_avl_add(avl, box(990), box(2053));
+  avl = gpr_avl_add(avl, box(355), box(2054));
+  avl = remove_int(avl, 730);
+  avl = remove_int(avl, 37);
+  avl = gpr_avl_add(avl, box(407), box(2057));
+  avl = gpr_avl_add(avl, box(222), box(2058));
+  avl = gpr_avl_add(avl, box(439), box(2059));
+  avl = gpr_avl_add(avl, box(563), box(2060));
+  avl = remove_int(avl, 992);
+  avl = remove_int(avl, 786);
+  avl = gpr_avl_add(avl, box(1), box(2063));
+  avl = gpr_avl_add(avl, box(473), box(2064));
+  avl = gpr_avl_add(avl, box(992), box(2065));
+  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));
+  avl = gpr_avl_add(avl, box(35), box(2071));
+  avl = remove_int(avl, 843);
+  avl = gpr_avl_add(avl, box(855), box(2073));
+  avl = remove_int(avl, 878);
+  avl = gpr_avl_add(avl, box(993), box(2075));
+  avl = gpr_avl_add(avl, box(87), box(2076));
+  avl = gpr_avl_add(avl, box(572), box(2077));
+  avl = remove_int(avl, 896);
+  avl = gpr_avl_add(avl, box(849), box(2079));
+  avl = remove_int(avl, 597);
+  avl = gpr_avl_add(avl, box(472), box(2081));
+  avl = remove_int(avl, 778);
+  avl = remove_int(avl, 934);
+  avl = remove_int(avl, 314);
+  avl = gpr_avl_add(avl, box(101), box(2085));
+  avl = remove_int(avl, 938);
+  avl = remove_int(avl, 1010);
+  avl = gpr_avl_add(avl, box(579), box(2088));
+  avl = remove_int(avl, 798);
+  avl = remove_int(avl, 88);
+  avl = gpr_avl_add(avl, box(851), box(2091));
+  avl = remove_int(avl, 705);
+  avl = gpr_avl_add(avl, box(26), box(2093));
+  avl = remove_int(avl, 973);
+  avl = gpr_avl_add(avl, box(923), box(2095));
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(310), box(2097));
+  avl = gpr_avl_add(avl, box(269), box(2098));
+  avl = remove_int(avl, 173);
+  avl = gpr_avl_add(avl, box(279), box(2100));
+  avl = remove_int(avl, 203);
+  avl = gpr_avl_add(avl, box(411), box(2102));
+  avl = remove_int(avl, 950);
+  avl = gpr_avl_add(avl, box(6), box(2104));
+  avl = remove_int(avl, 400);
+  avl = remove_int(avl, 468);
+  avl = remove_int(avl, 271);
+  avl = gpr_avl_add(avl, box(627), box(2108));
+  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));
+  avl = remove_int(avl, 194);
+  avl = remove_int(avl, 18);
+  avl = gpr_avl_add(avl, box(727), box(2120));
+  avl = remove_int(avl, 295);
+  avl = gpr_avl_add(avl, box(645), box(2122));
+  avl = remove_int(avl, 321);
+  avl = remove_int(avl, 863);
+  avl = gpr_avl_add(avl, box(824), box(2125));
+  avl = gpr_avl_add(avl, box(651), box(2126));
+  avl = gpr_avl_add(avl, box(804), box(2127));
+  avl = remove_int(avl, 307);
+  avl = gpr_avl_add(avl, box(867), box(2129));
+  avl = remove_int(avl, 384);
+  avl = gpr_avl_add(avl, box(819), box(2131));
+  avl = remove_int(avl, 674);
+  avl = gpr_avl_add(avl, box(76), box(2133));
+  avl = remove_int(avl, 898);
+  avl = gpr_avl_add(avl, box(45), box(2135));
+  avl = gpr_avl_add(avl, box(512), box(2136));
+  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));
+  avl = remove_int(avl, 509);
+  avl = remove_int(avl, 301);
+  avl = gpr_avl_add(avl, box(861), box(2146));
+  avl = gpr_avl_add(avl, box(918), box(2147));
+  avl = remove_int(avl, 992);
+  avl = gpr_avl_add(avl, box(356), box(2149));
+  avl = remove_int(avl, 64);
+  avl = remove_int(avl, 444);
+  avl = remove_int(avl, 741);
+  avl = gpr_avl_add(avl, box(710), box(2153));
+  avl = gpr_avl_add(avl, box(264), box(2154));
+  avl = remove_int(avl, 347);
+  avl = remove_int(avl, 250);
+  avl = gpr_avl_add(avl, box(82), box(2157));
+  avl = gpr_avl_add(avl, box(571), box(2158));
+  avl = remove_int(avl, 721);
+  avl = remove_int(avl, 622);
+  avl = gpr_avl_add(avl, box(950), box(2161));
+  avl = gpr_avl_add(avl, box(94), box(2162));
+  avl = remove_int(avl, 970);
+  avl = gpr_avl_add(avl, box(815), box(2164));
+  avl = remove_int(avl, 930);
+  avl = remove_int(avl, 703);
+  avl = gpr_avl_add(avl, box(432), box(2167));
+  avl = remove_int(avl, 544);
+  avl = gpr_avl_add(avl, box(21), box(2169));
+  avl = gpr_avl_add(avl, box(186), box(2170));
+  avl = remove_int(avl, 143);
+  avl = gpr_avl_add(avl, box(425), box(2172));
+  avl = remove_int(avl, 769);
+  avl = gpr_avl_add(avl, box(656), box(2174));
+  avl = remove_int(avl, 29);
+  avl = gpr_avl_add(avl, box(464), box(2176));
+  avl = remove_int(avl, 713);
+  avl = gpr_avl_add(avl, box(800), box(2178));
+  avl = remove_int(avl, 621);
+  avl = gpr_avl_add(avl, box(962), box(2180));
+  avl = remove_int(avl, 448);
+  avl = gpr_avl_add(avl, box(878), box(2182));
+  avl = remove_int(avl, 39);
+  avl = remove_int(avl, 999);
+  avl = gpr_avl_add(avl, box(182), box(2185));
+  avl = gpr_avl_add(avl, box(429), box(2186));
+  avl = gpr_avl_add(avl, box(598), box(2187));
+  avl = remove_int(avl, 551);
+  avl = gpr_avl_add(avl, box(827), box(2189));
+  avl = gpr_avl_add(avl, box(809), box(2190));
+  avl = remove_int(avl, 438);
+  avl = remove_int(avl, 811);
+  avl = gpr_avl_add(avl, box(808), box(2193));
+  avl = gpr_avl_add(avl, box(788), box(2194));
+  avl = remove_int(avl, 156);
+  avl = gpr_avl_add(avl, box(933), box(2196));
+  avl = gpr_avl_add(avl, box(344), box(2197));
+  avl = remove_int(avl, 460);
+  avl = gpr_avl_add(avl, box(161), box(2199));
+  avl = gpr_avl_add(avl, box(444), box(2200));
+  avl = remove_int(avl, 597);
+  avl = remove_int(avl, 668);
+  avl = gpr_avl_add(avl, box(703), box(2203));
+  avl = remove_int(avl, 515);
+  avl = gpr_avl_add(avl, box(380), box(2205));
+  avl = gpr_avl_add(avl, box(338), box(2206));
+  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));
+  avl = remove_int(avl, 450);
+  avl = gpr_avl_add(avl, box(411), box(2213));
+  avl = gpr_avl_add(avl, box(117), box(2214));
+  avl = gpr_avl_add(avl, box(322), box(2215));
+  avl = gpr_avl_add(avl, box(915), box(2216));
+  avl = gpr_avl_add(avl, box(410), box(2217));
+  avl = gpr_avl_add(avl, box(66), box(2218));
+  avl = remove_int(avl, 756);
+  avl = remove_int(avl, 596);
+  avl = gpr_avl_add(avl, box(882), box(2221));
+  avl = gpr_avl_add(avl, box(930), box(2222));
+  avl = gpr_avl_add(avl, box(36), box(2223));
+  avl = remove_int(avl, 742);
+  avl = gpr_avl_add(avl, box(539), box(2225));
+  avl = gpr_avl_add(avl, box(596), box(2226));
+  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));
+  avl = gpr_avl_add(avl, box(493), box(2233));
+  avl = gpr_avl_add(avl, box(839), box(2234));
+  avl = remove_int(avl, 774);
+  avl = gpr_avl_add(avl, box(337), box(2236));
+  avl = remove_int(avl, 322);
+  avl = gpr_avl_add(avl, box(16), box(2238));
+  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));
+  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));
+  avl = gpr_avl_add(avl, box(138), box(2249));
+  avl = gpr_avl_add(avl, box(437), box(2250));
+  avl = gpr_avl_add(avl, box(275), box(2251));
+  avl = remove_int(avl, 520);
+  avl = gpr_avl_add(avl, box(1019), box(2253));
+  avl = remove_int(avl, 955);
+  avl = gpr_avl_add(avl, box(270), box(2255));
+  avl = remove_int(avl, 680);
+  avl = remove_int(avl, 698);
+  avl = gpr_avl_add(avl, box(735), box(2258));
+  avl = gpr_avl_add(avl, box(400), box(2259));
+  avl = remove_int(avl, 991);
+  avl = gpr_avl_add(avl, box(263), box(2261));
+  avl = remove_int(avl, 704);
+  avl = gpr_avl_add(avl, box(757), box(2263));
+  avl = remove_int(avl, 194);
+  avl = remove_int(avl, 616);
+  avl = remove_int(avl, 784);
+  avl = gpr_avl_add(avl, box(382), box(2267));
+  avl = gpr_avl_add(avl, box(464), box(2268));
+  avl = gpr_avl_add(avl, box(817), box(2269));
+  avl = remove_int(avl, 445);
+  avl = gpr_avl_add(avl, box(412), box(2271));
+  avl = remove_int(avl, 525);
+  avl = gpr_avl_add(avl, box(299), box(2273));
+  avl = gpr_avl_add(avl, box(464), box(2274));
+  avl = gpr_avl_add(avl, box(715), box(2275));
+  avl = remove_int(avl, 58);
+  avl = remove_int(avl, 218);
+  avl = gpr_avl_add(avl, box(961), box(2278));
+  avl = gpr_avl_add(avl, box(491), box(2279));
+  avl = remove_int(avl, 846);
+  avl = gpr_avl_add(avl, box(762), box(2281));
+  avl = remove_int(avl, 974);
+  avl = remove_int(avl, 887);
+  avl = gpr_avl_add(avl, box(498), box(2284));
+  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));
+  avl = gpr_avl_add(avl, box(1021), box(2290));
+  avl = remove_int(avl, 155);
+  avl = remove_int(avl, 128);
+  avl = gpr_avl_add(avl, box(819), box(2293));
+  avl = gpr_avl_add(avl, box(324), box(2294));
+  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));
+  avl = gpr_avl_add(avl, box(474), box(2301));
+  avl = gpr_avl_add(avl, box(719), box(2302));
+  avl = gpr_avl_add(avl, box(236), box(2303));
+  avl = remove_int(avl, 818);
+  avl = gpr_avl_add(avl, box(727), box(2305));
+  avl = remove_int(avl, 892);
+  avl = remove_int(avl, 871);
+  avl = remove_int(avl, 231);
+  avl = gpr_avl_add(avl, box(62), box(2309));
+  avl = gpr_avl_add(avl, box(953), box(2310));
+  avl = remove_int(avl, 701);
+  avl = gpr_avl_add(avl, box(193), box(2312));
+  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));
+  avl = gpr_avl_add(avl, box(751), box(2318));
+  avl = remove_int(avl, 525);
+  avl = gpr_avl_add(avl, box(217), box(2320));
+  avl = remove_int(avl, 336);
+  avl = gpr_avl_add(avl, box(86), box(2322));
+  avl = gpr_avl_add(avl, box(81), box(2323));
+  avl = gpr_avl_add(avl, box(850), box(2324));
+  avl = remove_int(avl, 872);
+  avl = gpr_avl_add(avl, box(402), box(2326));
+  avl = gpr_avl_add(avl, box(54), box(2327));
+  avl = gpr_avl_add(avl, box(980), box(2328));
+  avl = gpr_avl_add(avl, box(845), box(2329));
+  avl = remove_int(avl, 1004);
+  avl = remove_int(avl, 273);
+  avl = remove_int(avl, 879);
+  avl = gpr_avl_add(avl, box(354), box(2333));
+  avl = gpr_avl_add(avl, box(58), box(2334));
+  avl = gpr_avl_add(avl, box(127), box(2335));
+  avl = remove_int(avl, 84);
+  avl = gpr_avl_add(avl, box(360), box(2337));
+  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));
+  avl = remove_int(avl, 558);
+  avl = remove_int(avl, 958);
+  avl = gpr_avl_add(avl, box(822), box(2345));
+  avl = remove_int(avl, 1004);
+  avl = remove_int(avl, 747);
+  avl = gpr_avl_add(avl, box(631), box(2348));
+  avl = gpr_avl_add(avl, box(442), box(2349));
+  avl = remove_int(avl, 957);
+  avl = remove_int(avl, 964);
+  avl = gpr_avl_add(avl, box(10), box(2352));
+  avl = remove_int(avl, 189);
+  avl = gpr_avl_add(avl, box(742), box(2354));
+  avl = remove_int(avl, 108);
+  avl = gpr_avl_add(avl, box(1014), box(2356));
+  avl = remove_int(avl, 266);
+  avl = remove_int(avl, 623);
+  avl = remove_int(avl, 697);
+  avl = gpr_avl_add(avl, box(180), box(2360));
+  avl = remove_int(avl, 472);
+  avl = gpr_avl_add(avl, box(567), box(2362));
+  avl = remove_int(avl, 1020);
+  avl = remove_int(avl, 273);
+  avl = gpr_avl_add(avl, box(864), box(2365));
+  avl = gpr_avl_add(avl, box(1009), box(2366));
+  avl = remove_int(avl, 224);
+  avl = remove_int(avl, 81);
+  avl = gpr_avl_add(avl, box(653), box(2369));
+  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));
+  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));
+  avl = gpr_avl_add(avl, box(925), box(2383));
+  avl = remove_int(avl, 994);
+  avl = remove_int(avl, 324);
+  avl = gpr_avl_add(avl, box(291), box(2386));
+  avl = remove_int(avl, 94);
+  avl = remove_int(avl, 795);
+  avl = remove_int(avl, 42);
+  avl = gpr_avl_add(avl, box(613), box(2390));
+  avl = remove_int(avl, 289);
+  avl = gpr_avl_add(avl, box(980), box(2392));
+  avl = remove_int(avl, 316);
+  avl = gpr_avl_add(avl, box(281), box(2394));
+  avl = gpr_avl_add(avl, box(1006), box(2395));
+  avl = remove_int(avl, 776);
+  avl = gpr_avl_add(avl, box(108), box(2397));
+  avl = gpr_avl_add(avl, box(918), box(2398));
+  avl = remove_int(avl, 721);
+  avl = remove_int(avl, 563);
+  avl = gpr_avl_add(avl, box(925), box(2401));
+  avl = remove_int(avl, 448);
+  avl = remove_int(avl, 198);
+  avl = remove_int(avl, 1);
+  avl = gpr_avl_add(avl, box(160), box(2405));
+  avl = remove_int(avl, 515);
+  avl = gpr_avl_add(avl, box(284), box(2407));
+  avl = gpr_avl_add(avl, box(225), box(2408));
+  avl = remove_int(avl, 304);
+  avl = gpr_avl_add(avl, box(714), box(2410));
+  avl = gpr_avl_add(avl, box(708), box(2411));
+  avl = gpr_avl_add(avl, box(624), box(2412));
+  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));
+  avl = remove_int(avl, 280);
+  avl = remove_int(avl, 25);
+  avl = remove_int(avl, 633);
+  avl = gpr_avl_add(avl, box(897), box(2421));
+  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));
+  avl = remove_int(avl, 948);
+  avl = remove_int(avl, 74);
+  avl = remove_int(avl, 571);
+  avl = gpr_avl_add(avl, box(486), box(2435));
+  avl = gpr_avl_add(avl, box(285), box(2436));
+  avl = remove_int(avl, 304);
+  avl = remove_int(avl, 516);
+  avl = gpr_avl_add(avl, box(758), box(2439));
+  avl = gpr_avl_add(avl, box(776), box(2440));
+  avl = remove_int(avl, 696);
+  avl = gpr_avl_add(avl, box(104), box(2442));
+  avl = gpr_avl_add(avl, box(700), box(2443));
+  avl = gpr_avl_add(avl, box(114), box(2444));
+  avl = gpr_avl_add(avl, box(567), box(2445));
+  avl = remove_int(avl, 620);
+  avl = gpr_avl_add(avl, box(270), box(2447));
+  avl = remove_int(avl, 730);
+  avl = gpr_avl_add(avl, box(749), box(2449));
+  avl = gpr_avl_add(avl, box(443), box(2450));
+  avl = remove_int(avl, 457);
+  avl = gpr_avl_add(avl, box(571), box(2452));
+  avl = gpr_avl_add(avl, box(626), box(2453));
+  avl = remove_int(avl, 638);
+  avl = remove_int(avl, 313);
+
+  gpr_avl_unref(avl);
+}
+
+static void test_stress(void) {
+  int added[1024];
+  int i, j;
+  int deletions = 0;
+  gpr_avl avl;
+
+  gpr_log(GPR_DEBUG, "test_stress");
+
+  srand((unsigned)time(NULL));
+  avl = gpr_avl_create(&int_int_vtable);
+
+  memset(added, 0, sizeof(added));
+
+  for (i = 1; deletions < 1000; i++) {
+    int idx = rand() % (int)GPR_ARRAY_SIZE(added);
+    GPR_ASSERT(i);
+    if (rand() < RAND_MAX / 2) {
+      added[idx] = i;
+      fprintf(stderr, "avl = gpr_avl_add(avl, box(%d), box(%d)); /* d=%d */\n",
+              idx, i, deletions);
+      avl = gpr_avl_add(avl, box(idx), box(i));
+    } else {
+      deletions += (added[idx] != 0);
+      added[idx] = 0;
+      fprintf(stderr, "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);
+}
+
+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();
+
+  return 0;
+}
diff --git a/test/core/util/reconnect_server.c b/test/core/util/reconnect_server.c
index c064fb32c6..28e521221b 100644
--- a/test/core/util/reconnect_server.c
+++ b/test/core/util/reconnect_server.c
@@ -44,6 +44,7 @@
 #include "src/core/iomgr/sockaddr.h"
 #include "src/core/iomgr/tcp_server.h"
 #include "test/core/util/port.h"
+#include "test/core/util/test_tcp_server.h"
 
 static void pretty_print_backoffs(reconnect_server *server) {
   gpr_timespec diff;
@@ -102,49 +103,18 @@ static void on_connect(grpc_exec_ctx *exec_ctx, void *arg, grpc_endpoint *tcp) {
 }
 
 void reconnect_server_init(reconnect_server *server) {
-  grpc_init();
-  server->tcp_server = NULL;
-  grpc_pollset_init(&server->pollset);
-  server->pollsets[0] = &server->pollset;
+  test_tcp_server_init(&server->tcp_server, on_connect, server);
   server->head = NULL;
   server->tail = NULL;
   server->peer = NULL;
 }
 
 void reconnect_server_start(reconnect_server *server, int port) {
-  struct sockaddr_in addr;
-  grpc_tcp_listener *listener;
-  int port_added;
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-
-  addr.sin_family = AF_INET;
-  addr.sin_port = htons((gpr_uint16)port);
-  memset(&addr.sin_addr, 0, sizeof(addr.sin_addr));
-
-  server->tcp_server = grpc_tcp_server_create();
-  listener = 
-      grpc_tcp_server_add_port(server->tcp_server, &addr, sizeof(addr));
-  port_added = grpc_tcp_listener_get_port(listener);
-  GPR_ASSERT(port_added == port);
-
-  grpc_tcp_server_start(&exec_ctx, server->tcp_server, server->pollsets, 1,
-                        on_connect, server);
-  gpr_log(GPR_INFO, "reconnect tcp server listening on 0.0.0.0:%d", port);
-
-  grpc_exec_ctx_finish(&exec_ctx);
+  test_tcp_server_start(&server->tcp_server, port);
 }
 
 void reconnect_server_poll(reconnect_server *server, int seconds) {
-  grpc_pollset_worker worker;
-  gpr_timespec deadline =
-      gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
-                   gpr_time_from_seconds(seconds, GPR_TIMESPAN));
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  gpr_mu_lock(GRPC_POLLSET_MU(&server->pollset));
-  grpc_pollset_work(&exec_ctx, &server->pollset, &worker,
-                    gpr_now(GPR_CLOCK_MONOTONIC), deadline);
-  gpr_mu_unlock(GRPC_POLLSET_MU(&server->pollset));
-  grpc_exec_ctx_finish(&exec_ctx);
+  test_tcp_server_poll(&server->tcp_server, seconds);
 }
 
 void reconnect_server_clear_timestamps(reconnect_server *server) {
@@ -159,18 +129,7 @@ void reconnect_server_clear_timestamps(reconnect_server *server) {
   server->peer = NULL;
 }
 
-static void do_nothing(grpc_exec_ctx *exec_ctx, void *ignored, int success) {}
-
 void reconnect_server_destroy(reconnect_server *server) {
-  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
-  grpc_closure do_nothing_closure[2];
-  grpc_closure_init(&do_nothing_closure[0], do_nothing, NULL);
-  grpc_closure_init(&do_nothing_closure[1], do_nothing, NULL);
-  grpc_tcp_server_destroy(&exec_ctx, server->tcp_server,
-                          &do_nothing_closure[0]);
   reconnect_server_clear_timestamps(server);
-  grpc_pollset_shutdown(&exec_ctx, &server->pollset, &do_nothing_closure[1]);
-  grpc_exec_ctx_finish(&exec_ctx);
-  grpc_pollset_destroy(&server->pollset);
-  grpc_shutdown();
+  test_tcp_server_destroy(&server->tcp_server);
 }
diff --git a/test/core/util/reconnect_server.h b/test/core/util/reconnect_server.h
index 8a278e0c7a..e2e6a02461 100644
--- a/test/core/util/reconnect_server.h
+++ b/test/core/util/reconnect_server.h
@@ -36,7 +36,7 @@
 
 #include <grpc/support/sync.h>
 #include <grpc/support/time.h>
-#include "src/core/iomgr/tcp_server.h"
+#include "test/core/util/test_tcp_server.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -48,9 +48,7 @@ typedef struct timestamp_list {
 } timestamp_list;
 
 typedef struct reconnect_server {
-  grpc_tcp_server *tcp_server;
-  grpc_pollset pollset;
-  grpc_pollset *pollsets[1];
+  test_tcp_server tcp_server;
   timestamp_list *head;
   timestamp_list *tail;
   char *peer;
diff --git a/test/core/util/test_tcp_server.c b/test/core/util/test_tcp_server.c
new file mode 100644
index 0000000000..c700d3637f
--- /dev/null
+++ b/test/core/util/test_tcp_server.c
@@ -0,0 +1,120 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#include "test/core/util/test_tcp_server.h"
+
+#include <grpc/grpc.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/host_port.h>
+#include <grpc/support/log.h>
+#include <grpc/support/sync.h>
+#include <grpc/support/time.h>
+#include <string.h>
+#include "src/core/iomgr/endpoint.h"
+#include "src/core/iomgr/sockaddr.h"
+#include "src/core/iomgr/tcp_server.h"
+#include "test/core/util/port.h"
+
+void test_tcp_server_init(test_tcp_server *server,
+                          grpc_tcp_server_cb on_connect, void *user_data) {
+  grpc_init();
+  server->tcp_server = NULL;
+  server->shutdown = 0;
+  grpc_pollset_init(&server->pollset);
+  server->pollsets[0] = &server->pollset;
+  server->on_connect = on_connect;
+  server->cb_data = user_data;
+}
+
+void test_tcp_server_start(test_tcp_server *server, int port) {
+  struct sockaddr_in addr;
+  grpc_tcp_listener *listener;
+  int port_added;
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+
+  addr.sin_family = AF_INET;
+  addr.sin_port = htons((gpr_uint16)port);
+  memset(&addr.sin_addr, 0, sizeof(addr.sin_addr));
+
+  server->tcp_server = grpc_tcp_server_create();
+  listener = grpc_tcp_server_add_port(server->tcp_server, &addr, sizeof(addr));
+  port_added = grpc_tcp_listener_get_port(listener);
+  GPR_ASSERT(port_added == port);
+
+  grpc_tcp_server_start(&exec_ctx, server->tcp_server, server->pollsets, 1,
+                        server->on_connect, server->cb_data);
+  gpr_log(GPR_INFO, "test tcp server listening on 0.0.0.0:%d", port);
+
+  grpc_exec_ctx_finish(&exec_ctx);
+}
+
+void test_tcp_server_poll(test_tcp_server *server, int seconds) {
+  grpc_pollset_worker worker;
+  gpr_timespec deadline =
+      gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
+                   gpr_time_from_seconds(seconds, GPR_TIMESPAN));
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  gpr_mu_lock(GRPC_POLLSET_MU(&server->pollset));
+  grpc_pollset_work(&exec_ctx, &server->pollset, &worker,
+                    gpr_now(GPR_CLOCK_MONOTONIC), deadline);
+  gpr_mu_unlock(GRPC_POLLSET_MU(&server->pollset));
+  grpc_exec_ctx_finish(&exec_ctx);
+}
+
+static void on_server_destroyed(grpc_exec_ctx *exec_ctx, void *data,
+                                int success) {
+  test_tcp_server *server = data;
+  server->shutdown = 1;
+}
+
+static void do_nothing(grpc_exec_ctx *exec_ctx, void *arg, int success) {}
+
+void test_tcp_server_destroy(test_tcp_server *server) {
+  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
+  gpr_timespec shutdown_deadline;
+  grpc_closure server_shutdown_cb;
+  grpc_closure do_nothing_cb;
+  grpc_closure_init(&server_shutdown_cb, on_server_destroyed, server);
+  grpc_closure_init(&do_nothing_cb, do_nothing, NULL);
+  grpc_tcp_server_destroy(&exec_ctx, server->tcp_server, &server_shutdown_cb);
+  shutdown_deadline = gpr_time_add(gpr_now(GPR_CLOCK_MONOTONIC),
+                                   gpr_time_from_seconds(5, GPR_TIMESPAN));
+  while (!server->shutdown &&
+         gpr_time_cmp(gpr_now(GPR_CLOCK_MONOTONIC), shutdown_deadline) < 0) {
+    test_tcp_server_poll(server, 1);
+  }
+  grpc_pollset_shutdown(&exec_ctx, &server->pollset, &do_nothing_cb);
+  grpc_exec_ctx_finish(&exec_ctx);
+  grpc_pollset_destroy(&server->pollset);
+  grpc_shutdown();
+}
diff --git a/test/core/util/test_tcp_server.h b/test/core/util/test_tcp_server.h
new file mode 100644
index 0000000000..deb65eef11
--- /dev/null
+++ b/test/core/util/test_tcp_server.h
@@ -0,0 +1,55 @@
+/*
+ *
+ * Copyright 2015, Google Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+#ifndef GRPC_TEST_CORE_UTIL_TEST_TCP_SERVER_H
+#define GRPC_TEST_CORE_UTIL_TEST_TCP_SERVER_H
+
+#include <grpc/support/sync.h>
+#include "src/core/iomgr/tcp_server.h"
+
+typedef struct test_tcp_server {
+  grpc_tcp_server *tcp_server;
+  int shutdown;
+  grpc_pollset pollset;
+  grpc_pollset *pollsets[1];
+  grpc_tcp_server_cb on_connect;
+  void *cb_data;
+} test_tcp_server;
+
+void test_tcp_server_init(test_tcp_server *server,
+                          grpc_tcp_server_cb on_connect, void *user_data);
+void test_tcp_server_start(test_tcp_server *server, int port);
+void test_tcp_server_poll(test_tcp_server *server, int seconds);
+void test_tcp_server_destroy(test_tcp_server *server);
+
+#endif /* GRPC_TEST_CORE_UTIL_TEST_TCP_SERVER_H */
author	Craig Tiller <craig.tiller@gmail.com>	2015-11-25 15:32:59 -0800
committer	Craig Tiller <craig.tiller@gmail.com>	2015-11-25 15:32:59 -0800
commit	de83121308bfa816dd9c093a5d316af2ac46f422 (patch)
tree	20ba34affbfc460249e104bf3e6370c9f00e9046 /test/core
parent	6d3b229209a12437b7abf813b5dc74b64dc55876 (diff)
parent	945836eade7d8f12f6eb84bc209da13ae7c89b38 (diff)