Converted tabs to spaces with tabconv.

26 files changed, 2679 insertions, 2679 deletions

diff --git a/src/experimental/blowfish.h b/src/experimental/blowfish.h
index 0308026..b287bd4 100644
--- a/src/experimental/blowfish.h
+++ b/src/experimental/blowfish.h
@@ -23,454 +23,454 @@
 #define MAX_STRING   256
 #define MAX_PASSWD   56  // 448bits
 #define F(x) \
-        (((SB[0][x.byte.zero] + SB[1][x.byte.one]) ^ SB[2][x.byte.two]) + \
-         SB[3][x.byte.three])
+    (((SB[0][x.byte.zero] + SB[1][x.byte.one]) ^ SB[2][x.byte.two]) + \
+     SB[3][x.byte.three])
 #define revBytes( x ) x = (((x&0xff)<<24)|((x&0xff00)<<8)|((x&0xff0000)>>8)|((x&0xff000000)>>24))
 
 namespace Bu
 {
-        template<int Mode>
-        class Blowfish : public Bu::Cipher<8>
-        {
-        public:
-                Blowfish( Bu::Stream &rNext ) :
-                        Bu::Cipher<8>( rNext )
-                {
-                }
-
-                virtual ~Blowfish()
-                {
-                        stop();
-                        reset();
-                }
-
-                void setPassword( const Bu::String &sPass )
-                {
-                        reset();
-
-                        uint32_t i,j,len=sPass.getSize();
-                        Word Work,null0,null1;
-
-                        if (len > 0)
-                        {
-                                j = 0;
-                                for (i=0;i<NUM_SUBKEYS;i++)
-                                {
-                                        Work.byte.zero = sPass[(j++)%len];
-                                        Work.byte.one = sPass[(j++)%len];
-                                        Work.byte.two = sPass[(j++)%len];
-                                        Work.byte.three = sPass[(j++)%len];
-                                        PA[i] ^= Work.word;
-                                }
-
-                                null0.word = null1.word = 0;
-
-                                for (i=0;i<NUM_SUBKEYS;i+=2)
-                                {
-                                        keyEncipher( null0, null1 );
-                                        PA[i] = null0.word;
-                                        PA[i+1] = null1.word;
-                                }
-
-                                for (j=0;j<NUM_S_BOXES;j++)
-                                        for (i=0;i<NUM_ENTRIES;i+=2)
-                                        {
-                                                keyEncipher( null0, null1 );
-                                                SB[j][i] = null0.word;
-                                                SB[j][i+1] = null1.word;
-                                        }
-                        }
-
-                        Work.word = null0.word = null1.word = 0;
-                        len = 0;
-                }
-
-        private:
-                uint32_t PA[NUM_SUBKEYS];
-                uint32_t SB[NUM_S_BOXES][NUM_ENTRIES];
+    template<int Mode>
+    class Blowfish : public Bu::Cipher<8>
+    {
+    public:
+        Blowfish( Bu::Stream &rNext ) :
+            Bu::Cipher<8>( rNext )
+        {
+        }
+
+        virtual ~Blowfish()
+        {
+            stop();
+            reset();
+        }
+
+        void setPassword( const Bu::String &sPass )
+        {
+            reset();
+
+            uint32_t i,j,len=sPass.getSize();
+            Word Work,null0,null1;
+
+            if (len > 0)
+            {
+                j = 0;
+                for (i=0;i<NUM_SUBKEYS;i++)
+                {
+                    Work.byte.zero = sPass[(j++)%len];
+                    Work.byte.one = sPass[(j++)%len];
+                    Work.byte.two = sPass[(j++)%len];
+                    Work.byte.three = sPass[(j++)%len];
+                    PA[i] ^= Work.word;
+                }
+
+                null0.word = null1.word = 0;
+
+                for (i=0;i<NUM_SUBKEYS;i+=2)
+                {
+                    keyEncipher( null0, null1 );
+                    PA[i] = null0.word;
+                    PA[i+1] = null1.word;
+                }
+
+                for (j=0;j<NUM_S_BOXES;j++)
+                    for (i=0;i<NUM_ENTRIES;i+=2)
+                    {
+                        keyEncipher( null0, null1 );
+                        SB[j][i] = null0.word;
+                        SB[j][i+1] = null1.word;
+                    }
+            }
+
+            Work.word = null0.word = null1.word = 0;
+            len = 0;
+        }
+
+    private:
+        uint32_t PA[NUM_SUBKEYS];
+        uint32_t SB[NUM_S_BOXES][NUM_ENTRIES];
 
 #if __BYTE_ORDER == __BIG_ENDIAN
-                struct WordByte
-                {
-                        uint32_t zero:8;
-                        uint32_t one:8;
-                        uint32_t two:8;
-                        uint32_t three:8;
-                };
+        struct WordByte
+        {
+            uint32_t zero:8;
+            uint32_t one:8;
+            uint32_t two:8;
+            uint32_t three:8;
+        };
 #elif __BYTE_ORDER == __LITTLE_ENDIAN
-                struct WordByte
-                {
-                        uint32_t three:8;
-                        uint32_t two:8;
-                        uint32_t one:8;
-                        uint32_t zero:8;
-                };
+        struct WordByte
+        {
+            uint32_t three:8;
+            uint32_t two:8;
+            uint32_t one:8;
+            uint32_t zero:8;
+        };
 #else
 #error No endianness defined
 #endif
 
-                union Word
-                {
-                        uint32_t word;
-                        WordByte byte;
-                };
-
-                struct DWord
-                {
-                        Word word0;
-                        Word word1;
-                };
-
-                void reset()
-                {
-                        uint32_t i,j;
-
-                        static uint32_t PA_Init[NUM_SUBKEYS] =
-                        {
-                                0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
-                                0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
-                                0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
-                                0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
-                                0x9216d5d9, 0x8979fb1b
-                        };
-
-                        static uint32_t SB_Init[NUM_S_BOXES][NUM_ENTRIES] = {
-                        {
-                                0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
-                                0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
-                                0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
-                                0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
-                                0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
-                                0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
-                                0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
-                                0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
-                                0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
-                                0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
-                                0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
-                                0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
-                                0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
-                                0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
-                                0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
-                                0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
-                                0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
-                                0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
-                                0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
-                                0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
-                                0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
-                                0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
-                                0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
-                                0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
-                                0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
-                                0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
-                                0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
-                                0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
-                                0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
-                                0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
-                                0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
-                                0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
-                                
-                                0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
-                                0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
-                                0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
-                                0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
-                                0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
-                                0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
-                                0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
-                                0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
-                                0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
-                                0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
-                                0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
-                                0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
-                                0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
-                                0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
-                                0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
-                                0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
-                                0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
-                                0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
-                                0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
-                                0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
-                                0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
-                                0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
-                                0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
-                                0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
-                                0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
-                                0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
-                                0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
-                                0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
-                                0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
-                                0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
-                                0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
-                                0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
-                        }, {
-                                0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
-                                0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
-                                0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
-                                0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
-                                0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
-                                0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
-                                0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
-                                0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
-                                0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
-                                0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
-                                0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
-                                0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
-                                0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
-                                0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
-                                0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
-                                0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
-                                0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
-                                0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
-                                0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
-                                0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
-                                0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
-                                0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
-                                0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
-                                0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
-                                0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
-                                0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
-                                0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
-                                0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
-                                0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
-                                0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
-                                0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
-                                0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
-
-                                0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
-                                0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
-                                0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
-                                0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
-                                0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
-                                0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
-                                0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
-                                0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
-                                0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
-                                0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
-                                0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
-                                0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
-                                0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
-                                0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
-                                0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
-                                0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
-                                0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
-                                0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
-                                0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
-                                0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
-                                0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
-                                0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
-                                0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
-                                0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
-                                0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
-                                0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
-                                0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
-                                0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
-                                0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
-                                0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
-                                0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
-                                0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
-                        }, {
-                                0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
-                                0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
-                                0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
-                                0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
-                                0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
-                                0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
-                                0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
-                                0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
-                                0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
-                                0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
-                                0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
-                                0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
-                                0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
-                                0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
-                                0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
-                                0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
-                                0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
-                                0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
-                                0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
-                                0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
-                                0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
-                                0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
-                                0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
-                                0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
-                                0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
-                                0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
-                                0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
-                                0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
-                                0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
-                                0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
-                                0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
-                                0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
-
-                                0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
-                                0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
-                                0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
-                                0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
-                                0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
-                                0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
-                                0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
-                                0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
-                                0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
-                                0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
-                                0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
-                                0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
-                                0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
-                                0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
-                                0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
-                                0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
-                                0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
-                                0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
-                                0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
-                                0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
-                                0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
-                                0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
-                                0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
-                                0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
-                                0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
-                                0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
-                                0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
-                                0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
-                                0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
-                                0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
-                                0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
-                                0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
-                        }, {
-                                0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
-                                0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
-                                0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
-                                0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
-                                0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
-                                0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
-                                0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
-                                0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
-                                0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
-                                0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
-                                0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
-                                0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
-                                0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
-                                0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
-                                0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
-                                0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
-                                0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
-                                0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
-                                0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
-                                0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
-                                0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
-                                0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
-                                0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
-                                0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
-                                0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
-                                0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
-                                0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
-                                0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
-                                0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
-                                0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
-                                0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
-                                0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
-
-                                0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
-                                0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
-                                0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
-                                0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
-                                0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
-                                0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
-                                0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
-                                0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
-                                0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
-                                0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
-                                0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
-                                0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
-                                0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
-                                0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
-                                0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
-                                0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
-                                0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
-                                0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
-                                0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
-                                0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
-                                0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
-                                0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
-                                0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
-                                0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
-                                0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
-                                0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
-                                0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
-                                0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
-                                0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
-                                0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
-                                0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
-                                0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
-                        }
-                        };
-
-                        for (i=0;i<NUM_SUBKEYS;i++)
-                                PA[i] = PA_Init[i];
-
-                        for (j=0;j<NUM_S_BOXES;j++)
-                                for (i=0;i<NUM_ENTRIES;i++)
-                                        SB[j][i] = SB_Init[j][i];
-                }
-
-        protected:
-                virtual void encipher( void *pData )
-                {
-                        DWord *dwWork = (DWord *)pData;
-                        Word &w1 = dwWork->word0, &w2 = dwWork->word1;
-
-                        w1.word = be32toh( w1.word );
-                        w2.word = be32toh( w2.word );
-
-                        keyEncipher( w1, w2 );
-
-                        revBytes( w1.word );
-                        revBytes( w2.word );
-                }
-
-                virtual void decipher( void *pData )
-                {
-                        DWord *dwWork = (DWord *)pData;
-                        Word &w1 = dwWork->word0, &w2 = dwWork->word1;
-
-                        revBytes( w1.word );
-                        revBytes( w2.word );
-                        
-                        w1.word ^= PA[17];
-                        w2.word ^= F(w1)^PA[16];      w1.word ^= F(w2)^PA[15];
-                        w2.word ^= F(w1)^PA[14];      w1.word ^= F(w2)^PA[13];
-                        w2.word ^= F(w1)^PA[12];      w1.word ^= F(w2)^PA[11];
-                        w2.word ^= F(w1)^PA[10];      w1.word ^= F(w2)^PA[9];
-                        w2.word ^= F(w1)^PA[8];       w1.word ^= F(w2)^PA[7];
-                        w2.word ^= F(w1)^PA[6];       w1.word ^= F(w2)^PA[5];
-                        w2.word ^= F(w1)^PA[4];       w1.word ^= F(w2)^PA[3];
-                        w2.word ^= F(w1)^PA[2];       w1.word ^= F(w2)^PA[1];
-                        w2.word ^= PA[0];
-                        
-                        Bu::swap( w1, w2 );
-
-                        w1.word = htobe32( w1.word );
-                        w2.word = htobe32( w2.word );
-                }
-
-                inline void keyEncipher( Word &w1, Word &w2 )
-                {
-                        w1.word ^= PA[0];
-                        w2.word ^= F(w1)^PA[1];       w1.word ^= F(w2)^PA[2];
-                        w2.word ^= F(w1)^PA[3];       w1.word ^= F(w2)^PA[4];
-                        w2.word ^= F(w1)^PA[5];       w1.word ^= F(w2)^PA[6];
-                        w2.word ^= F(w1)^PA[7];       w1.word ^= F(w2)^PA[8];
-                        w2.word ^= F(w1)^PA[9];       w1.word ^= F(w2)^PA[10];
-                        w2.word ^= F(w1)^PA[11];      w1.word ^= F(w2)^PA[12];
-                        w2.word ^= F(w1)^PA[13];      w1.word ^= F(w2)^PA[14];
-                        w2.word ^= F(w1)^PA[15];      w1.word ^= F(w2)^PA[16];
-                        w2.word ^= PA[17];
-
-                        Bu::swap( w1, w2 );
-                }
-        };
-
-        typedef CipherModeEcb<8, Blowfish<1> > BlowfishEcb;
-        typedef CipherModeCfb<8, Blowfish<1> > BlowfishCfb;
-        typedef CipherModeCbc<8, Blowfish<1> > BlowfishCbc;
-        typedef CipherModeOfb<8, Blowfish<1> > BlowfishOfb;
+        union Word
+        {
+            uint32_t word;
+            WordByte byte;
+        };
+
+        struct DWord
+        {
+            Word word0;
+            Word word1;
+        };
+
+        void reset()
+        {
+            uint32_t i,j;
+
+            static uint32_t PA_Init[NUM_SUBKEYS] =
+            {
+                0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+                0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+                0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+                0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+                0x9216d5d9, 0x8979fb1b
+            };
+
+            static uint32_t SB_Init[NUM_S_BOXES][NUM_ENTRIES] = {
+            {
+                0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
+                0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
+                0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
+                0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
+                0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
+                0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+                0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
+                0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
+                0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
+                0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
+                0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
+                0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+                0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
+                0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
+                0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
+                0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
+                0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
+                0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+                0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
+                0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
+                0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
+                0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
+                0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
+                0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+                0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
+                0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
+                0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
+                0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
+                0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
+                0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+                0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
+                0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
+                
+                0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
+                0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
+                0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
+                0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+                0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
+                0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
+                0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
+                0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
+                0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
+                0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+                0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
+                0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
+                0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
+                0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
+                0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
+                0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+                0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
+                0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
+                0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
+                0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
+                0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
+                0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+                0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
+                0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
+                0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
+                0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
+                0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
+                0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+                0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
+                0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
+                0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
+                0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
+            }, {
+                0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
+                0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
+                0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
+                0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
+                0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
+                0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+                0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
+                0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
+                0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
+                0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
+                0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
+                0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+                0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
+                0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
+                0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
+                0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
+                0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
+                0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+                0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
+                0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
+                0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
+                0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
+                0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
+                0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+                0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
+                0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
+                0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
+                0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
+                0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
+                0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+                0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
+                0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
+
+                0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
+                0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
+                0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
+                0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+                0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
+                0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
+                0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
+                0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
+                0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
+                0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+                0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
+                0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
+                0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
+                0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
+                0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
+                0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+                0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
+                0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
+                0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
+                0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
+                0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
+                0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+                0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
+                0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
+                0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
+                0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
+                0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
+                0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+                0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
+                0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
+                0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
+                0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
+            }, {
+                0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
+                0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
+                0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
+                0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
+                0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
+                0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+                0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
+                0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
+                0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
+                0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
+                0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
+                0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+                0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
+                0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
+                0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
+                0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
+                0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
+                0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+                0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
+                0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
+                0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
+                0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
+                0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
+                0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+                0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
+                0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
+                0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
+                0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
+                0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
+                0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+                0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
+                0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
+
+                0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
+                0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
+                0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
+                0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+                0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
+                0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
+                0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
+                0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
+                0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
+                0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+                0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
+                0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
+                0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
+                0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
+                0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
+                0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+                0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
+                0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
+                0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
+                0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
+                0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
+                0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+                0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
+                0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
+                0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
+                0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
+                0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
+                0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+                0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
+                0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
+                0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
+                0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
+            }, {
+                0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
+                0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
+                0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
+                0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
+                0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
+                0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+                0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
+                0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
+                0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
+                0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
+                0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
+                0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+                0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
+                0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
+                0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
+                0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
+                0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
+                0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+                0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
+                0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
+                0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
+                0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
+                0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
+                0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+                0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
+                0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
+                0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
+                0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
+                0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
+                0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+                0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
+                0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
+
+                0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
+                0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
+                0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
+                0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+                0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
+                0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
+                0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
+                0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
+                0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
+                0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+                0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
+                0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
+                0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
+                0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
+                0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
+                0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+                0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
+                0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
+                0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
+                0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
+                0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
+                0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+                0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
+                0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
+                0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
+                0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
+                0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
+                0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+                0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
+                0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
+                0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
+                0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
+            }
+            };
+
+            for (i=0;i<NUM_SUBKEYS;i++)
+                PA[i] = PA_Init[i];
+
+            for (j=0;j<NUM_S_BOXES;j++)
+                for (i=0;i<NUM_ENTRIES;i++)
+                    SB[j][i] = SB_Init[j][i];
+        }
+
+    protected:
+        virtual void encipher( void *pData )
+        {
+            DWord *dwWork = (DWord *)pData;
+            Word &w1 = dwWork->word0, &w2 = dwWork->word1;
+
+            w1.word = be32toh( w1.word );
+            w2.word = be32toh( w2.word );
+
+            keyEncipher( w1, w2 );
+
+            revBytes( w1.word );
+            revBytes( w2.word );
+        }
+
+        virtual void decipher( void *pData )
+        {
+            DWord *dwWork = (DWord *)pData;
+            Word &w1 = dwWork->word0, &w2 = dwWork->word1;
+
+            revBytes( w1.word );
+            revBytes( w2.word );
+            
+            w1.word ^= PA[17];
+            w2.word ^= F(w1)^PA[16];      w1.word ^= F(w2)^PA[15];
+            w2.word ^= F(w1)^PA[14];      w1.word ^= F(w2)^PA[13];
+            w2.word ^= F(w1)^PA[12];      w1.word ^= F(w2)^PA[11];
+            w2.word ^= F(w1)^PA[10];      w1.word ^= F(w2)^PA[9];
+            w2.word ^= F(w1)^PA[8];       w1.word ^= F(w2)^PA[7];
+            w2.word ^= F(w1)^PA[6];       w1.word ^= F(w2)^PA[5];
+            w2.word ^= F(w1)^PA[4];       w1.word ^= F(w2)^PA[3];
+            w2.word ^= F(w1)^PA[2];       w1.word ^= F(w2)^PA[1];
+            w2.word ^= PA[0];
+            
+            Bu::swap( w1, w2 );
+
+            w1.word = htobe32( w1.word );
+            w2.word = htobe32( w2.word );
+        }
+
+        inline void keyEncipher( Word &w1, Word &w2 )
+        {
+            w1.word ^= PA[0];
+            w2.word ^= F(w1)^PA[1];       w1.word ^= F(w2)^PA[2];
+            w2.word ^= F(w1)^PA[3];       w1.word ^= F(w2)^PA[4];
+            w2.word ^= F(w1)^PA[5];       w1.word ^= F(w2)^PA[6];
+            w2.word ^= F(w1)^PA[7];       w1.word ^= F(w2)^PA[8];
+            w2.word ^= F(w1)^PA[9];       w1.word ^= F(w2)^PA[10];
+            w2.word ^= F(w1)^PA[11];      w1.word ^= F(w2)^PA[12];
+            w2.word ^= F(w1)^PA[13];      w1.word ^= F(w2)^PA[14];
+            w2.word ^= F(w1)^PA[15];      w1.word ^= F(w2)^PA[16];
+            w2.word ^= PA[17];
+
+            Bu::swap( w1, w2 );
+        }
+    };
+
+    typedef CipherModeEcb<8, Blowfish<1> > BlowfishEcb;
+    typedef CipherModeCfb<8, Blowfish<1> > BlowfishCfb;
+    typedef CipherModeCbc<8, Blowfish<1> > BlowfishCbc;
+    typedef CipherModeOfb<8, Blowfish<1> > BlowfishOfb;
 };
 
 #endif
