oneliner 0.2.7 → 0.3.0

data/README

@@ -5,14 +5,15 @@ See http://en.wikipedia.org/wiki/Online_codes
 == Dependencies:
 
 Oneliner::SuperString:: openssl: http://www.openssl.org/
+Oneliner::SuperString:: glib: http://www.gtk.org/download/
 
 == Sub packages:
 
-Oneliner::SuperString:: A String subclass that has the added power of Online Coding.
+Oneliner::SuperString:: A class that has the super power of Online Coding.
 
 == Usage:
 
-You create Oneliner::SuperStrings just regular Strings, then you use Oneliner::SuperString#encode(size_of_chunk) to get Online Coded data from them.
+You create Oneliner::SuperStrings with a regular String as argument, then you use Oneliner::SuperString#encode(size_of_chunk) to get Online Coded data from them.
 
 Then you use Oneliner::SuperString#decode!(chunk) on a new Oneliner::SuperString to recreate the data from the original String. Only a few extra percent (around 10 - my randomness seems to be suboptimal) is needed to recreate the original data this way.
 
@@ -30,8 +31,5 @@ Then you use Oneliner::SuperString#decode!(chunk) on a new Oneliner::SuperString
  redundant_packages << s2.encode(256)
  redundant_packages << s2.encode(256)
  redundant_packages << s2.encode(256)
- index = 0
- while index < redundant_packages.size && !s.decode!(redundant_packages[index])
-   index += 1
- end
+ nil while s.decode!(redundant_packages.shift)
  assert_equal(s2, s)

data/ext/extconf.rb

@@ -28,6 +28,28 @@ unless have_library('ssl')
   crash "libssl needed"
 end
 
-dir_config("oneliner_ext")
+unless find_executable("pkg-config")
+  crash("pkg-config needed")
+end
+
+unless have_library('glib-2.0')
+  crash "libglib-2.0 needed"
+end
+
+if ARGV.include?("-d")
+  $CFLAGS += " -D ONELINER_DEBUG" 
+end
+
+if ARGV.include?("-O0")
+  $CFLAGS.gsub!(/-O./, "-O0")
+else
+  $CFLAGS.gsub!(/-O./, "-O3")
+end
+
+if ARGV.include?("-gdb")
+  $CFLAGS += " -g -gdwarf-2 -g3"
+end
+
+$CFLAGS += " " + `pkg-config --cflags --libs glib-2.0`.strip
 
-create_makefile("oneliner_ext")
+create_makefile("oneliner")

data/ext/oneliner.c

