diff --git a/lib/KorAP/Document.pm b/lib/KorAP/Document.pm
index 4af6c1a..2e3da2a 100644
--- a/lib/KorAP/Document.pm
+++ b/lib/KorAP/Document.pm
@@ -12,6 +12,10 @@
 use Data::Dumper;
 use File::Spec::Functions qw/catdir catfile catpath splitdir splitpath rel2abs/;
 
+# TODO: Currently metadata is processed multiple times - that's horrible!
+#       Due to the kind of processing, processed metadata may be stored in
+#       a multiprocess cache instead.
+
 our @ATTR = qw/text_sigle
 	       doc_sigle
 	       corpus_sigle
diff --git a/lib/KorAP/Document/Primary.pm b/lib/KorAP/Document/Primary.pm
index 9e86720..4acd66a 100644
--- a/lib/KorAP/Document/Primary.pm
+++ b/lib/KorAP/Document/Primary.pm
@@ -33,19 +33,27 @@
 };
 
 
+# Get the data using byte ofsets
 sub data_bytes {
   my ($self, $from, $to) = @_;
 
   use bytes;
 
-  return b(substr($self->[0], $from))->decode if $from && !$to;
+  # Only start offset defined
+  if ($from && !$to) {
+    return b(substr($self->[0], $from))->decode;
+  };
 
+  # No offset defined
   return b($self->[0])->decode unless $to;
 
+  # Get the substring based on offsets
   my $substr = substr($self->[0], $from, $to - $from);
 
+  # Decode
   return b($substr)->decode if defined $substr;
 
+  # No data
   return;
 };
 
diff --git a/lib/KorAP/Field/MultiTermToken.pm b/lib/KorAP/Field/MultiTermToken.pm
index fb83c1a..e658f0d 100644
--- a/lib/KorAP/Field/MultiTermToken.pm
+++ b/lib/KorAP/Field/MultiTermToken.pm
@@ -1,6 +1,7 @@
 package KorAP::Field::MultiTermToken;
 use KorAP::Field::MultiTerm;
 use List::MoreUtils 'uniq';
+use Carp qw/carp croak/;
 use strict;
 use warnings;
 
@@ -10,6 +11,7 @@
   bless [], shift;
 };
 