diff --git a/src/experimental/cache.h b/src/experimental/cache.h
index e3c8483..795d180 100644
--- a/src/experimental/cache.h
+++ b/src/experimental/cache.h
@@ -18,420 +18,420 @@
 
 namespace Bu
 {
-//      template<class keytype, class obtype>
-//      keytype __cacheGetKey( obtype *&pObj );
-        template<class keytype, class obtype>
-        keytype __cacheGetKey( const obtype *pObj )
-        {
-                return pObj->getKey();
-        }
-
-        template<class keytype, class obtype>
-        class Cache
-        {
-        public:
-                /**
-                 * Cache Pointer - Provides access to data that is held within the
-                 * cache.  This provides safe, refcounting access to data stored in
-                 * the cache, with support for lazy loading.
-                 */
-                class Ptr
-                {
-                friend class Bu::Cache<keytype, obtype>;
-                private:
-                        Ptr( Cache<keytype, obtype> *pCache, obtype *pData,
-                                const keytype &kId ) :
-                                pCache( pCache ),
-                                pData( pData ),
-                                kId( kId )
-                        {
-                                if( pCache )
-                                        pCache->incRef( kId );
-                        }
-                        
-                        Ptr( Cache<keytype, obtype> *pCache, const keytype &kId ) :
-                                pCache( pCache ),
-                                pData( NULL ),
-                                kId( kId )
-                        {
-                        }
-
-                public:
-                        Ptr( const Ptr &rSrc ) :
-                                pCache( rSrc.pCache ),
-                                pData( rSrc.pData ),
-                                kId( rSrc.kId )
-                        {
-                                if( pCache && pData )
-                                        pCache->incRef( kId );
-                        }
-
-                        Ptr() :
-                                pCache( 0 ),
-                                pData( 0 )
-                        {
-                        }
-
-                        virtual ~Ptr()
-                        {
-                                if( pCache && pData )
-                                        pCache->decRef( kId );
-                        }
-
-                        obtype &operator*()
-                        {
-                                checkPtr();
-                                return *pData;
-                        }
-
-                        const obtype &operator*() const
-                        {
-                                checkPtr();
-                                return *pData;
-                        }
-
-                        obtype *operator->()
-                        {
-                                checkPtr();
-                                return pData;
-                        }
-
-                        const obtype *operator->() const
-                        {
-                                checkPtr();
-                                return pData;
-                        }
-
-                        bool isValid() const
-                        {
-                                return pCache != NULL;
-                        }
-
-                        bool isBound() const
-                        {
-                                return pData != NULL;
-                        }
-
-                        bool isSet() const
-                        {
-                                return pCache != NULL;
-                        }
-
-                        const keytype &getKey() const
-                        {
-                                return kId;
-                        }
-
-                        void unbind()
-                        {
-                                if( pCache && pData )
-                                        pCache->decRef( kId );
-                                pData = NULL;
-                        }
-
-                        void clear()
-                        {
-                                unbind();
-                                pCache = NULL;
-                        }
-
-                        void unset()
-                        {
-                                clear();
-                        }
-
-                        Ptr &operator=( const Ptr &rRhs )
-                        {
-                                if( pCache && pData )
-                                        pCache->decRef( kId );
-                                pCache = rRhs.pCache;
-                                pData = rRhs.pData;
-                                kId = rRhs.kId;
-                                if( pCache && pData )
-                                        pCache->incRef( kId );
-                                return *this;
-                        }
-
-                        bool operator==( const Ptr &rRhs ) const
-                        {
-                                return pCache == rRhs.pCache && kId == rRhs.kId;
-                        }
-
-                        bool operator!=( const Ptr &rRhs ) const
-                        {
-                                return pCache != rRhs.pCache || kId != rRhs.kId;
-                        }
-
-                private:
-                        void checkPtr() const
-                        {
-                                if( pCache && !pData )
-                                {
-                                        pData = pCache->getRaw( kId );
-                                        pCache->incRef( kId );
-                                }
-                        }
-
-                private:
-                        Bu::Cache<keytype, obtype> *pCache;
-                        mutable obtype *pData;
-                        mutable keytype kId;
-                };
-
-        private:
-                typedef Bu::CacheStore<keytype, obtype> Store;
-                typedef Bu::List<Store *> StoreList;
-                typedef Bu::CacheCalc<keytype, obtype> Calc;
-                
-                typedef struct CacheEntry
-                {
-                        obtype *pData;
-                        int iRefs;
-                        time_t tLastSync;
-                } CacheEntry;
-
-                typedef Bu::Hash<keytype, CacheEntry> CidHash;
-
-        public:
-                typedef keytype Key;
-                Cache( Calc *pCalc, Store *pStore ) :
-                        pCalc( pCalc ),
-                        pStore( pStore )
-                {
-                        TRACE();
-                        pCalc->setCache( this );
-                }
-
-                virtual ~Cache()
-                {
-                        TRACE();
-
-                        // Better safe than sorry, better try a sync before anything
-                        // else happens.
-                        sync();
-
-                        // Cycle through and unload all objects from the system.
-                        for( typename CidHash::iterator i = hEnt.begin();
-                                 i != hEnt.end(); i++ )
-                        {
-                                if( i.getValue().iRefs > 0 )
-                                {
-                                        // TODO: Throw an error in this case? iRefs != 0 for an
-                                        // object when the Cache is destroyed.
-                                        throw Bu::ExceptionBase("iRefs not zero.");
-                                }
-                                pStore->unload(
-                                        i.getValue().pData,
-                                        i.getKey()
-                                        );
-                        }
-                        delete pCalc;
-                        delete pStore;
-                }
-
-                Ptr insert( obtype *pData )
-                {
-                        TRACE( pData );
-                        if( pStore->has( __cacheGetKey<keytype, obtype>( pData ) ) )
-                                throw Bu::ExceptionBase("Key already exists in cache.");
-                        CacheEntry e = {pData, 0, 0};
-                        keytype k = pStore->create( pData );
-                        hEnt.insert( k, e );
-
-                        pCalc->onLoad( pData, k );
-
-                        pStore->sync();
-
-                        return Ptr( this, pData, k );
-                }
-
-                bool has( const keytype &cId )
-                {
-                        return hEnt.has( cId ) || pStore->has( cId );
-                }
-
-                /**
-                 * Retrieve an object from the cache and return a pointer to it.
-                 * The object returned may be loaded from backend storage if needed,
-                 * or the currently live object will be returned.
-                 *@param cId The id of the object to load.
-                 *@returns A pointer to the object.
-                 */
-                Ptr get( const keytype &cId )
-                {
-                        TRACE( cId );
-                        try {
-                                return Ptr( this, hEnt.get( cId ).pData, cId );
-                        }
-                        catch( Bu::HashException &e ) {
-                                CacheEntry e = {pStore->load( cId ), 0, time( NULL )};
-                                pCalc->onLoad( e.pData, cId );
-                                hEnt.insert( cId, e );
-                                return Ptr( this, e.pData, cId );
-                        }
-                }
-
-                /**
-                 * Retrieve a handle to an object without loading it now.  This function
-                 * will return a pointer that has not yet been "realized" but can be
-                 * used normally.  Upon initial use in any way the object will be
-                 * loaded from the cache, either linking against the already loaded
-                 * object or loading it fresh from the backend storage.  The advantage
-                 * of this is that you recieve a usable handle to the data, but it
-                 * does not count as a reference yet, meaning that the data is loaded
-                 * when you need it, not before.
-                 */
-                Ptr getLazy( const keytype &cId )
-                {
-                        TRACE( cId );
-                        return Ptr( this, cId );
-                }
-
-                int getRefCount( const keytype &cId )
-                {
-                        TRACE( cId );
-                        return hEnt.get( cId ).iRefs;
-                }
-
-                void unload( const keytype &cId )
-                {
-                        TRACE( cId );
-                        try {
-                                if( hEnt.get( cId ).iRefs > 0 )
-                                {
-                                        printf("Shouldn't unload, references still exist!\n");
-                                        return;
-                                }
-                        }
-                        catch( Bu::HashException &e ) {
-                                // It's not here?  Eh, return.
-                                return;
-                        }
-                        obtype *pObj = hEnt.get( cId ).pData;
-                        pCalc->onUnload( pObj, cId );
-                        hEnt.erase( cId );
-
-                        // The unload has to happen last just in case cId is a reference
-                        // to data that is about to be deleted from memory by the unload.
-                        pStore->unload( pObj, cId );
-                }
-
-                void erase( const keytype &cId )
-                {
-                        TRACE( cId );
-                        try {
-                                if( hEnt.get( cId ).iRefs > 0 )
-                                {
-                                        printf("Shouldn't erase, references still exist!\n");
-                                        return;
-                                }
-
-                                obtype *pObj = hEnt.get( cId ).pData;
-                                pCalc->onDestroy( pObj, cId );
-                                hEnt.erase( cId );
-
-                                pStore->destroy( pObj, cId );
-                                pStore->sync();
-                        }
-                        catch( Bu::HashException &e ) {
-                                pCalc->onDestroy( cId );
-
-                                if( hEnt.has( cId ) )
-                                {
-                                        // The object was loaded by onDestroy
-                                        erase( cId );
-                                }
-                                else
-                                {
-                                        pStore->destroy( cId );
-                                        pStore->sync();
-                                }
-                        }
-                }
-
-                typedef Bu::List<keytype> KeyList;
-                KeyList getKeys()
-                {
-                        return pStore->getKeys();
-                }
-
-                KeyList getActiveKeys()
-                {
-                        return hEnt.getKeys();
-                }
-
-                int getSize()
-                {
-                        return pStore->getSize();
-                }
-
-                /**
-                 * Make sure all currently loaded but not-in-use objects are synced to
-                 * the store.
-                 */
-                void sync()
-                {
-                        TRACE();
-                        int iSynced = 0;
-                        for( typename CidHash::iterator i = hEnt.begin();
-                                 i != hEnt.end(); i++ )
-                        {
-                                if( i.getValue().iRefs == 0 )
-                                {
-                                        if( pCalc->shouldSync(
-                                                        i.getValue().pData,
-                                                        i.getKey(),
-                                                        i.getValue().tLastSync
-                                                        ) )
-                                        {
-                                                pStore->sync(
-                                                        i.getValue().pData,
-                                                        i.getKey()
-                                                        );
-                                                iSynced++;
-                                                i.getValue().tLastSync = time( NULL );
-                                        }
-                                }
-                        }
-                        if( iSynced > 0 )
-                        {
-                                pStore->sync();
-                        }
-                }
-
-        private:
-                void incRef( const keytype &cId )
-                {
-                        TRACE( cId );
-                        hEnt.get( cId ).iRefs++;
-                }
-
-                void decRef( const keytype &cId )
-                {
-                        TRACE( cId );
-                        CacheEntry &e = hEnt.get( cId );
-                        e.iRefs--;
-                }
-
-                obtype *getRaw( const keytype &cId )
-                {
-                        TRACE( cId );
-                        try {
-                                return hEnt.get( cId ).pData;
-                        }
-                        catch( Bu::HashException &e ) {
-                                CacheEntry e = {pStore->load( cId ), 0, time( NULL )};
-                                pCalc->onLoad( e.pData, cId );
-                                hEnt.insert( cId, e );
-                                return e.pData;
-                        }
-                }
-
-        private:
-                CidHash hEnt;
-                Calc *pCalc;
-                Store *pStore;
-        };
+//  template<class keytype, class obtype>
+//  keytype __cacheGetKey( obtype *&pObj );
+    template<class keytype, class obtype>
+    keytype __cacheGetKey( const obtype *pObj )
+    {
+        return pObj->getKey();
+    }
+
+    template<class keytype, class obtype>
+    class Cache
+    {
+    public:
+        /**
+         * Cache Pointer - Provides access to data that is held within the
+         * cache.  This provides safe, refcounting access to data stored in
+         * the cache, with support for lazy loading.
+         */
+        class Ptr
+        {
+        friend class Bu::Cache<keytype, obtype>;
+        private:
+            Ptr( Cache<keytype, obtype> *pCache, obtype *pData,
+                const keytype &kId ) :
+                pCache( pCache ),
+                pData( pData ),
+                kId( kId )
+            {
+                if( pCache )
+                    pCache->incRef( kId );
+            }
+            
+            Ptr( Cache<keytype, obtype> *pCache, const keytype &kId ) :
+                pCache( pCache ),
+                pData( NULL ),
+                kId( kId )
+            {
+            }
+
+        public:
+            Ptr( const Ptr &rSrc ) :
+                pCache( rSrc.pCache ),
+                pData( rSrc.pData ),
+                kId( rSrc.kId )
+            {
+                if( pCache && pData )
+                    pCache->incRef( kId );
+            }
+
+            Ptr() :
+                pCache( 0 ),
+                pData( 0 )
+            {
+            }
+
+            virtual ~Ptr()
+            {
+                if( pCache && pData )
+                    pCache->decRef( kId );
+            }
+
+            obtype &operator*()
+            {
+                checkPtr();
+                return *pData;
+            }
+
+            const obtype &operator*() const
+            {
+                checkPtr();
+                return *pData;
+            }
+
+            obtype *operator->()
+            {
+                checkPtr();
+                return pData;
+            }
+
+            const obtype *operator->() const
+            {
+                checkPtr();
+                return pData;
+            }
+
+            bool isValid() const
+            {
+                return pCache != NULL;
+            }
+
+            bool isBound() const
+            {
+                return pData != NULL;
+            }
+
+            bool isSet() const
+            {
+                return pCache != NULL;
+            }
+
+            const keytype &getKey() const
+            {
+                return kId;
+            }
+
+            void unbind()
+            {
+                if( pCache && pData )
+                    pCache->decRef( kId );
+                pData = NULL;
+            }
+
+            void clear()
+            {
+                unbind();
+                pCache = NULL;
+            }
+
+            void unset()
+            {
+                clear();
+            }
+
+            Ptr &operator=( const Ptr &rRhs )
+            {
+                if( pCache && pData )
+                    pCache->decRef( kId );
+                pCache = rRhs.pCache;
+                pData = rRhs.pData;
+                kId = rRhs.kId;
+                if( pCache && pData )
+                    pCache->incRef( kId );
+                return *this;
+            }
+
+            bool operator==( const Ptr &rRhs ) const
+            {
+                return pCache == rRhs.pCache && kId == rRhs.kId;
+            }
+
+            bool operator!=( const Ptr &rRhs ) const
+            {
+                return pCache != rRhs.pCache || kId != rRhs.kId;
+            }
+
+        private:
+            void checkPtr() const
+            {
+                if( pCache && !pData )
+                {
+                    pData = pCache->getRaw( kId );
+                    pCache->incRef( kId );
+                }
+            }
+
+        private:
+            Bu::Cache<keytype, obtype> *pCache;
+            mutable obtype *pData;
+            mutable keytype kId;
+        };
+
+    private:
+        typedef Bu::CacheStore<keytype, obtype> Store;
+        typedef Bu::List<Store *> StoreList;
+        typedef Bu::CacheCalc<keytype, obtype> Calc;
+        
+        typedef struct CacheEntry
+        {
+            obtype *pData;
+            int iRefs;
+            time_t tLastSync;
+        } CacheEntry;
+
+        typedef Bu::Hash<keytype, CacheEntry> CidHash;
+
+    public:
+        typedef keytype Key;
+        Cache( Calc *pCalc, Store *pStore ) :
+            pCalc( pCalc ),
+            pStore( pStore )
+        {
+            TRACE();
+            pCalc->setCache( this );
+        }
+
+        virtual ~Cache()
+        {
+            TRACE();
+
+            // Better safe than sorry, better try a sync before anything
+            // else happens.
+            sync();
+
+            // Cycle through and unload all objects from the system.
+            for( typename CidHash::iterator i = hEnt.begin();
+                 i != hEnt.end(); i++ )
+            {
+                if( i.getValue().iRefs > 0 )
+                {
+                    // TODO: Throw an error in this case? iRefs != 0 for an
+                    // object when the Cache is destroyed.
+                    throw Bu::ExceptionBase("iRefs not zero.");
+                }
+                pStore->unload(
+                    i.getValue().pData,
+                    i.getKey()
+                    );
+            }
+            delete pCalc;
+            delete pStore;
+        }
+
+        Ptr insert( obtype *pData )
+        {
+            TRACE( pData );
+            if( pStore->has( __cacheGetKey<keytype, obtype>( pData ) ) )
+                throw Bu::ExceptionBase("Key already exists in cache.");
+            CacheEntry e = {pData, 0, 0};
+            keytype k = pStore->create( pData );
+            hEnt.insert( k, e );
+
+            pCalc->onLoad( pData, k );
+
+            pStore->sync();
+
+            return Ptr( this, pData, k );
+        }
+
+        bool has( const keytype &cId )
+        {
+            return hEnt.has( cId ) || pStore->has( cId );
+        }
+
+        /**
+         * Retrieve an object from the cache and return a pointer to it.
+         * The object returned may be loaded from backend storage if needed,
+         * or the currently live object will be returned.
+         *@param cId The id of the object to load.
+         *@returns A pointer to the object.
+         */
+        Ptr get( const keytype &cId )
+        {
+            TRACE( cId );
+            try {
+                return Ptr( this, hEnt.get( cId ).pData, cId );
+            }
+            catch( Bu::HashException &e ) {
+                CacheEntry e = {pStore->load( cId ), 0, time( NULL )};
+                pCalc->onLoad( e.pData, cId );
+                hEnt.insert( cId, e );
+                return Ptr( this, e.pData, cId );
+            }
+        }
+
+        /**
+         * Retrieve a handle to an object without loading it now.  This function
+         * will return a pointer that has not yet been "realized" but can be
+         * used normally.  Upon initial use in any way the object will be
+         * loaded from the cache, either linking against the already loaded
+         * object or loading it fresh from the backend storage.  The advantage
+         * of this is that you recieve a usable handle to the data, but it
+         * does not count as a reference yet, meaning that the data is loaded
+         * when you need it, not before.
+         */
+        Ptr getLazy( const keytype &cId )
+        {
+            TRACE( cId );
+            return Ptr( this, cId );
+        }
+
+        int getRefCount( const keytype &cId )
+        {
+            TRACE( cId );
+            return hEnt.get( cId ).iRefs;
+        }
+
+        void unload( const keytype &cId )
+        {
+            TRACE( cId );
+            try {
+                if( hEnt.get( cId ).iRefs > 0 )
+                {
+                    printf("Shouldn't unload, references still exist!\n");
+                    return;
+                }
+            }
+            catch( Bu::HashException &e ) {
+                // It's not here?  Eh, return.
+                return;
+            }
+            obtype *pObj = hEnt.get( cId ).pData;
+            pCalc->onUnload( pObj, cId );
+            hEnt.erase( cId );
+
+            // The unload has to happen last just in case cId is a reference
+            // to data that is about to be deleted from memory by the unload.
+            pStore->unload( pObj, cId );
+        }
+
+        void erase( const keytype &cId )
+        {
+            TRACE( cId );
+            try {
+                if( hEnt.get( cId ).iRefs > 0 )
+                {
+                    printf("Shouldn't erase, references still exist!\n");
+                    return;
+                }
+
+                obtype *pObj = hEnt.get( cId ).pData;
+                pCalc->onDestroy( pObj, cId );
+                hEnt.erase( cId );
+
+                pStore->destroy( pObj, cId );
+                pStore->sync();
+            }
+            catch( Bu::HashException &e ) {
+                pCalc->onDestroy( cId );
+
+                if( hEnt.has( cId ) )
+                {
+                    // The object was loaded by onDestroy
+                    erase( cId );
+                }
+                else
+                {
+                    pStore->destroy( cId );
+                    pStore->sync();
+                }
+            }
+        }
+
+        typedef Bu::List<keytype> KeyList;
+        KeyList getKeys()
+        {
+            return pStore->getKeys();
+        }
+
+        KeyList getActiveKeys()
+        {
+            return hEnt.getKeys();
+        }
+
+        int getSize()
+        {
+            return pStore->getSize();
+        }
+
+        /**
+         * Make sure all currently loaded but not-in-use objects are synced to
+         * the store.
+         */
+        void sync()
+        {
+            TRACE();
+            int iSynced = 0;
+            for( typename CidHash::iterator i = hEnt.begin();
+                 i != hEnt.end(); i++ )
+            {
+                if( i.getValue().iRefs == 0 )
+                {
+                    if( pCalc->shouldSync(
+                            i.getValue().pData,
+                            i.getKey(),
+                            i.getValue().tLastSync
+                            ) )
+                    {
+                        pStore->sync(
+                            i.getValue().pData,
+                            i.getKey()
+                            );
+                        iSynced++;
+                        i.getValue().tLastSync = time( NULL );
+                    }
+                }
+            }
+            if( iSynced > 0 )
+            {
+                pStore->sync();
+            }
+        }
+
+    private:
+        void incRef( const keytype &cId )
+        {
+            TRACE( cId );
+            hEnt.get( cId ).iRefs++;
+        }
+
+        void decRef( const keytype &cId )
+        {
+            TRACE( cId );
+            CacheEntry &e = hEnt.get( cId );
+            e.iRefs--;
+        }
+
+        obtype *getRaw( const keytype &cId )
+        {
+            TRACE( cId );
+            try {
+                return hEnt.get( cId ).pData;
+            }
+            catch( Bu::HashException &e ) {
+                CacheEntry e = {pStore->load( cId ), 0, time( NULL )};
+                pCalc->onLoad( e.pData, cId );
+                hEnt.insert( cId, e );
+                return e.pData;
+            }
+        }
+
+    private:
+        CidHash hEnt;
+        Calc *pCalc;
+        Store *pStore;
+    };
 };
 
 #endif
