int d4d_version ()
{
  int D.2254;

  D.2254 = 10;
  return D.2254;
}


int d4d_init (void * (*<T342>) (unsigned int) mallocer, void (*<Tee>) (void *) freeer)
{
  int D.2258;

  if (mallocer == 0B) goto <D.2256>; else goto <D.2257>;
  <D.2256>:
  D.2258 = -1;
  // predicted unlikely by early return (on trees) predictor.
  return D.2258;
  <D.2257>:
  if (freeer == 0B) goto <D.2259>; else goto <D.2260>;
  <D.2259>:
  D.2258 = -1;
  // predicted unlikely by early return (on trees) predictor.
  return D.2258;
  <D.2260>:
  _1 = mallocer (16);
  d4d__main = _1;
  d4d__main.0_2 = d4d__main;
  if (d4d__main.0_2 == 0B) goto <D.2261>; else goto <D.2262>;
  <D.2261>:
  D.2258 = -2;
  // predicted unlikely by early return (on trees) predictor.
  return D.2258;
  <D.2262>:
  d4d__main.1_3 = d4d__main;
  d4d__memzero (d4d__main.1_3, 16);
  d4d__main.2_4 = d4d__main;
  d4d__main.2_4->d4d__malloc = mallocer;
  d4d__main.3_5 = d4d__main;
  d4d__main.3_5->d4d__free = freeer;
  {
    struct splay_tree_s * spt;
    long long unsigned int n;
    struct splay_tree_node_s * spn;

    spt = 0B;
    n = 0;
    spn = 0B;
    spt = splay_tree_new (splay_tree_compare_ints, 0B, 0B);
    n = 0;
    goto <D.2087>;
    <D.2086>:
    spn = d4dag___splay_tree_insert (spt, n, 0);
    if (spn == 0B) goto <D.2263>; else goto <D.2264>;
    <D.2263>:
    <D.2264>:
    n = n + 1;
    <D.2087>:
    if (n <= 9) goto <D.2086>; else goto <D.2084>;
    <D.2084>:
    d4dag___splay_tree_delete (spt);
  }
  D.2258 = 0;
  return D.2258;
}


int d4d_deinit ()
{
  int D.2268;

  d4d__main.4_1 = d4d__main;
  if (d4d__main.4_1 == 0B) goto <D.2266>; else goto <D.2267>;
  <D.2266>:
  D.2268 = 0;
  // predicted unlikely by early return (on trees) predictor.
  return D.2268;
  <D.2267>:
  d4d__main.5_2 = d4d__main;
  _3 = d4d__main.5_2->d4d__free;
  d4d__main.6_4 = d4d__main;
  _3 (d4d__main.6_4);
  d4d__main = 0B;
  D.2268 = 0;
  return D.2268;
}


void d4d__memzero (void * ptr, unsigned int n)
{
  unsigned char * p;

  p = 0B;
  p = ptr;
  goto <D.2097>;
  <D.2098>:
  *p = 0;
  p = p + 1;
  n = n + 4294967295;
  <D.2097>:
  if (n != 0) goto <D.2098>; else goto <D.2096>;
  <D.2096>:
  return;
}