@@ -0,0 +1,1780 @@
+// Archipelago - a distributed computing toolkit for ruby
+// Copyright (C) 2007  Martin Kihlgren <zond at troja dot ath dot cx>
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// as published by the Free Software Foundation; either version 2
+// of the License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+//
+// Interested in how the hell this load of bollocks works?
+// Begin by reading up on online codes at http://en.wikipedia.org/wiki/Online_codes, then
+// read doc/architecture.txt in this repository.
+//
+
+#include "ruby.h"
+#include <limits.h>
+#include <openssl/aes.h>
+#include <glib.h>
+#include <stdlib.h>
+#include <math.h>
+#include <sys/time.h>
+#include "oneliner.h"
+
+//
+// The classes
+//
+
+// The Oneliner::SuperString class, the one that does all the actual job.
+static VALUE rb_superstring;
+// The Oneliner::Chunk class, only for debugging purposes.
+static VALUE rb_chunk;
+
+//
+// Utility macros.
+//
+
+//
+// If we have debug turned on when compiling, lets do stuff with all these debug macros.
+//
+#ifdef ONELINER_DEBUG
+// The indentation of DBEUG messages.
+static guint32 DEBUG_indentation = 0;
+// Only execute s if debugging.
+#define IFDEBUG(s) s
+// Make the indentation of normal DEBUG messages one greater.
+#define INDENT indentation++;
+// Make the indentation of normal DEBUG messages one less.
+#define UNINDENT indentation--;
+// Warn if x is NULL.
+#define NULL_WARN(x) if ((x) == NULL) DEBUG("x is NULL!!!");
+// Indent DEBUG_indentation spaces and print the debug message.
+#define DEBUG(s, ...) {							\
+    guint32 _indentation_tmp;						\
+    fprintf(stderr, "DEBUG: ");						\
+    for (indentation_tmp = 0; indentation_tmp < DEBUG_indentation; indentation_tmp++) fprintf(stderr, " "); \
+    fprintf(stderr, s, ## __VA_ARGS__);					\
+    fprintf(stderr, "\n");						\
+    fflush(NULL); }
+// Print out the byte in str of length len as zeroes and ones.
+#define BITSTRING_DEBUG(msg,str,len) {					\
+    fprintf(stderr, "DEBUG: %s: ", (msg));				\
+    rb_funcall(rb_const_get(rb_cObject, rb_intern("Kernel")),		\
+	       rb_intern("print"),					\
+	       1,							\
+	       rb_funcall(rb_funcall(rb_funcall(rb_str_new((gchar *) (str), (len)), \
+						rb_intern("unpack"),	\
+						1,			\
+						rb_str_new2("b*")),	\
+				     rb_intern("first"),		\
+				     0),				\
+			  rb_intern("gsub"),				\
+			  2,						\
+			  rb_funcall(rb_const_get(rb_cObject, rb_intern("Regexp")), \
+				     rb_intern("new"),			\
+				     1,					\
+				     rb_str_new2("(.{4,4})")),		\
+			  rb_str_new2("\\1,")));			\
+    fprintf(stderr, "\n");						\
+    fflush(NULL); }
+// Print out the text in str of length len as a ruby inspected string.
+#define STRING_DEBUG(msg,str,len) {					\
+    fprintf(stderr, "DEBUG: %s: ", (msg));				\
+    rb_funcall(rb_const_get(rb_cObject, rb_intern("Kernel")), rb_intern("print"), 1, rb_funcall(rb_str_new((gchar *) (str), (len)), rb_intern("inspect"), 0)); \
+    fprintf(stderr, "\n");						\
+    fflush(NULL); }
+//
+// If we dont have debug turned on while compiling, just replace them with empty semicolons so as not to confuse the compiler.
+//
+#else
+#define INDENT ;
+#define UNINDENT ;
+#define DEBUG(s, ...) ;
+#define BITSTRING_DEBUG(msg,str,len) ;
+#define IFDEBUG(s) ;
+#endif
+
+//
+// Just iterate over ary freeing all content.
+//
+#define FREE_ARRAY_WITH_STRINGS(ary) {					\
+    guint32 _free_ary_with_strings_int;					\
+    for (_free_ary_with_strings_int = 0;				\
+	 _free_ary_with_strings_int < (ary)->len;			\
+	 _free_ary_with_strings_int++) {				\
+      if (g_array_index((ary), guint8 *, _free_ary_with_strings_int) != NULL) \
+	g_free(g_array_index((ary), guint8 *, _free_ary_with_strings_int)); \
+    }									\
+    g_array_free(ary, TRUE);						\
+  }
+// Returns the number of characters needed to print out the number i as a decimal number.
+#define CHARS_FOR(i) ((guint32) (log10((gdouble) (i))) + 1)
+// Returns a random number between 0 and max.
+#define RANDOM(context,max) (oneliner_context_random(context) % (max))
+// Returns a random float between >=0 and < 1.
+#define RANDFLOAT(context) ( (gdouble) ( (guint32) oneliner_context_random(context) ) ) / ( (gdouble) G_MAXUINT32 )
+// Will define a oneliner_superstring * named str and fetch the pointer from rb_obj into it.
+#define RB_ONELINER(rb_obj,str)				\
+  oneliner_superstring *str;				\
+  Data_Get_Struct(rb_obj, oneliner_superstring, str);
+// Will allocate a zeroed string of len characters for dst and copy src into it.
+#define ALLOC_COPY8(dst,src,len) {			\
+    (dst) = g_new0(guint8, (len) + 1);			\
+    memcpy((dst), (src), sizeof(guint8) * (len)); }
+
+// The Q constant of the algorithm (see http://en.wikipedia.org/wiki/Online_codes)
+#define Q 3
+// The E constant of the algorithm (see http://en.wikipedia.org/wiki/Online_codes)
+#define E 0.01
+
+//
+// The c representation of a superstring.
+//
+typedef struct {
+  // The data_blocks of this superstring.
+  GArray *data_blocks;
+  // The aux blocks of this superstring.
+  GArray *aux_blocks;
+  // Our graph of check blocks.
+  GArray *check_block_graph;
+  // Our graph of aux blocks for the source blocks.
+  GArray *aux_block_graph;
+  // Our graph of aux blocks for the aux blocks themselves.
+  GArray *known_aux_blocks;
+  // The list of found blocks to analyze.
+  GList *to_analyze;
+  // The list of xor_blocks to free.
+  GList *to_free;
+  // The size of each block in bits.
+  guint32 block_size;
+  // The number of guint8's needed to contain those bits.
+  guint32 n_chars_in_block;
+  // The length of the original data.
+  guint32 data_len;
+  // The number of data_blocks needed to contain that data.
+  guint32 n_data_blocks_needed;
+  // The number of bytes needed to store those data_blocks.
+  guint32 n_bytes_for_data_blocks;
+  // The number of aux blocks needed for those blocks.
+  guint32 n_aux_blocks_needed;
+  // The number of check blocks we have decoded so far.
+  guint32 n_seen_check_blocks;
+  // Whether we have decided already that we are done decoding.
+  gboolean decode_done;
+} oneliner_superstring;
+
+//
+// An as yet mysterious block.
+//
+typedef struct {
+  gboolean initialized;
+  guint8 *sum;
+  GHashTable *source_blocks;
+  oneliner_superstring *str;
+  gint32 index;
+} oneliner_xor_block;
+
+//
+// An insertion to do into the graph of a superstring.
+//
+typedef struct {
+  guint32 source_block_nr;
+  oneliner_xor_block *check_block;
+} oneliner_graph_insertion;
+
+//
+// A random context.
+//
+typedef guint8 oneliner_context;
+
+// Just to solve a few dependency problems between the functions.
+static guint8 *
+oneliner_superstring_get_combined_block(oneliner_superstring *str, guint32 block_nr);
+static void
+oneliner_superstring_analyze(oneliner_superstring *str, guint32 found_block_nr);
+
+//
+// Encrypt the context again
+//
+static void
+oneliner_context_randomize(oneliner_context *context)
+{
+  AES_KEY key;
+
+  AES_set_encrypt_key((guint8 *) "0123456789012345", 128, &key);
+
+  AES_encrypt((guint8 *) context + 4, 
+	      (guint8 *) context + 4, 
+	      &key);
+  * (guint32 *) context = 1;
+}
+
+//
+// Fill the buffer of context with seed and randomize it.
+//
+static gint32
+oneliner_context_seed(oneliner_context *context, gint32 seed)
+{
+  gint32 tmp;
+
+  for (tmp = 1; tmp < 5; tmp++)
+    ( (gint32 *) context )[tmp] = seed;
+
+  oneliner_context_randomize(context);
+
+  return seed;
+}
+
+//
+// Return an int that is the next random in the context
+//
+static gint32
+oneliner_context_random(oneliner_context *context)
+{
+  gint32 *int_context = (gint32 *) context;
+  if (int_context[0] < 5) {
+    gint32 return_value = int_context[int_context[0]];
+    int_context[0]++;
+    return return_value;
+  } else {
+    oneliner_context_randomize(context);
+    return oneliner_context_random(context);
+  }
+}
+
+//
+// Initialize a context.
+//
+static oneliner_context *
+oneliner_context_new()
+{
+  return (oneliner_context *) g_new0(guint8, 4 * 5);
+}
+
+//
+// Get a random degree
+//
+static guint32
+oneliner_context_get_degree(oneliner_context *context)
+{
+  gdouble f;
+  guint32 tmp = 0;
+  
+  f = RANDFLOAT(context);
+  while (f > 0) {
+    tmp++;
+    f = f - P[tmp];
+  }
+  return tmp;
+}
+
+//
+// Make object into object ^ subject
+//
+static void
+oneliner_string_xor(guint8 *object, guint8 *subject, guint32 len)
+{
+  guint32 tmp;
+
+#ifdef G_HAVE_GINT64
+  for (tmp = 0; tmp < len / 8; tmp++)
+    ( (guint64 *) object )[tmp] = ( (guint64 *) object )[tmp] ^ ( (guint64 *) subject )[tmp];
+  for (tmp = tmp * 2; tmp < len / 4; tmp++)
+    ( (guint32 *) object )[tmp] = ( (guint32 *) object )[tmp] ^ ( (guint32 *) subject )[tmp];
+  for (tmp = tmp * 4; tmp < len; tmp++)
+    object[tmp] = object[tmp] ^ subject[tmp];
+#else
+  for (tmp = 0; tmp < len / 4; tmp++)
+    ( (guint32 *) object )[tmp] = ( (guint32 *) object )[tmp] ^ ( (guint32 *) subject )[tmp];
+  for (tmp = tmp * 4; tmp < len; tmp++)
+    object[tmp] = object[tmp] ^ subject[tmp];
+#endif
+}
+
+//
+// Ruby wrapper for oneliner_string_xor. Will make the self String into self ^ the object String.
+// 
+static VALUE
+rb_oneliner_string_xor(VALUE self, VALUE object)
+{
+  Check_Type(object, T_STRING);
+  rb_str_modify(self);
+  oneliner_string_xor((guint8 *) RSTRING(self)->ptr, (guint8 *) RSTRING(object)->ptr, MIN(RSTRING(self)->len, RSTRING(object)->len));
+  return self;
+}
+
+//
+// Iterator used in the hash inspector.
+//
+static void
+oneliner_int_hash_debug_iterator(gpointer key, gpointer value, gpointer user_data)
+{
+  gchar **buf = (gchar **) user_data;
+  guint32 key_int = GPOINTER_TO_UINT(key);
+  guint32 value_int = GPOINTER_TO_UINT(value);
+  guint32 extra_size_needed = CHARS_FOR(key_int) + CHARS_FOR(value_int) + 6 + 1;
+  guint32 new_size_needed = strlen(*buf) + extra_size_needed;
+  *buf = g_realloc(*buf, new_size_needed);
+  snprintf(*buf + strlen(*buf), extra_size_needed, "%i => %i, ", key_int, value_int);
+}
+
+//
+// A hash inspector for GHashTables that considers all hashes as storing ints.
+//
+static gchar *
+oneliner_int_hash_to_s(GHashTable *hash)
+{
+  gchar *buf;
+  gchar *base = "<GHashTable: size='' data='";
+  guint32 size_needed = strlen(base) + CHARS_FOR(g_hash_table_size(hash)) + CHARS_FOR(G_MAXUINT32) + 1;
+  buf = g_new(gchar, size_needed);
+  snprintf(buf, size_needed, "<GHashTable:%i size='%i' data='", GPOINTER_TO_UINT(hash), g_hash_table_size(hash));
+  g_hash_table_foreach(hash, oneliner_int_hash_debug_iterator, &buf);
+  size_needed = strlen(buf) + 3;
+  buf = g_realloc(buf, size_needed);
+  snprintf(buf + strlen(buf), 3, "'>");
+  return buf;
+}
+
+//
+// Prints out an inspection of hash.
+//
+static void
+oneliner_int_hash_debug(GHashTable *hash)
+{
+  gchar *s = oneliner_int_hash_to_s(hash);
+  DEBUG(s);
+  g_free(s);
+}
+
+// Returns if this xor_block is finished.
+#define XOR_BLOCK_FINISHED(xor_block) ((xor_block)->initialized && \
+				       (g_hash_table_size((xor_block)->source_blocks) == 1) && \
+				       ((oneliner_xor_block_last_uses((xor_block)) % 2) == 1))
+// Returns if this xor_block is empty.
+#define XOR_BLOCK_EMPTY(xor_block) (g_hash_table_size((xor_block)->source_blocks) == 0)
+// Returns if this xor_block is an aux block.
+#define XOR_BLOCK_IS_AUX(xor_block) ((xor_block)->index > -1)
+// Returns if this xor_block is a check block.
+#define XOR_BLOCK_IS_CHECK(xor_block) ((xor_block)->index == -1)
+// Returns a constant string for the type of this xor_block.
+#define XOR_TYPE(xor_block) (XOR_BLOCK_IS_AUX((xor_block)) ? "aux_block" : "check_block")
+
+//
+// An inspector for xor_blocks.
+//
+static gchar *
+oneliner_xor_block_to_s(oneliner_xor_block *xor_block)
+{
+  gchar *rval;
+  gchar *source_blocks_buf;
+  gchar *base = "<xor_block: type='' index='' initialized='' sum='' source_blocks='";
+  guint32 size_needed = strlen(base) + 1 + 1 + CHARS_FOR(xor_block->index) + 1 + xor_block->str->n_chars_in_block + CHARS_FOR(G_MAXUINT32) + 1 + strlen(XOR_TYPE(xor_block));
+  rval = g_new(gchar, size_needed);
+  snprintf(rval, size_needed, "<xor_block:%i type='%s' index='%i' initialized='%i' sum='%i' source_blocks='", GPOINTER_TO_UINT(xor_block), XOR_TYPE(xor_block), xor_block->index, xor_block->initialized, *(xor_block->sum));
+  source_blocks_buf = oneliner_int_hash_to_s(xor_block->source_blocks);
+  size_needed = strlen(rval) + strlen(source_blocks_buf) + 4;
+  rval = g_realloc(rval, size_needed);
+  sprintf(rval + strlen(rval), "%s'>", source_blocks_buf);
+  g_free(source_blocks_buf);
+  return rval;
+}
+
+//
+// Prints out an inspection for this xor_block.
+//
+static void
+oneliner_xor_block_debug(oneliner_xor_block *xor_block)
+{
+  gchar *s = oneliner_xor_block_to_s(xor_block);
+  DEBUG(s);
+  g_free(s);
+}
+
+//
+// Allocates a new xor_block containing data of len, which is initialized and bound to str at index.
+//
+static oneliner_xor_block *
+oneliner_xor_block_new(guint8 *data, guint32 len, gboolean initialized, oneliner_superstring *str, gint32 index)
+{
+  oneliner_xor_block *rval = g_new0(oneliner_xor_block, 1);
+  ALLOC_COPY8(rval->sum, data, len);
+  rval->initialized = initialized;
+  rval->source_blocks = g_hash_table_new(NULL, NULL);
+  rval->str = str;
+  rval->index = index;
+  return rval;
+}
+
+//
+// Remove the dependency on the source_block_nr from ary for this xor_block.
+//
+static void
+oneliner_xor_block_free_and_remove_from_array(oneliner_xor_block *xor_block, GArray *ary, guint32 source_block_nr)
+{
+  GHashTable *hash;
+
+  if (ary != NULL) {
+    if ((hash = g_array_index(ary, GHashTable *, source_block_nr)) != NULL) {
+      if (g_hash_table_lookup_extended(hash, xor_block, NULL, NULL)) {
+	g_hash_table_remove(hash, xor_block);
+      } else {
+	DEBUG("it doesnt exist as a dependency :/ dependencies are:");
+	rb_raise(rb_eRuntimeError, "We have a serious problem with the internal state, an xor_block that depended on a data/aux block wasnt referenced back!");
+      }
+    } else {
+      DEBUG("no hash for that source block exists :/");
+      rb_raise(rb_eRuntimeError, "We have a serious problem with the internal state, the source block for an xor_block that we want to remove as a dependency doesnt have a dependency hash!"); 
+    }
+  } else {
+    DEBUG("no array exists :/");
+    rb_raise(rb_eRuntimeError, "We have a serious problem with the internal state, the oneliner_superstring an xor_block is attached to doesnt have the array we want to remove the dependencies of the xor_block from!");
+  }
+}
+
+//
+// Iterator for the freeing of xor_blocks.
+//
+// Will remove the dependency from the proper array in the oneliner_superstring of
+// this xor_block depending on it being aux or check block.
+//
+static void
+oneliner_xor_block_free_and_remove(gpointer key, gpointer data, gpointer user_data)
+{
+  guint32 source_block_nr = GPOINTER_TO_UINT(key);
+  oneliner_xor_block *xor_block = (oneliner_xor_block *) user_data;
+  
+  INDENT;
+
+  if (XOR_BLOCK_IS_CHECK(xor_block)) {
+    DEBUG("removing _%i_ as a dependency from it in check_block_graph", source_block_nr);
+    oneliner_xor_block_free_and_remove_from_array(xor_block, xor_block->str->check_block_graph, source_block_nr);
+  } else {
+    DEBUG("removing _%i_ as a dependency from it in aux_block_graph", source_block_nr);
+    oneliner_xor_block_free_and_remove_from_array(xor_block, xor_block->str->aux_block_graph, source_block_nr);
+  }
+
+  UNINDENT;
+}
+
+//
+// Free the xor_block, and if free_dependencies also remove all its dependencies from the arrays
+// of its oneliner_superstring.
+//
+static void
+oneliner_xor_block_free(oneliner_xor_block *xor_block, gboolean free_dependencies)
+{
+  INDENT;
+  DEBUG("freeing %s %i", XOR_TYPE(xor_block), GPOINTER_TO_UINT(xor_block));
+  g_free(xor_block->sum);
+  if (free_dependencies) {
+    g_hash_table_foreach(xor_block->source_blocks, oneliner_xor_block_free_and_remove, xor_block);
+  }
+  g_hash_table_destroy(xor_block->source_blocks);
+  if (free_dependencies && XOR_BLOCK_IS_AUX(xor_block) && xor_block->str->known_aux_blocks != NULL)
+    g_array_index(xor_block->str->known_aux_blocks, oneliner_xor_block *, xor_block->index) = NULL;
+  g_free(xor_block);
+  UNINDENT;
+}
+
+//
+// Add a dependency for source_block_nr for this xor_block.
+//
+static void
+oneliner_xor_block_add(oneliner_xor_block *xor_block, guint32 source_block_nr)
+{
+  g_hash_table_insert(xor_block->source_blocks,
+		      GUINT_TO_POINTER(source_block_nr),
+		      GUINT_TO_POINTER(GPOINTER_TO_UINT(g_hash_table_lookup(xor_block->source_blocks, 
+									    GUINT_TO_POINTER(source_block_nr))) + 1));
+}
+
+//
+// Set the sum of this xor_block to sum of length len. Will also set the xor_block to initialized.
+//
+static void
+oneliner_xor_block_set_sum(oneliner_xor_block *xor_block, guint8 *sum, guint32 len)
+{
+  oneliner_string_xor(xor_block->sum, sum, len);
+  xor_block->initialized = TRUE;
+}
+
+//
+// The iterator used by xor_block_last_source_block.
+//
+static void
+oneliner_xor_block_last_source_block_nr_iterator(gpointer key, gpointer data, gpointer user_data)
+{
+  * (guint32 *) user_data = GPOINTER_TO_UINT(key);
+}
+
+//
+// Returns the last source_block_nr that this xor_block depends on.
+//
+static guint32
+oneliner_xor_block_last_source_block_nr(oneliner_xor_block *xor_block)
+{
+  guint32 source_block_nr;
+  g_hash_table_foreach(xor_block->source_blocks, oneliner_xor_block_last_source_block_nr_iterator, &source_block_nr);
+  return source_block_nr;
+}
+
+//
+// The iterator used by xor_block_last_uses.
+//
+static void
+oneliner_xor_block_last_uses_iterator(gpointer key, gpointer data, gpointer user_data)
+{
+  * (guint32 *) user_data = GPOINTER_TO_UINT(data);
+}
+
+//
+// Returns the number of times this xor_block depends on its last source block.
+//
+static guint32
+oneliner_xor_block_last_uses(oneliner_xor_block *xor_block)
+{
+  guint32 uses;
+  g_hash_table_foreach(xor_block->source_blocks, oneliner_xor_block_last_uses_iterator, &uses);
+  return uses;
+}
+
+//
+// XOR the sum of xor_block with found_block_nr from the oneliner_superstring of xor_block the
+// requisite nr of times and then remove the dependency.
+//
+static void
+oneliner_xor_block_apply(oneliner_xor_block *xor_block, guint32 found_block_nr)
+{
+  guint32 uses;
+  guint32 tmp;
+
+  INDENT;
+  uses = GPOINTER_TO_UINT(g_hash_table_lookup(xor_block->source_blocks, GUINT_TO_POINTER(found_block_nr)));
+
+  if (uses < 1) {
+    DEBUG("its not used by this xor_block!!! :O");
+    IFDEBUG(oneliner_xor_block_debug(xor_block));
+    rb_raise(rb_eRuntimeError, "We have a serious problem with the internal state, the source block being applied to an xor_block doesnt seem to be included in it!");
+  }
+
+  if (uses % 2 == 1)
+    oneliner_string_xor(xor_block->sum, oneliner_superstring_get_combined_block(xor_block->str, found_block_nr), xor_block->str->n_chars_in_block);
+
+  g_hash_table_remove(xor_block->source_blocks, GUINT_TO_POINTER(found_block_nr));
+  UNINDENT;
+}
+
+//
+// Create a new graph_insertion of check_block for source_block_nr.
+//
+static oneliner_graph_insertion *
+oneliner_graph_insertion_new(oneliner_xor_block *check_block, guint32 source_block_nr)
+{
+  oneliner_graph_insertion *rval = g_new0(oneliner_graph_insertion, 1);
+  rval->check_block = check_block;
+  rval->source_block_nr = source_block_nr;
+  return rval;
+}
+
+//
+// Remove this graph insertion for block_nr and insertion, and remove its xor_block without
+// going for its dependencies (which shouldnt exist, anyway).
+//
+static gboolean
+oneliner_graph_insertion_free_with_check_block(gpointer block_nr, gpointer insertion, gpointer user_data)
+{
+  oneliner_xor_block_free(( (oneliner_graph_insertion *) insertion )->check_block, FALSE);
+  g_free(insertion);
+  return TRUE;
+}
+
+//
+// Insert the given insertion into the given oneliner_superstring.
+//
+static gboolean
+oneliner_insertion_execute(gpointer block_nr, gpointer insertion, gpointer string)
+{
+  oneliner_graph_insertion *ins = (oneliner_graph_insertion *) insertion;
+  oneliner_superstring *str = (oneliner_superstring *) string;
+  GHashTable *hash;
+
+  INDENT;
+  DEBUG("inserting check_block %i as a dependency for block _%i_", GPOINTER_TO_UINT(ins->check_block), ins->source_block_nr);
+
+  if ((hash = g_array_index(str->check_block_graph, GHashTable *, ins->source_block_nr)) == NULL) {
+    hash = g_array_index(str->check_block_graph, GHashTable *, ins->source_block_nr) = g_hash_table_new(NULL, NULL);
+  }
+
+  g_hash_table_insert(hash, ins->check_block, GUINT_TO_POINTER(ins->source_block_nr));
+
+  g_free(insertion);
+  UNINDENT;
+  return TRUE;
+}
+
+
+//
+// Return the block size in bits for a string of the given length.
+//
+static guint32
+oneliner_superstring_get_block_size(guint32 len) {
+  if (len < 1024) {
+    return (guint32) ceil((len / 1024.0) * 8.0);
+  } else {
+    return ((len / 128) / 8) * 8;
+  }
+}
+
+//
+// Fill *block with a block_size (bitwise) piece of *data from pos (bitwise).
+//
+static void
+oneliner_superstring_get_block_from_data(guint8 *data, guint32 pos, guint32 block_size, guint8 *block)
+{
+  //
+  // Block sizes 1-7 are tricky, 
+  // but all other sizes are divisible by 8 and therefore ok to do with a simple memcpy.
+  //
+  if (block_size < 8) {
+    // If the whole block fits within one char then we cant assume that we have permission
+    // to read the char after it, but if it DOESNT then we MUST assume that we have permission
+    // to read the char after it. Therefore the below fork where we read a char or a short from the data.
+    if ((pos + block_size - 1) / 8 == pos / 8) {
+      *block = data[pos / 8];
+      *block = *block << (8 - ((pos + block_size) % 8)) % 8;
+      *block = *block >> 8 - block_size;
+    } else {
+      guint16 short_containing_block = * (guint16 *) (data + (pos / 8));
+      short_containing_block = short_containing_block << (8 - ((pos + block_size) % 8)) % 8;
+      short_containing_block = short_containing_block >> 16 - block_size;
+      *block = (guint8) short_containing_block;
+    }
+  } else {
+    memcpy(block, data + (pos / 8), sizeof(guint8) * (block_size / 8));
+  }
+}
+
+//
+// Take *data and return a GArray * with all the block_size blocks it contains.
+// Needs hints as to how many bytes we need to contain all blocks, how long *data is,
+// how many chars each block needs and how many blocks we need in total.
+//
+static GArray *
+oneliner_superstring_build_blocks_from_data(guint32 n_bytes_for_blocks,
+					    guint32 data_len,
+					    guint32 block_size,
+					    guint32 n_chars_in_block,
+					    guint32 n_blocks_needed,
+					    guint8 *data)
+{
+  guint32 block_nr;
+  guint8 *tmp_block;
+  guint8 tmp_data[n_bytes_for_blocks];
+  GArray *rval = g_array_new(FALSE, FALSE, sizeof(guint8 *));
+
+  g_array_set_size(rval, n_blocks_needed);
+  memcpy((gchar *) tmp_data, (gchar *) data, sizeof(guint8) * data_len);
+  for (block_nr = 0; block_nr < n_blocks_needed; block_nr++) {
+    guint32 pos = block_nr * block_size;
+    tmp_block = g_new0(guint8, n_chars_in_block + 1);
+    oneliner_superstring_get_block_from_data(tmp_data, pos, block_size, tmp_block);
+    g_array_index(rval, guint8 *, block_nr) = tmp_block;
+  }
+
+  return rval;
+}
+					    
+
+//
+// Ensure that str->data_blocks contains a GArray with all the data_blocks of this data.
+//
+static void
+oneliner_superstring_build_data_blocks(oneliner_superstring *str, guint8 *data)
+{
+  str->data_blocks = oneliner_superstring_build_blocks_from_data(str->n_bytes_for_data_blocks,
+							    str->data_len,
+							    str->block_size,
+							    str->n_chars_in_block,
+							    str->n_data_blocks_needed,
+							    data);
+}
+
+//
+// Take the block_size (bitwise) content of *block and insert it in *data at block_nr.
+//
+static void
+oneliner_superstring_set_data_from_block(guint8 *data, guint32 block_nr, guint32 block_size, guint8 *block)
+{
+  //
+  // If the block size is less than 8 then we have some tricky business, otherwise
+  // we know that it is a multiple of 8, which makes it into a simple memcpy.
+  //
+  if (block_size < 8) {
+    // If the entire block fits within one byte then we can not assume that we can write
+    // the byte after, but if it doesnt then we MUST assume that we CAN write the byte
+    // after, therefore the below fork where we write a char or a long depending.
+    if ((block_nr * block_size) / 8 == (((block_nr + 1) * block_size) - 1) / 8) {
+      // Set the byte we want to write to the block content.
+      guint8 byte_to_write = *block;
+      // Left shift it enough so that it matches the segment of data we want to write.
+      byte_to_write = byte_to_write << (block_nr * block_size) % 8;
+      // Then OR the corresponding byte in the data with the byte to write. Since
+      // the data is supposed to be initialized with zeroes this ought to do the trick.
+      data[(block_nr * block_size) / 8] = data[(block_nr * block_size) / 8] | byte_to_write;
+    } else {
+      // Set the short we want to write to the block content.
+      guint16 short_to_write = (guint16) *block;
+      // Left shift it enough so that it matches the segment of data we want to write.
+      short_to_write = short_to_write << (block_nr * block_size) % 8;
+      // Then OR the corresponding short in the data with the short to write. Since
+      // the data is supposed to be initialized with zeroes this ought to do the trick.
+      * (guint16 *) (data + (block_nr * block_size) / 8) = * (guint16 *) (data + (block_nr * block_size) / 8) | short_to_write;
+    }
+  } else {
+    memcpy((gchar *) data + (block_nr * (block_size / 8)), (gchar *) block, sizeof(guint8) * (block_size / 8));
+  }
+}
+
+//
+// Take the given blocks of size block_size needing n_bytes_for_blocks to be stored completely and
+// concatenate them into a string, then return the first data_len bytes of the result.
+//
+// If prepend_size is larger than 0 then the prepend string will be prepended to the result.
+//
+static guint8 *
+oneliner_superstring_build_data_from_blocks(guint32 n_bytes_for_blocks, 
+					    guint32 data_len, 
+					    guint32 block_size, 
+					    GArray *blocks,
+					    guint32 prepend_size,
+					    guint8 *prepend)
+{
+  guint32 index;
+  guint8 *tmp_data = g_new0(guint8, n_bytes_for_blocks + prepend_size + 1);
+  for (index = 0; index < blocks->len; index++) {
+    oneliner_superstring_set_data_from_block(tmp_data + prepend_size, index, block_size, g_array_index(blocks, guint8 *, index));
+  }
+  memcpy((gchar *) tmp_data, (gchar *) prepend, sizeof(guint8) * prepend_size);
+  return g_realloc(tmp_data, data_len);
+}
+
+//
+// Return the guint8 * that the given *str describes with its data_blocks.
+//
+static guint8 *
+oneliner_superstring_build_data(oneliner_superstring *str)
+{
+  return oneliner_superstring_build_data_from_blocks(str->n_bytes_for_data_blocks,
+						     str->data_len,
+						     str->block_size,
+						     str->data_blocks,
+						     0,
+						     NULL);
+}
+
+//
+// Create the aux_blocks GArray for *str using its blocks and length.
+//
+static void
+oneliner_superstring_build_aux_blocks(oneliner_superstring *str)
+{
+  guint32 tmp;
+  oneliner_context *context = oneliner_context_new();
+
+  oneliner_context_seed(context, (gint32) str->data_len);
+  str->aux_blocks = g_array_new(FALSE, TRUE, sizeof(guint8 *));
+  g_array_set_size(str->aux_blocks, str->n_aux_blocks_needed);
+
+  for (tmp = 0; tmp < str->n_data_blocks_needed; tmp++) {
+    guint32 tmp2;
+    DEBUG("selecting aux_blocks for data block _%i_ (%i)", tmp, *g_array_index(str->data_blocks, gchar *, tmp));
+    for (tmp2 = 0; tmp2 < Q; tmp2++) {
+      guint32 aux_block_nr = (guint32) RANDOM(context, str->n_aux_blocks_needed);
+      if (g_array_index(str->aux_blocks, guint *, aux_block_nr) == NULL) {
+	ALLOC_COPY8(g_array_index(str->aux_blocks, guint8 *, aux_block_nr), 
+		    g_array_index(str->data_blocks, gchar *, tmp),
+		    str->n_chars_in_block);
+      } else {
+	oneliner_string_xor(g_array_index(str->aux_blocks, guint8 *, aux_block_nr), 
+			    g_array_index(str->data_blocks, guint8 *, tmp), 
+			    str->n_chars_in_block);
+      }
+      DEBUG("                                   %i => sum=%i", aux_block_nr, *g_array_index(str->aux_blocks, guint8 *, aux_block_nr));
+    }
+  }
+
+  g_free(context);
+}
+
+//
+// Initialize all the precalculated state of *str using data_len.
+//
+static void
+oneliner_superstring_initialize(oneliner_superstring *str, guint32 data_len)
+{
+  DEBUG("initializing string %i", GPOINTER_TO_UINT(str));
+  // Make sure the length of our data (our String superclass content) is set.
+  str->data_len = (guint32) data_len;
+  // Make sure the block size we deem reasonable for this data length is set.
+  str->block_size = oneliner_superstring_get_block_size(str->data_len);
+  // Make sure the number of chars needed to contain such a block is set.
+  str->n_chars_in_block = (guint32) ceil(str->block_size / 8.0);
+  // Make sure the number of data_blocks needed to contain this data is set.
+  str->n_data_blocks_needed = (guint32) ceil((str->data_len * 8.0) / str->block_size);
+  // Make sure the number of bytes needed to contain those data_blocks is set.
+  str->n_bytes_for_data_blocks = (guint32) ceil((str->n_data_blocks_needed * str->block_size) / 8.0);
+  // Make sure the number of aux blocks needed for those data_blocks is set.
+  str->n_aux_blocks_needed = (guint32) ceil(0.55 * Q * E * str->n_data_blocks_needed);
+  // Make sure the number of known check blocks so far is set.
+  str->n_seen_check_blocks = 0;
+  // Make sure we dont think we have decoded already.
+  str->decode_done = FALSE;
+  // Make sure we have an initialized to_analyze.
+  str->to_analyze = NULL;
+  // Make sure we have an initialized to_free.
+  str->to_free = NULL;
+  // Make sure our graphs are initialized empty.
+  str->check_block_graph = NULL;
+  str->known_aux_blocks = NULL;
+  str->aux_block_graph = NULL;
+}
+
+//
+// Initialize a superstring using (possibly) a String to encode.
+//
+static VALUE
+rb_oneliner_superstring_initialize(int argc, VALUE *argv, VALUE self)
+{
+  RB_ONELINER(self, str);
+
+  if (argc > 1) {
+    rb_raise(rb_eRuntimeError, "Oneliner::SuperString.new(String s = nil) takes at most 1 argument.");
+  } else if (argc == 1) {
+    Check_Type(argv[0], T_STRING);
+    
+    if (RSTRING(argv[0])->len < 1)
+      rb_raise(rb_eRuntimeError, "First argument to Oneliner::SuperString.new(String s = nil) must be a String of at least size 1 if given.");
+    
+    oneliner_superstring_initialize(str, RSTRING(argv[0])->len);
+
+    // Make sure that we have our data_blocks calculated properly.
+    oneliner_superstring_build_data_blocks(str, (guint8 *) RSTRING(argv[0])->ptr);
+    oneliner_superstring_build_aux_blocks(str);
+    str->decode_done = TRUE;
+  }
+  return self;
+}
+
+//
+// Returns whether *str is done decoding.
+//
+static VALUE
+oneliner_superstring_decode_done(oneliner_superstring *str)
+{
+  guint32 tmp;
+  if (str->decode_done)
+    return Qtrue;
+  if (str->data_blocks == NULL)
+    return Qfalse;
+  if (str->n_seen_check_blocks < str->n_data_blocks_needed)
+    return Qfalse;
+  for (tmp = 0; tmp < str->n_data_blocks_needed; tmp++)
+    if (g_array_index(str->data_blocks, guint8 *, tmp) == NULL)
+      return Qfalse;
+  str->decode_done = TRUE;
+  return Qtrue;
+}
+
+//
+// Returns a GArray * containing all the blocks described by *chunk of length chunk_len
+// in the context of *str (its block_size, n_chars_in_block etc).
+//
+static GArray *
+oneliner_superstring_get_blocks_from_chunk(oneliner_superstring *str, guint8 *chunk, guint32 chunk_len)
+{
+  return oneliner_superstring_build_blocks_from_data(chunk_len,
+						     chunk_len,
+						     str->block_size,
+						     str->n_chars_in_block,
+						     (chunk_len * 8) / str->block_size,
+						     chunk);
+}
+
+//
+// Return the guint8 * at either source or aux block with index block_nr in *str.
+//
+static guint8 *
+oneliner_superstring_get_combined_block(oneliner_superstring *str, guint32 block_nr)
+{
+  if (block_nr < str->n_data_blocks_needed)
+    return g_array_index(str->data_blocks, guint8 *, block_nr);
+  else
+    return g_array_index(str->aux_blocks, guint8 *, block_nr - str->n_data_blocks_needed);
+}
+
+//
+// Set either the source of aux block at block_nr of *str to *block.
+//
+static gboolean
+oneliner_superstring_set_combined_block(oneliner_superstring *str, guint32 block_nr, guint8 *block)
+{
+  if (block_nr < str->n_data_blocks_needed && g_array_index(str->data_blocks, guint8 *, block_nr) == NULL) {
+    ALLOC_COPY8(g_array_index(str->data_blocks, guint8 *, block_nr), block, str->n_chars_in_block);
+    return TRUE;
+  } else if (block_nr >= str->n_data_blocks_needed && g_array_index(str->aux_blocks, guint8 *, block_nr - str->n_data_blocks_needed) == NULL) {
+    ALLOC_COPY8(g_array_index(str->aux_blocks, guint8 *, block_nr - str->n_data_blocks_needed), block, str->n_chars_in_block);
+    return TRUE;
+  }
+  return FALSE;
+}
+
+//
+// Analyze if the given xor_block will be finished or empty after applying a newly found block,
+// and set and queue for analysis if we found something new.
+//
+static void
+oneliner_superstring_analyze_source_block_with_hash(gpointer key, gpointer data, gpointer user_data)
+{
+  guint32 source_block_nr;
+  guint32 found_block_nr = GPOINTER_TO_UINT(data);
+  oneliner_xor_block *xor_block = (oneliner_xor_block *) key;
+  oneliner_superstring *str = (oneliner_superstring *) user_data;
+
+  INDENT;
+  DEBUG("found %i for _%i_ (%i)", 
+	GPOINTER_TO_UINT(xor_block), 
+	found_block_nr, 
+	*oneliner_superstring_get_combined_block(str, found_block_nr));
+  INDENT;
+  IFDEBUG(oneliner_xor_block_debug(xor_block));
+
+  // Apply this new knowledge to it.
+  oneliner_xor_block_apply(xor_block,
+			   found_block_nr);
+  
+  DEBUG("after applying it got size %i", g_hash_table_size(xor_block->source_blocks));
+
+  //
+  // If that meant that it is finished then dance the dance of setting the combined block,
+  // removing it from the GList of check blocks for that combined block,
+  // and analyzing the results.
+  //
+  // Otherwise if it is empty, just free it and remove it.
+  //
+  // In fact, right after we have entered this FINISHED block, we will (since we
+  // call analyze on the resulting block, which leads here) check the same xor_block
+  // again, reach the EMPTY block, and then free the block.
+  //
+  if (XOR_BLOCK_FINISHED(xor_block)) {
+
+    // Find the source block that it defines.
+    source_block_nr = oneliner_xor_block_last_source_block_nr(xor_block);
+
+    DEBUG("it is finished! queueing %s %i to be freed!", XOR_TYPE(xor_block), GPOINTER_TO_UINT(xor_block));
+
+    // And free the xor block.
+    str->to_free = g_list_append(str->to_free, xor_block);
+    
+    // And set it.
+    // And now analyze what the newly found source block led to. 
+    // (Right, it can be an aux block as well, but my logic is still correct, I believe.)
+    if (oneliner_superstring_set_combined_block(str, source_block_nr, xor_block->sum)) {
+      DEBUG("_%i_ (%i) was unknown, setting and queueing %i to be analyzed! ******************", 
+	    source_block_nr, 
+	    *oneliner_superstring_get_combined_block(str, source_block_nr),
+	    source_block_nr); 
+      str->to_analyze = g_list_append(str->to_analyze, GUINT_TO_POINTER(source_block_nr));
+    }
+
+  } else if (XOR_BLOCK_EMPTY(xor_block)) {
+
+    DEBUG("it is empty, queueing %i to be freed!", GPOINTER_TO_UINT(xor_block));
+
+    // Free the check block.
+    str->to_free = g_list_append(str->to_free, xor_block);
+
+  }
+  UNINDENT;
+  UNINDENT;
+}
+
+//
+// Go through the to_free queue of str and free all xor_blocks that need to be freed.
+//
+static void
+oneliner_superstring_free_as_necessary(oneliner_superstring *str)
+{
+  GList *list_element = str->to_free;
+
+  INDENT;
+  DEBUG("going through the to_free queue...");
+
+  while (list_element != NULL) {
+    oneliner_xor_block_free((oneliner_xor_block *) list_element->data, TRUE);
+    str->to_free = g_list_remove_link(str->to_free, list_element);
+    g_list_free_1(list_element);
+    list_element = str->to_free;
+  }
+  UNINDENT;
+}
+
+//
+// See if there exists a hash of dependent check blocks for found_block_nr in ary
+// and if it does, analyze the results of applying it to them, then free all the check
+// blocks and remove the hash.
+//
+static void
+oneliner_superstring_analyze_source_block_with_array(oneliner_superstring *str,
+						     GArray *ary,
+						     guint32 found_block_nr)
+{
+  GHashTable *hash;
+
+  INDENT;
+  DEBUG("analyze_source_block_with_array called with _%i_ (%i) and %s", 
+	found_block_nr, 
+	*oneliner_superstring_get_combined_block(str, found_block_nr),
+	ary == str->check_block_graph ? "check_block_graph" : "aux_block_graph");
+	
+  if ((hash = g_array_index(ary, GHashTable *, found_block_nr)) != NULL) {
+    DEBUG("found a hash:");
+    IFDEBUG(oneliner_int_hash_debug(hash));
+    g_hash_table_foreach(hash, oneliner_superstring_analyze_source_block_with_hash, str);
+
+    oneliner_superstring_free_as_necessary(str);
+
+    g_hash_table_destroy(hash);
+    g_array_index(ary, GHashTable *, found_block_nr) = NULL;
+  }
+
+  UNINDENT;
+}
+
+//
+// Check to see if there is an un-initialized aux block at found_block_nr,
+// and if so initialize it. If that meant that it became finished or empty
+// then set and queue for analysis if it gave any new information.
+//
+static void
+oneliner_superstring_analyze_aux_block(oneliner_superstring *str, 
+				       guint32 found_block_nr)
+{
+  oneliner_xor_block *xor_block;
+  guint32 source_block_nr;
+  gboolean found_new_block;
+
+  INDENT;
+  DEBUG("analyze_aux_block called with _%i_ (%i)", 
+	found_block_nr, 
+	*oneliner_superstring_get_combined_block(str, found_block_nr));
+
+  if ((xor_block = g_array_index(str->known_aux_blocks, 
+				 oneliner_xor_block *, 
+				 found_block_nr - str->n_data_blocks_needed)) != NULL) {
+
+    DEBUG("found an unset aux block %i", GPOINTER_TO_UINT(xor_block));
+
+    oneliner_xor_block_set_sum(xor_block, oneliner_superstring_get_combined_block(str, found_block_nr), str->n_chars_in_block);
+    if (XOR_BLOCK_FINISHED(xor_block)) {
+      source_block_nr = oneliner_xor_block_last_source_block_nr(xor_block);
+
+      DEBUG("it is finished, setting the xor block to the new sum, and queueing %i to be freed!", GPOINTER_TO_UINT(xor_block));
+
+      g_array_index(str->known_aux_blocks, 
+		    oneliner_xor_block *, 
+		    found_block_nr - str->n_data_blocks_needed) = NULL;
+      str->to_free = g_list_append(str->to_free, xor_block);
+
+      if (oneliner_superstring_set_combined_block(str, source_block_nr, xor_block->sum)) {
+	DEBUG("_%i_ (%i) was unknown, setting and queueing %i to be analyzed! ******************", 
+	      source_block_nr, 
+	      *oneliner_superstring_get_combined_block(str, source_block_nr),
+	      source_block_nr); 
+	str->to_analyze = g_list_append(str->to_analyze, GUINT_TO_POINTER(source_block_nr));
+      }
+
+    } else if (XOR_BLOCK_EMPTY(xor_block)) {
+      DEBUG("it is empty, queueing %i to be freed", GPOINTER_TO_UINT(xor_block));
+      str->to_free = g_list_append(str->to_free, xor_block);
+    }
+
+    oneliner_superstring_free_as_necessary(str);
+  }
+  UNINDENT;
+}
+
+//
+// Analyze the new information provided by finding found_block_nr for str.
+//
+static void
+oneliner_superstring_analyze(oneliner_superstring *str, guint32 found_block_nr)
+{
+
+  INDENT;
+  DEBUG("analyze called with _%i_", found_block_nr);
+  //
+  // Analyze results for any unresolved check blocks for this found block nr.
+  //
+  oneliner_superstring_analyze_source_block_with_array(str,
+						       str->check_block_graph,
+						       found_block_nr);
+  
+  if (found_block_nr < str->n_data_blocks_needed) {
+    //
+    // Analyze results for any unresolved aux blocks for this found block nr.
+    //
+    oneliner_superstring_analyze_source_block_with_array(str,
+							 str->aux_block_graph,
+							 found_block_nr);
+  } else {
+    //
+    // Analyze results for any unresolved SOURCE blocks for this found aux block.
+    //
+    oneliner_superstring_analyze_aux_block(str, found_block_nr);
+  }
+
+  UNINDENT;
+}
+
+//
+// Take the chunk of length chunk_len and seed and add it to the graphs of str, and queue for analysis any
+// results we find.
+//
+static void
+oneliner_superstring_add_to_graph(oneliner_superstring *str, guint32 seed, guint8 *chunk, guint32 chunk_len)
+{
+  oneliner_context *context = oneliner_context_new();
+  GArray *content_blocks;
+  guint32 tmp;
+  guint32 tmp2;
+  guint32 unknown_source_blocks;
+  guint32 unknown_source_block_nr;
+  GHashTable *inserts = g_hash_table_new(NULL,NULL);
+  oneliner_xor_block *xor_block;
+  guint32 degree;
+  guint32 block_nr;
+  guint8 *block_content;
+
+  INDENT;
+  DEBUG("add_to_graph called");
+
+  oneliner_context_seed(context, (gint32) seed);
+
+  content_blocks = oneliner_superstring_get_blocks_from_chunk(str, chunk, chunk_len);
+  
+  DEBUG("the chunk '%s' of len %i has %i check blocks", chunk, chunk_len, content_blocks->len);
+
+  for (tmp = 0; tmp < content_blocks->len; tmp++) {
+    DEBUG("looking at block with sum %i", *g_array_index(content_blocks, guint8 *, tmp));
+    degree = oneliner_context_get_degree(context);
+    if (degree == 1) {
+      block_nr = RANDOM(context, str->n_data_blocks_needed + str->n_aux_blocks_needed);
+      DEBUG("found block _%i_ in a single block check block", block_nr);
+      if (oneliner_superstring_set_combined_block(str, block_nr, g_array_index(content_blocks, guint8 *, tmp))) {
+	DEBUG("_%i_ (%i) was unknown, setting it and queueing it for analyze! *********************", 
+	      block_nr,
+	      *oneliner_superstring_get_combined_block(str, block_nr));
+	str->to_analyze = g_list_append(str->to_analyze, GUINT_TO_POINTER(block_nr));
+      }
+    } else {
+      unknown_source_blocks = 0;
+      unknown_source_block_nr = 0;
+      
+      xor_block = oneliner_xor_block_new(g_array_index(content_blocks, guint8 *, tmp),
+					 str->n_chars_in_block,
+					 TRUE,
+					 str,
+					 -1);
+
+      DEBUG("found a multi block check block with blocks:");
+      for (tmp2 = 0; tmp2 < degree; tmp2++) {
+	block_nr = RANDOM(context, str->n_data_blocks_needed + str->n_aux_blocks_needed);
+	block_content = oneliner_superstring_get_combined_block(str, block_nr);
+	if (block_content != NULL) {
+	  oneliner_string_xor(xor_block->sum, block_content, str->n_chars_in_block);
+	  DEBUG("                                  _%i_ IS known!!!!!!!!! (making the block sum into %i)", block_nr, *(xor_block->sum));
+	} else {
+	  DEBUG("                                  _%i_ is NOT known :.(", block_nr);
+	  oneliner_xor_block_add(xor_block, block_nr);
+	  if (!g_hash_table_lookup_extended(inserts, GUINT_TO_POINTER(block_nr), NULL, NULL))
+	    g_hash_table_insert(inserts, GUINT_TO_POINTER(block_nr), oneliner_graph_insertion_new(xor_block, block_nr));
+	  unknown_source_blocks++;
+	  unknown_source_block_nr = block_nr;
+	}
+      }
+
+      if (XOR_BLOCK_FINISHED(xor_block)) {
+	DEBUG("found block _%i_ in a multi block check block (sum = %i) block with only one missing block", unknown_source_block_nr, GPOINTER_TO_UINT(xor_block->sum));
+	
+	if (oneliner_superstring_set_combined_block(str, unknown_source_block_nr, xor_block->sum)) {
+	  DEBUG("_%i_ (%i) was unknown, setting it and queueing it for analysis *****************", 
+		unknown_source_block_nr,
+		*oneliner_superstring_get_combined_block(str, unknown_source_block_nr));
+	  str->to_analyze = g_list_append(str->to_analyze, GUINT_TO_POINTER(unknown_source_block_nr));
+	}
+
+	g_hash_table_foreach_remove(inserts, oneliner_graph_insertion_free_with_check_block, NULL);
+
+      } else if (XOR_BLOCK_EMPTY(xor_block)) {
+	DEBUG("just deleting it, it is empty...");
+	g_hash_table_foreach_remove(inserts, oneliner_graph_insertion_free_with_check_block, NULL);
+      } else {
+	DEBUG("inserting it into the check_block_graph");
+	g_hash_table_foreach_remove(inserts, oneliner_insertion_execute, str);
+      }
+
+    }
+    (str->n_seen_check_blocks)++;
+  }
+
+  FREE_ARRAY_WITH_STRINGS(content_blocks);
+  g_hash_table_destroy(inserts);
+  g_free(context);
+  UNINDENT;
+}
+
+//
+// Build a dependency graph for the aux blocks of str.
+//
+static void
+oneliner_superstring_build_aux_graph(oneliner_superstring *str)
+{
+  oneliner_context *context = oneliner_context_new();
+  guint32 tmp;
+  guint8 *zeroes = g_new0(guint8, str->n_chars_in_block);
+  guint32 tmp2;
+  guint32 aux_block_nr;
+  oneliner_xor_block *aux_block;
+  GHashTable *aux_blocks;
+
+  INDENT;
+  DEBUG("build_aux_graph called");
+
+  oneliner_context_seed(context, (gint32) str->data_len);
+  str->known_aux_blocks = g_array_new(FALSE, TRUE, sizeof(oneliner_xor_block *));
+  g_array_set_size(str->known_aux_blocks, str->n_aux_blocks_needed);
+  str->aux_block_graph = g_array_new(FALSE, TRUE, sizeof(GHashTable *));
+  g_array_set_size(str->aux_block_graph, str->n_data_blocks_needed);
+
+  for (tmp = 0; tmp < str->n_data_blocks_needed; tmp++) {
+    aux_blocks = g_hash_table_new(NULL, NULL);
+
+    for (tmp2 = 0; tmp2 < Q; tmp2++) {
+      aux_block_nr = RANDOM(context, str->n_aux_blocks_needed);
+
+      if ((aux_block = g_array_index(str->known_aux_blocks, oneliner_xor_block *, aux_block_nr)) == NULL) {
+	aux_block = oneliner_xor_block_new(zeroes, str->n_chars_in_block, FALSE, str, aux_block_nr);
+	DEBUG("creating aux_block nr %i", aux_block_nr, tmp);
+	g_array_index(str->known_aux_blocks, oneliner_xor_block *, aux_block_nr) = aux_block;
+      }
+
+      DEBUG("adding _%i_ as dependency to aux_block %i", tmp, aux_block_nr);
+      oneliner_xor_block_add(aux_block, tmp);
+      IFDEBUG(oneliner_xor_block_debug(aux_block));
+
+      if (!g_hash_table_lookup_extended(aux_blocks, aux_block, NULL, NULL)) {
+	g_hash_table_insert(aux_blocks, aux_block, GUINT_TO_POINTER(tmp));
+      }
+    }
+    DEBUG("setting aux_block_graph for _%i_", tmp);
+    IFDEBUG(oneliner_int_hash_debug(aux_blocks));
+    g_array_index(str->aux_block_graph, GHashTable *, tmp) = aux_blocks;
+  }
+
+  UNINDENT;
+  g_free(zeroes);
+  g_free(context);
+}
+
+//
+// Go through the queue of results to analyze of str until it is empty (note that it can be appended
+// while analyzing...)
+//
+static void
+oneliner_superstring_analyze_until_done(oneliner_superstring *str)
+{
+  GList *list_element = str->to_analyze;
+
+  INDENT;
+  DEBUG("going through the to_analyze queue...");
+
+  while (list_element != NULL) {
+    oneliner_superstring_analyze(str, GPOINTER_TO_UINT(list_element->data));
+    str->to_analyze = g_list_remove_link(str->to_analyze, list_element);
+    g_list_free_1(list_element);
+    list_element = str->to_analyze;
+  }
+
+  UNINDENT;
+}
+
+//
+// Decode chunk into self, and return whether self seems to be finished decoding.
+//
+static VALUE
+rb_oneliner_superstring_decode(VALUE self, VALUE chunk)
+{
+  RB_ONELINER(self, str);
+  guint32 data_len;
+  guint32 seed;
+  guint32 blocks_needed;
+
+  INDENT;
+
+  Check_Type(chunk, T_STRING);
+
+  DEBUG("decode called for string %i with chunk '%s'", GPOINTER_TO_UINT(str), RSTRING(chunk)->ptr);
+
+  if (RSTRING(chunk)->len < 8)
+    rb_raise(rb_eRuntimeError, "Oneliner::SuperString#decode(String chunk) needs an argument that is at least 8 characters long.");
+
+  data_len = ((guint32 *) RSTRING(chunk)->ptr)[0];
+  seed = ((guint32 *) RSTRING(chunk)->ptr)[1];
+
+  DEBUG("data_len=%i, seed=%i", data_len, seed);
+  
+  if (str->data_len == 0) {
+    str->data_len = data_len;
+  } else if (str->data_len != data_len) {
+    rb_raise(rb_eRuntimeError, "Oneliner::Superstring#decode(String chunk) needs all consecutive calls to be with arguments having the same first four characters. Didn't you use chunks produced using #encode calls from the same instance?");
+  }
+
+  if (str->data_blocks == NULL) {
+    DEBUG("first decode, setting up...");
+    oneliner_superstring_initialize(str, data_len);
+    str->data_blocks = g_array_new(FALSE, TRUE, sizeof(guint8 *));
+    g_array_set_size(str->data_blocks, str->n_data_blocks_needed);
+    str->aux_blocks = g_array_new(FALSE, TRUE, sizeof(guint8 *));
+    g_array_set_size(str->aux_blocks, str->n_aux_blocks_needed);
+    str->check_block_graph = g_array_new(FALSE, TRUE, sizeof(GHashTable *));
+    g_array_set_size(str->check_block_graph, str->n_data_blocks_needed + str->n_aux_blocks_needed);
+    oneliner_superstring_build_aux_graph(str);
+  }
+
+  oneliner_superstring_add_to_graph(str, seed, (guint8 *) RSTRING(chunk)->ptr + 8, (guint32) RSTRING(chunk)->len - 8);
+
+  oneliner_superstring_analyze_until_done(str);
+  UNINDENT;
+  return oneliner_superstring_decode_done(str);
+}
+
+//
+// Produce and return a new check block for str using the given context.
+//
+static guint8 *
+oneliner_superstring_get_check_block(oneliner_superstring *str, oneliner_context *context)
+{
+  guint32 degree = oneliner_context_get_degree(context);
+  guint32 block_nr = RANDOM(context, str->n_data_blocks_needed + str->n_aux_blocks_needed);
+  guint8 *rval;
+  guint32 tmp;
+
+  ALLOC_COPY8(rval, oneliner_superstring_get_combined_block(str, block_nr), str->n_chars_in_block);
+  DEBUG("creating check block with degree %3i and data_blocks _%i_: %i", degree, block_nr, *oneliner_superstring_get_combined_block(str, block_nr));
+  for (tmp = 2; tmp <= degree; tmp++) {
+    block_nr = RANDOM(context, str->n_data_blocks_needed + str->n_aux_blocks_needed);
+    DEBUG("                                                _%i_: %i", block_nr, *oneliner_superstring_get_combined_block(str, block_nr));
+    oneliner_string_xor(rval, 
+			oneliner_superstring_get_combined_block(str, block_nr), 
+			str->n_chars_in_block);
+  }
+  DEBUG("                                                             sum: %i ^^^^^", *rval);
+  return rval;
+}
+
+//
+// Encode a new chunk of check blocks for str and put it in an array pointer to by buffer of length len.
+//
+static guint32
+oneliner_superstring_encode(oneliner_superstring *str, guint8 **buffer, guint32 len)
+{
+  oneliner_context *context = oneliner_context_new();
+  guint8 prepend[8];
+  gint32 tmp;
+  guint32 needed_blocks = ((len - 8) * 8) / str->block_size;
+  GArray *rval_ary = g_array_new(FALSE, FALSE, sizeof(guint8 *));
+  guint32 resulting_size;
+  struct timeval tv;
+
+  DEBUG("encode called for string %i with len %i (with block size %i that means %i blocks)", 
+	GPOINTER_TO_UINT(str), 
+	len,
+	str->block_size,
+	needed_blocks);
+
+  g_array_set_size(rval_ary, needed_blocks);
+
+  gettimeofday(&tv, NULL);
+  srand(tv.tv_usec);
+  tmp = (gint32) rand();
+  oneliner_context_seed(context, tmp);
+
+  ( (guint32 *) prepend )[0] = str->data_len;
+  ( (guint32 *) prepend )[1] = (guint32) tmp;
+
+  for (tmp = 0; tmp < needed_blocks; tmp++) {
+    guint8 *check_block = oneliner_superstring_get_check_block(str, context);
+    g_array_index(rval_ary, guint8 *, tmp) = check_block;
+  }
+  
+  // Here I let resulting_size describe the number of bytes needed to contain the rval_ary considering the block
+  // size. And since we cant really truncate it at the end at this stage (like we can in the final build_data_from_blocks)
+  // the data_len argument is the same as the n_bytes_for_blocks argument. Also, we want to prepend the original data-len
+  // and seed, so we use the prepend argument.
+  resulting_size = (guint32) ceil((needed_blocks * str->block_size) / 8) + 8;
+  *buffer = oneliner_superstring_build_data_from_blocks(resulting_size,
+							resulting_size,
+							str->block_size,
+							rval_ary,
+							8,
+							prepend);
+  g_free(context);
+  FREE_ARRAY_WITH_STRINGS(rval_ary);
+  
+  return resulting_size;
+}
+
+//
+// Add the given xor_block to the given hash. Used as an iterator to clear up other hashes.
+//
+static void
+oneliner_superstring_add_xor_to_hash(gpointer key, gpointer data, gpointer user_data)
+{
+  if (!g_hash_table_lookup_extended((GHashTable *) user_data, key, NULL, NULL)) {
+    DEBUG("queueing xor_block %i to be freed", GPOINTER_TO_UINT(key));
+    g_hash_table_insert((GHashTable *) user_data, key, NULL);
+  }
+}
+
+//
+// Go through the given ary and put all xor_blocks in its contained hahes into the
+// hashtable xors, then destroy the hashtables.
+//
+static void
+oneliner_superstring_free_ary_of_hashes_of_xor_blocks(GArray *ary, GHashTable *xors)
+{
+  guint32 tmp;
+  for (tmp = 0; tmp < ary->len; tmp++) {
+    GHashTable *hash;
+    if ((hash = (GHashTable *) g_array_index(ary, GHashTable *, tmp)) != NULL) {
+      DEBUG("removing xor blocks belonging to _%i_", tmp);
+      g_hash_table_foreach(hash, oneliner_superstring_add_xor_to_hash, xors);
+      g_hash_table_destroy(hash);
+    }
+  }
+}
+
+//
+// Free the given xor_block. Used to iterator over the hashtable containing all remaining
+// xor_blocks in an onliner_superstring when it is being freed.
+//
+static void
+oneliner_superstring_free_xors_killer(gpointer data, gpointer tmp1, gpointer tmp2)
+{
+  oneliner_xor_block_free((oneliner_xor_block *) data, FALSE);
+}
+
+//
+// Free the given oneliner_superstring by freeing its blocks and aux_blocks,
+// then go through the graphs and empty and free them, then free the xor_blocks that 
+// existed in the graphs.
+//
+static void
+oneliner_superstring_free(oneliner_superstring *str)
+{
+  GHashTable *xors = g_hash_table_new(NULL, NULL);
+  guint32 tmp;
+
+  DEBUG("freeing string %i", GPOINTER_TO_UINT(str));
+
+  if (str->data_blocks != NULL) {
+    FREE_ARRAY_WITH_STRINGS(str->data_blocks);
+  }
+  if (str->aux_blocks != NULL) {
+    FREE_ARRAY_WITH_STRINGS(str->aux_blocks);
+  }
+
+  if (str->check_block_graph != NULL) {
+    INDENT;
+    DEBUG("freeing check_block_graph");
+    oneliner_superstring_free_ary_of_hashes_of_xor_blocks(str->check_block_graph, xors);
+    g_array_free(str->check_block_graph, TRUE);
+    str->check_block_graph = NULL;
+    UNINDENT;
+  }
+  if (str->known_aux_blocks != NULL) {
+    INDENT;
+    DEBUG("freeing known_aux_blocks");
+    for (tmp = 0; tmp < str->n_aux_blocks_needed; tmp++) {
+      gpointer xor_block;
+      if ((xor_block = g_array_index(str->known_aux_blocks, oneliner_xor_block *, tmp)) != NULL) {
+	DEBUG("queueing aux block at _%i_ to be freed", tmp);
+	g_hash_table_insert(xors, xor_block, NULL);
+      }
+    }
+    g_array_free(str->known_aux_blocks, TRUE);
+    str->known_aux_blocks = NULL;
+    UNINDENT;
+  }
+  if (str->aux_block_graph != NULL) {
+    INDENT;
+    DEBUG("freeing aux_block_graph");
+    oneliner_superstring_free_ary_of_hashes_of_xor_blocks(str->aux_block_graph, xors);
+    g_array_free(str->aux_block_graph, TRUE);
+    str->aux_block_graph = NULL;
+    UNINDENT;
+  }
+
+  DEBUG("freeing all xor blocks");
+  g_hash_table_foreach(xors, oneliner_superstring_free_xors_killer, NULL);
+  g_hash_table_destroy(xors);
+  g_free(str);
+}
+
+//
+// Create a new Oneliner::SuperString by allocating a new oneliner_superstring.
+//
+static VALUE
+rb_oneliner_superstring_alloc(VALUE klass)
+{
+  oneliner_superstring *str = g_new0(oneliner_superstring, 1);
+  return Data_Wrap_Struct(klass, NULL, oneliner_superstring_free, str);
+}
+
+//
+// Create a ruby Array filled with all the char arrays of length len within container.
+//
+static VALUE
+oneliner_superstring_get_blocks(GArray *container, guint32 len)
+{
+  guint32 tmp;
+  VALUE rval = rb_ary_new();
+  if (container == NULL)
+    return rb_ary_new();
+  for (tmp = 0; tmp < container->len; tmp++) {
+    guint8 *tmp_block = g_array_index(container, guint8 *, tmp);
+    if (tmp_block == NULL)
+      rb_ary_push(rval, Qnil);
+    else
+      rb_ary_push(rval, rb_str_new((gchar *) tmp_block, len));
+  }
+  return rval;
+}
+
+//
+// Return the data blocks of self.
+//
+static VALUE
+rb_oneliner_superstring_data_blocks(VALUE self)
+{
+  RB_ONELINER(self, str);
+  return oneliner_superstring_get_blocks(str->data_blocks, str->n_chars_in_block);
+}
+
+//
+// Return the aux blocks of self.
+//
+static VALUE
+rb_oneliner_superstring_aux_blocks(VALUE self)
+{
+  RB_ONELINER(self, str);
+  return oneliner_superstring_get_blocks(str->aux_blocks, str->n_chars_in_block);
+}
+
+//
+// Put together the data blocks of self and return the resulting String.
+//
+static VALUE
+rb_oneliner_superstring_to_s(VALUE self)
+{
+  RB_ONELINER(self, str);
+  VALUE rval;
+  guint8 *tmp_data;
+
+  if (oneliner_superstring_decode_done(str) == Qfalse)
+    return rb_str_new2("");
+  tmp_data = oneliner_superstring_build_data(str);
+  rval = rb_str_new((gchar *) tmp_data, str->data_len);
+  g_free(tmp_data);
+  return rval;
+}
+
+//
+// Returns the block size of self.
+//
+static VALUE
+rb_oneliner_superstring_block_size(VALUE self)
+{
+  RB_ONELINER(self, str);
+  return INT2NUM(str->block_size);
+}
+
+//
+// Returns whether self is done decoding.
+//
+static VALUE
+rb_oneliner_superstring_decode_done(VALUE self)
+{
+  RB_ONELINER(self, str);
+  return oneliner_superstring_decode_done(str);
+}
+
+//
+// Return a newly created chunk of check blocks of size from self.
+//
+static VALUE
+rb_oneliner_superstring_encode(VALUE self, VALUE size)
+{
+  RB_ONELINER(self, str);
+  guint8 *chunk;
+  VALUE rval;
+  guint32 chunk_size;
+  
+  Check_Type(size, T_FIXNUM);
+  if (NUM2INT(size) < 8)
+    rb_raise(rb_eRuntimeError, "Oneliner::SuperString#encode(Fixnum size) needs a size of at least 8.");
+
+  if (!str->decode_done)
+    rb_raise(rb_eRuntimeError, "Oneliner::SuperString#encode(Fixnum size) can only be called on strings that are done decoding themselves.");
+
+  chunk_size = oneliner_superstring_encode(str, &chunk, NUM2INT(size));
+
+  rval = rb_str_new((gchar *) chunk, chunk_size);
+  
+  g_free(chunk);
+
+  return rval;
+}
+
+//
+// Returns the number of chars self would contain if you did to_s.
+//
+static VALUE
+rb_oneliner_superstring_size(VALUE self)
+{
+  RB_ONELINER(self, str);
+  return INT2NUM(str->data_len);
+}
+
+//
+// Returns the number of check blocks processed by self.
+//
+static VALUE
+rb_oneliner_superstring_seen_check_blocks(VALUE self)
+{
+  RB_ONELINER(self, str);
+  return INT2NUM(str->n_seen_check_blocks);
+}
+
+//
+// Iterator used to find out how many check blocks we have in our graphs.
+//
+static void
+rb_oneliner_superstring_known_check_blocks_iterator(gpointer key, gpointer data, gpointer user_data)
+{
+  g_hash_table_insert((GHashTable *) user_data, key, NULL);
+}
+
+//
+// Returns the number of check blocks in our graphs.
+//
+static VALUE
+rb_oneliner_superstring_known_check_blocks(VALUE self)
+{
+  RB_ONELINER(self, str);
+  guint32 tmp;
+  guint32 tmp2;
+  GHashTable *sum = g_hash_table_new(NULL, NULL);
+  VALUE rval;
+
+  if (str->data_blocks == NULL)
+    return INT2NUM(0);
+  for (tmp = 0; tmp < str->n_data_blocks_needed + str->n_aux_blocks_needed; tmp++)
+    if (g_array_index(str->check_block_graph, GHashTable *, tmp) != NULL)
+      g_hash_table_foreach((GHashTable *) g_array_index(str->check_block_graph, GHashTable *, tmp), 
+			   rb_oneliner_superstring_known_check_blocks_iterator, 
+			   sum);
+  rval = INT2NUM(g_hash_table_size(sum));
+  g_hash_table_destroy(sum);
+  return rval;
+}
+
+//
+// Create a Onliner::Chunk to inspect a chunk of check blocks.
+//
+static VALUE
+rb_oneliner_chunk_initialize(VALUE self, VALUE chunk)
+{
+  VALUE blocks_ary;
+  GArray *blocks;
+  guint32 data_len;
+  guint32 seed;
+  oneliner_superstring str;
+
+  data_len = ((guint32 *) RSTRING(chunk)->ptr)[0];
+  seed = ((guint32 *) RSTRING(chunk)->ptr)[1];
+
+  Check_Type(chunk, T_STRING);
+
+  if (RSTRING(chunk)->len < 8)
+    rb_raise(rb_eRuntimeError, "Oneliner::Chunk.new(String chunk) needs an argument that is at least 8 characters long.");
+
+  oneliner_superstring_initialize(&str, data_len);
+
+  blocks = oneliner_superstring_get_blocks_from_chunk(&str, 
+						      (guint8 *) RSTRING(chunk)->ptr + 8, 
+						      (guint32) RSTRING(chunk)->len - 8);
+
+  rb_ivar_set(self, rb_intern("@blocks"), oneliner_superstring_get_blocks(blocks, 
+									 str.n_chars_in_block));
+  rb_ivar_set(self, rb_intern("@seed"), INT2NUM(seed));
+  rb_ivar_set(self, rb_intern("@data_len"), INT2NUM(data_len));
+
+  FREE_ARRAY_WITH_STRINGS(blocks);
+
+  return self;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  void Init_oneliner() {
+    VALUE rb_string = rb_define_class("String", rb_cObject);
+    rb_define_method(rb_string, "xor!", rb_oneliner_string_xor, 1);
+
+    VALUE rb_oneliner = rb_define_module("Oneliner");
+    rb_superstring = rb_define_class_under(rb_oneliner, 
+                                           "SuperString",
+					   rb_cObject);
+    rb_define_alloc_func(rb_superstring, rb_oneliner_superstring_alloc);
+    rb_define_method(rb_superstring, "initialize", rb_oneliner_superstring_initialize, -1);
+    rb_define_method(rb_superstring, "data_blocks", rb_oneliner_superstring_data_blocks, 0);
+    rb_define_method(rb_superstring, "aux_blocks", rb_oneliner_superstring_aux_blocks, 0);
+    rb_define_method(rb_superstring, "to_s", rb_oneliner_superstring_to_s, 0);
+    rb_define_method(rb_superstring, "encode", rb_oneliner_superstring_encode, 1);
+    rb_define_method(rb_superstring, "block_size", rb_oneliner_superstring_block_size, 0);
+    rb_define_method(rb_superstring, "decode!", rb_oneliner_superstring_decode, 1);
+    rb_define_method(rb_superstring, "done?", rb_oneliner_superstring_decode_done, 0);
+    rb_define_method(rb_superstring, "size", rb_oneliner_superstring_size, 0);
+    rb_define_method(rb_superstring, "seen_check_blocks", rb_oneliner_superstring_seen_check_blocks, 0);
+    rb_define_method(rb_superstring, "known_check_blocks", rb_oneliner_superstring_known_check_blocks, 0);
+
+    rb_chunk = rb_define_class_under(rb_oneliner,
+				     "Chunk",
+				     rb_cObject);
+    rb_define_method(rb_chunk, "initialize", rb_oneliner_chunk_initialize, 1);
+  }
+#ifdef __cplusplus
+}
+#endif
+