diff --git a/src/experimental/cachecalc.h b/src/experimental/cachecalc.h
index ecfa3f4..cb5c755 100644
--- a/src/experimental/cachecalc.h
+++ b/src/experimental/cachecalc.h
@@ -14,50 +14,50 @@
 
 namespace Bu
 {
-        template<class keytype, class obtype> class Cache;
-
-        template<class keytype, class obtype>
-        class CacheCalc
-        {
-        friend class Cache<keytype, obtype>;
-        private:
-                typedef Cache<keytype, obtype> MyCache;
-        public:
-                CacheCalc() :
-                        pCache( (MyCache *)0 )
-                {
-                        TRACE();
-                }
-
-                virtual ~CacheCalc()
-                {
-                        TRACE();
-                }
-
-                virtual void onLoad( obtype *pSrc, const keytype &key )=0;
-                virtual void onUnload( obtype *pSrc, const keytype &key )=0;
-                virtual void onDestroy( obtype *pSrc, const keytype &key )=0;
-                virtual void onDestroy( const keytype &key )=0;
-                virtual bool shouldSync( obtype *pSrc, const keytype &key,
-                        time_t tLastSync )=0;
-                virtual void onTick() { };
-
-        protected:
-                MyCache *getCache()
-                {
-                        TRACE();
-                        return pCache;
-                }
-
-        private:
-                void setCache( MyCache *pCache )
-                {
-                        TRACE();
-                        this->pCache = pCache;
-                }
-
-                MyCache *pCache;
-        };
+    template<class keytype, class obtype> class Cache;
+
+    template<class keytype, class obtype>
+    class CacheCalc
+    {
+    friend class Cache<keytype, obtype>;
+    private:
+        typedef Cache<keytype, obtype> MyCache;
+    public:
+        CacheCalc() :
+            pCache( (MyCache *)0 )
+        {
+            TRACE();
+        }
+
+        virtual ~CacheCalc()
+        {
+            TRACE();
+        }
+
+        virtual void onLoad( obtype *pSrc, const keytype &key )=0;
+        virtual void onUnload( obtype *pSrc, const keytype &key )=0;
+        virtual void onDestroy( obtype *pSrc, const keytype &key )=0;
+        virtual void onDestroy( const keytype &key )=0;
+        virtual bool shouldSync( obtype *pSrc, const keytype &key,
+            time_t tLastSync )=0;
+        virtual void onTick() { };
+
+    protected:
+        MyCache *getCache()
+        {
+            TRACE();
+            return pCache;
+        }
+
+    private:
+        void setCache( MyCache *pCache )
+        {
+            TRACE();
+            this->pCache = pCache;
+        }
+
+        MyCache *pCache;
+    };
 };
 
 #endif
diff --git a/src/experimental/cachestore.h b/src/experimental/cachestore.h
index a332e49..5052670 100644
--- a/src/experimental/cachestore.h
+++ b/src/experimental/cachestore.h
@@ -12,35 +12,35 @@
 
 namespace Bu
 {
-        /**
-         * Handles I/O for data in the cache.  This also assigns ID's to the newly
-         * created objects that are requested through this system.
-         */
-        template<class keytype, class obtype>
-        class CacheStore
-        {
-        public:
-                CacheStore()
-                {
-                }
+    /**
+     * Handles I/O for data in the cache.  This also assigns ID's to the newly
+     * created objects that are requested through this system.
+     */
+    template<class keytype, class obtype>
+    class CacheStore
+    {
+    public:
+        CacheStore()
+        {
+        }
 
-                virtual ~CacheStore()
-                {
-                }
+        virtual ~CacheStore()
+        {
+        }
 
-                virtual obtype *load( const keytype &key )=0;
-                virtual void unload( obtype *pObj, const keytype &key )=0;
-                virtual keytype create( obtype *pSrc )=0;
-                virtual void sync()=0;
-                virtual void sync( obtype *pObj, const keytype &key )=0;
-                virtual void destroy( obtype *pObj, const keytype &key )=0;
-                virtual void destroy( const keytype &key )=0;
-                virtual bool has( const keytype &key )=0;
-                virtual Bu::List<keytype> getKeys() { return Bu::List<keytype>(); }
-                virtual int getSize() { return -1; }
+        virtual obtype *load( const keytype &key )=0;
+        virtual void unload( obtype *pObj, const keytype &key )=0;
+        virtual keytype create( obtype *pSrc )=0;
+        virtual void sync()=0;
+        virtual void sync( obtype *pObj, const keytype &key )=0;
+        virtual void destroy( obtype *pObj, const keytype &key )=0;
+        virtual void destroy( const keytype &key )=0;
+        virtual bool has( const keytype &key )=0;
+        virtual Bu::List<keytype> getKeys() { return Bu::List<keytype>(); }
+        virtual int getSize() { return -1; }
 
-        private:
-        };
+    private:
+    };
 };
 
 #endif
diff --git a/src/experimental/cachestorefiles.h b/src/experimental/cachestorefiles.h
index d3a6894..0805e7b 100644
--- a/src/experimental/cachestorefiles.h
+++ b/src/experimental/cachestorefiles.h
@@ -23,188 +23,188 @@
 
 namespace Bu
 {
-        template<class keytype, class obtype>
-        keytype __cacheGetKey( const obtype *pObj );
-
-        template<class keytype, class obtype>
-        obtype *__cacheStoreFilesAlloc( const keytype &key )
-        {
-                return new obtype();
-        }
-
-        template<class keytype, class obtype>
-        void __cacheStoreFilesStore( Bu::Stream &s, obtype &rObj,
-                        const keytype & )
-        {
-                Bu::Archive ar( s, Bu::Archive::save );
-                ar << rObj;
-        }
-
-        template<class keytype, class obtype>
-        obtype *__cacheStoreFilesLoad( Bu::Stream &s, const keytype &key )
-        {
-                obtype *pObj = __cacheStoreFilesAlloc<keytype, obtype>( key );
-                Bu::Archive ar( s, Bu::Archive::load );
-                ar >> (*pObj);
-                return pObj;
-        }
-
-        template<class keytype, class obtype>
-        class CacheStoreFiles : public CacheStore<keytype, obtype>
-        {
-        public:
-                CacheStoreFiles( const Bu::String &sPrefix ) :
-                        sPrefix( sPrefix )
-                {
-                        if( access( sPrefix.getStr(), W_OK|R_OK|X_OK ) )
-                        {
+    template<class keytype, class obtype>
+    keytype __cacheGetKey( const obtype *pObj );
+
+    template<class keytype, class obtype>
+    obtype *__cacheStoreFilesAlloc( const keytype &key )
+    {
+        return new obtype();
+    }
+
+    template<class keytype, class obtype>
+    void __cacheStoreFilesStore( Bu::Stream &s, obtype &rObj,
+            const keytype & )
+    {
+        Bu::Archive ar( s, Bu::Archive::save );
+        ar << rObj;
+    }
+
+    template<class keytype, class obtype>
+    obtype *__cacheStoreFilesLoad( Bu::Stream &s, const keytype &key )
+    {
+        obtype *pObj = __cacheStoreFilesAlloc<keytype, obtype>( key );
+        Bu::Archive ar( s, Bu::Archive::load );
+        ar >> (*pObj);
+        return pObj;
+    }
+
+    template<class keytype, class obtype>
+    class CacheStoreFiles : public CacheStore<keytype, obtype>
+    {
+    public:
+        CacheStoreFiles( const Bu::String &sPrefix ) :
+            sPrefix( sPrefix )
+        {
+            if( access( sPrefix.getStr(), W_OK|R_OK|X_OK ) )
+            {
 #ifdef WIN32
-                                mkdir( sPrefix.getStr() );
+                mkdir( sPrefix.getStr() );
 #else
-                                mkdir( sPrefix.getStr(), 0755 );
+                mkdir( sPrefix.getStr(), 0755 );
 #endif
-                        }
-                }
-
-                virtual ~CacheStoreFiles()
-                {
-                }
-                
-                virtual obtype *load( const keytype &key )
-                {
-//                      try
-//                      {
-                                Bu::MemBuf mb;
-                                Bu::Formatter f( mb );
-                                f << sPrefix << "/" << key;
-                                Bu::File fIn( mb.getString(), Bu::File::Read );
-                                obtype *pOb = __cacheStoreFilesLoad<keytype, obtype>( fIn, key );
-                                return pOb;
-//                      }
-//                      catch( std::exception &e )
-//                      {
-//                              throw Bu::HashException( e.what() );
-//                      }
-                }
-
-                virtual void unload( obtype *pObj, const keytype & )
-                {
-                        delete pObj;
-                }
-
-                virtual keytype create( obtype *pSrc )
-                {
-                        keytype key = __cacheGetKey<keytype, obtype>( pSrc );
-                        Bu::MemBuf mb;
-                        Bu::Formatter f( mb );
-                        f << sPrefix << "/" << key;
-
-                        Bu::File fTouch( mb.getString(), Bu::File::WriteNew );
-
-                        return key;
-                }
-
-                virtual void sync()
-                {
-                }
-
-                virtual void sync( obtype *pSrc, const keytype &key )
-                {
-                        Bu::MemBuf mb;
-                        Bu::Formatter f( mb );
-                        f << sPrefix << "/" << key;
-
-                        Bu::File fOut( mb.getString(), Bu::File::WriteNew );
-                        __cacheStoreFilesStore<keytype, obtype>( fOut, *pSrc, key );
-                }
-
-                virtual void destroy( obtype *pObj, const keytype &key )
-                {
-                        Bu::MemBuf mb;
-                        Bu::Formatter f( mb );
-                        f << sPrefix << "/" << key;
-
-                        unlink( mb.getString().getStr() );
-                        delete pObj;
-                }
-
-                virtual void destroy( const keytype &key )
-                {
-                        Bu::MemBuf mb;
-                        Bu::Formatter f( mb );
-                        f << sPrefix << "/" << key;
-
-                        unlink( mb.getString().getStr() );
-                }
-
-                virtual bool has( const keytype &key )
-                {
-                        Bu::MemBuf mb;
-                        Bu::Formatter f( mb );
-                        f << sPrefix << "/";
-                        Bu::String sBase = mb.getString();
-                        f << key;
-
-                        if( sBase == mb.getString() )
-                                return false;
-
-                        return access( mb.getString().getStr(), F_OK ) == 0;
-                }
-
-                virtual Bu::List<keytype> getKeys()
-                {
-                        DIR *dir = opendir( sPrefix.getStr() );
-                        struct dirent *de;
-                        Bu::List<keytype> lKeys;
-
-                        while( (de = readdir( dir ) ) )
-                        {
-                                if( de->d_type != DT_REG )
-                                        continue;
-
-                                keytype tmp;
-                                Bu::MemBuf mb( de->d_name );
-                                Bu::Formatter f( mb );
-                                try
-                                {
-                                        Fmt fm;
-                                        fm.tokenize( false );
-                                        f << fm;
-                                        f >> tmp;
-                                }
-                                catch( Bu::ExceptionBase &e )
-                                {
-                                        Bu::sio << "Parse error in dir-scan: " << e.what()
-                                                << Bu::sio.nl;
-                                }
-                                lKeys.append( tmp );
-                        }
-                        closedir( dir );
-
-                        return lKeys;
-                }
-
-                virtual int getSize()
-                {
-                        DIR *dir = opendir( sPrefix.getStr() );
-                        struct dirent *de;
-                        int iCount = 0;
-
-                        while( (de = readdir( dir ) ) )
-                        {
-                                if( de->d_type != DT_REG )
-                                        continue;
-
-                                iCount++;
-                        }
-                        closedir( dir );
-
-                        return iCount;
-                }
-
-        private:
-                Bu::String sPrefix;
-        };
+            }
+        }
+
+        virtual ~CacheStoreFiles()
+        {
+        }
+        
+        virtual obtype *load( const keytype &key )
+        {
+//          try
+//          {
+                Bu::MemBuf mb;
+                Bu::Formatter f( mb );
+                f << sPrefix << "/" << key;
+                Bu::File fIn( mb.getString(), Bu::File::Read );
+                obtype *pOb = __cacheStoreFilesLoad<keytype, obtype>( fIn, key );
+                return pOb;
+//          }
+//          catch( std::exception &e )
+//          {
+//              throw Bu::HashException( e.what() );
+//          }
+        }
+
+        virtual void unload( obtype *pObj, const keytype & )
+        {
+            delete pObj;
+        }
+
+        virtual keytype create( obtype *pSrc )
+        {
+            keytype key = __cacheGetKey<keytype, obtype>( pSrc );
+            Bu::MemBuf mb;
+            Bu::Formatter f( mb );
+            f << sPrefix << "/" << key;
+
+            Bu::File fTouch( mb.getString(), Bu::File::WriteNew );
+
+            return key;
+        }
+
+        virtual void sync()
+        {
+        }
+
+        virtual void sync( obtype *pSrc, const keytype &key )
+        {
+            Bu::MemBuf mb;
+            Bu::Formatter f( mb );
+            f << sPrefix << "/" << key;
+
+            Bu::File fOut( mb.getString(), Bu::File::WriteNew );
+            __cacheStoreFilesStore<keytype, obtype>( fOut, *pSrc, key );
+        }
+
+        virtual void destroy( obtype *pObj, const keytype &key )
+        {
+            Bu::MemBuf mb;
+            Bu::Formatter f( mb );
+            f << sPrefix << "/" << key;
+
+            unlink( mb.getString().getStr() );
+            delete pObj;
+        }
+
+        virtual void destroy( const keytype &key )
+        {
+            Bu::MemBuf mb;
+            Bu::Formatter f( mb );
+            f << sPrefix << "/" << key;
+
+            unlink( mb.getString().getStr() );
+        }
+
+        virtual bool has( const keytype &key )
+        {
+            Bu::MemBuf mb;
+            Bu::Formatter f( mb );
+            f << sPrefix << "/";
+            Bu::String sBase = mb.getString();
+            f << key;
+
+            if( sBase == mb.getString() )
+                return false;
+
+            return access( mb.getString().getStr(), F_OK ) == 0;
+        }
+
+        virtual Bu::List<keytype> getKeys()
+        {
+            DIR *dir = opendir( sPrefix.getStr() );
+            struct dirent *de;
+            Bu::List<keytype> lKeys;
+
+            while( (de = readdir( dir ) ) )
+            {
+                if( de->d_type != DT_REG )
+                    continue;
+
+                keytype tmp;
+                Bu::MemBuf mb( de->d_name );
+                Bu::Formatter f( mb );
+                try
+                {
+                    Fmt fm;
+                    fm.tokenize( false );
+                    f << fm;
+                    f >> tmp;
+                }
+                catch( Bu::ExceptionBase &e )
+                {
+                    Bu::sio << "Parse error in dir-scan: " << e.what()
+                        << Bu::sio.nl;
+                }
+                lKeys.append( tmp );
+            }
+            closedir( dir );
+
+            return lKeys;
+        }
+
+        virtual int getSize()
+        {
+            DIR *dir = opendir( sPrefix.getStr() );
+            struct dirent *de;
+            int iCount = 0;
+
+            while( (de = readdir( dir ) ) )
+            {
+                if( de->d_type != DT_REG )
+                    continue;
+
+                iCount++;
+            }
+            closedir( dir );
+
+            return iCount;
+        }
+
+    private:
+        Bu::String sPrefix;
+    };
 
 };
 
diff --git a/src/experimental/cachestoremyriad.h b/src/experimental/cachestoremyriad.h
index 1953b61..01fe307 100644
--- a/src/experimental/cachestoremyriad.h
+++ b/src/experimental/cachestoremyriad.h
@@ -18,141 +18,141 @@
 
 namespace Bu
 {
-        template<class keytype, class obtype>
-        keytype __cacheGetKey( const obtype *pObj );
-
-        template<class keytype, class obtype>
-        obtype *__cacheStoreMyriadAlloc( const keytype &key )
-        {
-                return new obtype();
-        }
-
-        template<class keytype, class obtype>
-        void __cacheStoreMyriadStore( Bu::Stream &s, obtype &rObj,
-                        const keytype & )
-        {
-                Bu::Archive ar( s, Bu::Archive::save );
-                ar << rObj;
-        }
-
-        template<class keytype, class obtype>
-        obtype *__cacheStoreMyriadLoad( Bu::Stream &s, const keytype &key )
-        {
-                obtype *pObj = __cacheStoreMyriadAlloc<keytype, obtype>( key );
-                Bu::Archive ar( s, Bu::Archive::load );
-                ar >> (*pObj);
-                return pObj;
-        }
-
-        template<class keytype, class obtype>
-        class CacheStoreMyriad : public CacheStore<keytype, obtype>
-        {
-        public:
-                CacheStoreMyriad( Bu::Stream &sArch,
-                        int iBlockSize=512, int iPreAllocate=8 ) :
-                        mStore( sArch, iBlockSize, iPreAllocate )
-                {
-                        try
-                        {
-                                MyriadStream ns = mStore.openStream( 1 );
-                                Bu::Archive ar( ns, Bu::Archive::load );
-                                ar >> hId;
-                        }
-                        catch( Bu::MyriadException &e )
-                        {
-                                int iStream = mStore.createStream();
-                                if( iStream != 1 )
-                                        throw Bu::ExceptionBase("That's...horrible...id = %d.\n\n",
-                                                        iStream );
-                                MyriadStream ns = mStore.openStream( 1 );
-                                Bu::Archive ar( ns, Bu::Archive::save );
-                                ar << hId;
-                        }
-                }
-
-                virtual ~CacheStoreMyriad()
-                {
-                        MyriadStream ns = mStore.openStream( 1 );
-                        Bu::Archive ar( ns, Bu::Archive::save );
-                        ar << hId;
-                }
-                
-                virtual obtype *load( const keytype &key )
-                {
-                        int iStream = hId.get( key );
-                        MyriadStream ns = mStore.openStream( iStream );
-                        obtype *pOb = __cacheStoreMyriadLoad<keytype, obtype>( ns, key );
-                        return pOb;
-                }
-
-                virtual void unload( obtype *pObj, const keytype & )
-                {
-                        delete pObj;
-                }
-
-                virtual keytype create( obtype *pSrc )
-                {
-                        keytype key = __cacheGetKey<keytype, obtype>( pSrc );
-                        int iStream = mStore.createStream();
-                        hId.insert( key, iStream );
-                        MyriadStream ns = mStore.openStream( iStream );
-                        __cacheStoreMyriadStore<keytype, obtype>( ns, *pSrc, key );
-                        ns.setSize( ns.tell() );
-                        return key;
-                }
-
-                virtual void sync()
-                {
-                        MyriadStream ns = mStore.openStream( 1 );
-                        Bu::Archive ar( ns, Bu::Archive::save );
-                        ar << hId;
-                        ns.setSize( ns.tell() );
-                        mStore.sync();
-                }
-
-                virtual void sync( obtype *pSrc, const keytype &key )
-                {
-                        int iStream = hId.get( key );
-                        MyriadStream ns = mStore.openStream( iStream );
-                        __cacheStoreMyriadStore<keytype, obtype>( ns, *pSrc, key );
-                        ns.setSize( ns.tell() );
-                }
-
-                virtual void destroy( obtype *pObj, const keytype &key )
-                {
-                        int iStream = hId.get( key );
-                        mStore.deleteStream( iStream );
-                        hId.erase( key );
-                        delete pObj;
-                }
-
-                virtual void destroy( const keytype &key )
-                {
-                        int iStream = hId.get( key );
-                        mStore.deleteStream( iStream );
-                        hId.erase( key );
-                }
-
-                virtual bool has( const keytype &key )
-                {
-                        return hId.has( key );
-                }
-
-                virtual Bu::List<keytype> getKeys()
-                {
-                        return hId.getKeys();
-                }
-
-                virtual int getSize()
-                {
-                        return hId.getSize();
-                }
-
-        private:
-                Myriad mStore;
-                typedef Bu::Hash<keytype, long> StreamHash;
-                StreamHash hId;
-        };
+    template<class keytype, class obtype>
+    keytype __cacheGetKey( const obtype *pObj );
+
+    template<class keytype, class obtype>
+    obtype *__cacheStoreMyriadAlloc( const keytype &key )
+    {
+        return new obtype();
+    }
+
+    template<class keytype, class obtype>
+    void __cacheStoreMyriadStore( Bu::Stream &s, obtype &rObj,
+            const keytype & )
+    {
+        Bu::Archive ar( s, Bu::Archive::save );
+        ar << rObj;
+    }
+
+    template<class keytype, class obtype>
+    obtype *__cacheStoreMyriadLoad( Bu::Stream &s, const keytype &key )
+    {
+        obtype *pObj = __cacheStoreMyriadAlloc<keytype, obtype>( key );
+        Bu::Archive ar( s, Bu::Archive::load );
+        ar >> (*pObj);
+        return pObj;
+    }
+
+    template<class keytype, class obtype>
+    class CacheStoreMyriad : public CacheStore<keytype, obtype>
+    {
+    public:
+        CacheStoreMyriad( Bu::Stream &sArch,
+            int iBlockSize=512, int iPreAllocate=8 ) :
+            mStore( sArch, iBlockSize, iPreAllocate )
+        {
+            try
+            {
+                MyriadStream ns = mStore.openStream( 1 );
+                Bu::Archive ar( ns, Bu::Archive::load );
+                ar >> hId;
+            }
+            catch( Bu::MyriadException &e )
+            {
+                int iStream = mStore.createStream();
+                if( iStream != 1 )
+                    throw Bu::ExceptionBase("That's...horrible...id = %d.\n\n",
+                            iStream );
+                MyriadStream ns = mStore.openStream( 1 );
+                Bu::Archive ar( ns, Bu::Archive::save );
+                ar << hId;
+            }
+        }
+
+        virtual ~CacheStoreMyriad()
+        {
+            MyriadStream ns = mStore.openStream( 1 );
+            Bu::Archive ar( ns, Bu::Archive::save );
+            ar << hId;
+        }
+        
+        virtual obtype *load( const keytype &key )
+        {
+            int iStream = hId.get( key );
+            MyriadStream ns = mStore.openStream( iStream );
+            obtype *pOb = __cacheStoreMyriadLoad<keytype, obtype>( ns, key );
+            return pOb;
+        }
+
+        virtual void unload( obtype *pObj, const keytype & )
+        {
+            delete pObj;
+        }
+
+        virtual keytype create( obtype *pSrc )
+        {
+            keytype key = __cacheGetKey<keytype, obtype>( pSrc );
+            int iStream = mStore.createStream();
+            hId.insert( key, iStream );
+            MyriadStream ns = mStore.openStream( iStream );
+            __cacheStoreMyriadStore<keytype, obtype>( ns, *pSrc, key );
+            ns.setSize( ns.tell() );
+            return key;
+        }
+
+        virtual void sync()
+        {
+            MyriadStream ns = mStore.openStream( 1 );
+            Bu::Archive ar( ns, Bu::Archive::save );
+            ar << hId;
+            ns.setSize( ns.tell() );
+            mStore.sync();
+        }
+
+        virtual void sync( obtype *pSrc, const keytype &key )
+        {
+            int iStream = hId.get( key );
+            MyriadStream ns = mStore.openStream( iStream );
+            __cacheStoreMyriadStore<keytype, obtype>( ns, *pSrc, key );
+            ns.setSize( ns.tell() );
+        }
+
+        virtual void destroy( obtype *pObj, const keytype &key )
+        {
+            int iStream = hId.get( key );
+            mStore.deleteStream( iStream );
+            hId.erase( key );
+            delete pObj;
+        }
+
+        virtual void destroy( const keytype &key )
+        {
+            int iStream = hId.get( key );
+            mStore.deleteStream( iStream );
+            hId.erase( key );
+        }
+
+        virtual bool has( const keytype &key )
+        {
+            return hId.has( key );
+        }
+
+        virtual Bu::List<keytype> getKeys()
+        {
+            return hId.getKeys();
+        }
+
+        virtual int getSize()
+        {
+            return hId.getSize();
+        }
+
+    private:
+        Myriad mStore;
+        typedef Bu::Hash<keytype, long> StreamHash;
+        StreamHash hId;
+    };
 };
 
 #endif