void splay_tree_delete_helper (struct splay_tree_s * sp, struct splay_tree_node_s * node)
{
  struct splay_tree_node_s * pending;
  struct splay_tree_node_s * active;

  pending = 0B;
  active = 0B;
  if (node == 0B) goto <D.2271>; else goto <D.2272>;
  <D.2271>:
  // predicted unlikely by early return (on trees) predictor.
  return;
  <D.2272>:
  _1 = sp->delete_key;
  if (_1 != 0B) goto <D.2273>; else goto <D.2274>;
  <D.2273>:
  _2 = sp->delete_key;
  _3 = node->key;
  _2 (_3);
  <D.2274>:
  _4 = sp->delete_value;
  if (_4 != 0B) goto <D.2275>; else goto <D.2276>;
  <D.2275>:
  _5 = sp->delete_value;
  _6 = node->value;
  _5 (_6);
  <D.2276>:
  pending.7_7 = (long long unsigned int) pending;
  node->key = pending.7_7;
  pending = node;
  goto <D.2107>;
  <D.2111>:
  active = pending;
  pending = 0B;
  goto <D.2109>;
  <D.2110>:
  {
    struct splay_tree_node_s * temp;

    temp = 0B;
    _8 = active->left;
    if (_8 != 0B) goto <D.2277>; else goto <D.2278>;
    <D.2277>:
    _9 = sp->delete_key;
    if (_9 != 0B) goto <D.2279>; else goto <D.2280>;
    <D.2279>:
    _10 = sp->delete_key;
    _11 = active->left;
    _12 = _11->key;
    _10 (_12);
    <D.2280>:
    _13 = sp->delete_value;
    if (_13 != 0B) goto <D.2281>; else goto <D.2282>;
    <D.2281>:
    _14 = sp->delete_value;
    _15 = active->left;
    _16 = _15->value;
    _14 (_16);
    <D.2282>:
    _17 = active->left;
    pending.8_18 = (long long unsigned int) pending;
    _17->key = pending.8_18;
    pending = active->left;
    <D.2278>:
    _19 = active->right;
    if (_19 != 0B) goto <D.2283>; else goto <D.2284>;
    <D.2283>:
    _20 = sp->delete_key;
    if (_20 != 0B) goto <D.2285>; else goto <D.2286>;
    <D.2285>:
    _21 = sp->delete_key;
    _22 = active->right;
    _23 = _22->key;
    _21 (_23);
    <D.2286>:
    _24 = sp->delete_value;
    if (_24 != 0B) goto <D.2287>; else goto <D.2288>;
    <D.2287>:
    _25 = sp->delete_value;
    _26 = active->right;
    _27 = _26->value;
    _25 (_27);
    <D.2288>:
    _28 = active->right;
    pending.9_29 = (long long unsigned int) pending;
    _28->key = pending.9_29;
    pending = active->right;
    <D.2284>:
    temp = active;
    _30 = temp->key;
    active = (struct splay_tree_node_s *) _30;
    _31 = sp->deallocate;
    _32 = sp->allocate_data;
    _31 (temp, _32);
  }
  <D.2109>:
  if (active != 0B) goto <D.2110>; else goto <D.2108>;
  <D.2108>:
  <D.2107>:
  if (pending != 0B) goto <D.2111>; else goto <D.2106>;
  <D.2106>:
  return;
}


void rotate_left (struct splay_tree_node_s * * pp, struct splay_tree_node_s * p, struct splay_tree_node_s * n)
{
  struct splay_tree_node_s * tmp;

  tmp = 0B;
  tmp = n->right;
  n->right = p;
  p->left = tmp;
  *pp = n;
  return;
}


void rotate_right (struct splay_tree_node_s * * pp, struct splay_tree_node_s * p, struct splay_tree_node_s * n)
{
  struct splay_tree_node_s * tmp;

  tmp = 0B;
  tmp = n->left;
  n->left = p;
  p->right = tmp;
  *pp = n;
  return;
}


