diff --git a/bench_enum.rs b/bench_enum.rs
new file mode 100644
index 00000000..ac98f5cd
--- /dev/null
+++ b/bench_enum.rs
@@ -0,0 +1,293 @@
+use test::Bencher;
+
+use serialize::{Decoder, Decodable};
+
+use de::{Deserializer, Deserializable};
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[deriving(Clone, Eq, Show, Decodable)]
+enum Animal {
+    Dog,
+    Frog(StrBuf, int)
+}
+
+impl<E, D: Deserializer<E>> Deserializable<E, D> for Animal {
+    #[inline]
+    fn deserialize(d: &mut D) -> Result<Animal, E> {
+        match try!(d.expect_enum_start("Animal", ["Dog", "Frog"])) {
+            0 => {
+                try!(d.expect_end());
+                Ok(Dog)
+            }
+            1 => {
+                let x0 = try!(Deserializable::deserialize(d));
+                let x1 = try!(Deserializable::deserialize(d));
+                try!(d.expect_end());
+                Ok(Frog(x0, x1))
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[deriving(Show)]
+enum Error {
+    EndOfStream,
+    SyntaxError,
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+mod decoder {
+    use serialize::Decoder;
+
+    use super::{Animal, Dog, Frog, Error, SyntaxError};
+
+    enum State {
+        AnimalState(Animal),
+        DogState,
+        FrogState,
+        IntState(int),
+        StrState(StrBuf),
+    }
+
+    pub struct AnimalDecoder {
+        stack: Vec<State>,
+
+    }
+
+    impl AnimalDecoder {
+        #[inline]
+        pub fn new(animal: Animal) -> AnimalDecoder {
+            AnimalDecoder {
+                stack: vec!(AnimalState(animal)),
+            }
+        }
+    }
+
+    impl Decoder<Error> for AnimalDecoder {
+        // Primitive types:
+        fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
+        fn read_uint(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
+        fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
+        #[inline]
+        fn read_int(&mut self) -> Result<int, Error> {
+            match self.stack.pop() {
+                Some(IntState(x)) => Ok(x),
+                _ => Err(SyntaxError),
+            }
+        }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
+        fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
+        #[inline]
+        fn read_str(&mut self) -> Result<StrBuf, Error> {
+            match self.stack.pop() {
+                Some(StrState(x)) => Ok(x),
+                _ => Err(SyntaxError),
+            }
+        }
+
+        // Compound types:
+        #[inline]
+        fn read_enum<T>(&mut self, name: &str, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
+            match self.stack.pop() {
+                Some(AnimalState(animal)) => {
+                    self.stack.push(AnimalState(animal));
+                    if name == "Animal" {
+                        f(self)
+                    } else {
+                        Err(SyntaxError)
+                    }
+                }
+                _ => Err(SyntaxError)
+            }
+        }
+
+        #[inline]
+        fn read_enum_variant<T>(&mut self, names: &[&str], f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
+            let name = match self.stack.pop() {
+                Some(AnimalState(Dog)) => "Dog",
+                Some(AnimalState(Frog(x0, x1))) => {
+                    self.stack.push(IntState(x1));
+                    self.stack.push(StrState(x0));
+                    "Frog"
+                }
+                _ => { return Err(SyntaxError); }
+            };
+
+            let idx = match names.iter().position(|n| *n == name) {
+                Some(idx) => idx,
+                None => { return Err(SyntaxError); }
+            };
+
+            f(self, idx)
+        }
+        #[inline]
+        fn read_enum_variant_arg<T>(&mut self, _a_idx: uint, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
+            f(self)
+        }
+        fn read_enum_struct_variant<T>(&mut self,
+                                       _names: &[&str],
+                                       _f: |&mut AnimalDecoder, uint| -> Result<T, Error>)
+                                       -> Result<T, Error> { Err(SyntaxError) }
+        fn read_enum_struct_variant_field<T>(&mut self,
+                                             _f_name: &str,
+                                             _f_idx: uint,
+                                             _f: |&mut AnimalDecoder| -> Result<T, Error>)
+                                             -> Result<T, Error> { Err(SyntaxError) }
+
+        fn read_struct<T>(&mut self, _s_name: &str, _len: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>)
+                          -> Result<T, Error> { Err(SyntaxError) }
+        fn read_struct_field<T>(&mut self,
+                                _f_name: &str,
+                                _f_idx: uint,
+                                _f: |&mut AnimalDecoder| -> Result<T, Error>)
+                                -> Result<T, Error> { Err(SyntaxError) }
+
+        fn read_tuple<T>(&mut self, _f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+        fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+
+        fn read_tuple_struct<T>(&mut self,
+                                _s_name: &str,
+                                _f: |&mut AnimalDecoder, uint| -> Result<T, Error>)
+                                -> Result<T, Error> { Err(SyntaxError) }
+        fn read_tuple_struct_arg<T>(&mut self,
+                                    _a_idx: uint,
+                                    _f: |&mut AnimalDecoder| -> Result<T, Error>)
+                                    -> Result<T, Error> { Err(SyntaxError) }
+
+        // Specialized types:
+        fn read_option<T>(&mut self, _f: |&mut AnimalDecoder, bool| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+
+        #[inline]
+        fn read_seq<T>(&mut self, f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
+            f(self, 3)
+        }
+        #[inline]
+        fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
+            f(self)
+        }
+
+        fn read_map<T>(&mut self, _f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+        fn read_map_elt_key<T>(&mut self, _idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+        fn read_map_elt_val<T>(&mut self, _idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+mod deserializer {
+    use super::{Animal, Dog, Frog, Error, EndOfStream, SyntaxError};
+
+    use de::Deserializer;
+    use de::{Token, Int, StrBuf, EnumStart, EnumVariant, End};
+
+    enum State {
+        AnimalState(Animal),
+        DogState,
+        FrogState,
+        IntState(int),
+        StrState(StrBuf),
+        EndState,
+
+    }
+
+    pub struct AnimalDeserializer {
+        stack: Vec<State>,
+    }
+
+    impl AnimalDeserializer {
+        #[inline]
+        pub fn new(animal: Animal) -> AnimalDeserializer {
+            AnimalDeserializer {
+                stack: vec!(AnimalState(animal)),
+            }
+        }
+    }
+
+    impl Iterator<Result<Token, Error>> for AnimalDeserializer {
+        #[inline]
+        fn next(&mut self) -> Option<Result<Token, Error>> {
+            match self.stack.pop() {
+                Some(AnimalState(Dog)) => {
+                    self.stack.push(EndState);
+                    self.stack.push(DogState);
+                    Some(Ok(EnumStart("Animal")))
+                }
+                Some(AnimalState(Frog(x0, x1))) => {
+                    self.stack.push(EndState);
+                    self.stack.push(IntState(x1));
+                    self.stack.push(StrState(x0));
+                    self.stack.push(FrogState);
+                    Some(Ok(EnumStart("Animal")))
+                }
+                Some(DogState) => {
+                    Some(Ok(EnumVariant("Dog")))
+                }
+                Some(FrogState) => {
+                    Some(Ok(EnumVariant("Frog")))
+                }
+                Some(IntState(x)) => {
+                    Some(Ok(Int(x)))
+                }
+                Some(StrState(x)) => {
+                    Some(Ok(StrBuf(x)))
+                }
+                Some(EndState) => {
+                    Some(Ok(End))
+                }
+                None => None,
+            }
+        }
+    }
+
+    impl Deserializer<Error> for AnimalDeserializer {
+        #[inline]
+        fn end_of_stream_error(&self) -> Error {
+            EndOfStream
+        }
+
+        #[inline]
+        fn syntax_error(&self) -> Error {
+            SyntaxError
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[bench]
+fn bench_enum_decoder(b: &mut Bencher) {
+    b.iter(|| {
+        let animal = Frog("Henry".to_strbuf(), 349);
+
+        let mut d = decoder::AnimalDecoder::new(animal.clone());
+        let value: Animal = Decodable::decode(&mut d).unwrap();
+
+        assert_eq!(value, animal);
+    })
+}
+
+#[bench]
+fn bench_enum_deserializer(b: &mut Bencher) {
+    b.iter(|| {
+        let animal = Frog("Henry".to_strbuf(), 349);
+
+        let mut d = deserializer::AnimalDeserializer::new(animal.clone());
+        let value: Animal = Deserializable::deserialize(&mut d).unwrap();
+
+        assert_eq!(value, animal);
+    })
+}
diff --git a/bench_struct.rs b/bench_struct.rs
new file mode 100644
index 00000000..1010604b
--- /dev/null
+++ b/bench_struct.rs
@@ -0,0 +1,549 @@
+use collections::HashMap;
+use test::Bencher;
+
+use serialize::{Decoder, Decodable};
+
+use de::{Deserializer, Deserializable};
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[deriving(Clone, Eq, Show, Decodable)]
+struct Inner {
+    a: (),
+    b: uint,
+    c: HashMap<StrBuf, Option<char>>,
+}
+
+impl<E, D: Deserializer<E>> Deserializable<E, D> for Inner {
+    #[inline]
+    fn deserialize(d: &mut D) -> Result<Inner, E> {
+        try!(d.expect_struct_start("Inner"));
+        let a = try!(d.expect_struct_field("a"));
+        let b = try!(d.expect_struct_field("b"));
+        let c = try!(d.expect_struct_field("c"));
+        try!(d.expect_end());
+        Ok(Inner { a: a, b: b, c: c })
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[deriving(Clone, Eq, Show, Decodable)]
+struct Outer {
+    inner: Vec<Inner>,
+}
+
+impl<E, D: Deserializer<E>> Deserializable<E, D> for Outer {
+    #[inline]
+    fn deserialize(d: &mut D) -> Result<Outer, E> {
+        try!(d.expect_struct_start("Outer"));
+        let inner = try!(d.expect_struct_field("inner"));
+        try!(d.expect_end());
+        Ok(Outer { inner: inner })
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[deriving(Show)]
+enum Error {
+    EndOfStream,
+    SyntaxError,
+}
+
+mod decoder {
+    use collections::HashMap;
+    use serialize::Decoder;
+
+    use super::{Outer, Inner, Error, SyntaxError};
+
+    #[deriving(Show)]
+    enum State {
+        OuterState(Outer),
+        InnerState(Inner),
+        NullState,
+        UintState(uint),
+        CharState(char),
+        StrState(StrBuf),
+        FieldState(&'static str),
+        VecState(Vec<Inner>),
+        MapState(HashMap<StrBuf, Option<char>>),
+        OptionState(bool),
+    }
+
+    pub struct OuterDecoder {
+        stack: Vec<State>,
+
+    }
+
+    impl OuterDecoder {
+        #[inline]
+        pub fn new(animal: Outer) -> OuterDecoder {
+            OuterDecoder {
+                stack: vec!(OuterState(animal)),
+            }
+        }
+    }
+
+    impl Decoder<Error> for OuterDecoder {
+        // Primitive types:
+        #[inline]
+        fn read_nil(&mut self) -> Result<(), Error> {
+            match self.stack.pop() {
+                Some(NullState) => Ok(()),
+                _ => Err(SyntaxError),
+            }
+        }
+        #[inline]
+        fn read_uint(&mut self) -> Result<uint, Error> {
+            match self.stack.pop() {
+                Some(UintState(value)) => Ok(value),
+                _ => Err(SyntaxError),
+            }
+        }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
+        fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
+        fn read_int(&mut self) -> Result<int, Error> { Err(SyntaxError) }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
+        #[inline]
+        fn read_char(&mut self) -> Result<char, Error> {
+            match self.stack.pop() {
+                Some(CharState(c)) => Ok(c),
+                _ => Err(SyntaxError),
+            }
+        }
+        #[inline]
+        fn read_str(&mut self) -> Result<StrBuf, Error> {
+            match self.stack.pop() {
+                Some(StrState(value)) => Ok(value),
+                _ => Err(SyntaxError),
+            }
+        }
+
+        // Compound types:
+        fn read_enum<T>(&mut self, _name: &str, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+
+        fn read_enum_variant<T>(&mut self,
+                                _names: &[&str],
+                                _f: |&mut OuterDecoder, uint| -> Result<T, Error>)
+                                -> Result<T, Error> { Err(SyntaxError) }
+        fn read_enum_variant_arg<T>(&mut self,
+                                    _a_idx: uint,
+                                    _f: |&mut OuterDecoder| -> Result<T, Error>)
+                                    -> Result<T, Error> { Err(SyntaxError) }
+
+        fn read_enum_struct_variant<T>(&mut self,
+                                       _names: &[&str],
+                                       _f: |&mut OuterDecoder, uint| -> Result<T, Error>)
+                                       -> Result<T, Error> { Err(SyntaxError) }
+        fn read_enum_struct_variant_field<T>(&mut self,
+                                             _f_name: &str,
+                                             _f_idx: uint,
+                                             _f: |&mut OuterDecoder| -> Result<T, Error>)
+                                             -> Result<T, Error> { Err(SyntaxError) }
+
+        #[inline]
+        fn read_struct<T>(&mut self, s_name: &str, _len: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
+            match self.stack.pop() {
+                Some(OuterState(Outer { inner: inner })) => {
+                    if s_name == "Outer" {
+                        self.stack.push(VecState(inner));
+                        self.stack.push(FieldState("inner"));
+                        f(self)
+                    } else {
+                        Err(SyntaxError)
+                    }
+                }
+                Some(InnerState(Inner { a: (), b: b, c: c })) => {
+                    if s_name == "Inner" {
+                        self.stack.push(MapState(c));
+                        self.stack.push(FieldState("c"));
+
+                        self.stack.push(UintState(b));
+                        self.stack.push(FieldState("b"));
+
+                        self.stack.push(NullState);
+                        self.stack.push(FieldState("a"));
+                        f(self)
+                    } else {
+                        Err(SyntaxError)
+                    }
+                }
+                _ => Err(SyntaxError),
+            }
+        }
+        #[inline]
+        fn read_struct_field<T>(&mut self, f_name: &str, _f_idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
+            match self.stack.pop() {
+                Some(FieldState(name)) => {
+                    if f_name == name {
+                        f(self)
+                    } else {
+                        Err(SyntaxError)
+                    }
+                }
+                _ => Err(SyntaxError)
+            }
+        }
+
+        fn read_tuple<T>(&mut self, _f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+        fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+
+        fn read_tuple_struct<T>(&mut self,
+                                _s_name: &str,
+                                _f: |&mut OuterDecoder, uint| -> Result<T, Error>)
+                                -> Result<T, Error> { Err(SyntaxError) }
+        fn read_tuple_struct_arg<T>(&mut self,
+                                    _a_idx: uint,
+                                    _f: |&mut OuterDecoder| -> Result<T, Error>)
+                                    -> Result<T, Error> { Err(SyntaxError) }
+
+        // Specialized types:
+        #[inline]
+        fn read_option<T>(&mut self, f: |&mut OuterDecoder, bool| -> Result<T, Error>) -> Result<T, Error> {
+            match self.stack.pop() {
+                Some(OptionState(b)) => f(self, b),
+                _ => Err(SyntaxError),
+            }
+        }
+
+        #[inline]
+        fn read_seq<T>(&mut self, f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
+            match self.stack.pop() {
+                Some(VecState(value)) => {
+                    let len = value.len();
+                    for inner in value.move_iter().rev() {
+                        self.stack.push(InnerState(inner));
+                    }
+                    f(self, len)
+                }
+                _ => Err(SyntaxError)
+            }
+        }
+        #[inline]
+        fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
+            f(self)
+        }
+
+        #[inline]
+        fn read_map<T>(&mut self, f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
+            match self.stack.pop() {
+                Some(MapState(map)) => {
+                    let len = map.len();
+                    for (key, value) in map.move_iter() {
+                        match value {
+                            Some(c) => {
+                                self.stack.push(CharState(c));
+                                self.stack.push(OptionState(true));
+                            }
+                            None => {
+                                self.stack.push(OptionState(false));
+                            }
+                        }
+                        self.stack.push(StrState(key));
+                    }
+                    f(self, len)
+                }
+                _ => Err(SyntaxError),
+            }
+        }
+        #[inline]
+        fn read_map_elt_key<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
+            f(self)
+        }
+        #[inline]
+        fn read_map_elt_val<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
+            f(self)
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+mod deserializer {
+    use super::{Outer, Inner, Error, EndOfStream, SyntaxError};
+    use de::Deserializer;
+    use de::{Token, Uint, Char, StrBuf, Null, TupleStart, StructStart, StructField, SeqStart, MapStart, Sep, End, Option};
+
+    enum State {
+        OuterState(Outer),
+        InnerState(Inner),
+        FieldState(&'static str),
+        NullState,
+        UintState(uint),
+        CharState(char),
+        StrState(StrBuf),
+        OptionState(bool),
+        TupleState(uint),
+        VecState(uint),
+        MapState(uint),
+        SepState,
+        EndState,
+
+    }
+
+    pub struct OuterDeserializer {
+        stack: Vec<State>,
+    }
+
+    impl OuterDeserializer {
+        #[inline]
+        pub fn new(outer: Outer) -> OuterDeserializer {
+            OuterDeserializer {
+                stack: vec!(OuterState(outer)),
+            }
+        }
+    }
+
+    impl Iterator<Result<Token, Error>> for OuterDeserializer {
+        #[inline]
+        fn next(&mut self) -> Option<Result<Token, Error>> {
+            match self.stack.last() {
+                Some(&OuterState(_)) => {
+                    outer_state(self)
+                }
+                Some(&InnerState(_)) => {
+                    inner_state(self)
+                }
+                Some(&FieldState(_)) => {
+                    field_state(self)
+                }
+                Some(&VecState(_)) => {
+                    vec_state(self)
+                }
+                Some(&MapState(_)) => {
+                    map_state(self)
+                }
+                Some(&TupleState(_)) => {
+                    tuple_state(self)
+                }
+                Some(&SepState) => {
+                    sep_state(self)
+                }
+                Some(&NullState) => {
+                    null_state(self)
+                }
+                Some(&UintState(_)) => {
+                    uint_state(self)
+                }
+                Some(&CharState(_)) => {
+                    char_state(self)
+                }
+                Some(&StrState(_)) => {
+                    strbuf_state(self)
+                }
+                Some(&OptionState(_)) => {
+                    option_state(self)
+                }
+                Some(&EndState) => {
+                    end_state(self)
+                }
+                None => None,
+            }
+        }
+    }
+
+    impl Deserializer<Error> for OuterDeserializer {
+        #[inline]
+        fn end_of_stream_error(&self) -> Error {
+            EndOfStream
+        }
+
+        #[inline]
+        fn syntax_error(&self) -> Error {
+            SyntaxError
+        }
+    }
+
+    fn outer_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        let inner = match d.stack.pop() {
+            Some(OuterState(Outer { inner })) => inner,
+            _ => { return Some(Err(d.syntax_error())); }
+        };
+
+        d.stack.push(EndState);
+
+        d.stack.push(EndState);
+        let len = inner.len();
+        for v in inner.move_iter().rev() {
+            d.stack.push(InnerState(v));
+            d.stack.push(SepState);
+        }
+        d.stack.push(VecState(len));
+
+        d.stack.push(FieldState("inner"));
+        Some(Ok(StructStart("Outer")))
+    }
+
+    fn inner_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        let ((), b, c) = match d.stack.pop() {
+            Some(InnerState(Inner { a, b, c })) => (a, b, c),
+            _ => { return Some(Err(d.syntax_error())); }
+        };
+
+        d.stack.push(EndState);
+
+        d.stack.push(EndState);
+        let len = c.len();
+        for (k, v) in c.move_iter() {
+            d.stack.push(EndState);
+            match v {
+                Some(c) => {
+                    d.stack.push(CharState(c));
+                    d.stack.push(OptionState(true));
+                }
+                None => {
+                    d.stack.push(OptionState(false));
+                }
+            }
+            d.stack.push(SepState);
+
+            d.stack.push(StrState(k));
+            d.stack.push(SepState);
+            d.stack.push(TupleState(2));
+
+            d.stack.push(SepState);
+        }
+        d.stack.push(MapState(len));
+
+        d.stack.push(FieldState("c"));
+
+        d.stack.push(UintState(b));
+        d.stack.push(FieldState("b"));
+
+        d.stack.push(NullState);
+        d.stack.push(FieldState("a"));
+        Some(Ok(StructStart("Inner")))
+    }
+
+    fn field_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        match d.stack.pop() {
+            Some(FieldState(name)) => Some(Ok(StructField(name))),
+            _ => Some(Err(d.syntax_error())),
+        }
+    }
+
+    fn vec_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        match d.stack.pop() {
+            Some(VecState(len)) => Some(Ok(SeqStart(len))),
+            _ => Some(Err(d.syntax_error())),
+        }
+    }
+
+    fn map_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        match d.stack.pop() {
+            Some(MapState(len)) => Some(Ok(MapStart(len))),
+            _ => Some(Err(d.syntax_error())),
+        }
+    }
+
+    fn tuple_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        match d.stack.pop() {
+            Some(TupleState(len)) => Some(Ok(TupleStart(len))),
+            _ => Some(Err(d.syntax_error())),
+        }
+    }
+
+    fn sep_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        match d.stack.pop() {
+            Some(SepState) => Some(Ok(Sep)),
+            _ => Some(Err(d.syntax_error())),
+        }
+    }
+
+    fn null_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        match d.stack.pop() {
+            Some(NullState) => Some(Ok(Null)),
+            _ => Some(Err(d.syntax_error())),
+        }
+    }
+
+    fn uint_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        match d.stack.pop() {
+            Some(UintState(x)) => Some(Ok(Uint(x))),
+            _ => Some(Err(d.syntax_error())),
+        }
+    }
+
+    fn char_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        match d.stack.pop() {
+            Some(CharState(x)) => Some(Ok(Char(x))),
+            _ => Some(Err(d.syntax_error())),
+        }
+    }
+
+    fn strbuf_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        match d.stack.pop() {
+            Some(StrState(x)) => Some(Ok(StrBuf(x))),
+            _ => Some(Err(d.syntax_error())),
+        }
+    }
+
+    fn option_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        match d.stack.pop() {
+            Some(OptionState(x)) => Some(Ok(Option(x))),
+            _ => Some(Err(d.syntax_error())),
+        }
+    }
+
+    fn end_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
+        match d.stack.pop() {
+            Some(EndState) => Some(Ok(End)),
+            _ => Some(Err(d.syntax_error())),
+        }
+    }
+}
+
+#[bench]
+fn bench_struct_decoder(b: &mut Bencher) {
+    b.iter(|| {
+        let mut map = HashMap::new();
+        map.insert("abc".to_strbuf(), Some('c'));
+
+        let outer = Outer {
+            inner: vec!(
+                Inner {
+                    a: (),
+                    b: 5,
+                    c: map,
+                },
+            )
+        };
+
+        let mut d = decoder::OuterDecoder::new(outer.clone());
+        let value: Outer = Decodable::decode(&mut d).unwrap();
+
+        assert_eq!(value, outer);
+    })
+}
+
+#[bench]
+fn bench_struct_deserializer(b: &mut Bencher) {
+    b.iter(|| {
+        let mut map = HashMap::new();
+        map.insert("abc".to_strbuf(), Some('c'));
+
+        let outer = Outer {
+            inner: vec!(
+                Inner {
+                    a: (),
+                    b: 5,
+                    c: map,
+                },
+            )
+        };
+
+        let mut d = deserializer::OuterDeserializer::new(outer.clone());
+        let value: Outer = Deserializable::deserialize(&mut d).unwrap();
+
+        assert_eq!(value, outer);
+    })
+}
diff --git a/bench_vec.rs b/bench_vec.rs
new file mode 100644
index 00000000..3c3ca3be
--- /dev/null
+++ b/bench_vec.rs
@@ -0,0 +1,248 @@
+use test::Bencher;
+
+use serialize::Decodable;
+
+use de::{Deserializable};
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[deriving(Show)]
+enum Error {
+    EndOfStream,
+    SyntaxError,
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+mod decoder {
+    use std::vec;
+    use serialize::Decoder;
+
+    use super::{Error, EndOfStream, SyntaxError};
+
+    pub struct IntsDecoder {
+        iter: vec::MoveItems<int>,
+    }
+
+    impl IntsDecoder {
+        #[inline]
+        pub fn new(values: Vec<int>) -> IntsDecoder {
+            IntsDecoder {
+                iter: values.move_iter()
+            }
+        }
+    }
+
+    impl Decoder<Error> for IntsDecoder {
+        // Primitive types:
+        fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
+        fn read_uint(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
+        fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
+        #[inline]
+        fn read_int(&mut self) -> Result<int, Error> {
+            match self.iter.next() {
+                Some(value) => Ok(value),
+                None => Err(EndOfStream),
+            }
+        }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
+        fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
+        fn read_str(&mut self) -> Result<StrBuf, Error> { Err(SyntaxError) }
+
+        // Compound types:
+        fn read_enum<T>(&mut self, _name: &str, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+
+        fn read_enum_variant<T>(&mut self,
+                                _names: &[&str],
+                                _f: |&mut IntsDecoder, uint| -> Result<T, Error>)
+                                -> Result<T, Error> { Err(SyntaxError) }
+        fn read_enum_variant_arg<T>(&mut self,
+                                    _a_idx: uint,
+                                    _f: |&mut IntsDecoder| -> Result<T, Error>)
+                                    -> Result<T, Error> { Err(SyntaxError) }
+
+        fn read_enum_struct_variant<T>(&mut self,
+                                       _names: &[&str],
+                                       _f: |&mut IntsDecoder, uint| -> Result<T, Error>)
+                                       -> Result<T, Error> { Err(SyntaxError) }
+        fn read_enum_struct_variant_field<T>(&mut self,
+                                             _f_name: &str,
+                                             _f_idx: uint,
+                                             _f: |&mut IntsDecoder| -> Result<T, Error>)
+                                             -> Result<T, Error> { Err(SyntaxError) }
+
+        fn read_struct<T>(&mut self, _s_name: &str, _len: uint, _f: |&mut IntsDecoder| -> Result<T, Error>)
+                          -> Result<T, Error> { Err(SyntaxError) }
+        fn read_struct_field<T>(&mut self,
+                                _f_name: &str,
+                                _f_idx: uint,
+                                _f: |&mut IntsDecoder| -> Result<T, Error>)
+                                -> Result<T, Error> { Err(SyntaxError) }
+
+        fn read_tuple<T>(&mut self, _f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+        fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+
+        fn read_tuple_struct<T>(&mut self,
+                                _s_name: &str,
+                                _f: |&mut IntsDecoder, uint| -> Result<T, Error>)
+                                -> Result<T, Error> { Err(SyntaxError) }
+        fn read_tuple_struct_arg<T>(&mut self,
+                                    _a_idx: uint,
+                                    _f: |&mut IntsDecoder| -> Result<T, Error>)
+                                    -> Result<T, Error> { Err(SyntaxError) }
+
+        // Specialized types:
+        fn read_option<T>(&mut self, _f: |&mut IntsDecoder, bool| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+
+        #[inline]
+        fn read_seq<T>(&mut self, f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
+            f(self, 3)
+        }
+        #[inline]
+        fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> {
+            f(self)
+        }
+
+        fn read_map<T>(&mut self, _f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+        fn read_map_elt_key<T>(&mut self, _idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+        fn read_map_elt_val<T>(&mut self, _idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+mod deserializer {
+    use std::num;
+    use std::vec;
+
+    use super::{Error, EndOfStream, SyntaxError};
+
+    use de::Deserializer;
+    use de::{Token, Int, SeqStart, Sep, End};
+
+    #[deriving(Eq, Show)]
+    enum IntsDeserializerState {
+        IntsDeserializserStartState,
+        IntsDeserializserSepOrEndState,
+        IntsDeserializserValueState,
+        IntsDeserializserEndState,
+    }
+
+    pub struct IntsDeserializer {
+        state: IntsDeserializerState,
+        len: uint,
+        iter: vec::MoveItems<int>,
+        value: Option<int>
+    }
+
+    impl IntsDeserializer {
+        #[inline]
+        pub fn new(values: Vec<int>) -> IntsDeserializer {
+            IntsDeserializer {
+                state: IntsDeserializserStartState,
+                len: values.len(),
+                iter: values.move_iter(),
+                value: None,
+            }
+        }
+    }
+
+    impl Iterator<Result<Token, Error>> for IntsDeserializer {
+        #[inline]
+        fn next(&mut self) -> Option<Result<Token, Error>> {
+            match self.state {
+                IntsDeserializserStartState => {
+                    self.state = IntsDeserializserSepOrEndState;
+                    Some(Ok(SeqStart(self.len)))
+                }
+                IntsDeserializserSepOrEndState => {
+                    match self.iter.next() {
+                        Some(value) => {
+                            self.state = IntsDeserializserValueState;
+                            self.value = Some(value);
+                            Some(Ok(Sep))
+                        }
+                        None => {
+                            self.state = IntsDeserializserEndState;
+                            Some(Ok(End))
+                        }
+                    }
+                }
+                IntsDeserializserValueState => {
+                    self.state = IntsDeserializserSepOrEndState;
+                    match self.value.take() {
+                        Some(value) => Some(Ok(Int(value))),
+                        None => Some(Err(self.end_of_stream_error())),
+                    }
+                }
+                IntsDeserializserEndState => {
+                    None
+                }
+            }
+        }
+    }
+
+    impl Deserializer<Error> for IntsDeserializer {
+        #[inline]
+        fn end_of_stream_error(&self) -> Error {
+            EndOfStream
+        }
+
+        #[inline]
+        fn syntax_error(&self) -> Error {
+            SyntaxError
+        }
+
+        #[inline]
+        fn expect_num<T: NumCast>(&mut self) -> Result<T, Error> {
+            assert_eq!(self.state, IntsDeserializserValueState);
+
+            self.state = IntsDeserializserSepOrEndState;
+
+            match self.value.take() {
+                Some(value) => {
+                    match num::cast(value) {
+                        Some(value) => Ok(value),
+                        None => Err(self.syntax_error()),
+                    }
+                }
+                None => Err(self.end_of_stream_error()),
+            }
+        }
+    }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+#[bench]
+fn bench_ints_decoder(b: &mut Bencher) {
+    b.iter(|| {
+        let ints = vec!(5, 6, 7);
+
+        let mut d = decoder::IntsDecoder::new(ints);
+        let value: Vec<int> = Decodable::decode(&mut d).unwrap();
+
+        assert_eq!(value, vec!(5, 6, 7));
+    })
+}
+
+#[bench]
+fn bench_ints_deserializer(b: &mut Bencher) {
+    b.iter(|| {
+        let ints = vec!(5, 6, 7);
+
+        let mut d = deserializer::IntsDeserializer::new(ints);
+        let value: Vec<int> = Deserializable::deserialize(&mut d).unwrap();
+
+        assert_eq!(value, vec!(5, 6, 7));
+    })
+}
diff --git a/de.rs b/de.rs
index d5d2cb31..1b650064 100644
--- a/de.rs
+++ b/de.rs
@@ -424,12 +424,10 @@ deserialize_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 
 #[cfg(test)]
 mod tests {
-    use std::num;
-    use std::vec;
     use collections::HashMap;
     use test::Bencher;
 
-    use serialize::{Decoder, Decodable};
+    use serialize::Decoder;
 
     use super::{Token, Null, Int, Uint, Str, StrBuf, Char, Option};
     use super::{TupleStart, StructStart, StructField, EnumStart, EnumVariant};
@@ -548,876 +546,6 @@ mod tests {
 
     //////////////////////////////////////////////////////////////////////////////
 
-    #[deriving(Eq, Show)]
-    enum IntsDeserializerState {
-        IntsDeserializserStartState,
-        IntsDeserializserSepOrEndState,
-        IntsDeserializserValueState,
-        IntsDeserializserEndState,
-    }
-
-    struct IntsDeserializer {
-        state: IntsDeserializerState,
-        len: uint,
-        iter: vec::MoveItems<int>,
-        value: Option<int>
-    }
-
-    impl IntsDeserializer {
-        #[inline]
-        fn new(values: Vec<int>) -> IntsDeserializer {
-            IntsDeserializer {
-                state: IntsDeserializserStartState,
-                len: values.len(),
-                iter: values.move_iter(),
-                value: None,
-            }
-        }
-    }
-
-    impl Iterator<Result<Token, Error>> for IntsDeserializer {
-        #[inline]
-        fn next(&mut self) -> Option<Result<Token, Error>> {
-            match self.state {
-                IntsDeserializserStartState => {
-                    self.state = IntsDeserializserSepOrEndState;
-                    Some(Ok(SeqStart(self.len)))
-                }
-                IntsDeserializserSepOrEndState => {
-                    match self.iter.next() {
-                        Some(value) => {
-                            self.state = IntsDeserializserValueState;
-                            self.value = Some(value);
-                            Some(Ok(Sep))
-                        }
-                        None => {
-                            self.state = IntsDeserializserEndState;
-                            Some(Ok(End))
-                        }
-                    }
-                }
-                IntsDeserializserValueState => {
-                    self.state = IntsDeserializserSepOrEndState;
-                    match self.value.take() {
-                        Some(value) => Some(Ok(Int(value))),
-                        None => Some(Err(self.end_of_stream_error())),
-                    }
-                }
-                IntsDeserializserEndState => {
-                    None
-                }
-            }
-        }
-    }
-
-    impl Deserializer<Error> for IntsDeserializer {
-        #[inline]
-        fn end_of_stream_error(&self) -> Error {
-            EndOfStream
-        }
-
-        #[inline]
-        fn syntax_error(&self) -> Error {
-            SyntaxError
-        }
-
-        #[inline]
-        fn expect_num<T: NumCast>(&mut self) -> Result<T, Error> {
-            assert_eq!(self.state, IntsDeserializserValueState);
-
-            self.state = IntsDeserializserSepOrEndState;
-
-            match self.value.take() {
-                Some(value) => {
-                    match num::cast(value) {
-                        Some(value) => Ok(value),
-                        None => Err(self.syntax_error()),
-                    }
-                }
-                None => Err(self.end_of_stream_error()),
-            }
-        }
-    }
-
-    //////////////////////////////////////////////////////////////////////////////
-
-    struct IntsDecoder {
-        iter: vec::MoveItems<int>,
-    }
-
-    impl IntsDecoder {
-        #[inline]
-        fn new(values: Vec<int>) -> IntsDecoder {
-            IntsDecoder {
-                iter: values.move_iter()
-            }
-        }
-    }
-
-    impl Decoder<Error> for IntsDecoder {
-        // Primitive types:
-        fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
-        fn read_uint(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
-        fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
-        #[inline]
-        fn read_int(&mut self) -> Result<int, Error> {
-            match self.iter.next() {
-                Some(value) => Ok(value),
-                None => Err(EndOfStream),
-            }
-        }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
-        fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
-        fn read_str(&mut self) -> Result<StrBuf, Error> { Err(SyntaxError) }
-
-        // Compound types:
-        fn read_enum<T>(&mut self, _name: &str, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_enum_variant<T>(&mut self,
-                                _names: &[&str],
-                                _f: |&mut IntsDecoder, uint| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-        fn read_enum_variant_arg<T>(&mut self,
-                                    _a_idx: uint,
-                                    _f: |&mut IntsDecoder| -> Result<T, Error>)
-                                    -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_enum_struct_variant<T>(&mut self,
-                                       _names: &[&str],
-                                       _f: |&mut IntsDecoder, uint| -> Result<T, Error>)
-                                       -> Result<T, Error> { Err(SyntaxError) }
-        fn read_enum_struct_variant_field<T>(&mut self,
-                                             _f_name: &str,
-                                             _f_idx: uint,
-                                             _f: |&mut IntsDecoder| -> Result<T, Error>)
-                                             -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_struct<T>(&mut self, _s_name: &str, _len: uint, _f: |&mut IntsDecoder| -> Result<T, Error>)
-                          -> Result<T, Error> { Err(SyntaxError) }
-        fn read_struct_field<T>(&mut self,
-                                _f_name: &str,
-                                _f_idx: uint,
-                                _f: |&mut IntsDecoder| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_tuple<T>(&mut self, _f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_tuple_struct<T>(&mut self,
-                                _s_name: &str,
-                                _f: |&mut IntsDecoder, uint| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_struct_arg<T>(&mut self,
-                                    _a_idx: uint,
-                                    _f: |&mut IntsDecoder| -> Result<T, Error>)
-                                    -> Result<T, Error> { Err(SyntaxError) }
-
-        // Specialized types:
-        fn read_option<T>(&mut self, _f: |&mut IntsDecoder, bool| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        #[inline]
-        fn read_seq<T>(&mut self, f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
-            f(self, 3)
-        }
-        #[inline]
-        fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            f(self)
-        }
-
-        fn read_map<T>(&mut self, _f: |&mut IntsDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_map_elt_key<T>(&mut self, _idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_map_elt_val<T>(&mut self, _idx: uint, _f: |&mut IntsDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-    }
-
-    //////////////////////////////////////////////////////////////////////////////
-
-    enum AnimalDecoderState {
-        AnimalDecoderAnimalState(Animal),
-        AnimalDecoderDogState,
-        AnimalDecoderFrogState,
-        AnimalDecoderIntState(int),
-        AnimalDecoderStrState(StrBuf),
-    }
-
-    struct AnimalDecoder {
-        stack: Vec<AnimalDecoderState>,
-
-    }
-
-    impl AnimalDecoder {
-        #[inline]
-        fn new(animal: Animal) -> AnimalDecoder {
-            AnimalDecoder {
-                stack: vec!(AnimalDecoderAnimalState(animal)),
-            }
-        }
-    }
-
-    impl Decoder<Error> for AnimalDecoder {
-        // Primitive types:
-        fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
-        fn read_uint(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
-        fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
-        #[inline]
-        fn read_int(&mut self) -> Result<int, Error> {
-            match self.stack.pop() {
-                Some(AnimalDecoderIntState(x)) => Ok(x),
-                _ => Err(SyntaxError),
-            }
-        }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
-        fn read_char(&mut self) -> Result<char, Error> { Err(SyntaxError) }
-        #[inline]
-        fn read_str(&mut self) -> Result<StrBuf, Error> {
-            match self.stack.pop() {
-                Some(AnimalDecoderStrState(x)) => Ok(x),
-                _ => Err(SyntaxError),
-            }
-        }
-
-        // Compound types:
-        #[inline]
-        fn read_enum<T>(&mut self, name: &str, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            match self.stack.pop() {
-                Some(AnimalDecoderAnimalState(animal)) => {
-                    self.stack.push(AnimalDecoderAnimalState(animal));
-                    if name == "Animal" {
-                        f(self)
-                    } else {
-                        Err(SyntaxError)
-                    }
-                }
-                _ => Err(SyntaxError)
-            }
-        }
-
-        #[inline]
-        fn read_enum_variant<T>(&mut self, names: &[&str], f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
-            let name = match self.stack.pop() {
-                Some(AnimalDecoderAnimalState(Dog)) => "Dog",
-                Some(AnimalDecoderAnimalState(Frog(x0, x1))) => {
-                    self.stack.push(AnimalDecoderIntState(x1));
-                    self.stack.push(AnimalDecoderStrState(x0));
-                    "Frog"
-                }
-                _ => { return Err(SyntaxError); }
-            };
-
-            let idx = match names.iter().position(|n| *n == name) {
-                Some(idx) => idx,
-                None => { return Err(SyntaxError); }
-            };
-
-            f(self, idx)
-        }
-        #[inline]
-        fn read_enum_variant_arg<T>(&mut self, _a_idx: uint, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            f(self)
-        }
-        fn read_enum_struct_variant<T>(&mut self,
-                                       _names: &[&str],
-                                       _f: |&mut AnimalDecoder, uint| -> Result<T, Error>)
-                                       -> Result<T, Error> { Err(SyntaxError) }
-        fn read_enum_struct_variant_field<T>(&mut self,
-                                             _f_name: &str,
-                                             _f_idx: uint,
-                                             _f: |&mut AnimalDecoder| -> Result<T, Error>)
-                                             -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_struct<T>(&mut self, _s_name: &str, _len: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>)
-                          -> Result<T, Error> { Err(SyntaxError) }
-        fn read_struct_field<T>(&mut self,
-                                _f_name: &str,
-                                _f_idx: uint,
-                                _f: |&mut AnimalDecoder| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_tuple<T>(&mut self, _f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_tuple_struct<T>(&mut self,
-                                _s_name: &str,
-                                _f: |&mut AnimalDecoder, uint| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_struct_arg<T>(&mut self,
-                                    _a_idx: uint,
-                                    _f: |&mut AnimalDecoder| -> Result<T, Error>)
-                                    -> Result<T, Error> { Err(SyntaxError) }
-
-        // Specialized types:
-        fn read_option<T>(&mut self, _f: |&mut AnimalDecoder, bool| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        #[inline]
-        fn read_seq<T>(&mut self, f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
-            f(self, 3)
-        }
-        #[inline]
-        fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            f(self)
-        }
-
-        fn read_map<T>(&mut self, _f: |&mut AnimalDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_map_elt_key<T>(&mut self, _idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_map_elt_val<T>(&mut self, _idx: uint, _f: |&mut AnimalDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-    }
-
-    //////////////////////////////////////////////////////////////////////////////
-
-    enum AnimalDeserializerState {
-        AnimalDeserializerAnimalState(Animal),
-        AnimalDeserializerDogState,
-        AnimalDeserializerFrogState,
-        AnimalDeserializerIntState(int),
-        AnimalDeserializerStrState(StrBuf),
-        AnimalDeserializerEndState,
-
-    }
-
-    struct AnimalDeserializer {
-        stack: Vec<AnimalDeserializerState>,
-    }
-
-    impl AnimalDeserializer {
-        #[inline]
-        fn new(animal: Animal) -> AnimalDeserializer {
-            AnimalDeserializer {
-                stack: vec!(AnimalDeserializerAnimalState(animal)),
-            }
-        }
-    }
-
-    impl Iterator<Result<Token, Error>> for AnimalDeserializer {
-        #[inline]
-        fn next(&mut self) -> Option<Result<Token, Error>> {
-            match self.stack.pop() {
-                Some(AnimalDeserializerAnimalState(Dog)) => {
-                    self.stack.push(AnimalDeserializerEndState);
-                    self.stack.push(AnimalDeserializerDogState);
-                    Some(Ok(EnumStart("Animal")))
-                }
-                Some(AnimalDeserializerAnimalState(Frog(x0, x1))) => {
-                    self.stack.push(AnimalDeserializerEndState);
-                    self.stack.push(AnimalDeserializerIntState(x1));
-                    self.stack.push(AnimalDeserializerStrState(x0));
-                    self.stack.push(AnimalDeserializerFrogState);
-                    Some(Ok(EnumStart("Animal")))
-                }
-                Some(AnimalDeserializerDogState) => {
-                    Some(Ok(EnumVariant("Dog")))
-                }
-                Some(AnimalDeserializerFrogState) => {
-                    Some(Ok(EnumVariant("Frog")))
-                }
-                Some(AnimalDeserializerIntState(x)) => {
-                    Some(Ok(Int(x)))
-                }
-                Some(AnimalDeserializerStrState(x)) => {
-                    Some(Ok(StrBuf(x)))
-                }
-                Some(AnimalDeserializerEndState) => {
-                    Some(Ok(End))
-                }
-                None => None,
-            }
-        }
-    }
-
-    impl Deserializer<Error> for AnimalDeserializer {
-        #[inline]
-        fn end_of_stream_error(&self) -> Error {
-            EndOfStream
-        }
-
-        #[inline]
-        fn syntax_error(&self) -> Error {
-            SyntaxError
-        }
-    }
-
-    //////////////////////////////////////////////////////////////////////////////
-
-    #[deriving(Show)]
-    enum OuterDecoderState {
-        OuterDecoderOuterState(Outer),
-        OuterDecoderInnerState(Inner),
-        OuterDecoderNullState,
-        OuterDecoderUintState(uint),
-        OuterDecoderCharState(char),
-        OuterDecoderStrState(StrBuf),
-        OuterDecoderFieldState(&'static str),
-        OuterDecoderVecState(Vec<Inner>),
-        OuterDecoderMapState(HashMap<StrBuf, Option<char>>),
-        OuterDecoderOptionState(bool),
-    }
-
-    struct OuterDecoder {
-        stack: Vec<OuterDecoderState>,
-
-    }
-
-    impl OuterDecoder {
-        #[inline]
-        fn new(animal: Outer) -> OuterDecoder {
-            OuterDecoder {
-                stack: vec!(OuterDecoderOuterState(animal)),
-            }
-        }
-    }
-
-    impl Decoder<Error> for OuterDecoder {
-        // Primitive types:
-        #[inline]
-        fn read_nil(&mut self) -> Result<(), Error> {
-            match self.stack.pop() {
-                Some(OuterDecoderNullState) => Ok(()),
-                _ => Err(SyntaxError),
-            }
-        }
-        #[inline]
-        fn read_uint(&mut self) -> Result<uint, Error> {
-            match self.stack.pop() {
-                Some(OuterDecoderUintState(value)) => Ok(value),
-                _ => Err(SyntaxError),
-            }
-        }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
-        fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
-        fn read_int(&mut self) -> Result<int, Error> { Err(SyntaxError) }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(SyntaxError) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(SyntaxError) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(SyntaxError) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(SyntaxError) }
-        #[inline]
-        fn read_char(&mut self) -> Result<char, Error> {
-            match self.stack.pop() {
-                Some(OuterDecoderCharState(c)) => Ok(c),
-                _ => Err(SyntaxError),
-            }
-        }
-        #[inline]
-        fn read_str(&mut self) -> Result<StrBuf, Error> {
-            match self.stack.pop() {
-                Some(OuterDecoderStrState(value)) => Ok(value),
-                _ => Err(SyntaxError),
-            }
-        }
-
-        // Compound types:
-        fn read_enum<T>(&mut self, _name: &str, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_enum_variant<T>(&mut self,
-                                _names: &[&str],
-                                _f: |&mut OuterDecoder, uint| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-        fn read_enum_variant_arg<T>(&mut self,
-                                    _a_idx: uint,
-                                    _f: |&mut OuterDecoder| -> Result<T, Error>)
-                                    -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_enum_struct_variant<T>(&mut self,
-                                       _names: &[&str],
-                                       _f: |&mut OuterDecoder, uint| -> Result<T, Error>)
-                                       -> Result<T, Error> { Err(SyntaxError) }
-        fn read_enum_struct_variant_field<T>(&mut self,
-                                             _f_name: &str,
-                                             _f_idx: uint,
-                                             _f: |&mut OuterDecoder| -> Result<T, Error>)
-                                             -> Result<T, Error> { Err(SyntaxError) }
-
-        #[inline]
-        fn read_struct<T>(&mut self, s_name: &str, _len: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            match self.stack.pop() {
-                Some(OuterDecoderOuterState(Outer { inner: inner })) => {
-                    if s_name == "Outer" {
-                        self.stack.push(OuterDecoderVecState(inner));
-                        self.stack.push(OuterDecoderFieldState("inner"));
-                        f(self)
-                    } else {
-                        Err(SyntaxError)
-                    }
-                }
-                Some(OuterDecoderInnerState(Inner { a: (), b: b, c: c })) => {
-                    if s_name == "Inner" {
-                        self.stack.push(OuterDecoderMapState(c));
-                        self.stack.push(OuterDecoderFieldState("c"));
-
-                        self.stack.push(OuterDecoderUintState(b));
-                        self.stack.push(OuterDecoderFieldState("b"));
-
-                        self.stack.push(OuterDecoderNullState);
-                        self.stack.push(OuterDecoderFieldState("a"));
-                        f(self)
-                    } else {
-                        Err(SyntaxError)
-                    }
-                }
-                _ => Err(SyntaxError),
-            }
-        }
-        #[inline]
-        fn read_struct_field<T>(&mut self, f_name: &str, _f_idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            match self.stack.pop() {
-                Some(OuterDecoderFieldState(name)) => {
-                    if f_name == name {
-                        f(self)
-                    } else {
-                        Err(SyntaxError)
-                    }
-                }
-                _ => Err(SyntaxError)
-            }
-        }
-
-        fn read_tuple<T>(&mut self, _f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_arg<T>(&mut self, _a_idx: uint, _f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> { Err(SyntaxError) }
-
-        fn read_tuple_struct<T>(&mut self,
-                                _s_name: &str,
-                                _f: |&mut OuterDecoder, uint| -> Result<T, Error>)
-                                -> Result<T, Error> { Err(SyntaxError) }
-        fn read_tuple_struct_arg<T>(&mut self,
-                                    _a_idx: uint,
-                                    _f: |&mut OuterDecoder| -> Result<T, Error>)
-                                    -> Result<T, Error> { Err(SyntaxError) }
-
-        // Specialized types:
-        #[inline]
-        fn read_option<T>(&mut self, f: |&mut OuterDecoder, bool| -> Result<T, Error>) -> Result<T, Error> {
-            match self.stack.pop() {
-                Some(OuterDecoderOptionState(b)) => f(self, b),
-                _ => Err(SyntaxError),
-            }
-        }
-
-        #[inline]
-        fn read_seq<T>(&mut self, f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
-            match self.stack.pop() {
-                Some(OuterDecoderVecState(value)) => {
-                    let len = value.len();
-                    for inner in value.move_iter().rev() {
-                        self.stack.push(OuterDecoderInnerState(inner));
-                    }
-                    f(self, len)
-                }
-                _ => Err(SyntaxError)
-            }
-        }
-        #[inline]
-        fn read_seq_elt<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            f(self)
-        }
-
-        #[inline]
-        fn read_map<T>(&mut self, f: |&mut OuterDecoder, uint| -> Result<T, Error>) -> Result<T, Error> {
-            match self.stack.pop() {
-                Some(OuterDecoderMapState(map)) => {
-                    let len = map.len();
-                    for (key, value) in map.move_iter() {
-                        match value {
-                            Some(c) => {
-                                self.stack.push(OuterDecoderCharState(c));
-                                self.stack.push(OuterDecoderOptionState(true));
-                            }
-                            None => {
-                                self.stack.push(OuterDecoderOptionState(false));
-                            }
-                        }
-                        self.stack.push(OuterDecoderStrState(key));
-                    }
-                    f(self, len)
-                }
-                _ => Err(SyntaxError),
-            }
-        }
-        #[inline]
-        fn read_map_elt_key<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            f(self)
-        }
-        #[inline]
-        fn read_map_elt_val<T>(&mut self, _idx: uint, f: |&mut OuterDecoder| -> Result<T, Error>) -> Result<T, Error> {
-            f(self)
-        }
-    }
-
-    //////////////////////////////////////////////////////////////////////////////
-
-    enum OuterDeserializerState {
-        OuterDeserializerOuterState(Outer),
-        OuterDeserializerInnerState(Inner),
-        OuterDeserializerFieldState(&'static str),
-        OuterDeserializerNullState,
-        OuterDeserializerUintState(uint),
-        OuterDeserializerCharState(char),
-        OuterDeserializerStrState(StrBuf),
-        OuterDeserializerOptionState(bool),
-        OuterDeserializerTupleState(uint),
-        OuterDeserializerVecState(uint),
-        OuterDeserializerMapState(uint),
-        OuterDeserializerSepState,
-        OuterDeserializerEndState,
-
-    }
-
-    struct OuterDeserializer {
-        stack: Vec<OuterDeserializerState>,
-    }
-
-    impl OuterDeserializer {
-        #[inline]
-        fn new(outer: Outer) -> OuterDeserializer {
-            OuterDeserializer {
-                stack: vec!(OuterDeserializerOuterState(outer)),
-            }
-        }
-    }
-
-    impl Iterator<Result<Token, Error>> for OuterDeserializer {
-        #[inline]
-        fn next(&mut self) -> Option<Result<Token, Error>> {
-            match self.stack.last() {
-                Some(&OuterDeserializerOuterState(_)) => {
-                    states::outer_state(self)
-                }
-                Some(&OuterDeserializerInnerState(_)) => {
-                    states::inner_state(self)
-                }
-                Some(&OuterDeserializerFieldState(_)) => {
-                    states::field_state(self)
-                }
-                Some(&OuterDeserializerVecState(_)) => {
-                    states::vec_state(self)
-                }
-                Some(&OuterDeserializerMapState(_)) => {
-                    states::map_state(self)
-                }
-                Some(&OuterDeserializerTupleState(_)) => {
-                    states::tuple_state(self)
-                }
-                Some(&OuterDeserializerSepState) => {
-                    states::sep_state(self)
-                }
-                Some(&OuterDeserializerNullState) => {
-                    states::null_state(self)
-                }
-                Some(&OuterDeserializerUintState(_)) => {
-                    states::uint_state(self)
-                }
-                Some(&OuterDeserializerCharState(_)) => {
-                    states::char_state(self)
-                }
-                Some(&OuterDeserializerStrState(_)) => {
-                    states::strbuf_state(self)
-                }
-                Some(&OuterDeserializerOptionState(_)) => {
-                    states::option_state(self)
-                }
-                Some(&OuterDeserializerEndState) => {
-                    states::end_state(self)
-                }
-                None => None,
-            }
-        }
-    }
-
-    impl Deserializer<Error> for OuterDeserializer {
-        #[inline]
-        fn end_of_stream_error(&self) -> Error {
-            EndOfStream
-        }
-
-        #[inline]
-        fn syntax_error(&self) -> Error {
-            SyntaxError
-        }
-    }
-
-    mod states {
-        use super::{OuterDeserializer, Error, Outer, Inner};
-        use super::{
-            OuterDeserializerOuterState,
-            OuterDeserializerInnerState,
-            OuterDeserializerFieldState,
-            OuterDeserializerNullState,
-            OuterDeserializerUintState,
-            OuterDeserializerCharState,
-            OuterDeserializerStrState,
-            OuterDeserializerOptionState,
-            OuterDeserializerTupleState,
-            OuterDeserializerVecState,
-            OuterDeserializerMapState,
-            OuterDeserializerSepState,
-            OuterDeserializerEndState,
-        };
-
-        use super::super::{Token, Null, Uint, StrBuf, Char, Option};
-        use super::super::{TupleStart, StructStart, StructField};
-        use super::super::{SeqStart, MapStart, Sep, End};
-        use super::super::Deserializer;
-
-        pub fn outer_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            let inner = match d.stack.pop() {
-                Some(OuterDeserializerOuterState(Outer { inner })) => inner,
-                _ => { return Some(Err(d.syntax_error())); }
-            };
-
-            d.stack.push(OuterDeserializerEndState);
-
-            d.stack.push(OuterDeserializerEndState);
-            let len = inner.len();
-            for v in inner.move_iter().rev() {
-                d.stack.push(OuterDeserializerInnerState(v));
-                d.stack.push(OuterDeserializerSepState);
-            }
-            d.stack.push(OuterDeserializerVecState(len));
-
-            d.stack.push(OuterDeserializerFieldState("inner"));
-            Some(Ok(StructStart("Outer")))
-        }
-
-        pub fn inner_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            let ((), b, c) = match d.stack.pop() {
-                Some(OuterDeserializerInnerState(Inner { a, b, c })) => (a, b, c),
-                _ => { return Some(Err(d.syntax_error())); }
-            };
-
-            d.stack.push(OuterDeserializerEndState);
-
-            d.stack.push(OuterDeserializerEndState);
-            let len = c.len();
-            for (k, v) in c.move_iter() {
-                d.stack.push(OuterDeserializerEndState);
-                match v {
-                    Some(c) => {
-                        d.stack.push(OuterDeserializerCharState(c));
-                        d.stack.push(OuterDeserializerOptionState(true));
-                    }
-                    None => {
-                        d.stack.push(OuterDeserializerOptionState(false));
-                    }
-                }
-                d.stack.push(OuterDeserializerSepState);
-
-                d.stack.push(OuterDeserializerStrState(k));
-                d.stack.push(OuterDeserializerSepState);
-                d.stack.push(OuterDeserializerTupleState(2));
-
-                d.stack.push(OuterDeserializerSepState);
-            }
-            d.stack.push(OuterDeserializerMapState(len));
-
-            d.stack.push(OuterDeserializerFieldState("c"));
-
-            d.stack.push(OuterDeserializerUintState(b));
-            d.stack.push(OuterDeserializerFieldState("b"));
-
-            d.stack.push(OuterDeserializerNullState);
-            d.stack.push(OuterDeserializerFieldState("a"));
-            Some(Ok(StructStart("Inner")))
-        }
-
-        pub fn field_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            match d.stack.pop() {
-                Some(OuterDeserializerFieldState(name)) => Some(Ok(StructField(name))),
-                _ => Some(Err(d.syntax_error())),
-            }
-        }
-
-        pub fn vec_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            match d.stack.pop() {
-                Some(OuterDeserializerVecState(len)) => Some(Ok(SeqStart(len))),
-                _ => Some(Err(d.syntax_error())),
-            }
-        }
-
-        pub fn map_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            match d.stack.pop() {
-                Some(OuterDeserializerMapState(len)) => Some(Ok(MapStart(len))),
-                _ => Some(Err(d.syntax_error())),
-            }
-        }
-
-        pub fn tuple_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            match d.stack.pop() {
-                Some(OuterDeserializerTupleState(len)) => Some(Ok(TupleStart(len))),
-                _ => Some(Err(d.syntax_error())),
-            }
-        }
-
-        pub fn sep_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            match d.stack.pop() {
-                Some(OuterDeserializerSepState) => Some(Ok(Sep)),
-                _ => Some(Err(d.syntax_error())),
-            }
-        }
-
-        pub fn null_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            match d.stack.pop() {
-                Some(OuterDeserializerNullState) => Some(Ok(Null)),
-                _ => Some(Err(d.syntax_error())),
-            }
-        }
-
-        pub fn uint_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            match d.stack.pop() {
-                Some(OuterDeserializerUintState(x)) => Some(Ok(Uint(x))),
-                _ => Some(Err(d.syntax_error())),
-            }
-        }
-
-        pub fn char_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            match d.stack.pop() {
-                Some(OuterDeserializerCharState(x)) => Some(Ok(Char(x))),
-                _ => Some(Err(d.syntax_error())),
-            }
-        }
-
-        pub fn strbuf_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            match d.stack.pop() {
-                Some(OuterDeserializerStrState(x)) => Some(Ok(StrBuf(x))),
-                _ => Some(Err(d.syntax_error())),
-            }
-        }
-
-        pub fn option_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            match d.stack.pop() {
-                Some(OuterDeserializerOptionState(x)) => Some(Ok(Option(x))),
-                _ => Some(Err(d.syntax_error())),
-            }
-        }
-
-        pub fn end_state(d: &mut OuterDeserializer) -> Option<Result<Token, Error>> {
-            match d.stack.pop() {
-                Some(OuterDeserializerEndState) => Some(Ok(End)),
-                _ => Some(Err(d.syntax_error())),
-            }
-        }
-    }
-
-    //////////////////////////////////////////////////////////////////////////////
-
     #[test]
     fn test_tokens_int() {
         let tokens = vec!(
@@ -1772,98 +900,4 @@ mod tests {
             assert_eq!(value, vec!(5, 6, 7));
         })
     }
-
-    #[bench]
-    fn bench_ints_deserializer(b: &mut Bencher) {
-        b.iter(|| {
-            let ints = vec!(5, 6, 7);
-
-            let mut d = IntsDeserializer::new(ints);
-            let value: Vec<int> = Deserializable::deserialize(&mut d).unwrap();
-
-            assert_eq!(value, vec!(5, 6, 7));
-        })
-    }
-
-    #[bench]
-    fn bench_ints_decoder(b: &mut Bencher) {
-        b.iter(|| {
-            let ints = vec!(5, 6, 7);
-
-            let mut d = IntsDecoder::new(ints);
-            let value: Vec<int> = Decodable::decode(&mut d).unwrap();
-
-            assert_eq!(value, vec!(5, 6, 7));
-        })
-    }
-
-    #[bench]
-    fn bench_enum_decoder(b: &mut Bencher) {
-        b.iter(|| {
-            let animal = Frog("Henry".to_strbuf(), 349);
-
-            let mut d = AnimalDecoder::new(animal.clone());
-            let value: Animal = Decodable::decode(&mut d).unwrap();
-
-            assert_eq!(value, animal);
-        })
-    }
-
-    #[bench]
-    fn bench_enum_deserializer(b: &mut Bencher) {
-        b.iter(|| {
-            let animal = Frog("Henry".to_strbuf(), 349);
-
-            let mut d = AnimalDeserializer::new(animal.clone());
-            let value: Animal = Deserializable::deserialize(&mut d).unwrap();
-
-            assert_eq!(value, animal);
-        })
-    }
-
-    #[bench]
-    fn bench_struct_decoder(b: &mut Bencher) {
-        b.iter(|| {
-            let mut map = HashMap::new();
-            map.insert("abc".to_strbuf(), Some('c'));
-
-            let outer = Outer {
-                inner: vec!(
-                    Inner {
-                        a: (),
-                        b: 5,
-                        c: map,
-                    },
-                )
-            };
-
-            let mut d = OuterDecoder::new(outer.clone());
-            let value: Outer = Decodable::decode(&mut d).unwrap();
-
-            assert_eq!(value, outer);
-        })
-    }
-
-    #[bench]
-    fn bench_struct_deserializer(b: &mut Bencher) {
-        b.iter(|| {
-            let mut map = HashMap::new();
-            map.insert("abc".to_strbuf(), Some('c'));
-
-            let outer = Outer {
-                inner: vec!(
-                    Inner {
-                        a: (),
-                        b: 5,
-                        c: map,
-                    },
-                )
-            };
-
-            let mut d = OuterDeserializer::new(outer.clone());
-            let value: Outer = Deserializable::deserialize(&mut d).unwrap();
-
-            assert_eq!(value, outer);
-        })
-    }
 }
diff --git a/serde.rs b/serde.rs
index b84d9c30..4e46354c 100644
--- a/serde.rs
+++ b/serde.rs
@@ -13,3 +13,12 @@ extern crate serialize;
 
 pub mod de;
 //pub mod json;
+
+#[cfg(test)]
+pub mod bench_enum;
+
+#[cfg(test)]
+pub mod bench_struct;
+
+#[cfg(test)]
+pub mod bench_vec;