typedef unsigned int size_t;
                    typedef long long int int64_t;
                    typedef unsigned char uint8_t;
                    namespace std {
                  typedef unsigned int size_t;
                }
                    extern "C++" {
                inline void* operator new(std::size_t, void* __p) throw() {
             }
                    typedef int64_t EncodedJSValue;
                    class JSValue {
                 public:         static JSValue decode(EncodedJSValue ptr);
                     bool isInt32() const;
                     double asDouble() const;
                     bool isNull() const;
                     bool isNumber() const;
                     bool isCell() const;
                 };
                    template<typename T, size_t inlineCapacity = 0>     class Vector {
                 public:         typedef T* iterator;
                     typedef const T* const_iterator;
                     const_iterator end() const {
          }
                     template<typename U> void append(const U&);
                 };
                    template<typename T, size_t inlineCapacity> template<typename U>     inline __attribute__((__always_inline__)) void Vector<T, inlineCapacity>::append(const U& val)     {
                     const U* ptr = &val;
                     new (end()) T(*ptr);
                 }
                enum WalkerState {
             StateUnknown, ArrayStartState, ArrayStartVisitMember, ArrayEndVisitMember,     ObjectStartState, ObjectStartVisitMember, ObjectEndVisitMember };
                enum SerializationTag {
                 NullTag = 4,     IntTag = 5,     RegExpTag = 18, };
                class CloneBase {
             };
                template <typename T> static void writeLittleEndian(Vector<uint8_t>& buffer, T value) {
                 for (unsigned i = 0;
             i < sizeof(T);
             i++) {
                  buffer.append(value & 0xFF);
                  value >>= 8;
              }
             }
                class CloneSerializer : CloneBase {
                 bool serialize(JSValue in);
                 void dumpImmediate(JSValue value)     {
                  if (value.isNull())             write(NullTag);
                  else if (value.isNumber()) {
                    if (value.isInt32()) {
                       write(value.asDouble());
                   }
                }
              }
                 bool dumpIfTerminal(JSValue value)     {
                  if (!value.isCell()) {
                    dumpImmediate(value);
                }
              }
                 void write(double d)     {
                  union {
                    double d;
                    int64_t i;
                }
          u;
                  u.d = d;
                  writeLittleEndian(m_buffer, u.i);
              }
                 Vector<uint8_t>& m_buffer;
             };
                bool CloneSerializer::serialize(JSValue in) {
                 WalkerState state = StateUnknown;
                 JSValue inValue = in;
                 while (1) {
                  switch (state) {
                    arrayStartState:             case ArrayStartState: {
                   }
                    case StateUnknown:                 if (dumpIfTerminal(inValue))                     goto arrayStartState;
                }
              }
             }
                }