void splay_tree_splay (struct splay_tree_s * sp, splay_tree_key key)
{
  int cmp1;
  int cmp2;
  struct splay_tree_node_s * n;
  struct splay_tree_node_s * c;

  cmp1 = 0;
  cmp2 = 0;
  n = 0B;
  c = 0B;
  _1 = sp->root;
  if (_1 == 0B) goto <D.2292>; else goto <D.2293>;
  <D.2292>:
  // predicted unlikely by early return (on trees) predictor.
  return;
  <D.2293>:
  <D.2134>:
  n = sp->root;
  _2 = sp->comp;
  _3 = n->key;
  cmp1 = _2 (key, _3);
  if (cmp1 == 0) goto <D.2294>; else goto <D.2295>;
  <D.2294>:
  // predicted unlikely by early return (on trees) predictor.
  return;
  <D.2295>:
  if (cmp1 < 0) goto <D.2296>; else goto <D.2297>;
  <D.2296>:
  c = n->left;
  goto <D.2298>;
  <D.2297>:
  c = n->right;
  <D.2298>:
  if (c == 0B) goto <D.2299>; else goto <D.2300>;
  <D.2299>:
  // predicted unlikely by early return (on trees) predictor.
  return;
  <D.2300>:
  _4 = sp->comp;
  _5 = c->key;
  cmp2 = _4 (key, _5);
  if (cmp2 == 0) goto <D.2301>; else goto <D.2304>;
  <D.2304>:
  if (cmp2 < 0) goto <D.2305>; else goto <D.2302>;
  <D.2305>:
  _6 = c->left;
  if (_6 == 0B) goto <D.2301>; else goto <D.2302>;
  <D.2302>:
  if (cmp2 > 0) goto <D.2306>; else goto <D.2303>;
  <D.2306>:
  _7 = c->right;
  if (_7 == 0B) goto <D.2301>; else goto <D.2303>;
  <D.2301>:
  if (cmp1 < 0) goto <D.2307>; else goto <D.2308>;
  <D.2307>:
  _8 = &sp->root;
  rotate_left (_8, n, c);
  goto <D.2309>;
  <D.2308>:
  _9 = &sp->root;
  rotate_right (_9, n, c);
  <D.2309>:
  // predicted unlikely by early return (on trees) predictor.
  return;
  <D.2303>:
  if (cmp1 < 0) goto <D.2312>; else goto <D.2310>;
  <D.2312>:
  if (cmp2 < 0) goto <D.2313>; else goto <D.2310>;
  <D.2313>:
  _10 = c->left;
  _11 = &n->left;
  rotate_left (_11, c, _10);
  _12 = n->left;
  _13 = &sp->root;
  rotate_left (_13, n, _12);
  goto <D.2311>;
  <D.2310>:
  if (cmp1 > 0) goto <D.2316>; else goto <D.2314>;
  <D.2316>:
  if (cmp2 > 0) goto <D.2317>; else goto <D.2314>;
  <D.2317>:
  _14 = c->right;
  _15 = &n->right;
  rotate_right (_15, c, _14);
  _16 = n->right;
  _17 = &sp->root;
  rotate_right (_17, n, _16);
  goto <D.2315>;
  <D.2314>:
  if (cmp1 < 0) goto <D.2320>; else goto <D.2318>;
  <D.2320>:
  if (cmp2 > 0) goto <D.2321>; else goto <D.2318>;
  <D.2321>:
  _18 = c->right;
  _19 = &n->left;
  rotate_right (_19, c, _18);
  _20 = n->left;
  _21 = &sp->root;
  rotate_left (_21, n, _20);
  goto <D.2319>;
  <D.2318>:
  if (cmp1 > 0) goto <D.2322>; else goto <D.2323>;
  <D.2322>:
  if (cmp2 < 0) goto <D.2324>; else goto <D.2325>;
  <D.2324>:
  _22 = c->left;
  _23 = &n->right;
  rotate_left (_23, c, _22);
  _24 = n->right;
  _25 = &sp->root;
  rotate_right (_25, n, _24);
  goto <D.2326>;
  <D.2325>:
  <D.2326>:
  <D.2323>:
  <D.2319>:
  <D.2315>:
  <D.2311>:
  goto <D.2134>;
  return;
}


void * splay_tree_xmalloc_allocate (unsigned int size, void * data)
{
  void * D.2330;
  void * ret;

  ret = 0B;
  if (data != 0B) goto <D.2328>; else goto <D.2329>;
  <D.2328>:
  <D.2329>:
  d4d__main.10_1 = d4d__main;
  _2 = d4d__main.10_1->d4d__malloc;
  ret = _2 (size);
  d4d__memzero (ret, size);
  D.2330 = ret;
  return D.2330;
}


void splay_tree_xmalloc_deallocate (void * object, void * data)
{
  if (object != 0B) goto <D.2332>; else goto <D.2333>;
  <D.2332>:
  d4d__main.11_1 = d4d__main;
  _2 = d4d__main.11_1->d4d__free;
  _2 (object);
  <D.2333>:
  if (data != 0B) goto <D.2334>; else goto <D.2335>;
  <D.2334>:
  <D.2335>:
  return;
}


struct splay_tree_s * splay_tree_new (int (*splay_tree_compare_fn) (splay_tree_key, splay_tree_key) compare_fn, void (*splay_tree_delete_key_fn) (splay_tree_key) delete_key_fn, void (*splay_tree_delete_value_fn) (splay_tree_value) delete_value_fn)
{
  struct splay_tree_s * D.2337;