diff --git a/src/experimental/cipher.h b/src/experimental/cipher.h
index 5d5cb07..6e58613 100644
--- a/src/experimental/cipher.h
+++ b/src/experimental/cipher.h
@@ -13,115 +13,115 @@
 
 namespace Bu
 {
-        template<int iBlockSize>
-        class Cipher : public Bu::Filter
-        {
-        public:
-                Cipher( Bu::Stream &rNext ) :
-                        Bu::Filter( rNext ),
-                        iReadBufFill( 0 ),
-                        iReadBufPos( 0 ),
-                        iWriteBufFill( 0 )
-                {
-                }
-
-                virtual ~Cipher()
-                {
-                }
-
-                virtual void start()
-                {
-                }
-
-                virtual Bu::size stop()
-                {
-                        flush();
-                        return 0;
-                }
-
-                virtual Bu::size read( void *pBuf, Bu::size iBytes )
-                {
-                        Bu::size iRead = 0;
-                        while( iRead < iBytes )
-                        {
-                                if( iReadBufFill < iBlockSize )
-                                {
-                                        int iR = rNext.read(
-                                                aReadBuf+iReadBufFill,
-                                                iBlockSize-iReadBufFill
-                                                );
-                                        if( iR == 0 )
-                                                return iRead;
-
-                                        iReadBufFill += iR;
-
-                                        if( iReadBufFill == iBlockSize )
-                                                decipher( aReadBuf );
-                                }
-
-                                if( iReadBufFill == iBlockSize )
-                                {
-                                        int iCpy = Bu::buMin( (int)(iBytes-iRead), iBlockSize-iReadBufPos );
-                                        memcpy( ((char *)pBuf)+iRead, aReadBuf+iReadBufPos, iCpy );
-                                        iRead += iCpy;
-                                        iReadBufPos += iCpy;
-                                        if( iReadBufPos == iBlockSize )
-                                        {
-                                                iReadBufPos = iReadBufFill = 0;
-                                        }
-                                }
-                        }
-
-                        return iRead;
-                }
-
-                virtual Bu::size write( const void *pBuf, Bu::size iBytes )
-                {
-                        Bu::size iPos = 0;
-                        
-                        while( iPos < iBytes )
-                        {
-                                int iLeft = Bu::buMin((int)(iBytes-iPos),iBlockSize-iWriteBufFill);
-                                memcpy( aWriteBuf+iWriteBufFill, (char *)pBuf+iPos, iLeft );
-                                iPos += iLeft;
-                                iWriteBufFill += iLeft;
-                                if( iWriteBufFill == iBlockSize )
-                                {
-                                        encipher( aWriteBuf );
-                                        rNext.write( aWriteBuf, iBlockSize );
-                                        iWriteBufFill = 0;
-                                }
-                        }
-
-                        return iPos;
-                }
-
-                virtual void flush()
-                {
-                        if( iWriteBufFill > 0 && iWriteBufFill < iBlockSize )
-                        {
-                                memset( aWriteBuf+iWriteBufFill, 0, iBlockSize-iWriteBufFill );
-                                encipher( aWriteBuf );
-                                rNext.write( aWriteBuf, iBlockSize );
-                                iWriteBufFill = 0;
-                        }
-                        rNext.flush();
-                }
-
-                using Bu::Stream::read;
-                using Bu::Stream::write;
-
-        protected:
-                virtual void encipher( void *pData )=0;
-                virtual void decipher( void *pData )=0;
-
-        private:
-                char aReadBuf[iBlockSize];
-                char aWriteBuf[iBlockSize];
-                int iReadBufFill;
-                int iReadBufPos;
-                int iWriteBufFill;
-        };
+    template<int iBlockSize>
+    class Cipher : public Bu::Filter
+    {
+    public:
+        Cipher( Bu::Stream &rNext ) :
+            Bu::Filter( rNext ),
+            iReadBufFill( 0 ),
+            iReadBufPos( 0 ),
+            iWriteBufFill( 0 )
+        {
+        }
+
+        virtual ~Cipher()
+        {
+        }
+
+        virtual void start()
+        {
+        }
+
+        virtual Bu::size stop()
+        {
+            flush();
+            return 0;
+        }
+
+        virtual Bu::size read( void *pBuf, Bu::size iBytes )
+        {
+            Bu::size iRead = 0;
+            while( iRead < iBytes )
+            {
+                if( iReadBufFill < iBlockSize )
+                {
+                    int iR = rNext.read(
+                        aReadBuf+iReadBufFill,
+                        iBlockSize-iReadBufFill
+                        );
+                    if( iR == 0 )
+                        return iRead;
+
+                    iReadBufFill += iR;
+
+                    if( iReadBufFill == iBlockSize )
+                        decipher( aReadBuf );
+                }
+
+                if( iReadBufFill == iBlockSize )
+                {
+                    int iCpy = Bu::buMin( (int)(iBytes-iRead), iBlockSize-iReadBufPos );
+                    memcpy( ((char *)pBuf)+iRead, aReadBuf+iReadBufPos, iCpy );
+                    iRead += iCpy;
+                    iReadBufPos += iCpy;
+                    if( iReadBufPos == iBlockSize )
+                    {
+                        iReadBufPos = iReadBufFill = 0;
+                    }
+                }
+            }
+
+            return iRead;
+        }
+
+        virtual Bu::size write( const void *pBuf, Bu::size iBytes )
+        {
+            Bu::size iPos = 0;
+            
+            while( iPos < iBytes )
+            {
+                int iLeft = Bu::buMin((int)(iBytes-iPos),iBlockSize-iWriteBufFill);
+                memcpy( aWriteBuf+iWriteBufFill, (char *)pBuf+iPos, iLeft );
+                iPos += iLeft;
+                iWriteBufFill += iLeft;
+                if( iWriteBufFill == iBlockSize )
+                {
+                    encipher( aWriteBuf );
+                    rNext.write( aWriteBuf, iBlockSize );
+                    iWriteBufFill = 0;
+                }
+            }
+
+            return iPos;
+        }
+
+        virtual void flush()
+        {
+            if( iWriteBufFill > 0 && iWriteBufFill < iBlockSize )
+            {
+                memset( aWriteBuf+iWriteBufFill, 0, iBlockSize-iWriteBufFill );
+                encipher( aWriteBuf );
+                rNext.write( aWriteBuf, iBlockSize );
+                iWriteBufFill = 0;
+            }
+            rNext.flush();
+        }
+
+        using Bu::Stream::read;
+        using Bu::Stream::write;
+
+    protected:
+        virtual void encipher( void *pData )=0;
+        virtual void decipher( void *pData )=0;
+
+    private:
+        char aReadBuf[iBlockSize];
+        char aWriteBuf[iBlockSize];
+        int iReadBufFill;
+        int iReadBufPos;
+        int iWriteBufFill;
+    };
 };
 
 #endif
diff --git a/src/experimental/ciphermodecbc.h b/src/experimental/ciphermodecbc.h
index 8fbf9f6..b06a972 100644
--- a/src/experimental/ciphermodecbc.h
+++ b/src/experimental/ciphermodecbc.h
@@ -6,49 +6,49 @@
 
 namespace Bu
 {
-        template<int iBlockSize, typename CipherType>
-        class CipherModeCbc : public CipherType
-        {
-        public:
-                CipherModeCbc(class Stream &rNext ) :
-                        CipherType( rNext ),
-                        bStart( true )
-                {
-                        memset( aVector, 0, iBlockSize );
-                }
-
-                virtual ~CipherModeCbc()
-                {
-                }
-
-                void setIv( const Bu::String &sIv )
-                {
-                        memcpy( aVector, sIv.getStr(), iBlockSize );
-                }
-
-        protected:
-                void decipher( void *pBuf )
-                {
-                        uint8_t aTmp[iBlockSize];
-                        memcpy( aTmp, pBuf, iBlockSize );
-                        CipherType::decipher( pBuf );
-                        for( int j = 0; j < iBlockSize; j++ )
-                                ((uint8_t *)pBuf)[j] ^= aVector[j];
-                        memcpy( aVector, aTmp, iBlockSize );
-                }
-
-                void encipher( void *pBuf )
-                {
-                        for( int j = 0; j < iBlockSize; j++ )
-                                ((uint8_t *)pBuf)[j] ^= aVector[j];
-                        CipherType::encipher( pBuf );
-                        memcpy( aVector, pBuf, iBlockSize );
-                }
-
-        private:
-                bool bStart;
-                uint8_t aVector[iBlockSize];
-        };
+    template<int iBlockSize, typename CipherType>
+    class CipherModeCbc : public CipherType
+    {
+    public:
+        CipherModeCbc(class Stream &rNext ) :
+            CipherType( rNext ),
+            bStart( true )
+        {
+            memset( aVector, 0, iBlockSize );
+        }
+
+        virtual ~CipherModeCbc()
+        {
+        }
+
+        void setIv( const Bu::String &sIv )
+        {
+            memcpy( aVector, sIv.getStr(), iBlockSize );
+        }
+
+    protected:
+        void decipher( void *pBuf )
+        {
+            uint8_t aTmp[iBlockSize];
+            memcpy( aTmp, pBuf, iBlockSize );
+            CipherType::decipher( pBuf );
+            for( int j = 0; j < iBlockSize; j++ )
+                ((uint8_t *)pBuf)[j] ^= aVector[j];
+            memcpy( aVector, aTmp, iBlockSize );
+        }
+
+        void encipher( void *pBuf )
+        {
+            for( int j = 0; j < iBlockSize; j++ )
+                ((uint8_t *)pBuf)[j] ^= aVector[j];
+            CipherType::encipher( pBuf );
+            memcpy( aVector, pBuf, iBlockSize );
+        }
+
+    private:
+        bool bStart;
+        uint8_t aVector[iBlockSize];
+    };
 };
 
 #endif
diff --git a/src/experimental/ciphermodecfb.h b/src/experimental/ciphermodecfb.h
index dab6c2e..34c682f 100644
--- a/src/experimental/ciphermodecfb.h
+++ b/src/experimental/ciphermodecfb.h
@@ -6,48 +6,48 @@
 
 namespace Bu
 {
-        template<int iBlockSize, typename CipherType>
-        class CipherModeCfb : public CipherType
-        {
-        public:
-                CipherModeCfb(class Stream &rNext ) :
-                        CipherType( rNext ),
-                        bStart( true )
-                {
-                        memset( aVector, 0, iBlockSize );
-                }
-
-                virtual ~CipherModeCfb()
-                {
-                }
-
-                void setIv( const Bu::String &sIv )
-                {
-                        memcpy( aVector, sIv.getStr(), iBlockSize );
-                }
-
-        protected:
-                void decipher( void *pBuf )
-                {
-                        uint8_t aTmp[iBlockSize];
-                        memcpy( aTmp, pBuf, iBlockSize );
-                        CipherType::encipher( aVector );
-                        for( int j = 0; j < iBlockSize; j++ )
-                                ((uint8_t *)pBuf)[j] ^= aVector[j];
-                        memcpy( aVector, aTmp, iBlockSize );
-                }
-
-                void encipher( void *pBuf )
-                {
-                        CipherType::encipher( aVector );
-                        for( int j = 0; j < iBlockSize; j++ )
-                                aVector[j] = ((uint8_t *)pBuf)[j] ^= aVector[j];
-                }
-
-        private:
-                bool bStart;
-                uint8_t aVector[iBlockSize];
-        };
+    template<int iBlockSize, typename CipherType>
+    class CipherModeCfb : public CipherType
+    {
+    public:
+        CipherModeCfb(class Stream &rNext ) :
+            CipherType( rNext ),
+            bStart( true )
+        {
+            memset( aVector, 0, iBlockSize );
+        }
+
+        virtual ~CipherModeCfb()
+        {
+        }
+
+        void setIv( const Bu::String &sIv )
+        {
+            memcpy( aVector, sIv.getStr(), iBlockSize );
+        }
+
+    protected:
+        void decipher( void *pBuf )
+        {
+            uint8_t aTmp[iBlockSize];
+            memcpy( aTmp, pBuf, iBlockSize );
+            CipherType::encipher( aVector );
+            for( int j = 0; j < iBlockSize; j++ )
+                ((uint8_t *)pBuf)[j] ^= aVector[j];
+            memcpy( aVector, aTmp, iBlockSize );
+        }
+
+        void encipher( void *pBuf )
+        {
+            CipherType::encipher( aVector );
+            for( int j = 0; j < iBlockSize; j++ )
+                aVector[j] = ((uint8_t *)pBuf)[j] ^= aVector[j];
+        }
+
+    private:
+        bool bStart;
+        uint8_t aVector[iBlockSize];
+    };
 };
 
 #endif
diff --git a/src/experimental/ciphermodeecb.h b/src/experimental/ciphermodeecb.h
index 006741a..cac2beb 100644
--- a/src/experimental/ciphermodeecb.h
+++ b/src/experimental/ciphermodeecb.h
@@ -3,30 +3,30 @@
 
 namespace Bu
 {
-        template<int iBlockSize, typename CipherType>
-        class CipherModeEcb : public CipherType
-        {
-        public:
-                CipherModeEcb( class Stream &rNext ) :
-                        CipherType( rNext )
-                {
-                }
+    template<int iBlockSize, typename CipherType>
+    class CipherModeEcb : public CipherType
+    {
+    public:
+        CipherModeEcb( class Stream &rNext ) :
+            CipherType( rNext )
+        {
+        }
 
-                virtual ~CipherModeEcb()
-                {
-                }
-        
-        protected:
-                virtual void decipher( void *pBuf )
-                {
-                        CipherType::decipher( pBuf );
-                }
+        virtual ~CipherModeEcb()
+        {
+        }
+    
+    protected:
+        virtual void decipher( void *pBuf )
+        {
+            CipherType::decipher( pBuf );
+        }
 
-                virtual void encipher( void *pBuf )
-                {
-                        CipherType::encipher( pBuf );
-                }
-        };
+        virtual void encipher( void *pBuf )
+        {
+            CipherType::encipher( pBuf );
+        }
+    };
 };
 
 #endif
diff --git a/src/experimental/ciphermodeofb.h b/src/experimental/ciphermodeofb.h
index 8c2aa20..e1b5108 100644
--- a/src/experimental/ciphermodeofb.h
+++ b/src/experimental/ciphermodeofb.h
@@ -6,51 +6,51 @@
 
 namespace Bu
 {
-        template<int iBlockSize, typename CipherType>
-        class CipherModeOfb : public CipherType
-        {
-        public:
-                CipherModeOfb(class Stream &rNext ) :
-                        CipherType( rNext ),
-                        bStart( true )
-                {
-                        memset( aVector, 0, iBlockSize );
-                }
-
-                virtual ~CipherModeOfb()
-                {
-                }
-
-                void setIv( const Bu::String &sIv )
-                {
-                        memcpy( aVector, sIv.getStr(), iBlockSize );
-                }
-
-        protected:
-                void decipher( void *pBuf )
-                {
-                        CipherType::encipher( aVector );
-                        uint8_t aTmp[iBlockSize];
-                        memcpy( aTmp, aVector, iBlockSize );
-                        for( int j = 0; j < iBlockSize; j++ )
-                                ((uint8_t *)pBuf)[j] ^= aVector[j];
-                        memcpy( aVector, aTmp, iBlockSize );
-                }
-
-                void encipher( void *pBuf )
-                {
-                        CipherType::encipher( aVector );
-                        uint8_t aTmp[iBlockSize];
-                        memcpy( aTmp, aVector, iBlockSize );
-                        for( int j = 0; j < iBlockSize; j++ )
-                                ((uint8_t *)pBuf)[j] ^= aVector[j];
-                        memcpy( aVector, aTmp, iBlockSize );
-                }
-
-        private:
-                bool bStart;
-                uint8_t aVector[iBlockSize];
-        };
+    template<int iBlockSize, typename CipherType>
+    class CipherModeOfb : public CipherType
+    {
+    public:
+        CipherModeOfb(class Stream &rNext ) :
+            CipherType( rNext ),
+            bStart( true )
+        {
+            memset( aVector, 0, iBlockSize );
+        }
+
+        virtual ~CipherModeOfb()
+        {
+        }
+
+        void setIv( const Bu::String &sIv )
+        {
+            memcpy( aVector, sIv.getStr(), iBlockSize );
+        }
+
+    protected:
+        void decipher( void *pBuf )
+        {
+            CipherType::encipher( aVector );
+            uint8_t aTmp[iBlockSize];
+            memcpy( aTmp, aVector, iBlockSize );
+            for( int j = 0; j < iBlockSize; j++ )
+                ((uint8_t *)pBuf)[j] ^= aVector[j];
+            memcpy( aVector, aTmp, iBlockSize );
+        }
+
+        void encipher( void *pBuf )
+        {
+            CipherType::encipher( aVector );
+            uint8_t aTmp[iBlockSize];
+            memcpy( aTmp, aVector, iBlockSize );
+            for( int j = 0; j < iBlockSize; j++ )
+                ((uint8_t *)pBuf)[j] ^= aVector[j];
+            memcpy( aVector, aTmp, iBlockSize );
+        }
+
+    private:
+        bool bStart;
+        uint8_t aVector[iBlockSize];
+    };
 };
 
 #endif
diff --git a/src/experimental/dir.h b/src/experimental/dir.h
index 8e885d1..9e518eb 100644
--- a/src/experimental/dir.h
+++ b/src/experimental/dir.h
@@ -6,15 +6,15 @@
 
 namespace Bu
 {
-        class Dir : public FileSystem
-        {
-        public:
-                Dir();
-                Dir( const Bu::String &sPath );
-                virtual ~Dir();
+    class Dir : public FileSystem
+    {
+    public:
+        Dir();
+        Dir( const Bu::String &sPath );
+        virtual ~Dir();
 
-        private:
-        };
+    private:
+    };
 };
 
 #endif
diff --git a/src/experimental/fastcgi.cpp b/src/experimental/fastcgi.cpp
index 7068fa8..71426b9 100644
--- a/src/experimental/fastcgi.cpp
+++ b/src/experimental/fastcgi.cpp
@@ -8,7 +8,7 @@
 #include "bu/fastcgi.h"
 
 #ifndef WIN32
-        #include <arpa/inet.h>
+    #include <arpa/inet.h>
 #endif
 
 #include <errno.h>
@@ -21,17 +21,17 @@ using Bu::sio;
 using Bu::Fmt;
 
 Bu::FastCgi::FastCgi() :
