use strict;
 use warnings;
 
-use vars (qw($TREE));
-
-use Carp qw(confess);
+use Carp qw(carp confess);
 
 =head1 NAME
 
 
 =cut
 
-$TREE = {};
+our $Tree = {};
+
+if ($::DEBUG & 0x0200)
+{
+       require Data::Dumper;
+}
 
 return (1);
 
        
        my $id = $caller . ':' . $name;
        
-       if (exists ($TREE->{$id}))
+       if (exists ($Tree->{$id}))
        {
                print STDERR $/, __FILE__, ": Name $name has been used in context $caller before.";
                return (undef);
        }
 
-       $TREE->{$id} = {};
-       $obj->{'data'} = $TREE->{$id};
+       $Tree->{$id} = {};
+       $obj->{'data'} = $Tree->{$id};
 
        $obj->{'key'} = $key;
        $obj->{'fields'} = [@fields];
        $obj->{'num_fields'} = scalar (@fields);
        $obj->{'field_index'} = {map { $_ => $i++ } (@fields)};
        $obj->{'id'} = $id;
+
+       if ($::DEBUG & 0x0200)
+       {
+               my $prefix = __FILE__ . ': ';
+               my $dbg = Data::Dumper->Dump ([$obj], ['obj']);
+               $dbg =~ s/^/$prefix/mg; chomp ($dbg);
+               print STDOUT $/, $dbg;
+       }
        
        return (bless ($obj, $pkg));
 }
        if ($obj->{'num_fields'} != scalar (@fields))
        {
                my $id = $obj->{'id'};
-               print STDERR $/, __FILE__, ": Number of fields do not match ($id).";
+               carp ("Number of fields do not match ($id).");
                return;
        }
 
+       if ($::DEBUG & 0x0200)
+       {
+               print STDOUT $/, __FILE__, ': PUT(', $obj->{'id'}, ', ', $key, ') = (' . join (', ', @fields) . ')';
+       }
+
        $obj->{'data'}{$key} = [@fields];
 }
 
                return (qw());
        }
 
+       if ($::DEBUG & 0x0200)
+       {
+               print STDOUT $/, __FILE__, ': GET(', $obj->{'id'}, ', ', $key, ') = (' . join (', ', @{$obj->{'fields'}}) . ')';
+       }
+
        return (@{$obj->{'data'}{$key}});
 }
 
 
 {
        my $nick = shift;
        my @data = $InterestingNumbersCache->get ($nick);
-       @data = (0, 0, 0, 0, 0, 0) unless (@data);
+       @data = (0, 0, 0, 0, 0, 0, 0) unless (@data);
        return (@data);
 }
 
 
 
 use Onis::Html (qw(get_filehandle));
 use Onis::Language (qw(translate));
-use Onis::Data::Core (qw(register_plugin));
+use Onis::Data::Core (qw(register_plugin nick_to_ident));
 use Onis::Data::Persistent ();
 use Onis::Users (qw(nick_to_name));
 
 
        # 0x0400   Data::Core (dump incoming data to stderr)
        # 0x0800   Data::Core (initializing)
        # 0x1000   Onis::Users
-       $::DEBUG = 0x0000;
+       $::DEBUG = 0x0200;
 }
 
 use strict;
        $VERSION =~ s/^\D*(\d+).*/r$1/;
 }
 
-our $FILEINFO;
+our $FileInfo;
 our $PURGE_LOGS = 0;
 
 print STDERR $/, __FILE__, ': $Id$' if ($::DEBUG);
 require "Onis/Parser/$logtype.pm";
 require Onis::Parser::Persistent;
 require Onis::Data::Persistent;
-import Onis::Parser qw/parse last_date/;
-import Onis::Parser::Persistent qw#newfile#;
-import Onis::Data::Persistent qw#init#;
+import Onis::Parser (qw(parse last_date));
+import Onis::Parser::Persistent (qw(newfile));
+import Onis::Data::Persistent ();
 
-$FILEINFO = init ('$FILEINFO', 'hash');
+$FileInfo = Onis::Data::Persistent->new ('FileInfo', 'inode', qw(mtime));
 
 if (get_config ('purge_logs'))
 {
        }
        else
        {
+               my ($old_mtime) = $FileInfo->get ($inode);
+
                print STDERR $/, __FILE__, ": ``$file'': " if ($::DEBUG & 0x200);
-               if (defined ($FILEINFO->{$inode}{'mtime'}))
+
+               if (defined ($old_mtime))
                {
-                       if ($FILEINFO->{$inode}{'mtime'} == $mtime)
+                       if ($old_mtime == $mtime)
                        {
                                print STDERR "File did not change. Skipping." if ($::DEBUG & 0x200);
                                next;
                        }
-                       elsif ($FILEINFO->{$inode}{'mtime'} < $mtime)
+                       elsif ($old_mtime < $mtime)
                        {
                                print STDERR "File changed. Reading it again." if ($::DEBUG & 0x200);
                        }
                {
                        print STDERR "File appears to be new. Reading it." if ($::DEBUG & 0x200);
                }
-               $FILEINFO->{$inode}{'mtime'} = $mtime;
+               $FileInfo->put ($inode, $mtime);
        }
        
        # truncate
                }
        }
        
-       newfile ($FILEINFO->{$inode});
+       newfile ($FileInfo->{$inode});
        while (<$logfile>)
        {
                s/\n|\r//g;
                                {
                                        print STDERR $/, __FILE__, ": Unable to delete empty file ``$file'': $!";
                                }
-                               delete ($FILEINFO->{$inode});
+                               delete ($FileInfo->{$inode});
                        }
                        else
                        {