  D.2337 = splay_tree_new_with_allocator (compare_fn, delete_key_fn, delete_value_fn, splay_tree_xmalloc_allocate, splay_tree_xmalloc_deallocate, 0B);
  return D.2337;
}


struct splay_tree_s * splay_tree_new_with_allocator (int (*splay_tree_compare_fn) (splay_tree_key, splay_tree_key) compare_fn, void (*splay_tree_delete_key_fn) (splay_tree_key) delete_key_fn, void (*splay_tree_delete_value_fn) (splay_tree_value) delete_value_fn, void * (*splay_tree_allocate_fn) (unsigned int, void *) allocate_fn, void (*splay_tree_deallocate_fn) (void *, void *) deallocate_fn, void * allocate_data)
{
  struct splay_tree_s * D.2339;

  D.2339 = splay_tree_new_typed_alloc (compare_fn, delete_key_fn, delete_value_fn, allocate_fn, allocate_fn, deallocate_fn, allocate_data);
  return D.2339;
}


struct splay_tree_s * splay_tree_new_typed_alloc (int (*splay_tree_compare_fn) (splay_tree_key, splay_tree_key) compare_fn, void (*splay_tree_delete_key_fn) (splay_tree_key) delete_key_fn, void (*splay_tree_delete_value_fn) (splay_tree_value) delete_value_fn, void * (*splay_tree_allocate_fn) (unsigned int, void *) tree_allocate_fn, void * (*splay_tree_allocate_fn) (unsigned int, void *) node_allocate_fn, void (*splay_tree_deallocate_fn) (void *, void *) deallocate_fn, void * allocate_data)
{
  struct splay_tree_s * D.2341;
  struct splay_tree_s * sp;

  sp = tree_allocate_fn (56, allocate_data);
  sp->root = 0B;
  sp->comp = compare_fn;
  sp->delete_key = delete_key_fn;
  sp->delete_value = delete_value_fn;
  sp->allocate = node_allocate_fn;
  sp->deallocate = deallocate_fn;
  sp->allocate_data = allocate_data;
  D.2341 = sp;
  return D.2341;
}


void d4dag___splay_tree_delete (struct splay_tree_s * sp)
{
  _1 = sp->root;
  splay_tree_delete_helper (sp, _1);
  _2 = sp->deallocate;
  _3 = sp->allocate_data;
  _2 (sp, _3);
  return;
}


struct splay_tree_node_s * d4dag___splay_tree_insert (struct splay_tree_s * sp, splay_tree_key key, splay_tree_value value)
{
  struct splay_tree_node_s * D.2360;
  int comparison;
  struct splay_tree_node_s * node;

  comparison = 0;
  node = 0B;
  splay_tree_splay (sp, key);
  _1 = sp->root;
  if (_1 != 0B) goto <D.2344>; else goto <D.2345>;
  <D.2344>:
  _2 = sp->comp;
  _3 = sp->root;
  _4 = _3->key;
  comparison = _2 (_4, key);
  <D.2345>:
  _5 = sp->root;
  if (_5 != 0B) goto <D.2348>; else goto <D.2346>;
  <D.2348>:
  if (comparison == 0) goto <D.2349>; else goto <D.2346>;
  <D.2349>:
  _6 = sp->delete_key;
  if (_6 != 0B) goto <D.2350>; else goto <D.2351>;
  <D.2350>:
  _7 = sp->delete_key;
  _8 = sp->root;
  _9 = _8->key;
  _7 (_9);
  <D.2351>:
  _10 = sp->delete_value;
  if (_10 != 0B) goto <D.2352>; else goto <D.2353>;
  <D.2352>:
  _11 = sp->delete_value;
  _12 = sp->root;
  _13 = _12->value;
  _11 (_13);
  <D.2353>:
  _14 = sp->root;
  _14->key = key;
  _15 = sp->root;
  _15->value = value;
  goto <D.2347>;
  <D.2346>:
  _16 = sp->allocate;
  _17 = sp->allocate_data;
  node = _16 (32, _17);
  node->key = key;
  node->value = value;
  _18 = sp->root;
  if (_18 == 0B) goto <D.2354>; else goto <D.2355>;
  <D.2354>:
  node->left = 0B;
  node->right = 0B;
  goto <D.2356>;
  <D.2355>:
  if (comparison < 0) goto <D.2357>; else goto <D.2358>;
  <D.2357>:
  _19 = sp->root;
  node->left = _19;
  _20 = node->left;
  _21 = _20->right;
  node->right = _21;
  _22 = node->left;
  _22->right = 0B;
  goto <D.2359>;
  <D.2358>:
  _23 = sp->root;
  node->right = _23;
  _24 = node->right;
  _25 = _24->left;
  node->left = _25;
  _26 = node->right;
  _26->left = 0B;
  <D.2359>:
  <D.2356>:
  sp->root = node;
  <D.2347>:
  D.2360 = sp->root;
  return D.2360;
}


