gee/concurrentset.c

   1 /* concurrentset.c generated by valac 0.18.0, the Vala compiler
   2  * generated from concurrentset.vala, do not modify */
   3
   4 /* concurrentset.vala
   5  *
   6  * Copyright (C) 2012  Maciej Piechotka
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  21  *
  22  * Author:
  23  *      Maciej Piechotka <uzytkownik2@gmail.com>
  24  */
  25
  26 #include <glib.h>
  27 #include <glib-object.h>
  28 #include <string.h>
  29 #include <gobject/gvaluecollector.h>
  30
  31
  32 #define GEE_TYPE_TRAVERSABLE (gee_traversable_get_type ())
  33 #define GEE_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversable))
  34 #define GEE_IS_TRAVERSABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_TRAVERSABLE))
  35 #define GEE_TRAVERSABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_TRAVERSABLE, GeeTraversableIface))
  36
  37 typedef struct _GeeTraversable GeeTraversable;
  38 typedef struct _GeeTraversableIface GeeTraversableIface;
  39
  40 #define GEE_TRAVERSABLE_TYPE_STREAM (gee_traversable_stream_get_type ())
  41
  42 #define GEE_TYPE_LAZY (gee_lazy_get_type ())
  43 #define GEE_LAZY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_LAZY, GeeLazy))
  44 #define GEE_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_LAZY, GeeLazyClass))
  45 #define GEE_IS_LAZY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_LAZY))
  46 #define GEE_IS_LAZY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_LAZY))
  47 #define GEE_LAZY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_LAZY, GeeLazyClass))
  48
  49 typedef struct _GeeLazy GeeLazy;
  50 typedef struct _GeeLazyClass GeeLazyClass;
  51
  52 #define GEE_TYPE_ITERATOR (gee_iterator_get_type ())
  53 #define GEE_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERATOR, GeeIterator))
  54 #define GEE_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERATOR))
  55 #define GEE_ITERATOR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERATOR, GeeIteratorIface))
  56
  57 typedef struct _GeeIterator GeeIterator;
  58 typedef struct _GeeIteratorIface GeeIteratorIface;
  59
  60 #define GEE_TYPE_ITERABLE (gee_iterable_get_type ())
  61 #define GEE_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ITERABLE, GeeIterable))
  62 #define GEE_IS_ITERABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ITERABLE))
  63 #define GEE_ITERABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_ITERABLE, GeeIterableIface))
  64
  65 typedef struct _GeeIterable GeeIterable;
  66 typedef struct _GeeIterableIface GeeIterableIface;
  67
  68 #define GEE_TYPE_COLLECTION (gee_collection_get_type ())
  69 #define GEE_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_COLLECTION, GeeCollection))
  70 #define GEE_IS_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_COLLECTION))
  71 #define GEE_COLLECTION_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_COLLECTION, GeeCollectionIface))
  72
  73 typedef struct _GeeCollection GeeCollection;
  74 typedef struct _GeeCollectionIface GeeCollectionIface;
  75
  76 #define GEE_TYPE_ABSTRACT_COLLECTION (gee_abstract_collection_get_type ())
  77 #define GEE_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollection))
  78 #define GEE_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  79 #define GEE_IS_ABSTRACT_COLLECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_COLLECTION))
  80 #define GEE_IS_ABSTRACT_COLLECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_COLLECTION))
  81 #define GEE_ABSTRACT_COLLECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_COLLECTION, GeeAbstractCollectionClass))
  82
  83 typedef struct _GeeAbstractCollection GeeAbstractCollection;
  84 typedef struct _GeeAbstractCollectionClass GeeAbstractCollectionClass;
  85 typedef struct _GeeAbstractCollectionPrivate GeeAbstractCollectionPrivate;
  86
  87 #define GEE_TYPE_SET (gee_set_get_type ())
  88 #define GEE_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_SET, GeeSet))
  89 #define GEE_IS_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_SET))
  90 #define GEE_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_SET, GeeSetIface))
  91
  92 typedef struct _GeeSet GeeSet;
  93 typedef struct _GeeSetIface GeeSetIface;
  94
  95 #define GEE_TYPE_ABSTRACT_SET (gee_abstract_set_get_type ())
  96 #define GEE_ABSTRACT_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_SET, GeeAbstractSet))
  97 #define GEE_ABSTRACT_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_SET, GeeAbstractSetClass))
  98 #define GEE_IS_ABSTRACT_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_SET))
  99 #define GEE_IS_ABSTRACT_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_SET))
 100 #define GEE_ABSTRACT_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_SET, GeeAbstractSetClass))
 101
 102 typedef struct _GeeAbstractSet GeeAbstractSet;
 103 typedef struct _GeeAbstractSetClass GeeAbstractSetClass;
 104 typedef struct _GeeAbstractSetPrivate GeeAbstractSetPrivate;
 105
 106 #define GEE_TYPE_SORTED_SET (gee_sorted_set_get_type ())
 107 #define GEE_SORTED_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_SORTED_SET, GeeSortedSet))
 108 #define GEE_IS_SORTED_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_SORTED_SET))
 109 #define GEE_SORTED_SET_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), GEE_TYPE_SORTED_SET, GeeSortedSetIface))
 110
 111 typedef struct _GeeSortedSet GeeSortedSet;
 112 typedef struct _GeeSortedSetIface GeeSortedSetIface;
 113
 114 #define GEE_TYPE_ABSTRACT_SORTED_SET (gee_abstract_sorted_set_get_type ())
 115 #define GEE_ABSTRACT_SORTED_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_ABSTRACT_SORTED_SET, GeeAbstractSortedSet))
 116 #define GEE_ABSTRACT_SORTED_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_ABSTRACT_SORTED_SET, GeeAbstractSortedSetClass))
 117 #define GEE_IS_ABSTRACT_SORTED_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_ABSTRACT_SORTED_SET))
 118 #define GEE_IS_ABSTRACT_SORTED_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_ABSTRACT_SORTED_SET))
 119 #define GEE_ABSTRACT_SORTED_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_ABSTRACT_SORTED_SET, GeeAbstractSortedSetClass))
 120
 121 typedef struct _GeeAbstractSortedSet GeeAbstractSortedSet;
 122 typedef struct _GeeAbstractSortedSetClass GeeAbstractSortedSetClass;
 123 typedef struct _GeeAbstractSortedSetPrivate GeeAbstractSortedSetPrivate;
 124
 125 #define GEE_TYPE_CONCURRENT_SET (gee_concurrent_set_get_type ())
 126 #define GEE_CONCURRENT_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_TYPE_CONCURRENT_SET, GeeConcurrentSet))
 127 #define GEE_CONCURRENT_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_TYPE_CONCURRENT_SET, GeeConcurrentSetClass))
 128 #define GEE_IS_CONCURRENT_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_TYPE_CONCURRENT_SET))
 129 #define GEE_IS_CONCURRENT_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_TYPE_CONCURRENT_SET))
 130 #define GEE_CONCURRENT_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_TYPE_CONCURRENT_SET, GeeConcurrentSetClass))
 131
 132 typedef struct _GeeConcurrentSet GeeConcurrentSet;
 133 typedef struct _GeeConcurrentSetClass GeeConcurrentSetClass;
 134 typedef struct _GeeConcurrentSetPrivate GeeConcurrentSetPrivate;
 135
 136 #define GEE_CONCURRENT_SET_TYPE_TOWER (gee_concurrent_set_tower_get_type ())
 137 #define GEE_CONCURRENT_SET_TOWER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_CONCURRENT_SET_TYPE_TOWER, GeeConcurrentSetTower))
 138 #define GEE_CONCURRENT_SET_TOWER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_CONCURRENT_SET_TYPE_TOWER, GeeConcurrentSetTowerClass))
 139 #define GEE_CONCURRENT_SET_IS_TOWER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_CONCURRENT_SET_TYPE_TOWER))
 140 #define GEE_CONCURRENT_SET_IS_TOWER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_CONCURRENT_SET_TYPE_TOWER))
 141 #define GEE_CONCURRENT_SET_TOWER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_CONCURRENT_SET_TYPE_TOWER, GeeConcurrentSetTowerClass))
 142
 143 typedef struct _GeeConcurrentSetTower GeeConcurrentSetTower;
 144 typedef struct _GeeConcurrentSetTowerClass GeeConcurrentSetTowerClass;
 145
 146 #define GEE_HAZARD_POINTER_TYPE_POLICY (gee_hazard_pointer_policy_get_type ())
 147 typedef struct _GeeHazardPointerContext GeeHazardPointerContext;
 148 #define _gee_concurrent_set_tower_unref0(var) ((var == NULL) ? NULL : (var = (gee_concurrent_set_tower_unref (var), NULL)))
 149 #define _gee_hazard_pointer_context_free0(var) ((var == NULL) ? NULL : (var = (gee_hazard_pointer_context_free (var), NULL)))
 150
 151 #define GEE_CONCURRENT_SET_TYPE_RANGE_TYPE (gee_concurrent_set_range_type_get_type ())
 152
 153 #define GEE_CONCURRENT_SET_TYPE_STATE (gee_concurrent_set_state_get_type ())
 154
 155 #define GEE_CONCURRENT_SET_TYPE_ITERATOR (gee_concurrent_set_iterator_get_type ())
 156 #define GEE_CONCURRENT_SET_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_CONCURRENT_SET_TYPE_ITERATOR, GeeConcurrentSetIterator))
 157 #define GEE_CONCURRENT_SET_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_CONCURRENT_SET_TYPE_ITERATOR, GeeConcurrentSetIteratorClass))
 158 #define GEE_CONCURRENT_SET_IS_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_CONCURRENT_SET_TYPE_ITERATOR))
 159 #define GEE_CONCURRENT_SET_IS_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_CONCURRENT_SET_TYPE_ITERATOR))
 160 #define GEE_CONCURRENT_SET_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_CONCURRENT_SET_TYPE_ITERATOR, GeeConcurrentSetIteratorClass))
 161
 162 typedef struct _GeeConcurrentSetIterator GeeConcurrentSetIterator;
 163 typedef struct _GeeConcurrentSetIteratorClass GeeConcurrentSetIteratorClass;
 164
 165 #define GEE_CONCURRENT_SET_TYPE_TOWER_ITER (gee_concurrent_set_tower_iter_get_type ())
 166 typedef struct _GeeConcurrentSetTowerIter GeeConcurrentSetTowerIter;
 167 typedef struct _GeeConcurrentSetTowerPrivate GeeConcurrentSetTowerPrivate;
 168
 169 #define GEE_CONCURRENT_SET_TYPE_TOWER_NODE (gee_concurrent_set_tower_node_get_type ())
 170 typedef struct _GeeConcurrentSetTowerNode GeeConcurrentSetTowerNode;
 171
 172 #define GEE_CONCURRENT_SET_TYPE_RANGE (gee_concurrent_set_range_get_type ())
 173 #define GEE_CONCURRENT_SET_RANGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_CONCURRENT_SET_TYPE_RANGE, GeeConcurrentSetRange))
 174 #define GEE_CONCURRENT_SET_RANGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_CONCURRENT_SET_TYPE_RANGE, GeeConcurrentSetRangeClass))
 175 #define GEE_CONCURRENT_SET_IS_RANGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_CONCURRENT_SET_TYPE_RANGE))
 176 #define GEE_CONCURRENT_SET_IS_RANGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_CONCURRENT_SET_TYPE_RANGE))
 177 #define GEE_CONCURRENT_SET_RANGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_CONCURRENT_SET_TYPE_RANGE, GeeConcurrentSetRangeClass))
 178
 179 typedef struct _GeeConcurrentSetRange GeeConcurrentSetRange;
 180 typedef struct _GeeConcurrentSetRangeClass GeeConcurrentSetRangeClass;
 181
 182 #define GEE_CONCURRENT_SET_TYPE_SUB_SET (gee_concurrent_set_sub_set_get_type ())
 183 #define GEE_CONCURRENT_SET_SUB_SET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_CONCURRENT_SET_TYPE_SUB_SET, GeeConcurrentSetSubSet))
 184 #define GEE_CONCURRENT_SET_SUB_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_CONCURRENT_SET_TYPE_SUB_SET, GeeConcurrentSetSubSetClass))
 185 #define GEE_CONCURRENT_SET_IS_SUB_SET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_CONCURRENT_SET_TYPE_SUB_SET))
 186 #define GEE_CONCURRENT_SET_IS_SUB_SET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_CONCURRENT_SET_TYPE_SUB_SET))
 187 #define GEE_CONCURRENT_SET_SUB_SET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_CONCURRENT_SET_TYPE_SUB_SET, GeeConcurrentSetSubSetClass))
 188
 189 typedef struct _GeeConcurrentSetSubSet GeeConcurrentSetSubSet;
 190 typedef struct _GeeConcurrentSetSubSetClass GeeConcurrentSetSubSetClass;
 191 #define _gee_concurrent_set_range_unref0(var) ((var == NULL) ? NULL : (var = (gee_concurrent_set_range_unref (var), NULL)))
 192 typedef struct _GeeConcurrentSetIteratorPrivate GeeConcurrentSetIteratorPrivate;
 193 #define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
 194 typedef struct _GeeConcurrentSetSubSetPrivate GeeConcurrentSetSubSetPrivate;
 195
 196 #define GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR (gee_concurrent_set_sub_iterator_get_type ())
 197 #define GEE_CONCURRENT_SET_SUB_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR, GeeConcurrentSetSubIterator))
 198 #define GEE_CONCURRENT_SET_SUB_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR, GeeConcurrentSetSubIteratorClass))
 199 #define GEE_CONCURRENT_SET_IS_SUB_ITERATOR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR))
 200 #define GEE_CONCURRENT_SET_IS_SUB_ITERATOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR))
 201 #define GEE_CONCURRENT_SET_SUB_ITERATOR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR, GeeConcurrentSetSubIteratorClass))
 202
 203 typedef struct _GeeConcurrentSetSubIterator GeeConcurrentSetSubIterator;
 204 typedef struct _GeeConcurrentSetSubIteratorClass GeeConcurrentSetSubIteratorClass;
 205 typedef struct _GeeConcurrentSetRangePrivate GeeConcurrentSetRangePrivate;
 206
 207 #define GEE_CONCURRENT_SET_RANGE_TYPE_POSITION (gee_concurrent_set_range_position_get_type ())
 208 typedef struct _GeeConcurrentSetSubIteratorPrivate GeeConcurrentSetSubIteratorPrivate;
 209 #define _g_destroy_func0(var) (((var == NULL) || (g_destroy_func == NULL)) ? NULL : (var = (g_destroy_func (var), NULL)))
 210 typedef struct _GeeConcurrentSetParamSpecRange GeeConcurrentSetParamSpecRange;
 211 typedef struct _GeeConcurrentSetParamSpecTower GeeConcurrentSetParamSpecTower;
 212 #define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
 213
 214 typedef gboolean (*GeeForallFunc) (gpointer g, void* user_data);
 215 typedef enum  {
 216         GEE_TRAVERSABLE_STREAM_YIELD,
 217         GEE_TRAVERSABLE_STREAM_CONTINUE,
 218         GEE_TRAVERSABLE_STREAM_END
 219 } GeeTraversableStream;
 220
 221 typedef GeeTraversableStream (*GeeStreamFunc) (GeeTraversableStream state, GeeLazy* g, GeeLazy** lazy, void* user_data);
 222 struct _GeeIteratorIface {
 223         GTypeInterface parent_iface;
 224         gboolean (*next) (GeeIterator* self);
 225         gboolean (*has_next) (GeeIterator* self);
 226         gpointer (*get) (GeeIterator* self);
 227         void (*remove) (GeeIterator* self);
 228         gboolean (*get_valid) (GeeIterator* self);
 229         gboolean (*get_read_only) (GeeIterator* self);
 230 };
 231
 232 typedef gpointer (*GeeFoldFunc) (gpointer g, gpointer a, void* user_data);
 233 typedef gpointer (*GeeMapFunc) (gpointer g, void* user_data);
 234 typedef gboolean (*GeePredicate) (gconstpointer g, void* user_data);
 235 struct _GeeTraversableIface {
 236         GTypeInterface parent_iface;
 237         GType (*get_g_type) (GeeTraversable* self);
 238         GBoxedCopyFunc (*get_g_dup_func) (GeeTraversable* self);
 239         GDestroyNotify (*get_g_destroy_func) (GeeTraversable* self);
 240         gboolean (*foreach) (GeeTraversable* self, GeeForallFunc f, void* f_target);
 241         GeeIterator* (*stream) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeStreamFunc f, void* f_target, GDestroyNotify f_target_destroy_notify);
 242         gpointer (*fold) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 243         GeeIterator* (*map) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeMapFunc f, void* f_target);
 244         GeeIterator* (*scan) (GeeTraversable* self, GType a_type, GBoxedCopyFunc a_dup_func, GDestroyNotify a_destroy_func, GeeFoldFunc f, void* f_target, gpointer seed);
 245         GeeIterator* (*filter) (GeeTraversable* self, GeePredicate pred, void* pred_target, GDestroyNotify pred_target_destroy_notify);
 246         GeeIterator* (*chop) (GeeTraversable* self, gint offset, gint length);
 247         GType (*get_element_type) (GeeTraversable* self);
 248 };
 249
 250 struct _GeeIterableIface {
 251         GTypeInterface parent_iface;
 252         GType (*get_g_type) (GeeIterable* self);
 253         GBoxedCopyFunc (*get_g_dup_func) (GeeIterable* self);
 254         GDestroyNotify (*get_g_destroy_func) (GeeIterable* self);
 255         GeeIterator* (*iterator) (GeeIterable* self);
 256 };
 257
 258 struct _GeeCollectionIface {
 259         GTypeInterface parent_iface;
 260         GType (*get_g_type) (GeeCollection* self);
 261         GBoxedCopyFunc (*get_g_dup_func) (GeeCollection* self);
 262         GDestroyNotify (*get_g_destroy_func) (GeeCollection* self);
 263         gboolean (*contains) (GeeCollection* self, gconstpointer item);
 264         gboolean (*add) (GeeCollection* self, gconstpointer item);
 265         gboolean (*remove) (GeeCollection* self, gconstpointer item);
 266         void (*clear) (GeeCollection* self);
 267         gboolean (*add_all) (GeeCollection* self, GeeCollection* collection);
 268         gboolean (*contains_all) (GeeCollection* self, GeeCollection* collection);
 269         gboolean (*remove_all) (GeeCollection* self, GeeCollection* collection);
 270         gboolean (*retain_all) (GeeCollection* self, GeeCollection* collection);
 271         gpointer* (*to_array) (GeeCollection* self, int* result_length1);
 272         gint (*get_size) (GeeCollection* self);
 273         gboolean (*get_is_empty) (GeeCollection* self);
 274         gboolean (*get_read_only) (GeeCollection* self);
 275         GeeCollection* (*get_read_only_view) (GeeCollection* self);
 276 };
 277
 278 struct _GeeAbstractCollection {
 279         GObject parent_instance;
 280         GeeAbstractCollectionPrivate * priv;
 281 };
 282
 283 struct _GeeAbstractCollectionClass {
 284         GObjectClass parent_class;
 285         gboolean (*contains) (GeeAbstractCollection* self, gconstpointer item);
 286         gboolean (*add) (GeeAbstractCollection* self, gconstpointer item);
 287         gboolean (*remove) (GeeAbstractCollection* self, gconstpointer item);
 288         void (*clear) (GeeAbstractCollection* self);
 289         GeeIterator* (*iterator) (GeeAbstractCollection* self);
 290         gboolean (*foreach) (GeeAbstractCollection* self, GeeForallFunc f, void* f_target);
 291         void (*reserved0) (GeeAbstractCollection* self);
 292         void (*reserved1) (GeeAbstractCollection* self);
 293         void (*reserved2) (GeeAbstractCollection* self);
 294         void (*reserved3) (GeeAbstractCollection* self);
 295         void (*reserved4) (GeeAbstractCollection* self);
 296         void (*reserved5) (GeeAbstractCollection* self);
 297         void (*reserved6) (GeeAbstractCollection* self);
 298         void (*reserved7) (GeeAbstractCollection* self);
 299         void (*reserved8) (GeeAbstractCollection* self);
 300         void (*reserved9) (GeeAbstractCollection* self);
 301         gint (*get_size) (GeeAbstractCollection* self);
 302         gboolean (*get_read_only) (GeeAbstractCollection* self);
 303         GeeCollection* (*get_read_only_view) (GeeAbstractCollection* self);
 304 };
 305
 306 struct _GeeSetIface {
 307         GTypeInterface parent_iface;
 308         GType (*get_g_type) (GeeSet* self);
 309         GBoxedCopyFunc (*get_g_dup_func) (GeeSet* self);
 310         GDestroyNotify (*get_g_destroy_func) (GeeSet* self);
 311         GeeSet* (*get_read_only_view) (GeeSet* self);
 312 };
 313
 314 struct _GeeAbstractSet {
 315         GeeAbstractCollection parent_instance;
 316         GeeAbstractSetPrivate * priv;
 317 };
 318
 319 struct _GeeAbstractSetClass {
 320         GeeAbstractCollectionClass parent_class;
 321         void (*reserved0) (GeeAbstractSet* self);
 322         void (*reserved1) (GeeAbstractSet* self);
 323         void (*reserved2) (GeeAbstractSet* self);
 324         void (*reserved3) (GeeAbstractSet* self);
 325         void (*reserved4) (GeeAbstractSet* self);
 326         void (*reserved5) (GeeAbstractSet* self);
 327         void (*reserved6) (GeeAbstractSet* self);
 328         void (*reserved7) (GeeAbstractSet* self);
 329         void (*reserved8) (GeeAbstractSet* self);
 330         void (*reserved9) (GeeAbstractSet* self);
 331         GeeSet* (*get_read_only_view) (GeeAbstractSet* self);
 332 };
 333
 334 struct _GeeSortedSetIface {
 335         GTypeInterface parent_iface;
 336         GType (*get_g_type) (GeeSortedSet* self);
 337         GBoxedCopyFunc (*get_g_dup_func) (GeeSortedSet* self);
 338         GDestroyNotify (*get_g_destroy_func) (GeeSortedSet* self);
 339         gpointer (*first) (GeeSortedSet* self);
 340         gpointer (*last) (GeeSortedSet* self);
 341         GeeIterator* (*iterator_at) (GeeSortedSet* self, gconstpointer element);
 342         gpointer (*lower) (GeeSortedSet* self, gconstpointer element);
 343         gpointer (*higher) (GeeSortedSet* self, gconstpointer element);
 344         gpointer (*floor) (GeeSortedSet* self, gconstpointer element);
 345         gpointer (*ceil) (GeeSortedSet* self, gconstpointer element);
 346         GeeSortedSet* (*head_set) (GeeSortedSet* self, gconstpointer before);
 347         GeeSortedSet* (*tail_set) (GeeSortedSet* self, gconstpointer after);
 348         GeeSortedSet* (*sub_set) (GeeSortedSet* self, gconstpointer from, gconstpointer to);
 349         GeeSortedSet* (*get_read_only_view) (GeeSortedSet* self);
 350 };
 351
 352 struct _GeeAbstractSortedSet {
 353         GeeAbstractSet parent_instance;
 354         GeeAbstractSortedSetPrivate * priv;
 355 };
 356
 357 struct _GeeAbstractSortedSetClass {
 358         GeeAbstractSetClass parent_class;
 359         gpointer (*first) (GeeAbstractSortedSet* self);
 360         gpointer (*last) (GeeAbstractSortedSet* self);
 361         GeeIterator* (*iterator_at) (GeeAbstractSortedSet* self, gconstpointer element);
 362         gpointer (*lower) (GeeAbstractSortedSet* self, gconstpointer element);
 363         gpointer (*higher) (GeeAbstractSortedSet* self, gconstpointer element);
 364         gpointer (*floor) (GeeAbstractSortedSet* self, gconstpointer element);
 365         gpointer (*ceil) (GeeAbstractSortedSet* self, gconstpointer element);
 366         GeeSortedSet* (*head_set) (GeeAbstractSortedSet* self, gconstpointer before);
 367         GeeSortedSet* (*tail_set) (GeeAbstractSortedSet* self, gconstpointer after);
 368         GeeSortedSet* (*sub_set) (GeeAbstractSortedSet* self, gconstpointer from, gconstpointer to);
 369         void (*reserved0) (GeeAbstractSortedSet* self);
 370         void (*reserved1) (GeeAbstractSortedSet* self);
 371         void (*reserved2) (GeeAbstractSortedSet* self);
 372         void (*reserved3) (GeeAbstractSortedSet* self);
 373         void (*reserved4) (GeeAbstractSortedSet* self);
 374         void (*reserved5) (GeeAbstractSortedSet* self);
 375         void (*reserved6) (GeeAbstractSortedSet* self);
 376         void (*reserved7) (GeeAbstractSortedSet* self);
 377         void (*reserved8) (GeeAbstractSortedSet* self);
 378         void (*reserved9) (GeeAbstractSortedSet* self);
 379         GeeSortedSet* (*get_read_only_view) (GeeAbstractSortedSet* self);
 380 };
 381
 382 struct _GeeConcurrentSet {
 383         GeeAbstractSortedSet parent_instance;
 384         GeeConcurrentSetPrivate * priv;
 385 };
 386
 387 struct _GeeConcurrentSetClass {
 388         GeeAbstractSortedSetClass parent_class;
 389 };
 390
 391 struct _GeeConcurrentSetPrivate {
 392         GType g_type;
 393         GBoxedCopyFunc g_dup_func;
 394         GDestroyNotify g_destroy_func;
 395         gint _size;
 396         GeeConcurrentSetTower* _head;
 397         GCompareDataFunc _cmp;
 398         gpointer _cmp_target;
 399         GDestroyNotify _cmp_target_destroy_notify;
 400 };
 401
 402 typedef enum  {
 403         GEE_HAZARD_POINTER_POLICY_DEFAULT,
 404         GEE_HAZARD_POINTER_POLICY_THREAD_EXIT,
 405         GEE_HAZARD_POINTER_POLICY_TRY_FREE,
 406         GEE_HAZARD_POINTER_POLICY_FREE,
 407         GEE_HAZARD_POINTER_POLICY_TRY_RELEASE,
 408         GEE_HAZARD_POINTER_POLICY_RELEASE
 409 } GeeHazardPointerPolicy;
 410
 411 typedef enum  {
 412         GEE_CONCURRENT_SET_RANGE_TYPE_HEAD,
 413         GEE_CONCURRENT_SET_RANGE_TYPE_TAIL,
 414         GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED,
 415         GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY
 416 } GeeConcurrentSetRangeType;
 417
 418 typedef enum  {
 419         GEE_CONCURRENT_SET_STATE_NONE = 0,
 420         GEE_CONCURRENT_SET_STATE_MARKED = 1,
 421         GEE_CONCURRENT_SET_STATE_FLAGGED = 2
 422 } GeeConcurrentSetState;
 423
 424 struct _GeeConcurrentSetTowerIter {
 425         GeeConcurrentSetTower* _iter[31];
 426 };
 427
 428 struct _GeeConcurrentSetTowerNode {
 429         GeeConcurrentSetTower* _succ;
 430         GeeConcurrentSetTower* _backlink;
 431 };
 432
 433 struct _GeeConcurrentSetTower {
 434         GTypeInstance parent_instance;
 435         volatile int ref_count;
 436         GeeConcurrentSetTowerPrivate * priv;
 437         GeeConcurrentSetTowerNode* _nodes;
 438         gpointer _data;
 439         gint _height;
 440 };
 441
 442 struct _GeeConcurrentSetTowerClass {
 443         GTypeClass parent_class;
 444         void (*finalize) (GeeConcurrentSetTower *self);
 445 };
 446
 447 struct _GeeConcurrentSetIterator {
 448         GObject parent_instance;
 449         GeeConcurrentSetIteratorPrivate * priv;
 450 };
 451
 452 struct _GeeConcurrentSetIteratorClass {
 453         GObjectClass parent_class;
 454 };
 455
 456 struct _GeeConcurrentSetIteratorPrivate {
 457         GType g_type;
 458         GBoxedCopyFunc g_dup_func;
 459         GDestroyNotify g_destroy_func;
 460         gboolean _removed;
 461         GeeConcurrentSet* _set;
 462         GeeConcurrentSetTowerIter _prev;
 463         GeeConcurrentSetTower* _curr;
 464 };
 465
 466 struct _GeeConcurrentSetSubSet {
 467         GeeAbstractSortedSet parent_instance;
 468         GeeConcurrentSetSubSetPrivate * priv;
 469 };
 470
 471 struct _GeeConcurrentSetSubSetClass {
 472         GeeAbstractSortedSetClass parent_class;
 473 };
 474
 475 struct _GeeConcurrentSetSubSetPrivate {
 476         GType g_type;
 477         GBoxedCopyFunc g_dup_func;
 478         GDestroyNotify g_destroy_func;
 479         GeeConcurrentSetRange* _range;
 480 };
 481
 482 struct _GeeConcurrentSetRange {
 483         GTypeInstance parent_instance;
 484         volatile int ref_count;
 485         GeeConcurrentSetRangePrivate * priv;
 486         gpointer _start;
 487         gpointer _end;
 488         GeeConcurrentSetRangeType _type;
 489         GeeConcurrentSetTowerIter _bookmark;
 490         GeeConcurrentSet* _set;
 491 };
 492
 493 struct _GeeConcurrentSetRangeClass {
 494         GTypeClass parent_class;
 495         void (*finalize) (GeeConcurrentSetRange *self);
 496 };
 497
 498 typedef enum  {
 499         GEE_CONCURRENT_SET_RANGE_POSITION_BEFORE = -1,
 500         GEE_CONCURRENT_SET_RANGE_POSITION_INSIDE = 0,
 501         GEE_CONCURRENT_SET_RANGE_POSITION_AFTER = 1,
 502         GEE_CONCURRENT_SET_RANGE_POSITION_EMPTY
 503 } GeeConcurrentSetRangePosition;
 504
 505 struct _GeeConcurrentSetSubIterator {
 506         GObject parent_instance;
 507         GeeConcurrentSetSubIteratorPrivate * priv;
 508 };
 509
 510 struct _GeeConcurrentSetSubIteratorClass {
 511         GObjectClass parent_class;
 512 };
 513
 514 struct _GeeConcurrentSetSubIteratorPrivate {
 515         GType g_type;
 516         GBoxedCopyFunc g_dup_func;
 517         GDestroyNotify g_destroy_func;
 518         GeeConcurrentSetRange* _range;
 519         GeeConcurrentSetTowerIter _prev;
 520         GeeConcurrentSetTower* _curr;
 521         gboolean _removed;
 522 };
 523
 524 struct _GeeConcurrentSetRangePrivate {
 525         GType g_type;
 526         GBoxedCopyFunc g_dup_func;
 527         GDestroyNotify g_destroy_func;
 528 };
 529
 530 struct _GeeConcurrentSetParamSpecRange {
 531         GParamSpec parent_instance;
 532 };
 533
 534 struct _GeeConcurrentSetTowerPrivate {
 535         GType g_type;
 536         GBoxedCopyFunc g_dup_func;
 537         GDestroyNotify g_destroy_func;
 538 };
 539
 540 struct _GeeConcurrentSetParamSpecTower {
 541         GParamSpec parent_instance;
 542 };
 543
 544
 545 static gpointer gee_concurrent_set_parent_class = NULL;
 546 static GPrivate* gee_concurrent_set_rand;
 547 static GPrivate* gee_concurrent_set_rand = NULL;
 548 static gpointer gee_concurrent_set_iterator_parent_class = NULL;
 549 static GeeTraversableIface* gee_concurrent_set_iterator_gee_traversable_parent_iface = NULL;
 550 static GeeIteratorIface* gee_concurrent_set_iterator_gee_iterator_parent_iface = NULL;
 551 static gpointer gee_concurrent_set_sub_set_parent_class = NULL;
 552 static gpointer gee_concurrent_set_sub_iterator_parent_class = NULL;
 553 static GeeTraversableIface* gee_concurrent_set_sub_iterator_gee_traversable_parent_iface = NULL;
 554 static GeeIteratorIface* gee_concurrent_set_sub_iterator_gee_iterator_parent_iface = NULL;
 555 static gpointer gee_concurrent_set_range_parent_class = NULL;
 556 static gpointer gee_concurrent_set_tower_parent_class = NULL;
 557
 558 GType gee_traversable_stream_get_type (void) G_GNUC_CONST;
 559 gpointer gee_lazy_ref (gpointer instance);
 560 void gee_lazy_unref (gpointer instance);
 561 GParamSpec* gee_param_spec_lazy (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
 562 void gee_value_set_lazy (GValue* value, gpointer v_object);
 563 void gee_value_take_lazy (GValue* value, gpointer v_object);
 564 gpointer gee_value_get_lazy (const GValue* value);
 565 GType gee_lazy_get_type (void) G_GNUC_CONST;
 566 GType gee_iterator_get_type (void) G_GNUC_CONST;
 567 GType gee_traversable_get_type (void) G_GNUC_CONST;
 568 GType gee_iterable_get_type (void) G_GNUC_CONST;
 569 GType gee_collection_get_type (void) G_GNUC_CONST;
 570 GType gee_abstract_collection_get_type (void) G_GNUC_CONST;
 571 GType gee_set_get_type (void) G_GNUC_CONST;
 572 GType gee_abstract_set_get_type (void) G_GNUC_CONST;
 573 GType gee_sorted_set_get_type (void) G_GNUC_CONST;
 574 GType gee_abstract_sorted_set_get_type (void) G_GNUC_CONST;
 575 GType gee_concurrent_set_get_type (void) G_GNUC_CONST;
 576 static gpointer gee_concurrent_set_tower_ref (gpointer instance);
 577 static void gee_concurrent_set_tower_unref (gpointer instance);
 578 static GParamSpec* gee_concurrent_set_param_spec_tower (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) G_GNUC_UNUSED;
 579 static void gee_concurrent_set_value_set_tower (GValue* value, gpointer v_object) G_GNUC_UNUSED;
 580 static void gee_concurrent_set_value_take_tower (GValue* value, gpointer v_object) G_GNUC_UNUSED;
 581 static gpointer gee_concurrent_set_value_get_tower (const GValue* value) G_GNUC_UNUSED;
 582 static GType gee_concurrent_set_tower_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 583 #define GEE_CONCURRENT_SET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_TYPE_CONCURRENT_SET, GeeConcurrentSetPrivate))
 584 enum  {
 585         GEE_CONCURRENT_SET_DUMMY_PROPERTY,
 586         GEE_CONCURRENT_SET_G_TYPE,
 587         GEE_CONCURRENT_SET_G_DUP_FUNC,
 588         GEE_CONCURRENT_SET_G_DESTROY_FUNC,
 589         GEE_CONCURRENT_SET_SIZE,
 590         GEE_CONCURRENT_SET_READ_ONLY
 591 };
 592 GType gee_hazard_pointer_policy_get_type (void) G_GNUC_CONST;
 593 GeeHazardPointerContext* gee_hazard_pointer_context_new (GeeHazardPointerPolicy* policy);
 594 GeeHazardPointerContext* gee_hazard_pointer_context_new (GeeHazardPointerPolicy* policy);
 595 void gee_hazard_pointer_context_free (GeeHazardPointerContext* self);
 596 GType gee_concurrent_set_range_type_get_type (void) G_GNUC_CONST;
 597 static GType gee_concurrent_set_state_get_type (void) G_GNUC_UNUSED;
 598 static GeeConcurrentSetTower* gee_concurrent_set_tower_new_head (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 599 static GeeConcurrentSetTower* gee_concurrent_set_tower_construct_head (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 600 static void _gee_concurrent_set_rand_lambda37_ (void* ptr);
 601 static void __gee_concurrent_set_rand_lambda37__gdestroy_notify (void* data);
 602 #define GEE_CONCURRENT_SET__MAX_HEIGHT 31
 603 GeeConcurrentSet* gee_concurrent_set_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc compare_func, void* compare_func_target, GDestroyNotify compare_func_target_destroy_notify);
 604 GeeConcurrentSet* gee_concurrent_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc compare_func, void* compare_func_target, GDestroyNotify compare_func_target_destroy_notify);
 605 GeeAbstractSortedSet* gee_abstract_sorted_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func);
 606 GCompareDataFunc gee_functions_get_compare_func_for (GType t, void** result_target, GDestroyNotify* result_target_destroy_notify);
 607 static GeeIterator* gee_concurrent_set_real_iterator (GeeAbstractCollection* base);
 608 static GeeConcurrentSetIterator* gee_concurrent_set_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, GeeConcurrentSetTower* head);
 609 static GeeConcurrentSetIterator* gee_concurrent_set_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, GeeConcurrentSetTower* head);
 610 static GType gee_concurrent_set_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 611 static gboolean gee_concurrent_set_real_contains (GeeAbstractCollection* base, gconstpointer key);
 612 static inline gboolean gee_concurrent_set_tower_search (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, gconstpointer key, GeeConcurrentSetTower** prev, GeeConcurrentSetTower** next, guint8 to_level, guint8 from_level);
 613 static gboolean gee_concurrent_set_real_add (GeeAbstractCollection* base, gconstpointer key);
 614 static GType gee_concurrent_set_tower_iter_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 615 static GeeConcurrentSetTowerIter* gee_concurrent_set_tower_iter_dup (const GeeConcurrentSetTowerIter* self);
 616 static void gee_concurrent_set_tower_iter_free (GeeConcurrentSetTowerIter* self);
 617 static void gee_concurrent_set_tower_iter_copy (const GeeConcurrentSetTowerIter* self, GeeConcurrentSetTowerIter* dest);
 618 static void gee_concurrent_set_tower_iter_destroy (GeeConcurrentSetTowerIter* self);
 619 static inline GeeConcurrentSetTower* gee_concurrent_set_tower_insert (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTowerIter* prev, gconstpointer key, guint8 chosen_level);
 620 static gboolean gee_concurrent_set_real_remove (GeeAbstractCollection* base, gconstpointer item);
 621 static inline gboolean gee_concurrent_set_tower_remove_key (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTowerIter* prev, gconstpointer key, guint8 from_level);
 622 static void gee_concurrent_set_real_clear (GeeAbstractCollection* base);
 623 static inline GeeConcurrentSetTower* gee_concurrent_set_tower_get_next (GeeConcurrentSetTower* self, guint8 level);
 624 gboolean gee_abstract_collection_remove (GeeAbstractCollection* self, gconstpointer item);
 625 static GType gee_concurrent_set_tower_node_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 626 static GeeConcurrentSetTowerNode* gee_concurrent_set_tower_node_dup (const GeeConcurrentSetTowerNode* self);
 627 static void gee_concurrent_set_tower_node_free (GeeConcurrentSetTowerNode* self);
 628 static gpointer gee_concurrent_set_real_first (GeeAbstractSortedSet* base);
 629 static inline gboolean gee_concurrent_set_tower_proceed (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTower** arg_prev, GeeConcurrentSetTower** arg_curr, guint8 level, gboolean force);
 630 static gpointer gee_concurrent_set_real_last (GeeAbstractSortedSet* base);
 631 static GeeIterator* gee_concurrent_set_real_iterator_at (GeeAbstractSortedSet* base, gconstpointer element);
 632 static inline gboolean gee_concurrent_set_tower_search_from_bookmark (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, gconstpointer key, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTowerIter* next, guint8 to_level, guint8 from_level);
 633 static GeeConcurrentSetIterator* gee_concurrent_set_iterator_new_point_at (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTower* curr);
 634 static GeeConcurrentSetIterator* gee_concurrent_set_iterator_construct_point_at (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTower* curr);
 635 static gpointer gee_concurrent_set_real_lower (GeeAbstractSortedSet* base, gconstpointer element);
 636 static gpointer gee_concurrent_set_real_higher (GeeAbstractSortedSet* base, gconstpointer element);
 637 static gpointer gee_concurrent_set_real_floor (GeeAbstractSortedSet* base, gconstpointer element);
 638 static gpointer gee_concurrent_set_real_ceil (GeeAbstractSortedSet* base, gconstpointer element);
 639 static GeeSortedSet* gee_concurrent_set_real_head_set (GeeAbstractSortedSet* base, gconstpointer before);
 640 static GeeConcurrentSetRange* gee_concurrent_set_range_new_head (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer end);
 641 static GeeConcurrentSetRange* gee_concurrent_set_range_construct_head (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer end);
 642 static gpointer gee_concurrent_set_range_ref (gpointer instance);
 643 static void gee_concurrent_set_range_unref (gpointer instance);
 644 static GParamSpec* gee_concurrent_set_param_spec_range (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) G_GNUC_UNUSED;
 645 static void gee_concurrent_set_value_set_range (GValue* value, gpointer v_object) G_GNUC_UNUSED;
 646 static void gee_concurrent_set_value_take_range (GValue* value, gpointer v_object) G_GNUC_UNUSED;
 647 static gpointer gee_concurrent_set_value_get_range (const GValue* value) G_GNUC_UNUSED;
 648 static GType gee_concurrent_set_range_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 649 static GeeConcurrentSetSubSet* gee_concurrent_set_sub_set_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range);
 650 static GeeConcurrentSetSubSet* gee_concurrent_set_sub_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range);
 651 static GType gee_concurrent_set_sub_set_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 652 static GeeSortedSet* gee_concurrent_set_real_tail_set (GeeAbstractSortedSet* base, gconstpointer after);
 653 static GeeConcurrentSetRange* gee_concurrent_set_range_new_tail (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer start);
 654 static GeeConcurrentSetRange* gee_concurrent_set_range_construct_tail (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer start);
 655 static GeeSortedSet* gee_concurrent_set_real_sub_set (GeeAbstractSortedSet* base, gconstpointer from, gconstpointer to);
 656 static GeeConcurrentSetRange* gee_concurrent_set_range_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer start, gconstpointer end);
 657 static GeeConcurrentSetRange* gee_concurrent_set_range_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer start, gconstpointer end);
 658 static gconstpointer gee_concurrent_set_max (GeeConcurrentSet* self, gconstpointer a, gconstpointer b, gboolean* changed);
 659 static gconstpointer gee_concurrent_set_min (GeeConcurrentSet* self, gconstpointer a, gconstpointer b, gboolean* changed);
 660 #define GEE_CONCURRENT_SET_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_CONCURRENT_SET_TYPE_ITERATOR, GeeConcurrentSetIteratorPrivate))
 661 enum  {
 662         GEE_CONCURRENT_SET_ITERATOR_DUMMY_PROPERTY,
 663         GEE_CONCURRENT_SET_ITERATOR_G_TYPE,
 664         GEE_CONCURRENT_SET_ITERATOR_G_DUP_FUNC,
 665         GEE_CONCURRENT_SET_ITERATOR_G_DESTROY_FUNC,
 666         GEE_CONCURRENT_SET_ITERATOR_VALID,
 667         GEE_CONCURRENT_SET_ITERATOR_READ_ONLY
 668 };
 669 static gboolean gee_concurrent_set_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 670 static inline gint gee_concurrent_set_tower_get_height (GeeConcurrentSetTower* self);
 671 static gboolean gee_concurrent_set_iterator_real_next (GeeIterator* base);
 672 static gboolean gee_concurrent_set_iterator_real_has_next (GeeIterator* base);
 673 static gpointer gee_concurrent_set_iterator_real_get (GeeIterator* base);
 674 gboolean gee_iterator_get_valid (GeeIterator* self);
 675 static void gee_concurrent_set_iterator_real_remove (GeeIterator* base);
 676 static inline gboolean gee_concurrent_set_tower_remove (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTower* curr);
 677 static void gee_concurrent_set_iterator_finalize (GObject* obj);
 678 gboolean gee_iterator_get_read_only (GeeIterator* self);
 679 static void _vala_gee_concurrent_set_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 680 static void _vala_gee_concurrent_set_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 681 #define GEE_CONCURRENT_SET_SUB_SET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_CONCURRENT_SET_TYPE_SUB_SET, GeeConcurrentSetSubSetPrivate))
 682 enum  {
 683         GEE_CONCURRENT_SET_SUB_SET_DUMMY_PROPERTY,
 684         GEE_CONCURRENT_SET_SUB_SET_G_TYPE,
 685         GEE_CONCURRENT_SET_SUB_SET_G_DUP_FUNC,
 686         GEE_CONCURRENT_SET_SUB_SET_G_DESTROY_FUNC,
 687         GEE_CONCURRENT_SET_SUB_SET_SIZE,
 688         GEE_CONCURRENT_SET_SUB_SET_IS_EMPTY,
 689         GEE_CONCURRENT_SET_SUB_SET_READ_ONLY
 690 };
 691 static GeeIterator* gee_concurrent_set_sub_set_real_iterator (GeeAbstractCollection* base);
 692 static GeeConcurrentSetSubIterator* gee_concurrent_set_sub_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range);
 693 static GeeConcurrentSetSubIterator* gee_concurrent_set_sub_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range);
 694 static GType gee_concurrent_set_sub_iterator_get_type (void) G_GNUC_CONST G_GNUC_UNUSED;
 695 static gboolean gee_concurrent_set_sub_set_real_contains (GeeAbstractCollection* base, gconstpointer item);
 696 static gboolean gee_concurrent_set_range_inside (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, gconstpointer val);
 697 static void gee_concurrent_set_range_improve_bookmark (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, GeeConcurrentSetTower** out_curr, GeeConcurrentSetTowerIter* prev);
 698 static gboolean gee_concurrent_set_sub_set_real_add (GeeAbstractCollection* base, gconstpointer key);
 699 static gboolean gee_concurrent_set_sub_set_real_remove (GeeAbstractCollection* base, gconstpointer key);
 700 static void gee_concurrent_set_sub_set_real_clear (GeeAbstractCollection* base);
 701 static gpointer gee_concurrent_set_sub_set_real_first (GeeAbstractSortedSet* base);
 702 static gpointer gee_concurrent_set_sub_set_real_last (GeeAbstractSortedSet* base);
 703 static gboolean gee_concurrent_set_range_proceed (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, GeeConcurrentSetTower** prev, GeeConcurrentSetTower** curr, guint8 level);
 704 static GeeIterator* gee_concurrent_set_sub_set_real_iterator_at (GeeAbstractSortedSet* base, gconstpointer element);
 705 static GeeConcurrentSetSubIterator* gee_concurrent_set_sub_iterator_new_point_at (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTower* curr);
 706 static GeeConcurrentSetSubIterator* gee_concurrent_set_sub_iterator_construct_point_at (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTower* curr);
 707 static gpointer gee_concurrent_set_sub_set_real_lower (GeeAbstractSortedSet* base, gconstpointer element);
 708 static gint gee_concurrent_set_range_cmp (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, gconstpointer val);
 709 static GType gee_concurrent_set_range_position_get_type (void) G_GNUC_UNUSED;
 710 gpointer gee_abstract_sorted_set_last (GeeAbstractSortedSet* self);
 711 static gpointer gee_concurrent_set_sub_set_real_higher (GeeAbstractSortedSet* base, gconstpointer element);
 712 gpointer gee_abstract_sorted_set_first (GeeAbstractSortedSet* self);
 713 static gpointer gee_concurrent_set_sub_set_real_floor (GeeAbstractSortedSet* base, gconstpointer element);
 714 static inline gboolean gee_concurrent_set_tower_is_head (GeeConcurrentSetTower* self);
 715 static gpointer gee_concurrent_set_sub_set_real_ceil (GeeAbstractSortedSet* base, gconstpointer element);
 716 static GeeSortedSet* gee_concurrent_set_sub_set_real_head_set (GeeAbstractSortedSet* base, gconstpointer before);
 717 static GeeConcurrentSetRange* gee_concurrent_set_range_cut_tail (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* from, gconstpointer end);
 718 static GeeSortedSet* gee_concurrent_set_sub_set_real_tail_set (GeeAbstractSortedSet* base, gconstpointer after);
 719 static GeeConcurrentSetRange* gee_concurrent_set_range_cut_head (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* from, gconstpointer start);
 720 static GeeSortedSet* gee_concurrent_set_sub_set_real_sub_set (GeeAbstractSortedSet* base, gconstpointer from, gconstpointer to);
 721 static GeeConcurrentSetRange* gee_concurrent_set_range_cut (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* from, gconstpointer start, gconstpointer end);
 722 gpointer gee_hazard_pointer_get_pointer (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer** aptr, gsize mask, gsize* mask_out);
 723 static gboolean gee_concurrent_set_sub_set_get_is_empty (GeeConcurrentSetSubSet* self);
 724 static void gee_concurrent_set_sub_set_finalize (GObject* obj);
 725 gint gee_abstract_collection_get_size (GeeAbstractCollection* self);
 726 gboolean gee_abstract_collection_get_read_only (GeeAbstractCollection* self);
 727 static void _vala_gee_concurrent_set_sub_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 728 static void _vala_gee_concurrent_set_sub_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 729 #define GEE_CONCURRENT_SET_SUB_ITERATOR_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR, GeeConcurrentSetSubIteratorPrivate))
 730 enum  {
 731         GEE_CONCURRENT_SET_SUB_ITERATOR_DUMMY_PROPERTY,
 732         GEE_CONCURRENT_SET_SUB_ITERATOR_G_TYPE,
 733         GEE_CONCURRENT_SET_SUB_ITERATOR_G_DUP_FUNC,
 734         GEE_CONCURRENT_SET_SUB_ITERATOR_G_DESTROY_FUNC,
 735         GEE_CONCURRENT_SET_SUB_ITERATOR_VALID,
 736         GEE_CONCURRENT_SET_SUB_ITERATOR_READ_ONLY
 737 };
 738 static gboolean gee_concurrent_set_sub_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target);
 739 static gboolean gee_concurrent_set_sub_iterator_begin (GeeConcurrentSetSubIterator* self);
 740 static gboolean gee_concurrent_set_sub_iterator_real_next (GeeIterator* base);
 741 static gboolean gee_concurrent_set_sub_iterator_real_has_next (GeeIterator* base);
 742 static gboolean gee_concurrent_set_range_beyond (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, GeeConcurrentSetTower* tw);
 743 static gpointer gee_concurrent_set_sub_iterator_real_get (GeeIterator* base);
 744 static void gee_concurrent_set_sub_iterator_real_remove (GeeIterator* base);
 745 static void gee_concurrent_set_sub_iterator_finalize (GObject* obj);
 746 static void _vala_gee_concurrent_set_sub_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 747 static void _vala_gee_concurrent_set_sub_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 748 #define GEE_CONCURRENT_SET_RANGE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_CONCURRENT_SET_TYPE_RANGE, GeeConcurrentSetRangePrivate))
 749 enum  {
 750         GEE_CONCURRENT_SET_RANGE_DUMMY_PROPERTY
 751 };
 752 static GeeConcurrentSetRange* gee_concurrent_set_range_new_empty (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset);
 753 static GeeConcurrentSetRange* gee_concurrent_set_range_construct_empty (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset);
 754 static void gee_concurrent_set_range_copy_bookmark (GeeConcurrentSetRange* self, GeeConcurrentSetRange* range);
 755 static inline void gee_concurrent_set_tower_backtrace (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetTower** curr, guint8 level);
 756 static inline gint gee_concurrent_set_tower_compare (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTower* a, GeeConcurrentSetTower* b);
 757 gboolean gee_hazard_pointer_compare_and_exchange_pointer (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer** aptr, gconstpointer old_ptr, gpointer _new_ptr, gsize mask, gsize old_mask, gsize new_mask);
 758 static inline gint gee_concurrent_set_tower_compare_data (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTower* a, gconstpointer b);
 759 static void gee_concurrent_set_range_finalize (GeeConcurrentSetRange* obj);
 760 #define GEE_CONCURRENT_SET_TOWER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GEE_CONCURRENT_SET_TYPE_TOWER, GeeConcurrentSetTowerPrivate))
 761 enum  {
 762         GEE_CONCURRENT_SET_TOWER_DUMMY_PROPERTY
 763 };
 764 static inline void gee_concurrent_set_tower_set_succ (GeeConcurrentSetTower* self, GeeConcurrentSetTower* next, GeeConcurrentSetState state, guint8 level);
 765 static inline void gee_concurrent_set_tower_set_backlink (GeeConcurrentSetTower* self, GeeConcurrentSetTower* backlink, guint8 level);
 766 static GeeConcurrentSetTower* gee_concurrent_set_tower_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, guint8 height);
 767 static GeeConcurrentSetTower* gee_concurrent_set_tower_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, guint8 height);
 768 static inline gboolean gee_concurrent_set_tower_search_helper (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, gconstpointer key, GeeConcurrentSetTower** prev, GeeConcurrentSetTower** next, guint8 level);
 769 static inline GeeConcurrentSetTower* gee_concurrent_set_tower_insert_helper (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTowerIter* prev, gconstpointer key, guint8 chosen_level, guint8 level);
 770 static inline GeeConcurrentSetTower* gee_concurrent_set_tower_get_succ (GeeConcurrentSetTower* self, GeeConcurrentSetState* state, guint8 level);
 771 static inline void gee_concurrent_set_tower_help_flagged (GeeConcurrentSetTower* self, GeeConcurrentSetTower* prev, guint8 level);
 772 static inline gboolean gee_concurrent_set_tower_compare_and_exchange (GeeConcurrentSetTower* self, GeeConcurrentSetTower* old_tower, GeeConcurrentSetState old_state, GeeConcurrentSetTower* new_tower, GeeConcurrentSetState new_state, guint8 level);
 773 static inline GeeConcurrentSetState gee_concurrent_set_tower_get_state (GeeConcurrentSetTower* self, guint8 level);
 774 static inline gboolean gee_concurrent_set_tower_remove_level (GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTower** prev, GeeConcurrentSetTower* curr, guint8 level);
 775 static inline gboolean gee_concurrent_set_tower_try_flag (GeeConcurrentSetTower* self, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTower** prev_tower, gboolean* status, guint8 level);
 776 static inline void gee_concurrent_set_tower_help_marked (GeeConcurrentSetTower* self, GeeConcurrentSetTower* prev_tower, guint8 level);
 777 static inline void gee_concurrent_set_tower_try_mark (GeeConcurrentSetTower* self, guint8 level);
 778 static inline gboolean gee_concurrent_set_tower_compare_succ (GeeConcurrentSetTower* self, GeeConcurrentSetTower* next, GeeConcurrentSetState state, guint8 level);
 779 static inline GeeConcurrentSetTower* gee_concurrent_set_tower_get_backlink (GeeConcurrentSetTower* self, guint8 level);
 780 void gee_hazard_pointer_set_pointer (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer** aptr, gpointer new_ptr, gsize mask, gsize new_mask);
 781 static void gee_concurrent_set_tower_finalize (GeeConcurrentSetTower* obj);
 782 static void _vala_array_copy2 (GeeConcurrentSetTower** self, GeeConcurrentSetTower** dest);
 783 static void gee_concurrent_set_finalize (GObject* obj);
 784 static void _vala_gee_concurrent_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec);
 785 static void _vala_gee_concurrent_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec);
 786 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
 787 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
 788
 789
 790 GType gee_concurrent_set_range_type_get_type (void) {
 791         static volatile gsize gee_concurrent_set_range_type_type_id__volatile = 0;
 792         if (g_once_init_enter (&gee_concurrent_set_range_type_type_id__volatile)) {
 793                 static const GEnumValue values[] = {{GEE_CONCURRENT_SET_RANGE_TYPE_HEAD, "GEE_CONCURRENT_SET_RANGE_TYPE_HEAD", "head"}, {GEE_CONCURRENT_SET_RANGE_TYPE_TAIL, "GEE_CONCURRENT_SET_RANGE_TYPE_TAIL", "tail"}, {GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED, "GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED", "bounded"}, {GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY, "GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY", "empty"}, {0, NULL, NULL}};
 794                 GType gee_concurrent_set_range_type_type_id;
 795                 gee_concurrent_set_range_type_type_id = g_enum_register_static ("GeeConcurrentSetRangeType", values);
 796                 g_once_init_leave (&gee_concurrent_set_range_type_type_id__volatile, gee_concurrent_set_range_type_type_id);
 797         }
 798         return gee_concurrent_set_range_type_type_id__volatile;
 799 }
 800
 801
 802 static GType gee_concurrent_set_state_get_type (void) {
 803         static volatile gsize gee_concurrent_set_state_type_id__volatile = 0;
 804         if (g_once_init_enter (&gee_concurrent_set_state_type_id__volatile)) {
 805                 static const GEnumValue values[] = {{GEE_CONCURRENT_SET_STATE_NONE, "GEE_CONCURRENT_SET_STATE_NONE", "none"}, {GEE_CONCURRENT_SET_STATE_MARKED, "GEE_CONCURRENT_SET_STATE_MARKED", "marked"}, {GEE_CONCURRENT_SET_STATE_FLAGGED, "GEE_CONCURRENT_SET_STATE_FLAGGED", "flagged"}, {0, NULL, NULL}};
 806                 GType gee_concurrent_set_state_type_id;
 807                 gee_concurrent_set_state_type_id = g_enum_register_static ("GeeConcurrentSetState", values);
 808                 g_once_init_leave (&gee_concurrent_set_state_type_id__volatile, gee_concurrent_set_state_type_id);
 809         }
 810         return gee_concurrent_set_state_type_id__volatile;
 811 }
 812
 813
 814 static void _gee_concurrent_set_rand_lambda37_ (void* ptr) {
 815         void* _tmp0_;
 816         GRand* rnd;
 817         GRand* _tmp1_;
 818         _tmp0_ = ptr;
 819         rnd = (GRand*) _tmp0_;
 820         _tmp1_ = rnd;
 821         g_rand_free (_tmp1_);
 822 }
 823
 824
 825 static void __gee_concurrent_set_rand_lambda37__gdestroy_notify (void* data) {
 826         _gee_concurrent_set_rand_lambda37_ (data);
 827 }
 828
 829
 830 GeeConcurrentSet* gee_concurrent_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc compare_func, void* compare_func_target, GDestroyNotify compare_func_target_destroy_notify) {
 831         GeeConcurrentSet * self = NULL;
 832         GCompareDataFunc _tmp0_;
 833         void* _tmp0__target;
 834         GCompareDataFunc _tmp4_;
 835         void* _tmp4__target;
 836         self = (GeeConcurrentSet*) gee_abstract_sorted_set_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func);
 837         self->priv->g_type = g_type;
 838         self->priv->g_dup_func = g_dup_func;
 839         self->priv->g_destroy_func = g_destroy_func;
 840         _tmp0_ = compare_func;
 841         _tmp0__target = compare_func_target;
 842         if (_tmp0_ == NULL) {
 843                 void* _tmp1_ = NULL;
 844                 GDestroyNotify _tmp2_ = NULL;
 845                 GCompareDataFunc _tmp3_ = NULL;
 846                 _tmp3_ = gee_functions_get_compare_func_for (g_type, &_tmp1_, &_tmp2_);
 847                 (compare_func_target_destroy_notify == NULL) ? NULL : (compare_func_target_destroy_notify (compare_func_target), NULL);
 848                 compare_func = NULL;
 849                 compare_func_target = NULL;
 850                 compare_func_target_destroy_notify = NULL;
 851                 compare_func = _tmp3_;
 852                 compare_func_target = _tmp1_;
 853                 compare_func_target_destroy_notify = _tmp2_;
 854         }
 855         _tmp4_ = compare_func;
 856         _tmp4__target = compare_func_target;
 857         (self->priv->_cmp_target_destroy_notify == NULL) ? NULL : (self->priv->_cmp_target_destroy_notify (self->priv->_cmp_target), NULL);
 858         self->priv->_cmp = NULL;
 859         self->priv->_cmp_target = NULL;
 860         self->priv->_cmp_target_destroy_notify = NULL;
 861         self->priv->_cmp = _tmp4_;
 862         self->priv->_cmp_target = _tmp4__target;
 863         self->priv->_cmp_target_destroy_notify = NULL;
 864         (compare_func_target_destroy_notify == NULL) ? NULL : (compare_func_target_destroy_notify (compare_func_target), NULL);
 865         compare_func = NULL;
 866         compare_func_target = NULL;
 867         compare_func_target_destroy_notify = NULL;
 868         return self;
 869 }
 870
 871
 872 GeeConcurrentSet* gee_concurrent_set_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc compare_func, void* compare_func_target, GDestroyNotify compare_func_target_destroy_notify) {
 873         return gee_concurrent_set_construct (GEE_TYPE_CONCURRENT_SET, g_type, g_dup_func, g_destroy_func, compare_func, compare_func_target, compare_func_target_destroy_notify);
 874 }
 875
 876
 877 static GeeIterator* gee_concurrent_set_real_iterator (GeeAbstractCollection* base) {
 878         GeeConcurrentSet * self;
 879         GeeIterator* result = NULL;
 880         GeeConcurrentSetTower* _tmp0_;
 881         GeeConcurrentSetIterator* _tmp1_;
 882         self = (GeeConcurrentSet*) base;
 883         _tmp0_ = self->priv->_head;
 884         _tmp1_ = gee_concurrent_set_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self, _tmp0_);
 885         result = (GeeIterator*) _tmp1_;
 886         return result;
 887 }
 888
 889
 890 static gpointer _gee_concurrent_set_tower_ref0 (gpointer self) {
 891         return self ? gee_concurrent_set_tower_ref (self) : NULL;
 892 }
 893
 894
 895 static gboolean gee_concurrent_set_real_contains (GeeAbstractCollection* base, gconstpointer key) {
 896         GeeConcurrentSet * self;
 897         gboolean result = FALSE;
 898         GeeHazardPointerContext* _tmp0_;
 899         GeeHazardPointerContext* ctx;
 900         GeeConcurrentSetTower* _tmp1_;
 901         GeeConcurrentSetTower* _tmp2_;
 902         GeeConcurrentSetTower* prev;
 903         GCompareDataFunc _tmp3_;
 904         void* _tmp3__target;
 905         gconstpointer _tmp4_;
 906         gboolean _tmp5_ = FALSE;
 907         self = (GeeConcurrentSet*) base;
 908         _tmp0_ = gee_hazard_pointer_context_new (NULL);
 909         ctx = _tmp0_;
 910         _tmp1_ = self->priv->_head;
 911         _tmp2_ = _gee_concurrent_set_tower_ref0 (_tmp1_);
 912         prev = _tmp2_;
 913         _tmp3_ = self->priv->_cmp;
 914         _tmp3__target = self->priv->_cmp_target;
 915         _tmp4_ = key;
 916         _tmp5_ = gee_concurrent_set_tower_search (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp3_, _tmp3__target, _tmp4_, &prev, NULL, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
 917         result = _tmp5_;
 918         _gee_concurrent_set_tower_unref0 (prev);
 919         _gee_hazard_pointer_context_free0 (ctx);
 920         return result;
 921 }
 922
 923
 924 static gboolean gee_concurrent_set_real_add (GeeAbstractCollection* base, gconstpointer key) {
 925         GeeConcurrentSet * self;
 926         gboolean result = FALSE;
 927         GeeHazardPointerContext* _tmp0_;
 928         GeeHazardPointerContext* ctx;
 929         GPrivate* _tmp1_;
 930         void* _tmp2_ = NULL;
 931         GRand* rnd;
 932         GRand* _tmp3_;
 933         GRand* _tmp7_;
 934         gint32 _tmp8_;
 935         gint32 _tmp9_ = 0;
 936         guint32 rand_int;
 937         guint32 _tmp10_;
 938         gint _tmp11_ = 0;
 939         guint8 height;
 940         GeeConcurrentSetTowerIter prev = {0};
 941         guint8 _tmp12_;
 942         GeeConcurrentSetTower* _tmp13_;
 943         GeeConcurrentSetTower* _tmp14_;
 944         GeeConcurrentSetTower* _tmp15_;
 945         GCompareDataFunc _tmp16_;
 946         void* _tmp16__target;
 947         gconstpointer _tmp17_;
 948         guint8 _tmp18_;
 949         guint8 _tmp19_;
 950         gboolean _tmp20_ = FALSE;
 951         GCompareDataFunc _tmp32_;
 952         void* _tmp32__target;
 953         gconstpointer _tmp33_;
 954         guint8 _tmp34_;
 955         GeeConcurrentSetTower* _tmp35_ = NULL;
 956         GeeConcurrentSetTower* _result_;
 957         GeeConcurrentSetTower* _tmp36_;
 958         GeeConcurrentSetTower* _tmp37_;
 959         self = (GeeConcurrentSet*) base;
 960         _tmp0_ = gee_hazard_pointer_context_new (NULL);
 961         ctx = _tmp0_;
 962         _tmp1_ = gee_concurrent_set_rand;
 963         _tmp2_ = g_private_get (_tmp1_);
 964         rnd = _tmp2_;
 965         _tmp3_ = rnd;
 966         if (_tmp3_ == NULL) {
 967                 GPrivate* _tmp4_;
 968                 GRand* _tmp5_;
 969                 GRand* _tmp6_;
 970                 _tmp4_ = gee_concurrent_set_rand;
 971                 _tmp5_ = g_rand_new ();
 972                 rnd = _tmp5_;
 973                 _tmp6_ = rnd;
 974                 g_private_set (_tmp4_, _tmp6_);
 975         }
 976         _tmp7_ = rnd;
 977         _tmp8_ = G_MAXINT32;
 978         _tmp9_ = g_rand_int_range (_tmp7_, (gint32) 0, _tmp8_);
 979         rand_int = (guint32) _tmp9_;
 980         _tmp10_ = rand_int;
 981         _tmp11_ = g_bit_nth_lsf ((gulong) (~_tmp10_), -1);
 982         height = (guint8) (1 + ((guint8) _tmp11_));
 983         memset (&prev, 0, sizeof (GeeConcurrentSetTowerIter));
 984         _tmp12_ = height;
 985         _tmp13_ = self->priv->_head;
 986         _tmp14_ = _gee_concurrent_set_tower_ref0 (_tmp13_);
 987         _gee_concurrent_set_tower_unref0 (prev._iter[_tmp12_ - 1]);
 988         prev._iter[_tmp12_ - 1] = _tmp14_;
 989         _tmp15_ = prev._iter[_tmp12_ - 1];
 990         _tmp16_ = self->priv->_cmp;
 991         _tmp16__target = self->priv->_cmp_target;
 992         _tmp17_ = key;
 993         _tmp18_ = height;
 994         _tmp19_ = height;
 995         _tmp20_ = gee_concurrent_set_tower_search (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp16_, _tmp16__target, _tmp17_, &prev._iter[_tmp18_ - 1], NULL, (guint8) (_tmp19_ - 1), (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
 996         if (_tmp20_) {
 997                 result = FALSE;
 998                 gee_concurrent_set_tower_iter_destroy (&prev);
 999                 _gee_hazard_pointer_context_free0 (ctx);
1000                 return result;
1001         }
1002         {
1003                 guint8 _tmp21_;
1004                 gint i;
1005                 _tmp21_ = height;
1006                 i = _tmp21_ - 2;
1007                 {
1008                         gboolean _tmp22_;
1009                         _tmp22_ = TRUE;
1010                         while (TRUE) {
1011                                 gboolean _tmp23_;
1012                                 gint _tmp25_;
1013                                 gint _tmp26_;
1014                                 GeeConcurrentSetTowerIter _tmp27_;
1015                                 guint8 _tmp28_;
1016                                 GeeConcurrentSetTower* _tmp29_;
1017                                 GeeConcurrentSetTower* _tmp30_;
1018                                 GeeConcurrentSetTower* _tmp31_;
1019                                 _tmp23_ = _tmp22_;
1020                                 if (!_tmp23_) {
1021                                         gint _tmp24_;
1022                                         _tmp24_ = i;
1023                                         i = _tmp24_ - 1;
1024                                 }
1025                                 _tmp22_ = FALSE;
1026                                 _tmp25_ = i;
1027                                 if (!(_tmp25_ >= 0)) {
1028                                         break;
1029                                 }
1030                                 _tmp26_ = i;
1031                                 _tmp27_ = prev;
1032                                 _tmp28_ = height;
1033                                 _tmp29_ = _tmp27_._iter[_tmp28_ - 1];
1034                                 _tmp30_ = _gee_concurrent_set_tower_ref0 (_tmp29_);
1035                                 _gee_concurrent_set_tower_unref0 (prev._iter[_tmp26_]);
1036                                 prev._iter[_tmp26_] = _tmp30_;
1037                                 _tmp31_ = prev._iter[_tmp26_];
1038                         }
1039                 }
1040         }
1041         _tmp32_ = self->priv->_cmp;
1042         _tmp32__target = self->priv->_cmp_target;
1043         _tmp33_ = key;
1044         _tmp34_ = height;
1045         _tmp35_ = gee_concurrent_set_tower_insert (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp32_, _tmp32__target, &prev, _tmp33_, (guint8) (_tmp34_ - 1));
1046         _result_ = _tmp35_;
1047         _tmp36_ = _result_;
1048         if (_tmp36_ != NULL) {
1049                 g_atomic_int_inc ((volatile gint *) (&self->priv->_size));
1050         }
1051         _tmp37_ = _result_;
1052         result = _tmp37_ != NULL;
1053         _gee_concurrent_set_tower_unref0 (_result_);
1054         gee_concurrent_set_tower_iter_destroy (&prev);
1055         _gee_hazard_pointer_context_free0 (ctx);
1056         return result;
1057 }
1058
1059
1060 static gboolean gee_concurrent_set_real_remove (GeeAbstractCollection* base, gconstpointer item) {
1061         GeeConcurrentSet * self;
1062         gboolean result = FALSE;
1063         GeeHazardPointerContext* _tmp0_;
1064         GeeHazardPointerContext* ctx;
1065         GeeConcurrentSetTowerIter prev = {0};
1066         GCompareDataFunc _tmp9_;
1067         void* _tmp9__target;
1068         gconstpointer _tmp10_;
1069         gboolean _tmp11_ = FALSE;
1070         gboolean _result_;
1071         gboolean _tmp12_;
1072         self = (GeeConcurrentSet*) base;
1073         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1074         ctx = _tmp0_;
1075         memset (&prev, 0, sizeof (GeeConcurrentSetTowerIter));
1076         {
1077                 gint i;
1078                 i = 0;
1079                 {
1080                         gboolean _tmp1_;
1081                         _tmp1_ = TRUE;
1082                         while (TRUE) {
1083                                 gboolean _tmp2_;
1084                                 gint _tmp4_;
1085                                 gint _tmp5_;
1086                                 GeeConcurrentSetTower* _tmp6_;
1087                                 GeeConcurrentSetTower* _tmp7_;
1088                                 GeeConcurrentSetTower* _tmp8_;
1089                                 _tmp2_ = _tmp1_;
1090                                 if (!_tmp2_) {
1091                                         gint _tmp3_;
1092                                         _tmp3_ = i;
1093                                         i = _tmp3_ + 1;
1094                                 }
1095                                 _tmp1_ = FALSE;
1096                                 _tmp4_ = i;
1097                                 if (!(_tmp4_ < GEE_CONCURRENT_SET__MAX_HEIGHT)) {
1098                                         break;
1099                                 }
1100                                 _tmp5_ = i;
1101                                 _tmp6_ = self->priv->_head;
1102                                 _tmp7_ = _gee_concurrent_set_tower_ref0 (_tmp6_);
1103                                 _gee_concurrent_set_tower_unref0 (prev._iter[_tmp5_]);
1104                                 prev._iter[_tmp5_] = _tmp7_;
1105                                 _tmp8_ = prev._iter[_tmp5_];
1106                         }
1107                 }
1108         }
1109         _tmp9_ = self->priv->_cmp;
1110         _tmp9__target = self->priv->_cmp_target;
1111         _tmp10_ = item;
1112         _tmp11_ = gee_concurrent_set_tower_remove_key (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp9_, _tmp9__target, &prev, _tmp10_, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
1113         _result_ = _tmp11_;
1114         _tmp12_ = _result_;
1115         if (_tmp12_) {
1116                 g_atomic_int_dec_and_test ((volatile gint *) (&self->priv->_size));
1117         }
1118         result = _result_;
1119         gee_concurrent_set_tower_iter_destroy (&prev);
1120         _gee_hazard_pointer_context_free0 (ctx);
1121         return result;
1122 }
1123
1124
1125 static void gee_concurrent_set_real_clear (GeeAbstractCollection* base) {
1126         GeeConcurrentSet * self;
1127         GeeHazardPointerContext* _tmp0_;
1128         GeeHazardPointerContext* ctx;
1129         GeeConcurrentSetTower* first = NULL;
1130         self = (GeeConcurrentSet*) base;
1131         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1132         ctx = _tmp0_;
1133         while (TRUE) {
1134                 GeeConcurrentSetTower* _tmp1_;
1135                 GeeConcurrentSetTower* _tmp2_ = NULL;
1136                 GeeConcurrentSetTower* _tmp3_;
1137                 GeeConcurrentSetTower* _tmp4_;
1138                 gconstpointer _tmp5_;
1139                 _tmp1_ = self->priv->_head;
1140                 _tmp2_ = gee_concurrent_set_tower_get_next (_tmp1_, (guint8) 0);
1141                 _gee_concurrent_set_tower_unref0 (first);
1142                 first = _tmp2_;
1143                 _tmp3_ = first;
1144                 if (!(_tmp3_ != NULL)) {
1145                         break;
1146                 }
1147                 _tmp4_ = first;
1148                 _tmp5_ = _tmp4_->_data;
1149                 gee_abstract_collection_remove ((GeeAbstractCollection*) self, _tmp5_);
1150         }
1151         _gee_concurrent_set_tower_unref0 (first);
1152         _gee_hazard_pointer_context_free0 (ctx);
1153 }
1154
1155
1156 static gpointer gee_concurrent_set_real_first (GeeAbstractSortedSet* base) {
1157         GeeConcurrentSet * self;
1158         gpointer result = NULL;
1159         GeeHazardPointerContext* _tmp0_;
1160         GeeHazardPointerContext* ctx;
1161         GeeConcurrentSetTower* prev;
1162         GeeConcurrentSetTower* _tmp1_;
1163         GeeConcurrentSetTower* _tmp2_;
1164         GeeConcurrentSetTower* curr;
1165         GCompareDataFunc _tmp3_;
1166         void* _tmp3__target;
1167         gboolean _tmp4_ = FALSE;
1168         self = (GeeConcurrentSet*) base;
1169         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1170         ctx = _tmp0_;
1171         prev = NULL;
1172         _tmp1_ = self->priv->_head;
1173         _tmp2_ = _gee_concurrent_set_tower_ref0 (_tmp1_);
1174         curr = _tmp2_;
1175         _tmp3_ = self->priv->_cmp;
1176         _tmp3__target = self->priv->_cmp_target;
1177         _tmp4_ = gee_concurrent_set_tower_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp3_, _tmp3__target, &prev, &curr, (guint8) 0, FALSE);
1178         if (_tmp4_) {
1179                 GeeConcurrentSetTower* _tmp5_;
1180                 gconstpointer _tmp6_;
1181                 gpointer _tmp7_;
1182                 _tmp5_ = curr;
1183                 _tmp6_ = _tmp5_->_data;
1184                 _tmp7_ = ((_tmp6_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp6_) : ((gpointer) _tmp6_);
1185                 result = _tmp7_;
1186                 _gee_concurrent_set_tower_unref0 (curr);
1187                 _gee_concurrent_set_tower_unref0 (prev);
1188                 _gee_hazard_pointer_context_free0 (ctx);
1189                 return result;
1190         } else {
1191                 result = NULL;
1192                 _gee_concurrent_set_tower_unref0 (curr);
1193                 _gee_concurrent_set_tower_unref0 (prev);
1194                 _gee_hazard_pointer_context_free0 (ctx);
1195                 return result;
1196         }
1197         _gee_concurrent_set_tower_unref0 (curr);
1198         _gee_concurrent_set_tower_unref0 (prev);
1199         _gee_hazard_pointer_context_free0 (ctx);
1200 }
1201
1202
1203 static gpointer gee_concurrent_set_real_last (GeeAbstractSortedSet* base) {
1204         GeeConcurrentSet * self;
1205         gpointer result = NULL;
1206         GeeHazardPointerContext* _tmp0_;
1207         GeeHazardPointerContext* ctx;
1208         GeeConcurrentSetTower* prev;
1209         GeeConcurrentSetTower* _tmp1_;
1210         GeeConcurrentSetTower* _tmp2_;
1211         GeeConcurrentSetTower* curr;
1212         gboolean found;
1213         gboolean _tmp9_;
1214         GeeConcurrentSetTower* _tmp10_;
1215         gconstpointer _tmp11_;
1216         gpointer _tmp12_;
1217         self = (GeeConcurrentSet*) base;
1218         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1219         ctx = _tmp0_;
1220         prev = NULL;
1221         _tmp1_ = self->priv->_head;
1222         _tmp2_ = _gee_concurrent_set_tower_ref0 (_tmp1_);
1223         curr = _tmp2_;
1224         found = FALSE;
1225         {
1226                 gint i;
1227                 i = GEE_CONCURRENT_SET__MAX_HEIGHT;
1228                 {
1229                         gboolean _tmp3_;
1230                         _tmp3_ = TRUE;
1231                         while (TRUE) {
1232                                 gboolean _tmp4_;
1233                                 gint _tmp6_;
1234                                 _tmp4_ = _tmp3_;
1235                                 if (!_tmp4_) {
1236                                         gint _tmp5_;
1237                                         _tmp5_ = i;
1238                                         i = _tmp5_ - 1;
1239                                 }
1240                                 _tmp3_ = FALSE;
1241                                 _tmp6_ = i;
1242                                 if (!(_tmp6_ >= 0)) {
1243                                         break;
1244                                 }
1245                                 while (TRUE) {
1246                                         GCompareDataFunc _tmp7_;
1247                                         void* _tmp7__target;
1248                                         gboolean _tmp8_ = FALSE;
1249                                         _tmp7_ = self->priv->_cmp;
1250                                         _tmp7__target = self->priv->_cmp_target;
1251                                         _tmp8_ = gee_concurrent_set_tower_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp7_, _tmp7__target, &prev, &curr, (guint8) 0, FALSE);
1252                                         if (!_tmp8_) {
1253                                                 break;
1254                                         }
1255                                         found = TRUE;
1256                                 }
1257                         }
1258                 }
1259         }
1260         _tmp9_ = found;
1261         if (!_tmp9_) {
1262                 result = NULL;
1263                 _gee_concurrent_set_tower_unref0 (curr);
1264                 _gee_concurrent_set_tower_unref0 (prev);
1265                 _gee_hazard_pointer_context_free0 (ctx);
1266                 return result;
1267         }
1268         _tmp10_ = curr;
1269         _tmp11_ = _tmp10_->_data;
1270         _tmp12_ = ((_tmp11_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp11_) : ((gpointer) _tmp11_);
1271         result = _tmp12_;
1272         _gee_concurrent_set_tower_unref0 (curr);
1273         _gee_concurrent_set_tower_unref0 (prev);
1274         _gee_hazard_pointer_context_free0 (ctx);
1275         return result;
1276 }
1277
1278
1279 static GeeIterator* gee_concurrent_set_real_iterator_at (GeeAbstractSortedSet* base, gconstpointer element) {
1280         GeeConcurrentSet * self;
1281         GeeIterator* result = NULL;
1282         GeeHazardPointerContext* _tmp0_;
1283         GeeHazardPointerContext* ctx;
1284         GeeConcurrentSetTowerIter prev = {0};
1285         GeeConcurrentSetTowerIter curr = {0};
1286         GCompareDataFunc _tmp9_;
1287         void* _tmp9__target;
1288         gconstpointer _tmp10_;
1289         GeeConcurrentSetTowerIter _tmp11_ = {0};
1290         gboolean _tmp12_ = FALSE;
1291         GeeConcurrentSetTowerIter _tmp13_;
1292         GeeConcurrentSetTower* _tmp14_;
1293         GeeConcurrentSetIterator* _tmp15_;
1294         self = (GeeConcurrentSet*) base;
1295         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1296         ctx = _tmp0_;
1297         memset (&prev, 0, sizeof (GeeConcurrentSetTowerIter));
1298         {
1299                 gint i;
1300                 i = 0;
1301                 {
1302                         gboolean _tmp1_;
1303                         _tmp1_ = TRUE;
1304                         while (TRUE) {
1305                                 gboolean _tmp2_;
1306                                 gint _tmp4_;
1307                                 gint _tmp5_;
1308                                 GeeConcurrentSetTower* _tmp6_;
1309                                 GeeConcurrentSetTower* _tmp7_;
1310                                 GeeConcurrentSetTower* _tmp8_;
1311                                 _tmp2_ = _tmp1_;
1312                                 if (!_tmp2_) {
1313                                         gint _tmp3_;
1314                                         _tmp3_ = i;
1315                                         i = _tmp3_ + 1;
1316                                 }
1317                                 _tmp1_ = FALSE;
1318                                 _tmp4_ = i;
1319                                 if (!(_tmp4_ < GEE_CONCURRENT_SET__MAX_HEIGHT)) {
1320                                         break;
1321                                 }
1322                                 _tmp5_ = i;
1323                                 _tmp6_ = self->priv->_head;
1324                                 _tmp7_ = _gee_concurrent_set_tower_ref0 (_tmp6_);
1325                                 _gee_concurrent_set_tower_unref0 (prev._iter[_tmp5_]);
1326                                 prev._iter[_tmp5_] = _tmp7_;
1327                                 _tmp8_ = prev._iter[_tmp5_];
1328                         }
1329                 }
1330         }
1331         _tmp9_ = self->priv->_cmp;
1332         _tmp9__target = self->priv->_cmp_target;
1333         _tmp10_ = element;
1334         _tmp12_ = gee_concurrent_set_tower_search_from_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp9_, _tmp9__target, _tmp10_, &prev, &_tmp11_, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
1335         gee_concurrent_set_tower_iter_destroy (&curr);
1336         curr = _tmp11_;
1337         if (!_tmp12_) {
1338                 result = NULL;
1339                 gee_concurrent_set_tower_iter_destroy (&curr);
1340                 gee_concurrent_set_tower_iter_destroy (&prev);
1341                 _gee_hazard_pointer_context_free0 (ctx);
1342                 return result;
1343         }
1344         _tmp13_ = curr;
1345         _tmp14_ = _tmp13_._iter[0];
1346         _tmp15_ = gee_concurrent_set_iterator_new_point_at (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self, &prev, _tmp14_);
1347         result = (GeeIterator*) _tmp15_;
1348         gee_concurrent_set_tower_iter_destroy (&curr);
1349         gee_concurrent_set_tower_iter_destroy (&prev);
1350         _gee_hazard_pointer_context_free0 (ctx);
1351         return result;
1352 }
1353
1354
1355 static gpointer gee_concurrent_set_real_lower (GeeAbstractSortedSet* base, gconstpointer element) {
1356         GeeConcurrentSet * self;
1357         gpointer result = NULL;
1358         GeeHazardPointerContext* _tmp0_;
1359         GeeHazardPointerContext* ctx;
1360         GeeConcurrentSetTower* _tmp1_;
1361         GeeConcurrentSetTower* _tmp2_;
1362         GeeConcurrentSetTower* prev;
1363         GCompareDataFunc _tmp3_;
1364         void* _tmp3__target;
1365         gconstpointer _tmp4_;
1366         GeeConcurrentSetTower* _tmp5_;
1367         GeeConcurrentSetTower* _tmp6_;
1368         GeeConcurrentSetTower* _tmp7_;
1369         gconstpointer _tmp8_;
1370         gpointer _tmp9_;
1371         self = (GeeConcurrentSet*) base;
1372         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1373         ctx = _tmp0_;
1374         _tmp1_ = self->priv->_head;
1375         _tmp2_ = _gee_concurrent_set_tower_ref0 (_tmp1_);
1376         prev = _tmp2_;
1377         _tmp3_ = self->priv->_cmp;
1378         _tmp3__target = self->priv->_cmp_target;
1379         _tmp4_ = element;
1380         gee_concurrent_set_tower_search (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp3_, _tmp3__target, _tmp4_, &prev, NULL, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
1381         _tmp5_ = prev;
1382         _tmp6_ = self->priv->_head;
1383         if (_tmp5_ == _tmp6_) {
1384                 result = NULL;
1385                 _gee_concurrent_set_tower_unref0 (prev);
1386                 _gee_hazard_pointer_context_free0 (ctx);
1387                 return result;
1388         }
1389         _tmp7_ = prev;
1390         _tmp8_ = _tmp7_->_data;
1391         _tmp9_ = ((_tmp8_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp8_) : ((gpointer) _tmp8_);
1392         result = _tmp9_;
1393         _gee_concurrent_set_tower_unref0 (prev);
1394         _gee_hazard_pointer_context_free0 (ctx);
1395         return result;
1396 }
1397
1398
1399 static gpointer gee_concurrent_set_real_higher (GeeAbstractSortedSet* base, gconstpointer element) {
1400         GeeConcurrentSet * self;
1401         gpointer result = NULL;
1402         GeeHazardPointerContext* _tmp0_;
1403         GeeHazardPointerContext* ctx;
1404         GeeConcurrentSetTower* _tmp1_;
1405         GeeConcurrentSetTower* _tmp2_;
1406         GeeConcurrentSetTower* prev;
1407         GeeConcurrentSetTower* next = NULL;
1408         GCompareDataFunc _tmp3_;
1409         void* _tmp3__target;
1410         gconstpointer _tmp4_;
1411         GeeConcurrentSetTower* _tmp5_ = NULL;
1412         gboolean _tmp6_ = FALSE;
1413         GeeConcurrentSetTower* _tmp9_;
1414         GeeConcurrentSetTower* _tmp10_;
1415         gconstpointer _tmp11_;
1416         gpointer _tmp12_;
1417         self = (GeeConcurrentSet*) base;
1418         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1419         ctx = _tmp0_;
1420         _tmp1_ = self->priv->_head;
1421         _tmp2_ = _gee_concurrent_set_tower_ref0 (_tmp1_);
1422         prev = _tmp2_;
1423         _tmp3_ = self->priv->_cmp;
1424         _tmp3__target = self->priv->_cmp_target;
1425         _tmp4_ = element;
1426         _tmp6_ = gee_concurrent_set_tower_search (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp3_, _tmp3__target, _tmp4_, &prev, &_tmp5_, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
1427         _gee_concurrent_set_tower_unref0 (next);
1428         next = _tmp5_;
1429         if (_tmp6_) {
1430                 GCompareDataFunc _tmp7_;
1431                 void* _tmp7__target;
1432                 gboolean _tmp8_ = FALSE;
1433                 _tmp7_ = self->priv->_cmp;
1434                 _tmp7__target = self->priv->_cmp_target;
1435                 _tmp8_ = gee_concurrent_set_tower_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp7_, _tmp7__target, &prev, &next, (guint8) 0, FALSE);
1436                 if (!_tmp8_) {
1437                         result = NULL;
1438                         _gee_concurrent_set_tower_unref0 (next);
1439                         _gee_concurrent_set_tower_unref0 (prev);
1440                         _gee_hazard_pointer_context_free0 (ctx);
1441                         return result;
1442                 }
1443         }
1444         _tmp9_ = next;
1445         if (_tmp9_ == NULL) {
1446                 result = NULL;
1447                 _gee_concurrent_set_tower_unref0 (next);
1448                 _gee_concurrent_set_tower_unref0 (prev);
1449                 _gee_hazard_pointer_context_free0 (ctx);
1450                 return result;
1451         }
1452         _tmp10_ = next;
1453         _tmp11_ = _tmp10_->_data;
1454         _tmp12_ = ((_tmp11_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp11_) : ((gpointer) _tmp11_);
1455         result = _tmp12_;
1456         _gee_concurrent_set_tower_unref0 (next);
1457         _gee_concurrent_set_tower_unref0 (prev);
1458         _gee_hazard_pointer_context_free0 (ctx);
1459         return result;
1460 }
1461
1462
1463 static gpointer gee_concurrent_set_real_floor (GeeAbstractSortedSet* base, gconstpointer element) {
1464         GeeConcurrentSet * self;
1465         gpointer result = NULL;
1466         GeeHazardPointerContext* _tmp0_;
1467         GeeHazardPointerContext* ctx;
1468         GeeConcurrentSetTower* _tmp1_;
1469         GeeConcurrentSetTower* _tmp2_;
1470         GeeConcurrentSetTower* prev;
1471         GeeConcurrentSetTower* next = NULL;
1472         GCompareDataFunc _tmp3_;
1473         void* _tmp3__target;
1474         gconstpointer _tmp4_;
1475         GeeConcurrentSetTower* _tmp5_ = NULL;
1476         gboolean _tmp6_ = FALSE;
1477         self = (GeeConcurrentSet*) base;
1478         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1479         ctx = _tmp0_;
1480         _tmp1_ = self->priv->_head;
1481         _tmp2_ = _gee_concurrent_set_tower_ref0 (_tmp1_);
1482         prev = _tmp2_;
1483         _tmp3_ = self->priv->_cmp;
1484         _tmp3__target = self->priv->_cmp_target;
1485         _tmp4_ = element;
1486         _tmp6_ = gee_concurrent_set_tower_search (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp3_, _tmp3__target, _tmp4_, &prev, &_tmp5_, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
1487         _gee_concurrent_set_tower_unref0 (next);
1488         next = _tmp5_;
1489         if (_tmp6_) {
1490                 GeeConcurrentSetTower* _tmp7_;
1491                 gconstpointer _tmp8_;
1492                 gpointer _tmp9_;
1493                 _tmp7_ = next;
1494                 _tmp8_ = _tmp7_->_data;
1495                 _tmp9_ = ((_tmp8_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp8_) : ((gpointer) _tmp8_);
1496                 result = _tmp9_;
1497                 _gee_concurrent_set_tower_unref0 (next);
1498                 _gee_concurrent_set_tower_unref0 (prev);
1499                 _gee_hazard_pointer_context_free0 (ctx);
1500                 return result;
1501         } else {
1502                 GeeConcurrentSetTower* _tmp10_;
1503                 GeeConcurrentSetTower* _tmp11_;
1504                 _tmp10_ = prev;
1505                 _tmp11_ = self->priv->_head;
1506                 if (_tmp10_ != _tmp11_) {
1507                         GeeConcurrentSetTower* _tmp12_;
1508                         gconstpointer _tmp13_;
1509                         gpointer _tmp14_;
1510                         _tmp12_ = prev;
1511                         _tmp13_ = _tmp12_->_data;
1512                         _tmp14_ = ((_tmp13_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp13_) : ((gpointer) _tmp13_);
1513                         result = _tmp14_;
1514                         _gee_concurrent_set_tower_unref0 (next);
1515                         _gee_concurrent_set_tower_unref0 (prev);
1516                         _gee_hazard_pointer_context_free0 (ctx);
1517                         return result;
1518                 } else {
1519                         result = NULL;
1520                         _gee_concurrent_set_tower_unref0 (next);
1521                         _gee_concurrent_set_tower_unref0 (prev);
1522                         _gee_hazard_pointer_context_free0 (ctx);
1523                         return result;
1524                 }
1525         }
1526         _gee_concurrent_set_tower_unref0 (next);
1527         _gee_concurrent_set_tower_unref0 (prev);
1528         _gee_hazard_pointer_context_free0 (ctx);
1529 }
1530
1531
1532 static gpointer gee_concurrent_set_real_ceil (GeeAbstractSortedSet* base, gconstpointer element) {
1533         GeeConcurrentSet * self;
1534         gpointer result = NULL;
1535         GeeHazardPointerContext* _tmp0_;
1536         GeeHazardPointerContext* ctx;
1537         GeeConcurrentSetTower* _tmp1_;
1538         GeeConcurrentSetTower* _tmp2_;
1539         GeeConcurrentSetTower* prev;
1540         GeeConcurrentSetTower* next = NULL;
1541         GCompareDataFunc _tmp3_;
1542         void* _tmp3__target;
1543         gconstpointer _tmp4_;
1544         GeeConcurrentSetTower* _tmp5_ = NULL;
1545         GeeConcurrentSetTower* _tmp6_;
1546         GeeConcurrentSetTower* _tmp7_;
1547         gconstpointer _tmp8_;
1548         gpointer _tmp9_;
1549         self = (GeeConcurrentSet*) base;
1550         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1551         ctx = _tmp0_;
1552         _tmp1_ = self->priv->_head;
1553         _tmp2_ = _gee_concurrent_set_tower_ref0 (_tmp1_);
1554         prev = _tmp2_;
1555         _tmp3_ = self->priv->_cmp;
1556         _tmp3__target = self->priv->_cmp_target;
1557         _tmp4_ = element;
1558         gee_concurrent_set_tower_search (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp3_, _tmp3__target, _tmp4_, &prev, &_tmp5_, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
1559         _gee_concurrent_set_tower_unref0 (next);
1560         next = _tmp5_;
1561         _tmp6_ = next;
1562         if (_tmp6_ == NULL) {
1563                 result = NULL;
1564                 _gee_concurrent_set_tower_unref0 (next);
1565                 _gee_concurrent_set_tower_unref0 (prev);
1566                 _gee_hazard_pointer_context_free0 (ctx);
1567                 return result;
1568         }
1569         _tmp7_ = next;
1570         _tmp8_ = _tmp7_->_data;
1571         _tmp9_ = ((_tmp8_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp8_) : ((gpointer) _tmp8_);
1572         result = _tmp9_;
1573         _gee_concurrent_set_tower_unref0 (next);
1574         _gee_concurrent_set_tower_unref0 (prev);
1575         _gee_hazard_pointer_context_free0 (ctx);
1576         return result;
1577 }
1578
1579
1580 static GeeSortedSet* gee_concurrent_set_real_head_set (GeeAbstractSortedSet* base, gconstpointer before) {
1581         GeeConcurrentSet * self;
1582         GeeSortedSet* result = NULL;
1583         GeeHazardPointerContext* _tmp0_;
1584         GeeHazardPointerContext* ctx;
1585         gconstpointer _tmp1_;
1586         GeeConcurrentSetRange* _tmp2_;
1587         GeeConcurrentSetRange* _tmp3_;
1588         GeeConcurrentSetSubSet* _tmp4_;
1589         GeeSortedSet* _tmp5_;
1590         self = (GeeConcurrentSet*) base;
1591         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1592         ctx = _tmp0_;
1593         _tmp1_ = before;
1594         _tmp2_ = gee_concurrent_set_range_new_head (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self, _tmp1_);
1595         _tmp3_ = _tmp2_;
1596         _tmp4_ = gee_concurrent_set_sub_set_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp3_);
1597         _tmp5_ = (GeeSortedSet*) _tmp4_;
1598         _gee_concurrent_set_range_unref0 (_tmp3_);
1599         result = _tmp5_;
1600         _gee_hazard_pointer_context_free0 (ctx);
1601         return result;
1602 }
1603
1604
1605 static GeeSortedSet* gee_concurrent_set_real_tail_set (GeeAbstractSortedSet* base, gconstpointer after) {
1606         GeeConcurrentSet * self;
1607         GeeSortedSet* result = NULL;
1608         GeeHazardPointerContext* _tmp0_;
1609         GeeHazardPointerContext* ctx;
1610         gconstpointer _tmp1_;
1611         GeeConcurrentSetRange* _tmp2_;
1612         GeeConcurrentSetRange* _tmp3_;
1613         GeeConcurrentSetSubSet* _tmp4_;
1614         GeeSortedSet* _tmp5_;
1615         self = (GeeConcurrentSet*) base;
1616         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1617         ctx = _tmp0_;
1618         _tmp1_ = after;
1619         _tmp2_ = gee_concurrent_set_range_new_tail (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self, _tmp1_);
1620         _tmp3_ = _tmp2_;
1621         _tmp4_ = gee_concurrent_set_sub_set_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp3_);
1622         _tmp5_ = (GeeSortedSet*) _tmp4_;
1623         _gee_concurrent_set_range_unref0 (_tmp3_);
1624         result = _tmp5_;
1625         _gee_hazard_pointer_context_free0 (ctx);
1626         return result;
1627 }
1628
1629
1630 static GeeSortedSet* gee_concurrent_set_real_sub_set (GeeAbstractSortedSet* base, gconstpointer from, gconstpointer to) {
1631         GeeConcurrentSet * self;
1632         GeeSortedSet* result = NULL;
1633         GeeHazardPointerContext* _tmp0_;
1634         GeeHazardPointerContext* ctx;
1635         gconstpointer _tmp1_;
1636         gconstpointer _tmp2_;
1637         GeeConcurrentSetRange* _tmp3_;
1638         GeeConcurrentSetRange* _tmp4_;
1639         GeeConcurrentSetSubSet* _tmp5_;
1640         GeeSortedSet* _tmp6_;
1641         self = (GeeConcurrentSet*) base;
1642         _tmp0_ = gee_hazard_pointer_context_new (NULL);
1643         ctx = _tmp0_;
1644         _tmp1_ = from;
1645         _tmp2_ = to;
1646         _tmp3_ = gee_concurrent_set_range_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, self, _tmp1_, _tmp2_);
1647         _tmp4_ = _tmp3_;
1648         _tmp5_ = gee_concurrent_set_sub_set_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp4_);
1649         _tmp6_ = (GeeSortedSet*) _tmp5_;
1650         _gee_concurrent_set_range_unref0 (_tmp4_);
1651         result = _tmp6_;
1652         _gee_hazard_pointer_context_free0 (ctx);
1653         return result;
1654 }
1655
1656
1657 static gconstpointer gee_concurrent_set_max (GeeConcurrentSet* self, gconstpointer a, gconstpointer b, gboolean* changed) {
1658         gboolean _vala_changed = FALSE;
1659         gconstpointer result = NULL;
1660         GCompareDataFunc _tmp0_;
1661         void* _tmp0__target;
1662         gconstpointer _tmp1_;
1663         gconstpointer _tmp2_;
1664         gint _tmp3_ = 0;
1665         gconstpointer _tmp4_ = NULL;
1666         gboolean _tmp5_;
1667         gconstpointer _tmp8_;
1668         g_return_val_if_fail (self != NULL, NULL);
1669         _tmp0_ = self->priv->_cmp;
1670         _tmp0__target = self->priv->_cmp_target;
1671         _tmp1_ = a;
1672         _tmp2_ = b;
1673         _tmp3_ = _tmp0_ (_tmp1_, _tmp2_, _tmp0__target);
1674         _vala_changed = _tmp3_ < 0;
1675         _tmp5_ = _vala_changed;
1676         if (_tmp5_) {
1677                 gconstpointer _tmp6_;
1678                 _tmp6_ = b;
1679                 _tmp4_ = _tmp6_;
1680         } else {
1681                 gconstpointer _tmp7_;
1682                 _tmp7_ = a;
1683                 _tmp4_ = _tmp7_;
1684         }
1685         _tmp8_ = _tmp4_;
1686         result = _tmp8_;
1687         if (changed) {
1688                 *changed = _vala_changed;
1689         }
1690         return result;
1691 }
1692
1693
1694 static gconstpointer gee_concurrent_set_min (GeeConcurrentSet* self, gconstpointer a, gconstpointer b, gboolean* changed) {
1695         gboolean _vala_changed = FALSE;
1696         gconstpointer result = NULL;
1697         GCompareDataFunc _tmp0_;
1698         void* _tmp0__target;
1699         gconstpointer _tmp1_;
1700         gconstpointer _tmp2_;
1701         gint _tmp3_ = 0;
1702         gconstpointer _tmp4_ = NULL;
1703         gboolean _tmp5_;
1704         gconstpointer _tmp8_;
1705         g_return_val_if_fail (self != NULL, NULL);
1706         _tmp0_ = self->priv->_cmp;
1707         _tmp0__target = self->priv->_cmp_target;
1708         _tmp1_ = a;
1709         _tmp2_ = b;
1710         _tmp3_ = _tmp0_ (_tmp1_, _tmp2_, _tmp0__target);
1711         _vala_changed = _tmp3_ > 0;
1712         _tmp5_ = _vala_changed;
1713         if (_tmp5_) {
1714                 gconstpointer _tmp6_;
1715                 _tmp6_ = b;
1716                 _tmp4_ = _tmp6_;
1717         } else {
1718                 gconstpointer _tmp7_;
1719                 _tmp7_ = a;
1720                 _tmp4_ = _tmp7_;
1721         }
1722         _tmp8_ = _tmp4_;
1723         result = _tmp8_;
1724         if (changed) {
1725                 *changed = _vala_changed;
1726         }
1727         return result;
1728 }
1729
1730
1731 static gint gee_concurrent_set_real_get_size (GeeAbstractCollection* base) {
1732         gint result;
1733         GeeConcurrentSet* self;
1734         gint _tmp0_ = 0;
1735         self = (GeeConcurrentSet*) base;
1736         _tmp0_ = g_atomic_int_get ((volatile gint *) (&self->priv->_size));
1737         result = _tmp0_;
1738         return result;
1739 }
1740
1741
1742 static gboolean gee_concurrent_set_real_get_read_only (GeeAbstractCollection* base) {
1743         gboolean result;
1744         GeeConcurrentSet* self;
1745         self = (GeeConcurrentSet*) base;
1746         result = FALSE;
1747         return result;
1748 }
1749
1750
1751 static gpointer _g_object_ref0 (gpointer self) {
1752         return self ? g_object_ref (self) : NULL;
1753 }
1754
1755
1756 static GeeConcurrentSetIterator* gee_concurrent_set_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, GeeConcurrentSetTower* head) {
1757         GeeConcurrentSetIterator * self = NULL;
1758         GeeConcurrentSetTower* _tmp0_;
1759         GeeConcurrentSetTower* _tmp1_;
1760         GeeConcurrentSet* _tmp2_;
1761         GeeConcurrentSet* _tmp3_;
1762         GeeConcurrentSetTower* _tmp4_;
1763         g_return_val_if_fail (cset != NULL, NULL);
1764         g_return_val_if_fail (head != NULL, NULL);
1765         self = (GeeConcurrentSetIterator*) g_object_new (object_type, NULL);
1766         self->priv->g_type = g_type;
1767         self->priv->g_dup_func = g_dup_func;
1768         self->priv->g_destroy_func = g_destroy_func;
1769         _tmp0_ = head;
1770         _tmp1_ = _gee_concurrent_set_tower_ref0 (_tmp0_);
1771         _gee_concurrent_set_tower_unref0 (self->priv->_curr);
1772         self->priv->_curr = _tmp1_;
1773         _tmp2_ = cset;
1774         _tmp3_ = _g_object_ref0 (_tmp2_);
1775         _g_object_unref0 (self->priv->_set);
1776         self->priv->_set = _tmp3_;
1777         _tmp4_ = self->priv->_curr;
1778         _vala_assert (_tmp4_ != NULL, "_curr != null");
1779         return self;
1780 }
1781
1782
1783 static GeeConcurrentSetIterator* gee_concurrent_set_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, GeeConcurrentSetTower* head) {
1784         return gee_concurrent_set_iterator_construct (GEE_CONCURRENT_SET_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, cset, head);
1785 }
1786
1787
1788 static GeeConcurrentSetIterator* gee_concurrent_set_iterator_construct_point_at (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTower* curr) {
1789         GeeConcurrentSetIterator * self = NULL;
1790         GeeConcurrentSetTower* _tmp0_;
1791         GeeConcurrentSetTower* _tmp1_;
1792         GeeConcurrentSet* _tmp2_;
1793         GeeConcurrentSet* _tmp3_;
1794         GeeConcurrentSetTowerIter _tmp4_;
1795         GeeConcurrentSetTowerIter _tmp5_ = {0};
1796         GeeConcurrentSetTower* _tmp6_;
1797         g_return_val_if_fail (cset != NULL, NULL);
1798         g_return_val_if_fail (prev != NULL, NULL);
1799         g_return_val_if_fail (curr != NULL, NULL);
1800         self = (GeeConcurrentSetIterator*) g_object_new (object_type, NULL);
1801         self->priv->g_type = g_type;
1802         self->priv->g_dup_func = g_dup_func;
1803         self->priv->g_destroy_func = g_destroy_func;
1804         _tmp0_ = curr;
1805         _tmp1_ = _gee_concurrent_set_tower_ref0 (_tmp0_);
1806         _gee_concurrent_set_tower_unref0 (self->priv->_curr);
1807         self->priv->_curr = _tmp1_;
1808         _tmp2_ = cset;
1809         _tmp3_ = _g_object_ref0 (_tmp2_);
1810         _g_object_unref0 (self->priv->_set);
1811         self->priv->_set = _tmp3_;
1812         _tmp4_ = *prev;
1813         gee_concurrent_set_tower_iter_copy (&_tmp4_, &_tmp5_);
1814         gee_concurrent_set_tower_iter_destroy (&self->priv->_prev);
1815         self->priv->_prev = _tmp5_;
1816         _tmp6_ = self->priv->_curr;
1817         _vala_assert (_tmp6_ != NULL, "_curr != null");
1818         return self;
1819 }
1820
1821
1822 static GeeConcurrentSetIterator* gee_concurrent_set_iterator_new_point_at (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTower* curr) {
1823         return gee_concurrent_set_iterator_construct_point_at (GEE_CONCURRENT_SET_TYPE_ITERATOR, g_type, g_dup_func, g_destroy_func, cset, prev, curr);
1824 }
1825
1826
1827 static gboolean gee_concurrent_set_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
1828         GeeConcurrentSetIterator * self;
1829         gboolean result = FALSE;
1830         GeeConcurrentSetTower* _tmp0_;
1831         GeeHazardPointerContext* _tmp1_;
1832         GeeHazardPointerContext* ctx;
1833         gboolean _tmp2_ = FALSE;
1834         GeeConcurrentSetTowerIter _tmp3_;
1835         GeeConcurrentSetTower* _tmp4_;
1836         gboolean _tmp6_;
1837         GeeConcurrentSetTowerIter _tmp13_;
1838         GeeConcurrentSetTower* _tmp14_;
1839         GeeConcurrentSetTower* _tmp15_;
1840         GeeConcurrentSetTower* new_prev;
1841         GeeConcurrentSetTower* _tmp16_;
1842         GeeConcurrentSetTower* _tmp17_;
1843         GeeConcurrentSetTower* new_curr;
1844         GeeConcurrentSetTower* _tmp47_;
1845         self = (GeeConcurrentSetIterator*) base;
1846         _tmp0_ = self->priv->_curr;
1847         _vala_assert (_tmp0_ != NULL, "_curr != null");
1848         _tmp1_ = gee_hazard_pointer_context_new (NULL);
1849         ctx = _tmp1_;
1850         _tmp3_ = self->priv->_prev;
1851         _tmp4_ = _tmp3_._iter[0];
1852         if (_tmp4_ != NULL) {
1853                 gboolean _tmp5_;
1854                 _tmp5_ = self->priv->_removed;
1855                 _tmp2_ = !_tmp5_;
1856         } else {
1857                 _tmp2_ = FALSE;
1858         }
1859         _tmp6_ = _tmp2_;
1860         if (_tmp6_) {
1861                 GeeForallFunc _tmp7_;
1862                 void* _tmp7__target;
1863                 GeeConcurrentSetTower* _tmp8_;
1864                 gconstpointer _tmp9_;
1865                 gpointer _tmp10_;
1866                 gboolean _tmp11_ = FALSE;
1867                 _tmp7_ = f;
1868                 _tmp7__target = f_target;
1869                 _tmp8_ = self->priv->_curr;
1870                 _tmp9_ = _tmp8_->_data;
1871                 _tmp10_ = ((_tmp9_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp9_) : ((gpointer) _tmp9_);
1872                 _tmp11_ = _tmp7_ (_tmp10_, _tmp7__target);
1873                 if (!_tmp11_) {
1874                         GeeConcurrentSetTower* _tmp12_;
1875                         _tmp12_ = self->priv->_curr;
1876                         _vala_assert (_tmp12_ != NULL, "_curr != null");
1877                         result = FALSE;
1878                         _gee_hazard_pointer_context_free0 (ctx);
1879                         return result;
1880                 }
1881         }
1882         _tmp13_ = self->priv->_prev;
1883         _tmp14_ = _tmp13_._iter[0];
1884         _tmp15_ = _gee_concurrent_set_tower_ref0 (_tmp14_);
1885         new_prev = _tmp15_;
1886         _tmp16_ = self->priv->_curr;
1887         _tmp17_ = _gee_concurrent_set_tower_ref0 (_tmp16_);
1888         new_curr = _tmp17_;
1889         while (TRUE) {
1890                 GeeConcurrentSet* _tmp18_;
1891                 GCompareDataFunc _tmp19_;
1892                 void* _tmp19__target;
1893                 gboolean _tmp20_ = FALSE;
1894                 GeeConcurrentSetTower* _tmp21_;
1895                 gboolean _tmp22_;
1896                 GeeConcurrentSetTower* _tmp39_;
1897                 GeeConcurrentSetTower* _tmp40_;
1898                 GeeForallFunc _tmp41_;
1899                 void* _tmp41__target;
1900                 GeeConcurrentSetTower* _tmp42_;
1901                 gconstpointer _tmp43_;
1902                 gpointer _tmp44_;
1903                 gboolean _tmp45_ = FALSE;
1904                 _tmp18_ = self->priv->_set;
1905                 _tmp19_ = _tmp18_->priv->_cmp;
1906                 _tmp19__target = _tmp18_->priv->_cmp_target;
1907                 _tmp20_ = gee_concurrent_set_tower_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp19_, _tmp19__target, &new_prev, &new_curr, (guint8) 0, FALSE);
1908                 if (!_tmp20_) {
1909                         break;
1910                 }
1911                 _tmp21_ = self->priv->_curr;
1912                 _vala_assert (_tmp21_ != NULL, "_curr != null");
1913                 _tmp22_ = self->priv->_removed;
1914                 if (!_tmp22_) {
1915                         GeeConcurrentSetTower* _tmp23_;
1916                         GeeConcurrentSetTower* _tmp24_;
1917                         GeeConcurrentSetTower* _tmp25_;
1918                         GeeConcurrentSetTowerIter _tmp26_;
1919                         GeeConcurrentSetTower* _tmp27_;
1920                         gint _tmp28_ = 0;
1921                         gint prev_height;
1922                         _tmp23_ = new_prev;
1923                         _tmp24_ = _gee_concurrent_set_tower_ref0 (_tmp23_);
1924                         _gee_concurrent_set_tower_unref0 (self->priv->_prev._iter[0]);
1925                         self->priv->_prev._iter[0] = _tmp24_;
1926                         _tmp25_ = self->priv->_prev._iter[0];
1927                         _tmp26_ = self->priv->_prev;
1928                         _tmp27_ = _tmp26_._iter[0];
1929                         _tmp28_ = gee_concurrent_set_tower_get_height (_tmp27_);
1930                         prev_height = _tmp28_;
1931                         {
1932                                 gint i;
1933                                 i = 1;
1934                                 {
1935                                         gboolean _tmp29_;
1936                                         _tmp29_ = TRUE;
1937                                         while (TRUE) {
1938                                                 gboolean _tmp30_;
1939                                                 gint _tmp32_;
1940                                                 gint _tmp33_;
1941                                                 gint _tmp34_;
1942                                                 GeeConcurrentSetTowerIter _tmp35_;
1943                                                 GeeConcurrentSetTower* _tmp36_;
1944                                                 GeeConcurrentSetTower* _tmp37_;
1945                                                 GeeConcurrentSetTower* _tmp38_;
1946                                                 _tmp30_ = _tmp29_;
1947                                                 if (!_tmp30_) {
1948                                                         gint _tmp31_;
1949                                                         _tmp31_ = i;
1950                                                         i = _tmp31_ + 1;
1951                                                 }
1952                                                 _tmp29_ = FALSE;
1953                                                 _tmp32_ = i;
1954                                                 _tmp33_ = prev_height;
1955                                                 if (!(_tmp32_ < _tmp33_)) {
1956                                                         break;
1957                                                 }
1958                                                 _tmp34_ = i;
1959                                                 _tmp35_ = self->priv->_prev;
1960                                                 _tmp36_ = _tmp35_._iter[0];
1961                                                 _tmp37_ = _gee_concurrent_set_tower_ref0 (_tmp36_);
1962                                                 _gee_concurrent_set_tower_unref0 (self->priv->_prev._iter[_tmp34_]);
1963                                                 self->priv->_prev._iter[_tmp34_] = _tmp37_;
1964                                                 _tmp38_ = self->priv->_prev._iter[_tmp34_];
1965                                         }
1966                                 }
1967                         }
1968                 }
1969                 _tmp39_ = new_curr;
1970                 _tmp40_ = _gee_concurrent_set_tower_ref0 (_tmp39_);
1971                 _gee_concurrent_set_tower_unref0 (self->priv->_curr);
1972                 self->priv->_curr = _tmp40_;
1973                 self->priv->_removed = FALSE;
1974                 _tmp41_ = f;
1975                 _tmp41__target = f_target;
1976                 _tmp42_ = self->priv->_curr;
1977                 _tmp43_ = _tmp42_->_data;
1978                 _tmp44_ = ((_tmp43_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp43_) : ((gpointer) _tmp43_);
1979                 _tmp45_ = _tmp41_ (_tmp44_, _tmp41__target);
1980                 if (!_tmp45_) {
1981                         GeeConcurrentSetTower* _tmp46_;
1982                         _tmp46_ = self->priv->_curr;
1983                         _vala_assert (_tmp46_ != NULL, "_curr != null");
1984                         result = FALSE;
1985                         _gee_concurrent_set_tower_unref0 (new_curr);
1986                         _gee_concurrent_set_tower_unref0 (new_prev);
1987                         _gee_hazard_pointer_context_free0 (ctx);
1988                         return result;
1989                 }
1990         }
1991         _tmp47_ = self->priv->_curr;
1992         _vala_assert (_tmp47_ != NULL, "_curr != null");
1993         result = TRUE;
1994         _gee_concurrent_set_tower_unref0 (new_curr);
1995         _gee_concurrent_set_tower_unref0 (new_prev);
1996         _gee_hazard_pointer_context_free0 (ctx);
1997         return result;
1998 }
1999
2000
2001 static gboolean gee_concurrent_set_iterator_real_next (GeeIterator* base) {
2002         GeeConcurrentSetIterator * self;
2003         gboolean result = FALSE;
2004         GeeHazardPointerContext* _tmp0_;
2005         GeeHazardPointerContext* ctx;
2006         GeeConcurrentSetTowerIter _tmp1_;
2007         GeeConcurrentSetTower* _tmp2_;
2008         GeeConcurrentSetTower* _tmp3_;
2009         GeeConcurrentSetTower* new_prev;
2010         GeeConcurrentSetTower* _tmp4_;
2011         GeeConcurrentSetTower* _tmp5_;
2012         GeeConcurrentSetTower* new_curr;
2013         GeeConcurrentSet* _tmp6_;
2014         GCompareDataFunc _tmp7_;
2015         void* _tmp7__target;
2016         gboolean _tmp8_ = FALSE;
2017         gboolean success;
2018         gboolean _tmp9_;
2019         GeeConcurrentSetTower* _tmp27_;
2020         self = (GeeConcurrentSetIterator*) base;
2021         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2022         ctx = _tmp0_;
2023         _tmp1_ = self->priv->_prev;
2024         _tmp2_ = _tmp1_._iter[0];
2025         _tmp3_ = _gee_concurrent_set_tower_ref0 (_tmp2_);
2026         new_prev = _tmp3_;
2027         _tmp4_ = self->priv->_curr;
2028         _tmp5_ = _gee_concurrent_set_tower_ref0 (_tmp4_);
2029         new_curr = _tmp5_;
2030         _tmp6_ = self->priv->_set;
2031         _tmp7_ = _tmp6_->priv->_cmp;
2032         _tmp7__target = _tmp6_->priv->_cmp_target;
2033         _tmp8_ = gee_concurrent_set_tower_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp7_, _tmp7__target, &new_prev, &new_curr, (guint8) 0, FALSE);
2034         success = _tmp8_;
2035         _tmp9_ = success;
2036         if (_tmp9_) {
2037                 gboolean _tmp10_;
2038                 GeeConcurrentSetTower* _tmp26_;
2039                 _tmp10_ = self->priv->_removed;
2040                 if (!_tmp10_) {
2041                         GeeConcurrentSetTower* _tmp11_;
2042                         GeeConcurrentSetTower* _tmp12_;
2043                         GeeConcurrentSetTowerIter _tmp13_;
2044                         GeeConcurrentSetTower* _tmp14_;
2045                         gint _tmp15_ = 0;
2046                         gint prev_height;
2047                         _tmp11_ = new_prev;
2048                         new_prev = NULL;
2049                         _gee_concurrent_set_tower_unref0 (self->priv->_prev._iter[0]);
2050                         self->priv->_prev._iter[0] = _tmp11_;
2051                         _tmp12_ = self->priv->_prev._iter[0];
2052                         _tmp13_ = self->priv->_prev;
2053                         _tmp14_ = _tmp13_._iter[0];
2054                         _tmp15_ = gee_concurrent_set_tower_get_height (_tmp14_);
2055                         prev_height = _tmp15_;
2056                         {
2057                                 gint i;
2058                                 i = 1;
2059                                 {
2060                                         gboolean _tmp16_;
2061                                         _tmp16_ = TRUE;
2062                                         while (TRUE) {
2063                                                 gboolean _tmp17_;
2064                                                 gint _tmp19_;
2065                                                 gint _tmp20_;
2066                                                 gint _tmp21_;
2067                                                 GeeConcurrentSetTowerIter _tmp22_;
2068                                                 GeeConcurrentSetTower* _tmp23_;
2069                                                 GeeConcurrentSetTower* _tmp24_;
2070                                                 GeeConcurrentSetTower* _tmp25_;
2071                                                 _tmp17_ = _tmp16_;
2072                                                 if (!_tmp17_) {
2073                                                         gint _tmp18_;
2074                                                         _tmp18_ = i;
2075                                                         i = _tmp18_ + 1;
2076                                                 }
2077                                                 _tmp16_ = FALSE;
2078                                                 _tmp19_ = i;
2079                                                 _tmp20_ = prev_height;
2080                                                 if (!(_tmp19_ < _tmp20_)) {
2081                                                         break;
2082                                                 }
2083                                                 _tmp21_ = i;
2084                                                 _tmp22_ = self->priv->_prev;
2085                                                 _tmp23_ = _tmp22_._iter[0];
2086                                                 _tmp24_ = _gee_concurrent_set_tower_ref0 (_tmp23_);
2087                                                 _gee_concurrent_set_tower_unref0 (self->priv->_prev._iter[_tmp21_]);
2088                                                 self->priv->_prev._iter[_tmp21_] = _tmp24_;
2089                                                 _tmp25_ = self->priv->_prev._iter[_tmp21_];
2090                                         }
2091                                 }
2092                         }
2093                 }
2094                 _tmp26_ = new_curr;
2095                 new_curr = NULL;
2096                 _gee_concurrent_set_tower_unref0 (self->priv->_curr);
2097                 self->priv->_curr = _tmp26_;
2098                 self->priv->_removed = FALSE;
2099         }
2100         _tmp27_ = self->priv->_curr;
2101         _vala_assert (_tmp27_ != NULL, "_curr != null");
2102         result = success;
2103         _gee_concurrent_set_tower_unref0 (new_curr);
2104         _gee_concurrent_set_tower_unref0 (new_prev);
2105         _gee_hazard_pointer_context_free0 (ctx);
2106         return result;
2107 }
2108
2109
2110 static gboolean gee_concurrent_set_iterator_real_has_next (GeeIterator* base) {
2111         GeeConcurrentSetIterator * self;
2112         gboolean result = FALSE;
2113         GeeHazardPointerContext* _tmp0_;
2114         GeeHazardPointerContext* ctx;
2115         GeeConcurrentSetTowerIter _tmp1_;
2116         GeeConcurrentSetTower* _tmp2_;
2117         GeeConcurrentSetTower* _tmp3_;
2118         GeeConcurrentSetTower* prev;
2119         GeeConcurrentSetTower* _tmp4_;
2120         GeeConcurrentSetTower* _tmp5_;
2121         GeeConcurrentSetTower* curr;
2122         GeeConcurrentSet* _tmp6_;
2123         GCompareDataFunc _tmp7_;
2124         void* _tmp7__target;
2125         gboolean _tmp8_ = FALSE;
2126         self = (GeeConcurrentSetIterator*) base;
2127         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2128         ctx = _tmp0_;
2129         _tmp1_ = self->priv->_prev;
2130         _tmp2_ = _tmp1_._iter[0];
2131         _tmp3_ = _gee_concurrent_set_tower_ref0 (_tmp2_);
2132         prev = _tmp3_;
2133         _tmp4_ = self->priv->_curr;
2134         _tmp5_ = _gee_concurrent_set_tower_ref0 (_tmp4_);
2135         curr = _tmp5_;
2136         _tmp6_ = self->priv->_set;
2137         _tmp7_ = _tmp6_->priv->_cmp;
2138         _tmp7__target = _tmp6_->priv->_cmp_target;
2139         _tmp8_ = gee_concurrent_set_tower_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp7_, _tmp7__target, &prev, &curr, (guint8) 0, FALSE);
2140         result = _tmp8_;
2141         _gee_concurrent_set_tower_unref0 (curr);
2142         _gee_concurrent_set_tower_unref0 (prev);
2143         _gee_hazard_pointer_context_free0 (ctx);
2144         return result;
2145 }
2146
2147
2148 static gpointer gee_concurrent_set_iterator_real_get (GeeIterator* base) {
2149         GeeConcurrentSetIterator * self;
2150         gpointer result = NULL;
2151         gboolean _tmp0_;
2152         gboolean _tmp1_;
2153         GeeConcurrentSetTower* _tmp2_;
2154         gconstpointer _tmp3_;
2155         gpointer _tmp4_;
2156         self = (GeeConcurrentSetIterator*) base;
2157         _tmp0_ = gee_iterator_get_valid ((GeeIterator*) self);
2158         _tmp1_ = _tmp0_;
2159         _vala_assert (_tmp1_, "valid");
2160         _tmp2_ = self->priv->_curr;
2161         _tmp3_ = _tmp2_->_data;
2162         _tmp4_ = ((_tmp3_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp3_) : ((gpointer) _tmp3_);
2163         result = _tmp4_;
2164         return result;
2165 }
2166
2167
2168 static void gee_concurrent_set_iterator_real_remove (GeeIterator* base) {
2169         GeeConcurrentSetIterator * self;
2170         GeeHazardPointerContext* _tmp0_;
2171         GeeHazardPointerContext* ctx;
2172         gboolean _tmp1_;
2173         gboolean _tmp2_;
2174         GeeConcurrentSet* _tmp3_;
2175         GCompareDataFunc _tmp4_;
2176         void* _tmp4__target;
2177         GeeConcurrentSetTower* _tmp5_;
2178         gboolean _tmp6_ = FALSE;
2179         self = (GeeConcurrentSetIterator*) base;
2180         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2181         ctx = _tmp0_;
2182         _tmp1_ = gee_iterator_get_valid ((GeeIterator*) self);
2183         _tmp2_ = _tmp1_;
2184         _vala_assert (_tmp2_, "valid");
2185         _tmp3_ = self->priv->_set;
2186         _tmp4_ = _tmp3_->priv->_cmp;
2187         _tmp4__target = _tmp3_->priv->_cmp_target;
2188         _tmp5_ = self->priv->_curr;
2189         _tmp6_ = gee_concurrent_set_tower_remove (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp4_, _tmp4__target, &self->priv->_prev, _tmp5_);
2190         if (_tmp6_) {
2191                 GeeConcurrentSet* _tmp7_;
2192                 _tmp7_ = self->priv->_set;
2193                 g_atomic_int_dec_and_test ((volatile gint *) (&_tmp7_->priv->_size));
2194         }
2195         self->priv->_removed = TRUE;
2196         _gee_hazard_pointer_context_free0 (ctx);
2197 }
2198
2199
2200 static gboolean gee_concurrent_set_iterator_real_get_valid (GeeIterator* base) {
2201         gboolean result;
2202         GeeConcurrentSetIterator* self;
2203         gboolean _tmp0_ = FALSE;
2204         GeeConcurrentSetTowerIter _tmp1_;
2205         GeeConcurrentSetTower* _tmp2_;
2206         gboolean _tmp4_;
2207         self = (GeeConcurrentSetIterator*) base;
2208         _tmp1_ = self->priv->_prev;
2209         _tmp2_ = _tmp1_._iter[0];
2210         if (_tmp2_ != NULL) {
2211                 gboolean _tmp3_;
2212                 _tmp3_ = self->priv->_removed;
2213                 _tmp0_ = !_tmp3_;
2214         } else {
2215                 _tmp0_ = FALSE;
2216         }
2217         _tmp4_ = _tmp0_;
2218         result = _tmp4_;
2219         return result;
2220 }
2221
2222
2223 static gboolean gee_concurrent_set_iterator_real_get_read_only (GeeIterator* base) {
2224         gboolean result;
2225         GeeConcurrentSetIterator* self;
2226         self = (GeeConcurrentSetIterator*) base;
2227         result = TRUE;
2228         return result;
2229 }
2230
2231
2232 static void gee_concurrent_set_iterator_class_init (GeeConcurrentSetIteratorClass * klass) {
2233         gee_concurrent_set_iterator_parent_class = g_type_class_peek_parent (klass);
2234         g_type_class_add_private (klass, sizeof (GeeConcurrentSetIteratorPrivate));
2235         G_OBJECT_CLASS (klass)->get_property = _vala_gee_concurrent_set_iterator_get_property;
2236         G_OBJECT_CLASS (klass)->set_property = _vala_gee_concurrent_set_iterator_set_property;
2237         G_OBJECT_CLASS (klass)->finalize = gee_concurrent_set_iterator_finalize;
2238         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_ITERATOR_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2239         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_ITERATOR_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2240         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_ITERATOR_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
2241         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_ITERATOR_VALID, g_param_spec_boolean ("valid", "valid", "valid", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2242         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_ITERATOR_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
2243 }
2244
2245
2246 static GType gee_concurrent_set_iterator_gee_traversable_get_g_type (GeeConcurrentSetIterator* self) {
2247         return self->priv->g_type;
2248 }
2249
2250
2251 static GBoxedCopyFunc gee_concurrent_set_iterator_gee_traversable_get_g_dup_func (GeeConcurrentSetIterator* self) {
2252         return self->priv->g_dup_func;
2253 }
2254
2255
2256 static GDestroyNotify gee_concurrent_set_iterator_gee_traversable_get_g_destroy_func (GeeConcurrentSetIterator* self) {
2257         return self->priv->g_destroy_func;
2258 }
2259
2260
2261 static void gee_concurrent_set_iterator_gee_traversable_interface_init (GeeTraversableIface * iface) {
2262         gee_concurrent_set_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
2263         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_concurrent_set_iterator_real_foreach;
2264         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_concurrent_set_iterator_gee_traversable_get_g_type;
2265         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_concurrent_set_iterator_gee_traversable_get_g_dup_func;
2266         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_concurrent_set_iterator_gee_traversable_get_g_destroy_func;
2267 }
2268
2269
2270 static void gee_concurrent_set_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
2271         gee_concurrent_set_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
2272         iface->next = (gboolean (*)(GeeIterator*)) gee_concurrent_set_iterator_real_next;
2273         iface->has_next = (gboolean (*)(GeeIterator*)) gee_concurrent_set_iterator_real_has_next;
2274         iface->get = (gpointer (*)(GeeIterator*)) gee_concurrent_set_iterator_real_get;
2275         iface->remove = (void (*)(GeeIterator*)) gee_concurrent_set_iterator_real_remove;
2276         iface->get_valid = gee_concurrent_set_iterator_real_get_valid;
2277         iface->get_read_only = gee_concurrent_set_iterator_real_get_read_only;
2278 }
2279
2280
2281 static void gee_concurrent_set_iterator_instance_init (GeeConcurrentSetIterator * self) {
2282         self->priv = GEE_CONCURRENT_SET_ITERATOR_GET_PRIVATE (self);
2283         self->priv->_removed = FALSE;
2284 }
2285
2286
2287 static void gee_concurrent_set_iterator_finalize (GObject* obj) {
2288         GeeConcurrentSetIterator * self;
2289         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_CONCURRENT_SET_TYPE_ITERATOR, GeeConcurrentSetIterator);
2290         _g_object_unref0 (self->priv->_set);
2291         gee_concurrent_set_tower_iter_destroy (&self->priv->_prev);
2292         _gee_concurrent_set_tower_unref0 (self->priv->_curr);
2293         G_OBJECT_CLASS (gee_concurrent_set_iterator_parent_class)->finalize (obj);
2294 }
2295
2296
2297 static GType gee_concurrent_set_iterator_get_type (void) {
2298         static volatile gsize gee_concurrent_set_iterator_type_id__volatile = 0;
2299         if (g_once_init_enter (&gee_concurrent_set_iterator_type_id__volatile)) {
2300                 static const GTypeInfo g_define_type_info = { sizeof (GeeConcurrentSetIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_concurrent_set_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeConcurrentSetIterator), 0, (GInstanceInitFunc) gee_concurrent_set_iterator_instance_init, NULL };
2301                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_concurrent_set_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2302                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_concurrent_set_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
2303                 GType gee_concurrent_set_iterator_type_id;
2304                 gee_concurrent_set_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeConcurrentSetIterator", &g_define_type_info, 0);
2305                 g_type_add_interface_static (gee_concurrent_set_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
2306                 g_type_add_interface_static (gee_concurrent_set_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
2307                 g_once_init_leave (&gee_concurrent_set_iterator_type_id__volatile, gee_concurrent_set_iterator_type_id);
2308         }
2309         return gee_concurrent_set_iterator_type_id__volatile;
2310 }
2311
2312
2313 static void _vala_gee_concurrent_set_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
2314         GeeConcurrentSetIterator * self;
2315         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_CONCURRENT_SET_TYPE_ITERATOR, GeeConcurrentSetIterator);
2316         switch (property_id) {
2317                 case GEE_CONCURRENT_SET_ITERATOR_VALID:
2318                 g_value_set_boolean (value, gee_iterator_get_valid ((GeeIterator*) self));
2319                 break;
2320                 case GEE_CONCURRENT_SET_ITERATOR_READ_ONLY:
2321                 g_value_set_boolean (value, gee_iterator_get_read_only ((GeeIterator*) self));
2322                 break;
2323                 default:
2324                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2325                 break;
2326         }
2327 }
2328
2329
2330 static void _vala_gee_concurrent_set_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
2331         GeeConcurrentSetIterator * self;
2332         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_CONCURRENT_SET_TYPE_ITERATOR, GeeConcurrentSetIterator);
2333         switch (property_id) {
2334                 case GEE_CONCURRENT_SET_ITERATOR_G_TYPE:
2335                 self->priv->g_type = g_value_get_gtype (value);
2336                 break;
2337                 case GEE_CONCURRENT_SET_ITERATOR_G_DUP_FUNC:
2338                 self->priv->g_dup_func = g_value_get_pointer (value);
2339                 break;
2340                 case GEE_CONCURRENT_SET_ITERATOR_G_DESTROY_FUNC:
2341                 self->priv->g_destroy_func = g_value_get_pointer (value);
2342                 break;
2343                 default:
2344                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
2345                 break;
2346         }
2347 }
2348
2349
2350 static gpointer _gee_concurrent_set_range_ref0 (gpointer self) {
2351         return self ? gee_concurrent_set_range_ref (self) : NULL;
2352 }
2353
2354
2355 static GeeConcurrentSetSubSet* gee_concurrent_set_sub_set_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range) {
2356         GeeConcurrentSetSubSet * self = NULL;
2357         GeeConcurrentSetRange* _tmp0_;
2358         GeeConcurrentSetRange* _tmp1_;
2359         g_return_val_if_fail (range != NULL, NULL);
2360         self = (GeeConcurrentSetSubSet*) gee_abstract_sorted_set_construct (object_type, g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func);
2361         self->priv->g_type = g_type;
2362         self->priv->g_dup_func = g_dup_func;
2363         self->priv->g_destroy_func = g_destroy_func;
2364         _tmp0_ = range;
2365         _tmp1_ = _gee_concurrent_set_range_ref0 (_tmp0_);
2366         _gee_concurrent_set_range_unref0 (self->priv->_range);
2367         self->priv->_range = _tmp1_;
2368         return self;
2369 }
2370
2371
2372 static GeeConcurrentSetSubSet* gee_concurrent_set_sub_set_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range) {
2373         return gee_concurrent_set_sub_set_construct (GEE_CONCURRENT_SET_TYPE_SUB_SET, g_type, g_dup_func, g_destroy_func, range);
2374 }
2375
2376
2377 static GeeIterator* gee_concurrent_set_sub_set_real_iterator (GeeAbstractCollection* base) {
2378         GeeConcurrentSetSubSet * self;
2379         GeeIterator* result = NULL;
2380         GeeHazardPointerContext* _tmp0_;
2381         GeeHazardPointerContext* ctx;
2382         GeeConcurrentSetRange* _tmp1_;
2383         GeeConcurrentSetSubIterator* _tmp2_;
2384         self = (GeeConcurrentSetSubSet*) base;
2385         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2386         ctx = _tmp0_;
2387         _tmp1_ = self->priv->_range;
2388         _tmp2_ = gee_concurrent_set_sub_iterator_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_);
2389         result = (GeeIterator*) _tmp2_;
2390         _gee_hazard_pointer_context_free0 (ctx);
2391         return result;
2392 }
2393
2394
2395 static gboolean gee_concurrent_set_sub_set_real_contains (GeeAbstractCollection* base, gconstpointer item) {
2396         GeeConcurrentSetSubSet * self;
2397         gboolean result = FALSE;
2398         GeeHazardPointerContext* _tmp0_;
2399         GeeHazardPointerContext* ctx;
2400         GeeConcurrentSetRange* _tmp1_;
2401         gconstpointer _tmp2_;
2402         gboolean _tmp3_ = FALSE;
2403         GeeConcurrentSetTowerIter prev = {0};
2404         GeeConcurrentSetRange* _tmp4_;
2405         GeeConcurrentSetTowerIter _tmp5_ = {0};
2406         GeeConcurrentSetRange* _tmp6_;
2407         GeeConcurrentSet* _tmp7_;
2408         GCompareDataFunc _tmp8_;
2409         void* _tmp8__target;
2410         gconstpointer _tmp9_;
2411         gboolean _tmp10_ = FALSE;
2412         self = (GeeConcurrentSetSubSet*) base;
2413         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2414         ctx = _tmp0_;
2415         _tmp1_ = self->priv->_range;
2416         _tmp2_ = item;
2417         _tmp3_ = gee_concurrent_set_range_inside (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_);
2418         if (!_tmp3_) {
2419                 result = FALSE;
2420                 _gee_hazard_pointer_context_free0 (ctx);
2421                 return result;
2422         }
2423         _tmp4_ = self->priv->_range;
2424         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp4_, NULL, &_tmp5_);
2425         gee_concurrent_set_tower_iter_destroy (&prev);
2426         prev = _tmp5_;
2427         _tmp6_ = self->priv->_range;
2428         _tmp7_ = _tmp6_->_set;
2429         _tmp8_ = _tmp7_->priv->_cmp;
2430         _tmp8__target = _tmp7_->priv->_cmp_target;
2431         _tmp9_ = item;
2432         _tmp10_ = gee_concurrent_set_tower_search_from_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp8_, _tmp8__target, _tmp9_, &prev, NULL, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
2433         result = _tmp10_;
2434         gee_concurrent_set_tower_iter_destroy (&prev);
2435         _gee_hazard_pointer_context_free0 (ctx);
2436         return result;
2437 }
2438
2439
2440 static gboolean gee_concurrent_set_sub_set_real_add (GeeAbstractCollection* base, gconstpointer key) {
2441         GeeConcurrentSetSubSet * self;
2442         gboolean result = FALSE;
2443         GeeHazardPointerContext* _tmp0_;
2444         GeeHazardPointerContext* ctx;
2445         GeeConcurrentSetRange* _tmp1_;
2446         gconstpointer _tmp2_;
2447         gboolean _tmp3_ = FALSE;
2448         GeeConcurrentSetTowerIter prev = {0};
2449         GeeConcurrentSetRange* _tmp4_;
2450         GeeConcurrentSetTowerIter _tmp5_ = {0};
2451         GPrivate* _tmp6_;
2452         void* _tmp7_ = NULL;
2453         GRand* rnd;
2454         GRand* _tmp8_;
2455         GRand* _tmp12_;
2456         gint32 _tmp13_;
2457         gint32 _tmp14_ = 0;
2458         guint32 rand_int;
2459         guint32 _tmp15_;
2460         gint _tmp16_ = 0;
2461         guint8 height;
2462         GeeConcurrentSetRange* _tmp17_;
2463         GeeConcurrentSet* _tmp18_;
2464         GCompareDataFunc _tmp19_;
2465         void* _tmp19__target;
2466         gconstpointer _tmp20_;
2467         guint8 _tmp21_;
2468         gboolean _tmp22_ = FALSE;
2469         GeeConcurrentSetRange* _tmp34_;
2470         GeeConcurrentSet* _tmp35_;
2471         GCompareDataFunc _tmp36_;
2472         void* _tmp36__target;
2473         gconstpointer _tmp37_;
2474         guint8 _tmp38_;
2475         GeeConcurrentSetTower* _tmp39_ = NULL;
2476         GeeConcurrentSetTower* _result_;
2477         GeeConcurrentSetTower* _tmp40_;
2478         GeeConcurrentSetTower* _tmp43_;
2479         self = (GeeConcurrentSetSubSet*) base;
2480         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2481         ctx = _tmp0_;
2482         _tmp1_ = self->priv->_range;
2483         _tmp2_ = key;
2484         _tmp3_ = gee_concurrent_set_range_inside (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_);
2485         if (!_tmp3_) {
2486                 result = FALSE;
2487                 _gee_hazard_pointer_context_free0 (ctx);
2488                 return result;
2489         }
2490         _tmp4_ = self->priv->_range;
2491         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp4_, NULL, &_tmp5_);
2492         gee_concurrent_set_tower_iter_destroy (&prev);
2493         prev = _tmp5_;
2494         _tmp6_ = gee_concurrent_set_rand;
2495         _tmp7_ = g_private_get (_tmp6_);
2496         rnd = _tmp7_;
2497         _tmp8_ = rnd;
2498         if (_tmp8_ == NULL) {
2499                 GPrivate* _tmp9_;
2500                 GRand* _tmp10_;
2501                 GRand* _tmp11_;
2502                 _tmp9_ = gee_concurrent_set_rand;
2503                 _tmp10_ = g_rand_new ();
2504                 rnd = _tmp10_;
2505                 _tmp11_ = rnd;
2506                 g_private_set (_tmp9_, _tmp11_);
2507         }
2508         _tmp12_ = rnd;
2509         _tmp13_ = G_MAXINT32;
2510         _tmp14_ = g_rand_int_range (_tmp12_, (gint32) 0, _tmp13_);
2511         rand_int = (guint32) _tmp14_;
2512         _tmp15_ = rand_int;
2513         _tmp16_ = g_bit_nth_lsf ((gulong) (~_tmp15_), -1);
2514         height = (guint8) (1 + ((guint8) _tmp16_));
2515         _tmp17_ = self->priv->_range;
2516         _tmp18_ = _tmp17_->_set;
2517         _tmp19_ = _tmp18_->priv->_cmp;
2518         _tmp19__target = _tmp18_->priv->_cmp_target;
2519         _tmp20_ = key;
2520         _tmp21_ = height;
2521         _tmp22_ = gee_concurrent_set_tower_search_from_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp19_, _tmp19__target, _tmp20_, &prev, NULL, (guint8) (_tmp21_ - 1), (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
2522         if (_tmp22_) {
2523                 result = FALSE;
2524                 gee_concurrent_set_tower_iter_destroy (&prev);
2525                 _gee_hazard_pointer_context_free0 (ctx);
2526                 return result;
2527         }
2528         {
2529                 guint8 _tmp23_;
2530                 gint i;
2531                 _tmp23_ = height;
2532                 i = _tmp23_ - 2;
2533                 {
2534                         gboolean _tmp24_;
2535                         _tmp24_ = TRUE;
2536                         while (TRUE) {
2537                                 gboolean _tmp25_;
2538                                 gint _tmp27_;
2539                                 gint _tmp28_;
2540                                 GeeConcurrentSetTowerIter _tmp29_;
2541                                 guint8 _tmp30_;
2542                                 GeeConcurrentSetTower* _tmp31_;
2543                                 GeeConcurrentSetTower* _tmp32_;
2544                                 GeeConcurrentSetTower* _tmp33_;
2545                                 _tmp25_ = _tmp24_;
2546                                 if (!_tmp25_) {
2547                                         gint _tmp26_;
2548                                         _tmp26_ = i;
2549                                         i = _tmp26_ - 1;
2550                                 }
2551                                 _tmp24_ = FALSE;
2552                                 _tmp27_ = i;
2553                                 if (!(_tmp27_ >= 0)) {
2554                                         break;
2555                                 }
2556                                 _tmp28_ = i;
2557                                 _tmp29_ = prev;
2558                                 _tmp30_ = height;
2559                                 _tmp31_ = _tmp29_._iter[_tmp30_ - 1];
2560                                 _tmp32_ = _gee_concurrent_set_tower_ref0 (_tmp31_);
2561                                 _gee_concurrent_set_tower_unref0 (prev._iter[_tmp28_]);
2562                                 prev._iter[_tmp28_] = _tmp32_;
2563                                 _tmp33_ = prev._iter[_tmp28_];
2564                         }
2565                 }
2566         }
2567         _tmp34_ = self->priv->_range;
2568         _tmp35_ = _tmp34_->_set;
2569         _tmp36_ = _tmp35_->priv->_cmp;
2570         _tmp36__target = _tmp35_->priv->_cmp_target;
2571         _tmp37_ = key;
2572         _tmp38_ = height;
2573         _tmp39_ = gee_concurrent_set_tower_insert (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp36_, _tmp36__target, &prev, _tmp37_, (guint8) (_tmp38_ - 1));
2574         _result_ = _tmp39_;
2575         _tmp40_ = _result_;
2576         if (_tmp40_ != NULL) {
2577                 GeeConcurrentSetRange* _tmp41_;
2578                 GeeConcurrentSet* _tmp42_;
2579                 _tmp41_ = self->priv->_range;
2580                 _tmp42_ = _tmp41_->_set;
2581                 g_atomic_int_inc ((volatile gint *) (&_tmp42_->priv->_size));
2582         }
2583         _tmp43_ = _result_;
2584         result = _tmp43_ != NULL;
2585         _gee_concurrent_set_tower_unref0 (_result_);
2586         gee_concurrent_set_tower_iter_destroy (&prev);
2587         _gee_hazard_pointer_context_free0 (ctx);
2588         return result;
2589 }
2590
2591
2592 static gboolean gee_concurrent_set_sub_set_real_remove (GeeAbstractCollection* base, gconstpointer key) {
2593         GeeConcurrentSetSubSet * self;
2594         gboolean result = FALSE;
2595         GeeHazardPointerContext* _tmp0_;
2596         GeeHazardPointerContext* ctx;
2597         GeeConcurrentSetRange* _tmp1_;
2598         gconstpointer _tmp2_;
2599         gboolean _tmp3_ = FALSE;
2600         GeeConcurrentSetTowerIter prev = {0};
2601         GeeConcurrentSetRange* _tmp4_;
2602         GeeConcurrentSetTowerIter _tmp5_ = {0};
2603         GeeConcurrentSetRange* _tmp6_;
2604         GeeConcurrentSet* _tmp7_;
2605         GCompareDataFunc _tmp8_;
2606         void* _tmp8__target;
2607         gconstpointer _tmp9_;
2608         gboolean _tmp10_ = FALSE;
2609         gboolean _result_;
2610         gboolean _tmp11_;
2611         self = (GeeConcurrentSetSubSet*) base;
2612         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2613         ctx = _tmp0_;
2614         _tmp1_ = self->priv->_range;
2615         _tmp2_ = key;
2616         _tmp3_ = gee_concurrent_set_range_inside (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_);
2617         if (!_tmp3_) {
2618                 result = FALSE;
2619                 _gee_hazard_pointer_context_free0 (ctx);
2620                 return result;
2621         }
2622         _tmp4_ = self->priv->_range;
2623         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp4_, NULL, &_tmp5_);
2624         gee_concurrent_set_tower_iter_destroy (&prev);
2625         prev = _tmp5_;
2626         _tmp6_ = self->priv->_range;
2627         _tmp7_ = _tmp6_->_set;
2628         _tmp8_ = _tmp7_->priv->_cmp;
2629         _tmp8__target = _tmp7_->priv->_cmp_target;
2630         _tmp9_ = key;
2631         _tmp10_ = gee_concurrent_set_tower_remove_key (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp8_, _tmp8__target, &prev, _tmp9_, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
2632         _result_ = _tmp10_;
2633         _tmp11_ = _result_;
2634         if (_tmp11_) {
2635                 GeeConcurrentSetRange* _tmp12_;
2636                 GeeConcurrentSet* _tmp13_;
2637                 _tmp12_ = self->priv->_range;
2638                 _tmp13_ = _tmp12_->_set;
2639                 g_atomic_int_dec_and_test ((volatile gint *) (&_tmp13_->priv->_size));
2640         }
2641         result = _result_;
2642         gee_concurrent_set_tower_iter_destroy (&prev);
2643         _gee_hazard_pointer_context_free0 (ctx);
2644         return result;
2645 }
2646
2647
2648 static void gee_concurrent_set_sub_set_real_clear (GeeAbstractCollection* base) {
2649         GeeConcurrentSetSubSet * self;
2650         GeeHazardPointerContext* _tmp0_;
2651         GeeHazardPointerContext* ctx;
2652         GeeConcurrentSetTowerIter prev = {0};
2653         GeeConcurrentSetTower* first = NULL;
2654         GeeConcurrentSetRange* _tmp1_;
2655         GeeConcurrentSetTower* _tmp2_ = NULL;
2656         GeeConcurrentSetTowerIter _tmp3_ = {0};
2657         self = (GeeConcurrentSetSubSet*) base;
2658         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2659         ctx = _tmp0_;
2660         _tmp1_ = self->priv->_range;
2661         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, &_tmp2_, &_tmp3_);
2662         _gee_concurrent_set_tower_unref0 (first);
2663         first = _tmp2_;
2664         gee_concurrent_set_tower_iter_destroy (&prev);
2665         prev = _tmp3_;
2666         while (TRUE) {
2667                 GeeConcurrentSetTower* _tmp4_;
2668                 GeeConcurrentSetRange* _tmp5_;
2669                 GeeConcurrentSet* _tmp6_;
2670                 GCompareDataFunc _tmp7_;
2671                 void* _tmp7__target;
2672                 GeeConcurrentSetTower* _tmp8_;
2673                 GeeConcurrentSetRange* _tmp9_;
2674                 GeeConcurrentSetTower* _tmp10_ = NULL;
2675                 GeeConcurrentSetTowerIter _tmp11_ = {0};
2676                 _tmp4_ = first;
2677                 if (!(_tmp4_ != NULL)) {
2678                         break;
2679                 }
2680                 _tmp5_ = self->priv->_range;
2681                 _tmp6_ = _tmp5_->_set;
2682                 _tmp7_ = _tmp6_->priv->_cmp;
2683                 _tmp7__target = _tmp6_->priv->_cmp_target;
2684                 _tmp8_ = first;
2685                 gee_concurrent_set_tower_remove (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp7_, _tmp7__target, &prev, _tmp8_);
2686                 _tmp9_ = self->priv->_range;
2687                 gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp9_, &_tmp10_, &_tmp11_);
2688                 _gee_concurrent_set_tower_unref0 (first);
2689                 first = _tmp10_;
2690                 gee_concurrent_set_tower_iter_destroy (&prev);
2691                 prev = _tmp11_;
2692         }
2693         _gee_concurrent_set_tower_unref0 (first);
2694         gee_concurrent_set_tower_iter_destroy (&prev);
2695         _gee_hazard_pointer_context_free0 (ctx);
2696 }
2697
2698
2699 static gpointer gee_concurrent_set_sub_set_real_first (GeeAbstractSortedSet* base) {
2700         GeeConcurrentSetSubSet * self;
2701         gpointer result = NULL;
2702         GeeHazardPointerContext* _tmp0_;
2703         GeeHazardPointerContext* ctx;
2704         GeeConcurrentSetTower* first = NULL;
2705         GeeConcurrentSetRange* _tmp1_;
2706         GeeConcurrentSetTower* _tmp2_ = NULL;
2707         GeeConcurrentSetTower* _tmp3_;
2708         GeeConcurrentSetTower* _tmp4_;
2709         gconstpointer _tmp5_;
2710         gpointer _tmp6_;
2711         self = (GeeConcurrentSetSubSet*) base;
2712         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2713         ctx = _tmp0_;
2714         _tmp1_ = self->priv->_range;
2715         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, &_tmp2_, NULL);
2716         _gee_concurrent_set_tower_unref0 (first);
2717         first = _tmp2_;
2718         _tmp3_ = first;
2719         if (_tmp3_ == NULL) {
2720                 result = NULL;
2721                 _gee_concurrent_set_tower_unref0 (first);
2722                 _gee_hazard_pointer_context_free0 (ctx);
2723                 return result;
2724         }
2725         _tmp4_ = first;
2726         _tmp5_ = _tmp4_->_data;
2727         _tmp6_ = ((_tmp5_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp5_) : ((gpointer) _tmp5_);
2728         result = _tmp6_;
2729         _gee_concurrent_set_tower_unref0 (first);
2730         _gee_hazard_pointer_context_free0 (ctx);
2731         return result;
2732 }
2733
2734
2735 static gpointer gee_concurrent_set_sub_set_real_last (GeeAbstractSortedSet* base) {
2736         GeeConcurrentSetSubSet * self;
2737         gpointer result = NULL;
2738         GeeHazardPointerContext* _tmp0_;
2739         GeeHazardPointerContext* ctx;
2740         GeeConcurrentSetTowerIter prev = {0};
2741         GeeConcurrentSetRange* _tmp1_;
2742         GeeConcurrentSetTowerIter _tmp2_ = {0};
2743         GeeConcurrentSetTower* curr;
2744         GeeConcurrentSetTower* _tmp34_;
2745         GeeConcurrentSetTower* _tmp35_;
2746         gconstpointer _tmp36_;
2747         gpointer _tmp37_;
2748         self = (GeeConcurrentSetSubSet*) base;
2749         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2750         ctx = _tmp0_;
2751         _tmp1_ = self->priv->_range;
2752         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, NULL, &_tmp2_);
2753         gee_concurrent_set_tower_iter_destroy (&prev);
2754         prev = _tmp2_;
2755         curr = NULL;
2756         {
2757                 gint i;
2758                 i = GEE_CONCURRENT_SET__MAX_HEIGHT - 1;
2759                 {
2760                         gboolean _tmp3_;
2761                         _tmp3_ = TRUE;
2762                         while (TRUE) {
2763                                 gboolean _tmp4_;
2764                                 gint _tmp6_;
2765                                 GeeConcurrentSetTower* _tmp7_;
2766                                 gboolean improved;
2767                                 gboolean _tmp24_ = FALSE;
2768                                 gboolean _tmp25_;
2769                                 gboolean _tmp27_;
2770                                 _tmp4_ = _tmp3_;
2771                                 if (!_tmp4_) {
2772                                         gint _tmp5_;
2773                                         _tmp5_ = i;
2774                                         i = _tmp5_ - 1;
2775                                 }
2776                                 _tmp3_ = FALSE;
2777                                 _tmp6_ = i;
2778                                 if (!(_tmp6_ >= 0)) {
2779                                         break;
2780                                 }
2781                                 _tmp7_ = curr;
2782                                 if (_tmp7_ == NULL) {
2783                                         GeeConcurrentSetTowerIter _tmp8_;
2784                                         gint _tmp9_;
2785                                         GeeConcurrentSetTower* _tmp10_;
2786                                         gint _tmp11_;
2787                                         GeeConcurrentSetTower* _tmp12_ = NULL;
2788                                         gboolean _tmp13_ = FALSE;
2789                                         GeeConcurrentSetTower* _tmp14_;
2790                                         gboolean _tmp19_;
2791                                         _tmp8_ = prev;
2792                                         _tmp9_ = i;
2793                                         _tmp10_ = _tmp8_._iter[_tmp9_];
2794                                         _tmp11_ = i;
2795                                         _tmp12_ = gee_concurrent_set_tower_get_next (_tmp10_, (guint8) _tmp11_);
2796                                         _gee_concurrent_set_tower_unref0 (curr);
2797                                         curr = _tmp12_;
2798                                         _tmp14_ = curr;
2799                                         if (_tmp14_ == NULL) {
2800                                                 _tmp13_ = TRUE;
2801                                         } else {
2802                                                 GeeConcurrentSetRange* _tmp15_;
2803                                                 GeeConcurrentSetTower* _tmp16_;
2804                                                 gconstpointer _tmp17_;
2805                                                 gboolean _tmp18_ = FALSE;
2806                                                 _tmp15_ = self->priv->_range;
2807                                                 _tmp16_ = curr;
2808                                                 _tmp17_ = _tmp16_->_data;
2809                                                 _tmp18_ = gee_concurrent_set_range_inside (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp15_, _tmp17_);
2810                                                 _tmp13_ = !_tmp18_;
2811                                         }
2812                                         _tmp19_ = _tmp13_;
2813                                         if (_tmp19_) {
2814                                                 _gee_concurrent_set_tower_unref0 (curr);
2815                                                 curr = NULL;
2816                                                 continue;
2817                                         }
2818                                 }
2819                                 improved = FALSE;
2820                                 while (TRUE) {
2821                                         GeeConcurrentSetRange* _tmp20_;
2822                                         gint _tmp21_;
2823                                         gint _tmp22_;
2824                                         gboolean _tmp23_ = FALSE;
2825                                         _tmp20_ = self->priv->_range;
2826                                         _tmp21_ = i;
2827                                         _tmp22_ = i;
2828                                         _tmp23_ = gee_concurrent_set_range_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp20_, &prev._iter[_tmp21_], &curr, (guint8) _tmp22_);
2829                                         if (!_tmp23_) {
2830                                                 break;
2831                                         }
2832                                         improved = TRUE;
2833                                 }
2834                                 _tmp25_ = improved;
2835                                 if (_tmp25_) {
2836                                         gint _tmp26_;
2837                                         _tmp26_ = i;
2838                                         _tmp24_ = _tmp26_ > 0;
2839                                 } else {
2840                                         _tmp24_ = FALSE;
2841                                 }
2842                                 _tmp27_ = _tmp24_;
2843                                 if (_tmp27_) {
2844                                         gint _tmp28_;
2845                                         GeeConcurrentSetTowerIter _tmp29_;
2846                                         gint _tmp30_;
2847                                         GeeConcurrentSetTower* _tmp31_;
2848                                         GeeConcurrentSetTower* _tmp32_;
2849                                         GeeConcurrentSetTower* _tmp33_;
2850                                         _tmp28_ = i;
2851                                         _tmp29_ = prev;
2852                                         _tmp30_ = i;
2853                                         _tmp31_ = _tmp29_._iter[_tmp30_];
2854                                         _tmp32_ = _gee_concurrent_set_tower_ref0 (_tmp31_);
2855                                         _gee_concurrent_set_tower_unref0 (prev._iter[_tmp28_ - 1]);
2856                                         prev._iter[_tmp28_ - 1] = _tmp32_;
2857                                         _tmp33_ = prev._iter[_tmp28_ - 1];
2858                                 }
2859                         }
2860                 }
2861         }
2862         _tmp34_ = curr;
2863         if (_tmp34_ == NULL) {
2864                 result = NULL;
2865                 _gee_concurrent_set_tower_unref0 (curr);
2866                 gee_concurrent_set_tower_iter_destroy (&prev);
2867                 _gee_hazard_pointer_context_free0 (ctx);
2868                 return result;
2869         }
2870         _tmp35_ = curr;
2871         _tmp36_ = _tmp35_->_data;
2872         _tmp37_ = ((_tmp36_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp36_) : ((gpointer) _tmp36_);
2873         result = _tmp37_;
2874         _gee_concurrent_set_tower_unref0 (curr);
2875         gee_concurrent_set_tower_iter_destroy (&prev);
2876         _gee_hazard_pointer_context_free0 (ctx);
2877         return result;
2878 }
2879
2880
2881 static GeeIterator* gee_concurrent_set_sub_set_real_iterator_at (GeeAbstractSortedSet* base, gconstpointer element) {
2882         GeeConcurrentSetSubSet * self;
2883         GeeIterator* result = NULL;
2884         GeeHazardPointerContext* _tmp0_;
2885         GeeHazardPointerContext* ctx;
2886         GeeConcurrentSetRange* _tmp1_;
2887         gconstpointer _tmp2_;
2888         gboolean _tmp3_ = FALSE;
2889         GeeConcurrentSetTowerIter prev = {0};
2890         GeeConcurrentSetTowerIter next = {0};
2891         GeeConcurrentSetRange* _tmp4_;
2892         GeeConcurrentSetTowerIter _tmp5_ = {0};
2893         GeeConcurrentSetRange* _tmp6_;
2894         GeeConcurrentSet* _tmp7_;
2895         GCompareDataFunc _tmp8_;
2896         void* _tmp8__target;
2897         gconstpointer _tmp9_;
2898         GeeConcurrentSetTowerIter _tmp10_ = {0};
2899         gboolean _tmp11_ = FALSE;
2900         GeeConcurrentSetRange* _tmp12_;
2901         GeeConcurrentSetTowerIter _tmp13_;
2902         GeeConcurrentSetTower* _tmp14_;
2903         GeeConcurrentSetTower* _tmp15_;
2904         GeeConcurrentSetSubIterator* _tmp16_;
2905         self = (GeeConcurrentSetSubSet*) base;
2906         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2907         ctx = _tmp0_;
2908         _tmp1_ = self->priv->_range;
2909         _tmp2_ = element;
2910         _tmp3_ = gee_concurrent_set_range_inside (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_);
2911         if (!_tmp3_) {
2912                 result = NULL;
2913                 _gee_hazard_pointer_context_free0 (ctx);
2914                 return result;
2915         }
2916         _tmp4_ = self->priv->_range;
2917         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp4_, NULL, &_tmp5_);
2918         gee_concurrent_set_tower_iter_destroy (&prev);
2919         prev = _tmp5_;
2920         _tmp6_ = self->priv->_range;
2921         _tmp7_ = _tmp6_->_set;
2922         _tmp8_ = _tmp7_->priv->_cmp;
2923         _tmp8__target = _tmp7_->priv->_cmp_target;
2924         _tmp9_ = element;
2925         _tmp11_ = gee_concurrent_set_tower_search_from_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp8_, _tmp8__target, _tmp9_, &prev, &_tmp10_, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
2926         gee_concurrent_set_tower_iter_destroy (&next);
2927         next = _tmp10_;
2928         if (!_tmp11_) {
2929                 result = NULL;
2930                 gee_concurrent_set_tower_iter_destroy (&next);
2931                 gee_concurrent_set_tower_iter_destroy (&prev);
2932                 _gee_hazard_pointer_context_free0 (ctx);
2933                 return result;
2934         }
2935         _tmp12_ = self->priv->_range;
2936         _tmp13_ = next;
2937         _tmp14_ = _tmp13_._iter[0];
2938         _tmp15_ = _gee_concurrent_set_tower_ref0 (_tmp14_);
2939         _tmp16_ = gee_concurrent_set_sub_iterator_new_point_at (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp12_, &prev, _tmp15_);
2940         result = (GeeIterator*) _tmp16_;
2941         gee_concurrent_set_tower_iter_destroy (&next);
2942         gee_concurrent_set_tower_iter_destroy (&prev);
2943         _gee_hazard_pointer_context_free0 (ctx);
2944         return result;
2945 }
2946
2947
2948 static gpointer gee_concurrent_set_sub_set_real_lower (GeeAbstractSortedSet* base, gconstpointer element) {
2949         GeeConcurrentSetSubSet * self;
2950         gpointer result = NULL;
2951         GeeHazardPointerContext* _tmp0_;
2952         GeeHazardPointerContext* ctx;
2953         GeeConcurrentSetRange* _tmp1_;
2954         gconstpointer _tmp2_;
2955         gint _tmp3_ = 0;
2956         self = (GeeConcurrentSetSubSet*) base;
2957         _tmp0_ = gee_hazard_pointer_context_new (NULL);
2958         ctx = _tmp0_;
2959         _tmp1_ = self->priv->_range;
2960         _tmp2_ = element;
2961         _tmp3_ = gee_concurrent_set_range_cmp (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_);
2962         switch (_tmp3_) {
2963                 case GEE_CONCURRENT_SET_RANGE_POSITION_BEFORE:
2964                 case GEE_CONCURRENT_SET_RANGE_POSITION_EMPTY:
2965                 {
2966                         result = NULL;
2967                         _gee_hazard_pointer_context_free0 (ctx);
2968                         return result;
2969                 }
2970                 case GEE_CONCURRENT_SET_RANGE_POSITION_INSIDE:
2971                 {
2972                         GeeConcurrentSetTowerIter prev = {0};
2973                         GeeConcurrentSetRange* _tmp4_;
2974                         GeeConcurrentSetTowerIter _tmp5_ = {0};
2975                         GeeConcurrentSetRange* _tmp6_;
2976                         GeeConcurrentSet* _tmp7_;
2977                         GCompareDataFunc _tmp8_;
2978                         void* _tmp8__target;
2979                         gconstpointer _tmp9_;
2980                         gboolean _tmp10_ = FALSE;
2981                         GeeConcurrentSetTowerIter _tmp11_;
2982                         GeeConcurrentSetTower* _tmp12_;
2983                         GeeConcurrentSetRange* _tmp13_;
2984                         GeeConcurrentSet* _tmp14_;
2985                         GeeConcurrentSetTower* _tmp15_;
2986                         gboolean _tmp21_;
2987                         GeeConcurrentSetTowerIter _tmp22_;
2988                         GeeConcurrentSetTower* _tmp23_;
2989                         gconstpointer _tmp24_;
2990                         gpointer _tmp25_;
2991                         _tmp4_ = self->priv->_range;
2992                         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp4_, NULL, &_tmp5_);
2993                         gee_concurrent_set_tower_iter_destroy (&prev);
2994                         prev = _tmp5_;
2995                         _tmp6_ = self->priv->_range;
2996                         _tmp7_ = _tmp6_->_set;
2997                         _tmp8_ = _tmp7_->priv->_cmp;
2998                         _tmp8__target = _tmp7_->priv->_cmp_target;
2999                         _tmp9_ = element;
3000                         gee_concurrent_set_tower_search_from_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp8_, _tmp8__target, _tmp9_, &prev, NULL, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
3001                         _tmp11_ = prev;
3002                         _tmp12_ = _tmp11_._iter[0];
3003                         _tmp13_ = self->priv->_range;
3004                         _tmp14_ = _tmp13_->_set;
3005                         _tmp15_ = _tmp14_->priv->_head;
3006                         if (_tmp12_ == _tmp15_) {
3007                                 _tmp10_ = TRUE;
3008                         } else {
3009                                 GeeConcurrentSetRange* _tmp16_;
3010                                 GeeConcurrentSetTowerIter _tmp17_;
3011                                 GeeConcurrentSetTower* _tmp18_;
3012                                 gconstpointer _tmp19_;
3013                                 gboolean _tmp20_ = FALSE;
3014                                 _tmp16_ = self->priv->_range;
3015                                 _tmp17_ = prev;
3016                                 _tmp18_ = _tmp17_._iter[0];
3017                                 _tmp19_ = _tmp18_->_data;
3018                                 _tmp20_ = gee_concurrent_set_range_inside (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp16_, _tmp19_);
3019                                 _tmp10_ = !_tmp20_;
3020                         }
3021                         _tmp21_ = _tmp10_;
3022                         if (_tmp21_) {
3023                                 result = NULL;
3024                                 gee_concurrent_set_tower_iter_destroy (&prev);
3025                                 _gee_hazard_pointer_context_free0 (ctx);
3026                                 return result;
3027                         }
3028                         _tmp22_ = prev;
3029                         _tmp23_ = _tmp22_._iter[0];
3030                         _tmp24_ = _tmp23_->_data;
3031                         _tmp25_ = ((_tmp24_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp24_) : ((gpointer) _tmp24_);
3032                         result = _tmp25_;
3033                         gee_concurrent_set_tower_iter_destroy (&prev);
3034                         _gee_hazard_pointer_context_free0 (ctx);
3035                         return result;
3036                 }
3037                 case GEE_CONCURRENT_SET_RANGE_POSITION_AFTER:
3038                 {
3039                         gpointer _tmp26_ = NULL;
3040                         _tmp26_ = gee_abstract_sorted_set_last ((GeeAbstractSortedSet*) self);
3041                         result = _tmp26_;
3042                         _gee_hazard_pointer_context_free0 (ctx);
3043                         return result;
3044                 }
3045                 default:
3046                 {
3047                         g_assert_not_reached ();
3048                 }
3049         }
3050         _gee_hazard_pointer_context_free0 (ctx);
3051 }
3052
3053
3054 static gpointer gee_concurrent_set_sub_set_real_higher (GeeAbstractSortedSet* base, gconstpointer element) {
3055         GeeConcurrentSetSubSet * self;
3056         gpointer result = NULL;
3057         GeeHazardPointerContext* _tmp0_;
3058         GeeHazardPointerContext* ctx;
3059         GeeConcurrentSetRange* _tmp1_;
3060         gconstpointer _tmp2_;
3061         gint _tmp3_ = 0;
3062         self = (GeeConcurrentSetSubSet*) base;
3063         _tmp0_ = gee_hazard_pointer_context_new (NULL);
3064         ctx = _tmp0_;
3065         _tmp1_ = self->priv->_range;
3066         _tmp2_ = element;
3067         _tmp3_ = gee_concurrent_set_range_cmp (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_);
3068         switch (_tmp3_) {
3069                 case GEE_CONCURRENT_SET_RANGE_POSITION_BEFORE:
3070                 {
3071                         gpointer _tmp4_ = NULL;
3072                         _tmp4_ = gee_abstract_sorted_set_first ((GeeAbstractSortedSet*) self);
3073                         result = _tmp4_;
3074                         _gee_hazard_pointer_context_free0 (ctx);
3075                         return result;
3076                 }
3077                 case GEE_CONCURRENT_SET_RANGE_POSITION_INSIDE:
3078                 {
3079                         GeeConcurrentSetTowerIter prev = {0};
3080                         GeeConcurrentSetTowerIter curr = {0};
3081                         GeeConcurrentSetRange* _tmp5_;
3082                         GeeConcurrentSetTowerIter _tmp6_ = {0};
3083                         GeeConcurrentSetRange* _tmp7_;
3084                         GeeConcurrentSet* _tmp8_;
3085                         GCompareDataFunc _tmp9_;
3086                         void* _tmp9__target;
3087                         gconstpointer _tmp10_;
3088                         GeeConcurrentSetTowerIter _tmp11_ = {0};
3089                         gboolean _tmp12_ = FALSE;
3090                         gboolean _tmp17_ = FALSE;
3091                         GeeConcurrentSetTowerIter _tmp18_;
3092                         GeeConcurrentSetTower* _tmp19_;
3093                         gboolean _tmp25_;
3094                         GeeConcurrentSetTowerIter _tmp26_;
3095                         GeeConcurrentSetTower* _tmp27_;
3096                         gconstpointer _tmp28_;
3097                         gpointer _tmp29_;
3098                         _tmp5_ = self->priv->_range;
3099                         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp5_, NULL, &_tmp6_);
3100                         gee_concurrent_set_tower_iter_destroy (&prev);
3101                         prev = _tmp6_;
3102                         _tmp7_ = self->priv->_range;
3103                         _tmp8_ = _tmp7_->_set;
3104                         _tmp9_ = _tmp8_->priv->_cmp;
3105                         _tmp9__target = _tmp8_->priv->_cmp_target;
3106                         _tmp10_ = element;
3107                         _tmp12_ = gee_concurrent_set_tower_search_from_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp9_, _tmp9__target, _tmp10_, &prev, &_tmp11_, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
3108                         gee_concurrent_set_tower_iter_destroy (&curr);
3109                         curr = _tmp11_;
3110                         if (_tmp12_) {
3111                                 GeeConcurrentSetRange* _tmp13_;
3112                                 GeeConcurrentSet* _tmp14_;
3113                                 GCompareDataFunc _tmp15_;
3114                                 void* _tmp15__target;
3115                                 gboolean _tmp16_ = FALSE;
3116                                 _tmp13_ = self->priv->_range;
3117                                 _tmp14_ = _tmp13_->_set;
3118                                 _tmp15_ = _tmp14_->priv->_cmp;
3119                                 _tmp15__target = _tmp14_->priv->_cmp_target;
3120                                 _tmp16_ = gee_concurrent_set_tower_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp15_, _tmp15__target, &prev._iter[0], &curr._iter[0], (guint8) 0, FALSE);
3121                                 if (!_tmp16_) {
3122                                         result = NULL;
3123                                         gee_concurrent_set_tower_iter_destroy (&curr);
3124                                         gee_concurrent_set_tower_iter_destroy (&prev);
3125                                         _gee_hazard_pointer_context_free0 (ctx);
3126                                         return result;
3127                                 }
3128                         }
3129                         _tmp18_ = curr;
3130                         _tmp19_ = _tmp18_._iter[0];
3131                         if (_tmp19_ == NULL) {
3132                                 _tmp17_ = TRUE;
3133                         } else {
3134                                 GeeConcurrentSetRange* _tmp20_;
3135                                 GeeConcurrentSetTowerIter _tmp21_;
3136                                 GeeConcurrentSetTower* _tmp22_;
3137                                 gconstpointer _tmp23_;
3138                                 gboolean _tmp24_ = FALSE;
3139                                 _tmp20_ = self->priv->_range;
3140                                 _tmp21_ = curr;
3141                                 _tmp22_ = _tmp21_._iter[0];
3142                                 _tmp23_ = _tmp22_->_data;
3143                                 _tmp24_ = gee_concurrent_set_range_inside (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp20_, _tmp23_);
3144                                 _tmp17_ = !_tmp24_;
3145                         }
3146                         _tmp25_ = _tmp17_;
3147                         if (_tmp25_) {
3148                                 result = NULL;
3149                                 gee_concurrent_set_tower_iter_destroy (&curr);
3150                                 gee_concurrent_set_tower_iter_destroy (&prev);
3151                                 _gee_hazard_pointer_context_free0 (ctx);
3152                                 return result;
3153                         }
3154                         _tmp26_ = curr;
3155                         _tmp27_ = _tmp26_._iter[0];
3156                         _tmp28_ = _tmp27_->_data;
3157                         _tmp29_ = ((_tmp28_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp28_) : ((gpointer) _tmp28_);
3158                         result = _tmp29_;
3159                         gee_concurrent_set_tower_iter_destroy (&curr);
3160                         gee_concurrent_set_tower_iter_destroy (&prev);
3161                         _gee_hazard_pointer_context_free0 (ctx);
3162                         return result;
3163                 }
3164                 case GEE_CONCURRENT_SET_RANGE_POSITION_AFTER:
3165                 case GEE_CONCURRENT_SET_RANGE_POSITION_EMPTY:
3166                 {
3167                         result = NULL;
3168                         _gee_hazard_pointer_context_free0 (ctx);
3169                         return result;
3170                 }
3171                 default:
3172                 {
3173                         g_assert_not_reached ();
3174                 }
3175         }
3176         _gee_hazard_pointer_context_free0 (ctx);
3177 }
3178
3179
3180 static gpointer gee_concurrent_set_sub_set_real_floor (GeeAbstractSortedSet* base, gconstpointer element) {
3181         GeeConcurrentSetSubSet * self;
3182         gpointer result = NULL;
3183         GeeHazardPointerContext* _tmp0_;
3184         GeeHazardPointerContext* ctx;
3185         GeeConcurrentSetRange* _tmp1_;
3186         gconstpointer _tmp2_;
3187         gint _tmp3_ = 0;
3188         self = (GeeConcurrentSetSubSet*) base;
3189         _tmp0_ = gee_hazard_pointer_context_new (NULL);
3190         ctx = _tmp0_;
3191         _tmp1_ = self->priv->_range;
3192         _tmp2_ = element;
3193         _tmp3_ = gee_concurrent_set_range_cmp (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_);
3194         switch (_tmp3_) {
3195                 case GEE_CONCURRENT_SET_RANGE_POSITION_BEFORE:
3196                 case GEE_CONCURRENT_SET_RANGE_POSITION_EMPTY:
3197                 {
3198                         result = NULL;
3199                         _gee_hazard_pointer_context_free0 (ctx);
3200                         return result;
3201                 }
3202                 case GEE_CONCURRENT_SET_RANGE_POSITION_INSIDE:
3203                 {
3204                         GeeConcurrentSetTowerIter curr = {0};
3205                         GeeConcurrentSetTowerIter prev = {0};
3206                         GeeConcurrentSetRange* _tmp4_;
3207                         GeeConcurrentSetTowerIter _tmp5_ = {0};
3208                         GeeConcurrentSetRange* _tmp6_;
3209                         GeeConcurrentSet* _tmp7_;
3210                         GCompareDataFunc _tmp8_;
3211                         void* _tmp8__target;
3212                         gconstpointer _tmp9_;
3213                         GeeConcurrentSetTowerIter _tmp10_ = {0};
3214                         gboolean _tmp11_ = FALSE;
3215                         gboolean _tmp14_ = FALSE;
3216                         gboolean _tmp15_ = FALSE;
3217                         GeeConcurrentSetTowerIter _tmp16_;
3218                         GeeConcurrentSetTower* _tmp17_;
3219                         gboolean _tmp21_;
3220                         gboolean _tmp27_;
3221                         GeeConcurrentSetTowerIter _tmp28_;
3222                         GeeConcurrentSetTower* _tmp29_;
3223                         gconstpointer _tmp30_;
3224                         gpointer _tmp31_;
3225                         _tmp4_ = self->priv->_range;
3226                         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp4_, NULL, &_tmp5_);
3227                         gee_concurrent_set_tower_iter_destroy (&prev);
3228                         prev = _tmp5_;
3229                         _tmp6_ = self->priv->_range;
3230                         _tmp7_ = _tmp6_->_set;
3231                         _tmp8_ = _tmp7_->priv->_cmp;
3232                         _tmp8__target = _tmp7_->priv->_cmp_target;
3233                         _tmp9_ = element;
3234                         _tmp11_ = gee_concurrent_set_tower_search_from_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp8_, _tmp8__target, _tmp9_, &prev, &_tmp10_, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
3235                         gee_concurrent_set_tower_iter_destroy (&curr);
3236                         curr = _tmp10_;
3237                         if (!_tmp11_) {
3238                                 GeeConcurrentSetTower* _tmp12_;
3239                                 GeeConcurrentSetTower* _tmp13_;
3240                                 _tmp12_ = prev._iter[0];
3241                                 prev._iter[0] = NULL;
3242                                 _gee_concurrent_set_tower_unref0 (curr._iter[0]);
3243                                 curr._iter[0] = _tmp12_;
3244                                 _tmp13_ = curr._iter[0];
3245                         }
3246                         _tmp16_ = curr;
3247                         _tmp17_ = _tmp16_._iter[0];
3248                         if (_tmp17_ == NULL) {
3249                                 _tmp15_ = TRUE;
3250                         } else {
3251                                 GeeConcurrentSetTowerIter _tmp18_;
3252                                 GeeConcurrentSetTower* _tmp19_;
3253                                 gboolean _tmp20_ = FALSE;
3254                                 _tmp18_ = curr;
3255                                 _tmp19_ = _tmp18_._iter[0];
3256                                 _tmp20_ = gee_concurrent_set_tower_is_head (_tmp19_);
3257                                 _tmp15_ = _tmp20_;
3258                         }
3259                         _tmp21_ = _tmp15_;
3260                         if (_tmp21_) {
3261                                 _tmp14_ = TRUE;
3262                         } else {
3263                                 GeeConcurrentSetRange* _tmp22_;
3264                                 GeeConcurrentSetTowerIter _tmp23_;
3265                                 GeeConcurrentSetTower* _tmp24_;
3266                                 gconstpointer _tmp25_;
3267                                 gboolean _tmp26_ = FALSE;
3268                                 _tmp22_ = self->priv->_range;
3269                                 _tmp23_ = curr;
3270                                 _tmp24_ = _tmp23_._iter[0];
3271                                 _tmp25_ = _tmp24_->_data;
3272                                 _tmp26_ = gee_concurrent_set_range_inside (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp22_, _tmp25_);
3273                                 _tmp14_ = !_tmp26_;
3274                         }
3275                         _tmp27_ = _tmp14_;
3276                         if (_tmp27_) {
3277                                 result = NULL;
3278                                 gee_concurrent_set_tower_iter_destroy (&prev);
3279                                 gee_concurrent_set_tower_iter_destroy (&curr);
3280                                 _gee_hazard_pointer_context_free0 (ctx);
3281                                 return result;
3282                         }
3283                         _tmp28_ = curr;
3284                         _tmp29_ = _tmp28_._iter[0];
3285                         _tmp30_ = _tmp29_->_data;
3286                         _tmp31_ = ((_tmp30_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp30_) : ((gpointer) _tmp30_);
3287                         result = _tmp31_;
3288                         gee_concurrent_set_tower_iter_destroy (&prev);
3289                         gee_concurrent_set_tower_iter_destroy (&curr);
3290                         _gee_hazard_pointer_context_free0 (ctx);
3291                         return result;
3292                 }
3293                 case GEE_CONCURRENT_SET_RANGE_POSITION_AFTER:
3294                 {
3295                         gpointer _tmp32_ = NULL;
3296                         _tmp32_ = gee_abstract_sorted_set_last ((GeeAbstractSortedSet*) self);
3297                         result = _tmp32_;
3298                         _gee_hazard_pointer_context_free0 (ctx);
3299                         return result;
3300                 }
3301                 default:
3302                 {
3303                         g_assert_not_reached ();
3304                 }
3305         }
3306         _gee_hazard_pointer_context_free0 (ctx);
3307 }
3308
3309
3310 static gpointer gee_concurrent_set_sub_set_real_ceil (GeeAbstractSortedSet* base, gconstpointer element) {
3311         GeeConcurrentSetSubSet * self;
3312         gpointer result = NULL;
3313         GeeHazardPointerContext* _tmp0_;
3314         GeeHazardPointerContext* ctx;
3315         GeeConcurrentSetRange* _tmp1_;
3316         gconstpointer _tmp2_;
3317         gint _tmp3_ = 0;
3318         self = (GeeConcurrentSetSubSet*) base;
3319         _tmp0_ = gee_hazard_pointer_context_new (NULL);
3320         ctx = _tmp0_;
3321         _tmp1_ = self->priv->_range;
3322         _tmp2_ = element;
3323         _tmp3_ = gee_concurrent_set_range_cmp (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_);
3324         switch (_tmp3_) {
3325                 case GEE_CONCURRENT_SET_RANGE_POSITION_BEFORE:
3326                 {
3327                         gpointer _tmp4_ = NULL;
3328                         _tmp4_ = gee_abstract_sorted_set_first ((GeeAbstractSortedSet*) self);
3329                         result = _tmp4_;
3330                         _gee_hazard_pointer_context_free0 (ctx);
3331                         return result;
3332                 }
3333                 case GEE_CONCURRENT_SET_RANGE_POSITION_INSIDE:
3334                 {
3335                         GeeConcurrentSetTowerIter curr = {0};
3336                         GeeConcurrentSetTowerIter prev = {0};
3337                         GeeConcurrentSetRange* _tmp5_;
3338                         GeeConcurrentSetTowerIter _tmp6_ = {0};
3339                         GeeConcurrentSetRange* _tmp7_;
3340                         GeeConcurrentSet* _tmp8_;
3341                         GCompareDataFunc _tmp9_;
3342                         void* _tmp9__target;
3343                         gconstpointer _tmp10_;
3344                         GeeConcurrentSetTowerIter _tmp11_ = {0};
3345                         gboolean _tmp12_ = FALSE;
3346                         GeeConcurrentSetTowerIter _tmp13_;
3347                         GeeConcurrentSetTower* _tmp14_;
3348                         gboolean _tmp20_;
3349                         GeeConcurrentSetTowerIter _tmp21_;
3350                         GeeConcurrentSetTower* _tmp22_;
3351                         gconstpointer _tmp23_;
3352                         gpointer _tmp24_;
3353                         _tmp5_ = self->priv->_range;
3354                         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp5_, NULL, &_tmp6_);
3355                         gee_concurrent_set_tower_iter_destroy (&prev);
3356                         prev = _tmp6_;
3357                         _tmp7_ = self->priv->_range;
3358                         _tmp8_ = _tmp7_->_set;
3359                         _tmp9_ = _tmp8_->priv->_cmp;
3360                         _tmp9__target = _tmp8_->priv->_cmp_target;
3361                         _tmp10_ = element;
3362                         gee_concurrent_set_tower_search_from_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp9_, _tmp9__target, _tmp10_, &prev, &_tmp11_, (guint8) 0, (guint8) (((guint8) GEE_CONCURRENT_SET__MAX_HEIGHT) - 1));
3363                         gee_concurrent_set_tower_iter_destroy (&curr);
3364                         curr = _tmp11_;
3365                         _tmp13_ = curr;
3366                         _tmp14_ = _tmp13_._iter[0];
3367                         if (_tmp14_ == NULL) {
3368                                 _tmp12_ = TRUE;
3369                         } else {
3370                                 GeeConcurrentSetRange* _tmp15_;
3371                                 GeeConcurrentSetTowerIter _tmp16_;
3372                                 GeeConcurrentSetTower* _tmp17_;
3373                                 gconstpointer _tmp18_;
3374                                 gboolean _tmp19_ = FALSE;
3375                                 _tmp15_ = self->priv->_range;
3376                                 _tmp16_ = curr;
3377                                 _tmp17_ = _tmp16_._iter[0];
3378                                 _tmp18_ = _tmp17_->_data;
3379                                 _tmp19_ = gee_concurrent_set_range_inside (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp15_, _tmp18_);
3380                                 _tmp12_ = !_tmp19_;
3381                         }
3382                         _tmp20_ = _tmp12_;
3383                         if (_tmp20_) {
3384                                 result = NULL;
3385                                 gee_concurrent_set_tower_iter_destroy (&prev);
3386                                 gee_concurrent_set_tower_iter_destroy (&curr);
3387                                 _gee_hazard_pointer_context_free0 (ctx);
3388                                 return result;
3389                         }
3390                         _tmp21_ = curr;
3391                         _tmp22_ = _tmp21_._iter[0];
3392                         _tmp23_ = _tmp22_->_data;
3393                         _tmp24_ = ((_tmp23_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp23_) : ((gpointer) _tmp23_);
3394                         result = _tmp24_;
3395                         gee_concurrent_set_tower_iter_destroy (&prev);
3396                         gee_concurrent_set_tower_iter_destroy (&curr);
3397                         _gee_hazard_pointer_context_free0 (ctx);
3398                         return result;
3399                 }
3400                 case GEE_CONCURRENT_SET_RANGE_POSITION_AFTER:
3401                 case GEE_CONCURRENT_SET_RANGE_POSITION_EMPTY:
3402                 {
3403                         result = NULL;
3404                         _gee_hazard_pointer_context_free0 (ctx);
3405                         return result;
3406                 }
3407                 default:
3408                 {
3409                         g_assert_not_reached ();
3410                 }
3411         }
3412         _gee_hazard_pointer_context_free0 (ctx);
3413 }
3414
3415
3416 static GeeSortedSet* gee_concurrent_set_sub_set_real_head_set (GeeAbstractSortedSet* base, gconstpointer before) {
3417         GeeConcurrentSetSubSet * self;
3418         GeeSortedSet* result = NULL;
3419         GeeHazardPointerContext* _tmp0_;
3420         GeeHazardPointerContext* ctx;
3421         GeeConcurrentSetRange* _tmp1_;
3422         gconstpointer _tmp2_;
3423         GeeConcurrentSetRange* _tmp3_ = NULL;
3424         GeeConcurrentSetRange* _tmp4_;
3425         GeeConcurrentSetSubSet* _tmp5_;
3426         GeeSortedSet* _tmp6_;
3427         self = (GeeConcurrentSetSubSet*) base;
3428         _tmp0_ = gee_hazard_pointer_context_new (NULL);
3429         ctx = _tmp0_;
3430         _tmp1_ = self->priv->_range;
3431         _tmp2_ = before;
3432         _tmp3_ = gee_concurrent_set_range_cut_tail (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_);
3433         _tmp4_ = _tmp3_;
3434         _tmp5_ = gee_concurrent_set_sub_set_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp4_);
3435         _tmp6_ = (GeeSortedSet*) _tmp5_;
3436         _gee_concurrent_set_range_unref0 (_tmp4_);
3437         result = _tmp6_;
3438         _gee_hazard_pointer_context_free0 (ctx);
3439         return result;
3440 }
3441
3442
3443 static GeeSortedSet* gee_concurrent_set_sub_set_real_tail_set (GeeAbstractSortedSet* base, gconstpointer after) {
3444         GeeConcurrentSetSubSet * self;
3445         GeeSortedSet* result = NULL;
3446         GeeHazardPointerContext* _tmp0_;
3447         GeeHazardPointerContext* ctx;
3448         GeeConcurrentSetRange* _tmp1_;
3449         gconstpointer _tmp2_;
3450         GeeConcurrentSetRange* _tmp3_ = NULL;
3451         GeeConcurrentSetRange* _tmp4_;
3452         GeeConcurrentSetSubSet* _tmp5_;
3453         GeeSortedSet* _tmp6_;
3454         self = (GeeConcurrentSetSubSet*) base;
3455         _tmp0_ = gee_hazard_pointer_context_new (NULL);
3456         ctx = _tmp0_;
3457         _tmp1_ = self->priv->_range;
3458         _tmp2_ = after;
3459         _tmp3_ = gee_concurrent_set_range_cut_head (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_);
3460         _tmp4_ = _tmp3_;
3461         _tmp5_ = gee_concurrent_set_sub_set_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp4_);
3462         _tmp6_ = (GeeSortedSet*) _tmp5_;
3463         _gee_concurrent_set_range_unref0 (_tmp4_);
3464         result = _tmp6_;
3465         _gee_hazard_pointer_context_free0 (ctx);
3466         return result;
3467 }
3468
3469
3470 static GeeSortedSet* gee_concurrent_set_sub_set_real_sub_set (GeeAbstractSortedSet* base, gconstpointer from, gconstpointer to) {
3471         GeeConcurrentSetSubSet * self;
3472         GeeSortedSet* result = NULL;
3473         GeeHazardPointerContext* _tmp0_;
3474         GeeHazardPointerContext* ctx;
3475         GeeConcurrentSetRange* _tmp1_;
3476         gconstpointer _tmp2_;
3477         gconstpointer _tmp3_;
3478         GeeConcurrentSetRange* _tmp4_ = NULL;
3479         GeeConcurrentSetRange* _tmp5_;
3480         GeeConcurrentSetSubSet* _tmp6_;
3481         GeeSortedSet* _tmp7_;
3482         self = (GeeConcurrentSetSubSet*) base;
3483         _tmp0_ = gee_hazard_pointer_context_new (NULL);
3484         ctx = _tmp0_;
3485         _tmp1_ = self->priv->_range;
3486         _tmp2_ = from;
3487         _tmp3_ = to;
3488         _tmp4_ = gee_concurrent_set_range_cut (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, _tmp2_, _tmp3_);
3489         _tmp5_ = _tmp4_;
3490         _tmp6_ = gee_concurrent_set_sub_set_new (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp5_);
3491         _tmp7_ = (GeeSortedSet*) _tmp6_;
3492         _gee_concurrent_set_range_unref0 (_tmp5_);
3493         result = _tmp7_;
3494         _gee_hazard_pointer_context_free0 (ctx);
3495         return result;
3496 }
3497
3498
3499 static gint gee_concurrent_set_sub_set_real_get_size (GeeAbstractCollection* base) {
3500         gint result;
3501         GeeConcurrentSetSubSet* self;
3502         GeeHazardPointerContext* _tmp0_;
3503         GeeHazardPointerContext* ctx;
3504         GeeConcurrentSetTower* curr = NULL;
3505         GeeConcurrentSetRange* _tmp1_;
3506         GeeConcurrentSetTower* _tmp2_ = NULL;
3507         GeeConcurrentSetTower* _tmp3_;
3508         self = (GeeConcurrentSetSubSet*) base;
3509         _tmp0_ = gee_hazard_pointer_context_new (NULL);
3510         ctx = _tmp0_;
3511         _tmp1_ = self->priv->_range;
3512         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, &_tmp2_, NULL);
3513         _gee_concurrent_set_tower_unref0 (curr);
3514         curr = _tmp2_;
3515         _tmp3_ = curr;
3516         if (_tmp3_ != NULL) {
3517                 gint acc;
3518                 GeeConcurrentSetRange* _tmp4_;
3519                 gpointer _tmp5_ = NULL;
3520                 GeeConcurrentSetTower* prev;
3521                 gint _tmp9_;
3522                 acc = 1;
3523                 _tmp4_ = self->priv->_range;
3524                 _tmp5_ = gee_hazard_pointer_get_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp4_->_bookmark._iter[0], (gsize) 0, NULL);
3525                 prev = (GeeConcurrentSetTower*) _tmp5_;
3526                 while (TRUE) {
3527                         GeeConcurrentSetRange* _tmp6_;
3528                         gboolean _tmp7_ = FALSE;
3529                         gint _tmp8_;
3530                         _tmp6_ = self->priv->_range;
3531                         _tmp7_ = gee_concurrent_set_range_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp6_, &prev, &curr, (guint8) 0);
3532                         if (!_tmp7_) {
3533                                 break;
3534                         }
3535                         _tmp8_ = acc;
3536                         acc = _tmp8_ + 1;
3537                 }
3538                 _tmp9_ = acc;
3539                 result = _tmp9_;
3540                 _gee_concurrent_set_tower_unref0 (prev);
3541                 _gee_concurrent_set_tower_unref0 (curr);
3542                 _gee_hazard_pointer_context_free0 (ctx);
3543                 return result;
3544         } else {
3545                 result = 0;
3546                 _gee_concurrent_set_tower_unref0 (curr);
3547                 _gee_hazard_pointer_context_free0 (ctx);
3548                 return result;
3549         }
3550         _gee_concurrent_set_tower_unref0 (curr);
3551         _gee_hazard_pointer_context_free0 (ctx);
3552 }
3553
3554
3555 static gboolean gee_concurrent_set_sub_set_get_is_empty (GeeConcurrentSetSubSet* self) {
3556         gboolean result;
3557         GeeHazardPointerContext* _tmp0_;
3558         GeeHazardPointerContext* ctx;
3559         GeeConcurrentSetTower* curr = NULL;
3560         GeeConcurrentSetRange* _tmp1_;
3561         GeeConcurrentSetTower* _tmp2_ = NULL;
3562         g_return_val_if_fail (self != NULL, FALSE);
3563         _tmp0_ = gee_hazard_pointer_context_new (NULL);
3564         ctx = _tmp0_;
3565         _tmp1_ = self->priv->_range;
3566         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp1_, &_tmp2_, NULL);
3567         _gee_concurrent_set_tower_unref0 (curr);
3568         curr = _tmp2_;
3569         result = curr != NULL;
3570         _gee_concurrent_set_tower_unref0 (curr);
3571         _gee_hazard_pointer_context_free0 (ctx);
3572         return result;
3573 }
3574
3575
3576 static gboolean gee_concurrent_set_sub_set_real_get_read_only (GeeAbstractCollection* base) {
3577         gboolean result;
3578         GeeConcurrentSetSubSet* self;
3579         self = (GeeConcurrentSetSubSet*) base;
3580         result = FALSE;
3581         return result;
3582 }
3583
3584
3585 static void gee_concurrent_set_sub_set_class_init (GeeConcurrentSetSubSetClass * klass) {
3586         gee_concurrent_set_sub_set_parent_class = g_type_class_peek_parent (klass);
3587         g_type_class_add_private (klass, sizeof (GeeConcurrentSetSubSetPrivate));
3588         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_concurrent_set_sub_set_real_iterator;
3589         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_concurrent_set_sub_set_real_contains;
3590         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_concurrent_set_sub_set_real_add;
3591         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_concurrent_set_sub_set_real_remove;
3592         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_concurrent_set_sub_set_real_clear;
3593         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->first = gee_concurrent_set_sub_set_real_first;
3594         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->last = gee_concurrent_set_sub_set_real_last;
3595         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->iterator_at = gee_concurrent_set_sub_set_real_iterator_at;
3596         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->lower = gee_concurrent_set_sub_set_real_lower;
3597         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->higher = gee_concurrent_set_sub_set_real_higher;
3598         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->floor = gee_concurrent_set_sub_set_real_floor;
3599         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->ceil = gee_concurrent_set_sub_set_real_ceil;
3600         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->head_set = gee_concurrent_set_sub_set_real_head_set;
3601         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->tail_set = gee_concurrent_set_sub_set_real_tail_set;
3602         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->sub_set = gee_concurrent_set_sub_set_real_sub_set;
3603         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_concurrent_set_sub_set_real_get_size;
3604         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_read_only = gee_concurrent_set_sub_set_real_get_read_only;
3605         G_OBJECT_CLASS (klass)->get_property = _vala_gee_concurrent_set_sub_set_get_property;
3606         G_OBJECT_CLASS (klass)->set_property = _vala_gee_concurrent_set_sub_set_set_property;
3607         G_OBJECT_CLASS (klass)->finalize = gee_concurrent_set_sub_set_finalize;
3608         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SUB_SET_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
3609         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SUB_SET_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
3610         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SUB_SET_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
3611         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SUB_SET_SIZE, g_param_spec_int ("size", "size", "size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
3612         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SUB_SET_IS_EMPTY, g_param_spec_boolean ("is-empty", "is-empty", "is-empty", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
3613         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SUB_SET_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
3614 }
3615
3616
3617 static void gee_concurrent_set_sub_set_instance_init (GeeConcurrentSetSubSet * self) {
3618         self->priv = GEE_CONCURRENT_SET_SUB_SET_GET_PRIVATE (self);
3619 }
3620
3621
3622 static void gee_concurrent_set_sub_set_finalize (GObject* obj) {
3623         GeeConcurrentSetSubSet * self;
3624         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_CONCURRENT_SET_TYPE_SUB_SET, GeeConcurrentSetSubSet);
3625         _gee_concurrent_set_range_unref0 (self->priv->_range);
3626         G_OBJECT_CLASS (gee_concurrent_set_sub_set_parent_class)->finalize (obj);
3627 }
3628
3629
3630 static GType gee_concurrent_set_sub_set_get_type (void) {
3631         static volatile gsize gee_concurrent_set_sub_set_type_id__volatile = 0;
3632         if (g_once_init_enter (&gee_concurrent_set_sub_set_type_id__volatile)) {
3633                 static const GTypeInfo g_define_type_info = { sizeof (GeeConcurrentSetSubSetClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_concurrent_set_sub_set_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeConcurrentSetSubSet), 0, (GInstanceInitFunc) gee_concurrent_set_sub_set_instance_init, NULL };
3634                 GType gee_concurrent_set_sub_set_type_id;
3635                 gee_concurrent_set_sub_set_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_SORTED_SET, "GeeConcurrentSetSubSet", &g_define_type_info, 0);
3636                 g_once_init_leave (&gee_concurrent_set_sub_set_type_id__volatile, gee_concurrent_set_sub_set_type_id);
3637         }
3638         return gee_concurrent_set_sub_set_type_id__volatile;
3639 }
3640
3641
3642 static void _vala_gee_concurrent_set_sub_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
3643         GeeConcurrentSetSubSet * self;
3644         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_CONCURRENT_SET_TYPE_SUB_SET, GeeConcurrentSetSubSet);
3645         switch (property_id) {
3646                 case GEE_CONCURRENT_SET_SUB_SET_SIZE:
3647                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
3648                 break;
3649                 case GEE_CONCURRENT_SET_SUB_SET_IS_EMPTY:
3650                 g_value_set_boolean (value, gee_concurrent_set_sub_set_get_is_empty (self));
3651                 break;
3652                 case GEE_CONCURRENT_SET_SUB_SET_READ_ONLY:
3653                 g_value_set_boolean (value, gee_abstract_collection_get_read_only ((GeeAbstractCollection*) self));
3654                 break;
3655                 default:
3656                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3657                 break;
3658         }
3659 }
3660
3661
3662 static void _vala_gee_concurrent_set_sub_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
3663         GeeConcurrentSetSubSet * self;
3664         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_CONCURRENT_SET_TYPE_SUB_SET, GeeConcurrentSetSubSet);
3665         switch (property_id) {
3666                 case GEE_CONCURRENT_SET_SUB_SET_G_TYPE:
3667                 self->priv->g_type = g_value_get_gtype (value);
3668                 break;
3669                 case GEE_CONCURRENT_SET_SUB_SET_G_DUP_FUNC:
3670                 self->priv->g_dup_func = g_value_get_pointer (value);
3671                 break;
3672                 case GEE_CONCURRENT_SET_SUB_SET_G_DESTROY_FUNC:
3673                 self->priv->g_destroy_func = g_value_get_pointer (value);
3674                 break;
3675                 default:
3676                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
3677                 break;
3678         }
3679 }
3680
3681
3682 static GeeConcurrentSetSubIterator* gee_concurrent_set_sub_iterator_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range) {
3683         GeeConcurrentSetSubIterator * self = NULL;
3684         GeeConcurrentSetRange* _tmp0_;
3685         GeeConcurrentSetRange* _tmp1_;
3686         GeeConcurrentSetRange* _tmp2_;
3687         g_return_val_if_fail (range != NULL, NULL);
3688         self = (GeeConcurrentSetSubIterator*) g_object_new (object_type, NULL);
3689         self->priv->g_type = g_type;
3690         self->priv->g_dup_func = g_dup_func;
3691         self->priv->g_destroy_func = g_destroy_func;
3692         _tmp0_ = range;
3693         gee_concurrent_set_range_improve_bookmark (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp0_, NULL, NULL);
3694         _tmp1_ = range;
3695         _tmp2_ = _gee_concurrent_set_range_ref0 (_tmp1_);
3696         _gee_concurrent_set_range_unref0 (self->priv->_range);
3697         self->priv->_range = _tmp2_;
3698         return self;
3699 }
3700
3701
3702 static GeeConcurrentSetSubIterator* gee_concurrent_set_sub_iterator_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range) {
3703         return gee_concurrent_set_sub_iterator_construct (GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR, g_type, g_dup_func, g_destroy_func, range);
3704 }
3705
3706
3707 static GeeConcurrentSetSubIterator* gee_concurrent_set_sub_iterator_construct_point_at (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTower* curr) {
3708         GeeConcurrentSetSubIterator * self = NULL;
3709         GeeConcurrentSetRange* _tmp0_;
3710         GeeConcurrentSetRange* _tmp1_;
3711         GeeConcurrentSetRange* _tmp2_;
3712         GeeConcurrentSetTowerIter _tmp3_;
3713         GeeConcurrentSetTowerIter _tmp4_ = {0};
3714         GeeConcurrentSetTower* _tmp5_;
3715         GeeConcurrentSetTower* _tmp6_;
3716         g_return_val_if_fail (range != NULL, NULL);
3717         g_return_val_if_fail (prev != NULL, NULL);
3718         g_return_val_if_fail (curr != NULL, NULL);
3719         self = (GeeConcurrentSetSubIterator*) g_object_new (object_type, NULL);
3720         self->priv->g_type = g_type;
3721         self->priv->g_dup_func = g_dup_func;
3722         self->priv->g_destroy_func = g_destroy_func;
3723         _tmp0_ = range;
3724         gee_concurrent_set_range_improve_bookmark (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp0_, NULL, NULL);
3725         _tmp1_ = range;
3726         _tmp2_ = _gee_concurrent_set_range_ref0 (_tmp1_);
3727         _gee_concurrent_set_range_unref0 (self->priv->_range);
3728         self->priv->_range = _tmp2_;
3729         _tmp3_ = *prev;
3730         gee_concurrent_set_tower_iter_copy (&_tmp3_, &_tmp4_);
3731         gee_concurrent_set_tower_iter_destroy (&self->priv->_prev);
3732         self->priv->_prev = _tmp4_;
3733         _tmp5_ = curr;
3734         _tmp6_ = _gee_concurrent_set_tower_ref0 (_tmp5_);
3735         _gee_concurrent_set_tower_unref0 (self->priv->_curr);
3736         self->priv->_curr = _tmp6_;
3737         _gee_concurrent_set_tower_unref0 (curr);
3738         return self;
3739 }
3740
3741
3742 static GeeConcurrentSetSubIterator* gee_concurrent_set_sub_iterator_new_point_at (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTower* curr) {
3743         return gee_concurrent_set_sub_iterator_construct_point_at (GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR, g_type, g_dup_func, g_destroy_func, range, prev, curr);
3744 }
3745
3746
3747 static gboolean gee_concurrent_set_sub_iterator_real_foreach (GeeTraversable* base, GeeForallFunc f, void* f_target) {
3748         GeeConcurrentSetSubIterator * self;
3749         gboolean result = FALSE;
3750         GeeConcurrentSetTower* _tmp0_;
3751         GeeHazardPointerContext* _tmp1_;
3752         GeeHazardPointerContext* ctx;
3753         gboolean _tmp2_ = FALSE;
3754         gboolean _tmp3_ = FALSE;
3755         GeeConcurrentSetTowerIter _tmp4_;
3756         GeeConcurrentSetTower* _tmp5_;
3757         gboolean _tmp7_;
3758         GeeConcurrentSetTowerIter _tmp14_;
3759         GeeConcurrentSetTower* _tmp15_;
3760         GeeConcurrentSetTower* _tmp16_;
3761         GeeConcurrentSetTower* new_prev;
3762         GeeConcurrentSetTower* _tmp17_;
3763         GeeConcurrentSetTower* _tmp18_;
3764         GeeConcurrentSetTower* new_curr;
3765         GeeConcurrentSetTower* _tmp45_;
3766         self = (GeeConcurrentSetSubIterator*) base;
3767         _tmp0_ = self->priv->_curr;
3768         _vala_assert (_tmp0_ != NULL, "_curr != null");
3769         _tmp1_ = gee_hazard_pointer_context_new (NULL);
3770         ctx = _tmp1_;
3771         _tmp2_ = gee_concurrent_set_sub_iterator_begin (self);
3772         if (!_tmp2_) {
3773                 result = TRUE;
3774                 _gee_hazard_pointer_context_free0 (ctx);
3775                 return result;
3776         }
3777         _tmp4_ = self->priv->_prev;
3778         _tmp5_ = _tmp4_._iter[0];
3779         if (_tmp5_ != NULL) {
3780                 gboolean _tmp6_;
3781                 _tmp6_ = self->priv->_removed;
3782                 _tmp3_ = !_tmp6_;
3783         } else {
3784                 _tmp3_ = FALSE;
3785         }
3786         _tmp7_ = _tmp3_;
3787         if (_tmp7_) {
3788                 GeeForallFunc _tmp8_;
3789                 void* _tmp8__target;
3790                 GeeConcurrentSetTower* _tmp9_;
3791                 gconstpointer _tmp10_;
3792                 gpointer _tmp11_;
3793                 gboolean _tmp12_ = FALSE;
3794                 _tmp8_ = f;
3795                 _tmp8__target = f_target;
3796                 _tmp9_ = self->priv->_curr;
3797                 _tmp10_ = _tmp9_->_data;
3798                 _tmp11_ = ((_tmp10_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp10_) : ((gpointer) _tmp10_);
3799                 _tmp12_ = _tmp8_ (_tmp11_, _tmp8__target);
3800                 if (!_tmp12_) {
3801                         GeeConcurrentSetTower* _tmp13_;
3802                         _tmp13_ = self->priv->_curr;
3803                         _vala_assert (_tmp13_ != NULL, "_curr != null");
3804                         result = FALSE;
3805                         _gee_hazard_pointer_context_free0 (ctx);
3806                         return result;
3807                 }
3808         }
3809         _tmp14_ = self->priv->_prev;
3810         _tmp15_ = _tmp14_._iter[0];
3811         _tmp16_ = _gee_concurrent_set_tower_ref0 (_tmp15_);
3812         new_prev = _tmp16_;
3813         _tmp17_ = self->priv->_curr;
3814         _tmp18_ = _gee_concurrent_set_tower_ref0 (_tmp17_);
3815         new_curr = _tmp18_;
3816         while (TRUE) {
3817                 GeeConcurrentSetRange* _tmp19_;
3818                 gboolean _tmp20_ = FALSE;
3819                 GeeConcurrentSetTower* _tmp21_;
3820                 GeeForallFunc _tmp22_;
3821                 void* _tmp22__target;
3822                 GeeConcurrentSetTower* _tmp23_;
3823                 gconstpointer _tmp24_;
3824                 gpointer _tmp25_;
3825                 gboolean _tmp26_ = FALSE;
3826                 gboolean _tmp28_;
3827                 GeeConcurrentSetTower* _tmp44_;
3828                 _tmp19_ = self->priv->_range;
3829                 _tmp20_ = gee_concurrent_set_range_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp19_, &new_prev, &new_curr, (guint8) 0);
3830                 if (!_tmp20_) {
3831                         break;
3832                 }
3833                 _tmp21_ = self->priv->_curr;
3834                 _vala_assert (_tmp21_ != NULL, "_curr != null");
3835                 _tmp22_ = f;
3836                 _tmp22__target = f_target;
3837                 _tmp23_ = self->priv->_curr;
3838                 _tmp24_ = _tmp23_->_data;
3839                 _tmp25_ = ((_tmp24_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp24_) : ((gpointer) _tmp24_);
3840                 _tmp26_ = _tmp22_ (_tmp25_, _tmp22__target);
3841                 if (!_tmp26_) {
3842                         GeeConcurrentSetTower* _tmp27_;
3843                         _tmp27_ = self->priv->_curr;
3844                         _vala_assert (_tmp27_ != NULL, "_curr != null");
3845                         result = FALSE;
3846                         _gee_concurrent_set_tower_unref0 (new_curr);
3847                         _gee_concurrent_set_tower_unref0 (new_prev);
3848                         _gee_hazard_pointer_context_free0 (ctx);
3849                         return result;
3850                 }
3851                 _tmp28_ = self->priv->_removed;
3852                 if (!_tmp28_) {
3853                         GeeConcurrentSetTower* _tmp29_;
3854                         GeeConcurrentSetTower* _tmp30_;
3855                         GeeConcurrentSetTowerIter _tmp31_;
3856                         GeeConcurrentSetTower* _tmp32_;
3857                         gint _tmp33_ = 0;
3858                         gint prev_height;
3859                         _tmp29_ = new_prev;
3860                         new_prev = NULL;
3861                         _gee_concurrent_set_tower_unref0 (self->priv->_prev._iter[0]);
3862                         self->priv->_prev._iter[0] = _tmp29_;
3863                         _tmp30_ = self->priv->_prev._iter[0];
3864                         _tmp31_ = self->priv->_prev;
3865                         _tmp32_ = _tmp31_._iter[0];
3866                         _tmp33_ = gee_concurrent_set_tower_get_height (_tmp32_);
3867                         prev_height = _tmp33_;
3868                         {
3869                                 gint i;
3870                                 i = 1;
3871                                 {
3872                                         gboolean _tmp34_;
3873                                         _tmp34_ = TRUE;
3874                                         while (TRUE) {
3875                                                 gboolean _tmp35_;
3876                                                 gint _tmp37_;
3877                                                 gint _tmp38_;
3878                                                 gint _tmp39_;
3879                                                 GeeConcurrentSetTowerIter _tmp40_;
3880                                                 GeeConcurrentSetTower* _tmp41_;
3881                                                 GeeConcurrentSetTower* _tmp42_;
3882                                                 GeeConcurrentSetTower* _tmp43_;
3883                                                 _tmp35_ = _tmp34_;
3884                                                 if (!_tmp35_) {
3885                                                         gint _tmp36_;
3886                                                         _tmp36_ = i;
3887                                                         i = _tmp36_ + 1;
3888                                                 }
3889                                                 _tmp34_ = FALSE;
3890                                                 _tmp37_ = i;
3891                                                 _tmp38_ = prev_height;
3892                                                 if (!(_tmp37_ < _tmp38_)) {
3893                                                         break;
3894                                                 }
3895                                                 _tmp39_ = i;
3896                                                 _tmp40_ = self->priv->_prev;
3897                                                 _tmp41_ = _tmp40_._iter[0];
3898                                                 _tmp42_ = _gee_concurrent_set_tower_ref0 (_tmp41_);
3899                                                 _gee_concurrent_set_tower_unref0 (self->priv->_prev._iter[_tmp39_]);
3900                                                 self->priv->_prev._iter[_tmp39_] = _tmp42_;
3901                                                 _tmp43_ = self->priv->_prev._iter[_tmp39_];
3902                                         }
3903                                 }
3904                         }
3905                 }
3906                 _tmp44_ = new_curr;
3907                 new_curr = NULL;
3908                 _gee_concurrent_set_tower_unref0 (self->priv->_curr);
3909                 self->priv->_curr = _tmp44_;
3910                 self->priv->_removed = FALSE;
3911         }
3912         _tmp45_ = self->priv->_curr;
3913         _vala_assert (_tmp45_ != NULL, "_curr != null");
3914         result = TRUE;
3915         _gee_concurrent_set_tower_unref0 (new_curr);
3916         _gee_concurrent_set_tower_unref0 (new_prev);
3917         _gee_hazard_pointer_context_free0 (ctx);
3918         return result;
3919 }
3920
3921
3922 static gboolean gee_concurrent_set_sub_iterator_real_next (GeeIterator* base) {
3923         GeeConcurrentSetSubIterator * self;
3924         gboolean result = FALSE;
3925         GeeHazardPointerContext* _tmp0_;
3926         GeeHazardPointerContext* ctx;
3927         GeeConcurrentSetTowerIter _tmp1_;
3928         GeeConcurrentSetTower* _tmp2_;
3929         self = (GeeConcurrentSetSubIterator*) base;
3930         _tmp0_ = gee_hazard_pointer_context_new (NULL);
3931         ctx = _tmp0_;
3932         _tmp1_ = self->priv->_prev;
3933         _tmp2_ = _tmp1_._iter[0];
3934         if (_tmp2_ == NULL) {
3935                 gboolean _tmp3_ = FALSE;
3936                 _tmp3_ = gee_concurrent_set_sub_iterator_begin (self);
3937                 result = _tmp3_;
3938                 _gee_hazard_pointer_context_free0 (ctx);
3939                 return result;
3940         } else {
3941                 GeeConcurrentSetTowerIter _tmp4_;
3942                 GeeConcurrentSetTower* _tmp5_;
3943                 GeeConcurrentSetTower* _tmp6_;
3944                 GeeConcurrentSetTower* new_prev;
3945                 GeeConcurrentSetTower* _tmp7_;
3946                 GeeConcurrentSetTower* _tmp8_;
3947                 GeeConcurrentSetTower* new_curr;
3948                 GeeConcurrentSetRange* _tmp9_;
3949                 gboolean _tmp10_ = FALSE;
3950                 _tmp4_ = self->priv->_prev;
3951                 _tmp5_ = _tmp4_._iter[0];
3952                 _tmp6_ = _gee_concurrent_set_tower_ref0 (_tmp5_);
3953                 new_prev = _tmp6_;
3954                 _tmp7_ = self->priv->_curr;
3955                 _tmp8_ = _gee_concurrent_set_tower_ref0 (_tmp7_);
3956                 new_curr = _tmp8_;
3957                 _tmp9_ = self->priv->_range;
3958                 _tmp10_ = gee_concurrent_set_range_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp9_, &new_prev, &new_curr, (guint8) 0);
3959                 if (_tmp10_) {
3960                         gboolean _tmp11_;
3961                         GeeConcurrentSetTower* _tmp27_;
3962                         _tmp11_ = self->priv->_removed;
3963                         if (!_tmp11_) {
3964                                 GeeConcurrentSetTower* _tmp12_;
3965                                 GeeConcurrentSetTower* _tmp13_;
3966                                 GeeConcurrentSetTowerIter _tmp14_;
3967                                 GeeConcurrentSetTower* _tmp15_;
3968                                 gint _tmp16_ = 0;
3969                                 gint prev_height;
3970                                 _tmp12_ = new_prev;
3971                                 new_prev = NULL;
3972                                 _gee_concurrent_set_tower_unref0 (self->priv->_prev._iter[0]);
3973                                 self->priv->_prev._iter[0] = _tmp12_;
3974                                 _tmp13_ = self->priv->_prev._iter[0];
3975                                 _tmp14_ = self->priv->_prev;
3976                                 _tmp15_ = _tmp14_._iter[0];
3977                                 _tmp16_ = gee_concurrent_set_tower_get_height (_tmp15_);
3978                                 prev_height = _tmp16_;
3979                                 {
3980                                         gint i;
3981                                         i = 1;
3982                                         {
3983                                                 gboolean _tmp17_;
3984                                                 _tmp17_ = TRUE;
3985                                                 while (TRUE) {
3986                                                         gboolean _tmp18_;
3987                                                         gint _tmp20_;
3988                                                         gint _tmp21_;
3989                                                         gint _tmp22_;
3990                                                         GeeConcurrentSetTowerIter _tmp23_;
3991                                                         GeeConcurrentSetTower* _tmp24_;
3992                                                         GeeConcurrentSetTower* _tmp25_;
3993                                                         GeeConcurrentSetTower* _tmp26_;
3994                                                         _tmp18_ = _tmp17_;
3995                                                         if (!_tmp18_) {
3996                                                                 gint _tmp19_;
3997                                                                 _tmp19_ = i;
3998                                                                 i = _tmp19_ + 1;
3999                                                         }
4000                                                         _tmp17_ = FALSE;
4001                                                         _tmp20_ = i;
4002                                                         _tmp21_ = prev_height;
4003                                                         if (!(_tmp20_ < _tmp21_)) {
4004                                                                 break;
4005                                                         }
4006                                                         _tmp22_ = i;
4007                                                         _tmp23_ = self->priv->_prev;
4008                                                         _tmp24_ = _tmp23_._iter[0];
4009                                                         _tmp25_ = _gee_concurrent_set_tower_ref0 (_tmp24_);
4010                                                         _gee_concurrent_set_tower_unref0 (self->priv->_prev._iter[_tmp22_]);
4011                                                         self->priv->_prev._iter[_tmp22_] = _tmp25_;
4012                                                         _tmp26_ = self->priv->_prev._iter[_tmp22_];
4013                                                 }
4014                                         }
4015                                 }
4016                         }
4017                         _tmp27_ = new_curr;
4018                         new_curr = NULL;
4019                         _gee_concurrent_set_tower_unref0 (self->priv->_curr);
4020                         self->priv->_curr = _tmp27_;
4021                         self->priv->_removed = FALSE;
4022                         result = TRUE;
4023                         _gee_concurrent_set_tower_unref0 (new_curr);
4024                         _gee_concurrent_set_tower_unref0 (new_prev);
4025                         _gee_hazard_pointer_context_free0 (ctx);
4026                         return result;
4027                 } else {
4028                         result = FALSE;
4029                         _gee_concurrent_set_tower_unref0 (new_curr);
4030                         _gee_concurrent_set_tower_unref0 (new_prev);
4031                         _gee_hazard_pointer_context_free0 (ctx);
4032                         return result;
4033                 }
4034                 _gee_concurrent_set_tower_unref0 (new_curr);
4035                 _gee_concurrent_set_tower_unref0 (new_prev);
4036         }
4037         _gee_hazard_pointer_context_free0 (ctx);
4038 }
4039
4040
4041 static gboolean gee_concurrent_set_sub_iterator_real_has_next (GeeIterator* base) {
4042         GeeConcurrentSetSubIterator * self;
4043         gboolean result = FALSE;
4044         GeeHazardPointerContext* _tmp0_;
4045         GeeHazardPointerContext* ctx;
4046         GeeConcurrentSetTowerIter _tmp1_;
4047         GeeConcurrentSetTower* _tmp2_;
4048         self = (GeeConcurrentSetSubIterator*) base;
4049         _tmp0_ = gee_hazard_pointer_context_new (NULL);
4050         ctx = _tmp0_;
4051         _tmp1_ = self->priv->_prev;
4052         _tmp2_ = _tmp1_._iter[0];
4053         if (_tmp2_ == NULL) {
4054                 GeeConcurrentSetTower* next = NULL;
4055                 GeeConcurrentSetRange* _tmp3_;
4056                 GeeConcurrentSetTower* _tmp4_ = NULL;
4057                 gboolean _tmp5_ = FALSE;
4058                 GeeConcurrentSetTower* _tmp6_;
4059                 gboolean _tmp10_;
4060                 GeeConcurrentSetTower* _tmp11_;
4061                 _tmp3_ = self->priv->_range;
4062                 gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp3_, &_tmp4_, NULL);
4063                 _gee_concurrent_set_tower_unref0 (next);
4064                 next = _tmp4_;
4065                 _tmp6_ = next;
4066                 if (_tmp6_ != NULL) {
4067                         GeeConcurrentSetRange* _tmp7_;
4068                         GeeConcurrentSetTower* _tmp8_;
4069                         gboolean _tmp9_ = FALSE;
4070                         _tmp7_ = self->priv->_range;
4071                         _tmp8_ = next;
4072                         _tmp9_ = gee_concurrent_set_range_beyond (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp7_, _tmp8_);
4073                         _tmp5_ = _tmp9_;
4074                 } else {
4075                         _tmp5_ = FALSE;
4076                 }
4077                 _tmp10_ = _tmp5_;
4078                 if (_tmp10_) {
4079                         _gee_concurrent_set_tower_unref0 (next);
4080                         next = NULL;
4081                 }
4082                 _tmp11_ = next;
4083                 result = _tmp11_ != NULL;
4084                 _gee_concurrent_set_tower_unref0 (next);
4085                 _gee_hazard_pointer_context_free0 (ctx);
4086                 return result;
4087         } else {
4088                 GeeConcurrentSetTowerIter _tmp12_;
4089                 GeeConcurrentSetTower* _tmp13_;
4090                 GeeConcurrentSetTower* _tmp14_;
4091                 GeeConcurrentSetTower* new_prev;
4092                 GeeConcurrentSetTower* _tmp15_;
4093                 GeeConcurrentSetTower* _tmp16_;
4094                 GeeConcurrentSetTower* new_curr;
4095                 GeeConcurrentSetRange* _tmp17_;
4096                 gboolean _tmp18_ = FALSE;
4097                 _tmp12_ = self->priv->_prev;
4098                 _tmp13_ = _tmp12_._iter[0];
4099                 _tmp14_ = _gee_concurrent_set_tower_ref0 (_tmp13_);
4100                 new_prev = _tmp14_;
4101                 _tmp15_ = self->priv->_curr;
4102                 _tmp16_ = _gee_concurrent_set_tower_ref0 (_tmp15_);
4103                 new_curr = _tmp16_;
4104                 _tmp17_ = self->priv->_range;
4105                 _tmp18_ = gee_concurrent_set_range_proceed (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp17_, &new_prev, &new_curr, (guint8) 0);
4106                 result = _tmp18_;
4107                 _gee_concurrent_set_tower_unref0 (new_curr);
4108                 _gee_concurrent_set_tower_unref0 (new_prev);
4109                 _gee_hazard_pointer_context_free0 (ctx);
4110                 return result;
4111         }
4112         _gee_hazard_pointer_context_free0 (ctx);
4113 }
4114
4115
4116 static gpointer gee_concurrent_set_sub_iterator_real_get (GeeIterator* base) {
4117         GeeConcurrentSetSubIterator * self;
4118         gpointer result = NULL;
4119         gboolean _tmp0_;
4120         gboolean _tmp1_;
4121         GeeConcurrentSetTower* _tmp2_;
4122         gconstpointer _tmp3_;
4123         gpointer _tmp4_;
4124         self = (GeeConcurrentSetSubIterator*) base;
4125         _tmp0_ = gee_iterator_get_valid ((GeeIterator*) self);
4126         _tmp1_ = _tmp0_;
4127         _vala_assert (_tmp1_, "valid");
4128         _tmp2_ = self->priv->_curr;
4129         _tmp3_ = _tmp2_->_data;
4130         _tmp4_ = ((_tmp3_ != NULL) && (self->priv->g_dup_func != NULL)) ? self->priv->g_dup_func ((gpointer) _tmp3_) : ((gpointer) _tmp3_);
4131         result = _tmp4_;
4132         return result;
4133 }
4134
4135
4136 static void gee_concurrent_set_sub_iterator_real_remove (GeeIterator* base) {
4137         GeeConcurrentSetSubIterator * self;
4138         GeeHazardPointerContext* _tmp0_;
4139         GeeHazardPointerContext* ctx;
4140         gboolean _tmp1_;
4141         gboolean _tmp2_;
4142         GeeConcurrentSetRange* _tmp3_;
4143         GeeConcurrentSet* _tmp4_;
4144         GCompareDataFunc _tmp5_;
4145         void* _tmp5__target;
4146         GeeConcurrentSetTower* _tmp6_;
4147         gboolean _tmp7_ = FALSE;
4148         self = (GeeConcurrentSetSubIterator*) base;
4149         _tmp0_ = gee_hazard_pointer_context_new (NULL);
4150         ctx = _tmp0_;
4151         _tmp1_ = gee_iterator_get_valid ((GeeIterator*) self);
4152         _tmp2_ = _tmp1_;
4153         _vala_assert (_tmp2_, "valid");
4154         _tmp3_ = self->priv->_range;
4155         _tmp4_ = _tmp3_->_set;
4156         _tmp5_ = _tmp4_->priv->_cmp;
4157         _tmp5__target = _tmp4_->priv->_cmp_target;
4158         _tmp6_ = self->priv->_curr;
4159         _tmp7_ = gee_concurrent_set_tower_remove (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp5_, _tmp5__target, &self->priv->_prev, _tmp6_);
4160         if (_tmp7_) {
4161                 GeeConcurrentSetRange* _tmp8_;
4162                 GeeConcurrentSet* _tmp9_;
4163                 _tmp8_ = self->priv->_range;
4164                 _tmp9_ = _tmp8_->_set;
4165                 g_atomic_int_dec_and_test ((volatile gint *) (&_tmp9_->priv->_size));
4166         }
4167         self->priv->_removed = TRUE;
4168         _gee_hazard_pointer_context_free0 (ctx);
4169 }
4170
4171
4172 static gboolean gee_concurrent_set_sub_iterator_begin (GeeConcurrentSetSubIterator* self) {
4173         gboolean result = FALSE;
4174         GeeConcurrentSetTowerIter _tmp0_;
4175         GeeConcurrentSetTower* _tmp1_;
4176         GeeConcurrentSetRange* _tmp2_;
4177         GeeConcurrentSetTower* _tmp3_ = NULL;
4178         GeeConcurrentSetTowerIter _tmp4_ = {0};
4179         GeeConcurrentSetTower* _tmp5_;
4180         GeeConcurrentSetTower* _tmp12_;
4181         g_return_val_if_fail (self != NULL, FALSE);
4182         _tmp0_ = self->priv->_prev;
4183         _tmp1_ = _tmp0_._iter[0];
4184         if (_tmp1_ != NULL) {
4185                 result = TRUE;
4186                 return result;
4187         }
4188         _tmp2_ = self->priv->_range;
4189         gee_concurrent_set_range_improve_bookmark (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp2_, &_tmp3_, &_tmp4_);
4190         _gee_concurrent_set_tower_unref0 (self->priv->_curr);
4191         self->priv->_curr = _tmp3_;
4192         gee_concurrent_set_tower_iter_destroy (&self->priv->_prev);
4193         self->priv->_prev = _tmp4_;
4194         _tmp5_ = self->priv->_curr;
4195         if (_tmp5_ == NULL) {
4196                 {
4197                         gint i;
4198                         i = 0;
4199                         {
4200                                 gboolean _tmp6_;
4201                                 _tmp6_ = TRUE;
4202                                 while (TRUE) {
4203                                         gboolean _tmp7_;
4204                                         gint _tmp9_;
4205                                         gint _tmp10_;
4206                                         GeeConcurrentSetTower* _tmp11_;
4207                                         _tmp7_ = _tmp6_;
4208                                         if (!_tmp7_) {
4209                                                 gint _tmp8_;
4210                                                 _tmp8_ = i;
4211                                                 i = _tmp8_ + 1;
4212                                         }
4213                                         _tmp6_ = FALSE;
4214                                         _tmp9_ = i;
4215                                         if (!(_tmp9_ < GEE_CONCURRENT_SET__MAX_HEIGHT)) {
4216                                                 break;
4217                                         }
4218                                         _tmp10_ = i;
4219                                         _gee_concurrent_set_tower_unref0 (self->priv->_prev._iter[_tmp10_]);
4220                                         self->priv->_prev._iter[_tmp10_] = NULL;
4221                                         _tmp11_ = self->priv->_prev._iter[_tmp10_];
4222                                 }
4223                         }
4224                 }
4225         }
4226         _tmp12_ = self->priv->_curr;
4227         result = _tmp12_ != NULL;
4228         return result;
4229 }
4230
4231
4232 static gboolean gee_concurrent_set_sub_iterator_real_get_valid (GeeIterator* base) {
4233         gboolean result;
4234         GeeConcurrentSetSubIterator* self;
4235         gboolean _tmp0_ = FALSE;
4236         GeeConcurrentSetTowerIter _tmp1_;
4237         GeeConcurrentSetTower* _tmp2_;
4238         gboolean _tmp4_;
4239         gboolean is_valid;
4240         gboolean _tmp5_ = FALSE;
4241         gboolean _tmp6_;
4242         gboolean _tmp8_;
4243         gboolean _tmp9_;
4244         self = (GeeConcurrentSetSubIterator*) base;
4245         _tmp1_ = self->priv->_prev;
4246         _tmp2_ = _tmp1_._iter[0];
4247         if (_tmp2_ != NULL) {
4248                 gboolean _tmp3_;
4249                 _tmp3_ = self->priv->_removed;
4250                 _tmp0_ = !_tmp3_;
4251         } else {
4252                 _tmp0_ = FALSE;
4253         }
4254         _tmp4_ = _tmp0_;
4255         is_valid = _tmp4_;
4256         _tmp6_ = is_valid;
4257         if (!_tmp6_) {
4258                 _tmp5_ = TRUE;
4259         } else {
4260                 GeeConcurrentSetTower* _tmp7_;
4261                 _tmp7_ = self->priv->_curr;
4262                 _tmp5_ = _tmp7_ != NULL;
4263         }
4264         _tmp8_ = _tmp5_;
4265         _vala_assert (_tmp8_, "!is_valid || _curr != null");
4266         _tmp9_ = is_valid;
4267         result = _tmp9_;
4268         return result;
4269 }
4270
4271
4272 static gboolean gee_concurrent_set_sub_iterator_real_get_read_only (GeeIterator* base) {
4273         gboolean result;
4274         GeeConcurrentSetSubIterator* self;
4275         self = (GeeConcurrentSetSubIterator*) base;
4276         result = FALSE;
4277         return result;
4278 }
4279
4280
4281 static void gee_concurrent_set_sub_iterator_class_init (GeeConcurrentSetSubIteratorClass * klass) {
4282         gee_concurrent_set_sub_iterator_parent_class = g_type_class_peek_parent (klass);
4283         g_type_class_add_private (klass, sizeof (GeeConcurrentSetSubIteratorPrivate));
4284         G_OBJECT_CLASS (klass)->get_property = _vala_gee_concurrent_set_sub_iterator_get_property;
4285         G_OBJECT_CLASS (klass)->set_property = _vala_gee_concurrent_set_sub_iterator_set_property;
4286         G_OBJECT_CLASS (klass)->finalize = gee_concurrent_set_sub_iterator_finalize;
4287         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SUB_ITERATOR_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
4288         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SUB_ITERATOR_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
4289         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SUB_ITERATOR_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
4290         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SUB_ITERATOR_VALID, g_param_spec_boolean ("valid", "valid", "valid", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
4291         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SUB_ITERATOR_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
4292 }
4293
4294
4295 static GType gee_concurrent_set_sub_iterator_gee_traversable_get_g_type (GeeConcurrentSetSubIterator* self) {
4296         return self->priv->g_type;
4297 }
4298
4299
4300 static GBoxedCopyFunc gee_concurrent_set_sub_iterator_gee_traversable_get_g_dup_func (GeeConcurrentSetSubIterator* self) {
4301         return self->priv->g_dup_func;
4302 }
4303
4304
4305 static GDestroyNotify gee_concurrent_set_sub_iterator_gee_traversable_get_g_destroy_func (GeeConcurrentSetSubIterator* self) {
4306         return self->priv->g_destroy_func;
4307 }
4308
4309
4310 static void gee_concurrent_set_sub_iterator_gee_traversable_interface_init (GeeTraversableIface * iface) {
4311         gee_concurrent_set_sub_iterator_gee_traversable_parent_iface = g_type_interface_peek_parent (iface);
4312         iface->foreach = (gboolean (*)(GeeTraversable*, GeeForallFunc, void*)) gee_concurrent_set_sub_iterator_real_foreach;
4313         iface->get_g_type = (GType(*)(GeeTraversable*)) gee_concurrent_set_sub_iterator_gee_traversable_get_g_type;
4314         iface->get_g_dup_func = (GBoxedCopyFunc(*)(GeeTraversable*)) gee_concurrent_set_sub_iterator_gee_traversable_get_g_dup_func;
4315         iface->get_g_destroy_func = (GDestroyNotify(*)(GeeTraversable*)) gee_concurrent_set_sub_iterator_gee_traversable_get_g_destroy_func;
4316 }
4317
4318
4319 static void gee_concurrent_set_sub_iterator_gee_iterator_interface_init (GeeIteratorIface * iface) {
4320         gee_concurrent_set_sub_iterator_gee_iterator_parent_iface = g_type_interface_peek_parent (iface);
4321         iface->next = (gboolean (*)(GeeIterator*)) gee_concurrent_set_sub_iterator_real_next;
4322         iface->has_next = (gboolean (*)(GeeIterator*)) gee_concurrent_set_sub_iterator_real_has_next;
4323         iface->get = (gpointer (*)(GeeIterator*)) gee_concurrent_set_sub_iterator_real_get;
4324         iface->remove = (void (*)(GeeIterator*)) gee_concurrent_set_sub_iterator_real_remove;
4325         iface->get_valid = gee_concurrent_set_sub_iterator_real_get_valid;
4326         iface->get_read_only = gee_concurrent_set_sub_iterator_real_get_read_only;
4327 }
4328
4329
4330 static void gee_concurrent_set_sub_iterator_instance_init (GeeConcurrentSetSubIterator * self) {
4331         self->priv = GEE_CONCURRENT_SET_SUB_ITERATOR_GET_PRIVATE (self);
4332         self->priv->_curr = NULL;
4333         self->priv->_removed = FALSE;
4334 }
4335
4336
4337 static void gee_concurrent_set_sub_iterator_finalize (GObject* obj) {
4338         GeeConcurrentSetSubIterator * self;
4339         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR, GeeConcurrentSetSubIterator);
4340         _gee_concurrent_set_range_unref0 (self->priv->_range);
4341         gee_concurrent_set_tower_iter_destroy (&self->priv->_prev);
4342         _gee_concurrent_set_tower_unref0 (self->priv->_curr);
4343         G_OBJECT_CLASS (gee_concurrent_set_sub_iterator_parent_class)->finalize (obj);
4344 }
4345
4346
4347 static GType gee_concurrent_set_sub_iterator_get_type (void) {
4348         static volatile gsize gee_concurrent_set_sub_iterator_type_id__volatile = 0;
4349         if (g_once_init_enter (&gee_concurrent_set_sub_iterator_type_id__volatile)) {
4350                 static const GTypeInfo g_define_type_info = { sizeof (GeeConcurrentSetSubIteratorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_concurrent_set_sub_iterator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeConcurrentSetSubIterator), 0, (GInstanceInitFunc) gee_concurrent_set_sub_iterator_instance_init, NULL };
4351                 static const GInterfaceInfo gee_traversable_info = { (GInterfaceInitFunc) gee_concurrent_set_sub_iterator_gee_traversable_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
4352                 static const GInterfaceInfo gee_iterator_info = { (GInterfaceInitFunc) gee_concurrent_set_sub_iterator_gee_iterator_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
4353                 GType gee_concurrent_set_sub_iterator_type_id;
4354                 gee_concurrent_set_sub_iterator_type_id = g_type_register_static (G_TYPE_OBJECT, "GeeConcurrentSetSubIterator", &g_define_type_info, 0);
4355                 g_type_add_interface_static (gee_concurrent_set_sub_iterator_type_id, GEE_TYPE_TRAVERSABLE, &gee_traversable_info);
4356                 g_type_add_interface_static (gee_concurrent_set_sub_iterator_type_id, GEE_TYPE_ITERATOR, &gee_iterator_info);
4357                 g_once_init_leave (&gee_concurrent_set_sub_iterator_type_id__volatile, gee_concurrent_set_sub_iterator_type_id);
4358         }
4359         return gee_concurrent_set_sub_iterator_type_id__volatile;
4360 }
4361
4362
4363 static void _vala_gee_concurrent_set_sub_iterator_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
4364         GeeConcurrentSetSubIterator * self;
4365         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR, GeeConcurrentSetSubIterator);
4366         switch (property_id) {
4367                 case GEE_CONCURRENT_SET_SUB_ITERATOR_VALID:
4368                 g_value_set_boolean (value, gee_iterator_get_valid ((GeeIterator*) self));
4369                 break;
4370                 case GEE_CONCURRENT_SET_SUB_ITERATOR_READ_ONLY:
4371                 g_value_set_boolean (value, gee_iterator_get_read_only ((GeeIterator*) self));
4372                 break;
4373                 default:
4374                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4375                 break;
4376         }
4377 }
4378
4379
4380 static void _vala_gee_concurrent_set_sub_iterator_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
4381         GeeConcurrentSetSubIterator * self;
4382         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_CONCURRENT_SET_TYPE_SUB_ITERATOR, GeeConcurrentSetSubIterator);
4383         switch (property_id) {
4384                 case GEE_CONCURRENT_SET_SUB_ITERATOR_G_TYPE:
4385                 self->priv->g_type = g_value_get_gtype (value);
4386                 break;
4387                 case GEE_CONCURRENT_SET_SUB_ITERATOR_G_DUP_FUNC:
4388                 self->priv->g_dup_func = g_value_get_pointer (value);
4389                 break;
4390                 case GEE_CONCURRENT_SET_SUB_ITERATOR_G_DESTROY_FUNC:
4391                 self->priv->g_destroy_func = g_value_get_pointer (value);
4392                 break;
4393                 default:
4394                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
4395                 break;
4396         }
4397 }
4398
4399
4400 static GType gee_concurrent_set_range_position_get_type (void) {
4401         static volatile gsize gee_concurrent_set_range_position_type_id__volatile = 0;
4402         if (g_once_init_enter (&gee_concurrent_set_range_position_type_id__volatile)) {
4403                 static const GEnumValue values[] = {{GEE_CONCURRENT_SET_RANGE_POSITION_BEFORE, "GEE_CONCURRENT_SET_RANGE_POSITION_BEFORE", "before"}, {GEE_CONCURRENT_SET_RANGE_POSITION_INSIDE, "GEE_CONCURRENT_SET_RANGE_POSITION_INSIDE", "inside"}, {GEE_CONCURRENT_SET_RANGE_POSITION_AFTER, "GEE_CONCURRENT_SET_RANGE_POSITION_AFTER", "after"}, {GEE_CONCURRENT_SET_RANGE_POSITION_EMPTY, "GEE_CONCURRENT_SET_RANGE_POSITION_EMPTY", "empty"}, {0, NULL, NULL}};
4404                 GType gee_concurrent_set_range_position_type_id;
4405                 gee_concurrent_set_range_position_type_id = g_enum_register_static ("GeeConcurrentSetRangePosition", values);
4406                 g_once_init_leave (&gee_concurrent_set_range_position_type_id__volatile, gee_concurrent_set_range_position_type_id);
4407         }
4408         return gee_concurrent_set_range_position_type_id__volatile;
4409 }
4410
4411
4412 static GeeConcurrentSetRange* gee_concurrent_set_range_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer start, gconstpointer end) {
4413         GeeConcurrentSetRange* self = NULL;
4414         gconstpointer _tmp0_;
4415         gpointer _tmp1_;
4416         gconstpointer _tmp2_;
4417         gpointer _tmp3_;
4418         GeeConcurrentSet* _tmp4_;
4419         GCompareDataFunc _tmp5_;
4420         void* _tmp5__target;
4421         gconstpointer _tmp6_;
4422         gconstpointer _tmp7_;
4423         gint _tmp8_ = 0;
4424         GeeConcurrentSet* _tmp18_;
4425         GeeConcurrentSet* _tmp19_;
4426         g_return_val_if_fail (cset != NULL, NULL);
4427         self = (GeeConcurrentSetRange*) g_type_create_instance (object_type);
4428         self->priv->g_type = g_type;
4429         self->priv->g_dup_func = g_dup_func;
4430         self->priv->g_destroy_func = g_destroy_func;
4431         _tmp0_ = start;
4432         _tmp1_ = ((_tmp0_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp0_) : ((gpointer) _tmp0_);
4433         _g_destroy_func0 (self->_start);
4434         self->_start = _tmp1_;
4435         _tmp2_ = end;
4436         _tmp3_ = ((_tmp2_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
4437         _g_destroy_func0 (self->_end);
4438         self->_end = _tmp3_;
4439         _tmp4_ = cset;
4440         _tmp5_ = _tmp4_->priv->_cmp;
4441         _tmp5__target = _tmp4_->priv->_cmp_target;
4442         _tmp6_ = start;
4443         _tmp7_ = end;
4444         _tmp8_ = _tmp5_ (_tmp6_, _tmp7_, _tmp5__target);
4445         if (_tmp8_ < 0) {
4446                 self->_type = GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED;
4447                 {
4448                         gint i;
4449                         i = 0;
4450                         {
4451                                 gboolean _tmp9_;
4452                                 _tmp9_ = TRUE;
4453                                 while (TRUE) {
4454                                         gboolean _tmp10_;
4455                                         gint _tmp12_;
4456                                         gint _tmp13_;
4457                                         GeeConcurrentSet* _tmp14_;
4458                                         GeeConcurrentSetTower* _tmp15_;
4459                                         GeeConcurrentSetTower* _tmp16_;
4460                                         GeeConcurrentSetTower* _tmp17_;
4461                                         _tmp10_ = _tmp9_;
4462                                         if (!_tmp10_) {
4463                                                 gint _tmp11_;
4464                                                 _tmp11_ = i;
4465                                                 i = _tmp11_ + 1;
4466                                         }
4467                                         _tmp9_ = FALSE;
4468                                         _tmp12_ = i;
4469                                         if (!(_tmp12_ < GEE_CONCURRENT_SET__MAX_HEIGHT)) {
4470                                                 break;
4471                                         }
4472                                         _tmp13_ = i;
4473                                         _tmp14_ = cset;
4474                                         _tmp15_ = _tmp14_->priv->_head;
4475                                         _tmp16_ = _gee_concurrent_set_tower_ref0 (_tmp15_);
4476                                         _gee_concurrent_set_tower_unref0 (self->_bookmark._iter[_tmp13_]);
4477                                         self->_bookmark._iter[_tmp13_] = _tmp16_;
4478                                         _tmp17_ = self->_bookmark._iter[_tmp13_];
4479                                 }
4480                         }
4481                 }
4482         } else {
4483                 self->_type = GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY;
4484         }
4485         _tmp18_ = cset;
4486         _tmp19_ = _g_object_ref0 (_tmp18_);
4487         _g_object_unref0 (self->_set);
4488         self->_set = _tmp19_;
4489         return self;
4490 }
4491
4492
4493 static GeeConcurrentSetRange* gee_concurrent_set_range_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer start, gconstpointer end) {
4494         return gee_concurrent_set_range_construct (GEE_CONCURRENT_SET_TYPE_RANGE, g_type, g_dup_func, g_destroy_func, cset, start, end);
4495 }
4496
4497
4498 static GeeConcurrentSetRange* gee_concurrent_set_range_construct_head (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer end) {
4499         GeeConcurrentSetRange* self = NULL;
4500         gconstpointer _tmp0_;
4501         gpointer _tmp1_;
4502         GeeConcurrentSet* _tmp11_;
4503         GeeConcurrentSet* _tmp12_;
4504         g_return_val_if_fail (cset != NULL, NULL);
4505         self = (GeeConcurrentSetRange*) g_type_create_instance (object_type);
4506         self->priv->g_type = g_type;
4507         self->priv->g_dup_func = g_dup_func;
4508         self->priv->g_destroy_func = g_destroy_func;
4509         _tmp0_ = end;
4510         _tmp1_ = ((_tmp0_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp0_) : ((gpointer) _tmp0_);
4511         _g_destroy_func0 (self->_end);
4512         self->_end = _tmp1_;
4513         self->_type = GEE_CONCURRENT_SET_RANGE_TYPE_HEAD;
4514         {
4515                 gint i;
4516                 i = 0;
4517                 {
4518                         gboolean _tmp2_;
4519                         _tmp2_ = TRUE;
4520                         while (TRUE) {
4521                                 gboolean _tmp3_;
4522                                 gint _tmp5_;
4523                                 gint _tmp6_;
4524                                 GeeConcurrentSet* _tmp7_;
4525                                 GeeConcurrentSetTower* _tmp8_;
4526                                 GeeConcurrentSetTower* _tmp9_;
4527                                 GeeConcurrentSetTower* _tmp10_;
4528                                 _tmp3_ = _tmp2_;
4529                                 if (!_tmp3_) {
4530                                         gint _tmp4_;
4531                                         _tmp4_ = i;
4532                                         i = _tmp4_ + 1;
4533                                 }
4534                                 _tmp2_ = FALSE;
4535                                 _tmp5_ = i;
4536                                 if (!(_tmp5_ < GEE_CONCURRENT_SET__MAX_HEIGHT)) {
4537                                         break;
4538                                 }
4539                                 _tmp6_ = i;
4540                                 _tmp7_ = cset;
4541                                 _tmp8_ = _tmp7_->priv->_head;
4542                                 _tmp9_ = _gee_concurrent_set_tower_ref0 (_tmp8_);
4543                                 _gee_concurrent_set_tower_unref0 (self->_bookmark._iter[_tmp6_]);
4544                                 self->_bookmark._iter[_tmp6_] = _tmp9_;
4545                                 _tmp10_ = self->_bookmark._iter[_tmp6_];
4546                         }
4547                 }
4548         }
4549         _tmp11_ = cset;
4550         _tmp12_ = _g_object_ref0 (_tmp11_);
4551         _g_object_unref0 (self->_set);
4552         self->_set = _tmp12_;
4553         return self;
4554 }
4555
4556
4557 static GeeConcurrentSetRange* gee_concurrent_set_range_new_head (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer end) {
4558         return gee_concurrent_set_range_construct_head (GEE_CONCURRENT_SET_TYPE_RANGE, g_type, g_dup_func, g_destroy_func, cset, end);
4559 }
4560
4561
4562 static GeeConcurrentSetRange* gee_concurrent_set_range_construct_tail (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer start) {
4563         GeeConcurrentSetRange* self = NULL;
4564         gconstpointer _tmp0_;
4565         gpointer _tmp1_;
4566         GeeConcurrentSet* _tmp11_;
4567         GeeConcurrentSet* _tmp12_;
4568         g_return_val_if_fail (cset != NULL, NULL);
4569         self = (GeeConcurrentSetRange*) g_type_create_instance (object_type);
4570         self->priv->g_type = g_type;
4571         self->priv->g_dup_func = g_dup_func;
4572         self->priv->g_destroy_func = g_destroy_func;
4573         _tmp0_ = start;
4574         _tmp1_ = ((_tmp0_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp0_) : ((gpointer) _tmp0_);
4575         _g_destroy_func0 (self->_start);
4576         self->_start = _tmp1_;
4577         self->_type = GEE_CONCURRENT_SET_RANGE_TYPE_TAIL;
4578         {
4579                 gint i;
4580                 i = 0;
4581                 {
4582                         gboolean _tmp2_;
4583                         _tmp2_ = TRUE;
4584                         while (TRUE) {
4585                                 gboolean _tmp3_;
4586                                 gint _tmp5_;
4587                                 gint _tmp6_;
4588                                 GeeConcurrentSet* _tmp7_;
4589                                 GeeConcurrentSetTower* _tmp8_;
4590                                 GeeConcurrentSetTower* _tmp9_;
4591                                 GeeConcurrentSetTower* _tmp10_;
4592                                 _tmp3_ = _tmp2_;
4593                                 if (!_tmp3_) {
4594                                         gint _tmp4_;
4595                                         _tmp4_ = i;
4596                                         i = _tmp4_ + 1;
4597                                 }
4598                                 _tmp2_ = FALSE;
4599                                 _tmp5_ = i;
4600                                 if (!(_tmp5_ < GEE_CONCURRENT_SET__MAX_HEIGHT)) {
4601                                         break;
4602                                 }
4603                                 _tmp6_ = i;
4604                                 _tmp7_ = cset;
4605                                 _tmp8_ = _tmp7_->priv->_head;
4606                                 _tmp9_ = _gee_concurrent_set_tower_ref0 (_tmp8_);
4607                                 _gee_concurrent_set_tower_unref0 (self->_bookmark._iter[_tmp6_]);
4608                                 self->_bookmark._iter[_tmp6_] = _tmp9_;
4609                                 _tmp10_ = self->_bookmark._iter[_tmp6_];
4610                         }
4611                 }
4612         }
4613         _tmp11_ = cset;
4614         _tmp12_ = _g_object_ref0 (_tmp11_);
4615         _g_object_unref0 (self->_set);
4616         self->_set = _tmp12_;
4617         return self;
4618 }
4619
4620
4621 static GeeConcurrentSetRange* gee_concurrent_set_range_new_tail (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset, gconstpointer start) {
4622         return gee_concurrent_set_range_construct_tail (GEE_CONCURRENT_SET_TYPE_RANGE, g_type, g_dup_func, g_destroy_func, cset, start);
4623 }
4624
4625
4626 static GeeConcurrentSetRange* gee_concurrent_set_range_construct_empty (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset) {
4627         GeeConcurrentSetRange* self = NULL;
4628         GeeConcurrentSet* _tmp0_;
4629         GeeConcurrentSet* _tmp1_;
4630         g_return_val_if_fail (cset != NULL, NULL);
4631         self = (GeeConcurrentSetRange*) g_type_create_instance (object_type);
4632         self->priv->g_type = g_type;
4633         self->priv->g_dup_func = g_dup_func;
4634         self->priv->g_destroy_func = g_destroy_func;
4635         self->_type = GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY;
4636         _tmp0_ = cset;
4637         _tmp1_ = _g_object_ref0 (_tmp0_);
4638         _g_object_unref0 (self->_set);
4639         self->_set = _tmp1_;
4640         return self;
4641 }
4642
4643
4644 static GeeConcurrentSetRange* gee_concurrent_set_range_new_empty (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSet* cset) {
4645         return gee_concurrent_set_range_construct_empty (GEE_CONCURRENT_SET_TYPE_RANGE, g_type, g_dup_func, g_destroy_func, cset);
4646 }
4647
4648
4649 static void gee_concurrent_set_range_copy_bookmark (GeeConcurrentSetRange* self, GeeConcurrentSetRange* range) {
4650         g_return_if_fail (self != NULL);
4651         g_return_if_fail (range != NULL);
4652         {
4653                 gint i;
4654                 i = 0;
4655                 {
4656                         gboolean _tmp0_;
4657                         _tmp0_ = TRUE;
4658                         while (TRUE) {
4659                                 gboolean _tmp1_;
4660                                 gint _tmp3_;
4661                                 gint _tmp4_;
4662                                 GeeConcurrentSetRange* _tmp5_;
4663                                 gint _tmp6_;
4664                                 gpointer _tmp7_ = NULL;
4665                                 GeeConcurrentSetTower* _tmp8_;
4666                                 _tmp1_ = _tmp0_;
4667                                 if (!_tmp1_) {
4668                                         gint _tmp2_;
4669                                         _tmp2_ = i;
4670                                         i = _tmp2_ + 1;
4671                                 }
4672                                 _tmp0_ = FALSE;
4673                                 _tmp3_ = i;
4674                                 if (!(_tmp3_ < GEE_CONCURRENT_SET__MAX_HEIGHT)) {
4675                                         break;
4676                                 }
4677                                 _tmp4_ = i;
4678                                 _tmp5_ = range;
4679                                 _tmp6_ = i;
4680                                 _tmp7_ = gee_hazard_pointer_get_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp5_->_bookmark._iter[_tmp6_], (gsize) 0, NULL);
4681                                 _gee_concurrent_set_tower_unref0 (self->_bookmark._iter[_tmp4_]);
4682                                 self->_bookmark._iter[_tmp4_] = (GeeConcurrentSetTower*) _tmp7_;
4683                                 _tmp8_ = self->_bookmark._iter[_tmp4_];
4684                         }
4685                 }
4686         }
4687 }
4688
4689
4690 static GeeConcurrentSetRange* gee_concurrent_set_range_cut_head (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* from, gconstpointer start) {
4691         GeeConcurrentSetRange* result = NULL;
4692         GeeConcurrentSetRange* _tmp0_;
4693         GeeConcurrentSet* _tmp1_;
4694         GeeConcurrentSetRange* _tmp2_;
4695         GeeConcurrentSetRange* _result_;
4696         GeeConcurrentSetRange* _tmp3_;
4697         GeeConcurrentSetRangeType _tmp4_;
4698         GeeConcurrentSetRange* _tmp52_;
4699         GeeConcurrentSetRangeType _tmp53_;
4700         g_return_val_if_fail (from != NULL, NULL);
4701         _tmp0_ = from;
4702         _tmp1_ = _tmp0_->_set;
4703         _tmp2_ = gee_concurrent_set_range_new_empty (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp1_);
4704         _result_ = _tmp2_;
4705         _tmp3_ = from;
4706         _tmp4_ = _tmp3_->_type;
4707         switch (_tmp4_) {
4708                 case GEE_CONCURRENT_SET_RANGE_TYPE_HEAD:
4709                 {
4710                         GeeConcurrentSetRange* _tmp5_;
4711                         GeeConcurrentSet* _tmp6_;
4712                         GCompareDataFunc _tmp7_;
4713                         void* _tmp7__target;
4714                         gconstpointer _tmp8_;
4715                         GeeConcurrentSetRange* _tmp9_;
4716                         gconstpointer _tmp10_;
4717                         gint _tmp11_ = 0;
4718                         _tmp5_ = from;
4719                         _tmp6_ = _tmp5_->_set;
4720                         _tmp7_ = _tmp6_->priv->_cmp;
4721                         _tmp7__target = _tmp6_->priv->_cmp_target;
4722                         _tmp8_ = start;
4723                         _tmp9_ = from;
4724                         _tmp10_ = _tmp9_->_end;
4725                         _tmp11_ = _tmp7_ (_tmp8_, _tmp10_, _tmp7__target);
4726                         if (_tmp11_ < 0) {
4727                                 GeeConcurrentSetRange* _tmp12_;
4728                                 gconstpointer _tmp13_;
4729                                 gpointer _tmp14_;
4730                                 GeeConcurrentSetRange* _tmp15_;
4731                                 GeeConcurrentSetRange* _tmp16_;
4732                                 gconstpointer _tmp17_;
4733                                 gpointer _tmp18_;
4734                                 GeeConcurrentSetRange* _tmp19_;
4735                                 _tmp12_ = _result_;
4736                                 _tmp13_ = start;
4737                                 _tmp14_ = ((_tmp13_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp13_) : ((gpointer) _tmp13_);
4738                                 _g_destroy_func0 (_tmp12_->_start);
4739                                 _tmp12_->_start = _tmp14_;
4740                                 _tmp15_ = _result_;
4741                                 _tmp16_ = from;
4742                                 _tmp17_ = _tmp16_->_end;
4743                                 _tmp18_ = ((_tmp17_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp17_) : ((gpointer) _tmp17_);
4744                                 _g_destroy_func0 (_tmp15_->_end);
4745                                 _tmp15_->_end = _tmp18_;
4746                                 _tmp19_ = _result_;
4747                                 _tmp19_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED;
4748                         } else {
4749                                 GeeConcurrentSetRange* _tmp20_;
4750                                 _tmp20_ = _result_;
4751                                 _tmp20_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY;
4752                         }
4753                         break;
4754                 }
4755                 case GEE_CONCURRENT_SET_RANGE_TYPE_TAIL:
4756                 {
4757                         GeeConcurrentSetRange* _tmp21_;
4758                         GeeConcurrentSetRange* _tmp22_;
4759                         GeeConcurrentSet* _tmp23_;
4760                         GeeConcurrentSetRange* _tmp24_;
4761                         gconstpointer _tmp25_;
4762                         gconstpointer _tmp26_;
4763                         gconstpointer _tmp27_ = NULL;
4764                         gpointer _tmp28_;
4765                         GeeConcurrentSetRange* _tmp29_;
4766                         _tmp21_ = _result_;
4767                         _tmp22_ = from;
4768                         _tmp23_ = _tmp22_->_set;
4769                         _tmp24_ = from;
4770                         _tmp25_ = _tmp24_->_start;
4771                         _tmp26_ = start;
4772                         _tmp27_ = gee_concurrent_set_max (_tmp23_, _tmp25_, _tmp26_, NULL);
4773                         _tmp28_ = ((_tmp27_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp27_) : ((gpointer) _tmp27_);
4774                         _g_destroy_func0 (_tmp21_->_start);
4775                         _tmp21_->_start = _tmp28_;
4776                         _tmp29_ = _result_;
4777                         _tmp29_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_TAIL;
4778                         break;
4779                 }
4780                 case GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED:
4781                 {
4782                         GeeConcurrentSetRange* _tmp30_;
4783                         GeeConcurrentSet* _tmp31_;
4784                         GCompareDataFunc _tmp32_;
4785                         void* _tmp32__target;
4786                         GeeConcurrentSetRange* _tmp33_;
4787                         gconstpointer _tmp34_;
4788                         gconstpointer _tmp35_;
4789                         gint _tmp36_ = 0;
4790                         _tmp30_ = from;
4791                         _tmp31_ = _tmp30_->_set;
4792                         _tmp32_ = _tmp31_->priv->_cmp;
4793                         _tmp32__target = _tmp31_->priv->_cmp_target;
4794                         _tmp33_ = from;
4795                         _tmp34_ = _tmp33_->_start;
4796                         _tmp35_ = start;
4797                         _tmp36_ = _tmp32_ (_tmp34_, _tmp35_, _tmp32__target);
4798                         if (_tmp36_ < 0) {
4799                                 GeeConcurrentSetRange* _tmp37_;
4800                                 GeeConcurrentSetRange* _tmp38_;
4801                                 GeeConcurrentSet* _tmp39_;
4802                                 GeeConcurrentSetRange* _tmp40_;
4803                                 gconstpointer _tmp41_;
4804                                 gconstpointer _tmp42_;
4805                                 gconstpointer _tmp43_ = NULL;
4806                                 gpointer _tmp44_;
4807                                 GeeConcurrentSetRange* _tmp45_;
4808                                 GeeConcurrentSetRange* _tmp46_;
4809                                 gconstpointer _tmp47_;
4810                                 gpointer _tmp48_;
4811                                 GeeConcurrentSetRange* _tmp49_;
4812                                 _tmp37_ = _result_;
4813                                 _tmp38_ = from;
4814                                 _tmp39_ = _tmp38_->_set;
4815                                 _tmp40_ = from;
4816                                 _tmp41_ = _tmp40_->_start;
4817                                 _tmp42_ = start;
4818                                 _tmp43_ = gee_concurrent_set_max (_tmp39_, _tmp41_, _tmp42_, NULL);
4819                                 _tmp44_ = ((_tmp43_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp43_) : ((gpointer) _tmp43_);
4820                                 _g_destroy_func0 (_tmp37_->_start);
4821                                 _tmp37_->_start = _tmp44_;
4822                                 _tmp45_ = _result_;
4823                                 _tmp46_ = from;
4824                                 _tmp47_ = _tmp46_->_end;
4825                                 _tmp48_ = ((_tmp47_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp47_) : ((gpointer) _tmp47_);
4826                                 _g_destroy_func0 (_tmp45_->_end);
4827                                 _tmp45_->_end = _tmp48_;
4828                                 _tmp49_ = _result_;
4829                                 _tmp49_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED;
4830                         } else {
4831                                 GeeConcurrentSetRange* _tmp50_;
4832                                 _tmp50_ = _result_;
4833                                 _tmp50_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY;
4834                         }
4835                         break;
4836                 }
4837                 case GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY:
4838                 {
4839                         GeeConcurrentSetRange* _tmp51_;
4840                         _tmp51_ = _result_;
4841                         _tmp51_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY;
4842                         break;
4843                 }
4844                 default:
4845                 {
4846                         g_assert_not_reached ();
4847                 }
4848         }
4849         _tmp52_ = _result_;
4850         _tmp53_ = _tmp52_->_type;
4851         if (_tmp53_ != GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY) {
4852                 GeeConcurrentSetRange* _tmp54_;
4853                 GeeConcurrentSetRange* _tmp55_;
4854                 GeeConcurrentSetRange* _tmp56_;
4855                 GeeConcurrentSetRange* _tmp57_;
4856                 _tmp54_ = from;
4857                 gee_concurrent_set_range_improve_bookmark (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp54_, NULL, NULL);
4858                 _tmp55_ = _result_;
4859                 _tmp56_ = from;
4860                 gee_concurrent_set_range_copy_bookmark (_tmp55_, _tmp56_);
4861                 _tmp57_ = _result_;
4862                 gee_concurrent_set_range_improve_bookmark (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp57_, NULL, NULL);
4863         }
4864         result = _result_;
4865         return result;
4866 }
4867
4868
4869 static GeeConcurrentSetRange* gee_concurrent_set_range_cut_tail (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* from, gconstpointer end) {
4870         GeeConcurrentSetRange* result = NULL;
4871         GeeConcurrentSetRange* _tmp0_;
4872         GeeConcurrentSet* _tmp1_;
4873         GeeConcurrentSetRange* _tmp2_;
4874         GeeConcurrentSetRange* _result_;
4875         GeeConcurrentSetRange* _tmp3_;
4876         GeeConcurrentSetRangeType _tmp4_;
4877         GeeConcurrentSetRange* _tmp52_;
4878         GeeConcurrentSetRangeType _tmp53_;
4879         g_return_val_if_fail (from != NULL, NULL);
4880         _tmp0_ = from;
4881         _tmp1_ = _tmp0_->_set;
4882         _tmp2_ = gee_concurrent_set_range_new_empty (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp1_);
4883         _result_ = _tmp2_;
4884         _tmp3_ = from;
4885         _tmp4_ = _tmp3_->_type;
4886         switch (_tmp4_) {
4887                 case GEE_CONCURRENT_SET_RANGE_TYPE_HEAD:
4888                 {
4889                         GeeConcurrentSetRange* _tmp5_;
4890                         GeeConcurrentSetRange* _tmp6_;
4891                         GeeConcurrentSet* _tmp7_;
4892                         GeeConcurrentSetRange* _tmp8_;
4893                         gconstpointer _tmp9_;
4894                         gconstpointer _tmp10_;
4895                         gconstpointer _tmp11_ = NULL;
4896                         gpointer _tmp12_;
4897                         GeeConcurrentSetRange* _tmp13_;
4898                         _tmp5_ = _result_;
4899                         _tmp6_ = from;
4900                         _tmp7_ = _tmp6_->_set;
4901                         _tmp8_ = from;
4902                         _tmp9_ = _tmp8_->_end;
4903                         _tmp10_ = end;
4904                         _tmp11_ = gee_concurrent_set_min (_tmp7_, _tmp9_, _tmp10_, NULL);
4905                         _tmp12_ = ((_tmp11_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp11_) : ((gpointer) _tmp11_);
4906                         _g_destroy_func0 (_tmp5_->_end);
4907                         _tmp5_->_end = _tmp12_;
4908                         _tmp13_ = _result_;
4909                         _tmp13_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_HEAD;
4910                         break;
4911                 }
4912                 case GEE_CONCURRENT_SET_RANGE_TYPE_TAIL:
4913                 {
4914                         GeeConcurrentSetRange* _tmp14_;
4915                         GeeConcurrentSet* _tmp15_;
4916                         GCompareDataFunc _tmp16_;
4917                         void* _tmp16__target;
4918                         GeeConcurrentSetRange* _tmp17_;
4919                         gconstpointer _tmp18_;
4920                         gconstpointer _tmp19_;
4921                         gint _tmp20_ = 0;
4922                         _tmp14_ = from;
4923                         _tmp15_ = _tmp14_->_set;
4924                         _tmp16_ = _tmp15_->priv->_cmp;
4925                         _tmp16__target = _tmp15_->priv->_cmp_target;
4926                         _tmp17_ = from;
4927                         _tmp18_ = _tmp17_->_start;
4928                         _tmp19_ = end;
4929                         _tmp20_ = _tmp16_ (_tmp18_, _tmp19_, _tmp16__target);
4930                         if (_tmp20_ < 0) {
4931                                 GeeConcurrentSetRange* _tmp21_;
4932                                 GeeConcurrentSetRange* _tmp22_;
4933                                 gconstpointer _tmp23_;
4934                                 gpointer _tmp24_;
4935                                 GeeConcurrentSetRange* _tmp25_;
4936                                 gconstpointer _tmp26_;
4937                                 gpointer _tmp27_;
4938                                 GeeConcurrentSetRange* _tmp28_;
4939                                 _tmp21_ = _result_;
4940                                 _tmp22_ = from;
4941                                 _tmp23_ = _tmp22_->_start;
4942                                 _tmp24_ = ((_tmp23_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp23_) : ((gpointer) _tmp23_);
4943                                 _g_destroy_func0 (_tmp21_->_start);
4944                                 _tmp21_->_start = _tmp24_;
4945                                 _tmp25_ = _result_;
4946                                 _tmp26_ = end;
4947                                 _tmp27_ = ((_tmp26_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp26_) : ((gpointer) _tmp26_);
4948                                 _g_destroy_func0 (_tmp25_->_end);
4949                                 _tmp25_->_end = _tmp27_;
4950                                 _tmp28_ = _result_;
4951                                 _tmp28_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED;
4952                         } else {
4953                                 GeeConcurrentSetRange* _tmp29_;
4954                                 _tmp29_ = _result_;
4955                                 _tmp29_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY;
4956                         }
4957                         break;
4958                 }
4959                 case GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED:
4960                 {
4961                         GeeConcurrentSetRange* _tmp30_;
4962                         GeeConcurrentSet* _tmp31_;
4963                         GCompareDataFunc _tmp32_;
4964                         void* _tmp32__target;
4965                         GeeConcurrentSetRange* _tmp33_;
4966                         gconstpointer _tmp34_;
4967                         gconstpointer _tmp35_;
4968                         gint _tmp36_ = 0;
4969                         _tmp30_ = from;
4970                         _tmp31_ = _tmp30_->_set;
4971                         _tmp32_ = _tmp31_->priv->_cmp;
4972                         _tmp32__target = _tmp31_->priv->_cmp_target;
4973                         _tmp33_ = from;
4974                         _tmp34_ = _tmp33_->_start;
4975                         _tmp35_ = end;
4976                         _tmp36_ = _tmp32_ (_tmp34_, _tmp35_, _tmp32__target);
4977                         if (_tmp36_ < 0) {
4978                                 GeeConcurrentSetRange* _tmp37_;
4979                                 GeeConcurrentSetRange* _tmp38_;
4980                                 gconstpointer _tmp39_;
4981                                 gpointer _tmp40_;
4982                                 GeeConcurrentSetRange* _tmp41_;
4983                                 GeeConcurrentSetRange* _tmp42_;
4984                                 GeeConcurrentSet* _tmp43_;
4985                                 GeeConcurrentSetRange* _tmp44_;
4986                                 gconstpointer _tmp45_;
4987                                 gconstpointer _tmp46_;
4988                                 gconstpointer _tmp47_ = NULL;
4989                                 gpointer _tmp48_;
4990                                 GeeConcurrentSetRange* _tmp49_;
4991                                 _tmp37_ = _result_;
4992                                 _tmp38_ = from;
4993                                 _tmp39_ = _tmp38_->_start;
4994                                 _tmp40_ = ((_tmp39_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp39_) : ((gpointer) _tmp39_);
4995                                 _g_destroy_func0 (_tmp37_->_start);
4996                                 _tmp37_->_start = _tmp40_;
4997                                 _tmp41_ = _result_;
4998                                 _tmp42_ = from;
4999                                 _tmp43_ = _tmp42_->_set;
5000                                 _tmp44_ = from;
5001                                 _tmp45_ = _tmp44_->_end;
5002                                 _tmp46_ = end;
5003                                 _tmp47_ = gee_concurrent_set_min (_tmp43_, _tmp45_, _tmp46_, NULL);
5004                                 _tmp48_ = ((_tmp47_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp47_) : ((gpointer) _tmp47_);
5005                                 _g_destroy_func0 (_tmp41_->_end);
5006                                 _tmp41_->_end = _tmp48_;
5007                                 _tmp49_ = _result_;
5008                                 _tmp49_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED;
5009                         } else {
5010                                 GeeConcurrentSetRange* _tmp50_;
5011                                 _tmp50_ = _result_;
5012                                 _tmp50_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY;
5013                         }
5014                         break;
5015                 }
5016                 case GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY:
5017                 {
5018                         GeeConcurrentSetRange* _tmp51_;
5019                         _tmp51_ = _result_;
5020                         _tmp51_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY;
5021                         break;
5022                 }
5023                 default:
5024                 {
5025                         g_assert_not_reached ();
5026                 }
5027         }
5028         _tmp52_ = _result_;
5029         _tmp53_ = _tmp52_->_type;
5030         if (_tmp53_ != GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY) {
5031                 GeeConcurrentSetRange* _tmp54_;
5032                 GeeConcurrentSetRange* _tmp55_;
5033                 GeeConcurrentSetRange* _tmp56_;
5034                 GeeConcurrentSetRange* _tmp57_;
5035                 _tmp54_ = from;
5036                 gee_concurrent_set_range_improve_bookmark (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp54_, NULL, NULL);
5037                 _tmp55_ = _result_;
5038                 _tmp56_ = from;
5039                 gee_concurrent_set_range_copy_bookmark (_tmp55_, _tmp56_);
5040                 _tmp57_ = _result_;
5041                 gee_concurrent_set_range_improve_bookmark (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp57_, NULL, NULL);
5042         }
5043         result = _result_;
5044         return result;
5045 }
5046
5047
5048 static GeeConcurrentSetRange* gee_concurrent_set_range_cut (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* from, gconstpointer start, gconstpointer end) {
5049         GeeConcurrentSetRange* result = NULL;
5050         GeeConcurrentSetRange* _tmp0_;
5051         GeeConcurrentSet* _tmp1_;
5052         GeeConcurrentSetRange* _tmp2_;
5053         GeeConcurrentSetRange* _result_;
5054         GeeConcurrentSetRange* _tmp3_;
5055         GeeConcurrentSetRange* _tmp4_;
5056         GeeConcurrentSetRangeType _tmp5_;
5057         gboolean _tmp31_ = FALSE;
5058         GeeConcurrentSetRange* _tmp32_;
5059         GeeConcurrentSetRangeType _tmp33_;
5060         gboolean _tmp40_;
5061         GeeConcurrentSetRange* _tmp49_;
5062         GeeConcurrentSetRangeType _tmp50_;
5063         g_return_val_if_fail (from != NULL, NULL);
5064         _tmp0_ = from;
5065         _tmp1_ = _tmp0_->_set;
5066         _tmp2_ = gee_concurrent_set_range_new_empty (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp1_);
5067         _result_ = _tmp2_;
5068         _tmp3_ = _result_;
5069         _tmp3_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED;
5070         _tmp4_ = from;
5071         _tmp5_ = _tmp4_->_type;
5072         switch (_tmp5_) {
5073                 case GEE_CONCURRENT_SET_RANGE_TYPE_HEAD:
5074                 {
5075                         GeeConcurrentSetRange* _tmp6_;
5076                         GeeConcurrentSet* _tmp7_;
5077                         GeeConcurrentSetRange* _tmp8_;
5078                         gconstpointer _tmp9_;
5079                         gconstpointer _tmp10_;
5080                         gconstpointer _tmp11_ = NULL;
5081                         _tmp6_ = from;
5082                         _tmp7_ = _tmp6_->_set;
5083                         _tmp8_ = from;
5084                         _tmp9_ = _tmp8_->_end;
5085                         _tmp10_ = end;
5086                         _tmp11_ = gee_concurrent_set_min (_tmp7_, _tmp9_, _tmp10_, NULL);
5087                         end = _tmp11_;
5088                         break;
5089                 }
5090                 case GEE_CONCURRENT_SET_RANGE_TYPE_TAIL:
5091                 {
5092                         GeeConcurrentSetRange* _tmp12_;
5093                         GeeConcurrentSet* _tmp13_;
5094                         GeeConcurrentSetRange* _tmp14_;
5095                         gconstpointer _tmp15_;
5096                         gconstpointer _tmp16_;
5097                         gconstpointer _tmp17_ = NULL;
5098                         _tmp12_ = from;
5099                         _tmp13_ = _tmp12_->_set;
5100                         _tmp14_ = from;
5101                         _tmp15_ = _tmp14_->_start;
5102                         _tmp16_ = start;
5103                         _tmp17_ = gee_concurrent_set_max (_tmp13_, _tmp15_, _tmp16_, NULL);
5104                         start = _tmp17_;
5105                         break;
5106                 }
5107                 case GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED:
5108                 {
5109                         GeeConcurrentSetRange* _tmp18_;
5110                         GeeConcurrentSet* _tmp19_;
5111                         GeeConcurrentSetRange* _tmp20_;
5112                         gconstpointer _tmp21_;
5113                         gconstpointer _tmp22_;
5114                         gconstpointer _tmp23_ = NULL;
5115                         GeeConcurrentSetRange* _tmp24_;
5116                         GeeConcurrentSet* _tmp25_;
5117                         GeeConcurrentSetRange* _tmp26_;
5118                         gconstpointer _tmp27_;
5119                         gconstpointer _tmp28_;
5120                         gconstpointer _tmp29_ = NULL;
5121                         _tmp18_ = from;
5122                         _tmp19_ = _tmp18_->_set;
5123                         _tmp20_ = from;
5124                         _tmp21_ = _tmp20_->_start;
5125                         _tmp22_ = start;
5126                         _tmp23_ = gee_concurrent_set_max (_tmp19_, _tmp21_, _tmp22_, NULL);
5127                         start = _tmp23_;
5128                         _tmp24_ = from;
5129                         _tmp25_ = _tmp24_->_set;
5130                         _tmp26_ = from;
5131                         _tmp27_ = _tmp26_->_end;
5132                         _tmp28_ = end;
5133                         _tmp29_ = gee_concurrent_set_min (_tmp25_, _tmp27_, _tmp28_, NULL);
5134                         end = _tmp29_;
5135                         break;
5136                 }
5137                 case GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY:
5138                 {
5139                         GeeConcurrentSetRange* _tmp30_;
5140                         _tmp30_ = _result_;
5141                         _tmp30_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY;
5142                         break;
5143                 }
5144                 default:
5145                 {
5146                         g_assert_not_reached ();
5147                 }
5148         }
5149         _tmp32_ = _result_;
5150         _tmp33_ = _tmp32_->_type;
5151         if (_tmp33_ != GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY) {
5152                 GeeConcurrentSetRange* _tmp34_;
5153                 GeeConcurrentSet* _tmp35_;
5154                 GCompareDataFunc _tmp36_;
5155                 void* _tmp36__target;
5156                 gconstpointer _tmp37_;
5157                 gconstpointer _tmp38_;
5158                 gint _tmp39_ = 0;
5159                 _tmp34_ = from;
5160                 _tmp35_ = _tmp34_->_set;
5161                 _tmp36_ = _tmp35_->priv->_cmp;
5162                 _tmp36__target = _tmp35_->priv->_cmp_target;
5163                 _tmp37_ = start;
5164                 _tmp38_ = end;
5165                 _tmp39_ = _tmp36_ (_tmp37_, _tmp38_, _tmp36__target);
5166                 _tmp31_ = _tmp39_ < 0;
5167         } else {
5168                 _tmp31_ = FALSE;
5169         }
5170         _tmp40_ = _tmp31_;
5171         if (_tmp40_) {
5172                 GeeConcurrentSetRange* _tmp41_;
5173                 gconstpointer _tmp42_;
5174                 gpointer _tmp43_;
5175                 GeeConcurrentSetRange* _tmp44_;
5176                 gconstpointer _tmp45_;
5177                 gpointer _tmp46_;
5178                 GeeConcurrentSetRange* _tmp47_;
5179                 _tmp41_ = _result_;
5180                 _tmp42_ = start;
5181                 _tmp43_ = ((_tmp42_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp42_) : ((gpointer) _tmp42_);
5182                 _g_destroy_func0 (_tmp41_->_start);
5183                 _tmp41_->_start = _tmp43_;
5184                 _tmp44_ = _result_;
5185                 _tmp45_ = end;
5186                 _tmp46_ = ((_tmp45_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp45_) : ((gpointer) _tmp45_);
5187                 _g_destroy_func0 (_tmp44_->_end);
5188                 _tmp44_->_end = _tmp46_;
5189                 _tmp47_ = _result_;
5190                 _tmp47_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED;
5191         } else {
5192                 GeeConcurrentSetRange* _tmp48_;
5193                 _tmp48_ = _result_;
5194                 _tmp48_->_type = GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY;
5195         }
5196         _tmp49_ = _result_;
5197         _tmp50_ = _tmp49_->_type;
5198         if (_tmp50_ != GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY) {
5199                 GeeConcurrentSetRange* _tmp51_;
5200                 GeeConcurrentSetRange* _tmp52_;
5201                 GeeConcurrentSetRange* _tmp53_;
5202                 GeeConcurrentSetRange* _tmp54_;
5203                 _tmp51_ = from;
5204                 gee_concurrent_set_range_improve_bookmark (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp51_, NULL, NULL);
5205                 _tmp52_ = _result_;
5206                 _tmp53_ = from;
5207                 gee_concurrent_set_range_copy_bookmark (_tmp52_, _tmp53_);
5208                 _tmp54_ = _result_;
5209                 gee_concurrent_set_range_improve_bookmark (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp54_, NULL, NULL);
5210         }
5211         result = _result_;
5212         return result;
5213 }
5214
5215
5216 static void gee_concurrent_set_range_improve_bookmark (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, GeeConcurrentSetTower** out_curr, GeeConcurrentSetTowerIter* prev) {
5217         GeeConcurrentSetTower* _vala_out_curr = NULL;
5218         GeeConcurrentSetTowerIter _vala_prev = {0};
5219         GeeConcurrentSetRange* _tmp0_;
5220         GeeConcurrentSetRangeType _tmp1_;
5221         gboolean _tmp112_ = FALSE;
5222         gboolean _tmp113_ = FALSE;
5223         gboolean _tmp115_;
5224         gboolean _tmp119_;
5225         g_return_if_fail (range != NULL);
5226         gee_concurrent_set_tower_iter_destroy (&_vala_prev);
5227         memset (&_vala_prev, 0, sizeof (GeeConcurrentSetTowerIter));
5228         _tmp0_ = range;
5229         _tmp1_ = _tmp0_->_type;
5230         switch (_tmp1_) {
5231                 case GEE_CONCURRENT_SET_RANGE_TYPE_HEAD:
5232                 {
5233                         if ((&_vala_out_curr) != NULL) {
5234                                 GeeConcurrentSetRange* _tmp2_;
5235                                 gpointer _tmp3_ = NULL;
5236                                 _tmp2_ = range;
5237                                 _tmp3_ = gee_hazard_pointer_get_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp2_->_bookmark._iter[0], (gsize) 0, NULL);
5238                                 _gee_concurrent_set_tower_unref0 (_vala_out_curr);
5239                                 _vala_out_curr = (GeeConcurrentSetTower*) _tmp3_;
5240                                 if ((&_vala_prev) != NULL) {
5241                                         GeeConcurrentSetTower* _tmp4_;
5242                                         GeeConcurrentSetTower* _tmp5_;
5243                                         GeeConcurrentSetTowerIter _tmp6_;
5244                                         GeeConcurrentSetTower* _tmp7_;
5245                                         GeeConcurrentSetTower* _tmp8_ = NULL;
5246                                         _tmp4_ = _vala_out_curr;
5247                                         _vala_out_curr = NULL;
5248                                         _gee_concurrent_set_tower_unref0 (_vala_prev._iter[0]);
5249                                         _vala_prev._iter[0] = _tmp4_;
5250                                         _tmp5_ = _vala_prev._iter[0];
5251                                         _tmp6_ = _vala_prev;
5252                                         _tmp7_ = _tmp6_._iter[0];
5253                                         _tmp8_ = gee_concurrent_set_tower_get_next (_tmp7_, (guint8) 0);
5254                                         _gee_concurrent_set_tower_unref0 (_vala_out_curr);
5255                                         _vala_out_curr = _tmp8_;
5256                                 } else {
5257                                         GeeConcurrentSetTower* _tmp9_;
5258                                         GeeConcurrentSetTower* _tmp10_ = NULL;
5259                                         _tmp9_ = _vala_out_curr;
5260                                         _tmp10_ = gee_concurrent_set_tower_get_next (_tmp9_, (guint8) 0);
5261                                         _gee_concurrent_set_tower_unref0 (_vala_out_curr);
5262                                         _vala_out_curr = _tmp10_;
5263                                 }
5264                         }
5265                         if ((&_vala_prev) != NULL) {
5266                                 {
5267                                         gint _tmp11_ = 0;
5268                                         gint _tmp12_;
5269                                         gint i;
5270                                         if ((&_vala_out_curr) != NULL) {
5271                                                 _tmp11_ = 1;
5272                                         } else {
5273                                                 _tmp11_ = 0;
5274                                         }
5275                                         _tmp12_ = _tmp11_;
5276                                         i = _tmp12_;
5277                                         {
5278                                                 gboolean _tmp13_;
5279                                                 _tmp13_ = TRUE;
5280                                                 while (TRUE) {
5281                                                         gboolean _tmp14_;
5282                                                         gint _tmp16_;
5283                                                         gint _tmp17_;
5284                                                         GeeConcurrentSetRange* _tmp18_;
5285                                                         gint _tmp19_;
5286                                                         gpointer _tmp20_ = NULL;
5287                                                         GeeConcurrentSetTower* _tmp21_;
5288                                                         _tmp14_ = _tmp13_;
5289                                                         if (!_tmp14_) {
5290                                                                 gint _tmp15_;
5291                                                                 _tmp15_ = i;
5292                                                                 i = _tmp15_ + 1;
5293                                                         }
5294                                                         _tmp13_ = FALSE;
5295                                                         _tmp16_ = i;
5296                                                         if (!(_tmp16_ < GEE_CONCURRENT_SET__MAX_HEIGHT)) {
5297                                                                 break;
5298                                                         }
5299                                                         _tmp17_ = i;
5300                                                         _tmp18_ = range;
5301                                                         _tmp19_ = i;
5302                                                         _tmp20_ = gee_hazard_pointer_get_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp18_->_bookmark._iter[_tmp19_], (gsize) 0, NULL);
5303                                                         _gee_concurrent_set_tower_unref0 (_vala_prev._iter[_tmp17_]);
5304                                                         _vala_prev._iter[_tmp17_] = (GeeConcurrentSetTower*) _tmp20_;
5305                                                         _tmp21_ = _vala_prev._iter[_tmp17_];
5306                                                 }
5307                                         }
5308                                 }
5309                         }
5310                         break;
5311                 }
5312                 case GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY:
5313                 {
5314                         _gee_concurrent_set_tower_unref0 (_vala_out_curr);
5315                         _vala_out_curr = NULL;
5316                         break;
5317                 }
5318                 case GEE_CONCURRENT_SET_RANGE_TYPE_TAIL:
5319                 case GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED:
5320                 {
5321                         GeeConcurrentSetTower* last_best;
5322                         last_best = NULL;
5323                         {
5324                                 gint i;
5325                                 i = GEE_CONCURRENT_SET__MAX_HEIGHT - 1;
5326                                 {
5327                                         gboolean _tmp22_;
5328                                         _tmp22_ = TRUE;
5329                                         while (TRUE) {
5330                                                 gboolean _tmp23_;
5331                                                 gint _tmp25_;
5332                                                 GeeConcurrentSetRange* _tmp26_;
5333                                                 gint _tmp27_;
5334                                                 gpointer _tmp28_ = NULL;
5335                                                 GeeConcurrentSetTower* curr;
5336                                                 GeeConcurrentSetTower* _tmp29_;
5337                                                 GeeConcurrentSetTower* _tmp30_;
5338                                                 GeeConcurrentSetTower* curr_old;
5339                                                 GeeConcurrentSetTower* _tmp31_;
5340                                                 gint _tmp32_;
5341                                                 gboolean _tmp33_ = FALSE;
5342                                                 gboolean _tmp34_ = FALSE;
5343                                                 GeeConcurrentSetTower* _tmp35_;
5344                                                 gboolean _tmp38_;
5345                                                 gboolean _tmp45_;
5346                                                 GeeConcurrentSetTower* _tmp48_;
5347                                                 GeeConcurrentSetTower* _tmp49_;
5348                                                 GeeConcurrentSetTower* _tmp59_;
5349                                                 gint _tmp60_;
5350                                                 GeeConcurrentSetTower* _tmp61_ = NULL;
5351                                                 GeeConcurrentSetTower* next;
5352                                                 gboolean _tmp62_ = FALSE;
5353                                                 gboolean _tmp64_;
5354                                                 GeeConcurrentSetTower* _tmp111_;
5355                                                 _tmp23_ = _tmp22_;
5356                                                 if (!_tmp23_) {
5357                                                         gint _tmp24_;
5358                                                         _tmp24_ = i;
5359                                                         i = _tmp24_ - 1;
5360                                                 }
5361                                                 _tmp22_ = FALSE;
5362                                                 _tmp25_ = i;
5363                                                 if (!(_tmp25_ >= 0)) {
5364                                                         break;
5365                                                 }
5366                                                 _tmp26_ = range;
5367                                                 _tmp27_ = i;
5368                                                 _tmp28_ = gee_hazard_pointer_get_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp26_->_bookmark._iter[_tmp27_], (gsize) 0, NULL);
5369                                                 curr = (GeeConcurrentSetTower*) _tmp28_;
5370                                                 _tmp29_ = curr;
5371                                                 _tmp30_ = _gee_concurrent_set_tower_ref0 (_tmp29_);
5372                                                 curr_old = _tmp30_;
5373                                                 _tmp31_ = curr;
5374                                                 _vala_assert (_tmp31_ != NULL, "curr != null");
5375                                                 _tmp32_ = i;
5376                                                 gee_concurrent_set_tower_backtrace (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, &curr, (guint8) _tmp32_);
5377                                                 _tmp35_ = last_best;
5378                                                 if (_tmp35_ != NULL) {
5379                                                         GeeConcurrentSetTower* _tmp36_;
5380                                                         GeeConcurrentSetTower* _tmp37_;
5381                                                         _tmp36_ = last_best;
5382                                                         _tmp37_ = curr;
5383                                                         _tmp34_ = _tmp36_ != _tmp37_;
5384                                                 } else {
5385                                                         _tmp34_ = FALSE;
5386                                                 }
5387                                                 _tmp38_ = _tmp34_;
5388                                                 if (_tmp38_) {
5389                                                         GeeConcurrentSetRange* _tmp39_;
5390                                                         GeeConcurrentSet* _tmp40_;
5391                                                         GCompareDataFunc _tmp41_;
5392                                                         void* _tmp41__target;
5393                                                         GeeConcurrentSetTower* _tmp42_;
5394                                                         GeeConcurrentSetTower* _tmp43_;
5395                                                         gint _tmp44_ = 0;
5396                                                         _tmp39_ = range;
5397                                                         _tmp40_ = _tmp39_->_set;
5398                                                         _tmp41_ = _tmp40_->priv->_cmp;
5399                                                         _tmp41__target = _tmp40_->priv->_cmp_target;
5400                                                         _tmp42_ = curr;
5401                                                         _tmp43_ = last_best;
5402                                                         _tmp44_ = gee_concurrent_set_tower_compare (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp41_, _tmp41__target, _tmp42_, _tmp43_);
5403                                                         _tmp33_ = _tmp44_ < 0;
5404                                                 } else {
5405                                                         _tmp33_ = FALSE;
5406                                                 }
5407                                                 _tmp45_ = _tmp33_;
5408                                                 if (_tmp45_) {
5409                                                         GeeConcurrentSetTower* _tmp46_;
5410                                                         GeeConcurrentSetTower* _tmp47_;
5411                                                         _tmp46_ = last_best;
5412                                                         _tmp47_ = _gee_concurrent_set_tower_ref0 (_tmp46_);
5413                                                         _gee_concurrent_set_tower_unref0 (curr);
5414                                                         curr = _tmp47_;
5415                                                 }
5416                                                 _tmp48_ = curr;
5417                                                 _tmp49_ = curr_old;
5418                                                 if (_tmp48_ != _tmp49_) {
5419                                                         GeeConcurrentSetRange* _tmp50_;
5420                                                         gint _tmp51_;
5421                                                         GeeConcurrentSetTower* _tmp52_;
5422                                                         GeeConcurrentSetTower* _tmp53_;
5423                                                         GeeConcurrentSetTower* _tmp54_;
5424                                                         gboolean _tmp55_ = FALSE;
5425                                                         _tmp50_ = range;
5426                                                         _tmp51_ = i;
5427                                                         _tmp52_ = curr_old;
5428                                                         _tmp53_ = curr;
5429                                                         _tmp54_ = _gee_concurrent_set_tower_ref0 (_tmp53_);
5430                                                         _tmp55_ = gee_hazard_pointer_compare_and_exchange_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp50_->_bookmark._iter[_tmp51_], _tmp52_, _tmp54_, (gsize) 0, (gsize) 0, (gsize) 0);
5431                                                         if (!_tmp55_) {
5432                                                                 GeeConcurrentSetRange* _tmp56_;
5433                                                                 gint _tmp57_;
5434                                                                 gpointer _tmp58_ = NULL;
5435                                                                 _tmp56_ = range;
5436                                                                 _tmp57_ = i;
5437                                                                 _tmp58_ = gee_hazard_pointer_get_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp56_->_bookmark._iter[_tmp57_], (gsize) 0, NULL);
5438                                                                 _gee_concurrent_set_tower_unref0 (curr);
5439                                                                 curr = (GeeConcurrentSetTower*) _tmp58_;
5440                                                         }
5441                                                 }
5442                                                 _tmp59_ = curr;
5443                                                 _tmp60_ = i;
5444                                                 _tmp61_ = gee_concurrent_set_tower_get_next (_tmp59_, (guint8) _tmp60_);
5445                                                 next = _tmp61_;
5446                                                 if ((&_vala_out_curr) != NULL) {
5447                                                         gint _tmp63_;
5448                                                         _tmp63_ = i;
5449                                                         _tmp62_ = _tmp63_ == 0;
5450                                                 } else {
5451                                                         _tmp62_ = FALSE;
5452                                                 }
5453                                                 _tmp64_ = _tmp62_;
5454                                                 if (_tmp64_) {
5455                                                         GeeConcurrentSetTower* _tmp65_;
5456                                                         GeeConcurrentSetTower* _tmp66_;
5457                                                         _tmp65_ = next;
5458                                                         _tmp66_ = _gee_concurrent_set_tower_ref0 (_tmp65_);
5459                                                         _gee_concurrent_set_tower_unref0 (_vala_out_curr);
5460                                                         _vala_out_curr = _tmp66_;
5461                                                 }
5462                                                 while (TRUE) {
5463                                                         gboolean _tmp67_ = FALSE;
5464                                                         GeeConcurrentSetTower* _tmp68_;
5465                                                         gboolean _tmp76_;
5466                                                         GeeConcurrentSetRange* _tmp77_;
5467                                                         GeeConcurrentSet* _tmp78_;
5468                                                         GCompareDataFunc _tmp79_;
5469                                                         void* _tmp79__target;
5470                                                         gint _tmp80_;
5471                                                         gboolean _tmp81_ = FALSE;
5472                                                         gboolean _tmp82_ = FALSE;
5473                                                         gboolean _tmp84_;
5474                                                         gboolean _tmp86_;
5475                                                         GeeConcurrentSetRange* _tmp89_;
5476                                                         GeeConcurrentSet* _tmp90_;
5477                                                         GCompareDataFunc _tmp91_;
5478                                                         void* _tmp91__target;
5479                                                         GeeConcurrentSetTower* _tmp92_;
5480                                                         GeeConcurrentSetRange* _tmp93_;
5481                                                         gconstpointer _tmp94_;
5482                                                         gint _tmp95_ = 0;
5483                                                         _tmp68_ = next;
5484                                                         if (_tmp68_ != NULL) {
5485                                                                 GeeConcurrentSetRange* _tmp69_;
5486                                                                 GeeConcurrentSet* _tmp70_;
5487                                                                 GCompareDataFunc _tmp71_;
5488                                                                 void* _tmp71__target;
5489                                                                 GeeConcurrentSetTower* _tmp72_;
5490                                                                 GeeConcurrentSetRange* _tmp73_;
5491                                                                 gconstpointer _tmp74_;
5492                                                                 gint _tmp75_ = 0;
5493                                                                 _tmp69_ = range;
5494                                                                 _tmp70_ = _tmp69_->_set;
5495                                                                 _tmp71_ = _tmp70_->priv->_cmp;
5496                                                                 _tmp71__target = _tmp70_->priv->_cmp_target;
5497                                                                 _tmp72_ = next;
5498                                                                 _tmp73_ = range;
5499                                                                 _tmp74_ = _tmp73_->_start;
5500                                                                 _tmp75_ = gee_concurrent_set_tower_compare_data (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp71_, _tmp71__target, _tmp72_, _tmp74_);
5501                                                                 _tmp67_ = _tmp75_ < 0;
5502                                                         } else {
5503                                                                 _tmp67_ = FALSE;
5504                                                         }
5505                                                         _tmp76_ = _tmp67_;
5506                                                         if (!_tmp76_) {
5507                                                                 break;
5508                                                         }
5509                                                         _tmp77_ = range;
5510                                                         _tmp78_ = _tmp77_->_set;
5511                                                         _tmp79_ = _tmp78_->priv->_cmp;
5512                                                         _tmp79__target = _tmp78_->priv->_cmp_target;
5513                                                         _tmp80_ = i;
5514                                                         gee_concurrent_set_tower_proceed (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp79_, _tmp79__target, &curr, &next, (guint8) _tmp80_, TRUE);
5515                                                         if ((&curr) != NULL) {
5516                                                                 gint _tmp83_;
5517                                                                 _tmp83_ = i;
5518                                                                 _tmp82_ = _tmp83_ == 0;
5519                                                         } else {
5520                                                                 _tmp82_ = FALSE;
5521                                                         }
5522                                                         _tmp84_ = _tmp82_;
5523                                                         if (_tmp84_) {
5524                                                                 GeeConcurrentSetTower* _tmp85_;
5525                                                                 _tmp85_ = next;
5526                                                                 _tmp81_ = _tmp85_ != NULL;
5527                                                         } else {
5528                                                                 _tmp81_ = FALSE;
5529                                                         }
5530                                                         _tmp86_ = _tmp81_;
5531                                                         if (_tmp86_) {
5532                                                                 GeeConcurrentSetTower* _tmp87_;
5533                                                                 GeeConcurrentSetTower* _tmp88_;
5534                                                                 _tmp87_ = next;
5535                                                                 _tmp88_ = _gee_concurrent_set_tower_ref0 (_tmp87_);
5536                                                                 _gee_concurrent_set_tower_unref0 (_vala_out_curr);
5537                                                                 _vala_out_curr = _tmp88_;
5538                                                         }
5539                                                         _tmp89_ = range;
5540                                                         _tmp90_ = _tmp89_->_set;
5541                                                         _tmp91_ = _tmp90_->priv->_cmp;
5542                                                         _tmp91__target = _tmp90_->priv->_cmp_target;
5543                                                         _tmp92_ = curr;
5544                                                         _tmp93_ = range;
5545                                                         _tmp94_ = _tmp93_->_start;
5546                                                         _tmp95_ = gee_concurrent_set_tower_compare_data (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp91_, _tmp91__target, _tmp92_, _tmp94_);
5547                                                         if (_tmp95_ < 0) {
5548                                                                 GeeConcurrentSetRange* _tmp96_;
5549                                                                 gint _tmp97_;
5550                                                                 GeeConcurrentSetTower* _tmp98_;
5551                                                                 GeeConcurrentSetTower* _tmp99_;
5552                                                                 GeeConcurrentSetTower* _tmp100_;
5553                                                                 gboolean _tmp101_ = FALSE;
5554                                                                 GeeConcurrentSetTower* _tmp105_;
5555                                                                 GeeConcurrentSetTower* _tmp106_;
5556                                                                 _tmp96_ = range;
5557                                                                 _tmp97_ = i;
5558                                                                 _tmp98_ = curr_old;
5559                                                                 _tmp99_ = curr;
5560                                                                 _tmp100_ = _gee_concurrent_set_tower_ref0 (_tmp99_);
5561                                                                 _tmp101_ = gee_hazard_pointer_compare_and_exchange_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp96_->_bookmark._iter[_tmp97_], _tmp98_, _tmp100_, (gsize) 0, (gsize) 0, (gsize) 0);
5562                                                                 if (!_tmp101_) {
5563                                                                         GeeConcurrentSetRange* _tmp102_;
5564                                                                         gint _tmp103_;
5565                                                                         gpointer _tmp104_ = NULL;
5566                                                                         _tmp102_ = range;
5567                                                                         _tmp103_ = i;
5568                                                                         _tmp104_ = gee_hazard_pointer_get_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp102_->_bookmark._iter[_tmp103_], (gsize) 0, NULL);
5569                                                                         _gee_concurrent_set_tower_unref0 (curr);
5570                                                                         curr = (GeeConcurrentSetTower*) _tmp104_;
5571                                                                 }
5572                                                                 _tmp105_ = curr;
5573                                                                 _tmp106_ = _gee_concurrent_set_tower_ref0 (_tmp105_);
5574                                                                 _gee_concurrent_set_tower_unref0 (curr_old);
5575                                                                 curr_old = _tmp106_;
5576                                                         } else {
5577                                                                 break;
5578                                                         }
5579                                                 }
5580                                                 if ((&_vala_prev) != NULL) {
5581                                                         gint _tmp107_;
5582                                                         GeeConcurrentSetTower* _tmp108_;
5583                                                         GeeConcurrentSetTower* _tmp109_;
5584                                                         GeeConcurrentSetTower* _tmp110_;
5585                                                         _tmp107_ = i;
5586                                                         _tmp108_ = curr;
5587                                                         _tmp109_ = _gee_concurrent_set_tower_ref0 (_tmp108_);
5588                                                         _gee_concurrent_set_tower_unref0 (_vala_prev._iter[_tmp107_]);
5589                                                         _vala_prev._iter[_tmp107_] = _tmp109_;
5590                                                         _tmp110_ = _vala_prev._iter[_tmp107_];
5591                                                 }
5592                                                 _tmp111_ = curr;
5593                                                 curr = NULL;
5594                                                 _gee_concurrent_set_tower_unref0 (last_best);
5595                                                 last_best = _tmp111_;
5596                                                 _gee_concurrent_set_tower_unref0 (next);
5597                                                 _gee_concurrent_set_tower_unref0 (curr_old);
5598                                                 _gee_concurrent_set_tower_unref0 (curr);
5599                                         }
5600                                 }
5601                         }
5602                         _gee_concurrent_set_tower_unref0 (last_best);
5603                         break;
5604                 }
5605                 default:
5606                 {
5607                         g_assert_not_reached ();
5608                 }
5609         }
5610         if ((&_vala_out_curr) != NULL) {
5611                 GeeConcurrentSetTower* _tmp114_;
5612                 _tmp114_ = _vala_out_curr;
5613                 _tmp113_ = _tmp114_ != NULL;
5614         } else {
5615                 _tmp113_ = FALSE;
5616         }
5617         _tmp115_ = _tmp113_;
5618         if (_tmp115_) {
5619                 GeeConcurrentSetRange* _tmp116_;
5620                 GeeConcurrentSetTower* _tmp117_;
5621                 gboolean _tmp118_ = FALSE;
5622                 _tmp116_ = range;
5623                 _tmp117_ = _vala_out_curr;
5624                 _tmp118_ = gee_concurrent_set_range_beyond (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp116_, _tmp117_);
5625                 _tmp112_ = _tmp118_;
5626         } else {
5627                 _tmp112_ = FALSE;
5628         }
5629         _tmp119_ = _tmp112_;
5630         if (_tmp119_) {
5631                 _gee_concurrent_set_tower_unref0 (_vala_out_curr);
5632                 _vala_out_curr = NULL;
5633         }
5634         if (out_curr) {
5635                 *out_curr = _vala_out_curr;
5636         } else {
5637                 _gee_concurrent_set_tower_unref0 (_vala_out_curr);
5638         }
5639         if (prev) {
5640                 *prev = _vala_prev;
5641         } else {
5642                 gee_concurrent_set_tower_iter_destroy (&_vala_prev);
5643         }
5644 }
5645
5646
5647 static gboolean gee_concurrent_set_range_proceed (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, GeeConcurrentSetTower** prev, GeeConcurrentSetTower** curr, guint8 level) {
5648         gboolean result = FALSE;
5649         GeeConcurrentSetRange* _tmp0_;
5650         GeeConcurrentSetRangeType _tmp1_;
5651         g_return_val_if_fail (range != NULL, FALSE);
5652         g_return_val_if_fail (*curr != NULL, FALSE);
5653         _tmp0_ = range;
5654         _tmp1_ = _tmp0_->_type;
5655         switch (_tmp1_) {
5656                 case GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY:
5657                 {
5658                         result = FALSE;
5659                         return result;
5660                 }
5661                 case GEE_CONCURRENT_SET_RANGE_TYPE_TAIL:
5662                 {
5663                         GeeConcurrentSetRange* _tmp2_;
5664                         GeeConcurrentSet* _tmp3_;
5665                         GCompareDataFunc _tmp4_;
5666                         void* _tmp4__target;
5667                         guint8 _tmp5_;
5668                         gboolean _tmp6_ = FALSE;
5669                         _tmp2_ = range;
5670                         _tmp3_ = _tmp2_->_set;
5671                         _tmp4_ = _tmp3_->priv->_cmp;
5672                         _tmp4__target = _tmp3_->priv->_cmp_target;
5673                         _tmp5_ = level;
5674                         _tmp6_ = gee_concurrent_set_tower_proceed (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp4_, _tmp4__target, prev, curr, _tmp5_, FALSE);
5675                         result = _tmp6_;
5676                         return result;
5677                 }
5678                 case GEE_CONCURRENT_SET_RANGE_TYPE_HEAD:
5679                 case GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED:
5680                 {
5681                         GeeConcurrentSetTower* _tmp7_;
5682                         GeeConcurrentSetTower* _tmp8_;
5683                         GeeConcurrentSetTower* tmp_prev;
5684                         GeeConcurrentSetTower* _tmp9_;
5685                         GeeConcurrentSetTower* _tmp10_;
5686                         GeeConcurrentSetTower* tmp_curr;
5687                         GeeConcurrentSetRange* _tmp11_;
5688                         GeeConcurrentSet* _tmp12_;
5689                         GCompareDataFunc _tmp13_;
5690                         void* _tmp13__target;
5691                         guint8 _tmp14_;
5692                         gboolean _tmp15_ = FALSE;
5693                         _tmp7_ = *prev;
5694                         _tmp8_ = _gee_concurrent_set_tower_ref0 (_tmp7_);
5695                         tmp_prev = _tmp8_;
5696                         _tmp9_ = *curr;
5697                         _tmp10_ = _gee_concurrent_set_tower_ref0 (_tmp9_);
5698                         tmp_curr = _tmp10_;
5699                         _tmp11_ = range;
5700                         _tmp12_ = _tmp11_->_set;
5701                         _tmp13_ = _tmp12_->priv->_cmp;
5702                         _tmp13__target = _tmp12_->priv->_cmp_target;
5703                         _tmp14_ = level;
5704                         _tmp15_ = gee_concurrent_set_tower_proceed (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp13_, _tmp13__target, &tmp_prev, &tmp_curr, _tmp14_, FALSE);
5705                         if (!_tmp15_) {
5706                                 result = FALSE;
5707                                 _gee_concurrent_set_tower_unref0 (tmp_curr);
5708                                 _gee_concurrent_set_tower_unref0 (tmp_prev);
5709                                 return result;
5710                         } else {
5711                                 GeeConcurrentSetRange* _tmp16_;
5712                                 GeeConcurrentSet* _tmp17_;
5713                                 GCompareDataFunc _tmp18_;
5714                                 void* _tmp18__target;
5715                                 GeeConcurrentSetTower* _tmp19_;
5716                                 GeeConcurrentSetRange* _tmp20_;
5717                                 gconstpointer _tmp21_;
5718                                 gint _tmp22_ = 0;
5719                                 _tmp16_ = range;
5720                                 _tmp17_ = _tmp16_->_set;
5721                                 _tmp18_ = _tmp17_->priv->_cmp;
5722                                 _tmp18__target = _tmp17_->priv->_cmp_target;
5723                                 _tmp19_ = tmp_curr;
5724                                 _tmp20_ = range;
5725                                 _tmp21_ = _tmp20_->_end;
5726                                 _tmp22_ = gee_concurrent_set_tower_compare_data (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp18_, _tmp18__target, _tmp19_, _tmp21_);
5727                                 if (_tmp22_ >= 0) {
5728                                         result = FALSE;
5729                                         _gee_concurrent_set_tower_unref0 (tmp_curr);
5730                                         _gee_concurrent_set_tower_unref0 (tmp_prev);
5731                                         return result;
5732                                 } else {
5733                                         GeeConcurrentSetTower* _tmp23_;
5734                                         GeeConcurrentSetTower* _tmp24_;
5735                                         _tmp23_ = tmp_prev;
5736                                         tmp_prev = NULL;
5737                                         _gee_concurrent_set_tower_unref0 (*prev);
5738                                         *prev = _tmp23_;
5739                                         _tmp24_ = tmp_curr;
5740                                         tmp_curr = NULL;
5741                                         _gee_concurrent_set_tower_unref0 (*curr);
5742                                         *curr = _tmp24_;
5743                                         result = TRUE;
5744                                         _gee_concurrent_set_tower_unref0 (tmp_curr);
5745                                         _gee_concurrent_set_tower_unref0 (tmp_prev);
5746                                         return result;
5747                                 }
5748                         }
5749                         _gee_concurrent_set_tower_unref0 (tmp_curr);
5750                         _gee_concurrent_set_tower_unref0 (tmp_prev);
5751                 }
5752                 default:
5753                 {
5754                         g_assert_not_reached ();
5755                 }
5756         }
5757 }
5758
5759
5760 static gboolean gee_concurrent_set_range_inside (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, gconstpointer val) {
5761         gboolean result = FALSE;
5762         GeeConcurrentSetRange* _tmp0_;
5763         GeeConcurrentSetRangeType _tmp1_;
5764         g_return_val_if_fail (range != NULL, FALSE);
5765         _tmp0_ = range;
5766         _tmp1_ = _tmp0_->_type;
5767         switch (_tmp1_) {
5768                 case GEE_CONCURRENT_SET_RANGE_TYPE_HEAD:
5769                 {
5770                         GeeConcurrentSetRange* _tmp2_;
5771                         GeeConcurrentSet* _tmp3_;
5772                         GCompareDataFunc _tmp4_;
5773                         void* _tmp4__target;
5774                         gconstpointer _tmp5_;
5775                         GeeConcurrentSetRange* _tmp6_;
5776                         gconstpointer _tmp7_;
5777                         gint _tmp8_ = 0;
5778                         _tmp2_ = range;
5779                         _tmp3_ = _tmp2_->_set;
5780                         _tmp4_ = _tmp3_->priv->_cmp;
5781                         _tmp4__target = _tmp3_->priv->_cmp_target;
5782                         _tmp5_ = val;
5783                         _tmp6_ = range;
5784                         _tmp7_ = _tmp6_->_end;
5785                         _tmp8_ = _tmp4_ (_tmp5_, _tmp7_, _tmp4__target);
5786                         result = _tmp8_ < 0;
5787                         return result;
5788                 }
5789                 case GEE_CONCURRENT_SET_RANGE_TYPE_TAIL:
5790                 {
5791                         GeeConcurrentSetRange* _tmp9_;
5792                         GeeConcurrentSet* _tmp10_;
5793                         GCompareDataFunc _tmp11_;
5794                         void* _tmp11__target;
5795                         gconstpointer _tmp12_;
5796                         GeeConcurrentSetRange* _tmp13_;
5797                         gconstpointer _tmp14_;
5798                         gint _tmp15_ = 0;
5799                         _tmp9_ = range;
5800                         _tmp10_ = _tmp9_->_set;
5801                         _tmp11_ = _tmp10_->priv->_cmp;
5802                         _tmp11__target = _tmp10_->priv->_cmp_target;
5803                         _tmp12_ = val;
5804                         _tmp13_ = range;
5805                         _tmp14_ = _tmp13_->_start;
5806                         _tmp15_ = _tmp11_ (_tmp12_, _tmp14_, _tmp11__target);
5807                         result = _tmp15_ >= 0;
5808                         return result;
5809                 }
5810                 case GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED:
5811                 {
5812                         gboolean _tmp16_ = FALSE;
5813                         GeeConcurrentSetRange* _tmp17_;
5814                         GeeConcurrentSet* _tmp18_;
5815                         GCompareDataFunc _tmp19_;
5816                         void* _tmp19__target;
5817                         gconstpointer _tmp20_;
5818                         GeeConcurrentSetRange* _tmp21_;
5819                         gconstpointer _tmp22_;
5820                         gint _tmp23_ = 0;
5821                         gboolean _tmp31_;
5822                         _tmp17_ = range;
5823                         _tmp18_ = _tmp17_->_set;
5824                         _tmp19_ = _tmp18_->priv->_cmp;
5825                         _tmp19__target = _tmp18_->priv->_cmp_target;
5826                         _tmp20_ = val;
5827                         _tmp21_ = range;
5828                         _tmp22_ = _tmp21_->_start;
5829                         _tmp23_ = _tmp19_ (_tmp20_, _tmp22_, _tmp19__target);
5830                         if (_tmp23_ >= 0) {
5831                                 GeeConcurrentSetRange* _tmp24_;
5832                                 GeeConcurrentSet* _tmp25_;
5833                                 GCompareDataFunc _tmp26_;
5834                                 void* _tmp26__target;
5835                                 gconstpointer _tmp27_;
5836                                 GeeConcurrentSetRange* _tmp28_;
5837                                 gconstpointer _tmp29_;
5838                                 gint _tmp30_ = 0;
5839                                 _tmp24_ = range;
5840                                 _tmp25_ = _tmp24_->_set;
5841                                 _tmp26_ = _tmp25_->priv->_cmp;
5842                                 _tmp26__target = _tmp25_->priv->_cmp_target;
5843                                 _tmp27_ = val;
5844                                 _tmp28_ = range;
5845                                 _tmp29_ = _tmp28_->_end;
5846                                 _tmp30_ = _tmp26_ (_tmp27_, _tmp29_, _tmp26__target);
5847                                 _tmp16_ = _tmp30_ < 0;
5848                         } else {
5849                                 _tmp16_ = FALSE;
5850                         }
5851                         _tmp31_ = _tmp16_;
5852                         result = _tmp31_;
5853                         return result;
5854                 }
5855                 case GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY:
5856                 {
5857                         result = FALSE;
5858                         return result;
5859                 }
5860                 default:
5861                 {
5862                         g_assert_not_reached ();
5863                 }
5864         }
5865 }
5866
5867
5868 static gboolean gee_concurrent_set_range_beyond (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, GeeConcurrentSetTower* tw) {
5869         gboolean result = FALSE;
5870         GeeConcurrentSetRange* _tmp0_;
5871         GeeConcurrentSetRangeType _tmp1_;
5872         g_return_val_if_fail (range != NULL, FALSE);
5873         g_return_val_if_fail (tw != NULL, FALSE);
5874         _tmp0_ = range;
5875         _tmp1_ = _tmp0_->_type;
5876         switch (_tmp1_) {
5877                 case GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY:
5878                 {
5879                         result = TRUE;
5880                         return result;
5881                 }
5882                 case GEE_CONCURRENT_SET_RANGE_TYPE_TAIL:
5883                 {
5884                         result = FALSE;
5885                         return result;
5886                 }
5887                 case GEE_CONCURRENT_SET_RANGE_TYPE_HEAD:
5888                 case GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED:
5889                 {
5890                         GeeConcurrentSetRange* _tmp2_;
5891                         GeeConcurrentSet* _tmp3_;
5892                         GCompareDataFunc _tmp4_;
5893                         void* _tmp4__target;
5894                         GeeConcurrentSetTower* _tmp5_;
5895                         GeeConcurrentSetRange* _tmp6_;
5896                         gconstpointer _tmp7_;
5897                         gint _tmp8_ = 0;
5898                         _tmp2_ = range;
5899                         _tmp3_ = _tmp2_->_set;
5900                         _tmp4_ = _tmp3_->priv->_cmp;
5901                         _tmp4__target = _tmp3_->priv->_cmp_target;
5902                         _tmp5_ = tw;
5903                         _tmp6_ = range;
5904                         _tmp7_ = _tmp6_->_end;
5905                         _tmp8_ = gee_concurrent_set_tower_compare_data (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp4_, _tmp4__target, _tmp5_, _tmp7_);
5906                         result = _tmp8_ >= 0;
5907                         return result;
5908                 }
5909                 default:
5910                 {
5911                         g_assert_not_reached ();
5912                 }
5913         }
5914 }
5915
5916
5917 static gint gee_concurrent_set_range_cmp (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetRange* range, gconstpointer val) {
5918         gint result = 0;
5919         GeeConcurrentSetRange* _tmp0_;
5920         GeeConcurrentSetRangeType _tmp1_;
5921         g_return_val_if_fail (range != NULL, 0);
5922         _tmp0_ = range;
5923         _tmp1_ = _tmp0_->_type;
5924         switch (_tmp1_) {
5925                 case GEE_CONCURRENT_SET_RANGE_TYPE_HEAD:
5926                 {
5927                         GeeConcurrentSetRangePosition _tmp2_ = 0;
5928                         GeeConcurrentSetRange* _tmp3_;
5929                         GeeConcurrentSet* _tmp4_;
5930                         GCompareDataFunc _tmp5_;
5931                         void* _tmp5__target;
5932                         gconstpointer _tmp6_;
5933                         GeeConcurrentSetRange* _tmp7_;
5934                         gconstpointer _tmp8_;
5935                         gint _tmp9_ = 0;
5936                         GeeConcurrentSetRangePosition _tmp10_;
5937                         _tmp3_ = range;
5938                         _tmp4_ = _tmp3_->_set;
5939                         _tmp5_ = _tmp4_->priv->_cmp;
5940                         _tmp5__target = _tmp4_->priv->_cmp_target;
5941                         _tmp6_ = val;
5942                         _tmp7_ = range;
5943                         _tmp8_ = _tmp7_->_end;
5944                         _tmp9_ = _tmp5_ (_tmp6_, _tmp8_, _tmp5__target);
5945                         if (_tmp9_ < 0) {
5946                                 _tmp2_ = GEE_CONCURRENT_SET_RANGE_POSITION_INSIDE;
5947                         } else {
5948                                 _tmp2_ = GEE_CONCURRENT_SET_RANGE_POSITION_AFTER;
5949                         }
5950                         _tmp10_ = _tmp2_;
5951                         result = (gint) _tmp10_;
5952                         return result;
5953                 }
5954                 case GEE_CONCURRENT_SET_RANGE_TYPE_TAIL:
5955                 {
5956                         GeeConcurrentSetRangePosition _tmp11_ = 0;
5957                         GeeConcurrentSetRange* _tmp12_;
5958                         GeeConcurrentSet* _tmp13_;
5959                         GCompareDataFunc _tmp14_;
5960                         void* _tmp14__target;
5961                         gconstpointer _tmp15_;
5962                         GeeConcurrentSetRange* _tmp16_;
5963                         gconstpointer _tmp17_;
5964                         gint _tmp18_ = 0;
5965                         GeeConcurrentSetRangePosition _tmp19_;
5966                         _tmp12_ = range;
5967                         _tmp13_ = _tmp12_->_set;
5968                         _tmp14_ = _tmp13_->priv->_cmp;
5969                         _tmp14__target = _tmp13_->priv->_cmp_target;
5970                         _tmp15_ = val;
5971                         _tmp16_ = range;
5972                         _tmp17_ = _tmp16_->_start;
5973                         _tmp18_ = _tmp14_ (_tmp15_, _tmp17_, _tmp14__target);
5974                         if (_tmp18_ >= 0) {
5975                                 _tmp11_ = GEE_CONCURRENT_SET_RANGE_POSITION_INSIDE;
5976                         } else {
5977                                 _tmp11_ = GEE_CONCURRENT_SET_RANGE_POSITION_BEFORE;
5978                         }
5979                         _tmp19_ = _tmp11_;
5980                         result = (gint) _tmp19_;
5981                         return result;
5982                 }
5983                 case GEE_CONCURRENT_SET_RANGE_TYPE_BOUNDED:
5984                 {
5985                         GeeConcurrentSetRangePosition _tmp20_ = 0;
5986                         GeeConcurrentSetRange* _tmp21_;
5987                         GeeConcurrentSet* _tmp22_;
5988                         GCompareDataFunc _tmp23_;
5989                         void* _tmp23__target;
5990                         gconstpointer _tmp24_;
5991                         GeeConcurrentSetRange* _tmp25_;
5992                         gconstpointer _tmp26_;
5993                         gint _tmp27_ = 0;
5994                         GeeConcurrentSetRangePosition _tmp37_;
5995                         _tmp21_ = range;
5996                         _tmp22_ = _tmp21_->_set;
5997                         _tmp23_ = _tmp22_->priv->_cmp;
5998                         _tmp23__target = _tmp22_->priv->_cmp_target;
5999                         _tmp24_ = val;
6000                         _tmp25_ = range;
6001                         _tmp26_ = _tmp25_->_start;
6002                         _tmp27_ = _tmp23_ (_tmp24_, _tmp26_, _tmp23__target);
6003                         if (_tmp27_ >= 0) {
6004                                 GeeConcurrentSetRangePosition _tmp28_ = 0;
6005                                 GeeConcurrentSetRange* _tmp29_;
6006                                 GeeConcurrentSet* _tmp30_;
6007                                 GCompareDataFunc _tmp31_;
6008                                 void* _tmp31__target;
6009                                 gconstpointer _tmp32_;
6010                                 GeeConcurrentSetRange* _tmp33_;
6011                                 gconstpointer _tmp34_;
6012                                 gint _tmp35_ = 0;
6013                                 GeeConcurrentSetRangePosition _tmp36_;
6014                                 _tmp29_ = range;
6015                                 _tmp30_ = _tmp29_->_set;
6016                                 _tmp31_ = _tmp30_->priv->_cmp;
6017                                 _tmp31__target = _tmp30_->priv->_cmp_target;
6018                                 _tmp32_ = val;
6019                                 _tmp33_ = range;
6020                                 _tmp34_ = _tmp33_->_end;
6021                                 _tmp35_ = _tmp31_ (_tmp32_, _tmp34_, _tmp31__target);
6022                                 if (_tmp35_ < 0) {
6023                                         _tmp28_ = GEE_CONCURRENT_SET_RANGE_POSITION_INSIDE;
6024                                 } else {
6025                                         _tmp28_ = GEE_CONCURRENT_SET_RANGE_POSITION_AFTER;
6026                                 }
6027                                 _tmp36_ = _tmp28_;
6028                                 _tmp20_ = _tmp36_;
6029                         } else {
6030                                 _tmp20_ = GEE_CONCURRENT_SET_RANGE_POSITION_BEFORE;
6031                         }
6032                         _tmp37_ = _tmp20_;
6033                         result = (gint) _tmp37_;
6034                         return result;
6035                 }
6036                 case GEE_CONCURRENT_SET_RANGE_TYPE_EMPTY:
6037                 {
6038                         result = (gint) GEE_CONCURRENT_SET_RANGE_POSITION_EMPTY;
6039                         return result;
6040                 }
6041                 default:
6042                 {
6043                         g_assert_not_reached ();
6044                 }
6045         }
6046 }
6047
6048
6049 static void gee_concurrent_set_value_range_init (GValue* value) {
6050         value->data[0].v_pointer = NULL;
6051 }
6052
6053
6054 static void gee_concurrent_set_value_range_free_value (GValue* value) {
6055         if (value->data[0].v_pointer) {
6056                 gee_concurrent_set_range_unref (value->data[0].v_pointer);
6057         }
6058 }
6059
6060
6061 static void gee_concurrent_set_value_range_copy_value (const GValue* src_value, GValue* dest_value) {
6062         if (src_value->data[0].v_pointer) {
6063                 dest_value->data[0].v_pointer = gee_concurrent_set_range_ref (src_value->data[0].v_pointer);
6064         } else {
6065                 dest_value->data[0].v_pointer = NULL;
6066         }
6067 }
6068
6069
6070 static gpointer gee_concurrent_set_value_range_peek_pointer (const GValue* value) {
6071         return value->data[0].v_pointer;
6072 }
6073
6074
6075 static gchar* gee_concurrent_set_value_range_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
6076         if (collect_values[0].v_pointer) {
6077                 GeeConcurrentSetRange* object;
6078                 object = collect_values[0].v_pointer;
6079                 if (object->parent_instance.g_class == NULL) {
6080                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
6081                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
6082                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
6083                 }
6084                 value->data[0].v_pointer = gee_concurrent_set_range_ref (object);
6085         } else {
6086                 value->data[0].v_pointer = NULL;
6087         }
6088         return NULL;
6089 }
6090
6091
6092 static gchar* gee_concurrent_set_value_range_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
6093         GeeConcurrentSetRange** object_p;
6094         object_p = collect_values[0].v_pointer;
6095         if (!object_p) {
6096                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
6097         }
6098         if (!value->data[0].v_pointer) {
6099                 *object_p = NULL;
6100         } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
6101                 *object_p = value->data[0].v_pointer;
6102         } else {
6103                 *object_p = gee_concurrent_set_range_ref (value->data[0].v_pointer);
6104         }
6105         return NULL;
6106 }
6107
6108
6109 static GParamSpec* gee_concurrent_set_param_spec_range (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
6110         GeeConcurrentSetParamSpecRange* spec;
6111         g_return_val_if_fail (g_type_is_a (object_type, GEE_CONCURRENT_SET_TYPE_RANGE), NULL);
6112         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
6113         G_PARAM_SPEC (spec)->value_type = object_type;
6114         return G_PARAM_SPEC (spec);
6115 }
6116
6117
6118 static gpointer gee_concurrent_set_value_get_range (const GValue* value) {
6119         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_CONCURRENT_SET_TYPE_RANGE), NULL);
6120         return value->data[0].v_pointer;
6121 }
6122
6123
6124 static void gee_concurrent_set_value_set_range (GValue* value, gpointer v_object) {
6125         GeeConcurrentSetRange* old;
6126         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_CONCURRENT_SET_TYPE_RANGE));
6127         old = value->data[0].v_pointer;
6128         if (v_object) {
6129                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, GEE_CONCURRENT_SET_TYPE_RANGE));
6130                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
6131                 value->data[0].v_pointer = v_object;
6132                 gee_concurrent_set_range_ref (value->data[0].v_pointer);
6133         } else {
6134                 value->data[0].v_pointer = NULL;
6135         }
6136         if (old) {
6137                 gee_concurrent_set_range_unref (old);
6138         }
6139 }
6140
6141
6142 static void gee_concurrent_set_value_take_range (GValue* value, gpointer v_object) {
6143         GeeConcurrentSetRange* old;
6144         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_CONCURRENT_SET_TYPE_RANGE));
6145         old = value->data[0].v_pointer;
6146         if (v_object) {
6147                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, GEE_CONCURRENT_SET_TYPE_RANGE));
6148                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
6149                 value->data[0].v_pointer = v_object;
6150         } else {
6151                 value->data[0].v_pointer = NULL;
6152         }
6153         if (old) {
6154                 gee_concurrent_set_range_unref (old);
6155         }
6156 }
6157
6158
6159 static void gee_concurrent_set_range_class_init (GeeConcurrentSetRangeClass * klass) {
6160         gee_concurrent_set_range_parent_class = g_type_class_peek_parent (klass);
6161         GEE_CONCURRENT_SET_RANGE_CLASS (klass)->finalize = gee_concurrent_set_range_finalize;
6162         g_type_class_add_private (klass, sizeof (GeeConcurrentSetRangePrivate));
6163 }
6164
6165
6166 static void gee_concurrent_set_range_instance_init (GeeConcurrentSetRange * self) {
6167         self->priv = GEE_CONCURRENT_SET_RANGE_GET_PRIVATE (self);
6168         self->ref_count = 1;
6169 }
6170
6171
6172 static void gee_concurrent_set_range_finalize (GeeConcurrentSetRange* obj) {
6173         GeeConcurrentSetRange * self;
6174         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_CONCURRENT_SET_TYPE_RANGE, GeeConcurrentSetRange);
6175         ((self->_start == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (self->_start = (self->priv->g_destroy_func (self->_start), NULL));
6176         ((self->_end == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (self->_end = (self->priv->g_destroy_func (self->_end), NULL));
6177         gee_concurrent_set_tower_iter_destroy (&self->_bookmark);
6178         _g_object_unref0 (self->_set);
6179 }
6180
6181
6182 static GType gee_concurrent_set_range_get_type (void) {
6183         static volatile gsize gee_concurrent_set_range_type_id__volatile = 0;
6184         if (g_once_init_enter (&gee_concurrent_set_range_type_id__volatile)) {
6185                 static const GTypeValueTable g_define_type_value_table = { gee_concurrent_set_value_range_init, gee_concurrent_set_value_range_free_value, gee_concurrent_set_value_range_copy_value, gee_concurrent_set_value_range_peek_pointer, "p", gee_concurrent_set_value_range_collect_value, "p", gee_concurrent_set_value_range_lcopy_value };
6186                 static const GTypeInfo g_define_type_info = { sizeof (GeeConcurrentSetRangeClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_concurrent_set_range_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeConcurrentSetRange), 0, (GInstanceInitFunc) gee_concurrent_set_range_instance_init, &g_define_type_value_table };
6187                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
6188                 GType gee_concurrent_set_range_type_id;
6189                 gee_concurrent_set_range_type_id = g_type_register_fundamental (g_type_fundamental_next (), "GeeConcurrentSetRange", &g_define_type_info, &g_define_type_fundamental_info, 0);
6190                 g_once_init_leave (&gee_concurrent_set_range_type_id__volatile, gee_concurrent_set_range_type_id);
6191         }
6192         return gee_concurrent_set_range_type_id__volatile;
6193 }
6194
6195
6196 static gpointer gee_concurrent_set_range_ref (gpointer instance) {
6197         GeeConcurrentSetRange* self;
6198         self = instance;
6199         g_atomic_int_inc (&self->ref_count);
6200         return instance;
6201 }
6202
6203
6204 static void gee_concurrent_set_range_unref (gpointer instance) {
6205         GeeConcurrentSetRange* self;
6206         self = instance;
6207         if (g_atomic_int_dec_and_test (&self->ref_count)) {
6208                 GEE_CONCURRENT_SET_RANGE_GET_CLASS (self)->finalize (self);
6209                 g_type_free_instance ((GTypeInstance *) self);
6210         }
6211 }
6212
6213
6214 static GeeConcurrentSetTower* gee_concurrent_set_tower_construct (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, guint8 height) {
6215         GeeConcurrentSetTower* self = NULL;
6216         guint8 _tmp0_;
6217         GeeConcurrentSetTowerNode* _tmp1_ = NULL;
6218         gconstpointer _tmp2_;
6219         gpointer _tmp3_;
6220         GeeConcurrentSetTowerNode* _tmp4_;
6221         gint _tmp4__length1;
6222         self = (GeeConcurrentSetTower*) g_type_create_instance (object_type);
6223         self->priv->g_type = g_type;
6224         self->priv->g_dup_func = g_dup_func;
6225         self->priv->g_destroy_func = g_destroy_func;
6226         _tmp0_ = height;
6227         _tmp1_ = g_new0 (GeeConcurrentSetTowerNode, _tmp0_);
6228         self->_nodes = (g_free (self->_nodes), NULL);
6229         self->_nodes = _tmp1_;
6230         _tmp2_ = data;
6231         _tmp3_ = ((_tmp2_ != NULL) && (g_dup_func != NULL)) ? g_dup_func ((gpointer) _tmp2_) : ((gpointer) _tmp2_);
6232         _g_destroy_func0 (self->_data);
6233         self->_data = _tmp3_;
6234         self->_height = 0;
6235         _tmp4_ = self->_nodes;
6236         _tmp4__length1 = -1;
6237         g_atomic_pointer_set ((volatile gpointer *) (&_tmp4_[0]._backlink), NULL);
6238         return self;
6239 }
6240
6241
6242 static GeeConcurrentSetTower* gee_concurrent_set_tower_new (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, gconstpointer data, guint8 height) {
6243         return gee_concurrent_set_tower_construct (GEE_CONCURRENT_SET_TYPE_TOWER, g_type, g_dup_func, g_destroy_func, data, height);
6244 }
6245
6246
6247 static GeeConcurrentSetTower* gee_concurrent_set_tower_construct_head (GType object_type, GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func) {
6248         GeeConcurrentSetTower* self = NULL;
6249         GeeConcurrentSetTowerNode* _tmp0_ = NULL;
6250         self = (GeeConcurrentSetTower*) g_type_create_instance (object_type);
6251         self->priv->g_type = g_type;
6252         self->priv->g_dup_func = g_dup_func;
6253         self->priv->g_destroy_func = g_destroy_func;
6254         _tmp0_ = g_new0 (GeeConcurrentSetTowerNode, GEE_CONCURRENT_SET__MAX_HEIGHT);
6255         self->_nodes = (g_free (self->_nodes), NULL);
6256         self->_nodes = _tmp0_;
6257         self->_height = -1;
6258         return self;
6259 }
6260
6261
6262 static GeeConcurrentSetTower* gee_concurrent_set_tower_new_head (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func) {
6263         return gee_concurrent_set_tower_construct_head (GEE_CONCURRENT_SET_TYPE_TOWER, g_type, g_dup_func, g_destroy_func);
6264 }
6265
6266
6267 static inline gboolean gee_concurrent_set_tower_search (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, gconstpointer key, GeeConcurrentSetTower** prev, GeeConcurrentSetTower** next, guint8 to_level, guint8 from_level) {
6268         GeeConcurrentSetTower* _vala_next = NULL;
6269         gboolean result = FALSE;
6270         guint8 _tmp0_;
6271         guint8 _tmp1_;
6272         gboolean res;
6273         g_return_val_if_fail (*prev != NULL, FALSE);
6274         _tmp0_ = from_level;
6275         _tmp1_ = to_level;
6276         _vala_assert (_tmp0_ >= _tmp1_, "from_level >= to_level");
6277         res = FALSE;
6278         _gee_concurrent_set_tower_unref0 (_vala_next);
6279         _vala_next = NULL;
6280         {
6281                 guint8 _tmp2_;
6282                 gint i;
6283                 _tmp2_ = from_level;
6284                 i = (gint) _tmp2_;
6285                 {
6286                         gboolean _tmp3_;
6287                         _tmp3_ = TRUE;
6288                         while (TRUE) {
6289                                 gboolean _tmp4_;
6290                                 gint _tmp6_;
6291                                 guint8 _tmp7_;
6292                                 GCompareDataFunc _tmp8_;
6293                                 void* _tmp8__target;
6294                                 gconstpointer _tmp9_;
6295                                 gint _tmp10_;
6296                                 GeeConcurrentSetTower* _tmp11_ = NULL;
6297                                 gboolean _tmp12_ = FALSE;
6298                                 _tmp4_ = _tmp3_;
6299                                 if (!_tmp4_) {
6300                                         gint _tmp5_;
6301                                         _tmp5_ = i;
6302                                         i = _tmp5_ - 1;
6303                                 }
6304                                 _tmp3_ = FALSE;
6305                                 _tmp6_ = i;
6306                                 _tmp7_ = to_level;
6307                                 if (!(_tmp6_ >= ((gint) _tmp7_))) {
6308                                         break;
6309                                 }
6310                                 _tmp8_ = cmp;
6311                                 _tmp8__target = cmp_target;
6312                                 _tmp9_ = key;
6313                                 _tmp10_ = i;
6314                                 _tmp12_ = gee_concurrent_set_tower_search_helper (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp8_, _tmp8__target, _tmp9_, prev, &_tmp11_, (guint8) _tmp10_);
6315                                 _gee_concurrent_set_tower_unref0 (_vala_next);
6316                                 _vala_next = _tmp11_;
6317                                 res = _tmp12_;
6318                         }
6319                 }
6320         }
6321         result = res;
6322         if (next) {
6323                 *next = _vala_next;
6324         } else {
6325                 _gee_concurrent_set_tower_unref0 (_vala_next);
6326         }
6327         return result;
6328 }
6329
6330
6331 static inline gboolean gee_concurrent_set_tower_search_from_bookmark (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, gconstpointer key, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTowerIter* next, guint8 to_level, guint8 from_level) {
6332         GeeConcurrentSetTowerIter _vala_next = {0};
6333         gboolean result = FALSE;
6334         guint8 _tmp0_;
6335         guint8 _tmp1_;
6336         gboolean res;
6337         g_return_val_if_fail (prev != NULL, FALSE);
6338         _tmp0_ = from_level;
6339         _tmp1_ = to_level;
6340         _vala_assert (_tmp0_ >= _tmp1_, "from_level >= to_level");
6341         res = FALSE;
6342         {
6343                 guint8 _tmp2_;
6344                 gint i;
6345                 _tmp2_ = from_level;
6346                 i = (gint) _tmp2_;
6347                 {
6348                         gboolean _tmp3_;
6349                         _tmp3_ = TRUE;
6350                         while (TRUE) {
6351                                 gboolean _tmp4_;
6352                                 gint _tmp6_;
6353                                 guint8 _tmp7_;
6354                                 GeeConcurrentSetTowerIter _tmp8_;
6355                                 gint _tmp9_;
6356                                 GeeConcurrentSetTower* _tmp10_;
6357                                 GeeConcurrentSetTower* tmp_prev;
6358                                 GeeConcurrentSetTower* tmp_next = NULL;
6359                                 GCompareDataFunc _tmp11_;
6360                                 void* _tmp11__target;
6361                                 gconstpointer _tmp12_;
6362                                 gint _tmp13_;
6363                                 gint _tmp14_;
6364                                 GeeConcurrentSetTower* _tmp15_ = NULL;
6365                                 gboolean _tmp16_ = FALSE;
6366                                 GeeConcurrentSetTowerIter _tmp20_;
6367                                 gint _tmp21_;
6368                                 GeeConcurrentSetTower* _tmp22_;
6369                                 GeeConcurrentSetTower* _tmp23_;
6370                                 _tmp4_ = _tmp3_;
6371                                 if (!_tmp4_) {
6372                                         gint _tmp5_;
6373                                         _tmp5_ = i;
6374                                         i = _tmp5_ - 1;
6375                                 }
6376                                 _tmp3_ = FALSE;
6377                                 _tmp6_ = i;
6378                                 _tmp7_ = to_level;
6379                                 if (!(_tmp6_ >= ((gint) _tmp7_))) {
6380                                         break;
6381                                 }
6382                                 _tmp8_ = *prev;
6383                                 _tmp9_ = i;
6384                                 _tmp10_ = _tmp8_._iter[_tmp9_];
6385                                 tmp_prev = _tmp10_;
6386                                 _tmp11_ = cmp;
6387                                 _tmp11__target = cmp_target;
6388                                 _tmp12_ = key;
6389                                 _tmp13_ = i;
6390                                 _tmp14_ = i;
6391                                 _tmp16_ = gee_concurrent_set_tower_search_helper (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp11_, _tmp11__target, _tmp12_, &(*prev)._iter[_tmp13_], &_tmp15_, (guint8) _tmp14_);
6392                                 _gee_concurrent_set_tower_unref0 (tmp_next);
6393                                 tmp_next = _tmp15_;
6394                                 res = _tmp16_;
6395                                 if ((&_vala_next) != NULL) {
6396                                         gint _tmp17_;
6397                                         GeeConcurrentSetTower* _tmp18_;
6398                                         GeeConcurrentSetTower* _tmp19_;
6399                                         _tmp17_ = i;
6400                                         _tmp18_ = tmp_next;
6401                                         tmp_next = NULL;
6402                                         _gee_concurrent_set_tower_unref0 (_vala_next._iter[_tmp17_]);
6403                                         _vala_next._iter[_tmp17_] = _tmp18_;
6404                                         _tmp19_ = _vala_next._iter[_tmp17_];
6405                                 }
6406                                 _tmp20_ = *prev;
6407                                 _tmp21_ = i;
6408                                 _tmp22_ = _tmp20_._iter[_tmp21_];
6409                                 _tmp23_ = tmp_prev;
6410                                 if (_tmp22_ != _tmp23_) {
6411                                         gint _tmp24_;
6412                                         GeeConcurrentSetTowerIter _tmp25_;
6413                                         gint _tmp26_;
6414                                         GeeConcurrentSetTower* _tmp27_;
6415                                         GeeConcurrentSetTower* _tmp28_;
6416                                         GeeConcurrentSetTower* _tmp29_;
6417                                         gboolean _tmp30_ = FALSE;
6418                                         gint _tmp31_;
6419                                         guint8 _tmp32_;
6420                                         gboolean _tmp41_;
6421                                         _tmp24_ = i;
6422                                         _tmp25_ = *prev;
6423                                         _tmp26_ = i;
6424                                         _tmp27_ = _tmp25_._iter[_tmp26_];
6425                                         _tmp28_ = _gee_concurrent_set_tower_ref0 (_tmp27_);
6426                                         _gee_concurrent_set_tower_unref0 ((*prev)._iter[_tmp24_]);
6427                                         (*prev)._iter[_tmp24_] = _tmp28_;
6428                                         _tmp29_ = (*prev)._iter[_tmp24_];
6429                                         _tmp31_ = i;
6430                                         _tmp32_ = to_level;
6431                                         if (_tmp31_ > ((gint) _tmp32_)) {
6432                                                 GCompareDataFunc _tmp33_;
6433                                                 void* _tmp33__target;
6434                                                 GeeConcurrentSetTowerIter _tmp34_;
6435                                                 gint _tmp35_;
6436                                                 GeeConcurrentSetTower* _tmp36_;
6437                                                 GeeConcurrentSetTowerIter _tmp37_;
6438                                                 gint _tmp38_;
6439                                                 GeeConcurrentSetTower* _tmp39_;
6440                                                 gint _tmp40_ = 0;
6441                                                 _tmp33_ = cmp;
6442                                                 _tmp33__target = cmp_target;
6443                                                 _tmp34_ = *prev;
6444                                                 _tmp35_ = i;
6445                                                 _tmp36_ = _tmp34_._iter[_tmp35_ - 1];
6446                                                 _tmp37_ = *prev;
6447                                                 _tmp38_ = i;
6448                                                 _tmp39_ = _tmp37_._iter[_tmp38_];
6449                                                 _tmp40_ = gee_concurrent_set_tower_compare (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp33_, _tmp33__target, _tmp36_, _tmp39_);
6450                                                 _tmp30_ = _tmp40_ <= 0;
6451                                         } else {
6452                                                 _tmp30_ = FALSE;
6453                                         }
6454                                         _tmp41_ = _tmp30_;
6455                                         if (_tmp41_) {
6456                                                 gint _tmp42_;
6457                                                 GeeConcurrentSetTowerIter _tmp43_;
6458                                                 gint _tmp44_;
6459                                                 GeeConcurrentSetTower* _tmp45_;
6460                                                 GeeConcurrentSetTower* _tmp46_;
6461                                                 GeeConcurrentSetTower* _tmp47_;
6462                                                 _tmp42_ = i;
6463                                                 _tmp43_ = *prev;
6464                                                 _tmp44_ = i;
6465                                                 _tmp45_ = _tmp43_._iter[_tmp44_];
6466                                                 _tmp46_ = _gee_concurrent_set_tower_ref0 (_tmp45_);
6467                                                 _gee_concurrent_set_tower_unref0 ((*prev)._iter[_tmp42_ - 1]);
6468                                                 (*prev)._iter[_tmp42_ - 1] = _tmp46_;
6469                                                 _tmp47_ = (*prev)._iter[_tmp42_ - 1];
6470                                         }
6471                                 }
6472                                 _gee_concurrent_set_tower_unref0 (tmp_next);
6473                         }
6474                 }
6475         }
6476         result = res;
6477         if (next) {
6478                 *next = _vala_next;
6479         } else {
6480                 gee_concurrent_set_tower_iter_destroy (&_vala_next);
6481         }
6482         return result;
6483 }
6484
6485
6486 static inline gboolean gee_concurrent_set_tower_search_helper (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, gconstpointer key, GeeConcurrentSetTower** prev, GeeConcurrentSetTower** next, guint8 level) {
6487         GeeConcurrentSetTower* _vala_next = NULL;
6488         gboolean result = FALSE;
6489         GeeConcurrentSetTower* _tmp0_;
6490         guint8 _tmp1_;
6491         GeeConcurrentSetTower* _tmp2_ = NULL;
6492         gboolean _tmp15_ = FALSE;
6493         GeeConcurrentSetTower* _tmp16_;
6494         gboolean _tmp22_;
6495         _tmp0_ = *prev;
6496         _tmp1_ = level;
6497         _tmp2_ = gee_concurrent_set_tower_get_next (_tmp0_, _tmp1_);
6498         _gee_concurrent_set_tower_unref0 (_vala_next);
6499         _vala_next = _tmp2_;
6500         while (TRUE) {
6501                 gboolean _tmp3_ = FALSE;
6502                 gboolean _tmp4_ = FALSE;
6503                 GeeConcurrentSetTower* _tmp5_;
6504                 gboolean _tmp10_;
6505                 gboolean _tmp14_;
6506                 _tmp5_ = _vala_next;
6507                 if (_tmp5_ != NULL) {
6508                         GCompareDataFunc _tmp6_;
6509                         void* _tmp6__target;
6510                         GeeConcurrentSetTower* _tmp7_;
6511                         gconstpointer _tmp8_;
6512                         gint _tmp9_ = 0;
6513                         _tmp6_ = cmp;
6514                         _tmp6__target = cmp_target;
6515                         _tmp7_ = _vala_next;
6516                         _tmp8_ = key;
6517                         _tmp9_ = gee_concurrent_set_tower_compare_data (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp6_, _tmp6__target, _tmp7_, _tmp8_);
6518                         _tmp4_ = _tmp9_ < 0;
6519                 } else {
6520                         _tmp4_ = FALSE;
6521                 }
6522                 _tmp10_ = _tmp4_;
6523                 if (_tmp10_) {
6524                         GCompareDataFunc _tmp11_;
6525                         void* _tmp11__target;
6526                         guint8 _tmp12_;
6527                         gboolean _tmp13_ = FALSE;
6528                         _tmp11_ = cmp;
6529                         _tmp11__target = cmp_target;
6530                         _tmp12_ = level;
6531                         _tmp13_ = gee_concurrent_set_tower_proceed (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp11_, _tmp11__target, prev, &_vala_next, _tmp12_, TRUE);
6532                         _tmp3_ = _tmp13_;
6533                 } else {
6534                         _tmp3_ = FALSE;
6535                 }
6536                 _tmp14_ = _tmp3_;
6537                 if (!_tmp14_) {
6538                         break;
6539                 }
6540         }
6541         _tmp16_ = _vala_next;
6542         if (_tmp16_ != NULL) {
6543                 GCompareDataFunc _tmp17_;
6544                 void* _tmp17__target;
6545                 gconstpointer _tmp18_;
6546                 GeeConcurrentSetTower* _tmp19_;
6547                 gconstpointer _tmp20_;
6548                 gint _tmp21_ = 0;
6549                 _tmp17_ = cmp;
6550                 _tmp17__target = cmp_target;
6551                 _tmp18_ = key;
6552                 _tmp19_ = _vala_next;
6553                 _tmp20_ = _tmp19_->_data;
6554                 _tmp21_ = _tmp17_ (_tmp18_, _tmp20_, _tmp17__target);
6555                 _tmp15_ = _tmp21_ == 0;
6556         } else {
6557                 _tmp15_ = FALSE;
6558         }
6559         _tmp22_ = _tmp15_;
6560         result = _tmp22_;
6561         if (next) {
6562                 *next = _vala_next;
6563         } else {
6564                 _gee_concurrent_set_tower_unref0 (_vala_next);
6565         }
6566         return result;
6567 }
6568
6569
6570 static inline GeeConcurrentSetTower* gee_concurrent_set_tower_insert (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTowerIter* prev, gconstpointer key, guint8 chosen_level) {
6571         GeeConcurrentSetTower* result = NULL;
6572         GCompareDataFunc _tmp0_;
6573         void* _tmp0__target;
6574         gconstpointer _tmp1_;
6575         guint8 _tmp2_;
6576         guint8 _tmp3_;
6577         GeeConcurrentSetTower* _tmp4_ = NULL;
6578         g_return_val_if_fail (prev != NULL, NULL);
6579         _tmp0_ = cmp;
6580         _tmp0__target = cmp_target;
6581         _tmp1_ = key;
6582         _tmp2_ = chosen_level;
6583         _tmp3_ = chosen_level;
6584         _tmp4_ = gee_concurrent_set_tower_insert_helper (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp0_, _tmp0__target, prev, _tmp1_, _tmp2_, _tmp3_);
6585         result = _tmp4_;
6586         return result;
6587 }
6588
6589
6590 static inline GeeConcurrentSetTower* gee_concurrent_set_tower_insert_helper (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTowerIter* prev, gconstpointer key, guint8 chosen_level, guint8 level) {
6591         GeeConcurrentSetTower* result = NULL;
6592         GeeConcurrentSetTower* new_tower = NULL;
6593         GeeConcurrentSetTower* next = NULL;
6594         GCompareDataFunc _tmp0_;
6595         void* _tmp0__target;
6596         gconstpointer _tmp1_;
6597         guint8 _tmp2_;
6598         guint8 _tmp3_;
6599         GeeConcurrentSetTower* _tmp4_ = NULL;
6600         gboolean _tmp5_ = FALSE;
6601         guint8 _tmp6_;
6602         GeeConcurrentSetTower* _tmp29_;
6603         GeeConcurrentSetTower* _tmp72_;
6604         GeeConcurrentSetTower* _tmp73_;
6605         GeeConcurrentSetState _tmp74_ = 0;
6606         g_return_val_if_fail (prev != NULL, NULL);
6607         _tmp0_ = cmp;
6608         _tmp0__target = cmp_target;
6609         _tmp1_ = key;
6610         _tmp2_ = level;
6611         _tmp3_ = level;
6612         _tmp5_ = gee_concurrent_set_tower_search_helper (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp0_, _tmp0__target, _tmp1_, &(*prev)._iter[_tmp2_], &_tmp4_, _tmp3_);
6613         _gee_concurrent_set_tower_unref0 (next);
6614         next = _tmp4_;
6615         if (_tmp5_) {
6616                 result = NULL;
6617                 _gee_concurrent_set_tower_unref0 (next);
6618                 _gee_concurrent_set_tower_unref0 (new_tower);
6619                 return result;
6620         }
6621         _tmp6_ = level;
6622         if (((gint) _tmp6_) > 0) {
6623                 GCompareDataFunc _tmp7_;
6624                 void* _tmp7__target;
6625                 GeeConcurrentSetTowerIter _tmp8_;
6626                 guint8 _tmp9_;
6627                 GeeConcurrentSetTower* _tmp10_;
6628                 GeeConcurrentSetTowerIter _tmp11_;
6629                 guint8 _tmp12_;
6630                 GeeConcurrentSetTower* _tmp13_;
6631                 gint _tmp14_ = 0;
6632                 GCompareDataFunc _tmp21_;
6633                 void* _tmp21__target;
6634                 gconstpointer _tmp22_;
6635                 guint8 _tmp23_;
6636                 guint8 _tmp24_;
6637                 GeeConcurrentSetTower* _tmp25_ = NULL;
6638                 _tmp7_ = cmp;
6639                 _tmp7__target = cmp_target;
6640                 _tmp8_ = *prev;
6641                 _tmp9_ = level;
6642                 _tmp10_ = _tmp8_._iter[_tmp9_];
6643                 _tmp11_ = *prev;
6644                 _tmp12_ = level;
6645                 _tmp13_ = _tmp11_._iter[_tmp12_ - 1];
6646                 _tmp14_ = gee_concurrent_set_tower_compare (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp7_, _tmp7__target, _tmp10_, _tmp13_);
6647                 if (_tmp14_ >= 0) {
6648                         guint8 _tmp15_;
6649                         GeeConcurrentSetTowerIter _tmp16_;
6650                         guint8 _tmp17_;
6651                         GeeConcurrentSetTower* _tmp18_;
6652                         GeeConcurrentSetTower* _tmp19_;
6653                         GeeConcurrentSetTower* _tmp20_;
6654                         _tmp15_ = level;
6655                         _tmp16_ = *prev;
6656                         _tmp17_ = level;
6657                         _tmp18_ = _tmp16_._iter[_tmp17_];
6658                         _tmp19_ = _gee_concurrent_set_tower_ref0 (_tmp18_);
6659                         _gee_concurrent_set_tower_unref0 ((*prev)._iter[_tmp15_ - 1]);
6660                         (*prev)._iter[_tmp15_ - 1] = _tmp19_;
6661                         _tmp20_ = (*prev)._iter[_tmp15_ - 1];
6662                 }
6663                 _tmp21_ = cmp;
6664                 _tmp21__target = cmp_target;
6665                 _tmp22_ = key;
6666                 _tmp23_ = chosen_level;
6667                 _tmp24_ = level;
6668                 _tmp25_ = gee_concurrent_set_tower_insert_helper (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp21_, _tmp21__target, prev, _tmp22_, _tmp23_, (guint8) (_tmp24_ - 1));
6669                 _gee_concurrent_set_tower_unref0 (new_tower);
6670                 new_tower = _tmp25_;
6671         } else {
6672                 gconstpointer _tmp26_;
6673                 guint8 _tmp27_;
6674                 GeeConcurrentSetTower* _tmp28_;
6675                 _tmp26_ = key;
6676                 _tmp27_ = chosen_level;
6677                 _tmp28_ = gee_concurrent_set_tower_new (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp26_, (guint8) (_tmp27_ + 1));
6678                 _gee_concurrent_set_tower_unref0 (new_tower);
6679                 new_tower = _tmp28_;
6680         }
6681         _tmp29_ = new_tower;
6682         if (_tmp29_ == NULL) {
6683                 result = NULL;
6684                 _gee_concurrent_set_tower_unref0 (next);
6685                 _gee_concurrent_set_tower_unref0 (new_tower);
6686                 return result;
6687         }
6688         while (TRUE) {
6689                 GeeConcurrentSetState prev_state = 0;
6690                 GeeConcurrentSetTowerIter _tmp30_;
6691                 guint8 _tmp31_;
6692                 GeeConcurrentSetTower* _tmp32_;
6693                 guint8 _tmp33_;
6694                 GeeConcurrentSetState _tmp34_ = 0;
6695                 GeeConcurrentSetTower* _tmp35_ = NULL;
6696                 GeeConcurrentSetTower* prev_next;
6697                 GeeConcurrentSetState _tmp36_;
6698                 GCompareDataFunc _tmp67_;
6699                 void* _tmp67__target;
6700                 gconstpointer _tmp68_;
6701                 guint8 _tmp69_;
6702                 guint8 _tmp70_;
6703                 gboolean _tmp71_ = FALSE;
6704                 _tmp30_ = *prev;
6705                 _tmp31_ = level;
6706                 _tmp32_ = _tmp30_._iter[_tmp31_];
6707                 _tmp33_ = level;
6708                 _tmp35_ = gee_concurrent_set_tower_get_succ (_tmp32_, &_tmp34_, _tmp33_);
6709                 prev_state = _tmp34_;
6710                 prev_next = _tmp35_;
6711                 _tmp36_ = prev_state;
6712                 if (_tmp36_ == GEE_CONCURRENT_SET_STATE_FLAGGED) {
6713                         GeeConcurrentSetTower* _tmp37_;
6714                         GeeConcurrentSetTowerIter _tmp38_;
6715                         guint8 _tmp39_;
6716                         GeeConcurrentSetTower* _tmp40_;
6717                         guint8 _tmp41_;
6718                         _tmp37_ = prev_next;
6719                         _tmp38_ = *prev;
6720                         _tmp39_ = level;
6721                         _tmp40_ = _tmp38_._iter[_tmp39_];
6722                         _tmp41_ = level;
6723                         gee_concurrent_set_tower_help_flagged (_tmp37_, _tmp40_, _tmp41_);
6724                 } else {
6725                         GeeConcurrentSetTower* _tmp42_;
6726                         GeeConcurrentSetTower* _tmp43_;
6727                         guint8 _tmp44_;
6728                         GeeConcurrentSetTowerIter _tmp45_;
6729                         guint8 _tmp46_;
6730                         GeeConcurrentSetTower* _tmp47_;
6731                         GeeConcurrentSetTower* _tmp48_;
6732                         GeeConcurrentSetTower* _tmp49_;
6733                         guint8 _tmp50_;
6734                         gboolean _tmp51_ = FALSE;
6735                         gboolean _result_;
6736                         gboolean _tmp52_;
6737                         GeeConcurrentSetTowerIter _tmp53_;
6738                         guint8 _tmp54_;
6739                         GeeConcurrentSetTower* _tmp55_;
6740                         guint8 _tmp56_;
6741                         GeeConcurrentSetState _tmp57_ = 0;
6742                         GeeConcurrentSetTower* _tmp58_ = NULL;
6743                         GeeConcurrentSetState _tmp59_;
6744                         guint8 _tmp65_;
6745                         guint8 _tmp66_;
6746                         _tmp42_ = new_tower;
6747                         _tmp43_ = next;
6748                         _tmp44_ = level;
6749                         gee_concurrent_set_tower_set_succ (_tmp42_, _tmp43_, GEE_CONCURRENT_SET_STATE_NONE, _tmp44_);
6750                         _tmp45_ = *prev;
6751                         _tmp46_ = level;
6752                         _tmp47_ = _tmp45_._iter[_tmp46_];
6753                         _tmp48_ = next;
6754                         _tmp49_ = new_tower;
6755                         _tmp50_ = level;
6756                         _tmp51_ = gee_concurrent_set_tower_compare_and_exchange (_tmp47_, _tmp48_, GEE_CONCURRENT_SET_STATE_NONE, _tmp49_, GEE_CONCURRENT_SET_STATE_NONE, _tmp50_);
6757                         _result_ = _tmp51_;
6758                         _tmp52_ = _result_;
6759                         if (_tmp52_) {
6760                                 _gee_concurrent_set_tower_unref0 (prev_next);
6761                                 break;
6762                         }
6763                         _tmp53_ = *prev;
6764                         _tmp54_ = level;
6765                         _tmp55_ = _tmp53_._iter[_tmp54_];
6766                         _tmp56_ = level;
6767                         _tmp58_ = gee_concurrent_set_tower_get_succ (_tmp55_, &_tmp57_, _tmp56_);
6768                         prev_state = _tmp57_;
6769                         _gee_concurrent_set_tower_unref0 (prev_next);
6770                         prev_next = _tmp58_;
6771                         _tmp59_ = prev_state;
6772                         if (_tmp59_ == GEE_CONCURRENT_SET_STATE_FLAGGED) {
6773                                 GeeConcurrentSetTower* _tmp60_;
6774                                 GeeConcurrentSetTowerIter _tmp61_;
6775                                 guint8 _tmp62_;
6776                                 GeeConcurrentSetTower* _tmp63_;
6777                                 guint8 _tmp64_;
6778                                 _tmp60_ = prev_next;
6779                                 _tmp61_ = *prev;
6780                                 _tmp62_ = level;
6781                                 _tmp63_ = _tmp61_._iter[_tmp62_];
6782                                 _tmp64_ = level;
6783                                 gee_concurrent_set_tower_help_flagged (_tmp60_, _tmp63_, _tmp64_);
6784                         }
6785                         _tmp65_ = level;
6786                         _tmp66_ = level;
6787                         gee_concurrent_set_tower_backtrace (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, &(*prev)._iter[_tmp65_], _tmp66_);
6788                 }
6789                 _tmp67_ = cmp;
6790                 _tmp67__target = cmp_target;
6791                 _tmp68_ = key;
6792                 _tmp69_ = level;
6793                 _tmp70_ = level;
6794                 _tmp71_ = gee_concurrent_set_tower_search_helper (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp67_, _tmp67__target, _tmp68_, &(*prev)._iter[_tmp69_], NULL, _tmp70_);
6795                 if (_tmp71_) {
6796                         result = NULL;
6797                         _gee_concurrent_set_tower_unref0 (prev_next);
6798                         _gee_concurrent_set_tower_unref0 (next);
6799                         _gee_concurrent_set_tower_unref0 (new_tower);
6800                         return result;
6801                 }
6802                 _gee_concurrent_set_tower_unref0 (prev_next);
6803         }
6804         _tmp72_ = new_tower;
6805         g_atomic_int_inc ((volatile gint *) (&_tmp72_->_height));
6806         _tmp73_ = new_tower;
6807         _tmp74_ = gee_concurrent_set_tower_get_state (_tmp73_, (guint8) 0);
6808         if (_tmp74_ == GEE_CONCURRENT_SET_STATE_MARKED) {
6809                 GCompareDataFunc _tmp75_;
6810                 void* _tmp75__target;
6811                 guint8 _tmp76_;
6812                 GeeConcurrentSetTower* _tmp77_;
6813                 guint8 _tmp78_;
6814                 _tmp75_ = cmp;
6815                 _tmp75__target = cmp_target;
6816                 _tmp76_ = level;
6817                 _tmp77_ = new_tower;
6818                 _tmp78_ = level;
6819                 gee_concurrent_set_tower_remove_level (_tmp75_, _tmp75__target, &(*prev)._iter[_tmp76_], _tmp77_, _tmp78_);
6820                 result = NULL;
6821                 _gee_concurrent_set_tower_unref0 (next);
6822                 _gee_concurrent_set_tower_unref0 (new_tower);
6823                 return result;
6824         }
6825         result = new_tower;
6826         _gee_concurrent_set_tower_unref0 (next);
6827         return result;
6828 }
6829
6830
6831 static inline gboolean gee_concurrent_set_tower_remove_key (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTowerIter* prev, gconstpointer key, guint8 from_level) {
6832         gboolean result = FALSE;
6833         GeeConcurrentSetTower* curr = NULL;
6834         GCompareDataFunc _tmp24_;
6835         void* _tmp24__target;
6836         gconstpointer _tmp25_;
6837         GeeConcurrentSetTower* _tmp26_ = NULL;
6838         gboolean _tmp27_ = FALSE;
6839         g_return_val_if_fail (prev != NULL, FALSE);
6840         {
6841                 guint8 _tmp0_;
6842                 gint i;
6843                 _tmp0_ = from_level;
6844                 i = (gint) _tmp0_;
6845                 {
6846                         gboolean _tmp1_;
6847                         _tmp1_ = TRUE;
6848                         while (TRUE) {
6849                                 gboolean _tmp2_;
6850                                 gint _tmp4_;
6851                                 GeeConcurrentSetTower* next = NULL;
6852                                 GCompareDataFunc _tmp5_;
6853                                 void* _tmp5__target;
6854                                 gconstpointer _tmp6_;
6855                                 gint _tmp7_;
6856                                 gint _tmp8_;
6857                                 GeeConcurrentSetTower* _tmp9_ = NULL;
6858                                 GCompareDataFunc _tmp10_;
6859                                 void* _tmp10__target;
6860                                 GeeConcurrentSetTowerIter _tmp11_;
6861                                 gint _tmp12_;
6862                                 GeeConcurrentSetTower* _tmp13_;
6863                                 GeeConcurrentSetTowerIter _tmp14_;
6864                                 gint _tmp15_;
6865                                 GeeConcurrentSetTower* _tmp16_;
6866                                 gint _tmp17_ = 0;
6867                                 _tmp2_ = _tmp1_;
6868                                 if (!_tmp2_) {
6869                                         gint _tmp3_;
6870                                         _tmp3_ = i;
6871                                         i = _tmp3_ - 1;
6872                                 }
6873                                 _tmp1_ = FALSE;
6874                                 _tmp4_ = i;
6875                                 if (!(_tmp4_ >= 1)) {
6876                                         break;
6877                                 }
6878                                 _tmp5_ = cmp;
6879                                 _tmp5__target = cmp_target;
6880                                 _tmp6_ = key;
6881                                 _tmp7_ = i;
6882                                 _tmp8_ = i;
6883                                 gee_concurrent_set_tower_search_helper (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp5_, _tmp5__target, _tmp6_, &(*prev)._iter[_tmp7_], &_tmp9_, (guint8) _tmp8_);
6884                                 _gee_concurrent_set_tower_unref0 (next);
6885                                 next = _tmp9_;
6886                                 _tmp10_ = cmp;
6887                                 _tmp10__target = cmp_target;
6888                                 _tmp11_ = *prev;
6889                                 _tmp12_ = i;
6890                                 _tmp13_ = _tmp11_._iter[_tmp12_ - 1];
6891                                 _tmp14_ = *prev;
6892                                 _tmp15_ = i;
6893                                 _tmp16_ = _tmp14_._iter[_tmp15_];
6894                                 _tmp17_ = gee_concurrent_set_tower_compare (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp10_, _tmp10__target, _tmp13_, _tmp16_);
6895                                 if (_tmp17_ < 0) {
6896                                         gint _tmp18_;
6897                                         GeeConcurrentSetTowerIter _tmp19_;
6898                                         gint _tmp20_;
6899                                         GeeConcurrentSetTower* _tmp21_;
6900                                         GeeConcurrentSetTower* _tmp22_;
6901                                         GeeConcurrentSetTower* _tmp23_;
6902                                         _tmp18_ = i;
6903                                         _tmp19_ = *prev;
6904                                         _tmp20_ = i;
6905                                         _tmp21_ = _tmp19_._iter[_tmp20_];
6906                                         _tmp22_ = _gee_concurrent_set_tower_ref0 (_tmp21_);
6907                                         _gee_concurrent_set_tower_unref0 ((*prev)._iter[_tmp18_ - 1]);
6908                                         (*prev)._iter[_tmp18_ - 1] = _tmp22_;
6909                                         _tmp23_ = (*prev)._iter[_tmp18_ - 1];
6910                                 }
6911                                 _gee_concurrent_set_tower_unref0 (next);
6912                         }
6913                 }
6914         }
6915         _tmp24_ = cmp;
6916         _tmp24__target = cmp_target;
6917         _tmp25_ = key;
6918         _tmp27_ = gee_concurrent_set_tower_search_helper (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp24_, _tmp24__target, _tmp25_, &(*prev)._iter[0], &_tmp26_, (guint8) 0);
6919         _gee_concurrent_set_tower_unref0 (curr);
6920         curr = _tmp26_;
6921         if (_tmp27_) {
6922                 GCompareDataFunc _tmp28_;
6923                 void* _tmp28__target;
6924                 GeeConcurrentSetTower* _tmp29_;
6925                 gboolean _tmp30_ = FALSE;
6926                 _tmp28_ = cmp;
6927                 _tmp28__target = cmp_target;
6928                 _tmp29_ = curr;
6929                 _tmp30_ = gee_concurrent_set_tower_remove (g_type, (GBoxedCopyFunc) g_dup_func, g_destroy_func, _tmp28_, _tmp28__target, prev, _tmp29_);
6930                 result = _tmp30_;
6931                 _gee_concurrent_set_tower_unref0 (curr);
6932                 return result;
6933         } else {
6934                 result = FALSE;
6935                 _gee_concurrent_set_tower_unref0 (curr);
6936                 return result;
6937         }
6938         _gee_concurrent_set_tower_unref0 (curr);
6939 }
6940
6941
6942 static inline gboolean gee_concurrent_set_tower_remove (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTowerIter* prev, GeeConcurrentSetTower* curr) {
6943         gboolean result = FALSE;
6944         GCompareDataFunc _tmp0_;
6945         void* _tmp0__target;
6946         GeeConcurrentSetTower* _tmp1_;
6947         gboolean _tmp2_ = FALSE;
6948         gboolean removed;
6949         g_return_val_if_fail (prev != NULL, FALSE);
6950         g_return_val_if_fail (curr != NULL, FALSE);
6951         _tmp0_ = cmp;
6952         _tmp0__target = cmp_target;
6953         _tmp1_ = curr;
6954         _tmp2_ = gee_concurrent_set_tower_remove_level (_tmp0_, _tmp0__target, &(*prev)._iter[0], _tmp1_, (guint8) 0);
6955         removed = _tmp2_;
6956         {
6957                 gint i;
6958                 i = 1;
6959                 {
6960                         gboolean _tmp3_;
6961                         _tmp3_ = TRUE;
6962                         while (TRUE) {
6963                                 gboolean _tmp4_;
6964                                 gint _tmp6_;
6965                                 GCompareDataFunc _tmp7_;
6966                                 void* _tmp7__target;
6967                                 gint _tmp8_;
6968                                 GeeConcurrentSetTower* _tmp9_;
6969                                 gint _tmp10_;
6970                                 _tmp4_ = _tmp3_;
6971                                 if (!_tmp4_) {
6972                                         gint _tmp5_;
6973                                         _tmp5_ = i;
6974                                         i = _tmp5_ + 1;
6975                                 }
6976                                 _tmp3_ = FALSE;
6977                                 _tmp6_ = i;
6978                                 if (!(_tmp6_ < GEE_CONCURRENT_SET__MAX_HEIGHT)) {
6979                                         break;
6980                                 }
6981                                 _tmp7_ = cmp;
6982                                 _tmp7__target = cmp_target;
6983                                 _tmp8_ = i;
6984                                 _tmp9_ = curr;
6985                                 _tmp10_ = i;
6986                                 gee_concurrent_set_tower_remove_level (_tmp7_, _tmp7__target, &(*prev)._iter[_tmp8_], _tmp9_, (guint8) _tmp10_);
6987                         }
6988                 }
6989         }
6990         result = removed;
6991         return result;
6992 }
6993
6994
6995 static inline gboolean gee_concurrent_set_tower_remove_level (GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTower** prev, GeeConcurrentSetTower* curr, guint8 level) {
6996         gboolean result = FALSE;
6997         gboolean status = FALSE;
6998         GeeConcurrentSetTower* _tmp0_;
6999         GCompareDataFunc _tmp1_;
7000         void* _tmp1__target;
7001         guint8 _tmp2_;
7002         gboolean _tmp3_ = FALSE;
7003         gboolean _tmp4_ = FALSE;
7004         gboolean flagged;
7005         gboolean _tmp5_;
7006         g_return_val_if_fail (*prev != NULL, FALSE);
7007         g_return_val_if_fail (curr != NULL, FALSE);
7008         _tmp0_ = curr;
7009         _tmp1_ = cmp;
7010         _tmp1__target = cmp_target;
7011         _tmp2_ = level;
7012         _tmp4_ = gee_concurrent_set_tower_try_flag (_tmp0_, _tmp1_, _tmp1__target, prev, &_tmp3_, _tmp2_);
7013         status = _tmp3_;
7014         flagged = _tmp4_;
7015         _tmp5_ = status;
7016         if (_tmp5_) {
7017                 GeeConcurrentSetTower* _tmp6_;
7018                 GeeConcurrentSetTower* _tmp7_;
7019                 guint8 _tmp8_;
7020                 _tmp6_ = curr;
7021                 _tmp7_ = *prev;
7022                 _tmp8_ = level;
7023                 gee_concurrent_set_tower_help_flagged (_tmp6_, _tmp7_, _tmp8_);
7024         }
7025         result = flagged;
7026         return result;
7027 }
7028
7029
7030 static inline gboolean gee_concurrent_set_tower_proceed (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTower** arg_prev, GeeConcurrentSetTower** arg_curr, guint8 level, gboolean force) {
7031         gboolean result = FALSE;
7032         GeeConcurrentSetTower* _tmp0_;
7033         GeeConcurrentSetTower* _tmp1_;
7034         GeeConcurrentSetTower* curr;
7035         GeeConcurrentSetTower* _tmp2_;
7036         guint8 _tmp3_;
7037         GeeConcurrentSetTower* _tmp4_ = NULL;
7038         GeeConcurrentSetTower* next;
7039         GeeConcurrentSetTower* _tmp5_;
7040         GeeConcurrentSetTower* _tmp22_;
7041         gboolean success;
7042         gboolean _tmp23_ = FALSE;
7043         gboolean _tmp24_;
7044         gboolean _tmp26_;
7045         g_return_val_if_fail (*arg_curr != NULL, FALSE);
7046         _tmp0_ = *arg_curr;
7047         _tmp1_ = _gee_concurrent_set_tower_ref0 (_tmp0_);
7048         curr = _tmp1_;
7049         _tmp2_ = curr;
7050         _tmp3_ = level;
7051         _tmp4_ = gee_concurrent_set_tower_get_next (_tmp2_, _tmp3_);
7052         next = _tmp4_;
7053         _tmp5_ = next;
7054         if (_tmp5_ != NULL) {
7055                 while (TRUE) {
7056                         gboolean _tmp6_ = FALSE;
7057                         GeeConcurrentSetTower* _tmp7_;
7058                         gboolean _tmp10_;
7059                         gboolean status = FALSE;
7060                         GeeConcurrentSetTower* _tmp11_;
7061                         GCompareDataFunc _tmp12_;
7062                         void* _tmp12__target;
7063                         guint8 _tmp13_;
7064                         gboolean _tmp14_ = FALSE;
7065                         gboolean _tmp15_;
7066                         GeeConcurrentSetTower* _tmp19_;
7067                         guint8 _tmp20_;
7068                         GeeConcurrentSetTower* _tmp21_ = NULL;
7069                         _tmp7_ = next;
7070                         if (_tmp7_ != NULL) {
7071                                 GeeConcurrentSetTower* _tmp8_;
7072                                 GeeConcurrentSetState _tmp9_ = 0;
7073                                 _tmp8_ = next;
7074                                 _tmp9_ = gee_concurrent_set_tower_get_state (_tmp8_, (guint8) 0);
7075                                 _tmp6_ = _tmp9_ == GEE_CONCURRENT_SET_STATE_MARKED;
7076                         } else {
7077                                 _tmp6_ = FALSE;
7078                         }
7079                         _tmp10_ = _tmp6_;
7080                         if (!_tmp10_) {
7081                                 break;
7082                         }
7083                         _tmp11_ = next;
7084                         _tmp12_ = cmp;
7085                         _tmp12__target = cmp_target;
7086                         _tmp13_ = level;
7087                         gee_concurrent_set_tower_try_flag (_tmp11_, _tmp12_, _tmp12__target, &curr, &_tmp14_, _tmp13_);
7088                         status = _tmp14_;
7089                         _tmp15_ = status;
7090                         if (_tmp15_) {
7091                                 GeeConcurrentSetTower* _tmp16_;
7092                                 GeeConcurrentSetTower* _tmp17_;
7093                                 guint8 _tmp18_;
7094                                 _tmp16_ = next;
7095                                 _tmp17_ = curr;
7096                                 _tmp18_ = level;
7097                                 gee_concurrent_set_tower_help_flagged (_tmp16_, _tmp17_, _tmp18_);
7098                         }
7099                         _tmp19_ = curr;
7100                         _tmp20_ = level;
7101                         _tmp21_ = gee_concurrent_set_tower_get_next (_tmp19_, _tmp20_);
7102                         _gee_concurrent_set_tower_unref0 (next);
7103                         next = _tmp21_;
7104                 }
7105         }
7106         _tmp22_ = next;
7107         success = _tmp22_ != NULL;
7108         _tmp24_ = success;
7109         if (_tmp24_) {
7110                 _tmp23_ = TRUE;
7111         } else {
7112                 gboolean _tmp25_;
7113                 _tmp25_ = force;
7114                 _tmp23_ = _tmp25_;
7115         }
7116         _tmp26_ = _tmp23_;
7117         if (_tmp26_) {
7118                 GeeConcurrentSetTower* _tmp27_;
7119                 GeeConcurrentSetTower* _tmp28_;
7120                 _tmp27_ = curr;
7121                 curr = NULL;
7122                 _gee_concurrent_set_tower_unref0 (*arg_prev);
7123                 *arg_prev = _tmp27_;
7124                 _tmp28_ = next;
7125                 next = NULL;
7126                 _gee_concurrent_set_tower_unref0 (*arg_curr);
7127                 *arg_curr = _tmp28_;
7128         }
7129         result = success;
7130         _gee_concurrent_set_tower_unref0 (next);
7131         _gee_concurrent_set_tower_unref0 (curr);
7132         return result;
7133 }
7134
7135
7136 static inline void gee_concurrent_set_tower_help_marked (GeeConcurrentSetTower* self, GeeConcurrentSetTower* prev_tower, guint8 level) {
7137         GeeConcurrentSetTower* _tmp0_;
7138         guint8 _tmp1_;
7139         GeeConcurrentSetTower* _tmp2_ = NULL;
7140         GeeConcurrentSetTower* _tmp3_;
7141         guint8 _tmp4_;
7142         g_return_if_fail (self != NULL);
7143         g_return_if_fail (prev_tower != NULL);
7144         _tmp0_ = prev_tower;
7145         _tmp1_ = level;
7146         _tmp2_ = gee_concurrent_set_tower_get_next (self, _tmp1_);
7147         _tmp3_ = _tmp2_;
7148         _tmp4_ = level;
7149         gee_concurrent_set_tower_compare_and_exchange (_tmp0_, self, GEE_CONCURRENT_SET_STATE_FLAGGED, _tmp3_, GEE_CONCURRENT_SET_STATE_NONE, _tmp4_);
7150         _gee_concurrent_set_tower_unref0 (_tmp3_);
7151 }
7152
7153
7154 static inline void gee_concurrent_set_tower_help_flagged (GeeConcurrentSetTower* self, GeeConcurrentSetTower* prev, guint8 level) {
7155         GeeConcurrentSetTower* _tmp0_;
7156         guint8 _tmp1_;
7157         guint8 _tmp2_;
7158         GeeConcurrentSetState _tmp3_ = 0;
7159         GeeConcurrentSetTower* _tmp5_;
7160         guint8 _tmp6_;
7161         g_return_if_fail (self != NULL);
7162         g_return_if_fail (prev != NULL);
7163         _tmp0_ = prev;
7164         _tmp1_ = level;
7165         gee_concurrent_set_tower_set_backlink (self, _tmp0_, _tmp1_);
7166         _tmp2_ = level;
7167         _tmp3_ = gee_concurrent_set_tower_get_state (self, _tmp2_);
7168         if (_tmp3_ != GEE_CONCURRENT_SET_STATE_MARKED) {
7169                 guint8 _tmp4_;
7170                 _tmp4_ = level;
7171                 gee_concurrent_set_tower_try_mark (self, _tmp4_);
7172         }
7173         _tmp5_ = prev;
7174         _tmp6_ = level;
7175         gee_concurrent_set_tower_help_marked (self, _tmp5_, _tmp6_);
7176 }
7177
7178
7179 static inline void gee_concurrent_set_tower_try_mark (GeeConcurrentSetTower* self, guint8 level) {
7180         g_return_if_fail (self != NULL);
7181         {
7182                 gboolean _tmp0_;
7183                 _tmp0_ = TRUE;
7184                 while (TRUE) {
7185                         gboolean _tmp1_;
7186                         guint8 _tmp4_;
7187                         GeeConcurrentSetTower* _tmp5_ = NULL;
7188                         GeeConcurrentSetTower* next_tower;
7189                         GeeConcurrentSetTower* _tmp6_;
7190                         GeeConcurrentSetTower* _tmp7_;
7191                         guint8 _tmp8_;
7192                         gboolean _tmp9_ = FALSE;
7193                         gboolean _result_;
7194                         gboolean _tmp10_;
7195                         _tmp1_ = _tmp0_;
7196                         if (!_tmp1_) {
7197                                 guint8 _tmp2_;
7198                                 GeeConcurrentSetState _tmp3_ = 0;
7199                                 _tmp2_ = level;
7200                                 _tmp3_ = gee_concurrent_set_tower_get_state (self, _tmp2_);
7201                                 if (!(_tmp3_ != GEE_CONCURRENT_SET_STATE_MARKED)) {
7202                                         break;
7203                                 }
7204                         }
7205                         _tmp0_ = FALSE;
7206                         _tmp4_ = level;
7207                         _tmp5_ = gee_concurrent_set_tower_get_next (self, _tmp4_);
7208                         next_tower = _tmp5_;
7209                         _tmp6_ = next_tower;
7210                         _tmp7_ = next_tower;
7211                         _tmp8_ = level;
7212                         _tmp9_ = gee_concurrent_set_tower_compare_and_exchange (self, _tmp6_, GEE_CONCURRENT_SET_STATE_NONE, _tmp7_, GEE_CONCURRENT_SET_STATE_MARKED, _tmp8_);
7213                         _result_ = _tmp9_;
7214                         _tmp10_ = _result_;
7215                         if (!_tmp10_) {
7216                                 GeeConcurrentSetState state = 0;
7217                                 guint8 _tmp11_;
7218                                 GeeConcurrentSetState _tmp12_ = 0;
7219                                 GeeConcurrentSetTower* _tmp13_ = NULL;
7220                                 GeeConcurrentSetState _tmp14_;
7221                                 _tmp11_ = level;
7222                                 _tmp13_ = gee_concurrent_set_tower_get_succ (self, &_tmp12_, _tmp11_);
7223                                 state = _tmp12_;
7224                                 _gee_concurrent_set_tower_unref0 (next_tower);
7225                                 next_tower = _tmp13_;
7226                                 _tmp14_ = state;
7227                                 if (_tmp14_ == GEE_CONCURRENT_SET_STATE_FLAGGED) {
7228                                         GeeConcurrentSetTower* _tmp15_;
7229                                         guint8 _tmp16_;
7230                                         _tmp15_ = next_tower;
7231                                         _tmp16_ = level;
7232                                         gee_concurrent_set_tower_help_flagged (self, _tmp15_, _tmp16_);
7233                                 }
7234                         }
7235                         _gee_concurrent_set_tower_unref0 (next_tower);
7236                 }
7237         }
7238 }
7239
7240
7241 static inline gboolean gee_concurrent_set_tower_try_flag (GeeConcurrentSetTower* self, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTower** prev_tower, gboolean* status, guint8 level) {
7242         gboolean _vala_status = FALSE;
7243         gboolean result = FALSE;
7244         g_return_val_if_fail (self != NULL, FALSE);
7245         g_return_val_if_fail (*prev_tower != NULL, FALSE);
7246         while (TRUE) {
7247                 GeeConcurrentSetTower* _tmp0_;
7248                 guint8 _tmp1_;
7249                 gboolean _tmp2_ = FALSE;
7250                 GeeConcurrentSetTower* _tmp3_;
7251                 guint8 _tmp4_;
7252                 gboolean _tmp5_ = FALSE;
7253                 gboolean _result_;
7254                 gboolean _tmp6_;
7255                 GeeConcurrentSetState result_state = 0;
7256                 GeeConcurrentSetTower* _tmp7_;
7257                 guint8 _tmp8_;
7258                 GeeConcurrentSetState _tmp9_ = 0;
7259                 GeeConcurrentSetTower* _tmp10_ = NULL;
7260                 GeeConcurrentSetTower* result_tower;
7261                 gboolean _tmp11_ = FALSE;
7262                 GeeConcurrentSetTower* _tmp12_;
7263                 gboolean _tmp14_;
7264                 guint8 _tmp15_;
7265                 GCompareDataFunc _tmp16_;
7266                 void* _tmp16__target;
7267                 gconstpointer _tmp17_;
7268                 guint8 _tmp18_;
7269                 gboolean _tmp19_ = FALSE;
7270                 _tmp0_ = *prev_tower;
7271                 _tmp1_ = level;
7272                 _tmp2_ = gee_concurrent_set_tower_compare_succ (_tmp0_, self, GEE_CONCURRENT_SET_STATE_FLAGGED, _tmp1_);
7273                 if (_tmp2_) {
7274                         _vala_status = TRUE;
7275                         result = FALSE;
7276                         if (status) {
7277                                 *status = _vala_status;
7278                         }
7279                         return result;
7280                 }
7281                 _tmp3_ = *prev_tower;
7282                 _tmp4_ = level;
7283                 _tmp5_ = gee_concurrent_set_tower_compare_and_exchange (_tmp3_, self, GEE_CONCURRENT_SET_STATE_NONE, self, GEE_CONCURRENT_SET_STATE_FLAGGED, _tmp4_);
7284                 _result_ = _tmp5_;
7285                 _tmp6_ = _result_;
7286                 if (_tmp6_) {
7287                         _vala_status = TRUE;
7288                         result = TRUE;
7289                         if (status) {
7290                                 *status = _vala_status;
7291                         }
7292                         return result;
7293                 }
7294                 _tmp7_ = *prev_tower;
7295                 _tmp8_ = level;
7296                 _tmp10_ = gee_concurrent_set_tower_get_succ (_tmp7_, &_tmp9_, _tmp8_);
7297                 result_state = _tmp9_;
7298                 result_tower = _tmp10_;
7299                 _tmp12_ = result_tower;
7300                 if (_tmp12_ == self) {
7301                         GeeConcurrentSetState _tmp13_;
7302                         _tmp13_ = result_state;
7303                         _tmp11_ = _tmp13_ == GEE_CONCURRENT_SET_STATE_FLAGGED;
7304                 } else {
7305                         _tmp11_ = FALSE;
7306                 }
7307                 _tmp14_ = _tmp11_;
7308                 if (_tmp14_) {
7309                         _vala_status = TRUE;
7310                         result = FALSE;
7311                         _gee_concurrent_set_tower_unref0 (result_tower);
7312                         if (status) {
7313                                 *status = _vala_status;
7314                         }
7315                         return result;
7316                 }
7317                 _tmp15_ = level;
7318                 gee_concurrent_set_tower_backtrace (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, prev_tower, _tmp15_);
7319                 _tmp16_ = cmp;
7320                 _tmp16__target = cmp_target;
7321                 _tmp17_ = self->_data;
7322                 _tmp18_ = level;
7323                 _tmp19_ = gee_concurrent_set_tower_search_helper (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func, _tmp16_, _tmp16__target, _tmp17_, prev_tower, NULL, _tmp18_);
7324                 if (!_tmp19_) {
7325                         _vala_status = FALSE;
7326                         result = FALSE;
7327                         _gee_concurrent_set_tower_unref0 (result_tower);
7328                         if (status) {
7329                                 *status = _vala_status;
7330                         }
7331                         return result;
7332                 }
7333                 _gee_concurrent_set_tower_unref0 (result_tower);
7334         }
7335         if (status) {
7336                 *status = _vala_status;
7337         }
7338 }
7339
7340
7341 static inline void gee_concurrent_set_tower_backtrace (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GeeConcurrentSetTower** curr, guint8 level) {
7342         while (TRUE) {
7343                 GeeConcurrentSetTower* _tmp0_;
7344                 guint8 _tmp1_;
7345                 GeeConcurrentSetState _tmp2_ = 0;
7346                 GeeConcurrentSetTower* _tmp3_;
7347                 guint8 _tmp4_;
7348                 GeeConcurrentSetTower* _tmp5_ = NULL;
7349                 _tmp0_ = *curr;
7350                 _tmp1_ = level;
7351                 _tmp2_ = gee_concurrent_set_tower_get_state (_tmp0_, _tmp1_);
7352                 if (!(_tmp2_ == GEE_CONCURRENT_SET_STATE_MARKED)) {
7353                         break;
7354                 }
7355                 _tmp3_ = *curr;
7356                 _tmp4_ = level;
7357                 _tmp5_ = gee_concurrent_set_tower_get_backlink (_tmp3_, _tmp4_);
7358                 _gee_concurrent_set_tower_unref0 (*curr);
7359                 *curr = _tmp5_;
7360         }
7361 }
7362
7363
7364 static inline gboolean gee_concurrent_set_tower_compare_and_exchange (GeeConcurrentSetTower* self, GeeConcurrentSetTower* old_tower, GeeConcurrentSetState old_state, GeeConcurrentSetTower* new_tower, GeeConcurrentSetState new_state, guint8 level) {
7365         gboolean result = FALSE;
7366         GeeConcurrentSetTowerNode* _tmp0_;
7367         gint _tmp0__length1;
7368         guint8 _tmp1_;
7369         GeeConcurrentSetTower* _tmp2_;
7370         GeeConcurrentSetTower* _tmp3_;
7371         GeeConcurrentSetTower* _tmp4_;
7372         GeeConcurrentSetState _tmp5_;
7373         GeeConcurrentSetState _tmp6_;
7374         gboolean _tmp7_ = FALSE;
7375         g_return_val_if_fail (self != NULL, FALSE);
7376         _tmp0_ = self->_nodes;
7377         _tmp0__length1 = -1;
7378         _tmp1_ = level;
7379         _tmp2_ = old_tower;
7380         _tmp3_ = new_tower;
7381         _tmp4_ = _gee_concurrent_set_tower_ref0 (_tmp3_);
7382         _tmp5_ = old_state;
7383         _tmp6_ = new_state;
7384         _tmp7_ = gee_hazard_pointer_compare_and_exchange_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp0_[_tmp1_]._succ, _tmp2_, _tmp4_, (gsize) 3, (gsize) _tmp5_, (gsize) _tmp6_);
7385         result = _tmp7_;
7386         return result;
7387 }
7388
7389
7390 static inline gboolean gee_concurrent_set_tower_compare_succ (GeeConcurrentSetTower* self, GeeConcurrentSetTower* next, GeeConcurrentSetState state, guint8 level) {
7391         gboolean result = FALSE;
7392         GeeConcurrentSetTowerNode* _tmp0_;
7393         gint _tmp0__length1;
7394         guint8 _tmp1_;
7395         void* _tmp2_ = NULL;
7396         gsize cur;
7397         GeeConcurrentSetTower* _tmp3_;
7398         GeeConcurrentSetState _tmp4_;
7399         g_return_val_if_fail (self != NULL, FALSE);
7400         _tmp0_ = self->_nodes;
7401         _tmp0__length1 = -1;
7402         _tmp1_ = level;
7403         _tmp2_ = g_atomic_pointer_get ((volatile gpointer *) (&_tmp0_[_tmp1_]._succ));
7404         cur = (gsize) _tmp2_;
7405         _tmp3_ = next;
7406         _tmp4_ = state;
7407         result = cur == (((gsize) _tmp3_) | ((gsize) _tmp4_));
7408         return result;
7409 }
7410
7411
7412 static inline GeeConcurrentSetTower* gee_concurrent_set_tower_get_next (GeeConcurrentSetTower* self, guint8 level) {
7413         GeeConcurrentSetTower* result = NULL;
7414         guint8 _tmp0_;
7415         GeeConcurrentSetTower* _tmp1_ = NULL;
7416         g_return_val_if_fail (self != NULL, NULL);
7417         _tmp0_ = level;
7418         _tmp1_ = gee_concurrent_set_tower_get_succ (self, NULL, _tmp0_);
7419         result = _tmp1_;
7420         return result;
7421 }
7422
7423
7424 static inline GeeConcurrentSetState gee_concurrent_set_tower_get_state (GeeConcurrentSetTower* self, guint8 level) {
7425         GeeConcurrentSetState result = 0;
7426         GeeConcurrentSetTowerNode* _tmp0_;
7427         gint _tmp0__length1;
7428         guint8 _tmp1_;
7429         void* _tmp2_ = NULL;
7430         g_return_val_if_fail (self != NULL, 0);
7431         _tmp0_ = self->_nodes;
7432         _tmp0__length1 = -1;
7433         _tmp1_ = level;
7434         _tmp2_ = g_atomic_pointer_get ((volatile gpointer *) (&_tmp0_[_tmp1_]._succ));
7435         result = (GeeConcurrentSetState) (((gsize) _tmp2_) & 3);
7436         return result;
7437 }
7438
7439
7440 static inline GeeConcurrentSetTower* gee_concurrent_set_tower_get_succ (GeeConcurrentSetTower* self, GeeConcurrentSetState* state, guint8 level) {
7441         GeeConcurrentSetState _vala_state = 0;
7442         GeeConcurrentSetTower* result = NULL;
7443         gsize rstate = 0UL;
7444         GeeConcurrentSetTowerNode* _tmp0_;
7445         gint _tmp0__length1;
7446         guint8 _tmp1_;
7447         gsize _tmp2_ = 0UL;
7448         gpointer _tmp3_ = NULL;
7449         GeeConcurrentSetTower* succ;
7450         GeeConcurrentSetTower* _tmp4_;
7451         g_return_val_if_fail (self != NULL, NULL);
7452         _tmp0_ = self->_nodes;
7453         _tmp0__length1 = -1;
7454         _tmp1_ = level;
7455         _tmp3_ = gee_hazard_pointer_get_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp0_[_tmp1_]._succ, (gsize) 3, &_tmp2_);
7456         rstate = _tmp2_;
7457         succ = (GeeConcurrentSetTower*) _tmp3_;
7458         _vala_state = (GeeConcurrentSetState) rstate;
7459         _tmp4_ = succ;
7460         succ = NULL;
7461         result = _tmp4_;
7462         _gee_concurrent_set_tower_unref0 (succ);
7463         if (state) {
7464                 *state = _vala_state;
7465         }
7466         return result;
7467 }
7468
7469
7470 static inline void gee_concurrent_set_tower_set_succ (GeeConcurrentSetTower* self, GeeConcurrentSetTower* next, GeeConcurrentSetState state, guint8 level) {
7471         GeeConcurrentSetTowerNode* _tmp0_;
7472         gint _tmp0__length1;
7473         guint8 _tmp1_;
7474         GeeConcurrentSetTower* _tmp2_;
7475         GeeConcurrentSetTower* _tmp3_;
7476         GeeConcurrentSetState _tmp4_;
7477         g_return_if_fail (self != NULL);
7478         _tmp0_ = self->_nodes;
7479         _tmp0__length1 = -1;
7480         _tmp1_ = level;
7481         _tmp2_ = next;
7482         _tmp3_ = _gee_concurrent_set_tower_ref0 (_tmp2_);
7483         _tmp4_ = state;
7484         gee_hazard_pointer_set_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp0_[_tmp1_]._succ, _tmp3_, (gsize) 3, (gsize) _tmp4_);
7485 }
7486
7487
7488 static inline GeeConcurrentSetTower* gee_concurrent_set_tower_get_backlink (GeeConcurrentSetTower* self, guint8 level) {
7489         GeeConcurrentSetTower* result = NULL;
7490         GeeConcurrentSetTowerNode* _tmp0_;
7491         gint _tmp0__length1;
7492         guint8 _tmp1_;
7493         gpointer _tmp2_ = NULL;
7494         g_return_val_if_fail (self != NULL, NULL);
7495         _tmp0_ = self->_nodes;
7496         _tmp0__length1 = -1;
7497         _tmp1_ = level;
7498         _tmp2_ = gee_hazard_pointer_get_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp0_[_tmp1_]._backlink, (gsize) 0, NULL);
7499         result = (GeeConcurrentSetTower*) _tmp2_;
7500         return result;
7501 }
7502
7503
7504 static inline void gee_concurrent_set_tower_set_backlink (GeeConcurrentSetTower* self, GeeConcurrentSetTower* backlink, guint8 level) {
7505         GeeConcurrentSetTowerNode* _tmp0_;
7506         gint _tmp0__length1;
7507         guint8 _tmp1_;
7508         GeeConcurrentSetTower* _tmp2_;
7509         GeeConcurrentSetTower* _tmp3_;
7510         g_return_if_fail (self != NULL);
7511         _tmp0_ = self->_nodes;
7512         _tmp0__length1 = -1;
7513         _tmp1_ = level;
7514         _tmp2_ = backlink;
7515         _tmp3_ = _gee_concurrent_set_tower_ref0 (_tmp2_);
7516         gee_hazard_pointer_compare_and_exchange_pointer (GEE_CONCURRENT_SET_TYPE_TOWER, (GBoxedCopyFunc) gee_concurrent_set_tower_ref, gee_concurrent_set_tower_unref, &_tmp0_[_tmp1_]._backlink, NULL, _tmp3_, (gsize) 0, (gsize) 0, (gsize) 0);
7517 }
7518
7519
7520 static inline gint gee_concurrent_set_tower_get_height (GeeConcurrentSetTower* self) {
7521         gint result = 0;
7522         gint _tmp0_ = 0;
7523         gint height;
7524         gint _tmp1_ = 0;
7525         gint _tmp2_;
7526         gint _tmp4_;
7527         g_return_val_if_fail (self != NULL, 0);
7528         _tmp0_ = g_atomic_int_get ((volatile gint *) (&self->_height));
7529         height = _tmp0_;
7530         _tmp2_ = height;
7531         if (_tmp2_ != (-1)) {
7532                 gint _tmp3_;
7533                 _tmp3_ = height;
7534                 _tmp1_ = _tmp3_;
7535         } else {
7536                 _tmp1_ = GEE_CONCURRENT_SET__MAX_HEIGHT;
7537         }
7538         _tmp4_ = _tmp1_;
7539         result = _tmp4_;
7540         return result;
7541 }
7542
7543
7544 static inline gboolean gee_concurrent_set_tower_is_head (GeeConcurrentSetTower* self) {
7545         gboolean result = FALSE;
7546         gint _tmp0_ = 0;
7547         gint height;
7548         g_return_val_if_fail (self != NULL, FALSE);
7549         _tmp0_ = g_atomic_int_get ((volatile gint *) (&self->_height));
7550         height = _tmp0_;
7551         result = height == (-1);
7552         return result;
7553 }
7554
7555
7556 static inline gint gee_concurrent_set_tower_compare (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTower* a, GeeConcurrentSetTower* b) {
7557         gint result = 0;
7558         GeeConcurrentSetTower* _tmp0_;
7559         gint _tmp1_ = 0;
7560         gboolean ah;
7561         GeeConcurrentSetTower* _tmp2_;
7562         gint _tmp3_ = 0;
7563         gboolean bh;
7564         gint _tmp4_ = 0;
7565         gboolean _tmp5_;
7566         gint _tmp18_;
7567         g_return_val_if_fail (a != NULL, 0);
7568         g_return_val_if_fail (b != NULL, 0);
7569         _tmp0_ = a;
7570         _tmp1_ = g_atomic_int_get ((volatile gint *) (&_tmp0_->_height));
7571         ah = _tmp1_ == (-1);
7572         _tmp2_ = b;
7573         _tmp3_ = g_atomic_int_get ((volatile gint *) (&_tmp2_->_height));
7574         bh = _tmp3_ == (-1);
7575         _tmp5_ = ah;
7576         if (_tmp5_) {
7577                 gint _tmp6_ = 0;
7578                 gboolean _tmp7_;
7579                 gint _tmp8_;
7580                 _tmp7_ = bh;
7581                 if (_tmp7_) {
7582                         _tmp6_ = 0;
7583                 } else {
7584                         _tmp6_ = -1;
7585                 }
7586                 _tmp8_ = _tmp6_;
7587                 _tmp4_ = _tmp8_;
7588         } else {
7589                 gint _tmp9_ = 0;
7590                 gboolean _tmp10_;
7591                 gint _tmp17_;
7592                 _tmp10_ = bh;
7593                 if (_tmp10_) {
7594                         _tmp9_ = 1;
7595                 } else {
7596                         GCompareDataFunc _tmp11_;
7597                         void* _tmp11__target;
7598                         GeeConcurrentSetTower* _tmp12_;
7599                         gconstpointer _tmp13_;
7600                         GeeConcurrentSetTower* _tmp14_;
7601                         gconstpointer _tmp15_;
7602                         gint _tmp16_ = 0;
7603                         _tmp11_ = cmp;
7604                         _tmp11__target = cmp_target;
7605                         _tmp12_ = a;
7606                         _tmp13_ = _tmp12_->_data;
7607                         _tmp14_ = b;
7608                         _tmp15_ = _tmp14_->_data;
7609                         _tmp16_ = _tmp11_ (_tmp13_, _tmp15_, _tmp11__target);
7610                         _tmp9_ = _tmp16_;
7611                 }
7612                 _tmp17_ = _tmp9_;
7613                 _tmp4_ = _tmp17_;
7614         }
7615         _tmp18_ = _tmp4_;
7616         result = _tmp18_;
7617         return result;
7618 }
7619
7620
7621 static inline gint gee_concurrent_set_tower_compare_data (GType g_type, GBoxedCopyFunc g_dup_func, GDestroyNotify g_destroy_func, GCompareDataFunc cmp, void* cmp_target, GeeConcurrentSetTower* a, gconstpointer b) {
7622         gint result = 0;
7623         GeeConcurrentSetTower* _tmp0_;
7624         gint _tmp1_ = 0;
7625         gboolean ah;
7626         gint _tmp2_ = 0;
7627         gboolean _tmp3_;
7628         g_return_val_if_fail (a != NULL, 0);
7629         _tmp0_ = a;
7630         _tmp1_ = g_atomic_int_get ((volatile gint *) (&_tmp0_->_height));
7631         ah = _tmp1_ == (-1);
7632         _tmp3_ = ah;
7633         if (_tmp3_) {
7634                 _tmp2_ = -1;
7635         } else {
7636                 GCompareDataFunc _tmp4_;
7637                 void* _tmp4__target;
7638                 GeeConcurrentSetTower* _tmp5_;
7639                 gconstpointer _tmp6_;
7640                 gconstpointer _tmp7_;
7641                 gint _tmp8_ = 0;
7642                 _tmp4_ = cmp;
7643                 _tmp4__target = cmp_target;
7644                 _tmp5_ = a;
7645                 _tmp6_ = _tmp5_->_data;
7646                 _tmp7_ = b;
7647                 _tmp8_ = _tmp4_ (_tmp6_, _tmp7_, _tmp4__target);
7648                 _tmp2_ = _tmp8_;
7649         }
7650         result = _tmp2_;
7651         return result;
7652 }
7653
7654
7655 static void gee_concurrent_set_value_tower_init (GValue* value) {
7656         value->data[0].v_pointer = NULL;
7657 }
7658
7659
7660 static void gee_concurrent_set_value_tower_free_value (GValue* value) {
7661         if (value->data[0].v_pointer) {
7662                 gee_concurrent_set_tower_unref (value->data[0].v_pointer);
7663         }
7664 }
7665
7666
7667 static void gee_concurrent_set_value_tower_copy_value (const GValue* src_value, GValue* dest_value) {
7668         if (src_value->data[0].v_pointer) {
7669                 dest_value->data[0].v_pointer = gee_concurrent_set_tower_ref (src_value->data[0].v_pointer);
7670         } else {
7671                 dest_value->data[0].v_pointer = NULL;
7672         }
7673 }
7674
7675
7676 static gpointer gee_concurrent_set_value_tower_peek_pointer (const GValue* value) {
7677         return value->data[0].v_pointer;
7678 }
7679
7680
7681 static gchar* gee_concurrent_set_value_tower_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
7682         if (collect_values[0].v_pointer) {
7683                 GeeConcurrentSetTower* object;
7684                 object = collect_values[0].v_pointer;
7685                 if (object->parent_instance.g_class == NULL) {
7686                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
7687                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
7688                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
7689                 }
7690                 value->data[0].v_pointer = gee_concurrent_set_tower_ref (object);
7691         } else {
7692                 value->data[0].v_pointer = NULL;
7693         }
7694         return NULL;
7695 }
7696
7697
7698 static gchar* gee_concurrent_set_value_tower_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
7699         GeeConcurrentSetTower** object_p;
7700         object_p = collect_values[0].v_pointer;
7701         if (!object_p) {
7702                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
7703         }
7704         if (!value->data[0].v_pointer) {
7705                 *object_p = NULL;
7706         } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
7707                 *object_p = value->data[0].v_pointer;
7708         } else {
7709                 *object_p = gee_concurrent_set_tower_ref (value->data[0].v_pointer);
7710         }
7711         return NULL;
7712 }
7713
7714
7715 static GParamSpec* gee_concurrent_set_param_spec_tower (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
7716         GeeConcurrentSetParamSpecTower* spec;
7717         g_return_val_if_fail (g_type_is_a (object_type, GEE_CONCURRENT_SET_TYPE_TOWER), NULL);
7718         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
7719         G_PARAM_SPEC (spec)->value_type = object_type;
7720         return G_PARAM_SPEC (spec);
7721 }
7722
7723
7724 static gpointer gee_concurrent_set_value_get_tower (const GValue* value) {
7725         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_CONCURRENT_SET_TYPE_TOWER), NULL);
7726         return value->data[0].v_pointer;
7727 }
7728
7729
7730 static void gee_concurrent_set_value_set_tower (GValue* value, gpointer v_object) {
7731         GeeConcurrentSetTower* old;
7732         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_CONCURRENT_SET_TYPE_TOWER));
7733         old = value->data[0].v_pointer;
7734         if (v_object) {
7735                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, GEE_CONCURRENT_SET_TYPE_TOWER));
7736                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
7737                 value->data[0].v_pointer = v_object;
7738                 gee_concurrent_set_tower_ref (value->data[0].v_pointer);
7739         } else {
7740                 value->data[0].v_pointer = NULL;
7741         }
7742         if (old) {
7743                 gee_concurrent_set_tower_unref (old);
7744         }
7745 }
7746
7747
7748 static void gee_concurrent_set_value_take_tower (GValue* value, gpointer v_object) {
7749         GeeConcurrentSetTower* old;
7750         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, GEE_CONCURRENT_SET_TYPE_TOWER));
7751         old = value->data[0].v_pointer;
7752         if (v_object) {
7753                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, GEE_CONCURRENT_SET_TYPE_TOWER));
7754                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
7755                 value->data[0].v_pointer = v_object;
7756         } else {
7757                 value->data[0].v_pointer = NULL;
7758         }
7759         if (old) {
7760                 gee_concurrent_set_tower_unref (old);
7761         }
7762 }
7763
7764
7765 static void gee_concurrent_set_tower_class_init (GeeConcurrentSetTowerClass * klass) {
7766         gee_concurrent_set_tower_parent_class = g_type_class_peek_parent (klass);
7767         GEE_CONCURRENT_SET_TOWER_CLASS (klass)->finalize = gee_concurrent_set_tower_finalize;
7768         g_type_class_add_private (klass, sizeof (GeeConcurrentSetTowerPrivate));
7769 }
7770
7771
7772 static void gee_concurrent_set_tower_instance_init (GeeConcurrentSetTower * self) {
7773         self->priv = GEE_CONCURRENT_SET_TOWER_GET_PRIVATE (self);
7774         self->ref_count = 1;
7775 }
7776
7777
7778 static void gee_concurrent_set_tower_finalize (GeeConcurrentSetTower* obj) {
7779         GeeConcurrentSetTower * self;
7780         gint _tmp0_ = 0;
7781         gint height;
7782         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_CONCURRENT_SET_TYPE_TOWER, GeeConcurrentSetTower);
7783         _tmp0_ = gee_concurrent_set_tower_get_height (self);
7784         height = _tmp0_;
7785         {
7786                 guint8 i;
7787                 i = (guint8) 0;
7788                 {
7789                         gboolean _tmp1_;
7790                         _tmp1_ = TRUE;
7791                         while (TRUE) {
7792                                 gboolean _tmp2_;
7793                                 guint8 _tmp4_;
7794                                 gint _tmp5_;
7795                                 guint8 _tmp6_;
7796                                 guint8 _tmp7_;
7797                                 _tmp2_ = _tmp1_;
7798                                 if (!_tmp2_) {
7799                                         guint8 _tmp3_;
7800                                         _tmp3_ = i;
7801                                         i = _tmp3_ + 1;
7802                                 }
7803                                 _tmp1_ = FALSE;
7804                                 _tmp4_ = i;
7805                                 _tmp5_ = height;
7806                                 if (!(((gint) _tmp4_) < _tmp5_)) {
7807                                         break;
7808                                 }
7809                                 _tmp6_ = i;
7810                                 gee_concurrent_set_tower_set_succ (self, NULL, GEE_CONCURRENT_SET_STATE_NONE, _tmp6_);
7811                                 _tmp7_ = i;
7812                                 gee_concurrent_set_tower_set_backlink (self, NULL, _tmp7_);
7813                         }
7814                 }
7815         }
7816         self->_nodes = (g_free (self->_nodes), NULL);
7817         self->_nodes = NULL;
7818         self->_nodes = (g_free (self->_nodes), NULL);
7819         ((self->_data == NULL) || (self->priv->g_destroy_func == NULL)) ? NULL : (self->_data = (self->priv->g_destroy_func (self->_data), NULL));
7820 }
7821
7822
7823 static GType gee_concurrent_set_tower_get_type (void) {
7824         static volatile gsize gee_concurrent_set_tower_type_id__volatile = 0;
7825         if (g_once_init_enter (&gee_concurrent_set_tower_type_id__volatile)) {
7826                 static const GTypeValueTable g_define_type_value_table = { gee_concurrent_set_value_tower_init, gee_concurrent_set_value_tower_free_value, gee_concurrent_set_value_tower_copy_value, gee_concurrent_set_value_tower_peek_pointer, "p", gee_concurrent_set_value_tower_collect_value, "p", gee_concurrent_set_value_tower_lcopy_value };
7827                 static const GTypeInfo g_define_type_info = { sizeof (GeeConcurrentSetTowerClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_concurrent_set_tower_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeConcurrentSetTower), 0, (GInstanceInitFunc) gee_concurrent_set_tower_instance_init, &g_define_type_value_table };
7828                 static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
7829                 GType gee_concurrent_set_tower_type_id;
7830                 gee_concurrent_set_tower_type_id = g_type_register_fundamental (g_type_fundamental_next (), "GeeConcurrentSetTower", &g_define_type_info, &g_define_type_fundamental_info, 0);
7831                 g_once_init_leave (&gee_concurrent_set_tower_type_id__volatile, gee_concurrent_set_tower_type_id);
7832         }
7833         return gee_concurrent_set_tower_type_id__volatile;
7834 }
7835
7836
7837 static gpointer gee_concurrent_set_tower_ref (gpointer instance) {
7838         GeeConcurrentSetTower* self;
7839         self = instance;
7840         g_atomic_int_inc (&self->ref_count);
7841         return instance;
7842 }
7843
7844
7845 static void gee_concurrent_set_tower_unref (gpointer instance) {
7846         GeeConcurrentSetTower* self;
7847         self = instance;
7848         if (g_atomic_int_dec_and_test (&self->ref_count)) {
7849                 GEE_CONCURRENT_SET_TOWER_GET_CLASS (self)->finalize (self);
7850                 g_type_free_instance ((GTypeInstance *) self);
7851         }
7852 }
7853
7854
7855 static GeeConcurrentSetTowerNode* gee_concurrent_set_tower_node_dup (const GeeConcurrentSetTowerNode* self) {
7856         GeeConcurrentSetTowerNode* dup;
7857         dup = g_new0 (GeeConcurrentSetTowerNode, 1);
7858         memcpy (dup, self, sizeof (GeeConcurrentSetTowerNode));
7859         return dup;
7860 }
7861
7862
7863 static void gee_concurrent_set_tower_node_free (GeeConcurrentSetTowerNode* self) {
7864         g_free (self);
7865 }
7866
7867
7868 static GType gee_concurrent_set_tower_node_get_type (void) {
7869         static volatile gsize gee_concurrent_set_tower_node_type_id__volatile = 0;
7870         if (g_once_init_enter (&gee_concurrent_set_tower_node_type_id__volatile)) {
7871                 GType gee_concurrent_set_tower_node_type_id;
7872                 gee_concurrent_set_tower_node_type_id = g_boxed_type_register_static ("GeeConcurrentSetTowerNode", (GBoxedCopyFunc) gee_concurrent_set_tower_node_dup, (GBoxedFreeFunc) gee_concurrent_set_tower_node_free);
7873                 g_once_init_leave (&gee_concurrent_set_tower_node_type_id__volatile, gee_concurrent_set_tower_node_type_id);
7874         }
7875         return gee_concurrent_set_tower_node_type_id__volatile;
7876 }
7877
7878
7879 static void _vala_array_copy2 (GeeConcurrentSetTower** self, GeeConcurrentSetTower** dest) {
7880         int i;
7881         for (i = 0; i < 31; i++) {
7882                 GeeConcurrentSetTower* _tmp0_;
7883                 _tmp0_ = _gee_concurrent_set_tower_ref0 (self[i]);
7884                 dest[i] = _tmp0_;
7885         }
7886 }
7887
7888
7889 static void gee_concurrent_set_tower_iter_copy (const GeeConcurrentSetTowerIter* self, GeeConcurrentSetTowerIter* dest) {
7890         GeeConcurrentSetTower* _tmp0_[31];
7891         gint _tmp0__length1;
7892         _vala_array_copy2 ((*self)._iter, _tmp0_);
7893         _vala_array_destroy ((*dest)._iter, 31, (GDestroyNotify) gee_concurrent_set_tower_unref);
7894         memcpy ((*dest)._iter, _tmp0_, 31 * sizeof (GeeConcurrentSetTower*));
7895 }
7896
7897
7898 static void gee_concurrent_set_tower_iter_destroy (GeeConcurrentSetTowerIter* self) {
7899         _vala_array_destroy ((*self)._iter, 31, (GDestroyNotify) gee_concurrent_set_tower_unref);
7900 }
7901
7902
7903 static GeeConcurrentSetTowerIter* gee_concurrent_set_tower_iter_dup (const GeeConcurrentSetTowerIter* self) {
7904         GeeConcurrentSetTowerIter* dup;
7905         dup = g_new0 (GeeConcurrentSetTowerIter, 1);
7906         gee_concurrent_set_tower_iter_copy (self, dup);
7907         return dup;
7908 }
7909
7910
7911 static void gee_concurrent_set_tower_iter_free (GeeConcurrentSetTowerIter* self) {
7912         gee_concurrent_set_tower_iter_destroy (self);
7913         g_free (self);
7914 }
7915
7916
7917 static GType gee_concurrent_set_tower_iter_get_type (void) {
7918         static volatile gsize gee_concurrent_set_tower_iter_type_id__volatile = 0;
7919         if (g_once_init_enter (&gee_concurrent_set_tower_iter_type_id__volatile)) {
7920                 GType gee_concurrent_set_tower_iter_type_id;
7921                 gee_concurrent_set_tower_iter_type_id = g_boxed_type_register_static ("GeeConcurrentSetTowerIter", (GBoxedCopyFunc) gee_concurrent_set_tower_iter_dup, (GBoxedFreeFunc) gee_concurrent_set_tower_iter_free);
7922                 g_once_init_leave (&gee_concurrent_set_tower_iter_type_id__volatile, gee_concurrent_set_tower_iter_type_id);
7923         }
7924         return gee_concurrent_set_tower_iter_type_id__volatile;
7925 }
7926
7927
7928 static void gee_concurrent_set_class_init (GeeConcurrentSetClass * klass) {
7929         GPrivate* _tmp0_;
7930         gee_concurrent_set_parent_class = g_type_class_peek_parent (klass);
7931         g_type_class_add_private (klass, sizeof (GeeConcurrentSetPrivate));
7932         GEE_ABSTRACT_COLLECTION_CLASS (klass)->iterator = gee_concurrent_set_real_iterator;
7933         GEE_ABSTRACT_COLLECTION_CLASS (klass)->contains = gee_concurrent_set_real_contains;
7934         GEE_ABSTRACT_COLLECTION_CLASS (klass)->add = gee_concurrent_set_real_add;
7935         GEE_ABSTRACT_COLLECTION_CLASS (klass)->remove = gee_concurrent_set_real_remove;
7936         GEE_ABSTRACT_COLLECTION_CLASS (klass)->clear = gee_concurrent_set_real_clear;
7937         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->first = gee_concurrent_set_real_first;
7938         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->last = gee_concurrent_set_real_last;
7939         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->iterator_at = gee_concurrent_set_real_iterator_at;
7940         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->lower = gee_concurrent_set_real_lower;
7941         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->higher = gee_concurrent_set_real_higher;
7942         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->floor = gee_concurrent_set_real_floor;
7943         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->ceil = gee_concurrent_set_real_ceil;
7944         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->head_set = gee_concurrent_set_real_head_set;
7945         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->tail_set = gee_concurrent_set_real_tail_set;
7946         GEE_ABSTRACT_SORTED_SET_CLASS (klass)->sub_set = gee_concurrent_set_real_sub_set;
7947         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_size = gee_concurrent_set_real_get_size;
7948         GEE_ABSTRACT_COLLECTION_CLASS (klass)->get_read_only = gee_concurrent_set_real_get_read_only;
7949         G_OBJECT_CLASS (klass)->get_property = _vala_gee_concurrent_set_get_property;
7950         G_OBJECT_CLASS (klass)->set_property = _vala_gee_concurrent_set_set_property;
7951         G_OBJECT_CLASS (klass)->finalize = gee_concurrent_set_finalize;
7952         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_G_TYPE, g_param_spec_gtype ("g-type", "type", "type", G_TYPE_NONE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
7953         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_G_DUP_FUNC, g_param_spec_pointer ("g-dup-func", "dup func", "dup func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
7954         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_G_DESTROY_FUNC, g_param_spec_pointer ("g-destroy-func", "destroy func", "destroy func", G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
7955         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_SIZE, g_param_spec_int ("size", "size", "size", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
7956         g_object_class_install_property (G_OBJECT_CLASS (klass), GEE_CONCURRENT_SET_READ_ONLY, g_param_spec_boolean ("read-only", "read-only", "read-only", FALSE, G_PARAM_STATIC_NAME | G_PARAM_STATIC_NICK | G_PARAM_STATIC_BLURB | G_PARAM_READABLE));
7957         _tmp0_ = g_private_new (__gee_concurrent_set_rand_lambda37__gdestroy_notify);
7958         gee_concurrent_set_rand = _tmp0_;
7959 }
7960
7961
7962 static void gee_concurrent_set_instance_init (GeeConcurrentSet * self) {
7963         GeeConcurrentSetTower* _tmp0_;
7964         self->priv = GEE_CONCURRENT_SET_GET_PRIVATE (self);
7965         self->priv->_size = 0;
7966         _tmp0_ = gee_concurrent_set_tower_new_head (self->priv->g_type, (GBoxedCopyFunc) self->priv->g_dup_func, self->priv->g_destroy_func);
7967         self->priv->_head = _tmp0_;
7968 }
7969
7970
7971 static void gee_concurrent_set_finalize (GObject* obj) {
7972         GeeConcurrentSet * self;
7973         GeeHazardPointerContext* _tmp0_;
7974         GeeHazardPointerContext* ctx;
7975         self = G_TYPE_CHECK_INSTANCE_CAST (obj, GEE_TYPE_CONCURRENT_SET, GeeConcurrentSet);
7976         _tmp0_ = gee_hazard_pointer_context_new (NULL);
7977         ctx = _tmp0_;
7978         _gee_concurrent_set_tower_unref0 (self->priv->_head);
7979         self->priv->_head = NULL;
7980         _gee_hazard_pointer_context_free0 (ctx);
7981         _gee_concurrent_set_tower_unref0 (self->priv->_head);
7982         (self->priv->_cmp_target_destroy_notify == NULL) ? NULL : (self->priv->_cmp_target_destroy_notify (self->priv->_cmp_target), NULL);
7983         self->priv->_cmp = NULL;
7984         self->priv->_cmp_target = NULL;
7985         self->priv->_cmp_target_destroy_notify = NULL;
7986         G_OBJECT_CLASS (gee_concurrent_set_parent_class)->finalize (obj);
7987 }
7988
7989
7990 /**
7991  * A skip-linked list. This implementation is based on
7992  * [[http://www.cse.yorku.ca/~ruppert/Mikhail.pdf|Mikhail Fomitchev Master Thesis]].
7993  *
7994  * Many threads are allowed to operate on the same structure as well as modification
7995  * of structure during iteration is allowed. However the change may not be immidiatly
7996  * visible to other threads.
7997  */
7998 GType gee_concurrent_set_get_type (void) {
7999         static volatile gsize gee_concurrent_set_type_id__volatile = 0;
8000         if (g_once_init_enter (&gee_concurrent_set_type_id__volatile)) {
8001                 static const GTypeInfo g_define_type_info = { sizeof (GeeConcurrentSetClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) gee_concurrent_set_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (GeeConcurrentSet), 0, (GInstanceInitFunc) gee_concurrent_set_instance_init, NULL };
8002                 GType gee_concurrent_set_type_id;
8003                 gee_concurrent_set_type_id = g_type_register_static (GEE_TYPE_ABSTRACT_SORTED_SET, "GeeConcurrentSet", &g_define_type_info, 0);
8004                 g_once_init_leave (&gee_concurrent_set_type_id__volatile, gee_concurrent_set_type_id);
8005         }
8006         return gee_concurrent_set_type_id__volatile;
8007 }
8008
8009
8010 static void _vala_gee_concurrent_set_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
8011         GeeConcurrentSet * self;
8012         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_CONCURRENT_SET, GeeConcurrentSet);
8013         switch (property_id) {
8014                 case GEE_CONCURRENT_SET_SIZE:
8015                 g_value_set_int (value, gee_abstract_collection_get_size ((GeeAbstractCollection*) self));
8016                 break;
8017                 case GEE_CONCURRENT_SET_READ_ONLY:
8018                 g_value_set_boolean (value, gee_abstract_collection_get_read_only ((GeeAbstractCollection*) self));
8019                 break;
8020                 default:
8021                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
8022                 break;
8023         }
8024 }
8025
8026
8027 static void _vala_gee_concurrent_set_set_property (GObject * object, guint property_id, const GValue * value, GParamSpec * pspec) {
8028         GeeConcurrentSet * self;
8029         self = G_TYPE_CHECK_INSTANCE_CAST (object, GEE_TYPE_CONCURRENT_SET, GeeConcurrentSet);
8030         switch (property_id) {
8031                 case GEE_CONCURRENT_SET_G_TYPE:
8032                 self->priv->g_type = g_value_get_gtype (value);
8033                 break;
8034                 case GEE_CONCURRENT_SET_G_DUP_FUNC:
8035                 self->priv->g_dup_func = g_value_get_pointer (value);
8036                 break;
8037                 case GEE_CONCURRENT_SET_G_DESTROY_FUNC:
8038                 self->priv->g_destroy_func = g_value_get_pointer (value);
8039                 break;
8040                 default:
8041                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
8042                 break;
8043         }
8044 }
8045
8046
8047 static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
8048         if ((array != NULL) && (destroy_func != NULL)) {
8049                 int i;
8050                 for (i = 0; i < array_length; i = i + 1) {
8051                         if (((gpointer*) array)[i] != NULL) {
8052                                 destroy_func (((gpointer*) array)[i]);
8053                         }
8054                 }
8055         }
8056 }
8057
8058
8059 static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
8060         _vala_array_destroy (array, array_length, destroy_func);
8061         g_free (array);
8062 }
8063
8064
8065