public static IoString createObject(IoState state, string symbol)
 {
     IoString str = new IoString();
     str = str.clone(state) as IoString;
     str.value = symbol;
     return str;
 }

        public static IoNumber newWithDouble(IoState state, double n)
        {
            IoNumber fab = new IoNumber();
            IoNumber num = state.protoWithInitFunc(fab.name) as IoNumber;
            num = num.clone(state) as IoNumber;
            num.isInteger = false;
            num.doubleValue = n;

            if (Double.Equals(n, 0) ||
                (!Double.IsInfinity(n) && !Double.IsNaN(n) &&
                !n.ToString(CultureInfo.InvariantCulture).Contains(".") &&
                !n.ToString(CultureInfo.InvariantCulture).Contains("E") &&
                !n.ToString(CultureInfo.InvariantCulture).Contains("e")
                )
            )
            {
                try
                {
                    num.longValue = Convert.ToInt32(n);
                    num.isInteger = true;
                }
                catch (OverflowException oe)
                {

                }
            }
            return num;
        }

 public static IoSeq createObject(IoState state, string symbol)
 {
     IoSeq seq = new IoSeq();
     seq = seq.clone(state) as IoSeq;
     seq.value = symbol;
     return seq;
 }

 public IoCLR(IoState state, string name)
 {
     isActivatable = true;
     this.state = state;
     createSlots();
     createProtos();
     uniqueId = 0;
 }

 public IoCFunction(IoState state, string name, IoMethodFunc func)
 {
     isActivatable = true;
     this.state = state;
     createSlots();
     createProtos();
     uniqueId = 0;
     funcName = name;
     this.func = func;
 }

 public override IoObject clone(IoState state)
 {
     IoCLRObject proto = state.protoWithInitFunc(name) as IoCLRObject;
     IoCLRObject result = new IoCLRObject();
     result.isActivatable = true;
     uniqueIdCounter++;
     result.uniqueId = uniqueIdCounter;
     result.state = state;
     result.createProtos();
     result.createSlots();
     result.protos.Add(proto);
     return result;
 }

        public override IoObject proto(IoState state)
        {
            IoCLRAssembly pro = new IoCLRAssembly();
            pro.state = state;
            pro.uniqueId = 0;
            pro.createSlots();
            pro.createProtos();
            pro.isActivatable = true;
            state.registerProtoWithFunc(pro.name, new IoStateProto(pro.name, pro, new IoStateProtoFunc(pro.proto)));
            //pro.protos.Add(state.protoWithInitFunc("Object"));

            IoCFunction[] methodTable = new IoCFunction[] {
                new IoCFunction("namespaces", new IoMethodFunc(IoCLRAssembly.slotNamespaces)),
            };

            pro.addTaglessMethodTable(state, methodTable);
            return pro;
        }

 static void Main()
 {
     IoState state = new IoState();
     state.prompt(state);
 }

 public static new IoCLRAssembly createProto(IoState state)
 {
     IoCLRAssembly cf = new IoCLRAssembly();
     return cf.proto(state) as IoCLRAssembly;
 }

 public static new IoCLRAssembly createObject(IoState state)
 {
     IoCLRAssembly cf = new IoCLRAssembly();
     return cf.proto(state).clone(state) as IoCLRAssembly;
 }

 public IoSeqObjectHashtable(IoState s)
 {
     state = s;
 }

 public static new IoBlock createObject(IoState state)
 {
     IoBlock number = new IoBlock();
     return number.clone(state) as IoBlock;
 }

        public override IoObject proto(IoState state)
        {
            IoMap pro = new IoMap();
            pro.state = state;
            pro.createSlots();
            pro.createProtos();
            pro.map = new Hashtable();
            state.registerProtoWithFunc(pro.name, new IoStateProto(pro.name, pro, new IoStateProtoFunc(pro.proto)));
            pro.protos.Add(state.protoWithInitFunc("Object"));

            IoCFunction[] methodTable = new IoCFunction[] {
                new IoCFunction("at", new IoMethodFunc(IoMap.slotAt)),
                new IoCFunction("atPut", new IoMethodFunc(IoMap.slotAtPut)),
                new IoCFunction("atIfAbsentPut", new IoMethodFunc(IoMap.slotAtIfAbsentPut)),
                new IoCFunction("empty", new IoMethodFunc(IoMap.slotEmpty)),
                new IoCFunction("size", new IoMethodFunc(IoMap.slotSize)),
                new IoCFunction("removeAt", new IoMethodFunc(IoMap.slotRemoveAt)),
                new IoCFunction("hasKey", new IoMethodFunc(IoMap.slotHasKey)),
                new IoCFunction("hasValue", new IoMethodFunc(IoMap.slotHasValue)),
            };

            pro.addTaglessMethodTable(state, methodTable);
            return pro;
        }

        public override IoObject proto(IoState state)
        {
            IoString pro = new IoString();
            pro.state = state;
            //    pro.tag.cloneFunc = new IoTagCloneFunc(this.clone);
            //    pro.tag.compareFunc = new IoTagCompareFunc(this.compare);
            pro.createSlots();
            pro.createProtos();
            state.registerProtoWithFunc(name, new IoStateProto(name, pro, new IoStateProtoFunc(this.proto)));
            pro.protos.Add(state.protoWithInitFunc("Object"));

            IoCFunction[] methodTable = new IoCFunction[] {
                new IoCFunction("appendStr", new IoMethodFunc(IoString.slotAppendStr)),
                new IoCFunction("at", new IoMethodFunc(IoString.slotAt)),
                new IoCFunction("reverse", new IoMethodFunc(IoString.slotReverse)),
            };

            pro.addTaglessMethodTable(state, methodTable);
            return pro;
        }

 public override IoObject clone(IoState state)
 {
     IoString proto = state.protoWithInitFunc(name) as IoString;
     IoString result = new IoString();
     result.state = state;
     result.value = proto.value;
     result.createProtos();
     result.createSlots();
     result.protos.Add(proto);
     return result;
 }

 public static new IoCLRFunction createProto(IoState state)
 {
     IoCLRFunction cf = new IoCLRFunction();
     return cf.proto(state) as IoCLRFunction;
 }

 public static new IoCLRFunction createObject(IoState state)
 {
     IoCLRFunction cf = new IoCLRFunction();
     return cf.proto(state).clone(state) as IoCLRFunction;
 }

 // Prototypes and Clone
 public static new IoBlock createProto(IoState state)
 {
     IoBlock number = new IoBlock();
     return number.proto(state) as IoBlock;
 }

 public static new IoCLRObject createProto(IoState state)
 {
     IoCLRObject cf = new IoCLRObject();
     return cf.proto(state) as IoCLRObject;
 }

 // Public methos
 public IoObject getType(IoState state, string typeName)
 {
     Type t = null;
     foreach (string s in this.usingNamespaces.Keys)
     {
         IoCLRAssembly asm = this.usingNamespaces[s] as IoCLRAssembly;
         t = asm.assembly.GetType(s + "." + typeName);
         if (t != null)
         {
             IoCLRObject obj = IoCLRObject.createObject(state) as IoCLRObject;
             obj.clrType = t;
             obj.clrInstance = null;
             return obj;
         }
     }
     if (t == null)
     {
         foreach (string s in this.loadedAssemblies.Keys)
         {
             IoCLRAssembly asm = this.loadedAssemblies[s] as IoCLRAssembly;
             t = asm.assembly.GetType(typeName);
             if (t != null)
             {
                 IoCLRObject obj = IoCLRObject.createObject(state) as IoCLRObject;
                 obj.clrType = t;
                 obj.clrInstance = null;
                 return obj;
             }
         }
     }
     return null;
 }