void d4dag___splay_tree_remove (struct splay_tree_s * sp, splay_tree_key key)
{
  struct splay_tree_node_s * left;
  struct splay_tree_node_s * right;

  left = 0B;
  right = 0B;
  splay_tree_splay (sp, key);
  _1 = sp->root;
  if (_1 != 0B) goto <D.2362>; else goto <D.2363>;
  <D.2362>:
  _2 = sp->comp;
  _3 = sp->root;
  _4 = _3->key;
  _5 = _2 (_4, key);
  if (_5 == 0) goto <D.2364>; else goto <D.2365>;
  <D.2364>:
  _6 = sp->root;
  left = _6->left;
  _7 = sp->root;
  right = _7->right;
  _8 = sp->delete_key;
  if (_8 != 0B) goto <D.2366>; else goto <D.2367>;
  <D.2366>:
  _9 = sp->delete_key;
  _10 = sp->root;
  _11 = _10->key;
  _9 (_11);
  <D.2367>:
  _12 = sp->delete_value;
  if (_12 != 0B) goto <D.2368>; else goto <D.2369>;
  <D.2368>:
  _13 = sp->delete_value;
  _14 = sp->root;
  _15 = _14->value;
  _13 (_15);
  <D.2369>:
  _16 = sp->deallocate;
  _17 = sp->allocate_data;
  _18 = sp->root;
  _16 (_18, _17);
  if (left != 0B) goto <D.2370>; else goto <D.2371>;
  <D.2370>:
  sp->root = left;
  if (right != 0B) goto <D.2372>; else goto <D.2373>;
  <D.2372>:
  goto <D.2184>;
  <D.2185>:
  left = left->right;
  <D.2184>:
  _19 = left->right;
  if (_19 != 0B) goto <D.2185>; else goto <D.2183>;
  <D.2183>:
  left->right = right;
  <D.2373>:
  goto <D.2374>;
  <D.2371>:
  sp->root = right;
  <D.2374>:
  <D.2365>:
  <D.2363>:
  return;
}


struct splay_tree_node_s * splay_tree_lookup (struct splay_tree_s * sp, splay_tree_key key)
{
  struct splay_tree_node_s * D.2379;

  splay_tree_splay (sp, key);
  _1 = sp->root;
  if (_1 != 0B) goto <D.2377>; else goto <D.2376>;
  <D.2377>:
  _2 = sp->comp;
  _3 = sp->root;
  _4 = _3->key;
  _5 = _2 (_4, key);
  if (_5 == 0) goto <D.2378>; else goto <D.2376>;
  <D.2378>:
  D.2379 = sp->root;
  // predicted unlikely by early return (on trees) predictor.
  return D.2379;
  <D.2376>:
  D.2379 = 0B;
  // predicted unlikely by early return (on trees) predictor.
  return D.2379;
}


struct splay_tree_node_s * splay_tree_max (struct splay_tree_s * sp)
{
  struct splay_tree_node_s * D.2383;
  struct splay_tree_node_s * n;