-        pSrv( NULL ),
-        bRunning( true )
+    pSrv( NULL ),
+    bRunning( true )
 {
-        pSrv = new Bu::TcpServerSocket( (Bu::TcpServerSocket::socket_t)STDIN_FILENO, false );
+    pSrv = new Bu::TcpServerSocket( (Bu::TcpServerSocket::socket_t)STDIN_FILENO, false );
 }
 
 Bu::FastCgi::FastCgi( int iPort ) :
-        pSrv( NULL ),
-        bRunning( true )
+    pSrv( NULL ),
+    bRunning( true )
 {
-        pSrv = new Bu::TcpServerSocket( iPort );
+    pSrv = new Bu::TcpServerSocket( iPort );
 }
 
 Bu::FastCgi::~FastCgi()
@@ -41,332 +41,332 @@ Bu::FastCgi::~FastCgi()
 bool Bu::FastCgi::isEmbedded()
 {
 #ifndef WIN32
-        struct sockaddr name;
-        socklen_t namelen = sizeof(name);
-        if( getpeername( STDIN_FILENO, &name, &namelen ) != 0 &&
-                errno == ENOTCONN )
-        {
-                sio << "errno = " << errno << " (" << strerror( errno ) << ")" <<
-                        sio.nl;
-                sio << "Socket found" << sio.nl;
-                return true;
-        }
-        else
-        {
-                sio << "errno = " << errno << " (" << strerror( errno ) << ")" <<
-                        sio.nl;
-                sio << "No socket detected, running in standalone mode" << sio.nl;
-                return false;
-        }
+    struct sockaddr name;
+    socklen_t namelen = sizeof(name);
+    if( getpeername( STDIN_FILENO, &name, &namelen ) != 0 &&
+        errno == ENOTCONN )
+    {
+        sio << "errno = " << errno << " (" << strerror( errno ) << ")" <<
+            sio.nl;
+        sio << "Socket found" << sio.nl;
+        return true;
+    }
+    else
+    {
+        sio << "errno = " << errno << " (" << strerror( errno ) << ")" <<
+            sio.nl;
+        sio << "No socket detected, running in standalone mode" << sio.nl;
+        return false;
+    }
 #else
-        #warning Bu::FastCgi::isEmbedded IS A STUB for WIN32!!!!
-        return false;
+    #warning Bu::FastCgi::isEmbedded IS A STUB for WIN32!!!!
+    return false;
 #endif
 }
 
 void Bu::FastCgi::read( Bu::TcpSocket &s, Bu::FastCgi::Record &r )
 {
-        int iRead = s.read( &r, sizeof(Record) );
-        if( iRead != sizeof(Record) )
-                throw Bu::TcpSocketException("Hey, the size %d is wrong for Record. (%s)",
-                        iRead, strerror( errno ) );
-        r.uRequestId = ntohs( r.uRequestId );
-        r.uContentLength = ntohs( r.uContentLength );
+    int iRead = s.read( &r, sizeof(Record) );
+    if( iRead != sizeof(Record) )
+        throw Bu::TcpSocketException("Hey, the size %d is wrong for Record. (%s)",
+            iRead, strerror( errno ) );
+    r.uRequestId = ntohs( r.uRequestId );
+    r.uContentLength = ntohs( r.uContentLength );
 }
 
 void Bu::FastCgi::write( Bu::TcpSocket &s, Bu::FastCgi::Record r )
 {
-//      sio << "Out -> " << r << sio.nl;
-        r.uRequestId = htons( r.uRequestId );
-        r.uContentLength = htons( r.uContentLength );
-        s.write( &r, sizeof(Record) );
+//  sio << "Out -> " << r << sio.nl;
+    r.uRequestId = htons( r.uRequestId );
+    r.uContentLength = htons( r.uContentLength );
+    s.write( &r, sizeof(Record) );
 }
 
 void Bu::FastCgi::read( Bu::TcpSocket &s, Bu::FastCgi::BeginRequestBody &b )
 {
-        s.read( &b, sizeof(BeginRequestBody) );
-        b.uRole = ntohs( b.uRole );
+    s.read( &b, sizeof(BeginRequestBody) );
+    b.uRole = ntohs( b.uRole );
 }
 
 void Bu::FastCgi::write( Bu::TcpSocket &s, Bu::FastCgi::EndRequestBody b )
 {
-        b.uStatus = htonl( b.uStatus );
-        s.write( &b, sizeof(b) );
+    b.uStatus = htonl( b.uStatus );
+    s.write( &b, sizeof(b) );
 }
 
 uint32_t Bu::FastCgi::readLen( Bu::TcpSocket &s, uint16_t &uRead )
 {
-        uint8_t uByte[4];
-        s.read( uByte, 1 );
-        uRead++;
-        if( uByte[0] >> 7 == 0 )
-                return uByte[0];
-        
-        s.read( uByte+1, 3 );
-        uRead += 3;
-        return ((uByte[0]&0x7f)<<24)|(uByte[1]<<16)|(uByte[2]<<8)|(uByte[3]);
+    uint8_t uByte[4];
+    s.read( uByte, 1 );
+    uRead++;
+    if( uByte[0] >> 7 == 0 )
+        return uByte[0];
+    
+    s.read( uByte+1, 3 );
+    uRead += 3;
+    return ((uByte[0]&0x7f)<<24)|(uByte[1]<<16)|(uByte[2]<<8)|(uByte[3]);
 }
 
 void Bu::FastCgi::readPair( Bu::TcpSocket &s, StrHash &hParams, uint16_t &uRead )
 {
-        uint32_t uName = readLen( s, uRead );
-        uint32_t uValue = readLen( s, uRead );
-        uRead += uName + uValue;
-        unsigned char *sName = new unsigned char[uName];
-        s.read( sName, uName );
-        Bu::String fsName( (char *)sName, uName );
-        delete[] sName;
-
-        if( uValue > 0 )
-        {
-                unsigned char *sValue = new unsigned char[uValue];
-                s.read( sValue, uValue );
-                Bu::String fsValue( (char *)sValue, uValue );
-                hParams.insert( fsName, fsValue );
-                delete[] sValue;
-        }
-        else
-        {
-                hParams.insert( fsName, "" );
-        }
+    uint32_t uName = readLen( s, uRead );
+    uint32_t uValue = readLen( s, uRead );
+    uRead += uName + uValue;
+    unsigned char *sName = new unsigned char[uName];
+    s.read( sName, uName );
+    Bu::String fsName( (char *)sName, uName );
+    delete[] sName;
+
+    if( uValue > 0 )
+    {
+        unsigned char *sValue = new unsigned char[uValue];
+        s.read( sValue, uValue );
+        Bu::String fsValue( (char *)sValue, uValue );
+        hParams.insert( fsName, fsValue );
+        delete[] sValue;
+    }
+    else
+    {
+        hParams.insert( fsName, "" );
+    }
 }
 
 bool Bu::FastCgi::hasChannel( int iChan )
 {
-        if( aChannel.getSize() < iChan )
-                return false;
-        if( aChannel[iChan-1] == NULL )
-                return false;
-        return true;
+    if( aChannel.getSize() < iChan )
+        return false;
+    if( aChannel[iChan-1] == NULL )
+        return false;
+    return true;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::FastCgi::Record &r )
 {
-        f << "[Ver=" << (uint32_t)r.uVersion <<
-                ", Type=" << (uint32_t)r.uType <<
-                ", Req=" << (uint32_t)r.uRequestId <<
-                ", clen=" << (uint32_t)r.uContentLength <<
-                ", plen=" << (uint32_t)r.uPaddingLength <<
-                ", resv=" << (uint32_t)r.uReserved <<
-                "]";
-        return f;
+    f << "[Ver=" << (uint32_t)r.uVersion <<
+        ", Type=" << (uint32_t)r.uType <<
+        ", Req=" << (uint32_t)r.uRequestId <<
+        ", clen=" << (uint32_t)r.uContentLength <<
+        ", plen=" << (uint32_t)r.uPaddingLength <<
+        ", resv=" << (uint32_t)r.uReserved <<
+        "]";
+    return f;
 }
 
 void Bu::FastCgi::run()
 {
-//      sio << "sizeof(Bu::FastCgi::Record) = " << sizeof(Record) << sio.nl;
-        bRunning = true;
-        while( bRunning )
-        {
-                int iSock = pSrv->accept( 5 );
-                if( iSock < 0 )
-                        continue;
-
-                Bu::TcpSocket s( iSock );
-                s.setBlocking( true );
-//              sio << "Got connection, blocking?  " << s.isBlocking() << sio.nl;
-                try
-                {
-                        for(;;)
-                        {
-                                Record r;
-                                memset( &r, 0, sizeof(r) );
-//                              try
-//                              {
-                                        read( s, r );
-//                              }
-//                              catch( Bu::ExceptionBase &e )
-//                              {
-//                                      sio << "Error: " << e.what() << ", " << s.isOpen() <<
-//                                              sio.nl;
-//                                      continue;
-//                              }
-                                Channel *pChan = NULL;
-                                if( r.uRequestId > 0 )
-                                {
-                                        if( !hasChannel( r.uRequestId ) &&
-                                                r.uType != typeBeginRequest )
-                                        {
-                                                sio << "Error, stream data without stream." << sio.nl;
-                                                sio << r << sio.nl;
-                                                if( r.uContentLength > 0 )
-                                                {
-                                                        char *buf = new char[r.uContentLength];
-                                                        sio << " (read " << s.read( buf, r.uContentLength )
-                                                                << "/" << r.uContentLength << "):" << sio.nl;
-                                                        sio.write( buf, r.uContentLength );
-                                                        sio << sio.nl << sio.nl;
-                                                }
-                                        }
-                                        while( aChannel.getSize() < r.uRequestId )
-                                                aChannel.append( NULL );
-                                        if( r.uRequestId > 0 )
-                                                pChan = aChannel[r.uRequestId-1];
-                                }
-
-//                              sio << "Record (id=" << r.uRequestId << ", len=" << 
-//                                      r.uContentLength << ", pad=" << 
-//                                      (unsigned int)r.uPaddingLength << "):  ";
-//                              fflush( stdout );
-                                
-                                switch( (RequestType)r.uType )
-                                {
-                                        case typeBeginRequest:
-//                                              sio << "Begin Request.";
-                                                {
-                                                        BeginRequestBody b;
-                                                        read( s, b );
-                                                        if( pChan != NULL )
-                                                        {
-                                                                sio << "Error!!!" << sio.nl;
-                                                                return;
-                                                        }
-                                                        pChan = aChannel[r.uRequestId-1] = new Channel();
-                                                }
-                                                break;
-
-                                        case typeParams:
-//                                              sio << "Params.";
-                                                if( r.uContentLength == 0 )
-                                                {
-                                                        pChan->uFlags |= chflgParamsDone;
-                                                }
-                                                else
-                                                {
-                                                        uint16_t uUsed = 0;
-                                                        while( uUsed < r.uContentLength )
-                                                        {
-                                                                readPair( s, pChan->hParams, uUsed );
-                                                        }
-                                                }
-                                                break;
-
-                                        case typeStdIn:
-//                                              sio << "StdIn.";
-                                                if( r.uContentLength == 0 )
-                                                {
-                                                        pChan->uFlags |= chflgStdInDone;
-                                                }
-                                                else
-                                                {
-                                                        char *buf = new char[r.uContentLength];
-                                                        int iTotal = 0;
-                                                        do
-                                                        {
-                                                                size_t iRead = s.read(
-                                                                        buf, r.uContentLength-iTotal );
-                                                                iTotal += iRead;
-//                                                              sio << " (read " << iRead << " " << iTotal
-//                                                                      << "/" << r.uContentLength << ")";
-                                                                pChan->sStdIn.append( buf, iRead );
-                                                        } while( iTotal < r.uContentLength );
-                                                        delete[] buf;
-                                                }
-                                                break;
-
-                                        case typeData:
-//                                              sio << "Data.";
-                                                if( r.uContentLength == 0 )
-                                                {
-                                                        pChan->uFlags |= chflgDataDone;
-                                                }
-                                                else
-                                                {
-                                                        char *buf = new char[r.uContentLength];
-                                                        s.read( buf, r.uContentLength );
-                                                        pChan->sData.append( buf, r.uContentLength );
-                                                        delete[] buf;
-                                                }
-                                                break;
-
-                                        case typeStdOut:
-                                        case typeStdErr:
-                                        case typeEndRequest:
-                                        case typeAbortRequest:
-                                        case typeGetValuesResult:
-//                                              sio << "Scary.";
-                                                // ??? we shouldn't get these.
-                                                break;
-
-                                        case typeGetValues:
-                                                break;
-                                }
-
-//                              sio << sio.nl;
-
-                                if( pChan )
-                                {
-                                        if( pChan->uFlags == chflgAllDone )
-                                        {
-//                                              sio << "All done, generating output." << sio.nl;
-                                                Bu::MemBuf mStdOut, mStdErr;
-                                                int iRet = onRequest(
-                                                        pChan->hParams, pChan->sStdIn,
-                                                        mStdOut, mStdErr
-                                                        );
-
-                                                Bu::String &sStdOut = mStdOut.getString();
-                                                Bu::String &sStdErr = mStdErr.getString();
-
-                                                Record rOut;
-                                                memset( &rOut, 0, sizeof(rOut) );
-                                                rOut.uVersion = 1;
-                                                rOut.uRequestId = r.uRequestId;
-                                                rOut.uPaddingLength = 0;
-                                                rOut.uType = typeStdOut;
-                                                if( sStdOut.getSize() > 0 )
-                                                {
-                                                        for( int iPos = 0; iPos < sStdOut.getSize();
-                                                                 iPos += 65528 )
-                                                        {
-                                                                int iSize = sStdOut.getSize()-iPos;
-                                                                if( iSize > 65528 )
-                                                                        iSize = 65528;
-                                                                rOut.uContentLength = iSize;
-                                                                write( s, rOut );
-                                                                s.write( sStdOut.getStr()+iPos, iSize );
-                                                        }
-                                                }
-                                                rOut.uContentLength = 0;
-                                                write( s, rOut );
-
-                                                rOut.uType = typeStdErr;
-                                                if( sStdErr.getSize() > 0 )
-                                                {
-                                                        for( int iPos = 0; iPos < sStdErr.getSize();
-                                                                 iPos += 65528 )
-                                                        {
-                                                                int iSize = sStdErr.getSize()-iPos;
-                                                                if( iSize > 65528 )
-                                                                        iSize = 65528;
-                                                                rOut.uContentLength = iSize;
-                                                                write( s, rOut );
-                                                                s.write( sStdErr.getStr()+iPos, iSize );
-                                                        }
-                                                }
-                                                rOut.uContentLength = 0;
-                                                write( s, rOut );
-
-                                                rOut.uType = typeEndRequest;
-                                                rOut.uContentLength = 8;
-                                                write( s, rOut );
-                                                
-                                                EndRequestBody b;
-                                                memset( &b, 0, sizeof(b) );
-                                                b.uStatus =  iRet;
-                                                write( s, b );
-
-                                                delete pChan;
-                                                aChannel[r.uRequestId-1] = NULL;
-                                        }
-                                }
-                        }
-                }
-                catch( Bu::TcpSocketException &e )
-                {
-//                      sio << "Bu::SocketException: " << e.what() << sio.nl <<
-//                              "\tSocket open:  " << s.isOpen() << sio.nl;
-                }
-        }
+//  sio << "sizeof(Bu::FastCgi::Record) = " << sizeof(Record) << sio.nl;
+    bRunning = true;
+    while( bRunning )
+    {
+        int iSock = pSrv->accept( 5 );
+        if( iSock < 0 )
+            continue;
+
+        Bu::TcpSocket s( iSock );
+        s.setBlocking( true );
+//      sio << "Got connection, blocking?  " << s.isBlocking() << sio.nl;
+        try
+        {
+            for(;;)
+            {
+                Record r;
+                memset( &r, 0, sizeof(r) );
+//              try
+//              {
+                    read( s, r );
+//              }
+//              catch( Bu::ExceptionBase &e )
+//              {
+//                  sio << "Error: " << e.what() << ", " << s.isOpen() <<
+//                      sio.nl;
+//                  continue;
+//              }
+                Channel *pChan = NULL;
+                if( r.uRequestId > 0 )
+                {
+                    if( !hasChannel( r.uRequestId ) &&
+                        r.uType != typeBeginRequest )
+                    {
+                        sio << "Error, stream data without stream." << sio.nl;
+                        sio << r << sio.nl;
+                        if( r.uContentLength > 0 )
+                        {
+                            char *buf = new char[r.uContentLength];
+                            sio << " (read " << s.read( buf, r.uContentLength )
+                                << "/" << r.uContentLength << "):" << sio.nl;
+                            sio.write( buf, r.uContentLength );
+                            sio << sio.nl << sio.nl;
+                        }
+                    }
+                    while( aChannel.getSize() < r.uRequestId )
+                        aChannel.append( NULL );
+                    if( r.uRequestId > 0 )
+                        pChan = aChannel[r.uRequestId-1];
+                }
+
+//              sio << "Record (id=" << r.uRequestId << ", len=" << 
+//                  r.uContentLength << ", pad=" << 
+//                  (unsigned int)r.uPaddingLength << "):  ";
+//              fflush( stdout );
+                
+                switch( (RequestType)r.uType )
+                {
+                    case typeBeginRequest:
+//                      sio << "Begin Request.";
+                        {
+                            BeginRequestBody b;
+                            read( s, b );
+                            if( pChan != NULL )
+                            {
+                                sio << "Error!!!" << sio.nl;
+                                return;
+                            }
+                            pChan = aChannel[r.uRequestId-1] = new Channel();
+                        }
+                        break;
+
+                    case typeParams:
+//                      sio << "Params.";
+                        if( r.uContentLength == 0 )
+                        {
+                            pChan->uFlags |= chflgParamsDone;
+                        }
+                        else
+                        {
+                            uint16_t uUsed = 0;
+                            while( uUsed < r.uContentLength )
+                            {
+                                readPair( s, pChan->hParams, uUsed );
+                            }
+                        }
+                        break;
+
+                    case typeStdIn:
+//                      sio << "StdIn.";
+                        if( r.uContentLength == 0 )
+                        {
+                            pChan->uFlags |= chflgStdInDone;
+                        }
+                        else
+                        {
+                            char *buf = new char[r.uContentLength];
+                            int iTotal = 0;
+                            do
+                            {
+                                size_t iRead = s.read(
+                                    buf, r.uContentLength-iTotal );
+                                iTotal += iRead;
+//                              sio << " (read " << iRead << " " << iTotal
+//                                  << "/" << r.uContentLength << ")";
+                                pChan->sStdIn.append( buf, iRead );
+                            } while( iTotal < r.uContentLength );
+                            delete[] buf;
+                        }
+                        break;
+
+                    case typeData:
+//                      sio << "Data.";
+                        if( r.uContentLength == 0 )
+                        {
+                            pChan->uFlags |= chflgDataDone;
+                        }
+                        else
+                        {
+                            char *buf = new char[r.uContentLength];
+                            s.read( buf, r.uContentLength );
+                            pChan->sData.append( buf, r.uContentLength );
+                            delete[] buf;
+                        }
+                        break;
+
+                    case typeStdOut:
+                    case typeStdErr:
+                    case typeEndRequest:
+                    case typeAbortRequest:
+                    case typeGetValuesResult:
+//                      sio << "Scary.";
+                        // ??? we shouldn't get these.
+                        break;
+
+                    case typeGetValues:
+                        break;
+                }
+
+//              sio << sio.nl;
+
+                if( pChan )
+                {
+                    if( pChan->uFlags == chflgAllDone )
+                    {
+//                      sio << "All done, generating output." << sio.nl;
+                        Bu::MemBuf mStdOut, mStdErr;
+                        int iRet = onRequest(
+                            pChan->hParams, pChan->sStdIn,
+                            mStdOut, mStdErr
+                            );
+
+                        Bu::String &sStdOut = mStdOut.getString();
+                        Bu::String &sStdErr = mStdErr.getString();
+
+                        Record rOut;
+                        memset( &rOut, 0, sizeof(rOut) );
+                        rOut.uVersion = 1;
+                        rOut.uRequestId = r.uRequestId;
+                        rOut.uPaddingLength = 0;
+                        rOut.uType = typeStdOut;
+                        if( sStdOut.getSize() > 0 )
+                        {
+                            for( int iPos = 0; iPos < sStdOut.getSize();
+                                 iPos += 65528 )
+                            {
+                                int iSize = sStdOut.getSize()-iPos;
+                                if( iSize > 65528 )
+                                    iSize = 65528;
+                                rOut.uContentLength = iSize;
+                                write( s, rOut );
+                                s.write( sStdOut.getStr()+iPos, iSize );
+                            }
+                        }
+                        rOut.uContentLength = 0;
+                        write( s, rOut );
+
+                        rOut.uType = typeStdErr;
+                        if( sStdErr.getSize() > 0 )
+                        {
+                            for( int iPos = 0; iPos < sStdErr.getSize();
+                                 iPos += 65528 )
+                            {
+                                int iSize = sStdErr.getSize()-iPos;
+                                if( iSize > 65528 )
+                                    iSize = 65528;
+                                rOut.uContentLength = iSize;
+                                write( s, rOut );
+                                s.write( sStdErr.getStr()+iPos, iSize );
+                            }
+                        }
+                        rOut.uContentLength = 0;
+                        write( s, rOut );
+
+                        rOut.uType = typeEndRequest;
+                        rOut.uContentLength = 8;
+                        write( s, rOut );
+                        
+                        EndRequestBody b;
+                        memset( &b, 0, sizeof(b) );
+                        b.uStatus =  iRet;
+                        write( s, b );
+
+                        delete pChan;
+                        aChannel[r.uRequestId-1] = NULL;
+                    }
+                }
+            }
+        }
+        catch( Bu::TcpSocketException &e )
+        {
+//          sio << "Bu::SocketException: " << e.what() << sio.nl <<
+//              "\tSocket open:  " << s.isOpen() << sio.nl;
+        }
+    }
 }
 