+
 sub add {
   my $self = shift;
   my $mt;
@@ -77,19 +79,24 @@
 
 # Get relation based positions
 sub _rel_right_pos {
+
+  # There are relation ids!
+
   # token to token - right token
   if ($_[0] =~ m/^<i>(\d+)<s>/o) {
     return ($1, $1);
   }
+
   # token/span to span - right token
   elsif ($_[0] =~ m/^<i>(\d+)<i>(\d+)<s>/o) {
     return ($1, $2);
   }
+
   # span to token - right token
   elsif ($_[0] =~ m/^<b>\d+<i>(\d+)<s>/o) {
     return ($1, $1);
   };
-  warn 'Unknown relation format!';
+  carp 'Unknown relation format!';
   return (0,0);
 };
 
diff --git a/lib/KorAP/Index/XIP/Dependency.pm b/lib/KorAP/Index/XIP/Dependency.pm
index 1b53b24..adf86c6 100644
--- a/lib/KorAP/Index/XIP/Dependency.pm
+++ b/lib/KorAP/Index/XIP/Dependency.pm
@@ -6,6 +6,8 @@
 
   # Phrase depencies are currently ignored.
 
+  my $rel_id = 1;
+
   $$self->add_tokendata(
     foundry => 'xip',
     layer => 'dependency',
@@ -22,6 +24,7 @@
       foreach (@$rel) {
 	my $label = $_->{-label};
 
+	# Relation is "unary" - meaning relation to itself
 	if ($_->{-type} && $_->{-type} eq 'unary') {
 	  $mtt->add(
 	    term => '>xip/d:' . $label,
diff --git a/lib/KorAP/Tokenizer.pm b/lib/KorAP/Tokenizer.pm
index a4a9721..f9f540d 100644
--- a/lib/KorAP/Tokenizer.pm
+++ b/lib/KorAP/Tokenizer.pm
@@ -68,7 +68,7 @@
 
   $self->log->trace('Tokenize data ' . $self->foundry . ':' . $self->layer);
 
-  # TODO: Reuse the following code from Spans.pm and tokens.pm
+  # TODO: Reuse the following code from Spans.pm and Tokens.pm
   my ($tokens, $error);
   try {
       local $SIG{__WARN__} = sub {
@@ -113,7 +113,7 @@
 
       $should++;
 
-      # Ignore non-word tokens
+      # Ignore non-word and non-number tokens (sorry!)
       if ($token !~ /[\w\d]/) {
 #	if ($mtt) {
 #	  my $term = [$token, $from, $to];
diff --git a/lib/KorAP/Tokenizer/Range.pm b/lib/KorAP/Tokenizer/Range.pm
index ed900e5..762653b 100644
--- a/lib/KorAP/Tokenizer/Range.pm
+++ b/lib/KorAP/Tokenizer/Range.pm
@@ -2,13 +2,15 @@
 use strict;
 use warnings;
 use Array::IntSpan;
+use Carp 'carp';
 
 our $SPAN_RE = qr/!([-+]?\d+):([-+]?\d+)$/;
 
+our $debug = 1;
+
 sub new {
-  my $class = shift;
   my $range = Array::IntSpan->new;
-  bless \$range, $class;
+  bless \$range, shift;
 };
 
 
@@ -17,27 +19,35 @@
   ${shift()}->set_range(@_);
 };
 
+
 # Set gap in range from x to y with !z-1:z
 sub gap {
-  ${shift()}->set_range($_[0], $_[1],
-  '!' . ($_[2] - 1) . ':' . $_[2]);
+  ${shift()}->set_range(
+    $_[0], $_[1],
+    '!' . ($_[2] - 1) . ':' . $_[2]
+  );
 };
 
+
 # Lookup range - ignore gaps!
 sub lookup {
-  my $x = ${$_[0]}->lookup( $_[1] ) or return;
-  return if index($x, '!') == 0;
+  my $x = ${$_[0]}->lookup( $_[1] );
+  return if (!defined $x || index($x, '!') == 0);
   return $x;
 };
 
+
+# Lookup the position before the character offset
 sub before {
   my $self = shift;
   my $offset = shift;
 
+  # Be aware - this uses the array-lookup, not the object method!
   my $found = $$self->lookup( $offset );
 
+  # Nothing set here
   unless (defined $found) {
-    warn 'There is no value for ', $offset;
+    carp "There is no value for $offset" if $debug;
     return;
   };
 
@@ -50,17 +60,19 @@
     # Didn't hit a gap
     # this however may be inaccurate
     # but lifts recall
-    return $found - 1;
+    return $found > 1 ? $found - 1 : 0;
   };
 };
 
+
+# Lookup the position after the character offset
 sub after {
   my $self = shift;
   my $offset = shift;
   my $found = $$self->lookup( $offset );
 
   unless (defined $found) {
-    warn 'There is no value for ', $offset;
+    carp "There is no value for $offset" if $debug;
     return;
   };
 
@@ -76,9 +88,54 @@
 
 sub to_string {
   my $self = shift;
-  return join('', map {'['.join(',',@$_).']'}
-		@{$$self->get_range(0,100,'...')})
-    . '...';
+  return join('',
+	      map {'['.join(',',@$_).']'}
+		@{$$self->get_range(0,100,'...')}
+	      ) . '...';
 };
 
 1;
+
+
+__END__
+
+=pod
+
+This module is used for mapping character offsets to positions in
+the stream of tokens.
+
+=head1 set
+
+  $range->set(34, 46, 2);
+
+Start-offset, end-offset, position in token stream.
+
+=head1 gap
+
+  $range->gap(47, 49, 5);
+
+Start-offset, end-offset, preceding position in token stream.
+
+=head1 before
+
+  my $pos = $range->before(15);
+
+Return the token position in the token stream
+before the character offset.
+Be aware: The smallest before-position is 0.
+
+=head1 after
+
+  my $pos = $range->after(34);
+
+Return the token position in the token stream
+following the character offset.
+In case, the character offset is part of a token,
+the current token position is returned.
+
+=head1 to_string
+
+  print $range->to_string;
+
+Serialize the first 100 character positions
+in a string representation.
diff --git a/t/artificial.t b/t/artificial.t
index 92ebb8a..95ef890 100644
--- a/t/artificial.t
+++ b/t/artificial.t
@@ -14,6 +14,18 @@
 
 use_ok('KorAP::Document');
 
+# Tests for material identicality of a token
+sub _t2h {
+  my $string = shift;
+  $string =~ s/^\[\(\d+?-\d+?\)(.+?)\]$/$1/;
+  my %hash = ();
+  foreach (split(qr!\|!, $string)) {
+    $hash{$_} = 1;
+  };
+  return \%hash;
+};
+
+
 my $path = catdir(dirname(__FILE__), 'artificial');
 ok(my $doc = KorAP::Document->new( path => $path . '/' ), 'Load Korap::Document');
 like($doc->path, qr!$path/$!, 'Path');
@@ -93,7 +105,6 @@
 # Add OpenNLP/morpho
 ok($tokens->add('OpenNLP', 'Morpho'), 'Add OpenNLP/Morpho');
 
-
 $i = 0;
 foreach (qw/APPRART ADJA ADJA NN VVFIN ART NN ART NN NE PTKVZ KOUS ART NN NN NN VVPP VAFIN/) {
   like($tokens->stream->pos($i++)->to_string,
@@ -107,7 +118,7 @@
 
 is($tokens->stream->pos(0)->to_string,
    '[(0-3)-:opennlp/sentences$<i>1|-:tokens$<i>18|<>:opennlp/s:s#0-129$<i>17<b>0|_0#0-3|i:zum|opennlp/p:APPRART|s:Zum]',
-#   '[(0-3)-:opennlp/sentences$<i>1|-:tokens$<i>18|_0#0-3|i:zum|s:Zum|opennlp/p:APPRART|<>:opennlp/s:s#0-129$<i>17]',
+   #   '[(0-3)-:opennlp/sentences$<i>1|-:tokens$<i>18|_0#0-3|i:zum|s:Zum|opennlp/p:APPRART|<>:opennlp/s:s#0-129$<i>17]',
    'Correct sentence'
  );
 
@@ -128,9 +139,9 @@
 # Add OpenNLP/sentences
 ok($tokens->add('Base', 'Paragraphs'), 'Add Base/Paragraphs');
 
-is($tokens->stream->pos(0)->to_string,
-   '[(0-3)-:base/paragraphs$<i>0|-:base/sentences$<i>1|-:tokens$<i>18|<>:base/s:t#0-129$<i>17<b>0|<>:base/s:s#0-129$<i>17<b>2|_0#0-3|i:zum|s:Zum]',
-#   '[(0-3)-:base/paragraphs$<i>0|-:base/sentences$<i>1|-:tokens$<i>18|_0#0-3|i:zum|s:Zum|<>:base/s:t#0-129$<i>17<b>0|<>:base/s:s#0-129$<i>17<b>0]',
+is_deeply(
+  _t2h($tokens->stream->pos(0)->to_string),
+  _t2h('[(0-3)-:base/paragraphs$<i>1|-:base/sentences$<i>1|-:tokens$<i>18|<>:base/s:t#0-129$<i>17<b>0|<>:base/s:p#0-129$<i>17<b>1|<>:base/s:s#0-129$<i>17<b>2|_0#0-3|i:zum|s:Zum]'),
    'Correct base annotation');
 
 # New instantiation
@@ -141,9 +152,11 @@
 ok($tokens->add('CoreNLP', 'NamedEntities', 'ne_hgc_175m_600'), 'Add CoreNLP/NamedEntities');
 
 # [(64-73)s:Hofbergli|i:hofbergli|_9#64-73|corenlp/ne_dewac_175m_600:I-LOC|corenlp/ne_hgc_175m_600:I-LOC]
-is($tokens->stream->pos(9)->to_string,
-   '[(64-73)_9#64-73|corenlp/ne:I-LOC|i:hofbergli|s:Hofbergli]',
-   'Correct NamedEntities annotation');
+is_deeply(
+  _t2h($tokens->stream->pos(9)->to_string),
+  _t2h('[(64-73)_9#64-73|corenlp/ne:I-LOC|i:hofbergli|s:Hofbergli]'),
+  'Correct NamedEntities annotation'
+);
 
 # New instantiation
 ok($tokens = new_tokenizer->parse, 'Parse');
@@ -151,10 +164,11 @@
 # Add CoreNLP/Morpho
 ok($tokens->add('CoreNLP', 'Morpho'), 'Add CoreNLP/Morpho');
 
-is($tokens->stream->pos(0)->to_string,
-   '[(0-3)-:tokens$<i>18|_0#0-3|corenlp/p:APPRART|i:zum|s:Zum]',
-#   '[(0-3)-:tokens$<i>18|_0#0-3|i:zum|s:Zum|corenlp/p:APPRART]',
-   'Correct corenlp annotation');
+is_deeply(
+  _t2h($tokens->stream->pos(0)->to_string),
+  _t2h('[(0-3)-:tokens$<i>18|_0#0-3|corenlp/p:APPRART|i:zum|s:Zum]'),
+  'Correct corenlp annotation'
+);
 
 $i = 0;
 foreach (qw/APPRART ADJ ADJA NN VVFIN ART NN ART NN NE PTKVZ KOUS ART NN NN NN VVPP VAFIN/) {
@@ -164,15 +178,15 @@
 };
 
 
-
 # Add CoreNLP/Sentences
 ok($tokens->add('CoreNLP', 'Sentences'), 'Add CoreNLP/Sentences');
 
-is($tokens->stream->pos(0)->to_string,
-   '[(0-3)-:corenlp/sentences$<i>1|-:tokens$<i>18|<>:corenlp/s:s#0-129$<i>17<b>0|_0#0-3|corenlp/p:APPRART|i:zum|s:Zum]',
-#   '[(0-3)-:corenlp/sentences$<i>1|-:tokens$<i>18|_0#0-3|i:zum|s:Zum|corenlp/p:APPRART|<>:corenlp/s:s#0-129$<i>17]',
-   'Correct corenlp annotation');
-
+is_deeply(
+  _t2h($tokens->stream->pos(0)->to_string),
+  _t2h('[(0-3)-:corenlp/sentences$<i>1|-:tokens$<i>18|<>:corenlp/s:s#0-129$<i>17<b>0|_0#0-3|corenlp/p:APPRART|i:zum|s:Zum]'),
+  #   '[(0-3)-:corenlp/sentences$<i>1|-:tokens$<i>18|_0#0-3|i:zum|s:Zum|corenlp/p:APPRART|<>:corenlp/s:s#0-129$<i>17]',
+  'Correct corenlp annotation'
+);
 
 # New instantiation
 ok($tokens = new_tokenizer->parse, 'New Tokenizer');
@@ -180,10 +194,12 @@
 # Add CoreNLP/Sentences
 ok($tokens->add('Connexor', 'Sentences'), 'Add Connexor/Sentences');
 
-is($tokens->stream->pos(0)->to_string,
-   '[(0-3)-:cnx/sentences$<i>1|-:tokens$<i>18|<>:cnx/s:s#0-129$<i>17<b>0|_0#0-3|i:zum|s:Zum]',
-   #   '[(0-3)-:cnx/sentences$<i>1|-:tokens$<i>18|_0#0-3|i:zum|s:Zum|<>:cnx/s:s#0-129$<i>17<b>0]',
-   'Correct cnx annotation');
+is_deeply(
+  _t2h($tokens->stream->pos(0)->to_string),
+  _t2h('[(0-3)-:cnx/sentences$<i>1|-:tokens$<i>18|<>:cnx/s:s#0-129$<i>17<b>0|_0#0-3|i:zum|s:Zum]'),
+  #   '[(0-3)-:cnx/sentences$<i>1|-:tokens$<i>18|_0#0-3|i:zum|s:Zum|<>:cnx/s:s#0-129$<i>17<b>0]',
+  'Correct cnx annotation'
+);
 
 # New instantiation
 ok($tokens = new_tokenizer->parse, 'New Tokenizer');
@@ -253,11 +269,12 @@
 # Add XIP/Sentences
 ok($tokens->add('XIP', 'Sentences'), 'Add XIP/Sentences');
 
-is($tokens->stream->pos(0)->to_string,
-   '[(0-3)-:tokens$<i>18|-:xip/sentences$<i>1|<>:xip/s:s#0-129$<i>17<b>0|_0#0-3|i:zum|s:Zum]',
-#   '[(0-3)-:tokens$<i>18|_0#0-3|i:zum|s:Zum|-:xip/sentences$<i>1|<>:xip/s:s#0-129$<i>17<b>0]',
-   'First sentence'
- );
+is_deeply(
+  _t2h($tokens->stream->pos(0)->to_string),
+  _t2h('[(0-3)-:tokens$<i>18|-:xip/sentences$<i>1|<>:xip/s:s#0-129$<i>17<b>0|_0#0-3|i:zum|s:Zum]'),
+  #   '[(0-3)-:tokens$<i>18|_0#0-3|i:zum|s:Zum|-:xip/sentences$<i>1|<>:xip/s:s#0-129$<i>17<b>0]',
+  'First sentence'
+);
 
 # Add XIP/Morpho
 ok($tokens->add('XIP', 'Morpho'), 'Add XIP/Morpho');
@@ -294,10 +311,16 @@
 # Add XIP/Sentences
 ok($tokens->add('XIP', 'Dependency'), 'Add XIP/Dependency');
 
-
 $stream = $tokens->stream;
-like($stream->pos(1)->to_string, qr!\|>:xip/d:NMOD\$<i>3!, 'Dependency fine');
-like($stream->pos(3)->to_string, qr!\|<:xip/d:NMOD\$<i>1!, 'Dependency fine');
+diag $stream->pos(1)->to_string;
+
+like($stream->pos(1)->to_string, qr![^<]>:xip/d:NMOD\$<i>3!, 'Dependency fine');
+like($stream->pos(3)->to_string, qr![^<]<:xip/d:NMOD\$<i>1!, 'Dependency fine');
+
+done_testing;
+__END__
+
+
 like($stream->pos(3)->to_string, qr!\|<:xip/d:NMOD\$<i>2!, 'Dependency fine');
 like($stream->pos(4)->to_string, qr!\|>xip/d:VMAIN\$<i>4!, 'Dependency fine');
 like($stream->pos(4)->to_string, qr!\|<:xip/d:SUBJ\$<i>6!, 'Dependency fine');
diff --git a/t/artificial/base/paragraph.xml b/t/artificial/base/paragraph.xml
index c9f1724..be19d62 100644
--- a/t/artificial/base/paragraph.xml
+++ b/t/artificial/base/paragraph.xml
@@ -3,6 +3,6 @@
 
 <layer docid="ART_00001" xmlns="http://ids-mannheim.de/ns/KorAP" version="KorAP-0.4">
   <spanList>
-    <span from="0" to="590" />
+    <span from="0" to="129" />
   </spanList>
 </layer>
diff --git a/t/meta.t b/t/meta.t
index 5159889..d3c851c 100644
--- a/t/meta.t
+++ b/t/meta.t
@@ -12,6 +12,9 @@
 use File::Spec::Functions 'catdir';
 
 
+diag 'Support "availability"';
+diag 'Support "pubPlace-key"';
+
 # TODO: Make 'text' -> 'primaryText'
 
 use_ok('KorAP::Document');