  n = sp->root;
  if (n == 0B) goto <D.2381>; else goto <D.2382>;
  <D.2381>:
  D.2383 = 0B;
  // predicted unlikely by early return (on trees) predictor.
  return D.2383;
  <D.2382>:
  goto <D.2195>;
  <D.2196>:
  n = n->right;
  <D.2195>:
  _1 = n->right;
  if (_1 != 0B) goto <D.2196>; else goto <D.2194>;
  <D.2194>:
  D.2383 = n;
  return D.2383;
}


struct splay_tree_node_s * d4dag___splay_tree_min (struct splay_tree_s * sp)
{
  struct splay_tree_node_s * D.2387;
  struct splay_tree_node_s * n;

  n = 0B;
  if (sp == 0B) goto <D.2385>; else goto <D.2386>;
  <D.2385>:
  D.2387 = 0B;
  // predicted unlikely by early return (on trees) predictor.
  return D.2387;
  <D.2386>:
  n = sp->root;
  if (n == 0B) goto <D.2388>; else goto <D.2389>;
  <D.2388>:
  D.2387 = 0B;
  // predicted unlikely by early return (on trees) predictor.
  return D.2387;
  <D.2389>:
  goto <D.2202>;
  <D.2203>:
  n = n->left;
  <D.2202>:
  _1 = n->left;
  if (_1 != 0B) goto <D.2203>; else goto <D.2201>;
  <D.2201>:
  D.2387 = n;
  return D.2387;
}


struct splay_tree_node_s * d4dag___splay_tree_predecessor (struct splay_tree_s * sp, splay_tree_key key)
{
  struct splay_tree_node_s * D.2393;
  int comparison;
  struct splay_tree_node_s * node;

  comparison = 0;
  node = 0B;
  if (sp == 0B) goto <D.2391>; else goto <D.2392>;
  <D.2391>:
  D.2393 = 0B;
  // predicted unlikely by early return (on trees) predictor.
  return D.2393;
  <D.2392>:
  _1 = sp->root;
  if (_1 == 0B) goto <D.2394>; else goto <D.2395>;
  <D.2394>:
  D.2393 = 0B;
  // predicted unlikely by early return (on trees) predictor.
  return D.2393;
  <D.2395>:
  splay_tree_splay (sp, key);
  _2 = sp->comp;
  _3 = sp->root;
  _4 = _3->key;
  comparison = _2 (_4, key);
  if (comparison < 0) goto <D.2396>; else goto <D.2397>;
  <D.2396>:
  D.2393 = sp->root;
  // predicted unlikely by early return (on trees) predictor.
  return D.2393;
  <D.2397>:
  _5 = sp->root;
  node = _5->left;
  if (node != 0B) goto <D.2398>; else goto <D.2399>;
  <D.2398>:
  goto <D.2211>;
  <D.2212>:
  node = node->right;
  <D.2211>:
  _6 = node->right;
  if (_6 != 0B) goto <D.2212>; else goto <D.2210>;
  <D.2210>:
  <D.2399>:
  D.2393 = node;
  return D.2393;
}


struct splay_tree_node_s * splay_tree_successor (struct splay_tree_s * sp, splay_tree_key key)
{
  struct splay_tree_node_s * D.2403;
  int comparison;
  struct splay_tree_node_s * node;

  comparison = 0;
  node = 0B;
  _1 = sp->root;
  if (_1 == 0B) goto <D.2401>; else goto <D.2402>;
  <D.2401>:
  D.2403 = 0B;
  // predicted unlikely by early return (on trees) predictor.
  return D.2403;
  <D.2402>:
  splay_tree_splay (sp, key);
  _2 = sp->comp;
  _3 = sp->root;
  _4 = _3->key;
  comparison = _2 (_4, key);
  if (comparison > 0) goto <D.2404>; else goto <D.2405>;
  <D.2404>:
  D.2403 = sp->root;
  // predicted unlikely by early return (on trees) predictor.
  return D.2403;
  <D.2405>:
  _5 = sp->root;
  node = _5->right;
  if (node != 0B) goto <D.2406>; else goto <D.2407>;
  <D.2406>:
  goto <D.2220>;
  <D.2221>:
  node = node->left;
  <D.2220>:
  _6 = node->left;
  if (_6 != 0B) goto <D.2221>; else goto <D.2219>;
  <D.2219>:
  <D.2407>:
  D.2403 = node;
  return D.2403;
}


