commit 1c9707b5b8e401b6dd110e3caee7a0d7d0898ab7
Author: Mike Nolan <tesses@tesses.net>
Date:   Sun Sep 1 22:19:22 2024 -0500

    removing each

diff --git a/file.twss b/file.twss
new file mode 100644
index 0000000..494c0e8
--- /dev/null
+++ b/file.twss
@@ -0,0 +1,12 @@
+<!--tws
+   d = list();
+   d.add(5);
+   d.add(6);
+   d.add("Demi Lovato");
+    each(d)
+    {
+        print item;
+        print "\n";
+       
+    }
+-->
\ No newline at end of file
diff --git a/main.twss b/main.twss
new file mode 100644
index 0000000..e48704b
--- /dev/null
+++ b/main.twss
@@ -0,0 +1,8 @@
+<!--tws
+    print 37 + 1 + 4;
+-->
+John
+<!--tws
+    print "Demi Lovato\n";
+    print "John";
+-->
diff --git a/templater.cpp b/templater.cpp
new file mode 100644
index 0000000..12ec18f
--- /dev/null
+++ b/templater.cpp
@@ -0,0 +1,36 @@
+#include "tesseswebserver.hpp"
+TESSESWEBSERVER_STATIC_DECLARATION
+using namespace Tesses::WebServer;
+using namespace Tesses::WebServer::ScriptEngine;
+
+
+int main(int argc,char** argv)
+{
+    RootEnvironment* rEnv = new RootEnvironment();
+    rEnv->print = [](ScriptType arg)-> void {
+       
+        std::cout << ConvertToString(arg);
+    };
+    
+    BytecodeCompiler bcc(ScriptParser::Parse("file.twss"));
+    bcc.Compile();
+    auto rf = bcc.file->rootFunction;
+    rf->env = rEnv;
+    rf->isRoot=true;
+    for(auto f : bcc.file->functions)
+    {
+         auto rf2 = f.second;
+        rf2->env = rEnv;
+        rf2->isRoot=false;
+       
+
+
+       
+        rEnv->SetValue(f.first,ObjectType(f.second));
+    }
+   
+    rf->Execute(rEnv,{});
+
+
+
+}
\ No newline at end of file
diff --git a/tessesscriptengine.hpp b/tessesscriptengine.hpp
new file mode 100644
index 0000000..fdcb14f
--- /dev/null
+++ b/tessesscriptengine.hpp
@@ -0,0 +1,4242 @@
+#pragma once
+
+#include "tesseswebserver.hpp"
+
+
+#if defined(INCLUDED_FROM_TESSESWEBSERVER_H)
+namespace ScriptEngine
+#else
+namespace Tesses::WebServer::ScriptEngine
+#endif
+{
+    class Instruction
+    {
+        public:
+            virtual int Length()=0;
+            virtual void Write(uint8_t* buffer)=0;
+            virtual ~Instruction()
+            {
+
+            }
+            const static uint8_t ADD = 0;
+            const static uint8_t SUB = 1;
+            const static uint8_t TIMES = 2;
+            const static uint8_t DIVIDE = 3;
+            const static uint8_t MOD = 4;
+            const static uint8_t LEFTSHIFT = 5;
+            const static uint8_t RIGHTSHIFT = 6;
+            const static uint8_t LESSTHAN = 7;
+            const static uint8_t GREATERTHAN = 8;
+            const static uint8_t LESSTHANEQUALTO = 9;
+            const static uint8_t GREATERTHANEQUALTO = 10;
+            const static uint8_t EQUALS = 11;
+            const static uint8_t NOTEQUALS = 12;
+            const static uint8_t BITWISEOR = 13;
+            const static uint8_t BITWISEAND = 14;
+            const static uint8_t BITWISENOT = 15;
+            const static uint8_t EXCLUSIVEOR = 16;
+            const static uint8_t LOGICALNOT = 17;
+            const static uint8_t NEGATIVE = 18;
+            const static uint8_t GETVARIABLE = 19;
+            const static uint8_t SETVARIABLE = 20;
+            const static uint8_t GETFIELD = 21;
+            const static uint8_t SETFIELD = 22;
+            const static uint8_t GETARRAY = 23;
+            const static uint8_t SETARRAY = 24;
+            const static uint8_t PUSH_STRING = 25;
+            const static uint8_t PUSH_CHAR = 26;
+            const static uint8_t PUSH_LONG = 27;
+            const static uint8_t PUSH_DOUBLE = 28;
+            const static uint8_t SET_LOOP = 29; //for scoping reasons
+            const static uint8_t GET_LOOP = 30;
+            const static uint8_t DESTROY_LOOP = 31;
+            const static uint8_t CALL_FUNC = 32;
+            const static uint8_t CALL_METHOD = 33;
+            const static uint8_t PRINT = 34;
+            const static uint8_t JMPC = 35;
+            const static uint8_t JMP = 36;
+            const static uint8_t POP = 37;
+            const static uint8_t RET = 38;
+            const static uint8_t SCOPE_BEGIN = 39;
+            const static uint8_t SCOPE_END = 40;
+            const static uint8_t GET_GLOBAL_VARIABLE = 41;
+            const static uint8_t SET_GLOBAL_VARIABLE = 42;
+            const static uint8_t GET_CALLER_VARIABLE = 43;
+            const static uint8_t SET_CALLER_VARIABLE = 44;
+            const static uint8_t DECLARE_VARIABLE = 45;
+            const static uint8_t PUSH_NULL = 46;
+            const static uint8_t PUSH_UNDEFINED = 47;
+            const static uint8_t PUSH_FALSE = 48;
+            const static uint8_t PUSH_TRUE = 49;
+            const static uint8_t ITTR = 50;
+            
+            #if defined(DEBUG)
+            virtual void Print()
+            {
+
+            }
+            #endif
+    };
+    class Object {
+        
+        public:
+        
+        virtual std::string ToString()
+        {
+            return "";
+        }
+        virtual bool ToBool()
+        {
+            return false;
+        }
+        virtual bool CanDestroy()
+        {
+            return true;
+        }
+        
+        virtual ~Object()
+        {
+
+        }
+    };
+    
+    class Undefined {
+        
+       
+    };
+    class Null
+    {
+        
+    };
+    
+
+    class ObjectType {
+        public:
+            Object* data;
+            ObjectType(Object* o)
+            {
+                this->data = o;
+            }
+    };
+   
+
+    typedef std::variant<std::string,ObjectType> IttrType; 
+
+
+ 
+
+    class IttrKVP {
+        public:
+        IttrType ittr;
+        int64_t index;
+    };
+
+    
+    typedef std::variant<Undefined,Null,ObjectType,IttrKVP,std::string,int64_t,double,bool,char> ScriptType;
+    class Ittr : public Object {
+        public:
+        IttrType ittr;
+        int64_t index;
+    };
+
+    
+    inline bool Equals(ScriptType& left, ScriptType& right)
+    {
+        if(std::holds_alternative<std::string>(left) && std::holds_alternative<std::string>(right))
+        {
+            return std::get<std::string>(left) == std::get<std::string>(right);
+        }
+        if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+        {
+            return std::get<int64_t>(left) == std::get<int64_t>(right);
+        }
+        if(std::holds_alternative<char>(left) && std::holds_alternative<char>(right))
+        {
+            return std::get<char>(left) == std::get<char>(right);
+        }
+        if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+        {
+            return std::get<double>(left) == std::get<double>(right);
+        }
+        if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+        {
+            return (double)std::get<int64_t>(left) == std::get<double>(right);
+        }
+        if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+        {
+            return std::get<double>(left) == (double)std::get<int64_t>(right);
+        }
+        if(std::holds_alternative<bool>(left) && std::holds_alternative<bool>(right))
+        {
+            return std::get<bool>(left) == std::get<bool>(right); 
+        }
+        if(std::holds_alternative<Undefined>(left) && std::holds_alternative<Undefined>(right))
+        {
+            return true;
+        }
+        if(std::holds_alternative<Null>(left) && std::holds_alternative<Null>(right))
+        {
+            return true;
+        }
+        if(std::holds_alternative<ObjectType>(left) && std::holds_alternative<ObjectType>(right))
+        {
+            auto objLeft = std::get<ObjectType>(left).data;
+            auto objRight = std::get<ObjectType>(right).data;
+            if(objLeft == objRight)
+                return true;
+        }
+        return false;
+    }
+    inline bool ConvertToBool(ScriptType& st)
+    {
+        if(std::holds_alternative<std::string>(st))
+        {
+            return std::get<std::string>(st).size() > 0;
+        }
+        if(std::holds_alternative<int64_t>(st))
+        {
+            return std::get<int64_t>(st) != 0;
+        }
+        if(std::holds_alternative<double>(st))
+        {
+            return std::get<double>(st) != 0;
+        }
+        if(std::holds_alternative<bool>(st))
+        {
+            std::cout << (std::get<bool>(st) ? "true" : "false") << std::endl;
+            return std::get<bool>(st);
+        }
+        if(std::holds_alternative<char>(st))
+        {
+            return std::get<char>(st) != 0;
+        }
+        if(std::holds_alternative<ObjectType>(st))
+        {
+            return std::get<ObjectType>(st).data->ToBool();
+        }
+        return false;
+    }
+    inline ScriptType IttrGetValue(ScriptType& st);
+    inline std::string IttrGetKey(ScriptType& st);
+    inline std::string ConvertToString(ScriptType& st);
+    inline std::string ConvertToString(ScriptType& st)
+    {
+        if(std::holds_alternative<IttrKVP>(st))
+        {
+            auto v = IttrGetValue(st);
+            
+            return  IttrGetKey(st) + ": " + ConvertToString(v);
+        }
+        
+        if(std::holds_alternative<Null>(st))
+        {
+            return "null";
+        }
+        if(std::holds_alternative<std::string>(st))
+        {
+            return std::get<std::string>(st);
+        }
+        if(std::holds_alternative<int64_t>(st))
+        {
+            return std::to_string(std::get<int64_t>(st));
+        }
+        if(std::holds_alternative<double>(st))
+        {
+            return std::to_string(std::get<double>(st));
+        }
+        if(std::holds_alternative<bool>(st))
+        {
+            return std::get<bool>(st) ? "true" : "false";
+        }
+        if(std::holds_alternative<char>(st))
+        {
+            return std::string({std::get<char>(st)});
+        }
+        if(std::holds_alternative<ObjectType>(st))
+        {
+            return std::get<ObjectType>(st).data->ToString();
+        }
+
+        return "undefined";
+    }
+
+   class RootEnvironment;
+    
+    class Environment {
+        public:
+            std::function<void(ScriptType)> print;
+            virtual bool HasObject(std::string key) = 0;
+            virtual bool HasObjectRecurse(std::string key) = 0;
+            virtual ScriptType GetValue(std::string key) = 0;
+            virtual void SetValue(std::string key,ScriptType val) = 0;
+            virtual Environment* GetRoot()=0;
+            virtual Environment* GetParent()=0;
+            virtual Environment* GetGlobal()
+            {
+                return this->GetRoot()->GetGlobal();
+            }
+            virtual void Declare(std::string key,ScriptType val)
+            {
+                SetValue(key,val);
+            }
+            Environment* GetSub();
+            virtual ~Environment()
+            {
+
+            }
+    }; 
+
+    class SubEnvironment : public Environment
+    {
+        Environment* parent;
+        public:
+            std::map<std::string,ScriptType> items;
+            SubEnvironment(Environment* env)
+            {
+                this->parent = env;
+            }
+            Environment* GetParent()
+            {
+                return parent;
+            }
+            Environment* GetRoot()
+            {
+                return parent->GetRoot();
+            }
+
+            bool HasObject(std::string key)
+            {
+                return items.count(key) > 0;
+            }
+            bool HasObjectRecurse(std::string key)
+            {
+                if(items.count(key) > 0) return true;
+                
+                return this->parent->HasObjectRecurse(key);
+            }
+            ScriptType GetValue(std::string key)
+            {  
+                if(HasObject(key))
+                {
+                    return items[key];
+                }
+                return this->parent->GetValue(key);
+            }
+            void SetValue(std::string key,ScriptType val)
+            {
+                if(HasObject(key))
+                {
+                   items[key] = val;
+                   return;
+                }
+                if(this->parent->HasObjectRecurse(key))
+                {
+                    this->parent->SetValue(key,val);
+                }
+                items[key] = val;
+            }
+            void Declare(std::string key,ScriptType val)
+            {
+                this->items[key] = val;
+            }
+    };
+
+    inline Environment* Environment::GetSub()
+    {
+        SubEnvironment* env = new SubEnvironment(this);
+        env->print = this->print;
+        return env;
+    }
+  class CallableObject : public Object
+    {
+        public:
+        bool useGlobalEnv=false;
+
+        virtual bool FirstArgumentIsThis()
+        {
+            return false;
+        }
+
+        bool CanDestroy()
+        {
+            return false;
+        }
+        
+        virtual ScriptType Execute(Environment* callerEnv,std::vector<ScriptType> args)
+        {
+            return Null();
+        }
+
+        ScriptType Execute(Environment* callerEnv,std::initializer_list<ScriptType> args)
+        {
+            return Execute(callerEnv,std::vector<ScriptType>(args));
+        }
+
+        std::string ToString()
+        {
+            return "";
+        }   
+        bool ToBool()
+        {
+            return true;
+        }
+      
+    };
+
+     class ExternalFunction : public CallableObject {
+        public:
+            std::function<ScriptType(Environment*,std::vector<ScriptType>)> callback;
+            bool firstArgIsThis;
+            bool FirstArgumentIsThis()
+            {
+                return firstArgIsThis;
+            }
+            ExternalFunction(std::function<ScriptType(Environment*,std::vector<ScriptType>)> callback,bool firstArgIsThis=false)
+            {
+                this->callback = callback;
+                this->firstArgIsThis = firstArgIsThis;
+            }
+            ScriptType Execute(Environment* callerEnv,std::vector<ScriptType> args)
+            {
+                return callback(callerEnv,args);
+            }
+            
+            ~ExternalFunction()
+            {
+
+            }
+    };
+
+    class InternalFunction;
+
+    class List : public Object {
+        public:
+            std::vector<ScriptType> items;
+            std::string ToString()
+            {
+                return "";
+            }
+            bool ToBool()
+            {
+                return items.size() > 0;
+            }           
+    };
+
+    class Dictionary : public Object {
+        public:
+        std::vector<std::pair<std::string,ScriptType>> items;
+        std::string ToString()
+            {
+                return "";
+            }
+            bool ToBool()
+            {
+                return items.size() > 0;
+            }         
+            bool HasValue(std::string key)
+            {
+                for(auto item : items)
+                    if(item.first == key) return true;
+                return false;
+            }
+            ScriptType GetValue(std::string key)
+            {
+                for(auto item : items)
+                    if(item.first == key) return item.second;
+                return Undefined();
+            }
+
+            void SetValue(std::string key, ScriptType& value)
+            {
+                if(std::holds_alternative<Undefined>(value))
+                {
+                    for(auto item = items.cbegin();item <= items.cend();item++)
+                    {
+                        auto myItem = *item;
+                        if(myItem.first == key)
+                        {
+                            items.erase(item);
+                            return;
+                        }
+                    }
+                }
+                else
+                {
+                
+                    for(auto item : items)
+                    {
+                        if(item.first == key) 
+                        {
+                            item.second = value;
+                            return;
+                        }
+                    }
+
+                    items.push_back(std::pair<std::string,ScriptType>(key,value));
+                }
+            }
+    };
+
+    inline ScriptType CreateIttrFor(ScriptType& st)
+    {
+        if(std::holds_alternative<std::string>(st))
+        {
+            Ittr* ittr =new Ittr();
+            ittr->index = -1;
+            ittr->ittr = std::get<std::string>(st);
+            ObjectType t(ittr);
+            return t;
+        }
+        if(std::holds_alternative<ObjectType>(st))
+        {
+            auto ot = std::get<ObjectType>(st).data;
+            auto ls = dynamic_cast<List*>(ot);
+            auto dict = dynamic_cast<Dictionary*>(ot);
+            if(ls != nullptr)
+            {
+                Ittr* ittr=new Ittr();
+                ittr->index = -1;
+                ittr->ittr = ObjectType(ls);
+                ObjectType t(ittr);
+                return t;
+            }
+            if(dict != nullptr)
+            {
+                Ittr* ittr=new Ittr();
+                ittr->index = -1;
+                ittr->ittr = ObjectType(dict);
+                ObjectType t(ittr);
+                return t;
+            }
+        }
+        return Null();
+    }
+
+    inline bool IttrMoveNext(ScriptType& st)
+    {
+        if(std::holds_alternative<ObjectType>(st))
+        {
+            auto objIttr = std::get<ObjectType>(st).data;
+            auto ittr = dynamic_cast<Ittr*>(objIttr);
+            if(ittr == nullptr) return false;
+             std::cout << "INDEXB: " << ittr->index << std::endl;
+            ittr->index++;
+            std::cout << "INDEXA: " << ittr->index << std::endl;
+            
+            if(std::holds_alternative<std::string>(ittr->ittr))
+            {
+                std::string str = std::get<std::string>(ittr->ittr);
+
+                
+                if(ittr->index >= 0 && ittr->index < str.size())
+                {
+                    return true;
+                } 
+            }
+            if(std::holds_alternative<ObjectType>(ittr->ittr))
+            {
+                auto ot = std::get<ObjectType>(ittr->ittr).data;
+                auto ls = dynamic_cast<List*>(ot);
+                auto dict = dynamic_cast<Dictionary*>(ot);
+
+                if(ls != nullptr)
+                {
+
+                    if(ittr->index >= 0 && ittr->index < ls->items.size())
+                    {
+                       
+                        return true;
+                    }
+                } 
+                if(dict != nullptr)
+                {
+
+                    if(ittr->index >= 0 && ittr->index < dict->items.size())
+                    {
+                        
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    
+    inline ScriptType IttrCurrent(ScriptType& st)
+    {
+        if(std::holds_alternative<ObjectType>(st))
+        {
+            auto objIttr = std::get<ObjectType>(st).data;
+            auto ittr = dynamic_cast<Ittr*>(objIttr);
+            if(ittr == nullptr) return Null();
+            if(std::holds_alternative<std::string>(ittr->ittr))
+            {
+                std::string str = std::get<std::string>(ittr->ittr);
+                if(ittr->index >= 0 && ittr->index < str.size())
+                {
+                    return str[ittr->index];
+                } 
+            }
+            if(std::holds_alternative<ObjectType>(ittr->ittr))
+            {
+                auto ot = std::get<ObjectType>(ittr->ittr).data;
+                auto ls = dynamic_cast<List*>(ot);
+                auto dict = dynamic_cast<Dictionary*>(ot);
+
+                if(ls != nullptr)
+                {
+                    if(ittr->index >= 0 && ittr->index < ls->items.size())
+                    {
+                        return ls->items[ittr->index];
+                    }
+                } 
+                if(dict != nullptr)
+                {
+                    if(ittr->index >= 0 && ittr->index < dict->items.size())
+                    {
+                        IttrKVP kvp;
+                        kvp.index = ittr->index;
+                        kvp.ittr = ittr->ittr;
+                        return kvp;
+                    }
+                }
+            }
+        }
+        return Null();
+    }
+    inline std::string IttrGetKey(ScriptType& st)
+    {
+         if(std::holds_alternative<IttrKVP>(st))
+        {
+            auto ittr = std::get<IttrKVP>(st);
+          
+            if(std::holds_alternative<ObjectType>(ittr.ittr))
+            {
+                auto ot = std::get<ObjectType>(ittr.ittr).data;
+                 auto dict = dynamic_cast<Dictionary*>(ot);
+
+              
+                if(dict != nullptr)
+                {
+                    if(ittr.index >= 0 && ittr.index < dict->items.size())
+                    {
+                        return dict->items[ittr.index].first;
+                    }
+                }
+            }
+        }
+        return std::string({});
+    }
+    
+    inline ScriptType IttrGetValue(ScriptType& st)
+    {
+         if(std::holds_alternative<IttrKVP>(st))
+        {
+            auto ittr = std::get<IttrKVP>(st);
+          
+            if(std::holds_alternative<ObjectType>(ittr.ittr))
+            {
+                auto ot = std::get<ObjectType>(ittr.ittr).data;
+                 auto dict = dynamic_cast<Dictionary*>(ot);
+
+              
+                if(dict != nullptr)
+                {
+                    if(ittr.index >= 0 && ittr.index < dict->items.size())
+                    {
+                        return dict->items[ittr.index].second;
+                    }
+                }
+            }
+        }
+        return Null();
+    }
+    inline ScriptType TypeOf(Environment* env, std::vector<ScriptType> args);
+    class RootEnvironment : public Environment
+    {
+        std::vector<CallableObject*> fns;
+        public:
+            RootEnvironment()
+            {
+                DeclareFunctions();
+            }
+            Environment* global=nullptr;
+            std::map<std::string,ScriptType> items;
+            Environment* GetRoot()
+            {
+                return this;
+            }
+            Environment* GetGlobal()
+            {
+                if(global != nullptr) return global;
+                return this;
+            }
+            Environment* GetParent()
+            {
+                return this;
+            }
+            bool HasObject(std::string key)
+            {
+                return items.count(key) > 0;
+            }
+            bool HasObjectRecurse(std::string key)
+            {
+                return items.count(key) > 0;
+            }
+            ScriptType GetValue(std::string key)
+            {
+                return items[key];
+            }
+            void SetValue(std::string key,ScriptType val)
+            {
+                items[key] = val;
+            }
+            void Free(ScriptType t,bool tree=false)
+            {
+                
+                if(std::holds_alternative<ObjectType>(t))
+                {
+                    auto myObj=std::get<ObjectType>(t);
+                    
+                    if(tree)
+                    {
+                        auto ls = dynamic_cast<List*>(myObj.data);
+                        auto dict = dynamic_cast<Dictionary*>(myObj.data);
+                        if(ls != nullptr)
+                        {
+                            for(auto item : ls->items)
+                                Free(item,true);
+                        }
+                        if(dict != nullptr)
+                        {
+                            for(auto item : dict->items)
+                                Free(item.second,true);
+                        }
+                    }
+                    if(myObj.data != nullptr &&  myObj.data->CanDestroy())
+                    delete myObj.data;
+                }
+            }
+            void DeclareFunctions()
+            {
+                 DeclareFunction("dictionary",[this](Environment* env, std::vector<ScriptType> args)-> ScriptType {
+                    Dictionary* dict=new Dictionary();
+                    ObjectType ot(dict);
+                    return ot;                    
+                });
+                 DeclareFunction("list",[this](Environment* env, std::vector<ScriptType> args)-> ScriptType {
+                    List* list=new List();
+                    ObjectType ot(list);
+                    return ot;                    
+                });
+                DeclareFunction("typeof",TypeOf);
+                DeclareFunction("free",[this](Environment* env, std::vector<ScriptType> args)-> ScriptType {
+                    if(args.size() > 0)
+                    {
+                        Free(args[0]);
+                    }
+                    return Null();
+                });
+
+                DeclareFunction("free_tree",[this](Environment* env, std::vector<ScriptType> args)-> ScriptType {
+                    if(args.size() > 0)
+                    {
+                        Free(args[0],true);
+                    }
+                    return Null();
+                });
+            }
+            void DeclareFunction(std::string name,std::function<ScriptType(Environment* env, std::vector<ScriptType>)> method)
+            {
+                ExternalFunction* item = new ExternalFunction(method);
+             
+                fns.push_back(item);
+                
+                ObjectType ot(item);
+                SetValue(name,ot);
+            }
+            ~RootEnvironment()
+            {
+                
+                for(auto item : fns)
+                    delete item;
+                 
+            }
+    };
+  
+    class ChunkExecuter
+    {
+            uint8_t* bytecode;
+            size_t bytecodeLength;
+            std::vector<std::string>* args;
+            size_t ip=0;
+            std::stack<ScriptType> stack;
+            Environment* env;
+        public:
+        ChunkExecuter(Environment* env,uint8_t* bytecode,size_t bytecodeLength,std::vector<std::string>* args)
+        {
+            this->bytecode = bytecode;
+            this->bytecodeLength = bytecodeLength;
+            this->args = args;
+            this->env = env;
+        }
+
+        ScriptType Pop()
+        {
+            if(stack.empty()) throw std::exception();
+            ScriptType t = stack.top();
+
+         
+            stack.pop();
+            return t;
+        }
+        template<typename T>
+        T PopSpecific()
+        {
+            auto p = Pop();
+
+            if(std::holds_alternative<T>(p))
+            {
+                return std::get<T>(p);
+            }
+            else
+            {
+                std::vector<ScriptType> args;
+                args.push_back(p);
+                auto v = TypeOf(env,args);
+                this->env->print("IP: ");
+                this->env->print((int64_t)ip);
+                this->env->print(" Unexpected type: ");
+                this->env->print(v);
+                this->env->print(" with value ");
+                this->env->print(p);
+                this->env->print("\n");
+                
+
+                throw std::exception();
+            }
+        }
+        int64_t PopLong()
+        {
+            auto val = PopSpecific<int64_t>();
+    
+            
+            return val;
+        }
+        std::string PopString()
+        {
+            auto val = PopSpecific<std::string>();
+            return val;
+        }
+
+
+        ScriptType Mod(ScriptType& left,ScriptType& right)
+        {
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<int64_t>(left) % std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return fmod(std::get<double>(left), (double)std::get<int64_t>(right));
+            }
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+            {
+                return fmod((double)std::get<int64_t>(left), std::get<double>(right));
+            }
+
+            if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+            {
+                return fmod(std::get<double>(left),std::get<double>(right));
+            }
+
+            return Null();
+        }
+
+        ScriptType Divide(ScriptType& left,ScriptType& right)
+        {
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<int64_t>(left) / std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<double>(left) / (double)std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+            {
+                return (double)std::get<int64_t>(left) / std::get<double>(right);
+            }
+
+            if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+            {
+                return std::get<double>(left) / std::get<double>(right);
+            }
+
+            return Null();
+        }
+
+
+        ScriptType Times(ScriptType& left,ScriptType& right)
+        {
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<int64_t>(left) * std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<double>(left) * (double)std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+            {
+                return (double)std::get<int64_t>(left) * std::get<double>(right);
+            }
+
+            if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+            {
+                return std::get<double>(left) * std::get<double>(right);
+            }
+
+            return Null();
+        }
+        ScriptType GreaterThan(ScriptType& left,ScriptType& right)
+        {
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<int64_t>(left) > std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<double>(left) > (double)std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+            {
+                return (double)std::get<int64_t>(left) > std::get<double>(right);
+            }
+
+            if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+            {
+                return std::get<double>(left) > std::get<double>(right);
+            }
+
+            return Null();
+        }
+          ScriptType LessThan(ScriptType& left,ScriptType& right)
+        {
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<int64_t>(left) < std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<double>(left) < (double)std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+            {
+                return (double)std::get<int64_t>(left) < std::get<double>(right);
+            }
+
+            if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+            {
+                return std::get<double>(left) < std::get<double>(right);
+            }
+
+            return Null();
+        }
+
+        ScriptType GreaterThanEqualsTo(ScriptType& left,ScriptType& right)
+        {
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<int64_t>(left) >= std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<double>(left) >= (double)std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+            {
+                return (double)std::get<int64_t>(left) >= std::get<double>(right);
+            }
+
+            if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+            {
+                return std::get<double>(left) >= std::get<double>(right);
+            }
+
+            return Null();
+        }
+          ScriptType LessThanEqualsTo(ScriptType& left,ScriptType& right)
+        {
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<int64_t>(left) <= std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<double>(left) <= (double)std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+            {
+                return (double)std::get<int64_t>(left) <= std::get<double>(right);
+            }
+
+            if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+            {
+                return std::get<double>(left) <= std::get<double>(right);
+            }
+
+            return Null();
+        }
+
+     
+
+        ScriptType Sub(ScriptType& left,ScriptType& right)
+        {
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<int64_t>(left) - std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<double>(left) - (double)std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+            {
+                return (double)std::get<int64_t>(left) - std::get<double>(right);
+            }
+
+            if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+            {
+                return std::get<double>(left) - std::get<double>(right);
+            }
+
+            return Null();
+        }
+
+        ScriptType Add(ScriptType& left,ScriptType& right)
+        {
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<int64_t>(left) + std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<double>(left) + (double)std::get<int64_t>(right);
+            }
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+            {
+                return (double)std::get<int64_t>(left) + std::get<double>(right);
+            }
+
+            if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+            {
+                return std::get<double>(left) + std::get<double>(right);
+            }
+            if(std::holds_alternative<std::string>(left) && std::holds_alternative<std::string>(right))
+            {
+                return std::get<std::string>(left) + std::get<std::string>(right);
+            }
+            if(std::holds_alternative<int64_t>(left) && std::holds_alternative<std::string>(right))
+            {
+                return std::to_string(std::get<int64_t>(left)) + std::get<std::string>(right);
+            }
+            if(std::holds_alternative<std::string>(left) && std::holds_alternative<int64_t>(right))
+            {
+                return std::get<std::string>(left) + std::to_string(std::get<int64_t>(right));
+            }
+            if(std::holds_alternative<double>(left) && std::holds_alternative<std::string>(right))
+            {
+                return std::to_string(std::get<double>(left)) + std::get<std::string>(right);
+            }
+            if(std::holds_alternative<std::string>(left) && std::holds_alternative<double>(right))
+            {
+                return std::get<std::string>(left) + std::to_string(std::get<double>(right));
+            }
+            if(std::holds_alternative<std::string>(left) && std::holds_alternative<char>(right))
+            {
+                return std::get<std::string>(left) + std::string({std::get<char>(right)});
+            }
+            if(std::holds_alternative<char>(left) && std::holds_alternative<std::string>(right))
+            {
+                return std::string({std::get<char>(left)}) + std::get<std::string>(right);
+            }
+            return Null();
+        }
+        
+        ScriptType CallMethod(ScriptType& member, std::string key, std::vector<ScriptType>& args)
+        {
+            
+            
+            if(std::holds_alternative<Undefined>(member))
+            {
+                 if(key == "toString")
+                {
+                    return "undefined";
+                }
+            }
+            if(std::holds_alternative<Null>(member))
+            {
+                 if(key == "toString")
+                {
+                    return "null";
+                }
+            }
+            if(std::holds_alternative<ObjectType>(member))
+            {
+                auto obj = std::get<ObjectType>(member).data;
+                auto ls = dynamic_cast<List*>(obj);
+                auto dict = dynamic_cast<Dictionary*>(obj);
+                auto ittr = dynamic_cast<Ittr*>(obj);
+                if(ittr != nullptr)
+                {
+                     if(key == "current")
+                {
+                    return IttrCurrent(member);
+                }
+                if(key == "movenext")
+                {
+                    return IttrMoveNext(member);
+                }
+
+                }
+                if(ls != nullptr)
+                {
+                    if(key == "add" && args.size() > 0)
+                    {
+                        ls->items.push_back(args[0]);
+                    }
+                    else if(key == "remove" && args.size() > 0)
+                    {
+                        for(auto ittr = ls->items.cbegin();ittr<ls->items.cend();ittr++)
+                        {
+                            auto item = *ittr;
+                            if(Equals(item,args[0]))
+                            {
+                                ls->items.erase(ittr);
+                                break;
+                            }
+                        }
+                    }
+                    else if(key == "indexof" && args.size() > 0)
+                    {
+                        int64_t index = -1;
+                        for(auto ittr = ls->items.cbegin();ittr<ls->items.cend();ittr++)
+                        {
+                            auto item = *ittr;
+                            if(Equals(item,args[0]))
+                            {
+                                break;
+                            }
+                            index++;
+                        }
+
+                        return index;
+                    }
+                    else if(key == "insert" && args.size() > 1)
+                    {
+                         auto index = args[0];
+                        if(std::holds_alternative<int64_t>(index))
+                        {
+                            auto myIndex=std::get<int64_t>(index);
+                            if(myIndex >= 0 && myIndex <= ls->items.size())
+                            {
+                                ls->items.insert(ls->items.cbegin() + myIndex,{args[1]});
+                            }
+                        }
+                    }
+                    else if(key == "removeat" && args.size() > 0)
+                    {
+                        auto index = args[0];
+                        if(std::holds_alternative<int64_t>(index))
+                        {
+                            auto myIndex=std::get<int64_t>(index);
+                            if(myIndex >= 0 && myIndex < ls->items.size())
+                            {
+                                ls->items.erase(ls->items.cbegin() + myIndex);
+                            }
+                        }
+                    }
+                    else if(key == "count" || key == "length")
+                    {
+                        return (int64_t)ls->items.size();
+                    }
+                    else if(key == "clear") {
+                        ls->items.clear();
+                    }
+                    else if(key == "at" && args.size() > 0)
+                    {
+                        auto index = args[0];
+                        if(std::holds_alternative<int64_t>(index))
+                        {
+                            auto myIndex=std::get<int64_t>(index);
+                            if(myIndex >= 0 && myIndex < ls->items.size())
+                            {
+                                return ls->items.at((size_t)myIndex);
+                            }
+                        }
+                    }
+                    else if(key == "set" && args.size() > 1)
+                    {
+                        auto index = args[0];
+                        if(std::holds_alternative<int64_t>(index))
+                        {
+                            auto myIndex=std::get<int64_t>(index);
+                            if(myIndex >= 0 && myIndex < ls->items.size())
+                            {
+                                return ls->items[(size_t)myIndex]=args[1];
+                            }
+                        }
+                    }
+                }
+
+                if(dict != nullptr)
+                {
+                    auto item = dict->GetValue(key);
+                    if(std::holds_alternative<ObjectType>(item))
+                    {
+                        auto fnt = std::get<ObjectType>(item).data;
+                        auto fn = dynamic_cast<CallableObject*>(fnt);
+                        if(fn != nullptr)
+                        {
+                            if(fn->FirstArgumentIsThis())
+                                args.insert(args.cbegin(),{member});
+                                
+                            
+                            return fn->Execute(this->env,args);
+                        }
+                    }
+                    if(key == "toString" && args.size() == 0)
+                    {
+                        return std::string({});
+                    }
+                }
+            }
+            if(std::holds_alternative<int64_t>(member))
+            {
+                if(key == "toString")
+                {
+                    return std::to_string(std::get<int64_t>(member));
+                }
+                if(key == "toDouble")
+                {
+                    return (double)std::get<int64_t>(member);
+                }
+                if(key == "toDoubleBits")
+                {
+                    return std::bit_cast<double>(std::get<int64_t>(member));
+                }
+                if(key == "toChar")
+                {
+                    return (char)std::get<int64_t>(member);
+                }
+            }
+            if(std::holds_alternative<std::string>(member))
+            {
+                std::string myStr=std::get<std::string>(member);
+                if(key == "toString")
+                {
+                    return myStr;
+                }
+                if(key == "length" || key == "count")
+                {
+                    return (int64_t)myStr.size();
+                }
+                if(key == "toLower")
+                {
+                    std::transform(myStr.begin(),myStr.end(),myStr.begin(),::tolower);
+                    return myStr;
+                }
+                if(key == "toUpper")
+                {
+                    std::transform(myStr.begin(),myStr.end(),myStr.begin(),::toupper);
+                    return myStr;
+                }
+            }
+            if(std::holds_alternative<char>(member))
+            {
+                if(key == "toString")
+                {
+                    return std::string({std::get<char>(member)});
+                }
+                if(key == "toLong")
+                {
+                    return (int64_t)std::get<char>(member);
+                }
+                if(key == "toLower")
+                {
+                    return (char)std::tolower(std::get<char>(member));
+                }
+                if(key == "toUpper")
+                {
+                    return (char)std::toupper(std::get<char>(member));
+                }
+            }
+            if(std::holds_alternative<double>(member))
+            {
+                if(key == "toString")
+                {
+                    return std::to_string(std::get<double>(member));
+                }
+                if(key == "toLong")
+                {
+                    return (int64_t)std::get<double>(member);
+                }
+                if(key == "toLongBits")
+                {
+                    return std::bit_cast<int64_t>(std::get<double>(member));
+                }
+            }
+
+            return Undefined();
+        }
+
+        ScriptType SetField(ScriptType& instance,std::string name,ScriptType& value)
+        {
+            
+            if(std::holds_alternative<ObjectType>(instance))
+            {
+                auto inst = std::get<ObjectType>(instance).data;
+              
+                auto dict = dynamic_cast<Dictionary*>(inst);
+              
+                if(dict != nullptr)
+                {
+                    auto myFuncObj = dict->GetValue(std::string("set") + name);
+
+                    if(std::holds_alternative<ObjectType>(myFuncObj))
+                    {
+                        auto myFuncObj2 = std::get<ObjectType>(myFuncObj).data;
+                        auto callbl = dynamic_cast<CallableObject*>(myFuncObj2);
+                        if(callbl != nullptr)
+                        {
+                            if(callbl->FirstArgumentIsThis())
+                            {
+                                return callbl->Execute(env,{instance,value});
+                            }
+                            else
+                            {
+                                return callbl->Execute(env,{value});
+                            }
+                        }
+                    }
+
+
+                    dict->SetValue(name,value);
+                }
+            }
+            return value;
+        }
+
+        ScriptType GetField(ScriptType& instance, std::string name)
+        {
+            if(std::holds_alternative<std::string>(instance))
+            {
+                auto str = std::get<std::string>(instance);
+                if(name == "length" || name == "count")
+                {
+                    return (int64_t)str.size();
+                }
+            }
+            if(std::holds_alternative<IttrKVP>(instance))
+            {
+                if(name == "key")
+                {
+                    return IttrGetKey(instance);
+                }
+
+                if(name == "value")
+                {
+                    return IttrGetValue(instance);
+                }
+                return Null();
+            }
+            if(std::holds_alternative<ObjectType>(instance))
+            {
+                auto inst = std::get<ObjectType>(instance).data;
+                auto ls = dynamic_cast<List*>(inst);
+                auto dict = dynamic_cast<Dictionary*>(inst);
+                if(ls != nullptr)
+                {
+                    if(name == "length" || name == "count")
+                    {
+                        return (int64_t)ls->items.size();
+                    }
+                }
+                if(dict != nullptr)
+                {
+                    auto myFuncObj = dict->GetValue(std::string("get") + name);
+
+                    if(std::holds_alternative<ObjectType>(myFuncObj))
+                    {
+                        auto myFuncObj2 = std::get<ObjectType>(myFuncObj).data;
+                        auto callbl = dynamic_cast<CallableObject*>(myFuncObj2);
+                        if(callbl != nullptr)
+                        {
+                            if(callbl->FirstArgumentIsThis())
+                            {
+                                return callbl->Execute(env,{instance});
+                            }
+                            else
+                            {
+                                return callbl->Execute(env,{});
+                            }
+                        }
+                    }
+
+
+                    return dict->GetValue(name);
+                }
+            }
+            return Undefined();
+        }
+
+        ScriptType Execute(Environment* callerEnv,std::vector<ScriptType> __args)
+        {
+           // std::cout << __args.size() << " " << this->args->size() << std::endl;
+            if(__args.size() != this->args->size()) 
+            {
+                callerEnv->print("Expected " + std::to_string((int64_t)this->args->size()) + " args, got " + std::to_string((int64_t)__args.size()) + " args.\n");
+                throw std::exception();
+            }
+
+            for(size_t i = 0;i<__args.size();i++)
+            {
+                
+                env->Declare(this->args->at(i),__args[i]);
+            }
+            
+
+            int scopes=0;
+            std::stack<int> loops;
+        
+            while(ip < bytecodeLength)
+            {
+                uint8_t instruction = bytecode[ip];
+                
+                ip++;
+                switch(instruction)
+                {
+                    case Instruction::PUSH_FALSE:
+                    {
+                        stack.push(false);
+                    }
+                    break;
+                    case Instruction::PUSH_TRUE:
+                    {
+                        stack.push(true);
+                    }
+                    break;
+                    case Instruction::PUSH_NULL:
+                    {
+                        stack.push(Null());
+                    }
+                    break;
+                    case Instruction::PUSH_UNDEFINED:
+                    {
+                        stack.push(Undefined());
+                    }
+                    break;
+                    case Instruction::PUSH_CHAR:
+                    {
+                        if(ip + 1 <= bytecodeLength)
+                        {
+                            stack.push((char)bytecode[ip++]);
+                        }
+                        else
+                        {
+                            throw std::exception();
+                        }
+                    }
+                    break;
+                    case Instruction::CALL_FUNC:
+                    {
+                        int64_t lng=PopLong();
+                        std::vector<ScriptType> _args;
+                        for(int i = 0;i<lng;i++)
+                        {
+                            _args.insert(_args.cbegin(),{Pop()});
+                        }
+                        auto fCall = Pop();
+                        auto myF=dynamic_cast<CallableObject*>(std::get<ObjectType>(fCall).data);
+                        if(myF != nullptr)
+                        {
+                            stack.push(myF->Execute(env,_args));
+                            
+                        }
+                        else
+                        {
+                            stack.push(Null());
+                        }
+                    }
+                    break;
+                    case Instruction::CALL_METHOD:
+                    {
+                        int64_t lng=PopLong();
+                        std::vector<ScriptType> _args;
+                        for(int i = 0;i<lng;i++)
+                        {
+                            _args.insert(_args.cbegin(),{Pop()});
+                        }
+                        
+                        std::string key = PopString();
+                        auto member = Pop();
+                        stack.push(CallMethod(member,key,_args));
+                    }
+                    break;
+                    case Instruction::EQUALS:
+                    {
+                        auto right = Pop();
+                        auto left = Pop();
+                        stack.push(Equals(left,right));
+                    }   
+                    break;
+                    case Instruction::NOTEQUALS:
+                    {
+                        auto right = Pop();
+                        auto left = Pop();
+                        bool v = !Equals(left,right);
+                        stack.push(v);
+                    }   
+                    break;
+                    case Instruction::LESSTHAN:
+                    {
+                        auto right = Pop();
+                        auto left = Pop();
+                        stack.push(LessThan(left,right));
+                    }   
+                    break;
+                     case Instruction::GREATERTHAN:
+                    {
+                        auto right = Pop();
+                        auto left = Pop();
+                        stack.push(GreaterThan(left,right));
+                    }   
+                    break;
+                     case Instruction::LESSTHANEQUALTO:
+                    {
+                        auto right = Pop();
+                        auto left = Pop();
+                        stack.push(LessThanEqualsTo(left,right));
+                    }   
+                    break;
+                     case Instruction::GREATERTHANEQUALTO:
+                    {
+                        auto right = Pop();
+                        auto left = Pop();
+                        stack.push(GreaterThanEqualsTo(left,right));
+                    }   
+                    break;
+                    case Instruction::ADD:
+                    {
+                        auto right = Pop();
+                        auto left = Pop();
+                        stack.push(Add(left,right));
+                    }   
+                    break;
+                    case Instruction::SUB:
+                    {
+                        auto right = Pop();
+                        auto left = Pop();
+                        stack.push(Sub(left,right));
+                    }
+                    break;
+                    case Instruction::TIMES:
+                    {
+                        auto right = Pop();
+                        auto left = Pop();
+                        stack.push(Times(left,right));
+                    }
+                    break;
+                    case Instruction::DIVIDE:
+                    {
+                        auto right = Pop();
+                        auto left = Pop();
+                        stack.push(Divide(left,right));
+                    }
+                    break;
+                    case Instruction::MOD:
+                    {
+                        auto right = Pop();
+                        auto left = Pop();
+                        stack.push(Mod(left,right));
+                    }
+                    break;
+                    case Instruction::PUSH_LONG:
+                    {
+                        
+                        if(ip + 8 <= bytecodeLength)
+                        {
+                            uint64_t value = ((uint64_t)bytecode[ip++] << 56) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 48) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 40) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 32) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 24) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 16) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 8) & 0xFF;
+                            value |= (uint64_t)bytecode[ip++] & 0xFF;
+                            
+                            stack.push((int64_t)value);
+                        }
+                    }
+                    break;
+                    case Instruction::PUSH_DOUBLE:
+                    {
+                        if(ip + 8 <= bytecodeLength)
+                        {
+                            uint64_t value = ((uint64_t)bytecode[ip++] << 56) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 48) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 40) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 32) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 24) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 16) & 0xFF;
+                            value |= ((uint64_t)bytecode[ip++] << 8) & 0xFF;
+                            value |= (uint64_t)bytecode[ip++] & 0xFF;
+
+                            
+                            stack.push(*(double*)&value);
+                        }
+                    }
+                    break;
+                    case Instruction::PUSH_STRING:
+                    {
+                        
+                        if(ip + 4 <= bytecodeLength)
+                        {
+
+
+                            size_t len = (bytecode[ip++] << 24) & 0xFF;
+                            len |= (bytecode[ip++] << 16) & 0xFF;
+                            len |= (bytecode[ip++] << 8) & 0xFF;
+                            len |= bytecode[ip++] & 0xFF;
+
+                            if(ip + len <= bytecodeLength)
+                            {
+                                std::string str((char*)bytecode+ip,len);
+                                ip+=len;
+
+                          
+                                stack.push(str);
+                            }
+                        }
+                    }
+                    break;
+                    case Instruction::GET_CALLER_VARIABLE:
+                    {
+                        auto str = PopString();
+                       
+                       auto v=callerEnv->GetValue(str);
+                        stack.push(v);
+                    }
+                    break;
+                    case Instruction::SET_CALLER_VARIABLE:
+                    {
+                        auto v = Pop();
+                        auto str = PopString();
+                        callerEnv->SetValue(str,v);
+                        stack.push(v);
+                    }
+                    break;
+                    case Instruction::GET_GLOBAL_VARIABLE:
+                    {
+                        auto str = PopString();
+                        auto v = env->GetGlobal()->GetValue(str);
+                        stack.push(v);
+                    }
+                    break;
+                    case Instruction::SET_GLOBAL_VARIABLE:
+                    {
+                        auto v = Pop();
+                        auto str = PopString();
+                        env->GetGlobal()->SetValue(str,v);
+                        stack.push(v);
+                    }
+                    break;
+                    case Instruction::GETVARIABLE:
+                    {
+                        auto str = PopString();
+                        
+                       auto v = env->GetValue(str);
+                        stack.push(v);
+                    }
+                    break;
+                    case Instruction::SETVARIABLE:
+                    {
+                        auto v = Pop();
+                        auto str = PopString();
+                        env->SetValue(str,v);
+                        stack.push(v);
+                    }
+                    break;
+                    case Instruction::DECLARE_VARIABLE:
+                    {
+                        auto v = Pop();
+                        auto str = PopString();
+                        env->Declare(str,v);
+                        stack.push(v);
+                    }
+                    break;
+                    case Instruction::PRINT:
+                    {
+                        auto v = Pop();
+                        
+                        callerEnv->print(v);
+                    }
+                    break;
+                    case Instruction::SCOPE_BEGIN:
+                    {
+                        scopes++;
+                        env = env->GetSub();                   
+                    }
+                    break;
+                    case Instruction::SCOPE_END:
+                    {
+                        Environment* env2 = env;
+                        env=env2->GetParent();
+                        if(env != env2)
+                        {
+                            delete env2;
+                        }
+                        scopes--;
+                    }
+                    break;
+                    case Instruction::SET_LOOP:
+                    {
+                        loops.push(scopes);
+                    }
+                    break;
+                    case Instruction::GET_LOOP:
+                    {
+                        int myLoops = loops.top();
+                        
+                        while(scopes > myLoops)
+                        {
+                            Environment* env2 = env;
+                            env=env2->GetParent();
+                            if(env != env2)
+                            {
+                                delete env2;
+                            }
+                        
+                            scopes--;
+                        }
+                    }
+                    break;
+                    case Instruction::DESTROY_LOOP:
+                    {
+                        int myLoops = loops.top();
+                        loops.pop();
+                        
+                        while(scopes > myLoops)
+                        {
+                            Environment* env2 = env;
+                            env=env2->GetParent();
+                            if(env != env2)
+                            {
+                                delete env2;
+                            }
+                        
+                            scopes--;
+                        }
+                    }
+                    break;
+                    case Instruction::RET:
+                    {
+                        auto val = Pop();
+                         while(scopes > 0)
+                        {
+                            Environment* env2 = env;
+                            env=env2->GetParent();
+                            if(env != env2)
+                            {
+                                delete env2;
+                            }
+                        
+                            scopes--;
+                        }
+                        
+                        return val;
+                    }
+                    break;
+                    case Instruction::JMP:
+                    {
+                        if(ip + 4 <= bytecodeLength)
+                        {
+
+
+                            size_t len = (bytecode[ip++] << 24) & 0xFF;
+                            len |= (bytecode[ip++] << 16) & 0xFF;
+                            len |= (bytecode[ip++] << 8) & 0xFF;
+                            len |= bytecode[ip++] & 0xFF;
+                            if(len < bytecodeLength)
+                            ip = len;
+                            else
+                            {
+                                std::cout << "Jump failed" << std::endl;
+                                throw std::exception();
+                            }
+                        }
+                    }
+                    break;
+                    case Instruction::JMPC:
+                    {
+                        if(ip + 4 <= bytecodeLength)
+                        {
+
+                            
+                            size_t len = (bytecode[ip++] << 24) & 0xFF;
+                            len |= (bytecode[ip++] << 16) & 0xFF;
+                            len |= (bytecode[ip++] << 8) & 0xFF;
+                            len |= bytecode[ip++] & 0xFF;
+                            if(len < bytecodeLength)
+                            {
+                                auto v = Pop();
+                                if(ConvertToBool(v))
+                                ip = len;
+                                
+                            }
+                            else
+                            {
+                                std::cout << "Jump failed" << std::endl;
+                                throw std::exception();
+                            }
+                        }
+                    }
+                    break;
+                    case Instruction::ITTR:
+                    {
+                        auto ittr=Pop();
+                        stack.push(CreateIttrFor(ittr));
+                    }
+                    break;
+                    case Instruction::GETFIELD:
+                    {
+                        std::string name = PopString();
+                        auto instance = Pop();
+                        stack.push(GetField(instance,name));
+                    }
+                    break;
+                    case Instruction::SETFIELD:
+                    {
+                        auto val = Pop();
+                        std::string name = PopString();
+                        auto instance = Pop();
+                        stack.push(SetField(instance,name,val));
+                    }
+                    break;
+                }
+            }
+             while(scopes > 0)
+                        {
+                            Environment* env2 = env;
+                            env=env2->GetParent();
+                            if(env != env2)
+                            {
+                                delete env2;
+                            }
+                        
+                            scopes--;
+                        }
+                        return Null();
+        }
+    };
+   
+    class InternalFunction : public CallableObject
+    {
+        public:
+            bool isRoot=false;
+            uint8_t* bytecode;
+            size_t bytecodeLength;
+            std::vector<std::string> args;
+            Environment* env;
+            bool FirstArgumentIsThis()
+        {
+            return args.size() > 0 && args[0] == "this";
+        }
+            ScriptType Execute(Environment* callerEnv,std::vector<ScriptType> args)
+            {
+                Environment* env2 = isRoot ? env : env->GetSub();
+                ChunkExecuter exec(env2,bytecode,bytecodeLength,&this->args);
+                
+
+                auto ret=exec.Execute(callerEnv,args);
+
+                if(!isRoot) delete env2;
+                return ret;
+            }   
+    };
+
+    
+
+    class LexToken {
+        public:
+        std::string text;
+        bool isString;
+        bool isChar;
+
+        LexToken(std::string text)
+        {
+            this->text = text;
+            this->isString = false;
+            this->isChar = false;
+        }
+
+        LexToken(std::string text,bool isString)
+        {
+            this->text = text;
+            this->isString = isString;
+            this->isChar = !isChar;
+        }
+
+        LexToken(const LexToken& tkn)
+        {
+            this->text = tkn.text;
+            this->isString = tkn.isString;
+            this->isChar = tkn.isChar;
+        }
+    };
+
+    class Node {
+        public:
+        virtual bool IsExpression() {
+            return false;
+        }
+        virtual ~Node()
+        {
+            
+        }
+    };
+
+    class Expression : public Node {
+        public:
+        bool IsExpression()
+        {
+            return true;
+        }
+    };
+
+    class OneExpression : public Expression {
+        public:
+            Node* node;
+            OneExpression(Node* node)
+            {
+                this->node = node;
+            }
+    };
+
+    class TwoExpression : public Expression {
+        public:
+            Node* left;
+            Node* right;
+            TwoExpression(Node* left,Node* right)
+            {
+                this->left = left;
+                this->right = right;
+            }
+    };
+
+    #define LIST_OF_CONST_EXPRESSIONS \
+        NODE(bool,Bool) \
+        NODE(std::string,String) \
+        NODE(int64_t,Long) \
+        NODE(double,Double) \
+        NODE(char,Char)
+
+    
+
+    #define LIST_OF_ONE_EXPRESSIONS \
+        NODE(PostfixIncrement) \
+        NODE(PostfixDecrement) \
+        NODE(PrefixIncrement) \
+        NODE(PrefixDecrement) \
+        NODE(BitwiseNot) \
+        NODE(LogicalNot) \
+        NODE(Negative) \
+        NODE(CompoundAssign) \
+        NODE(Global) \
+        NODE(Caller) \
+        NODE(Var)
+
+    #define LIST_OF_TWO_EXPRESSIONS \
+    NODE(Add) \
+    NODE(Sub) \
+    NODE(Times) \
+    NODE(Divide) \
+    NODE(Mod) \
+    NODE(LeftShift) \
+    NODE(RightShift) \
+    NODE(LessThan) \
+    NODE(GreaterThan) \
+    NODE(LessThanEqualTo) \
+    NODE(GreaterThanEqualTo) \
+    NODE(Equals) \
+    NODE(NotEquals) \
+    NODE(BitwiseOr) \
+    NODE(BitwiseAnd) \
+    NODE(ExclusiveOr) \
+    NODE(LogicalOr) \
+    NODE(LogicalAnd) \
+    NODE(Assign) 
+
+
+    #define NODE(_node) class _node##Expression : public OneExpression { \
+        public: \
+            _node##Expression(Node* n) : OneExpression(n) {} ~_node##Expression() {delete node;} \
+        };
+        LIST_OF_ONE_EXPRESSIONS
+    #undef NODE
+
+    #define NODE(node) class node##Expression : public TwoExpression { \
+        public: \
+            node##Expression(Node* n,Node* n2) : TwoExpression(n,n2) {} ~node##Expression() {delete left; delete right;} \
+        };
+        LIST_OF_TWO_EXPRESSIONS
+    #undef NODE
+
+    #define NODE(ttype,tname) class Const##tname##Expression : public Expression { \
+        public: \
+            ttype value; \
+            Const##tname##Expression(ttype v) \
+            { \
+                this->value = v; \
+            }\
+     }; 
+            LIST_OF_CONST_EXPRESSIONS
+    #undef NODE
+
+    class ConstNullExpression : public Expression {};
+    class ConstUndefinedExpression : public Expression {};
+
+    class GetVariableExpression : public Expression {
+        public:
+            std::string name;
+            GetVariableExpression(std::string name)
+            {
+                this->name = name;
+            }
+    };
+
+    class IfNode : public Node {
+        public:
+            Node* cond;
+            Node* yes;
+            Node* no;
+            IfNode(Node* cond,Node* yes,Node* no)
+            {
+                this->cond = cond;
+                this->yes = yes;
+                this->no = no;
+            }
+            ~IfNode()
+            {
+                delete cond;
+                delete yes;
+                delete no;
+            }
+    };
+    class TernaryExpression : public Expression {
+        public:
+            Node* cond;
+            Node* yes;
+            Node* no;
+            TernaryExpression(Node* cond,Node* yes,Node* no)
+            {
+                this->cond = cond;
+                this->yes = yes;
+                this->no = no;
+            }
+            ~TernaryExpression()
+            {
+                delete cond;
+                delete yes;
+                delete no;
+            }
+    };
+
+    class WhileNode : public Node {
+        public:
+            Node* cond;
+            Node* body;
+            bool isDo;
+            WhileNode(Node* cond,Node* body, bool isDo)
+            {
+                this->cond = cond;
+                this->body = body;
+                this->isDo = isDo;
+            }
+            ~WhileNode()
+            {
+                delete cond;
+                delete body;
+            }
+    };
+    
+    class ForNode : public Node {
+        public:
+            Node* init;
+            Node* cond;
+            Node* inc;
+            Node* body;
+            ForNode(Node* init,Node* cond,Node* inc,Node* body)
+            {
+                this->init = init;
+                this->cond = cond;
+                this->inc = inc;
+                this->body = body;
+            }
+            ~ForNode()
+            {
+                delete init;
+                delete cond;
+                delete inc;
+                delete body;
+            }
+    };
+
+    class PrintNode : public Node {
+        public:
+            Node* expr;
+            PrintNode(Node* expr)
+            {
+                this->expr = expr;
+            }
+            ~PrintNode()
+            {
+                delete expr;
+            }
+    };
+
+    class EachNode : public Node {
+        public:
+            Node* item;
+            Node* list;
+            Node* body;
+            EachNode(Node* item,Node* list,Node* body)
+            {
+                this->item = item;
+                this->list = list;
+                this->body = body;
+            }
+            ~EachNode()
+            {
+                delete item;
+                delete list;
+                delete body;
+            }
+    };
+
+    class FunctionDeclarationNode : public Node {
+        public:
+            Node* nameAndArgs;
+            Node* body;
+            FunctionDeclarationNode(Node* nameAndArgs,Node* body)
+            {
+                this->nameAndArgs = nameAndArgs;
+                this->body = body;
+            }
+            ~FunctionDeclarationNode()
+            {
+                delete nameAndArgs;
+                delete body;
+            }
+    };
+
+    class FunctionCallExpression : public Expression 
+    {
+        public:
+            std::vector<Node*> args;
+            Node* name;
+            FunctionCallExpression(Node* name) {
+                this->name = name;
+            }
+            ~FunctionCallExpression()
+            {
+                for(auto item : args)
+                {
+                    delete item;
+                }
+                delete name;
+            }
+    };
+
+    class GetMemberExpression : public Expression 
+    {
+        public:
+            std::string name;
+            Node* parent;
+            GetMemberExpression(Node* parent,std::string name)
+            {
+                this->parent = parent;
+                this->name = name;
+            }
+            ~GetMemberExpression()
+            {
+                delete parent;
+            }
+    };
+    class GetArrayExpression : public Expression 
+    {
+        public:
+            Node* expr;
+            Node* parent;
+            GetArrayExpression(Node* parent,Node* expr)
+            {
+                this->parent = parent;
+                this->expr = expr;
+            }
+            ~GetArrayExpression()
+            {
+                delete expr;
+                delete parent;
+            }
+    };
+
+    class ReturnNode : public Node {
+        public:
+            Node* retVal;
+            ReturnNode(Node* retVal)
+            {
+                this->retVal = retVal;
+            }
+            ~ReturnNode()
+            {
+                delete retVal;
+            }
+    };
+
+    class BreakNode : public Node {};
+    class ContinueNode : public Node {};
+
+    class ScopeNode : public Node {
+        public:
+            std::vector<Node*> items;
+            bool rootScope;
+            ~ScopeNode()
+            {
+                for(auto item : items)
+                    delete item;
+            }
+    };
+
+    class ScriptParser 
+    {
+        size_t i = 0;
+        std::vector<LexToken> tokens;
+        std::filesystem::path path;
+        
+
+
+        static std::string Template(std::filesystem::path file)
+        {
+            //convert anything out of <!--tws --> to print ""; statements
+
+            std::string myRealBuf = {};
+
+            bool inCode = false;
+            std::string buffer={};
+
+            FILE* fs = fopen(file.c_str(),"rb");
+            if(fs == NULL) return "";
+
+            uint8_t sliding_buffer[7];
+
+            size_t len=0;
+
+            auto advance = [&sliding_buffer,&len,&fs]()-> bool {
+                if(len > 0)
+                {
+                    len--;
+                    for(size_t i = 0;i<len;i++)
+                    {
+                        sliding_buffer[i] = sliding_buffer[i+1];
+                    }
+
+                    
+                }
+                if(len < 7)
+                    len+= fread(sliding_buffer+len,1,7-len,fs);
+                
+                return len > 0;
+            };
+
+            auto flush = [&buffer,&myRealBuf,&inCode]() -> void {
+                if(buffer.size() == 0) return;
+                if(inCode)
+                {
+                    myRealBuf.append(buffer);
+                }
+                else
+                {
+                    myRealBuf.append("print \"");
+                    for(auto item : buffer)
+                    {
+                        switch(item)
+                        {
+                            case '\0':
+                                myRealBuf.append("\\0");
+                                break;
+                            case '\n':
+                                myRealBuf.append("\\n");
+                                break;
+                            case '\r':
+                                myRealBuf.append("\\r");
+                                break;
+                            case '\f':
+                                myRealBuf.append("\\f");
+                                break;
+                            case '\t':
+                                myRealBuf.append("\\t");
+                                break;
+                            case '\v':
+                                myRealBuf.append("\\v");
+                                break;
+                            case '\b':
+                                myRealBuf.append("\\b");
+                                break;
+                            case '\a':
+                                myRealBuf.append("\\a");
+                                break;
+                            case '\x1B':
+                                myRealBuf.append("\\e");
+                                break;
+                            case '\"':
+                            case '\'':
+                            case '\\':
+                                myRealBuf.push_back('\\');
+                                myRealBuf.push_back(item);
+                                break;
+                            default:
+                                myRealBuf.push_back(item);
+                                break;
+                        }
+                    }
+
+                    myRealBuf.append("\";");
+                }
+                buffer = {};
+            };
+
+            while(advance())
+            {
+                if(memcmp(sliding_buffer,"<!--tws",7) == 0)
+                {
+                    flush();
+                    inCode=true;
+                    len = 0;
+                    if(advance() == false) break;
+                
+                }
+                if(inCode && memcmp(sliding_buffer,"-->",3) == 0)
+                {
+                    flush();
+                    inCode=false;
+                    for(int i = 0;i<3;i++)
+                        if(advance() == false) break;
+                    if(len == 0) break;
+                }
+
+                buffer.push_back((char)sliding_buffer[0]);
+            }
+            flush();
+            fclose(fs);
+            return myRealBuf;
+        }
+        
+        static void Lex(std::filesystem::path file,std::vector<LexToken>& tokens)
+        {
+            std::string text = Template(file);
+            
+            size_t offset = 0;
+
+            int peeked = -1;
+
+            auto peek = [&text,&offset,&peeked]() -> int {
+                if(peeked > -1) return peeked;
+                
+                if(offset < text.size())
+                {
+                    peeked = text[offset];
+                    offset++;
+                    return peeked;
+                }
+                return -1;
+            };
+
+            auto read = [&text,&offset,&peeked]() -> int {
+                if(peeked != -1)
+                {
+                    int myPeek = peeked;
+                    peeked=-1;
+                    return myPeek;
+                }
+
+                if(offset < text.size())
+                {
+                    int c = text[offset];
+                    offset++;
+                    return c;
+                }
+                return -1;
+            };
+            int myRead=-1;
+            int myPeek=-1;
+
+            std::string buf={};
+
+            auto flush = [&buf,&tokens]()-> void {
+                if(buf.size() > 0)
+                {
+                    tokens.push_back(LexToken(buf));
+                    buf.clear();
+                }
+            };
+
+            auto read_chr_ = [&read]()-> std::pair<int,bool> 
+            {
+                int myC = read();
+                if(myC == '\\')
+                {
+                    myC = read();
+
+                    if(myC == 'n')
+                    {
+                        return std::pair<int,bool>('\n',true);
+                    }
+                    else if(myC == 'r')
+                    {
+                        return std::pair<int,bool>('\r',true);
+                    }
+                    else if(myC == 'v')
+                    {
+                        return std::pair<int,bool>('\v',true);
+                    }
+                    else if(myC == 't')
+                    {
+                        return std::pair<int,bool>('\t',true);
+                    }
+                    else if(myC == 'b')
+                    {
+                        return std::pair<int,bool>('\b',true);
+                    }
+                    else if(myC == 'a')
+                    {
+                        return std::pair<int,bool>('\a',true);
+                    }
+                    else if(myC == 'e')
+                    {
+                        return std::pair<int,bool>('\x1B',true);
+                    }
+                    else if(myC == '0')
+                    {
+                        return std::pair<int,bool>('\0',true);
+                    }
+                    else if(myC == 'x')
+                    {
+                        int x1 = read();
+                        int x2 = read();
+
+                        return std::pair<int,bool>(((HttpUtils::hex_char_to_nibble(x1) << 4) & 0xF) | (HttpUtils::hex_char_to_nibble(x2) & 0xF),true);
+                    }
+                    else {
+                        return std::pair<int,bool>(myC,true);
+                    }
+                }
+                return std::pair<int,bool>(myC,false);
+            };
+
+            auto read_string = [&read_chr_,&tokens]()-> void {
+                std::pair<int,bool> c;
+                std::string myStr = {};
+                while((c = read_chr_()).first != -1)
+                {
+                    if(c.first == '\"' && !c.second) break;
+                    myStr.push_back((char)c.first);
+                }
+
+                tokens.push_back(LexToken(myStr,true));
+            };
+
+            auto read_char = [&read_chr_,&tokens,&read]()-> void {
+                auto v = read_chr_();
+                if(v.first != -1)
+                {
+                    tokens.push_back(LexToken(std::string({(char)v.first}),false));
+                }
+                read();
+            };
+
+            while((myRead = read()) != -1)
+            {
+                myPeek = peek();
+
+                switch(myRead)
+                {
+                    case '/':
+                    flush();
+                    if(myPeek == '/')
+                    {
+                        while(true)
+                        {
+                            myRead = read();
+                            if(myRead == -1) throw std::exception();
+                            if(myRead == '\n') break;
+                        }
+                    }
+                    else if(myPeek == '*')
+                    {
+                        read();
+                        while(true)
+                        {
+                            myRead = read();
+                            if(myRead == -1) throw std::exception();
+                            if(myRead == '*')
+                            {
+                                myRead = read();
+                                if(myRead == '/') break;
+                            }
+                        }
+                    }
+                    else if(myPeek == '=')
+                    {
+                        read();
+                        tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
+                    }
+                    else
+                    {
+                        tokens.push_back(LexToken(std::string({(char)myRead})));
+                    }
+                        break;
+                    case '\"':
+                        flush();
+                        read_string();
+                        break;
+                    case '\'':
+                        flush();
+                        read_char();
+                        break;
+                    case '<':
+                    case '>':
+                        {
+                        if(myPeek == myRead)
+                        {
+                            read();
+                            flush();
+                            int myPeek2 = peek();
+
+                            if(myPeek2 == '=')
+                            {
+                                read();
+                                tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek,'='})));
+                            }
+                            else{
+                            tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
+                            }
+                        }
+                        else if(myPeek == '=')
+                        {
+                            read();
+                            flush();
+                            tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
+                        }
+                        else
+                        {
+                            flush();
+                            tokens.push_back(LexToken(std::string({(char)myRead})));
+                        }
+                    }
+
+                        break;
+                    case '+':
+                    case '-':
+                    case '|':
+                    case '&':
+                    {
+                        if(myPeek == myRead)
+                        {
+                            read();
+                            flush();
+                            tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
+                        }
+                        else if(myPeek == '=')
+                        {
+                            read();
+                            flush();
+                            tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
+                        }
+                        else
+                        {
+                            flush();
+                            tokens.push_back(LexToken(std::string({(char)myRead})));
+                        }
+                    }
+
+                        break;
+                    case '^':
+                    case '*':
+                    case '%':
+                    case '=':
+                    case '!':
+                    {
+                        if(myPeek == '=')
+                        {
+                            read();
+                            flush();
+                            tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
+                        }
+                        else
+                        {
+                            flush();
+                            tokens.push_back(LexToken(std::string({(char)myRead})));
+                        }
+                    }
+                        break;
+                    case '?':
+                    case '.':
+                    case ';':
+                    case ':':
+                    case '(':
+                    case ')':
+                    case '[':
+                    case ']':
+                    case '{':
+                    case '}':
+                    case ',':
+                        flush();
+                        tokens.push_back(LexToken(std::string({(char)myRead})));
+                        break;
+                    case '\r':
+                    case '\n':
+                    case '\t':
+                    case ' ':
+                        flush();
+                        break;
+                    default:
+                        buf.push_back((char)myRead);
+                        break;
+                
+                }
+            }
+        }
+
+        bool NextTokenIs(std::string val, bool take=true)
+        {
+            //std::cout << val << " == " << tokens[i].text << std::endl;
+            if(i >= tokens.size()) return false;
+            if(!tokens[i].isChar && !tokens[i].isString && tokens[i].text == val)
+            {
+                if(take) i++;
+
+                return true;
+            }
+            return false;
+        }
+    
+        ScriptParser(std::filesystem::path path)
+        {
+            Lex(path,tokens);
+            this->path = path;
+        }
+
+        
+
+
+        void Ensure(std::string val)
+        {
+           
+            
+            if(i >= tokens.size()) throw std::exception();
+
+            
+            if(!tokens[i].isChar && !tokens[i].isString && tokens[i].text == val)
+            {
+                i++;
+                return;
+            }
+                            
+            throw std::exception();
+        }
+
+        bool IsAnyOf(std::initializer_list<std::string> tkns, std::string& txt)
+        {
+            if(this->i >= this->tokens.size()) return false;
+            for(auto item : tkns)
+            {
+                if(this->tokens[i].isString) continue;
+                if(this->tokens[i].isChar) continue;
+                if(this->tokens[i].text.compare(item) == 0)
+                {
+                    this->i++;
+                    txt = item;
+                    return true;
+                }
+            }
+            return false;
+        }
+        Node* ParseValue()
+        {
+            if(i>=tokens.size()) throw std::exception();
+            if(tokens[i].isString)
+            {
+                auto val=tokens[i].text;
+                i++;
+                return new ConstStringExpression(val);
+            }
+            if(tokens[i].isChar)
+            {
+                auto val = tokens[i].text;
+                i++;
+                return new ConstCharExpression(val[0]);
+            }
+            
+            std::string token = tokens[i].text;
+            
+            
+            i++;
+        
+            bool hasNumber=true;    
+            int64_t lngNum = 0;
+            
+            if(token.size() == 1 && token[0] == '0')
+            {
+                lngNum = 0;
+            }
+            else
+            if(token.size() > 0 && token[0] == '0')
+            {
+                if(token.size() > 1 && token[1] == 'x')
+                {
+                    lngNum = std::stoll(token.substr(2),nullptr,16);
+                }
+                else if(token.size() > 1 && token[1] == 'b')
+                {
+                    lngNum = std::stoll(token.substr(2),nullptr,2);
+                }
+                else
+                {
+                    lngNum = std::stoll(token.substr(1),nullptr,8);
+                }
+
+            }
+            else if(token.size() > 0 && token[0] >= '0' && token[0] <= '9')
+            {
+                lngNum=std::stoll(token,nullptr,10);
+            }
+            else
+            {
+                hasNumber = false;
+            }
+
+            Node* val = nullptr;
+
+            
+
+            if(hasNumber && this->NextTokenIs(".",false) && i+1 < tokens.size() && !tokens[i+1].isChar && !tokens[i+1].isString)
+            {
+                std::string myToken = tokens[i+1].text;
+                if(myToken.size() > 0 && myToken[0] >= '0' && myToken[0] <= '9')
+                {
+                    i+=2;
+                    std::string myN = std::to_string(lngNum) + "." + myToken;
+
+                    double v = std::stod(myN,nullptr);
+
+                    val = new ConstDoubleExpression(v);
+                }
+                else
+                {
+                    val = new ConstLongExpression(lngNum);
+                }
+            }
+            else if(hasNumber)
+            {
+                val = new ConstLongExpression(lngNum);
+            }
+            else {
+                if(token == "(")
+                {
+                    val = ParseExpression();
+                    Ensure(")");
+                }
+                if(token == "true")
+                {
+                    val = new ConstBoolExpression(true);
+                }
+                else if(token == "false")
+                {
+                    val = new ConstBoolExpression(false);
+                }
+                else if(token == "null")
+                {
+                    val = new ConstNullExpression();
+                }
+                else if(token == "undefined")
+                {
+                    val = new ConstUndefinedExpression();
+                }
+                else if(token == "var")
+                {
+                    if(i>=tokens.size()) throw std::exception();
+                    if(tokens[i].isString) throw std::exception();
+                    if(tokens[i].isChar) throw std::exception();
+                    val = new VarExpression(new GetVariableExpression(tokens[i].text));
+                    i++;
+                    
+                }
+                else if(token == "global")
+                {
+                    if(i>=tokens.size()) throw std::exception();
+                    if(tokens[i].isString) throw std::exception();
+                    if(tokens[i].isChar) throw std::exception();
+                    val = new GlobalExpression(new GetVariableExpression(tokens[i].text));
+                    i++;
+                }
+                else if(token == "caller")
+                {
+                    if(i>=tokens.size()) throw std::exception();
+                    if(tokens[i].isString) throw std::exception();
+                    if(tokens[i].isChar) throw std::exception();
+                    val = new CallerExpression(new GetVariableExpression(tokens[i].text));
+                    i++;
+                }
+                else {
+
+                    val = new GetVariableExpression(token);
+                }
+            }
+            std::string myT;
+            while(IsAnyOf({".","[","("},myT))
+            {
+                if(myT == ".")
+                {
+                    if(i>=tokens.size()) throw std::exception();
+                    if(tokens[i].isChar || tokens[i].isString) throw std::exception();
+                    std::string name = tokens[i].text; 
+                    i++;    
+                    val = new GetMemberExpression(val, name);
+                }
+                if(myT == "[")
+                {
+                    Node* expr=ParseExpression();
+                    Ensure("]");
+                    val = new GetArrayExpression(val,expr);
+                }
+                if(myT == "(")
+                {
+                    auto fcall = new FunctionCallExpression(val);
+                    while(!NextTokenIs(")",false))
+                    {
+                        fcall->args.push_back(ParseExpression());
+                        if(!NextTokenIs(")",false))
+                        Ensure(",");
+                    }
+                    Ensure(")");
+                    val = fcall;
+                }
+            }
+
+            return val;
+        }
+        Node* ParseUnary()
+        {
+            if(NextTokenIs("-"))
+            {
+                return new NegativeExpression(ParseUnary());
+            }
+            if(NextTokenIs("~"))
+            {
+                return new BitwiseNotExpression(ParseUnary());
+            }
+            if(NextTokenIs("!"))
+            {
+                return new LogicalNotExpression(ParseUnary());
+            }
+            if(NextTokenIs("--"))
+            {
+                return new PrefixDecrementExpression(ParseUnary());
+            }
+            if(NextTokenIs("++"))
+            {
+                return new PrefixIncrementExpression(ParseUnary());
+            }
+
+           
+            return ParseValue();
+        }
+        Node* ParseFactor()
+        {
+            Node* v = ParseUnary();
+            std::string tok;
+            while(IsAnyOf({"*","/","%"},tok))
+            {
+                if(tok == "*")
+                    v = new TimesExpression(v,ParseUnary());
+                if(tok == "/")
+                    v = new DivideExpression(v,ParseUnary());
+                if(tok == "%")
+                    v = new ModExpression(v,ParseUnary());
+            }
+            return v;
+        }
+        Node* ParseSum()
+        {
+            Node* v = ParseFactor();
+            std::string tok;
+            while(IsAnyOf({"+","-"},tok))
+            {
+                if(tok == "+")
+                    v = new AddExpression(v,ParseFactor());
+                if(tok == "-")
+                    v = new SubExpression(v,ParseFactor());
+            }
+            return v;
+        }
+        Node* ParseShift()
+        {
+            Node* v = ParseSum();
+            std::string tok;
+            while(IsAnyOf({"<<",">>"},tok))
+            {
+                if(tok == "<<")
+                    v = new LeftShiftExpression(v,ParseSum());
+                if(tok == ">>")
+                    v = new RightShiftExpression(v,ParseSum());
+            }
+            return v;
+        }
+        Node* ParseRel()
+        {
+            Node* v = ParseShift();
+            std::string tok;
+            while(IsAnyOf({"<",">","<=",">="},tok))
+            {
+                if(tok == "<")
+                    v = new LessThanExpression(v,ParseShift());
+                if(tok == ">")
+                    v = new GreaterThanExpression(v,ParseShift());
+                if(tok == "<=")
+                    v = new LessThanEqualToExpression(v,ParseShift());
+                if(tok == ">=")
+                    v = new GreaterThanEqualToExpression(v,ParseShift());
+            }
+            return v;
+        }
+        Node* ParseEq()
+        {
+            Node* v = ParseRel();
+            std::string tok;
+            while(IsAnyOf({"!=","=="},tok))
+            {
+                if(tok == "!=")
+                    v = new NotEqualsExpression(v,ParseRel());
+                if(tok == "==")
+                    v = new EqualsExpression(v,ParseRel());
+            }
+            return v;
+        }
+        Node* ParseBAnd()
+        {
+            Node* v = ParseEq();
+            while(NextTokenIs("&"))
+            {
+                v = new BitwiseAndExpression(v,ParseEq());
+            }
+            return v;
+        }
+        Node* ParseXOr()
+        {
+            Node* v = ParseBAnd();
+            while(NextTokenIs("^"))
+            {
+                v = new ExclusiveOrExpression(v,ParseBAnd());
+            }
+            return v;
+        }
+        Node* ParseBOr()
+        {
+            Node* v = ParseXOr();
+            while(NextTokenIs("|"))
+            {
+                v = new BitwiseOrExpression(v,ParseXOr());
+            }
+            return v;
+        }
+        Node* ParseLAnd()
+        {
+            Node* v = ParseBOr();
+            while(NextTokenIs("&&"))
+            {
+                v = new LogicalAndExpression(v,ParseBOr());
+            }
+            return v;
+        }
+
+        Node* ParseLOr()
+        {
+            Node* v = ParseLAnd();
+            while(NextTokenIs("||"))
+            {
+                v = new LogicalOrExpression(v,ParseLAnd());
+            }
+            return v;
+        }
+
+        Node* ParseTernary()
+        {
+            Node* cond = ParseLOr(); 
+            if(NextTokenIs("?"))
+            {
+                Node* yes = ParseTernary();
+                Ensure(":");
+                Node* no = ParseTernary();
+                return new TernaryExpression(cond,yes,no);
+            }
+            return cond;
+        }
+
+        Node* ParseExpression()
+        {
+            Node* v = ParseTernary();
+            std::string t;
+            while(IsAnyOf({"=","+=","-=","*=","/=","%=","<<=",">>=","&=","^=","|="},t))
+            {
+                if(t == "=")
+                {
+                    v = new AssignExpression(v,ParseTernary());
+                }
+                if (t == "+=")
+                {
+                    v = new CompoundAssignExpression(new AddExpression(v,ParseTernary()));
+                }                
+                if (t == "-=")
+                {
+                    v = new CompoundAssignExpression(new SubExpression(v,ParseTernary()));
+                }
+                if (t == "*=")
+                {
+                    v = new CompoundAssignExpression(new TimesExpression(v,ParseTernary()));
+                }
+                if (t == "/=")
+                {
+                    v = new CompoundAssignExpression(new DivideExpression(v,ParseTernary()));
+                }
+                if (t == "%=")
+                {
+                    v = new CompoundAssignExpression(new ModExpression(v,ParseTernary()));
+                }
+                if (t == "<<=")
+                {
+                    v = new CompoundAssignExpression(new LeftShiftExpression(v,ParseTernary()));
+                }
+                if (t == ">>=")
+                {
+                    v = new CompoundAssignExpression(new RightShiftExpression(v,ParseTernary()));
+                }
+                if (t == "&=")
+                {
+                    v = new CompoundAssignExpression(new BitwiseAndExpression(v,ParseTernary()));
+                }
+                if (t == "^=")
+                {
+                    v = new CompoundAssignExpression(new ExclusiveOrExpression(v,ParseTernary()));
+                }
+                if (t == "|=")
+                {
+                    v = new CompoundAssignExpression(new BitwiseOrExpression(v,ParseTernary()));
+                }
+            }
+            return v;
+        }
+
+
+        Node* ParseNode(bool rootNode=false)
+        {
+            if(NextTokenIs("{") || rootNode)
+            {
+                
+                ScopeNode* sn = new ScopeNode();
+                sn->rootScope = rootNode;
+
+                while(this->i < this->tokens.size() && !NextTokenIs("}"))
+                {
+                    sn->items.push_back(ParseNode());
+
+                    NextTokenIs(";");
+                }
+                return sn;   
+            }
+
+            if(NextTokenIs("include"))
+            {
+                
+                if(i < tokens.size())
+                {
+                    std::filesystem::path par = this->path.parent_path();
+
+                    std::string file = tokens[i].text;
+                    i++;
+                    Ensure(";");
+
+                    ScriptParser p(par / file);
+
+                    return p.ParseNode(true);
+                }
+            }
+            if(NextTokenIs("print"))
+            {
+                Node* n=new PrintNode(ParseExpression());
+                Ensure(";");
+                return n;
+            }
+            if(NextTokenIs("return"))
+            {
+                Node* n=new ReturnNode(ParseExpression());
+                Ensure(";");
+                return n;
+            }
+            if(NextTokenIs("break"))
+            {
+                Ensure(";");
+                return new BreakNode();
+            }
+            if(NextTokenIs("continue"))
+            {
+                Ensure(";");
+                return new ContinueNode();
+            }
+            if(NextTokenIs("if"))
+            {
+                Ensure("(");
+                Node* cond = ParseExpression();
+                Ensure(")");
+
+                Node* yes = nullptr;
+
+                if(!NextTokenIs("else",false))
+                {
+                    yes = ParseNode();
+                    NextTokenIs(";");
+                }
+
+                Node* no = nullptr;
+
+                if(NextTokenIs("else"))
+                {
+                    no = ParseNode();
+                    NextTokenIs(";");
+                }
+
+                return new IfNode(cond,yes,no);
+            }
+            if(NextTokenIs("for"))
+            {
+                Ensure("(");
+
+                Node* init = nullptr;
+                Node* cond = nullptr;
+                Node* inc = nullptr;
+                
+                if(!NextTokenIs(";",false))
+                {
+                    init = ParseExpression();
+                }
+                Ensure(";");
+                if(!NextTokenIs(";",false))
+                {
+                    cond = ParseExpression();
+                }
+                Ensure(";");
+                if(!NextTokenIs(")",false))
+                {
+                    inc = ParseExpression();
+                }
+                Ensure(")");
+
+                Node* body = ParseNode();
+                NextTokenIs(";");
+
+                return new ForNode(init,cond,inc,body);
+            }
+            if(NextTokenIs("while"))
+            {
+                Ensure("(");
+                Node* cond = ParseExpression();
+                Ensure(")");
+                Node* body = ParseNode();
+                NextTokenIs(";");
+                return new WhileNode(cond,body,false);
+            }
+            if(NextTokenIs("do"))
+            {
+                Ensure("(");
+                Node* cond = ParseExpression();
+                Ensure(")");
+                Node* body = ParseNode();
+                NextTokenIs(";");
+                return new WhileNode(cond,body,true);
+            }
+            if(NextTokenIs("each"))
+            {
+                Ensure("(");
+                Node* list = ParseExpression();
+                Node* item = nullptr;
+
+                if(NextTokenIs(":"))
+                {
+                    item = list;
+                    list = ParseExpression();
+                }
+                else
+                {
+                    item = new GetVariableExpression("item");
+                }
+                Ensure(")");
+                Node* body = ParseNode();
+                NextTokenIs(";");
+                return new EachNode(item,list,body);
+            }
+            if(NextTokenIs("func"))
+            {
+                Node* fn = ParseExpression();
+                Node* body = ParseNode();
+                NextTokenIs(";");
+                
+                return new FunctionDeclarationNode(fn,body);
+            }
+            Node* n= ParseExpression();
+            Ensure(";");
+            return n;
+        }
+
+
+        public:
+        static Node* Parse(std::filesystem::path path)
+        {
+            ScriptParser p(path);
+            return p.ParseNode(true);
+        }
+
+    };
+
+    inline ScriptType TypeOf(Environment* env, std::vector<ScriptType> args)
+    {
+        
+                    if(args.size() > 0)
+                    {
+                        auto item = args[0];
+                        if(std::holds_alternative<char>(item))
+                        {
+                            return "char";
+                        }
+                        if(std::holds_alternative<std::string>(item))
+                        {
+                            return "string";
+                        }
+                        if(std::holds_alternative<int64_t>(item))
+                        {
+                            return "long";
+                        }
+                        if(std::holds_alternative<double>(item))
+                        {
+                            return "double";
+                        }
+                       
+                        if(std::holds_alternative<IttrKVP>(item))
+                        {
+                            return "ittrkvp";
+                        }
+                        if(std::holds_alternative<bool>(item))
+                        {
+                            return "bool";
+                        }
+                        if(std::holds_alternative<Undefined>(item))
+                        {
+                            return "undefined";
+                        }
+                        if(std::holds_alternative<Null>(item))
+                        {
+                            return "null";
+                        }
+                        if(std::holds_alternative<ObjectType>(item))
+                        {
+                            auto ot = std::get<ObjectType>(item).data;
+                            auto ls = dynamic_cast<List*>(ot);
+                            auto dict = dynamic_cast<Dictionary*>(ot);
+                            auto ifunc = dynamic_cast<InternalFunction*>(ot);
+                            auto efunc = dynamic_cast<ExternalFunction*>(ot);
+                            auto ittr = dynamic_cast<Ittr*>(ot);
+                            if(ittr != nullptr) return "ittr";
+                            if(ls != nullptr) return "list";
+                            if(dict != nullptr) return "dictionary";
+                            if(ifunc != nullptr) return "internal_function";
+                            if(efunc != nullptr) return "external_function";
+                        }
+                    }
+                    return Null();
+                
+    }
+
+    class BytecodeFile {
+        public:
+            std::map<std::string,InternalFunction*> functions;
+            InternalFunction* rootFunction;
+
+            ~BytecodeFile()
+            {
+                delete rootFunction;
+                for(auto item : functions)
+                {
+                    delete item.second;
+                }
+            }
+    };
+
+   #if defined(DEBUG)
+    #define INSTRUCTION_NAME(INAME) case Instruction:: INAME : printf("%s",#INAME); break;
+#endif
+  
+
+    class SimpleInstruction : public Instruction
+    {
+        public:
+            uint8_t instruction;
+            SimpleInstruction(uint8_t instruction)
+            {
+                this->instruction = instruction;
+            }
+            int Length()
+            {
+                return 1;
+            }
+            void Write(uint8_t* buffer)
+            {
+                buffer[0] = instruction;
+            }
+        #if defined(DEBUG)
+            void Print()
+            {
+                switch(instruction)
+                {
+                    INSTRUCTION_NAME(ADD)
+                    INSTRUCTION_NAME(SUB)
+                    INSTRUCTION_NAME(TIMES)
+                    INSTRUCTION_NAME(DIVIDE)
+                    INSTRUCTION_NAME(MOD)
+                    INSTRUCTION_NAME(LEFTSHIFT)
+                    INSTRUCTION_NAME(RIGHTSHIFT)
+                    INSTRUCTION_NAME(LESSTHAN)
+                    INSTRUCTION_NAME(GREATERTHAN)
+                    INSTRUCTION_NAME(GREATERTHANEQUALTO)
+                    INSTRUCTION_NAME(LESSTHANEQUALTO)
+                    INSTRUCTION_NAME(PRINT)
+                    INSTRUCTION_NAME(SCOPE_BEGIN)
+                    INSTRUCTION_NAME(SCOPE_END)
+                    INSTRUCTION_NAME(POP)
+                    INSTRUCTION_NAME(GETVARIABLE)
+                    INSTRUCTION_NAME(SETVARIABLE)
+                    INSTRUCTION_NAME(GETFIELD)
+                    INSTRUCTION_NAME(SETFIELD)
+                    INSTRUCTION_NAME(CALL_METHOD)
+                    INSTRUCTION_NAME(CALL_FUNC)
+                    INSTRUCTION_NAME(DESTROY_LOOP)
+                    INSTRUCTION_NAME(ITTR)
+                    INSTRUCTION_NAME(SET_LOOP)
+                    INSTRUCTION_NAME(GET_LOOP)
+                    default:
+                        printf("UNKNOWN: %i\n",(int)instruction);
+                        break;
+                }
+                printf("\n");
+            }
+        #endif
+    };
+
+    class LabelInstruction : public Instruction 
+    {   
+        std::string label;
+        public:
+            LabelInstruction(std::string label)
+            {
+                this->label = label;
+            }
+            std::string GetLabel()
+            {
+                return label;
+            }
+            void SetLabel(std::string lbl)
+            {
+                label = lbl;
+            }
+            int Length()
+            {
+                return 0;
+            }
+            void Write(uint8_t* buffer)
+            {
+
+            }
+            #if defined(DEBUG)
+            void Print()
+            {
+                printf("%s:\n",label.c_str());
+            }
+            #endif
+    };
+
+    class LabelableInstruction : public Instruction
+    {
+        public:
+            virtual std::string GetLabel()=0;
+            virtual void SetLabel(std::string lbl)=0;
+            virtual int GetPosition()=0;
+            virtual void SetPosition(int pos)=0;
+    };
+    
+    class JumpInstruction : public LabelableInstruction 
+    {
+        std::string label;
+        int position;
+        uint8_t instr;
+        public:
+            JumpInstruction(uint8_t instr,std::string label)
+            {
+                this->instr = instr;
+                this->label = label;
+                this->position = 0;
+            }
+            std::string GetLabel()
+            {
+                return label;
+            }
+            void SetLabel(std::string lbl)
+            {
+                label = lbl;
+            }
+            int GetPosition()
+            {
+                return position;
+            }
+            void SetPosition(int pos)
+            {
+                this->position = pos;
+            }
+            int Length() {return 5;}
+            void Write(uint8_t* buffer)
+            {
+                buffer[0] = instr;
+                buffer[1] = (uint8_t)((position >> 24) & 0xFF);
+                buffer[2] = (uint8_t)((position >> 16) & 0xFF);
+                buffer[3] = (uint8_t)((position >> 8) & 0xFF);
+                buffer[4] = (uint8_t)(position & 0xFF);
+            }
+
+           #if defined(DEBUG)
+            void Print()
+            {
+                switch(instr)
+                {
+                    INSTRUCTION_NAME(JMP)
+                    INSTRUCTION_NAME(JMPC)
+                }
+                printf(" %s [%i]\n", label.c_str(),this->position);
+            }
+
+            #endif
+    };
+    
+    class LongInstruction : public Instruction {
+        
+        public:
+            int64_t value;
+            LongInstruction(int64_t value)
+            {
+                this->value = value;
+            }
+            int Length()
+            {
+                return 9;
+            }
+            void Write(uint8_t* buffer)
+            {
+                buffer[0] = Instruction::PUSH_LONG;
+                buffer[1] = (uint8_t)((value >> 56) & 0xFF);
+                buffer[2] = (uint8_t)((value >> 48) & 0xFF);
+                buffer[3] = (uint8_t)((value >> 40) & 0xFF);
+                buffer[4] = (uint8_t)((value >> 32) & 0xFF);
+                buffer[5] = (uint8_t)((value >> 24) & 0xFF);
+                buffer[6] = (uint8_t)((value >> 16) & 0xFF);
+                buffer[7] = (uint8_t)((value >> 8) & 0xFF);
+                buffer[8] = (uint8_t)(value & 0xFF);
+            }
+            #if defined(DEBUG)
+            void Print()
+            {
+                std::cout << "PUSH_LONG " << value << std::endl;
+            }
+            #endif
+    };
+    class CharInstruction : public Instruction {
+        public:
+            char value;
+            CharInstruction(char c)
+            {
+                this->value = c;
+            }
+            int Length()
+            {
+                return 2;
+            }
+
+            void Write(uint8_t* buffer)
+            {
+                buffer[0] = Instruction::PUSH_CHAR;
+                buffer[1] = value;
+            }
+            #if defined(DEBUG)
+            void Print()
+            {
+                std::cout << "PUSH_CHAR \'" << value << "\'" << std::endl;
+            }
+            #endif
+    };  
+    class StringInstruction : public Instruction {
+        
+        public:
+            std::string value;
+            StringInstruction(std::string value)
+            {
+                this->value = value;
+            }
+            int Length()
+            {
+                return 5+value.size();
+            }
+            void Write(uint8_t* buffer)
+            {
+                buffer[0] = Instruction::PUSH_STRING;
+                auto sz = this->value.size();
+                buffer[1] = (uint8_t)((sz >> 24) & 0xFF);
+                buffer[2] = (uint8_t)((sz >> 16) & 0xFF);
+                buffer[3] = (uint8_t)((sz >> 8) & 0xFF);
+                buffer[4] = (uint8_t)(sz & 0xFF);
+                for(size_t i = 0;i<sz;i++)
+                {
+                    buffer[i+5] = (uint8_t)value[i];
+                }
+            }
+            #if defined(DEBUG)
+            void Print()
+            {
+                std::cout << "PUSH_STRING \"" << value << "\"" << std::endl;
+            }
+            #endif
+    };
+    
+    class BytecodeCompiler
+    {
+        std::string _brk={};
+        
+        std::string _cont = {};
+
+        std::stack<std::string> __eachs;
+
+        int jmpId = 0;
+        std::string NewJumpId()
+        {
+            std::string s = "__compGen" + std::to_string(jmpId);
+            jmpId++;
+            return s;
+        }
+        void ExpressionPop(Node* n,std::vector<Instruction*>& instructions)
+        {
+            if(n == nullptr) return;
+            if(n->IsExpression())
+                instructions.push_back(new SimpleInstruction(Instruction::POP));
+        }
+        Node* n;
+        void GenerateFree(Node* _n,std::vector<Instruction*>& instructions)
+        {
+            GetVariableExpression fnName("free");
+            FunctionCallExpression fcE(&fnName);
+            fcE.args.push_back(_n);
+            Compile(&fcE,instructions);
+            instructions.push_back(new SimpleInstruction(Instruction::POP));
+            fcE.args.clear();
+            fcE.name=nullptr;
+        }
+        void Compile(Node* n,std::vector<Instruction*>& instructions)
+        {
+            if(n==nullptr) return;
+            auto addExpr = dynamic_cast<AddExpression*>(n);
+            auto subExpr = dynamic_cast<SubExpression*>(n);
+            auto timesExpr = dynamic_cast<TimesExpression*>(n);
+            auto divExpr = dynamic_cast<DivideExpression*>(n);
+            auto modExpr = dynamic_cast<ModExpression*>(n);
+            auto lsExpr = dynamic_cast<LeftShiftExpression*>(n);
+            auto rsExpr = dynamic_cast<RightShiftExpression*>(n);
+            auto ltExpr = dynamic_cast<LessThanExpression*>(n);
+            auto gtExpr = dynamic_cast<GreaterThanExpression*>(n);
+            auto lteExpr = dynamic_cast<LessThanEqualToExpression*>(n);
+            auto gteExpr = dynamic_cast<GreaterThanEqualToExpression*>(n);
+            auto funcDecl = dynamic_cast<FunctionDeclarationNode*>(n);
+            auto varDecl = dynamic_cast<VarExpression*>(n);
+            auto lnotExpr = dynamic_cast<LogicalNotExpression*>(n);
+
+            auto scope = dynamic_cast<ScopeNode*>(n);
+
+            auto print = dynamic_cast<PrintNode*>(n);
+            auto lng = dynamic_cast<ConstLongExpression*>(n);
+            auto str = dynamic_cast<ConstStringExpression*>(n);
+
+            auto assign = dynamic_cast<AssignExpression*>(n);
+            auto compound = dynamic_cast<CompoundAssignExpression*>(n);
+
+            auto varGet = dynamic_cast<GetVariableExpression*>(n);
+            auto memGet = dynamic_cast<GetMemberExpression*>(n);
+            auto arrGet = dynamic_cast<GetArrayExpression*>(n);
+            auto gblGet = dynamic_cast<GlobalExpression*>(n);
+            auto callerGet = dynamic_cast<CallerExpression*>(n);
+
+            auto fCall = dynamic_cast<FunctionCallExpression*>(n);
+
+            auto ifNode = dynamic_cast<IfNode*>(n);
+            auto ternary = dynamic_cast<TernaryExpression*>(n);
+            auto whileNode = dynamic_cast<WhileNode*>(n);
+            auto breakNode = dynamic_cast<BreakNode*>(n);
+            auto cont = dynamic_cast<ContinueNode*>(n);
+            auto eachLoop = dynamic_cast<EachNode*>(n);
+            auto forLoop = dynamic_cast<ForNode*>(n);
+            auto lOr = dynamic_cast<LogicalOrExpression*>(n);
+            auto lAnd = dynamic_cast<LogicalAndExpression*>(n);
+            auto retNode = dynamic_cast<ReturnNode*>(n);
+            auto boolExpr = dynamic_cast<ConstBoolExpression*>(n);
+            auto nullExpr = dynamic_cast<ConstNullExpression*>(n);
+            auto undefinedExpr = dynamic_cast<ConstUndefinedExpression*>(n);
+            auto chrExpr = dynamic_cast<ConstCharExpression*>(n);
+            auto equalsExpr = dynamic_cast<EqualsExpression*>(n);
+            auto notEqualsExpr = dynamic_cast<NotEqualsExpression*>(n);
+            if(equalsExpr != nullptr)
+            {
+                Compile(equalsExpr->left,instructions);
+                Compile(equalsExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::EQUALS));
+            }
+             if(notEqualsExpr != nullptr)
+            {
+                Compile(notEqualsExpr->left,instructions);
+                Compile(notEqualsExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::NOTEQUALS));
+            }
+
+            if(chrExpr != nullptr)
+            {
+                instructions.push_back(new CharInstruction(chrExpr->value));
+            }
+            if(boolExpr != nullptr)
+            {
+                instructions.push_back(new SimpleInstruction(boolExpr->value ? Instruction::PUSH_TRUE : Instruction::PUSH_FALSE));
+            }
+            if(nullExpr != nullptr)
+            {
+                instructions.push_back(new SimpleInstruction(Instruction::PUSH_NULL));
+            }
+            if(undefinedExpr != nullptr)
+            {
+                instructions.push_back(new SimpleInstruction(Instruction::PUSH_UNDEFINED));
+            }
+            if(retNode != nullptr)
+            {
+                while(!this->__eachs.empty())
+                {
+                    auto item = this->__eachs.top();
+                    GetVariableExpression gve(item);
+                    GenerateFree(&gve,instructions);
+                    this->__eachs.pop();
+                }
+                Compile(retNode->retVal,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::RET));
+            }
+            if(lnotExpr != nullptr)
+            {
+                Compile(lnotExpr->node,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::LOGICALNOT));
+            }
+            if(lOr != nullptr)
+            {
+                std::string end = this->NewJumpId();
+                std::string pushTrue = this->NewJumpId();
+                Compile(lOr->left,instructions);
+                instructions.push_back(new JumpInstruction(Instruction::JMPC,pushTrue));
+                Compile(lOr->right,instructions);
+                instructions.push_back(new JumpInstruction(Instruction::JMP,end));
+                instructions.push_back(new LabelInstruction(pushTrue));
+                instructions.push_back(new SimpleInstruction(Instruction::PUSH_TRUE));
+                instructions.push_back(new LabelInstruction(end));
+            }
+            if(lAnd != nullptr)
+            {
+                std::string end = this->NewJumpId();
+                std::string pushFalse = this->NewJumpId();
+                std::string hndl = this->NewJumpId();
+                Compile(lAnd->left,instructions);
+                instructions.push_back(new JumpInstruction(Instruction::JMPC,hndl));
+                instructions.push_back(new JumpInstruction(Instruction::JMP,pushFalse));
+                instructions.push_back(new LabelInstruction(hndl));
+                Compile(lAnd->right,instructions);
+                instructions.push_back(new JumpInstruction(Instruction::JMP,end));
+                instructions.push_back(new LabelInstruction(pushFalse));
+                instructions.push_back(new SimpleInstruction(Instruction::PUSH_FALSE));
+                instructions.push_back(new LabelInstruction(end));
+            }
+            if(breakNode != nullptr)
+            {
+                if( _brk.size() > 0)
+                {
+                    instructions.push_back(new SimpleInstruction(Instruction::GET_LOOP));
+                    instructions.push_back(new JumpInstruction(Instruction::JMP,_brk));
+                } else {
+                    throw std::exception();
+                }
+            }
+            if(cont != nullptr)
+            {
+                if(_cont.size() > 0)
+                {
+                    instructions.push_back(new SimpleInstruction(Instruction::GET_LOOP));
+                    instructions.push_back(new JumpInstruction(Instruction::JMP, _cont));
+                }
+                else {
+                    throw std::exception();
+                }
+            }
+                if(forLoop != nullptr)
+            {
+                instructions.push_back(new SimpleInstruction(Instruction::SET_LOOP));
+                Compile(forLoop->init,instructions);
+                ExpressionPop(forLoop->init,instructions);
+                std::string oldcont = _cont;
+                std::string oldbrk = _brk;
+               
+                std::string end = NewJumpId();
+                std::string begin = NewJumpId();
+                 std::string yes = NewJumpId();
+                
+                std::string cont = NewJumpId();
+
+                _cont = cont;
+                _brk = end;
+
+
+                instructions.push_back(new LabelInstruction(begin));
+                Compile(forLoop->cond,instructions);
+                instructions.push_back(new JumpInstruction(Instruction::JMPC,yes));
+                instructions.push_back(new JumpInstruction(Instruction::JMP,end));
+                instructions.push_back(new LabelInstruction(yes));
+                Compile(forLoop->body,instructions);
+                ExpressionPop(forLoop->body,instructions);
+                instructions.push_back(new LabelInstruction(cont));
+                Compile(forLoop->inc,instructions);
+                ExpressionPop(forLoop->inc,instructions);
+                instructions.push_back(new JumpInstruction(Instruction::JMP,begin));
+                instructions.push_back(new LabelInstruction(end)); //used for break
+                instructions.push_back(new SimpleInstruction(Instruction::DESTROY_LOOP));
+
+                _cont = oldcont;
+                _brk = oldbrk;
+            }
+            if(eachLoop != nullptr)
+            {
+                
+                instructions.push_back(new SimpleInstruction(Instruction::SET_LOOP));
+                std::string eachIttr = NewJumpId();
+                __eachs.push(eachIttr);
+                instructions.push_back(new StringInstruction(eachIttr));
+                Compile(eachLoop->list,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::ITTR));
+                instructions.push_back(new SimpleInstruction(Instruction::SETVARIABLE));
+                instructions.push_back(new SimpleInstruction(Instruction::POP));
+                     std::string oldcont = _cont;
+                    std::string oldbrk = _brk;
+                    std::string yes = NewJumpId();
+                    std::string end = NewJumpId();
+                    std::string begin = NewJumpId();
+
+                    _cont = begin;
+                    _brk = end;
+                    
+                    instructions.push_back(new LabelInstruction(begin));
+                    GetVariableExpression var(eachIttr);
+                    GetMemberExpression mem(&var,"movenext");
+                    FunctionCallExpression ce(&mem);
+                    Compile(&ce,instructions);
+                    ce.name = nullptr;
+                    mem.parent=nullptr;
+
+                    instructions.push_back(new JumpInstruction(Instruction::JMPC,yes));
+                    instructions.push_back(new JumpInstruction(Instruction::JMP,end));
+                    instructions.push_back(new LabelInstruction(yes));
+                    GetMemberExpression mem2(&var,"current");
+                    FunctionCallExpression ce2(&mem2);
+                    AssignExpression assignExpr(eachLoop->item,&ce2);
+                    
+                    
+                    Compile(&assignExpr,instructions);
+                    ExpressionPop(&assignExpr,instructions);
+                    
+                    mem2.parent=nullptr;
+                    ce2.name=nullptr;
+
+                    assignExpr.left=nullptr;
+                    assignExpr.right = nullptr;
+                    Compile(eachLoop->body,instructions);
+                    ExpressionPop(eachLoop->body,instructions);
+                    instructions.push_back(new JumpInstruction(Instruction::JMP,begin));
+                    instructions.push_back(new LabelInstruction(end));
+                    __eachs.pop();
+                    
+                    GenerateFree(&var,instructions);
+                    instructions.push_back(new SimpleInstruction(Instruction::DESTROY_LOOP));
+
+                    _cont = oldcont;
+                    _brk = oldbrk;
+            }
+            if(whileNode != nullptr)
+            {
+                if(whileNode->isDo)
+                {
+                     instructions.push_back(new SimpleInstruction(Instruction::SET_LOOP));
+                    std::string oldcont = _cont;
+                    std::string oldbrk = _brk;
+                    
+                    std::string end = NewJumpId();
+                    std::string begin = NewJumpId();
+
+                    _cont = begin;
+                    _brk = end;
+                    instructions.push_back(new LabelInstruction(begin));
+                    Compile(whileNode->body,instructions);
+                    ExpressionPop(whileNode->body,instructions);
+
+
+                    Compile(whileNode->cond,instructions);
+                    instructions.push_back(new JumpInstruction(Instruction::JMPC,begin));
+                    instructions.push_back(new LabelInstruction(end)); //used for break
+
+                    instructions.push_back(new SimpleInstruction(Instruction::DESTROY_LOOP));
+
+                    _cont = oldcont;
+                    _brk = oldbrk;
+                }
+                else
+                {
+                    instructions.push_back(new SimpleInstruction(Instruction::SET_LOOP));
+                     std::string oldcont = _cont;
+                    std::string oldbrk = _brk;
+                    std::string yes = NewJumpId();
+                    std::string end = NewJumpId();
+                    std::string begin = NewJumpId();
+
+                    _cont = begin;
+                    _brk = end;
+                    
+                    instructions.push_back(new LabelInstruction(begin));
+                    Compile(whileNode->cond,instructions);
+                    instructions.push_back(new JumpInstruction(Instruction::JMPC,yes));
+                    instructions.push_back(new JumpInstruction(Instruction::JMP,end));
+                    instructions.push_back(new LabelInstruction(yes));
+                    Compile(whileNode->body,instructions);
+                    ExpressionPop(whileNode->body,instructions);
+                    instructions.push_back(new JumpInstruction(Instruction::JMP,begin));
+                    instructions.push_back(new LabelInstruction(end));
+
+                    instructions.push_back(new SimpleInstruction(Instruction::DESTROY_LOOP));
+
+                    _cont = oldcont;
+                    _brk = oldbrk;
+                }
+            }
+
+            if(ifNode != nullptr)
+            {
+                std::string yes = NewJumpId();
+                std::string end = NewJumpId();
+                Compile(ifNode->cond,instructions);
+                instructions.push_back(new JumpInstruction(Instruction::JMPC,yes));
+                Compile(ifNode->no,instructions);
+                ExpressionPop(ifNode->no,instructions);
+                instructions.push_back(new JumpInstruction(Instruction::JMP,end));
+                instructions.push_back(new LabelInstruction(yes));
+                Compile(ifNode->yes,instructions);
+                ExpressionPop(ifNode->yes,instructions);
+                instructions.push_back(new LabelInstruction(end));
+            }
+            if(ternary != nullptr)
+            {
+                std::string yes = NewJumpId();
+                std::string end = NewJumpId();
+               
+                Compile(ternary->cond,instructions);
+                instructions.push_back(new JumpInstruction(Instruction::JMPC,yes));
+                Compile(ternary->no,instructions);
+               
+                instructions.push_back(new JumpInstruction(Instruction::JMP,end));
+                instructions.push_back(new LabelInstruction(yes));
+                Compile(ternary->yes,instructions);
+               
+                instructions.push_back(new LabelInstruction(end));
+            }
+
+            if(compound != nullptr)
+            {
+                auto twoNode = dynamic_cast<TwoExpression*>(compound->node);
+                if(twoNode != nullptr)
+                {
+                    AssignExpression aE(twoNode->left,twoNode);
+                    Compile(&aE,instructions);
+                    aE.left = nullptr;
+                    aE.right = nullptr;
+                }
+            }
+
+            if(addExpr != nullptr)
+            {
+                Compile(addExpr->left,instructions);
+                Compile(addExpr->right,instructions);
+                
+                instructions.push_back(new SimpleInstruction(Instruction::ADD));
+            }
+
+            if(subExpr != nullptr)
+            {
+                Compile(subExpr->left,instructions);
+                Compile(subExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::SUB));
+            }
+            if(timesExpr != nullptr)
+            {
+                Compile(timesExpr->left,instructions);
+                Compile(timesExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::TIMES));
+            }
+            if(divExpr != nullptr)
+            {
+                Compile(divExpr->left,instructions);
+                Compile(divExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::DIVIDE));
+            }
+            if(modExpr != nullptr)
+            {
+                Compile(modExpr->left,instructions);
+                Compile(modExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::MOD));
+            }
+            if(lsExpr != nullptr)
+            {
+                Compile(lsExpr->left,instructions);
+                Compile(lsExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::LEFTSHIFT));
+            }
+            if(rsExpr != nullptr)
+            {
+                Compile(rsExpr->left,instructions);
+                Compile(rsExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::RIGHTSHIFT));
+            }
+            if(ltExpr != nullptr)
+            {
+                Compile(ltExpr->left,instructions);
+                Compile(ltExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::LESSTHAN));
+            }
+            if(gtExpr != nullptr)
+            {
+                Compile(gtExpr->left,instructions);
+                Compile(gtExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::GREATERTHAN));
+            }
+            if(lteExpr != nullptr)
+            {
+                Compile(lteExpr->left,instructions);
+                Compile(lteExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::LESSTHANEQUALTO));
+            }
+            if(gteExpr != nullptr)
+            {
+                Compile(gteExpr->left,instructions);
+                Compile(gteExpr->right,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::GREATERTHANEQUALTO));
+            }
+            if(funcDecl != nullptr)
+            {
+                auto fcall = dynamic_cast<FunctionCallExpression*>(funcDecl->nameAndArgs);
+                if(fcall != nullptr)
+                {
+                    auto fname = dynamic_cast<GetVariableExpression*>(fcall->name);
+
+                    if(fname != nullptr)
+                    {
+                       
+
+                        auto fn = new InternalFunction();
+                        this->file->functions[fname->name] = fn;
+
+                       
+                        
+                        for(auto arg : fcall->args)
+                        {
+                            auto argTXT = dynamic_cast<GetVariableExpression*>(arg);
+                            if(argTXT != nullptr)
+                            {
+                                fn->args.push_back(argTXT->name);
+                            }
+
+                        }
+
+                        Compile(funcDecl->body,fn);
+                    }
+
+                }
+
+            }
+            if(scope != nullptr)
+            {
+                if(!scope->rootScope)
+                    instructions.push_back(new SimpleInstruction(Instruction::SCOPE_BEGIN));
+                
+                for(auto no : scope->items)
+                {
+                    Compile(no,instructions);
+                    ExpressionPop(no,instructions);
+                }
+                
+                if(!scope->rootScope)
+                    instructions.push_back(new SimpleInstruction(Instruction::SCOPE_END));
+                
+            }
+            if(lng != nullptr)
+            {
+                
+                instructions.push_back(new LongInstruction(lng->value));
+            }
+            if(str != nullptr)
+            {
+                
+                instructions.push_back(new StringInstruction(str->value));
+            }
+            if(print != nullptr)
+            {
+                Compile(print->expr,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::PRINT));
+            }
+            if(varDecl != nullptr)
+            {
+                auto gvn = dynamic_cast<GetVariableExpression*>(varDecl->node);
+                if(gvn != nullptr)
+                {
+                    instructions.push_back(new StringInstruction(gvn->name));
+                    instructions.push_back(new SimpleInstruction(Instruction::PUSH_NULL));
+                    instructions.push_back(new SimpleInstruction(Instruction::DECLARE_VARIABLE));
+                }
+
+
+            }
+
+            if(assign != nullptr)
+            {
+                GetVariableExpression* gVar = dynamic_cast<GetVariableExpression*>(assign->left);
+                GetMemberExpression* gMem = dynamic_cast<GetMemberExpression*>(assign->left);
+                GetArrayExpression* gArray = dynamic_cast<GetArrayExpression*>(assign->left);
+                VarExpression* vDecl = dynamic_cast<VarExpression*>(assign->left);
+                GlobalExpression* gGbl = dynamic_cast<GlobalExpression*>(assign->left);
+                CallerExpression* gCaller = dynamic_cast<CallerExpression*>(assign->left);
+                if(gVar != nullptr)
+                {
+                    instructions.push_back(new StringInstruction(gVar->name));
+                    Compile(assign->right,instructions);
+                    instructions.push_back(new SimpleInstruction(Instruction::SETVARIABLE));
+                }
+                if(gMem != nullptr)
+                {
+                    
+                    Compile(gMem->parent,instructions);
+                    instructions.push_back(new StringInstruction(gMem->name));
+                    Compile(assign->right,instructions);
+                    instructions.push_back(new SimpleInstruction(Instruction::SETFIELD));
+                }
+
+                if(gArray != nullptr)
+                {
+                    
+                    Compile(gArray->parent,instructions);
+                    Compile(gArray->expr,instructions);
+                    Compile(assign->right,instructions);
+                    instructions.push_back(new SimpleInstruction(Instruction::SETARRAY));
+                }
+
+                if(gGbl != nullptr)
+                {
+                    gVar = dynamic_cast<GetVariableExpression*>(gGbl->node);
+                    if(gVar != nullptr)
+                    {
+                        instructions.push_back(new StringInstruction(gVar->name));
+                        Compile(assign->right,instructions);
+                        instructions.push_back(new SimpleInstruction(Instruction::SET_GLOBAL_VARIABLE));
+                    }
+                }
+
+                if(gCaller != nullptr)
+                {
+                    gVar = dynamic_cast<GetVariableExpression*>(gCaller->node);
+                    if(gVar != nullptr)
+                    {
+                        instructions.push_back(new StringInstruction(gVar->name));
+                        Compile(assign->right,instructions);
+                        instructions.push_back(new SimpleInstruction(Instruction::SET_CALLER_VARIABLE));
+                    }
+                }
+                if(vDecl != nullptr)
+                {
+                    gVar = dynamic_cast<GetVariableExpression*>(vDecl->node);
+                    if(gVar != nullptr)
+                    {
+                        instructions.push_back(new StringInstruction(gVar->name));
+                        Compile(assign->right,instructions);
+                        instructions.push_back(new SimpleInstruction(Instruction::DECLARE_VARIABLE));
+                    }
+                }
+            }
+
+            if(varGet != nullptr)
+            {
+                instructions.push_back(new StringInstruction(varGet->name));
+                instructions.push_back(new SimpleInstruction(Instruction::GETVARIABLE));
+            }
+
+            if(gblGet != nullptr)
+            {
+                varGet = dynamic_cast<GetVariableExpression*>(gblGet->node);
+                if(varGet != nullptr)
+                {
+                    instructions.push_back(new StringInstruction(varGet->name));
+                    instructions.push_back(new SimpleInstruction(Instruction::GET_GLOBAL_VARIABLE));
+                }
+            }
+            if(callerGet != nullptr)
+            {
+                varGet = dynamic_cast<GetVariableExpression*>(callerGet->node);
+                if(varGet != nullptr)
+                {
+                    instructions.push_back(new StringInstruction(varGet->name));
+                    instructions.push_back(new SimpleInstruction(Instruction::GET_CALLER_VARIABLE));
+                }
+            }
+
+            if(memGet != nullptr)
+            {
+                Compile(memGet->parent,instructions);
+                instructions.push_back(new StringInstruction(memGet->name));
+                instructions.push_back(new SimpleInstruction(Instruction::GETFIELD));
+            }
+
+            if(arrGet != nullptr)
+            {
+                Compile(arrGet->parent,instructions);
+                Compile(arrGet->expr,instructions);
+                instructions.push_back(new SimpleInstruction(Instruction::GETARRAY));
+            }
+            if(fCall != nullptr)
+            {
+                auto field = dynamic_cast<GetMemberExpression*>(fCall->name);
+                if(field != nullptr)
+                {
+                    Compile(field->parent,instructions);
+                    instructions.push_back(new StringInstruction(field->name));
+                    for(auto item : fCall->args)
+                        Compile(item,instructions);
+                    instructions.push_back(new LongInstruction(fCall->args.size()));
+                    instructions.push_back(new SimpleInstruction(Instruction::CALL_METHOD));
+                }
+                else
+                {
+                    Compile(fCall->name,instructions);
+                    for(auto item : fCall->args)
+                        Compile(item,instructions);
+                        
+
+                    instructions.push_back(new LongInstruction(fCall->args.size()));
+                    instructions.push_back(new SimpleInstruction(Instruction::CALL_FUNC));
+                }
+            }
+        }
+        void Compile(Node* n, InternalFunction* func)
+        {
+            std::vector<Instruction*> instructions;
+            Compile(n,instructions);
+            int length=0;
+            std::map<std::string,int> lbls;
+            for(auto item : instructions)
+            {
+                auto lbl = dynamic_cast<LabelInstruction*>(item);
+                if(lbl != nullptr)
+                lbls[lbl->GetLabel()] = length;
+                length += item->Length();
+            }
+
+            func->bytecodeLength = length;
+            func->bytecode = new uint8_t[length];
+
+            uint8_t* buffer = func->bytecode;
+            #if defined(DEBUG)
+            printf("INSTRUCTIONS:\n\n");
+            #endif
+            size_t len2=0;
+            for(auto item : instructions)
+            {
+                auto lblable = dynamic_cast<LabelableInstruction*>(item);
+                if(lblable != nullptr)
+                {
+                    lblable->SetPosition(lbls[lblable->GetLabel()]);
+                }
+                item->Write(buffer);
+                buffer += item->Length();
+
+                #if defined(DEBUG)
+                printf("OFFSET %i\n",(int)len2);
+                item->Print();
+                #endif
+                len2+=item->Length();
+
+                delete item;
+            }
+
+            #if defined(DEBUG)
+            printf("\n\nEND OF INSTRUCTIONS\n\n");
+            #endif
+            instructions.clear();
+        }
+        public:
+        BytecodeFile* file;
+        BytecodeCompiler(Node* root)
+        {
+            this->n = root;
+            file=new BytecodeFile();
+            file->rootFunction = new InternalFunction();
+            file->rootFunction->isRoot=true;
+            
+
+        }
+
+        
+
+        void Compile()
+        {
+            Compile(n,file->rootFunction);
+        }
+
+      
+    };
+
+    
+
+
+   
+}
\ No newline at end of file
diff --git a/tesseswebserver.cpp b/tesseswebserver.cpp
new file mode 100644
index 0000000..f769125
--- /dev/null
+++ b/tesseswebserver.cpp
@@ -0,0 +1,41 @@
+#include "tesseswebserver.hpp"
+TESSESWEBSERVER_STATIC_DECLARATION
+using namespace Tesses::WebServer;
+using namespace Tesses::WebServer::ScriptEngine;
+
+class DummyServer : public IServer
+{
+    public:
+    bool Handle(ServerContext* ctx)
+    {
+        std::string resp = {};
+
+        for(auto param : ctx->queryParams.GetAll())
+        {
+            resp.append(param.first);
+            resp.append(": ");
+            resp.append(param.second);
+            resp.append("\r\n");
+        }
+
+        ctx->SetContentType("text/plain")->SendText(resp);
+        return true;
+    }
+};
+
+int main(int argc,char** argv)
+{
+    
+
+    
+
+
+    HttpServerListener::Init();
+
+    IServer* myServer = new DummyServer();
+    
+    HttpServerListener::Listen(myServer,3000);
+    
+
+
+}
\ No newline at end of file
diff --git a/tesseswebserver.hpp b/tesseswebserver.hpp
new file mode 100644
index 0000000..ced9a86
--- /dev/null
+++ b/tesseswebserver.hpp
@@ -0,0 +1,1142 @@
+#pragma once
+//#define GEKKO
+#include "tesseswebserverfeatures.hpp"
+
+#include <variant>
+#include <cstdio>
+#include <iostream>
+#include <exception>
+#include <vector>
+#include <atomic>
+#include <string>
+#include <cstring>
+#include <filesystem>
+#include <initializer_list>
+#include <map>
+#include <stack>
+
+#include <functional>
+#include <cmath>
+#include <bit>
+#include <cctype>
+
+#if defined(USE_JANSSON)
+#include <jansson.h>
+#endif
+
+#if defined(USE_CURL)
+#include <curl/curl.h>
+#include <curl/easy.h>
+#endif
+
+#if defined(USE_SQLITE3)
+#include <sqlite3.h>
+#endif
+
+#if defined(USE_MBEDTLS)
+#include <mbedtls/ssl.h>
+#endif
+
+#if defined(DEBUG)
+   
+    #define DEBUGOUT(...) printf(__VA_ARGS__)
+#else
+    #define DEBUGOUT(...)
+#endif
+
+#if defined(GEKKO)
+#include <ogc/lwp.h>
+#include <ogc/mutex.h>
+
+#if defined(HW_RVL) && defined(USE_WIISOCKETS)
+    #include <sys/socket.h>
+    #include <wiisocket.h>
+#else
+    #include <network.h>
+    #define socket net_socket
+    #define bind net_bind
+    #define listen net_listen
+    #define recv net_recv
+    #define send net_send
+    #define close net_close
+#endif
+
+#else
+#include <threads.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#endif
+
+namespace Tesses::WebServer {
+
+#if defined(GEKKO)
+typedef void* THREAD_RETURN_TYPE;
+
+#define THREAD_DEFAULT_RETURN_TYPE (NULL)
+
+typedef THREAD_RETURN_TYPE (*callback)(void* arg);
+#else
+typedef int THREAD_RETURN_TYPE;
+
+#define THREAD_DEFAULT_RETURN_TYPE 0
+
+typedef THREAD_RETURN_TYPE (*callback)(void* arg);
+
+
+#endif
+
+class Statics {
+    public:
+    #if defined(GEKKO)
+    std::vector<Thread*> joined_threads;
+    mutex_t mtx;
+    #else
+    mtx_t mtx;
+    #endif
+    std::atomic<bool> isRunning;
+};
+extern Tesses::WebServer::Statics tesses_webserver_statics;
+class Thread {
+    #if defined(GEKKO)
+    lwp_t thrd;
+    std::atomic<bool> hasExited;
+    callback cb;
+    void* arg;
+    
+    #else
+    thrd_t thrd;
+    
+    
+    #endif
+    public:
+
+    static void Init()
+    {
+        #if defined(GEKKO)
+            LWP_MutexInit(&tesses_webserver_statics.mtx,true);
+        #else
+            mtx_init(&tesses_webserver_statics.mtx,mtx_recursive);
+        #endif
+    }
+
+    Thread(callback cb,void* arg,uint32_t stackSize)
+    {
+        #if defined(GEKKO)
+        this->hasExited=false;
+        this->cb = cb;
+        this->arg = arg;
+        LWP_CreateThread(&this->thrd,HANDLER,arg,NULL,stackSize,80);
+        #else
+        thrd_create(&thrd,cb,arg);
+        #endif
+    }
+    #if defined(GEKKO)
+    static THREAD_RETURN_TYPE HANDLER(void* arg)
+    {
+        Thread* thrd = (Thread*)arg;
+        THREAD_RETURN_TYPE t = thrd->cb(arg);
+        thrd->hasExited=true;
+        return t;
+    }
+    #endif
+
+    int Join(THREAD_RETURN_TYPE* retType)
+    {
+        #if defined(GEKKO)
+        return LWP_JoinThread(this->thrd,retType);
+        #else
+        return thrd_join(this->thrd,retType);
+        #endif
+    }
+
+    void Detach()
+    {
+        #if defined(GEKKO)
+            Lock();
+            tesses_webserver_statics.joined_thrads.push_back(this);
+            Unlock();
+        #else
+            thrd_detach(this->thrd);
+            delete this;
+        #endif
+    }
+
+    static void Lock()
+    {
+        #if defined(GEKKO)
+            LWP_MutexLock(tesses_webserver_statics.mtx);
+        #else
+            mtx_lock(&tesses_webserver_statics.mtx);
+        #endif
+    }
+    static void Unlock()
+    {
+        #if defined(GEKKO)
+            LWP_MutexUnlock(tesses_webserver_statics.mtx);
+        #else
+            mtx_unlock(&tesses_webserver_statics.mtx);
+        #endif
+    }
+
+    
+
+    static void CleanThreads()
+    {
+        #if defined(GEKKO)
+        Lock();
+        for(auto i = tesses_webserver_statics.joined_threads.begin();i<tesses_webserver_statics.joined_threads.end();i++)
+        {
+            auto item = *i;
+            if(item->hasExited)
+            {
+                THREAD_RETURN_TYPE arg;
+                item->Join(&arg);
+                delete item;
+                tesses_webserver_statics.joined_threads.erase(i);
+                i--;
+            }
+        }
+        Unlock();
+        #endif
+    }
+};
+
+class Stream {
+    public:
+    virtual ssize_t Read(uint8_t* buffer,size_t len)=0;
+    virtual ssize_t Write(uint8_t* buffer,size_t len)=0;
+
+    virtual void Seek(uint64_t offset,int whence)
+    {
+
+    }
+
+    virtual int64_t Position()
+    {
+        return 0;
+    }
+
+    virtual bool CanSeek()
+    {
+        return false;
+    }
+
+    void WriteBlock(uint8_t* buffer,size_t len)
+    {
+        size_t read;
+        do{
+            read = 1024;
+            if(len < 1024)
+                read = len;
+            if(read > 0)
+                read=this->Write(buffer,read);
+            
+
+
+            buffer += read;
+            len -= read;
+        } while(read > 0);
+    }
+
+    virtual int64_t Length()
+    {
+        return -1;
+    }
+    virtual ~Stream()
+    {
+
+    }
+
+    int ReadByte()
+    {
+        uint8_t byte;
+        if(Read(&byte,1) == 0) return -1;
+        
+        return byte;
+    }
+
+    std::string ReadLine()
+    {
+        std::string str = {};
+        int c = ReadByte();
+        while(c != '\n' && c != -1)
+        {   
+            if(c != '\r')
+            {
+                str.push_back((char)c);
+            }
+            c = ReadByte();
+        }
+
+        DEBUGOUT("ReadLine: %s\n",str.c_str());
+
+        return str;
+    }
+};
+
+
+class FileStream : public Stream
+{
+    private:
+        FILE* f;
+        bool canSeek;
+        bool owns;
+    public:
+
+    FileStream(std::string filename, std::string mode)
+    {
+        this->f = fopen(filename.c_str(),mode.c_str());
+        this->canSeek=true;
+        this->owns=true;
+    }
+
+    FileStream(FILE* f,bool canSeek,bool owns)
+    {
+        this->f = f;
+        this->canSeek = canSeek;
+        this->owns = owns;
+    }
+
+    ssize_t Read(uint8_t* buffer,size_t len)
+    {
+        return (ssize_t)fread(buffer,1,len,this->f);
+        
+    }
+
+    ssize_t Write(uint8_t* buffer, size_t len)
+    {
+        return (ssize_t)fwrite(buffer,1,len,this->f);
+    }
+    int64_t Position()
+    {
+        #if(_FILE_OFFSET_BITS == 64)
+        #if defined(WIN32)
+        return (int64_t)_ftelli64(this->f);
+        #else
+        return (int64_t)ftello(this->f);
+        #endif
+        #else
+        return (int64_t)ftell(this->f);
+        #endif
+    }
+
+    void Seek(uint64_t offset,int whence)
+    {
+        #if(_FILE_OFFSET_BITS == 64)
+        #if defined(WIN32)
+        _ftelli64(this->f,(__int64)offset,whence);
+        #else
+        fseeko(this->f,(off_t)offset,whence);
+        #endif
+        #else
+        fseek(this->f,(long)offset,whence);
+        #endif
+    }
+};  
+
+class SocketStream : public Stream {
+    int sock;
+    public:
+    SocketStream(int sock)
+    {
+        this->sock = sock;
+    }
+    ssize_t Read(uint8_t* buffer,size_t len)
+    {
+         ssize_t r= recv(this->sock,buffer,len,0);
+        return r;
+    }
+    ssize_t Write(uint8_t* buffer,size_t len)
+    {
+        return send(this->sock,buffer,len,0);
+    }
+    ~SocketStream()
+    {
+        close(sock);
+    }
+};
+typedef enum StatusCode {
+    Continue=100,
+    SwitchingProtocols=101,
+    Processing=102,
+    EarlyHints=103,
+    OK=200,
+    Created=201,
+    Accepted=202,
+    NonAuthoritativeInformation=203,
+    NoContent=204,
+    ResetContent=205,
+    PartialContent=206,
+    MultiStatus=207,
+    AlreadyReported=208,
+    IMUsed=226,
+    MultipleChoices=300,
+    MovedPermanently=301,
+    Found=302,
+    SeeOther=303,
+    NotModified=304,
+    UseProxy=305,
+    TemporaryRedirect=307,
+    PermanentRedirect=308,
+    BadRequest=400,
+    Unauthorized=401,
+    PaymentRequired=402,
+    Forbidden=403,
+    NotFound=404,
+    MethodNotAllowed=405,
+    NotAcceptable=406,
+    ProxyAuthenticationRequired=407,
+    RequestTimeout=408,
+    Conflict=409,
+    Gone=410,
+    LengthRequired=411,
+    PreconditionFailed=412,
+    PayloadTooLarge=413,
+    URITooLong=414,
+    UnsupportedMediaType=415,
+    RangeNotSatisfiable=416,
+    ExpectationFailed=417,
+    ImATeapot=418,
+    MisdirectedRequest=421,
+    UnprocessableContent=422,
+    Locked=423,
+    FailedDependency=424,
+    TooEarly=425,
+    UpgradeRequired=426,
+    PreconditionRequired=428,
+    TooManyRequests=429,
+    RequestHeaderFieldsTooLarge=431,
+    UnavailableForLegalReasons=451,
+    InternalServerError=500,
+    NotImplemented=501,
+    BadGateway=502,
+    ServiceUnavailable=503,
+    GatewayTimeout=504,
+    HTTPVersionNotSupported=505,
+    VariantAlsoNegotiates=506,
+    InsufficientStorage=507,
+    LoopDetected=508,
+    NotExtended=510,
+    NetworkAuthenticationRequired=511
+} StatusCode;
+
+
+class HttpUtils {
+    
+
+    public:
+        static char nibble_to_hex_char(uint8_t number)
+        {
+            if(number >= 0 && number <= 9)
+            {
+                return '0'+number;
+            }
+            if(number >= 0xA && number <= 0xF)
+            {
+                return (char)(55+number);
+            }
+            return '0';
+        }
+        static uint8_t hex_char_to_nibble(char c)
+        {
+            if(c >= '0' && c <= '9')
+                return c - '0';
+            
+            if(c >= 'A' && c <= 'F')
+                return (c-'A')+0xA;
+            
+            if(c >= 'a' && c <= 'f')
+                return (c-'a')+0xA;
+            return 0;
+        }
+    static std::vector<std::pair<std::string,std::string>> QueryParamsDecode(std::string query)
+    {
+        std::vector<std::pair<std::string,std::string>> strs;
+        for(auto item : SplitString(query,"&"))
+        {
+            std::vector<std::string> ss=SplitString(item,"=",2);
+            if(ss.size() >= 1)
+            {
+                std::string value = {};
+                if(ss.size() == 2)
+                {
+                    value = UrlDecode(ss[1]);
+                }
+                strs.push_back(std::pair<std::string,std::string>(ss[0],value));
+            }
+        }
+        return strs;
+    }
+
+    static std::string QueryParamsEncode(std::vector<std::pair<std::string,std::string>> query)
+    {
+        std::string s={};
+        bool first = true;
+        for(auto item : query)
+        {
+            if(!first)
+            {
+                s.push_back('&');
+            }
+            s.insert(s.size(),item.first);
+            s.push_back('=');
+            s.insert(s.size(),UrlEncode(item.second));
+            first=false;
+        }
+        return s;
+    }
+
+    static std::string UrlDecode(std::string v)
+    {   
+        std::string s = {};
+
+        for(size_t i = 0;i<v.size();i++)
+        {
+            if(v[i] == '+')
+                s.push_back(' ');
+            else if(v[i] == '%')
+            {
+                i++;
+                uint8_t n = hex_char_to_nibble(v[i])<<4;
+                i++;
+                n |= hex_char_to_nibble(v[i]);
+                s.push_back((char)n);
+            }
+            else
+                s.push_back(v[i]);
+
+        }
+        return s;
+    }
+    static std::string UrlPathEncode(std::string v)
+    {
+        std::string s = {};
+
+        for(auto item : v)
+        {
+            if(item >= 'A' && item <= 'Z')
+                s.push_back(item);
+            else if(item >= 'a' && item <= 'z')
+                s.push_back(item);
+            else if(item >= '0' && item <= '9')
+                s.push_back(item);
+            else if(item == '-' || item == '_' || item == '.' || item == '~')
+                s.push_back(item);
+            else
+            {
+                s.push_back('%');
+                s.push_back(nibble_to_hex_char((item >> 4) & 0xF));
+                s.push_back(nibble_to_hex_char((item) & 0xF));
+            }
+        }
+        return s;
+    }
+    static std::string UrlPathDecode(std::string v)
+    {
+        std::string s = {};
+
+        for(size_t i = 0;i<v.size();i++)
+        {
+            if(v[i] == '%')
+            {
+                i++;
+                uint8_t n = hex_char_to_nibble(v[i])<<4;
+                i++;
+                n |= hex_char_to_nibble(v[i]);
+                s.push_back((char)n);
+            }
+            else
+                s.push_back(v[i]);
+
+        }
+        return s;
+    }
+
+    static std::string UrlEncode(std::string v)
+    {
+        std::string s = {};
+
+        for(auto item : v)
+        {
+            if(item == ' ')
+                s.push_back('+');
+            else if(item >= 'A' && item <= 'Z')
+                s.push_back(item);
+            else if(item >= 'a' && item <= 'z')
+                s.push_back(item);
+            else if(item >= '0' && item <= '9')
+                s.push_back(item);
+            else if(item == '-' || item == '_' || item == '.' || item == '~')
+                s.push_back(item);
+            else
+            {
+                s.push_back('%');
+                s.push_back(nibble_to_hex_char((item >> 4) & 0xF));
+                s.push_back(nibble_to_hex_char((item) & 0xF));
+            }
+        }
+        return s;
+    }
+
+    static std::vector<std::string> SplitString(std::string text, std::string delimiter,std::size_t maxCnt = std::string::npos)
+    {
+        std::vector<std::string> strs;
+        std::size_t i = 1;
+        while(text.length() > 0)
+        {
+            if(i == maxCnt)
+           {
+                strs.push_back(text);
+                break;    
+           }
+           std::size_t index= text.find_first_of(delimiter);
+
+           
+
+           if(index == std::string::npos)
+           {
+                strs.push_back(text);
+                break;
+           }
+           else
+           {
+                std::string left = text.substr(0,index);
+
+                text = text.substr(index+delimiter.size());
+
+                strs.push_back(left);
+           }
+           i++;
+        }
+        return strs;
+    }
+    static std::string HtmlEncode(std::string html)
+    {
+        std::string myHtml = {};
+        for(auto item : html)
+        {
+            if(item == '\"')
+            {
+                myHtml.append("&quot;");
+            }
+            else if(item == '\'')
+            {
+                myHtml.append("&apos;");
+            }
+            else if(item == '&')
+            {
+                myHtml.append("&amp;");
+            }
+            else if(item == '<')
+            {
+                myHtml.append("&lt;");
+            }
+            else if(item == '>')
+            {
+                myHtml.append("&gt;");
+            }
+            else
+            {
+                myHtml.push_back(item);
+            }
+        }
+        return myHtml;
+    }
+    static std::string StatusCodeString(StatusCode code)
+    {
+        switch(code)
+        {
+            case StatusCode::Continue:
+                return "Continue";
+            case StatusCode::SwitchingProtocols:
+                return "Switching Protocols";
+            case StatusCode::Processing:
+                return "Processing";
+            case StatusCode::EarlyHints:
+                return "Early Hints";
+            case StatusCode::OK:
+                return "OK";
+            case StatusCode::Created:
+                return "Created";
+            case StatusCode::Accepted:
+                return "Accepted";
+            case StatusCode::NonAuthoritativeInformation:
+                return "Non-Authoritative Information";
+            case StatusCode::NoContent:
+                return "No Content";
+            case StatusCode::ResetContent:
+                return "Reset Content";
+            case StatusCode::PartialContent:
+                return "PartialContent";
+            case StatusCode::MultiStatus:
+                return "Multi-Status";
+            case StatusCode::AlreadyReported:
+                return "Already Reported";
+            case StatusCode::IMUsed:
+                return "IM Used";
+            case StatusCode::MultipleChoices:
+                return "Multiple Choices";
+            case StatusCode::MovedPermanently:
+                return "Moved Permanently";
+            case StatusCode::Found:
+                return "Found";
+            case StatusCode::SeeOther:
+                return "See Other";
+            case StatusCode::NotModified:
+                return "Not Modified";
+            case StatusCode::UseProxy:
+                return "Use Proxy";
+            case StatusCode::TemporaryRedirect:
+                return "Temporary Redirect";
+            case StatusCode::PermanentRedirect:
+                return "Permanent Redirect";
+            case StatusCode::BadRequest:
+                return "Bad Request";
+            case StatusCode::Unauthorized:
+                return "Unauthorized";
+            case StatusCode::PaymentRequired:
+                return "Payment Required";
+            case StatusCode::Forbidden:
+                return "Forbidden";
+            case StatusCode::NotFound:
+                return "Not Found";
+            case StatusCode::MethodNotAllowed:
+                return "Method Not Allowed";
+            case StatusCode::NotAcceptable:
+                return "Not Acceptable";
+            case StatusCode::ProxyAuthenticationRequired:
+                return "Proxy Authentication Required";
+            case StatusCode::RequestTimeout:
+                return "Request Timeout";
+            case StatusCode::Conflict:
+                return "Conflict";
+            case StatusCode::Gone:
+                return "Gone";
+            case StatusCode::LengthRequired:
+                return "Length Required";
+            case StatusCode::PreconditionFailed:
+                return "Precondition Failed";
+            case StatusCode::PayloadTooLarge:
+                return "Payload Too Large";
+            case StatusCode::URITooLong:
+                return "URI Too Long";
+            case StatusCode::UnsupportedMediaType:
+                return "Unsupported Media Type";
+            case StatusCode::RangeNotSatisfiable:
+                return "Range Not Satisfiable";
+            case StatusCode::ExpectationFailed:
+                return "Expectation Failed";
+            case StatusCode::ImATeapot:
+                return "I'm a teapot";
+            case StatusCode::MisdirectedRequest:
+                return "Misdirected Request";
+            case StatusCode::UnprocessableContent:
+                return "Unprocessable Content";
+            case StatusCode::Locked:
+                return "Locked";
+            case StatusCode::FailedDependency:
+                return "Failed Dependency";
+            case StatusCode::TooEarly:
+                return "Too Early";
+            case StatusCode::UpgradeRequired:
+                return "Upgrade Required";
+            case StatusCode::PreconditionRequired:
+                return "Precondition Required";
+            case StatusCode::TooManyRequests:
+                return "Too Many Requests";
+            case StatusCode::RequestHeaderFieldsTooLarge:
+                return "Request Header Fields Too Large";
+            case StatusCode::UnavailableForLegalReasons:
+                return "Unavailable For Legal Reasons";
+            case StatusCode::InternalServerError:
+                return "Internal Server Error";
+            case StatusCode::NotImplemented:
+                return "Not Implemented";
+            case StatusCode::ServiceUnavailable:
+                return "Service Unavailable";
+            case StatusCode::GatewayTimeout:
+                return "Gateway Timeout";
+            case StatusCode::HTTPVersionNotSupported:
+                return "HTTP Version Not Supported";
+            case StatusCode::VariantAlsoNegotiates:
+                return "Variant Also Negotiates";
+            case StatusCode::InsufficientStorage:
+                return "Insufficient Storage";  
+            case StatusCode::LoopDetected:
+                return "Loop Detected";
+            case StatusCode::NotExtended:
+                return "Not Extended";
+            case StatusCode::NetworkAuthenticationRequired:
+                return "Network Authentication Required";
+            default:
+                return "";
+        }
+    }
+};
+
+class QueryParams {
+    private:
+        std::vector<std::pair<std::string,std::string>> items;
+    public:
+        void Add(std::string key, std::string value)
+        {
+            Add(std::pair<std::string,std::string>(key,value));
+        }
+        void Add(std::pair<std::string,std::string> pair)
+        {
+            items.push_back(pair);
+        }
+        void Add(std::vector<std::pair<std::string,std::string>>& items)
+        {
+            for(auto item : items)
+            this->items.push_back(item);
+        }
+        std::vector<std::pair<std::string,std::string>>& GetAll()
+        {
+            return this->items;
+        }
+        void Get(std::vector<std::string>& v, std::string key)
+        {
+            for(auto item : this->items)
+                if(item.first == key)
+                    v.push_back(item.second);
+        }
+        void Set(std::string key,std::string value)
+        {
+            Clear(key);
+            Add(key,value);
+        }
+
+        
+        void Set(std::pair<std::string,std::string> item)
+        {
+            Set(item.first,item.second);
+        }
+
+        void Set(std::string key, std::vector<std::string>& value)
+        {
+            Clear(key);
+            for(auto item : value)
+                Add(key,item);
+        }
+
+        bool TryGetFirst(std::string key,std::string& val)
+        {
+            for(auto item : this->items)
+                if(item.first == key)
+                {
+                    val = item.second;
+                    return true;
+                }
+            return false;
+        }
+        void Clear(std::string key)
+        {
+
+            for(auto item = items.begin();item<items.end();item++)
+            {
+                if((*item).first == key)
+                {
+                    items.erase(item);
+                    item--;
+                }
+            }
+        }
+        void Clear()
+        {
+            items.clear();
+        }
+};
+
+
+class ServerContext {
+    Stream* strm;
+    bool ok;
+    public:
+    ServerContext(Stream* strm)
+    {
+        DEBUGOUT("ServerContext Constructed\n");
+        this->strm = strm;
+        std::string firstLine = strm->ReadLine();
+        DEBUGOUT("READ Request line\n");
+        std::vector<std::string> firstLineA=HttpUtils::SplitString(firstLine," ",4);
+        DEBUGOUT("Split Request line\n");
+
+        if(firstLineA.size() == 4 || firstLineA.size() < 3)
+        {
+            DEBUGOUT("Request line does not have 3 entries\n");
+            this->ok=false;
+        }
+        else
+        {
+            this->ok=false;
+            method = firstLineA[0];
+            std::vector<std::string> p = HttpUtils::SplitString(firstLineA[1],"?",2);
+            if(p.size() >= 1)
+            {
+                this->ok = true;
+                this->originalPath = p[0];
+                DEBUGOUT("Path %s\n",this->originalPath.c_str());
+                this->path = originalPath;
+                if(p.size() == 2)
+                {
+                    auto qp=HttpUtils::QueryParamsDecode(p[1]);
+                    this->queryParams.Add(qp);
+                }
+            }
+            version = firstLineA[2];
+            responseVersion=version;
+            std::string line;
+            while((line=strm->ReadLine()).size() > 0)
+            {
+                std::vector<std::string> header=HttpUtils::SplitString(line,": ",2);
+                if(header.size() == 2)
+                {
+                    this->requestHeaders.Add(std::pair<std::string,std::string>(header[0],header[1]));
+                }
+            }
+
+        }
+        
+
+
+    }
+    bool CanHandleRequest()
+    {
+        return this->ok;
+    }
+
+    std::string method;
+    std::string originalPath;
+    std::string path;
+    std::string version;
+
+    std::string responseVersion;
+
+    bool ConnectionOpen()
+    {
+        std::string keep_alive;
+        if(requestHeaders.TryGetFirst("Connection",keep_alive))
+        {
+            return keep_alive.compare("keep-alive") == 0;
+        }
+        return false;
+    }
+
+    QueryParams queryParams;
+    QueryParams requestHeaders;
+    QueryParams responseHeaders;
+
+    StatusCode statusCode=StatusCode::OK;
+
+    void SendHeaders()
+    {
+        std::string headers = responseVersion + " " + std::to_string((int)statusCode) + " " + HttpUtils::StatusCodeString(statusCode) + "\r\n";
+
+        for(auto header : responseHeaders.GetAll())
+        {
+            headers += header.first + ": " + header.second + "\r\n";
+        }
+        headers += "\r\n";
+        this->strm->WriteBlock((uint8_t*)headers.c_str(),headers.size());
+
+    }
+
+    void SendErrorPage(bool showPath)
+    {
+        std::string errorHtml = showPath ? ("<html><head><title>File " + HttpUtils::HtmlEncode(this->originalPath) + " " + HttpUtils::StatusCodeString(this->statusCode) + "</title></head><body><h1>" + std::to_string((int)this->statusCode) + " " + HttpUtils::StatusCodeString(this->statusCode) + "</h1><h4>" + HttpUtils::HtmlEncode(this->originalPath) + "</h4></body></html>") : "";
+
+        SetContentType("text/html")->SendText(errorHtml);
+    }
+    
+    ServerContext* SetContentType(std::string contentType)
+    {
+        return this->SetHeader("Content-Type",contentType);
+    }
+
+    ServerContext* SetHeader(std::string key,std::string value)
+    {
+        this->responseHeaders.Set(key,value);
+        return this;
+    }
+
+    void SendBytes(uint8_t* buffer,size_t len)
+    {
+        this->SetHeader("Content-Length",std::to_string(len))->SendHeaders();
+        this->strm->WriteBlock(buffer,len);
+    }
+
+    void SendText(std::string text)
+    {
+        SendBytes((uint8_t*)text.c_str(),text.size());
+    }
+
+    void SendNotFound()
+    {
+        statusCode = StatusCode::NotFound;
+        SendErrorPage(true);
+    }
+    void SendBadRequest()
+    {
+        statusCode = StatusCode::BadRequest;
+        SendErrorPage(false);
+    }
+
+    ~ServerContext()
+    {
+        if(!ConnectionOpen())
+        delete strm;
+    }
+};
+
+class IServer {
+    public:
+    virtual bool Handle(ServerContext* ctx)=0;
+};
+
+
+#if defined(USE_SCRIPT_ENGINE)
+    #define INCLUDED_FROM_TESSESWEBSERVER_H
+    #include "tessesscriptengine.hpp"
+    #undef INCLUDED_FROM_TESSESWEBSERVER_H
+#endif
+
+class HttpServerListener {
+    
+    
+    static THREAD_RETURN_TYPE HandleRequestOnThread(void* arg)
+    {
+        DEBUGOUT("Started thread\n");
+        void** args = (void**)arg;
+        IServer* svr=  static_cast<IServer*>(args[0]);
+        Stream* strm = static_cast<Stream*>(args[1]);
+
+        delete args;
+
+        HandleRequest(svr,strm);
+        
+        return THREAD_DEFAULT_RETURN_TYPE;
+    }
+    
+    public:
+    
+    static void Init()
+    {
+        tesses_webserver_statics.isRunning=true;
+        Thread::Init();
+    }
+
+    
+
+    static void HandleRequest(IServer* server,Stream* strm)
+    {
+        start:
+        ServerContext* ctx = new ServerContext(strm);
+
+        if(!ctx->CanHandleRequest())
+        {
+            ctx->SendBadRequest();
+            delete ctx;
+            return;
+        }
+       
+        if(!server->Handle(ctx))
+            ctx->SendNotFound();
+
+        
+        if(ctx->ConnectionOpen())
+        {
+            delete ctx;
+            goto start;
+        }
+
+        delete ctx;
+
+        
+    }
+
+    
+
+    static void ListenWithBoundSocket(IServer* server,int boundAndListeningSocket)
+    {
+        printf("\033[31mAlmost ready to listen\033[0m\n");
+        while(tesses_webserver_statics.isRunning)
+        {
+            struct sockaddr addr;
+            socklen_t addrlen;
+            int a = accept(boundAndListeningSocket, &addr, &addrlen);
+
+            void** myArg = new void*[2];
+
+            myArg[0] = static_cast<void*>(server);
+            myArg[1] = static_cast<void*>(new SocketStream(a));
+
+
+            Thread* thread = new Thread(HandleRequestOnThread,myArg,512000);
+            thread->Detach();
+
+            /*ServerContext* ctx = ReadHeaders(a);
+
+            if(!server->Handle(ctx))
+                ctx->SendNotFound();
+
+            delete ctx;
+            
+
+            close(a);
+            */
+        }
+    }
+    static void Listen(IServer* server, unsigned int domain,const struct sockaddr* addr, socklen_t addrlen)
+    {
+        int s=socket(domain,SOCK_STREAM,0);
+        if(s == -1) 
+        {
+            printf("Socket error\n");
+            
+            throw std::exception();
+        }
+        if(bind(s,addr,addrlen) == -1)
+        {
+            printf("Bind error\n");
+            throw std::exception();
+        }
+        
+        if(listen(s,10) == -1)
+        {
+            printf("Listen error\n");
+            throw std::exception();
+        }
+        ListenWithBoundSocket(server,s);
+    }
+
+    static void Listen(IServer* server, int port)
+    {
+        struct sockaddr_in addr;
+        memset(&addr,0,sizeof(addr));
+        addr.sin_family = AF_INET;
+        addr.sin_port = htons((uint16_t)port);
+        addr.sin_addr.s_addr = 0;
+
+        Listen(server,AF_INET,(struct sockaddr*)&addr,(socklen_t)sizeof(addr));
+    }
+
+    static void DoJobs()
+    {
+        #if defined(GEKKO)
+        Thread::CleanThreads();
+        #endif
+    }
+
+    static void Stop()
+    {
+        
+    }
+};
+
+#define TESSESWEBSERVER_STATIC_DECLARATION Tesses::WebServer::Statics Tesses::WebServer::tesses_webserver_statics;
+
+
+
+}
\ No newline at end of file
diff --git a/tesseswebserverfeatures.hpp b/tesseswebserverfeatures.hpp
new file mode 100644
index 0000000..58ea23f
--- /dev/null
+++ b/tesseswebserverfeatures.hpp
@@ -0,0 +1,7 @@
+#pragma once
+
+#define USE_SCRIPT_ENGINE
+#define USE_MBEDTLS
+#define USE_CURL
+#define USE_SQLITE3
+#define USE_JANSSON
\ No newline at end of file
diff --git a/wwwroot/cgi-bin/add-todo.twss b/wwwroot/cgi-bin/add-todo.twss
new file mode 100644
index 0000000..05a9e99
--- /dev/null
+++ b/wwwroot/cgi-bin/add-todo.twss
@@ -0,0 +1,8 @@
+<!--tws 
+    t = post("text");
+    if(t != null)
+    {
+        todos.add(t);
+    }
+    redirect("/");
+-->
\ No newline at end of file
diff --git a/wwwroot/deinit.twss b/wwwroot/deinit.twss
new file mode 100644
index 0000000..a60b3e1
--- /dev/null
+++ b/wwwroot/deinit.twss
@@ -0,0 +1,3 @@
+<!--tws 
+    free(todos);
+-->
\ No newline at end of file
diff --git a/wwwroot/index.twss b/wwwroot/index.twss
new file mode 100644
index 0000000..b320bcc
--- /dev/null
+++ b/wwwroot/index.twss
@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>ToDo List</title>
+</head>
+<body>
+    <h1>ToDo List</h1>
+
+    <form method="POST" action="./cgi-bin/add-todo.twss">
+        <input type="text" name="text" placeholder="ToDo Text">
+        <input type="submit" value="Add">
+    </form>
+
+    <ul>
+        <!--tws
+            each(global todos) {
+        -->
+            <li><!--tws print htmlencode(item); --></li>
+        <!--tws
+            }
+        -->
+    </ul>
+</body>
+</html>
\ No newline at end of file
diff --git a/wwwroot/init.twss b/wwwroot/init.twss
new file mode 100644
index 0000000..3e43948
--- /dev/null
+++ b/wwwroot/init.twss
@@ -0,0 +1,3 @@
+<!--tws
+    todos = list();
+-->
\ No newline at end of file