diff --git a/src/experimental/fastcgi.h b/src/experimental/fastcgi.h
index 63d975f..50b10f5 100644
--- a/src/experimental/fastcgi.h
+++ b/src/experimental/fastcgi.h
@@ -16,118 +16,118 @@
 
 namespace Bu
 {
-        class Stream;
-
-        class FastCgi
-        {
-        public:
-                FastCgi( int iPort );
-                FastCgi();
-                virtual ~FastCgi();
-
-                static bool isEmbedded();
-
-                typedef Bu::Hash<Bu::String, Bu::String> StrHash;
-                enum RequestType
-                {
-                        typeBeginRequest        = 1,
-                        typeAbortRequest        = 2,
-                        typeEndRequest          = 3,
-                        typeParams                      = 4,
-                        typeStdIn                       = 5,
-                        typeStdOut                      = 6,
-                        typeStdErr                      = 7,
-                        typeData                        = 8,
-                        typeGetValues           = 9,
-                        typeGetValuesResult     = 10
-                };
-
-                enum Role
-                {
-                        roleResponder           = 1,
-                        roleAuthorizer          = 2,
-                        roleFilter                      = 3
-                };
-
-                enum Flags
-                {
-                        flagsKeepConn           = 1
-                };
-
-                enum Status
-                {
-                        statusRequestComplete   = 0,
-                        statusCantMpxConn               = 1,
-                        statusOverloaded                = 2,
-                        statusUnknownRole               = 3
-                };
-
-                typedef struct {
-                        uint8_t uVersion;
-                        uint8_t uType;
-                        uint16_t uRequestId;
-                        uint16_t uContentLength;
-                        uint8_t uPaddingLength;
-                        uint8_t uReserved;
-                } Record;
-
-                typedef struct {
-                        uint16_t uRole;
-                        uint8_t uFlags;
-                        uint8_t reserved[5];
-                } BeginRequestBody;
-
-                typedef struct {
-                        uint32_t uStatus;
-                        uint8_t uProtocolStatus;
-                        uint8_t reserved[3];
-                } EndRequestBody;
-
-                typedef struct Channel {
-                        Channel() : uFlags( 0 ) { }
-                        StrHash hParams;
-                        Bu::String sStdIn;
-                        Bu::String sData;
-                        uint8_t uFlags;
-                } Channel;
-
-                enum ChannelFlags
-                {
-                        chflgParamsDone         = 0x01,
-                        chflgStdInDone          = 0x02,
-                        chflgDataDone           = 0x04,
-
-                        chflgAllDone            = 0x03
-                };
-
-                virtual void run();
-
-                void stopRunning() { bRunning = false; }
-
-                virtual void onInit() { };
-                virtual int onRequest( const StrHash &hParams,
-                        const Bu::String &sStdIn, Bu::Stream &sStdOut,
-                        Bu::Stream &sStdErr )=0;
-                virtual void onUninit() { };
-
-        private:
-                void read( Bu::TcpSocket &s, Record &r );
-                void read( Bu::TcpSocket &s, BeginRequestBody &b );
-                uint32_t readLen( Bu::TcpSocket &s, uint16_t &uUsed );
-                void readPair( Bu::TcpSocket &s, StrHash &hParams, uint16_t &uUsed );
-
-                void write( Bu::TcpSocket &s, Record r );
-                void write( Bu::TcpSocket &s, EndRequestBody b );
-
-                bool hasChannel( int iChan );
-
-        private:
-                Bu::TcpServerSocket *pSrv;
-                bool bRunning;
-                Bu::Array<Channel *> aChannel;
-        };
-
-        Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::FastCgi::Record &r );
+    class Stream;
+
+    class FastCgi
+    {
+    public:
+        FastCgi( int iPort );
+        FastCgi();
+        virtual ~FastCgi();
+
+        static bool isEmbedded();
+
+        typedef Bu::Hash<Bu::String, Bu::String> StrHash;
+        enum RequestType
+        {
+            typeBeginRequest    = 1,
+            typeAbortRequest    = 2,
+            typeEndRequest      = 3,
+            typeParams          = 4,
+            typeStdIn           = 5,
+            typeStdOut          = 6,
+            typeStdErr          = 7,
+            typeData            = 8,
+            typeGetValues       = 9,
+            typeGetValuesResult = 10
+        };
+
+        enum Role
+        {
+            roleResponder       = 1,
+            roleAuthorizer      = 2,
+            roleFilter          = 3
+        };
+
+        enum Flags
+        {
+            flagsKeepConn       = 1
+        };
+
+        enum Status
+        {
+            statusRequestComplete   = 0,
+            statusCantMpxConn       = 1,
+            statusOverloaded        = 2,
+            statusUnknownRole       = 3
+        };
+
+        typedef struct {
+            uint8_t uVersion;
+            uint8_t uType;
+            uint16_t uRequestId;
+            uint16_t uContentLength;
+            uint8_t uPaddingLength;
+            uint8_t uReserved;
+        } Record;
+
+        typedef struct {
+            uint16_t uRole;
+            uint8_t uFlags;
+            uint8_t reserved[5];
+        } BeginRequestBody;
+
+        typedef struct {
+            uint32_t uStatus;
+            uint8_t uProtocolStatus;
+            uint8_t reserved[3];
+        } EndRequestBody;
+
+        typedef struct Channel {
+            Channel() : uFlags( 0 ) { }
+            StrHash hParams;
+            Bu::String sStdIn;
+            Bu::String sData;
+            uint8_t uFlags;
+        } Channel;
+
+        enum ChannelFlags
+        {
+            chflgParamsDone     = 0x01,
+            chflgStdInDone      = 0x02,
+            chflgDataDone       = 0x04,
+
+            chflgAllDone        = 0x03
+        };
+
+        virtual void run();
+
+        void stopRunning() { bRunning = false; }
+
+        virtual void onInit() { };
+        virtual int onRequest( const StrHash &hParams,
+            const Bu::String &sStdIn, Bu::Stream &sStdOut,
+            Bu::Stream &sStdErr )=0;
+        virtual void onUninit() { };
+
+    private:
+        void read( Bu::TcpSocket &s, Record &r );
+        void read( Bu::TcpSocket &s, BeginRequestBody &b );
+        uint32_t readLen( Bu::TcpSocket &s, uint16_t &uUsed );
+        void readPair( Bu::TcpSocket &s, StrHash &hParams, uint16_t &uUsed );
+
+        void write( Bu::TcpSocket &s, Record r );
+        void write( Bu::TcpSocket &s, EndRequestBody b );
+
+        bool hasChannel( int iChan );
+
+    private:
+        Bu::TcpServerSocket *pSrv;
+        bool bRunning;
+        Bu::Array<Channel *> aChannel;
+    };
+
+    Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::FastCgi::Record &r );
 };
 
 #endif
diff --git a/src/experimental/filesystem.h b/src/experimental/filesystem.h
index 0c992a5..d25cb67 100644
--- a/src/experimental/filesystem.h
+++ b/src/experimental/filesystem.h
@@ -3,22 +3,22 @@
 
 namespace Bu
 {
-        /**
-         * Represents an abstract baseclass for any file organization structure.
-         * If you're looking for acessing a local filesystem, try Bu::Dir.  This
-         * is used to make switching between different types of filesystems
-         * seamless.  FileSystems could be anything that organizes and grants
-         * access to file data, local filesystems, FTP servers, zip or myriadfs
-         * files, etc.
-         */
-        class FileSystem
-        {
-        public:
-                FileSystem();
-                virtual ~FileSystem();
+    /**
+     * Represents an abstract baseclass for any file organization structure.
+     * If you're looking for acessing a local filesystem, try Bu::Dir.  This
+     * is used to make switching between different types of filesystems
+     * seamless.  FileSystems could be anything that organizes and grants
+     * access to file data, local filesystems, FTP servers, zip or myriadfs
+     * files, etc.
+     */
+    class FileSystem
+    {
+    public:
+        FileSystem();
+        virtual ~FileSystem();
 
-        
-        };
+    
+    };
 };
 
 #endif
diff --git a/src/experimental/httpget.cpp b/src/experimental/httpget.cpp
index 7a8a89a..70c722c 100644
--- a/src/experimental/httpget.cpp
+++ b/src/experimental/httpget.cpp
@@ -8,11 +8,11 @@
 #include "bu/httpget.h"
 
 Bu::HttpGet::HttpGet( const Bu::Url &uSrc, const Bu::String &sMethod ) :
-        uSrc( uSrc ),
-        sMethod( sMethod ),
-        sSrv( uSrc.getHost(), uSrc.getPort() )
+    uSrc( uSrc ),
+    sMethod( sMethod ),
+    sSrv( uSrc.getHost(), uSrc.getPort() )
 {
-        sSrv.write( sMethod + " " + uSrc.getFullPath() + " HTTP/1.1\r\n" );
+    sSrv.write( sMethod + " " + uSrc.getFullPath() + " HTTP/1.1\r\n" );
 }
 
 Bu::HttpGet::~HttpGet()
@@ -25,28 +25,28 @@ void Bu::HttpGet::close()
 
 void Bu::HttpGet::get()
 {
-        for( MimeHash::iterator i = hMimeOut.begin(); i; i++ )
-        {
-                sSrv.write( i.getKey() + ": " + i.getValue() + "\r\n" );
-        }
-        sSrv.write("\r\n", 2 );
+    for( MimeHash::iterator i = hMimeOut.begin(); i; i++ )
+    {
+        sSrv.write( i.getKey() + ": " + i.getValue() + "\r\n" );
+    }
+    sSrv.write("\r\n", 2 );
 
-//      sSrv.read(
+//  sSrv.read(
 }
 
 Bu::size Bu::HttpGet::read( void * /*pBuf*/, Bu::size /*nBytes*/ )
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::HttpGet::write( const void * /*pBuf*/, Bu::size /*nBytes*/ )
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::HttpGet::tell()
 {
-        return 0;
+    return 0;
 }
 
 void Bu::HttpGet::seek( Bu::size )
@@ -63,12 +63,12 @@ void Bu::HttpGet::setPosEnd( Bu::size )
 
 bool Bu::HttpGet::isEos()
 {
-        return false;
+    return false;
 }
 
 bool Bu::HttpGet::isOpen()
 {
-        return true;
+    return true;
 }
 
 void Bu::HttpGet::flush()
@@ -77,32 +77,32 @@ void Bu::HttpGet::flush()
 
 bool Bu::HttpGet::canRead()
 {
-        return true;
+    return true;
 }
 
 bool Bu::HttpGet::canWrite()
 {
-        return false;
+    return false;
 }
 
 bool Bu::HttpGet::isReadable()
 {
-        return true;
+    return true;
 }
 
 bool Bu::HttpGet::isWritable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::HttpGet::isSeekable()
 {
-        return false;
+    return false;
 }
 
 bool Bu::HttpGet::isBlocking()
 {
-        return true;
+    return true;
 }
 
 void Bu::HttpGet::setBlocking( bool /*bBlocking*/ )
@@ -111,16 +111,16 @@ void Bu::HttpGet::setBlocking( bool /*bBlocking*/ )
 
 Bu::size Bu::HttpGet::getSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::size Bu::HttpGet::getBlockSize() const
 {
-        return 0;
+    return 0;
 }
 
 Bu::String Bu::HttpGet::getLocation() const
 {
-        return uSrc.getUrl();
+    return uSrc.getUrl();
 }
 
diff --git a/src/experimental/httpget.h b/src/experimental/httpget.h
index e8092e5..21e69d6 100644
--- a/src/experimental/httpget.h
+++ b/src/experimental/httpget.h
@@ -16,51 +16,51 @@
 
 namespace Bu
 {
-        class HttpGet : public Bu::Stream
-        {
-        public:
-                HttpGet( const Bu::Url &uSrc, const Bu::String &sMethod="GET" );
-                virtual ~HttpGet();
+    class HttpGet : public Bu::Stream
+    {
+    public:
+        HttpGet( const Bu::Url &uSrc, const Bu::String &sMethod="GET" );
+        virtual ~HttpGet();
 
-                void get();
+        void get();
 
-                // From Bu::Stream
-                virtual void close();
-                virtual Bu::size read( void *pBuf, Bu::size nBytes );
-                virtual Bu::size write( const void *pBuf, Bu::size nBytes );
-                using Stream::write;
+        // From Bu::Stream
+        virtual void close();
+        virtual Bu::size read( void *pBuf, Bu::size nBytes );
+        virtual Bu::size write( const void *pBuf, Bu::size nBytes );
+        using Stream::write;
 
-                virtual Bu::size tell();
-                virtual void seek( Bu::size offset );
-                virtual void setPos( Bu::size pos );
-                virtual void setPosEnd( Bu::size pos );
-                virtual bool isEos();
-                virtual bool isOpen();
+        virtual Bu::size tell();
+        virtual void seek( Bu::size offset );
+        virtual void setPos( Bu::size pos );
+        virtual void setPosEnd( Bu::size pos );
+        virtual bool isEos();
+        virtual bool isOpen();
 
-                virtual void flush();
+        virtual void flush();
 
-                virtual bool canRead();
-                virtual bool canWrite();
+        virtual bool canRead();
+        virtual bool canWrite();
 
-                virtual bool isReadable();
-                virtual bool isWritable();
-                virtual bool isSeekable();
+        virtual bool isReadable();
+        virtual bool isWritable();
+        virtual bool isSeekable();
 
-                virtual bool isBlocking();
-                virtual void setBlocking( bool bBlocking=true );
+        virtual bool isBlocking();
+        virtual void setBlocking( bool bBlocking=true );
 
-                virtual size getSize() const;
-                virtual size getBlockSize() const;
-                virtual Bu::String getLocation() const;
+        virtual size getSize() const;
+        virtual size getBlockSize() const;
+        virtual Bu::String getLocation() const;
 
-        private:
-                Bu::Url uSrc;
-                Bu::String sMethod;
-                Bu::TcpSocket sSrv;
-                typedef Bu::Hash<Bu::String,Bu::String> MimeHash;
-                MimeHash hMimeIn;
-                MimeHash hMimeOut;
-        };
+    private:
+        Bu::Url uSrc;
+        Bu::String sMethod;
+        Bu::TcpSocket sSrv;
+        typedef Bu::Hash<Bu::String,Bu::String> MimeHash;
+        MimeHash hMimeIn;
+        MimeHash hMimeOut;
+    };
 };
 
 #endif
diff --git a/src/experimental/lexer.cpp b/src/experimental/lexer.cpp
index 48ee017..ae95d09 100644
--- a/src/experimental/lexer.cpp
+++ b/src/experimental/lexer.cpp
@@ -18,23 +18,23 @@ Bu::Lexer::~Lexer()
 }
 
 Bu::Lexer::Token::Token() :
-        iToken( -1 )
+    iToken( -1 )
 {
 }
 
 Bu::Lexer::Token::Token( Bu::Lexer::TokenType iToken ) :
-        iToken( iToken )
+    iToken( iToken )
 {
 }
 
 Bu::String Bu::Lexer::tokenToString( const Bu::Lexer::Token &t )
 {
-        Bu::MemBuf mb;
-        Bu::Formatter f( mb );
-        f << "<" << t.iToken << ">";
-        if( t.vExtra.isSet() )
-                f << " (" << t.vExtra << ")";
+    Bu::MemBuf mb;
+    Bu::Formatter f( mb );
+    f << "<" << t.iToken << ">";
+    if( t.vExtra.isSet() )
+        f << " (" << t.vExtra << ")";
 
-        return mb.getString();
+    return mb.getString();
 }
 
diff --git a/src/experimental/lexer.h b/src/experimental/lexer.h
index 69f4106..273f3cf 100644
--- a/src/experimental/lexer.h
+++ b/src/experimental/lexer.h
@@ -12,47 +12,47 @@
 
 namespace Bu
 {
-        class Stream;
-
-        /**
-         * The base class for creating a lexical analyzer.  This is designed to work
-         * in tandem with the Bu::Parser class, which uses this to tokenize textual
-         * input.  It can be used by just about anything that cares about tokens
-         * more than raw input, though.
-         */
-        class Lexer
-        {
-        public:
-                Lexer();
-                virtual ~Lexer();
-
-                typedef int TokenType;
-
-                class Token
-                {
-                public:
-                        Token();
-                        Token( TokenType iToken );
-
-                        template<class t>
-                        Token( TokenType iToken, const t &v ) :
-                                iToken( iToken )//,
-//                              vExtra( v )
-                        {
-                                vExtra = v;
-                        }
-                        TokenType iToken;
-                        Bu::Variant vExtra;
-                        int iStartCol;
-                        int iStartRow;
-                        int iEndCol;
-                        int iEndRow;
-                };
-
-                virtual Token *nextToken()=0;
-
-                virtual Bu::String tokenToString( const Token &t );
-        };
+    class Stream;
+
+    /**
+     * The base class for creating a lexical analyzer.  This is designed to work
+     * in tandem with the Bu::Parser class, which uses this to tokenize textual
+     * input.  It can be used by just about anything that cares about tokens
+     * more than raw input, though.
+     */
+    class Lexer
+    {
+    public:
+        Lexer();
+        virtual ~Lexer();
+
+        typedef int TokenType;
+
+        class Token
+        {
+        public:
+            Token();
+            Token( TokenType iToken );
+
+            template<class t>
+            Token( TokenType iToken, const t &v ) :
+                iToken( iToken )//,
+//              vExtra( v )
+            {
+                vExtra = v;
+            }
+            TokenType iToken;
+            Bu::Variant vExtra;
+            int iStartCol;
+            int iStartRow;
+            int iEndCol;
+            int iEndRow;
+        };
+
+        virtual Token *nextToken()=0;
+
+        virtual Bu::String tokenToString( const Token &t );
+    };
 };
 
 #endif