int splay_tree_foreach (struct splay_tree_s * sp, int (*splay_tree_foreach_fn) (struct splay_tree_node_s *, void *) fn, void * data)
{
  int D.2411;
  struct splay_tree_node_s * spn;
  splay_tree_key key;
  int val;

  spn = 0B;
  key = 0;
  val = 0;
  if (sp == 0B) goto <D.2409>; else goto <D.2410>;
  <D.2409>:
  D.2411 = 0;
  // predicted unlikely by early return (on trees) predictor.
  return D.2411;
  <D.2410>:
  _1 = sp->root;
  if (_1 == 0B) goto <D.2412>; else goto <D.2413>;
  <D.2412>:
  D.2411 = 0;
  // predicted unlikely by early return (on trees) predictor.
  return D.2411;
  <D.2413>:
  val = 0;
  spn = d4dag___splay_tree_min (sp);
  goto <D.2231>;
  <D.2232>:
  key = spn->key;
  val = fn (spn, data);
  if (val != 0) goto <D.2414>; else goto <D.2415>;
  <D.2414>:
  goto <D.2230>;
  <D.2415>:
  spn = splay_tree_successor (sp, key);
  <D.2231>:
  if (spn != 0B) goto <D.2232>; else goto <D.2230>;
  <D.2230>:
  D.2411 = val;
  return D.2411;
}


int splay_tree_compare_ints (splay_tree_key k1, splay_tree_key k2)
{
  int D.2419;

  _1 = (int) k1;
  _2 = (int) k2;
  if (_1 < _2) goto <D.2417>; else goto <D.2418>;
  <D.2417>:
  D.2419 = -1;
  // predicted unlikely by early return (on trees) predictor.
  return D.2419;
  <D.2418>:
  _3 = (int) k1;
  _4 = (int) k2;
  if (_3 > _4) goto <D.2420>; else goto <D.2421>;
  <D.2420>:
  D.2419 = 1;
  // predicted unlikely by early return (on trees) predictor.
  return D.2419;
  <D.2421>:
  D.2419 = 0;
  // predicted unlikely by early return (on trees) predictor.
  return D.2419;
}


int splay_tree_compare_pointers (splay_tree_key k1, splay_tree_key k2)
{
  int D.2425;

  k1.12_1 = (char *) k1;
  k2.13_2 = (char *) k2;
  if (k1.12_1 < k2.13_2) goto <D.2423>; else goto <D.2424>;
  <D.2423>:
  D.2425 = -1;
  // predicted unlikely by early return (on trees) predictor.
  return D.2425;
  <D.2424>:
  k1.14_3 = (char *) k1;
  k2.15_4 = (char *) k2;
  if (k1.14_3 > k2.15_4) goto <D.2426>; else goto <D.2427>;
  <D.2426>:
  D.2425 = 1;
  // predicted unlikely by early return (on trees) predictor.
  return D.2425;
  <D.2427>:
  D.2425 = 0;
  // predicted unlikely by early return (on trees) predictor.
  return D.2425;
}


int splay_tree_compare_strings (splay_tree_key k1, splay_tree_key k2)
{
  int D.2430;
  char * s1;
  char * s2;

  s1 = (char *) k1;
  s2 = (char *) k2;
  goto <D.2248>;
  <D.2249>:
  s1 = s1 + 1;
  s2 = s2 + 1;
  <D.2248>:
  _1 = *s1;
  if (_1 != 0) goto <D.2429>; else goto <D.2247>;
  <D.2429>:
  _2 = *s1;
  _3 = *s2;
  if (_2 == _3) goto <D.2249>; else goto <D.2247>;
  <D.2247>:
  _4 = *s1;
  _5 = (int) _4;
  _6 = *s2;
  _7 = (int) _6;
  D.2430 = _5 - _7;
  return D.2430;
}


void splay_tree_delete_pointers (splay_tree_value value)
{
  if (value != 0) goto <D.2432>; else goto <D.2433>;
  <D.2432>:
  d4d__main.16_1 = d4d__main;
  _2 = d4d__main.16_1->d4d__free;
  value.17_3 = (void *) value;
  _2 (value.17_3);
  <D.2433>:
  return;
}