diff --git a/src/experimental/parser.cpp b/src/experimental/parser.cpp
index 9f10256..5d0d7eb 100644
--- a/src/experimental/parser.cpp
+++ b/src/experimental/parser.cpp
@@ -21,231 +21,231 @@ Bu::Parser::~Parser()
 
 void Bu::Parser::pushLexer( Lexer *pLex )
 {
-        sLexer.push( pLex );
+    sLexer.push( pLex );
 }
 
 void Bu::Parser::popLexer()
 {
-        delete sLexer.peekPop();
+    delete sLexer.peekPop();
 }
 
 Lexer::Token *Bu::Parser::popToken()
 {
-        return sToken.peekPop();
+    return sToken.peekPop();
 }
 
 void Bu::Parser::pushToken( Lexer::Token *pTok )
 {
-        sToken.push( pTok );
+    sToken.push( pTok );
 }
 
 void Bu::Parser::parse()
 {
-        int iCurNt = iRootNonTerminal;
-        Lexer::Token *ptCur = sLexer.peek()->nextToken();
-        sio << "Token(a): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
-        selectProduction( iCurNt, ptCur );
-        
-        while( !sState.isEmpty() )
-        {
-                switch( (*sState.peek()).eType )
-                {
-                        case State::typeTerminal:
-                                sio << "terminal: " << ptCur->iToken << " == "
-                                        << (*sState.peek()).iIndex << sio.nl;
-                                if( ptCur->iToken == (*sState.peek()).iIndex )
-                                {
-                                        advanceState();
-                                        delete ptCur;
-                                        ptCur = sLexer.peek()->nextToken();
-                                        sio << "Token(b): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
-                                }
-                                else
-                                {
-                                        throw Bu::ExceptionBase("Error parsing code.");
-                                }
-                                break;
-
-                        case State::typeTerminalPush:
-                                sio << "terminalpush: " << ptCur->iToken << " == "
-                                        << (*sState.peek()).iIndex << sio.nl;
-                                if( ptCur->iToken == (*sState.peek()).iIndex )
-                                {
-                                        advanceState();
-                                        sToken.push( ptCur );
-
-                                        ptCur = sLexer.peek()->nextToken();
-                                        sio << "Token(c): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
-                                }
-                                else
-                                {
-                                        throw Bu::ExceptionBase("Error parsing code.");
-                                }
-                                break;
-
-                        case State::typeNonTerminal:
-                                sio << "nonterminal: " << ptCur->iToken << " --> "
-                                        << (*sState.peek()).iIndex << sio.nl;
-                                {
-                                        int iNt = (*sState.peek()).iIndex;
-                                        sio << "Current state: " << *sState.peek() << sio.nl;
-                                        if( !selectProduction( iNt, ptCur ) )
-                                        {
-                                                throw Bu::ExceptionBase("Error parsing code.");
-                                        }
-                                }
-                                break;
-
-                        case State::typeReduction:
-                                sio << "reduction" << sio.nl;
-                                aReduction[(*sState.peek()).iIndex]( *this );
-                                advanceState();
-                                break;
-                }
-        }       
+    int iCurNt = iRootNonTerminal;
+    Lexer::Token *ptCur = sLexer.peek()->nextToken();
+    sio << "Token(a): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
+    selectProduction( iCurNt, ptCur );
+    
+    while( !sState.isEmpty() )
+    {
+        switch( (*sState.peek()).eType )
+        {
+            case State::typeTerminal:
+                sio << "terminal: " << ptCur->iToken << " == "
+                    << (*sState.peek()).iIndex << sio.nl;
+                if( ptCur->iToken == (*sState.peek()).iIndex )
+                {
+                    advanceState();
+                    delete ptCur;
+                    ptCur = sLexer.peek()->nextToken();
+                    sio << "Token(b): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
+                }
+                else
+                {
+                    throw Bu::ExceptionBase("Error parsing code.");
+                }
+                break;
+
+            case State::typeTerminalPush:
+                sio << "terminalpush: " << ptCur->iToken << " == "
+                    << (*sState.peek()).iIndex << sio.nl;
+                if( ptCur->iToken == (*sState.peek()).iIndex )
+                {
+                    advanceState();
+                    sToken.push( ptCur );
+
+                    ptCur = sLexer.peek()->nextToken();
+                    sio << "Token(c): " << sLexer.peek()->tokenToString( *ptCur ) << sio.nl;
+                }
+                else
+                {
+                    throw Bu::ExceptionBase("Error parsing code.");
+                }
+                break;
+
+            case State::typeNonTerminal:
+                sio << "nonterminal: " << ptCur->iToken << " --> "
+                    << (*sState.peek()).iIndex << sio.nl;
+                {
+                    int iNt = (*sState.peek()).iIndex;
+                    sio << "Current state: " << *sState.peek() << sio.nl;
+                    if( !selectProduction( iNt, ptCur ) )
+                    {
+                        throw Bu::ExceptionBase("Error parsing code.");
+                    }
+                }
+                break;
+
+            case State::typeReduction:
+                sio << "reduction" << sio.nl;
+                aReduction[(*sState.peek()).iIndex]( *this );
+                advanceState();
+                break;
+        }
+    }   
 }
 
 bool Bu::Parser::selectProduction( int iNt, Lexer::Token *ptCur )
 {
-        NonTerminal &nt = aNonTerminal[iNt];
-        int j = 0;
-        for( NonTerminal::ProductionList::iterator i = nt.lProduction.begin();
-                 i; i++,j++ )
-        {
-                if( (*i).isEmpty() )
-                        continue;
-                sio << "-->(Attempting production " << iNt << ":" << j << ": "
-                        << (*i).first() << ")" << sio.nl;
-                if( (*i).first().eType == State::typeTerminal ||
-                        (*i).first().eType == State::typeTerminalPush )
-                {
-                        if( (*i).first().iIndex == ptCur->iToken )
-                        {
-                                sState.push( (*i).begin() );
-                                sio.incIndent();
-                                sio << "Pushing production " << j << " from nt " << iNt
-                                        << sio.nl;
-                                return true;
-                        }
-                }
-                else if( (*i).first().eType == State::typeNonTerminal )
-                {
-                        sState.push( (*i).begin() );
-                        sio.incIndent();
-                        sio << "Pushing production " << j << " from nt " << iNt
-                                << " as test." << sio.nl;
-                        if( !selectProduction( (*i).first().iIndex, ptCur ) )
-                        {
-                                sio.decIndent();
-                                sState.pop();
-                                sio << "Production " << j << " from nt " << iNt
-                                        << " didn't work out." << sio.nl;
-                        }
-                        else
-                        {
-                                return true;
-                        }
-                }
-        }
-        if( nt.bCanSkip )
-        {
-                sio << "Nothing matches, skipping non-terminal." << sio.nl;
-                advanceState();
-                return true;
-        }
-        sio << "-->(Found nothing)" << sio.nl;
-        return false;
+    NonTerminal &nt = aNonTerminal[iNt];
+    int j = 0;
+    for( NonTerminal::ProductionList::iterator i = nt.lProduction.begin();
+         i; i++,j++ )
+    {
+        if( (*i).isEmpty() )
+            continue;
+        sio << "-->(Attempting production " << iNt << ":" << j << ": "
+            << (*i).first() << ")" << sio.nl;
+        if( (*i).first().eType == State::typeTerminal ||
+            (*i).first().eType == State::typeTerminalPush )
+        {
+            if( (*i).first().iIndex == ptCur->iToken )
+            {
+                sState.push( (*i).begin() );
+                sio.incIndent();
+                sio << "Pushing production " << j << " from nt " << iNt
+                    << sio.nl;
+                return true;
+            }
+        }
+        else if( (*i).first().eType == State::typeNonTerminal )
+        {
+            sState.push( (*i).begin() );
+            sio.incIndent();
+            sio << "Pushing production " << j << " from nt " << iNt
+                << " as test." << sio.nl;
+            if( !selectProduction( (*i).first().iIndex, ptCur ) )
+            {
+                sio.decIndent();
+                sState.pop();
+                sio << "Production " << j << " from nt " << iNt
+                    << " didn't work out." << sio.nl;
+            }
+            else
+            {
+                return true;
+            }
+        }
+    }
+    if( nt.bCanSkip )
+    {
+        sio << "Nothing matches, skipping non-terminal." << sio.nl;
+        advanceState();
+        return true;
+    }
+    sio << "-->(Found nothing)" << sio.nl;
+    return false;
 }
 
 void Bu::Parser::advanceState()
 {
-        if( sState.isEmpty() )
-                return;
-
-        sState.peek()++;
-        if( !sState.peek() )
-        {
-                sio.decIndent();
-                sState.pop();
-                sio << "State advanced, End of production." << sio.nl;
-                advanceState();
-                return;
-        }
-        sio << "State advanced, now: " << *(sState.peek()) << sio.nl;
+    if( sState.isEmpty() )
+        return;
+
+    sState.peek()++;
+    if( !sState.peek() )
+    {
+        sio.decIndent();
+        sState.pop();
+        sio << "State advanced, End of production." << sio.nl;
+        advanceState();
+        return;
+    }
+    sio << "State advanced, now: " << *(sState.peek()) << sio.nl;
 }
 
 void Bu::Parser::setRootNonTerminal( int iRoot )
 {
-        iRootNonTerminal = iRoot;
+    iRootNonTerminal = iRoot;
 }
 
 void Bu::Parser::setRootNonTerminal( const Bu::String &sRoot )
 {
-        setRootNonTerminal( hNonTerminalName.get( sRoot ) );
+    setRootNonTerminal( hNonTerminalName.get( sRoot ) );
 }
 
 int Bu::Parser::addNonTerminal( const Bu::String &sName, NonTerminal &nt )
 {
-        int iId = aNonTerminal.getSize();
-        aNonTerminal.append( nt );
-        hNonTerminalName.insert( sName, iId );
-        sio << "nt '" << sName << "' = " << iId << sio.nl;
-        return iId;
+    int iId = aNonTerminal.getSize();
+    aNonTerminal.append( nt );
+    hNonTerminalName.insert( sName, iId );
+    sio << "nt '" << sName << "' = " << iId << sio.nl;
+    return iId;
 }
 
 int Bu::Parser::addNonTerminal( const Bu::String &sName )
 {
-        int iId = aNonTerminal.getSize();
-        aNonTerminal.append( NonTerminal() );
-        hNonTerminalName.insert( sName, iId );
-        sio << "nt '" << sName << "' = " << iId << sio.nl;
-        return iId;
+    int iId = aNonTerminal.getSize();
+    aNonTerminal.append( NonTerminal() );
+    hNonTerminalName.insert( sName, iId );
+    sio << "nt '" << sName << "' = " << iId << sio.nl;
+    return iId;
 }
 
 void Bu::Parser::setNonTerminal( const Bu::String &sName, NonTerminal &nt )
 {
-        aNonTerminal[hNonTerminalName.get(sName)] = nt;
+    aNonTerminal[hNonTerminalName.get(sName)] = nt;
 }
 
 int Bu::Parser::getNonTerminalId( const Bu::String &sName )
 {
-        return hNonTerminalName.get( sName );
+    return hNonTerminalName.get( sName );
 }
 
 bool Bu::Parser::hasNonTerminal( const Bu::String &sName )
 {
-        return hNonTerminalName.has( sName );
+    return hNonTerminalName.has( sName );
 }
 
 int Bu::Parser::addReduction( const Bu::String &sName, const Reduction &r )
 {
-        int iId = aReduction.getSize();
-        aReduction.append( r );
-        hReductionName.insert( sName, iId );
-        return iId;
+    int iId = aReduction.getSize();
+    aReduction.append( r );
+    hReductionName.insert( sName, iId );
+    return iId;
 }
 
 int Bu::Parser::addReduction( const Bu::String &sName )
 {
-        int iId = aReduction.getSize();
-        aReduction.append( Reduction() );
-        hReductionName.insert( sName, iId );
-        return iId;
+    int iId = aReduction.getSize();
+    aReduction.append( Reduction() );
+    hReductionName.insert( sName, iId );
+    return iId;
 }
 
 void Bu::Parser::setReduction( const Bu::String &sName, const Reduction &r )
 {
-        aReduction[hReductionName.get(sName)] = r;
+    aReduction[hReductionName.get(sName)] = r;
 }
 
 int Bu::Parser::getReductionId( const Bu::String &sName )
 {
-        return hReductionName.get( sName );
+    return hReductionName.get( sName );
 }
 
 bool Bu::Parser::hasReduction( const Bu::String &sName )
 {
-        return hReductionName.has( sName );
+    return hReductionName.has( sName );
 }
 
 //
@@ -253,8 +253,8 @@ bool Bu::Parser::hasReduction( const Bu::String &sName )
 //
 
 Bu::Parser::State::State( Bu::Parser::State::Type eType, int iIndex ) :
-        eType( eType ),
-        iIndex( iIndex )
+    eType( eType ),
+    iIndex( iIndex )
 {
 }
 
@@ -267,7 +267,7 @@ Bu::Parser::State::~State()
 //
 
 Bu::Parser::NonTerminal::NonTerminal() :
-        bCanSkip( false )
+    bCanSkip( false )
 {
 }
 
@@ -277,35 +277,35 @@ Bu::Parser::NonTerminal::~NonTerminal()
 
 void Bu::Parser::NonTerminal::addProduction( Production p )
 {
-        lProduction.append( p );
+    lProduction.append( p );
 }
 
 void Bu::Parser::NonTerminal::setCanSkip()
 {
-        bCanSkip = true;
+    bCanSkip = true;
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, Bu::Parser::State::Type t )
 {
-        switch( t )
-        {
-                case Bu::Parser::State::typeTerminal:
-                        return f << "typeTerminal";
+    switch( t )
+    {
+        case Bu::Parser::State::typeTerminal:
+            return f << "typeTerminal";
 
-                case Bu::Parser::State::typeTerminalPush:
-                        return f << "typeTerminalPush";
+        case Bu::Parser::State::typeTerminalPush:
+            return f << "typeTerminalPush";
 
-                case Bu::Parser::State::typeNonTerminal:
-                        return f << "typeNonTerminal";
+        case Bu::Parser::State::typeNonTerminal:
+            return f << "typeNonTerminal";
 
-                case Bu::Parser::State::typeReduction:
-                        return f << "typeReduction";
-        }
-        return f << "***error***";
+        case Bu::Parser::State::typeReduction:
+            return f << "typeReduction";
+    }
+    return f << "***error***";
 }
 
 Bu::Formatter &Bu::operator<<( Bu::Formatter &f, const Bu::Parser::State &s )
 {
-        return f << "{" << s.eType << ": " << s.iIndex << "}";
+    return f << "{" << s.eType << ": " << s.iIndex << "}";
 }
 
diff --git a/src/experimental/parser.h b/src/experimental/parser.h
index 953202d..50b6afb 100644
--- a/src/experimental/parser.h
+++ b/src/experimental/parser.h
@@ -18,115 +18,115 @@
 
 namespace Bu
 {
-        /**
-         * The base framework for a LR(1) grammar parser.  Provided a proper set of
-         * ParserStates this will prase any input the lexer can provide.
-         */
-        class Parser
-        {
-        public:
-                Parser();
-                virtual ~Parser();
-
-                /**
-                 * When a Lexer is pushed onto the stack it becomes the source for
-                 * future tokens read by the parser until it is popped off the stack.
-                 * The Parser takes ownership of every Lexer pushed onto the stack,
-                 * and will delete it when it is popped off the stack.
-                 */
-                void pushLexer( Lexer *pLex );
-
-                /**
-                 * Pop a lexer off the stack, and delete it.
-                 */
-                void popLexer();
-
-                Lexer::Token *popToken();
-                void pushToken( Lexer::Token *pTok );
-
-                /**
-                 * Execute a parse.
-                 */
-                void parse();
-
-                void setRootNonTerminal( int iRoot );
-                void setRootNonTerminal( const Bu::String &sRoot );
-
-                typedef Bu::Signal1<void, Parser &> Reduction;
-
-                /**
-                 * Represents a possible state, either a terminal or non-terminal symbol
-                 * in a Production.
-                 */
-                class State
-                {
-                public:
-                        enum Type
-                        {
-                                typeTerminal,
-                                typeTerminalPush,
-                                typeNonTerminal,
-                                typeReduction
-                        };
-
-                        State( Type eType, int iIndex );
-                        virtual ~State();
-
-                //private:
-                        Type eType;
-                        int iIndex;
-                };
-
-                typedef Bu::List<State> Production;
-
-                class NonTerminal
-                {
-                public:
-                        NonTerminal();
-                        virtual ~NonTerminal();
-
-                        void addProduction( Production p );
-                        void setCanSkip();
-
-//              private:
-                        typedef Bu::List<Production> ProductionList;
-                        ProductionList lProduction;
-                        bool bCanSkip;
-                };
-
-                int addNonTerminal( const Bu::String &sName, NonTerminal &nt );
-                int addNonTerminal( const Bu::String &sName );
-                void setNonTerminal( const Bu::String &sName, NonTerminal &nt );
-                int getNonTerminalId( const Bu::String &sName );
-                bool hasNonTerminal( const Bu::String &sName );
-
-                int addReduction( const Bu::String &sName, const Reduction &r );
-                int addReduction( const Bu::String &sName );
-                void setReduction( const Bu::String &sName, const Reduction &r );
-                int getReductionId( const Bu::String &sName );
-                bool hasReduction( const Bu::String &sName );
-
-        private:
-                bool selectProduction( int iNt, Lexer::Token *ptCur );
-                void advanceState();
-
-        private:
-                typedef Bu::List<Lexer *> LexerStack;
-                typedef Bu::List<Lexer::Token *> TokenStack;
-                typedef Bu::List<Production::const_iterator> StateStack;
-                typedef Bu::Array<Reduction> ReductionArray;
-                typedef Bu::Hash<Bu::String,int> NameIndexHash;
-                typedef Bu::Array<NonTerminal> NonTerminalArray;
-
-                LexerStack sLexer;
-                TokenStack sToken;
-                StateStack sState;
-                ReductionArray aReduction;
-                NameIndexHash hReductionName;
-                NonTerminalArray aNonTerminal;
-                NameIndexHash hNonTerminalName;
-                int iRootNonTerminal;
-        };
+    /**
+     * The base framework for a LR(1) grammar parser.  Provided a proper set of
+     * ParserStates this will prase any input the lexer can provide.
+     */
+    class Parser
+    {
+    public:
+        Parser();
+        virtual ~Parser();
+
+        /**
+         * When a Lexer is pushed onto the stack it becomes the source for
+         * future tokens read by the parser until it is popped off the stack.
+         * The Parser takes ownership of every Lexer pushed onto the stack,
+         * and will delete it when it is popped off the stack.
+         */
+        void pushLexer( Lexer *pLex );
+
+        /**
+         * Pop a lexer off the stack, and delete it.
+         */
+        void popLexer();
+
+        Lexer::Token *popToken();
+        void pushToken( Lexer::Token *pTok );
+
+        /**
+         * Execute a parse.
+         */
+        void parse();
+
+        void setRootNonTerminal( int iRoot );
+        void setRootNonTerminal( const Bu::String &sRoot );
+
+        typedef Bu::Signal1<void, Parser &> Reduction;
+
+        /**
+         * Represents a possible state, either a terminal or non-terminal symbol
+         * in a Production.
+         */
+        class State
+        {
+        public:
+            enum Type
+            {
+                typeTerminal,
+                typeTerminalPush,
+                typeNonTerminal,
+                typeReduction
+            };
+
+            State( Type eType, int iIndex );
+            virtual ~State();
+
+        //private:
+            Type eType;
+            int iIndex;
+        };
+
+        typedef Bu::List<State> Production;
+
+        class NonTerminal
+        {
+        public:
+            NonTerminal();
+            virtual ~NonTerminal();
+
+            void addProduction( Production p );
+            void setCanSkip();
+
+//      private:
+            typedef Bu::List<Production> ProductionList;
+            ProductionList lProduction;
+            bool bCanSkip;
+        };
+
+        int addNonTerminal( const Bu::String &sName, NonTerminal &nt );
+        int addNonTerminal( const Bu::String &sName );
+        void setNonTerminal( const Bu::String &sName, NonTerminal &nt );
+        int getNonTerminalId( const Bu::String &sName );
+        bool hasNonTerminal( const Bu::String &sName );
+
+        int addReduction( const Bu::String &sName, const Reduction &r );
+        int addReduction( const Bu::String &sName );
+        void setReduction( const Bu::String &sName, const Reduction &r );
+        int getReductionId( const Bu::String &sName );
+        bool hasReduction( const Bu::String &sName );
+
+    private:
+        bool selectProduction( int iNt, Lexer::Token *ptCur );
+        void advanceState();
+
+    private:
+        typedef Bu::List<Lexer *> LexerStack;
+        typedef Bu::List<Lexer::Token *> TokenStack;
+        typedef Bu::List<Production::const_iterator> StateStack;
+        typedef Bu::Array<Reduction> ReductionArray;
+        typedef Bu::Hash<Bu::String,int> NameIndexHash;
+        typedef Bu::Array<NonTerminal> NonTerminalArray;
+
+        LexerStack sLexer;
+        TokenStack sToken;
+        StateStack sState;
+        ReductionArray aReduction;
+        NameIndexHash hReductionName;
+        NonTerminalArray aNonTerminal;
+        NameIndexHash hNonTerminalName;
+        int iRootNonTerminal;
+    };
 Bu::Formatter &operator<<( Bu::Formatter &f, Bu::Parser::State::Type t );
 Bu::Formatter &operator<<( Bu::Formatter &f, const Bu::Parser::State &s );
 };
diff --git a/src/experimental/regex.cpp b/src/experimental/regex.cpp
index de24935..dbe0e85 100644
--- a/src/experimental/regex.cpp
+++ b/src/experimental/regex.cpp
@@ -13,83 +13,83 @@
 #define aSubStr ((regmatch_t *)paSubStr)
 
 Bu::RegEx::RegEx() :
-        pRegEx( NULL ),
-        bCompiled( false ),
-        paSubStr( NULL )
+    pRegEx( NULL ),
+    bCompiled( false ),
+    paSubStr( NULL )
 {
 }
 
 Bu::RegEx::RegEx( const Bu::String &sSrc ) :
-        pRegEx( NULL ),
-        bCompiled( false ),
-        paSubStr( NULL )
+    pRegEx( NULL ),
+    bCompiled( false ),
+    paSubStr( NULL )
 {
-        compile( sSrc );
+    compile( sSrc );
 }
 
 Bu::RegEx::~RegEx()
 {
-        if( bCompiled )
-        {
-                regfree( re );
-                delete re;
-                delete[] aSubStr;
-        }
+    if( bCompiled )
+    {
+        regfree( re );
+        delete re;
+        delete[] aSubStr;
+    }
 }
 
 void Bu::RegEx::compile( const Bu::String &sSrc )
 {
-        if( bCompiled )
-        {
-                regfree( re );
-                delete re;
-                delete[] aSubStr;
-                bCompiled = false;
-        }
-        pRegEx = (void *)(new regex_t);
+    if( bCompiled )
+    {
+        regfree( re );
+        delete re;
+        delete[] aSubStr;
+        bCompiled = false;
+    }
+    pRegEx = (void *)(new regex_t);
 
-        int nErr = regcomp( re, sSrc.getStr(), REG_EXTENDED|REG_NEWLINE );
-        if( nErr )
-        {
-                size_t length = regerror( nErr, re, NULL, 0 );
-                char *buffer = new char[length];
-                (void) regerror( nErr, re, buffer, length );
-                Bu::String s( buffer );
-                delete[] buffer;
-                throw "???"; // BuildException( s.getStr() );
-        }
-        bCompiled = true;
-        this->sSrc = sSrc;
+    int nErr = regcomp( re, sSrc.getStr(), REG_EXTENDED|REG_NEWLINE );
+    if( nErr )
+    {
+        size_t length = regerror( nErr, re, NULL, 0 );
+        char *buffer = new char[length];
+        (void) regerror( nErr, re, buffer, length );
+        Bu::String s( buffer );
+        delete[] buffer;
+        throw "???"; // BuildException( s.getStr() );
+    }
+    bCompiled = true;
+    this->sSrc = sSrc;
 
-        nSubStr = re->re_nsub+1;
-        paSubStr = (void *)(new regmatch_t[nSubStr]);
+    nSubStr = re->re_nsub+1;
+    paSubStr = (void *)(new regmatch_t[nSubStr]);
 }
 
 int Bu::RegEx::getNumSubStrings()
 {
-        return nSubStr;
+    return nSubStr;
 }
 
 bool Bu::RegEx::execute( const Bu::String &sSrc )
 {
-        sTest = sSrc;
-        if( regexec( re, sSrc.getStr(), nSubStr, aSubStr, 0 ) )
-                return false;
-        return true;
+    sTest = sSrc;
+    if( regexec( re, sSrc.getStr(), nSubStr, aSubStr, 0 ) )
+        return false;
+    return true;
 }
 
 void Bu::RegEx::getSubStringRange( int nIndex, int &iStart, int &iEnd )
 {
-        iStart = aSubStr[nIndex].rm_so;
-        iEnd = aSubStr[nIndex].rm_eo;
+    iStart = aSubStr[nIndex].rm_so;
+    iEnd = aSubStr[nIndex].rm_eo;
 }
 
 Bu::String Bu::RegEx::getSubString( int nIndex )
 {
-//      regmatch_t *Subs = aSubStr;
-        return Bu::String(
-                sTest.getStr()+aSubStr[nIndex].rm_so,
-                aSubStr[nIndex].rm_eo - aSubStr[nIndex].rm_so
-                );
+//  regmatch_t *Subs = aSubStr;
+    return Bu::String(
+        sTest.getStr()+aSubStr[nIndex].rm_so,
+        aSubStr[nIndex].rm_eo - aSubStr[nIndex].rm_so
+        );
 }
 
diff --git a/src/experimental/regex.h b/src/experimental/regex.h
index c83ebe8..e723450 100644
--- a/src/experimental/regex.h
+++ b/src/experimental/regex.h
@@ -14,31 +14,31 @@
 
 namespace Bu
 {
-        class RegEx
-        {
-        public:
-                RegEx();
-                RegEx( const Bu::String &sSrc );
-                virtual ~RegEx();
+    class RegEx
+    {
+    public:
+        RegEx();
+        RegEx( const Bu::String &sSrc );
+        virtual ~RegEx();
 
-                void compile( const Bu::String &sSrc );
-                int getNumSubStrings();
-                bool execute( const Bu::String &sSrc );
-                void getSubStringRange( int nIndex, int &iStart, int &iEnd );
-                Bu::String getSubString( int nIndex );
-                const Bu::String &getSource()
-                {
-                        return sSrc;
-                }
+        void compile( const Bu::String &sSrc );
+        int getNumSubStrings();
+        bool execute( const Bu::String &sSrc );
+        void getSubStringRange( int nIndex, int &iStart, int &iEnd );
+        Bu::String getSubString( int nIndex );
+        const Bu::String &getSource()
+        {
+            return sSrc;
+        }
 
-        private:
-                Bu::String sSrc;
-                Bu::String sTest;
-                void *pRegEx;
-                bool bCompiled;
-                int nSubStr;
-                void *paSubStr;
-        };
+    private:
+        Bu::String sSrc;
+        Bu::String sTest;
+        void *pRegEx;
+        bool bCompiled;
+        int nSubStr;
+        void *paSubStr;
+    };
 };
 
 #endif
diff --git a/src/experimental/regexengine.h b/src/experimental/regexengine.h
index ec181c1..133d418 100644
--- a/src/experimental/regexengine.h
+++ b/src/experimental/regexengine.h
@@ -7,136 +7,136 @@
 
 namespace Bu
 {
-        template<typename chr> class RegExEngine;
-
-        template<typename chr>
-        class RegExEngineCore
-        {
-        friend class RegExEngine<chr>;
-        friend class SharedCore<RegExEngine<chr>, RegExEngineCore<chr> >;
-        private:
-                RegExEngineCore()
-                {
-                }
-
-                virtual ~RegExEngineCore()
-                {
-                }
-
-                class Range
-                {
-                public:
-                        Range( chr cLower, chr cUpper, int iTrgState ) :
-                                cLower( cLower ), cUpper( cUpper ), iTrgState( iTrgState )
-                        {
-                        }
-                
-                        chr cLower;
-                        chr cUpper;
-                        int iTrgState;
-                };
-
-                class State
-                {
-                public:
-                        Bu::Array<Range> aRange;
-                };
-
-                int addState()
-                {
-                        aState.append( State() );
-                        return aState.getSize()-1;
-                }
-
-                void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState )
-                {
-                        aState[iState].aRange.append( Range( cLower, cUpper, iTrgState ) );
-                }
-
-                template<typename str>
-                bool match( const str &sIn, int &iSize, int &iCompletion )
-                {
-                        bool bMatch;
-                        int iState = 0;
-                        iSize = 0;
-                        for( typename str::const_iterator i = sIn.begin(); i; i++ )
-                        {
-                                Bu::sio << "Finding char " << *i << " in state " << iState
-                                        << ":" << Bu::sio.nl;
-                                bMatch = false;
-                                for( typename Bu::Array<Range>::iterator j =
-                                         aState[iState].aRange.begin(); j; j++ )
-                                {
-                                        Bu::sio << "    Testing range " << (*j).cLower << " - " << (*j).cUpper << Bu::sio.nl;
-                                        if( *i >= (*j).cLower && *i <= (*j).cUpper )
-                                        {
-                                                iState = (*j).iTrgState;
-                                                bMatch = true;
-                                                iSize++;
-                                                if( iState < 0 )
-                                                {
-                                                        iCompletion = iState;
-                                                        return true;
-                                                }
-                                        }
-                                }
-                                if( bMatch == false )
-                                {
-                                        return false;
-                                }
-                        }
-
-                        iCompletion = 0;
-                        return true;
-                }
-
-                typedef Bu::Array<State> StateArray;
-                StateArray aState;
-        };
-
-        template<typename chr>
-        class RegExEngine : public SharedCore<RegExEngine<chr>,
-                                                RegExEngineCore<chr> >
-        {
-        private:
-                typedef class RegExEngine<chr> MyType;
-                typedef class RegExEngineCore<chr> Core;
-                typedef class Core::Range Range;
-                typedef class Core::State State;
-        
-        protected:
-                using SharedCore<MyType, Core>::core;
-                using SharedCore<MyType, Core>::_hardCopy;
-                using SharedCore<MyType, Core>::_resetCore;
-                using SharedCore<MyType, Core>::_allocateCore;
-
-        public:
-                RegExEngine()
-                {
-                }
-
-                virtual ~RegExEngine()
-                {
-                }
-
-                int addState()
-                {
-                        return core->addState();
-                }
-
-                void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState )
-                {
-                        core->addCompletion( iState, cLower, cUpper, iTrgState );
-                }
-
-                template<typename str>
-                bool match( const str &sIn, int &iSize, int &iCompletion )
-                {
-                        return core->match( sIn, iSize, iCompletion );
-                }
-
-        private:
-        };
+    template<typename chr> class RegExEngine;
+
+    template<typename chr>
+    class RegExEngineCore
+    {
+    friend class RegExEngine<chr>;
+    friend class SharedCore<RegExEngine<chr>, RegExEngineCore<chr> >;
+    private:
+        RegExEngineCore()
+        {
+        }
+
+        virtual ~RegExEngineCore()
+        {
+        }
+
+        class Range
+        {
+        public:
+            Range( chr cLower, chr cUpper, int iTrgState ) :
+                cLower( cLower ), cUpper( cUpper ), iTrgState( iTrgState )
+            {
+            }
+        
+            chr cLower;
+            chr cUpper;
+            int iTrgState;
+        };
+
+        class State
+        {
+        public:
+            Bu::Array<Range> aRange;
+        };
+
+        int addState()
+        {
+            aState.append( State() );
+            return aState.getSize()-1;
+        }
+
+        void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState )
+        {
+            aState[iState].aRange.append( Range( cLower, cUpper, iTrgState ) );
+        }
+
+        template<typename str>
+        bool match( const str &sIn, int &iSize, int &iCompletion )
+        {
+            bool bMatch;
+            int iState = 0;
+            iSize = 0;
+            for( typename str::const_iterator i = sIn.begin(); i; i++ )
+            {
+                Bu::sio << "Finding char " << *i << " in state " << iState
+                    << ":" << Bu::sio.nl;
+                bMatch = false;
+                for( typename Bu::Array<Range>::iterator j =
+                     aState[iState].aRange.begin(); j; j++ )
+                {
+                    Bu::sio << "    Testing range " << (*j).cLower << " - " << (*j).cUpper << Bu::sio.nl;
+                    if( *i >= (*j).cLower && *i <= (*j).cUpper )
+                    {
+                        iState = (*j).iTrgState;
+                        bMatch = true;
+                        iSize++;
+                        if( iState < 0 )
+                        {
+                            iCompletion = iState;
+                            return true;
+                        }
+                    }
+                }
+                if( bMatch == false )
+                {
+                    return false;
+                }
+            }
+
+            iCompletion = 0;
+            return true;
+        }
+
+        typedef Bu::Array<State> StateArray;
+        StateArray aState;
+    };
+
+    template<typename chr>
+    class RegExEngine : public SharedCore<RegExEngine<chr>,
+                        RegExEngineCore<chr> >
+    {
+    private:
+        typedef class RegExEngine<chr> MyType;
+        typedef class RegExEngineCore<chr> Core;
+        typedef class Core::Range Range;
+        typedef class Core::State State;
+    
+    protected:
+        using SharedCore<MyType, Core>::core;
+        using SharedCore<MyType, Core>::_hardCopy;
+        using SharedCore<MyType, Core>::_resetCore;
+        using SharedCore<MyType, Core>::_allocateCore;
+
+    public:
+        RegExEngine()
+        {
+        }
+
+        virtual ~RegExEngine()
+        {
+        }
+
+        int addState()
+        {
+            return core->addState();
+        }
+
+        void addCompletion( int iState, chr cLower, chr cUpper, int iTrgState )
+        {
+            core->addCompletion( iState, cLower, cUpper, iTrgState );
+        }
+
+        template<typename str>
+        bool match( const str &sIn, int &iSize, int &iCompletion )
+        {
+            return core->match( sIn, iSize, iCompletion );
+        }
+
+    private:
+    };
 };
 
 #endif
diff --git a/src/experimental/xmlreader.cpp b/src/experimental/xmlreader.cpp
index f11ac04..82f4684 100644
--- a/src/experimental/xmlreader.cpp
+++ b/src/experimental/xmlreader.cpp
@@ -11,13 +11,13 @@
 namespace Bu { subExceptionDef( XmlException ) }
 
 Bu::XmlReader::XmlReader( Stream &rInput ) :
-        rInput( rInput ),
-        iCurToken( 0 ),
-        iNextToken( 0 ),
-        bIgnoreWS( true )
+    rInput( rInput ),
+    iCurToken( 0 ),
+    iNextToken( 0 ),
+    bIgnoreWS( true )
 {
-        nextToken();
-        stDocument();
+    nextToken();
+    stDocument();
 }
 
 Bu::XmlReader::~XmlReader()
@@ -26,148 +26,148 @@ Bu::XmlReader::~XmlReader()
 
 void Bu::XmlReader::fillBuffer()
 {
-        if( rInput.isEos() )
-                return;
-        char buf[1024];
-        int iSize = rInput.read( buf, 1024 );
-        sBuf.append( buf, iSize );
+    if( rInput.isEos() )
+        return;
+    char buf[1024];
+    int iSize = rInput.read( buf, 1024 );
+    sBuf.append( buf, iSize );
 }
 
 void Bu::XmlReader::cleanupBuffer( int iUsed )
 {
-        for( int j = 0; j < iUsed; j++ )
-        {
-                if( sBuf[j] == '\n' )
-                {
-                        spNextToken.iLine++;
-                        spNextToken.iChar = 1;
-                }
-                else
-                {
-                        spNextToken.iChar++;
-                }
-        }
-
-        printf("--Deleting %d bytes from front of buffer.\n", iUsed );
-        sBuf.trimFront( iUsed );
+    for( int j = 0; j < iUsed; j++ )
+    {
+        if( sBuf[j] == '\n' )
+        {
+            spNextToken.iLine++;
+            spNextToken.iChar = 1;
+        }
+        else
+        {
+            spNextToken.iChar++;
+        }
+    }
+
+    printf("--Deleting %d bytes from front of buffer.\n", iUsed );
+    sBuf.trimFront( iUsed );
 }
 
 int Bu::XmlReader::nextToken()
 {
-        fillBuffer();
-
-        int iUsed = 1;
-
-        iCurToken = iNextToken;
-        spCurToken = spNextToken;
-
-        switch( sBuf[0] )
-        {
-                case '<':
-                        if( !strncmp( sBuf.getStr(), "<?xml", 5 ) )
-                        {
-                                iNextToken = tokXmlDeclHead;
-                                iUsed = 5;
-                        }
-                        else
-                        {
-                                iNextToken = '<';
-                        }
-                        break;
-
-                case '?':
-                        if( sBuf[1] == '>' )
-                        {
-                                iNextToken = tokXmlDeclEnd;
-                                iUsed = 2;
-                        }
-                        else
-                        {
-                                iNextToken = '?';
-                        }
-                        break;
-
-                case ' ':
-                case '\t':
-                case '\n':
-                case '\r':
-                        for( int j = 1;; j++ )
-                        {
-                                if( j == sBuf.getSize() )
-                                {
-                                        if( rInput.isEos() )
-                                                error("Reached end of input while waiting for whitespace to end.");
-
-                                        fillBuffer();
-                                }
-                                if( sBuf[j] == ' ' || sBuf[j] == '\t' ||
-                                        sBuf[j] == '\n' || sBuf[j] == '\r' )
-                                        iUsed++;
-                                else
-                                        break;
-                        }
-                        sStr.clear();
-                        sStr.append( sBuf, iUsed );
-                        iNextToken = tokWS;
-                        break;
-
-                case '=':
-                        iNextToken = sBuf[0];
-                        break;
-
-                default:
-                        if( (sBuf[0] >= 'a' && sBuf[0] <= 'z') ||
-                                (sBuf[0] >= 'A' && sBuf[0] <= 'Z') )
-                        {
-                                for( int j = 1;; j++ )
-                                {
-                                        if( j == sBuf.getSize() )
-                                        {
-                                                if( rInput.isEos() )
-                                                        error("Reached end of input while waiting for a string to end.");
-
-                                                fillBuffer();
-                                        }
-                                        if( (sBuf[j] >= 'a' && sBuf[j] <= 'z') ||
-                                                (sBuf[j] >= 'A' && sBuf[j] <= 'Z') )
-                                                iUsed++;
-                                        else
-                                                break;
-                                }
-                                sStr.clear();
-                                sStr.append( sBuf, iUsed );
-                                iNextToken = tokIdent;
-                        }
-        }
-
-        cleanupBuffer( iUsed );
-
-        return iCurToken;
+    fillBuffer();
+
+    int iUsed = 1;
+
+    iCurToken = iNextToken;
+    spCurToken = spNextToken;
+
+    switch( sBuf[0] )
+    {
+        case '<':
+            if( !strncmp( sBuf.getStr(), "<?xml", 5 ) )
+            {
+                iNextToken = tokXmlDeclHead;
+                iUsed = 5;
+            }
+            else
+            {
+                iNextToken = '<';
+            }
+            break;
+
+        case '?':
+            if( sBuf[1] == '>' )
+            {
+                iNextToken = tokXmlDeclEnd;
+                iUsed = 2;
+            }
+            else
+            {
+                iNextToken = '?';
+            }
+            break;
+
+        case ' ':
+        case '\t':
+        case '\n':
+        case '\r':
+            for( int j = 1;; j++ )
+            {
+                if( j == sBuf.getSize() )
+                {
+                    if( rInput.isEos() )
+                        error("Reached end of input while waiting for whitespace to end.");
+
+                    fillBuffer();
+                }
+                if( sBuf[j] == ' ' || sBuf[j] == '\t' ||
+                    sBuf[j] == '\n' || sBuf[j] == '\r' )
+                    iUsed++;
+                else
+                    break;
+            }
+            sStr.clear();
+            sStr.append( sBuf, iUsed );
+            iNextToken = tokWS;
+            break;
+
+        case '=':
+            iNextToken = sBuf[0];
+            break;
+
+        default:
+            if( (sBuf[0] >= 'a' && sBuf[0] <= 'z') ||
+                (sBuf[0] >= 'A' && sBuf[0] <= 'Z') )
+            {
+                for( int j = 1;; j++ )
+                {
+                    if( j == sBuf.getSize() )
+                    {
+                        if( rInput.isEos() )
+                            error("Reached end of input while waiting for a string to end.");
+
+                        fillBuffer();
+                    }
+                    if( (sBuf[j] >= 'a' && sBuf[j] <= 'z') ||
+                        (sBuf[j] >= 'A' && sBuf[j] <= 'Z') )
+                        iUsed++;
+                    else
+                        break;
+                }
+                sStr.clear();
+                sStr.append( sBuf, iUsed );
+                iNextToken = tokIdent;
+            }
+    }
+
+    cleanupBuffer( iUsed );
+
+    return iCurToken;
 }
 
 void Bu::XmlReader::error( const char *sMessage )
 {
-        throw Bu::XmlException("%d:%d:  %s",
-                spCurToken.iLine, spCurToken.iChar, sMessage );
+    throw Bu::XmlException("%d:%d:  %s",
+        spCurToken.iLine, spCurToken.iChar, sMessage );
 }
 
 void Bu::XmlReader::stDocument()
 {
-        stProlog();
+    stProlog();
 }
 
 void Bu::XmlReader::stProlog()
 {
-        stXmlDecl();
+    stXmlDecl();
 }
 
 void Bu::XmlReader::stXmlDecl()
 {
-        if( nextToken() != tokXmlDeclHead )
-                error("You must begin your xml file with a declaration: <?xml ... ?>");
-        if( nextToken() != tokIdent )
-                error("A version comes first!");
-        if( sStr != "version" )
-                error("No, a version!");
+    if( nextToken() != tokXmlDeclHead )
+        error("You must begin your xml file with a declaration: <?xml ... ?>");
+    if( nextToken() != tokIdent )
+        error("A version comes first!");
+    if( sStr != "version" )
+        error("No, a version!");
 }
 
diff --git a/src/experimental/xmlreader.h b/src/experimental/xmlreader.h
index d4bad1e..9615cfb 100644
--- a/src/experimental/xmlreader.h
+++ b/src/experimental/xmlreader.h
@@ -13,52 +13,52 @@
 
 namespace Bu
 {
-        class Stream;
+    class Stream;
 
-        subExceptionDecl( XmlException );
+    subExceptionDecl( XmlException );
 
-        class XmlReader
-        {
-        public:
-                XmlReader( Stream &rInput );
-                virtual ~XmlReader();
+    class XmlReader
+    {
+    public:
+        XmlReader( Stream &rInput );
+        virtual ~XmlReader();
 
-        private:
-                Stream &rInput;
-                int iCurToken;
-                int iNextToken;
-                Bu::String sBuf;
-                Bu::String sStr;
-                bool bIgnoreWS;
-                typedef struct StreamPos
-                {
-                        StreamPos() : iLine( 1 ), iChar( 1 ) { }
-                        int iLine;
-                        int iChar;
-                } StreamPos;
-                StreamPos spCurToken;
-                StreamPos spNextToken;
+    private:
+        Stream &rInput;
+        int iCurToken;
+        int iNextToken;
+        Bu::String sBuf;
+        Bu::String sStr;
+        bool bIgnoreWS;
+        typedef struct StreamPos
+        {
+            StreamPos() : iLine( 1 ), iChar( 1 ) { }
+            int iLine;
+            int iChar;
+        } StreamPos;
+        StreamPos spCurToken;
+        StreamPos spNextToken;
 
 
-                enum
-                {
-                        tokXmlDeclHead  =       0x100,
-                        tokXmlDeclEnd,
-                        tokWS,
-                        tokIdent,
-                        tokString
-                };
+        enum
+        {
+            tokXmlDeclHead  =   0x100,
+            tokXmlDeclEnd,
+            tokWS,
+            tokIdent,
+            tokString
+        };
 
-                void fillBuffer();
-                void cleanupBuffer( int iUsed );
-                int nextToken();
+        void fillBuffer();
+        void cleanupBuffer( int iUsed );
+        int nextToken();
 
-                void stDocument();
-                void stProlog();
-                void stXmlDecl();
+        void stDocument();
+        void stProlog();
+        void stXmlDecl();
 
-                void error( const char *sMessage );
-        };
+        void error( const char *sMessage );
+    };
 };
 
 #endif