diff --git a/variant.cs b/variant.cs
new file mode 100644
index 0000000..0856e76
--- /dev/null
+++ b/variant.cs
@@ -0,0 +1,257 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace object1
+{
+    class variant
+    {
+        protected enum V_TYPE
+        {
+            INT,
+            FLOAT,
+            STRING,
+            DOUBLE,
+            OBJECT,
+            NULL
+        };
+
+        protected V_TYPE TYPE;
+        protected object data;
+
+        protected void setData(object o, V_TYPE t)
+        {
+            TYPE = t;
+            data = o;
+        }
+
+        public variant(int val)
+        {
+            setData(val, V_TYPE.INT);
+        }
+
+        public variant(float f)
+        {
+            setData(f, V_TYPE.FLOAT);
+        }
+
+        public variant(string s)
+        {
+            setData(s, V_TYPE.STRING);
+        }
+
+        public variant(double d)
+        {
+            setData(d, V_TYPE.DOUBLE);
+        }
+
+        public variant(variant v)
+        {
+            setData(v.data, v.TYPE);
+        }
+
+        public variant()
+        {
+            setData(null, V_TYPE.NULL);
+        }
+
+        public static implicit operator variant(int i)
+        {
+            return new variant(i);
+        }
+
+        public static implicit operator variant(float f)
+        {
+            return new variant(f);
+        }
+
+        public static implicit operator variant(double d)
+        {
+            return new variant(d);
+        }
+
+        public static implicit operator variant(string s)
+        {
+            return new variant(s);
+        }
+
+        public static implicit operator int(variant v)
+        {
+            switch (v.TYPE)
+            {
+                case V_TYPE.INT:
+                case V_TYPE.FLOAT:
+                case V_TYPE.DOUBLE:
+                case V_TYPE.OBJECT:
+                    return (int)v.data;
+                case V_TYPE.STRING:
+                    return int.Parse((string)v.data);
+                default:
+                    return 0;
+            }
+        }
+
+        public static implicit operator float(variant v)
+        {
+            switch (v.TYPE)
+            {
+                case V_TYPE.INT:
+                case V_TYPE.FLOAT:
+                case V_TYPE.DOUBLE:
+                case V_TYPE.OBJECT:
+                    return (float)v.data;
+                case V_TYPE.STRING:
+                    return float.Parse((string)v.data);
+                default:
+                    return 0;
+            }
+        }
+
+        public static implicit operator double(variant v)
+        {
+            switch (v.TYPE)
+            {
+                case V_TYPE.INT:
+                case V_TYPE.FLOAT:
+                case V_TYPE.DOUBLE:
+                case V_TYPE.OBJECT:
+                    return (double)v.data;
+                case V_TYPE.STRING:
+                    return double.Parse((string)v.data);
+                default:
+                    return 0;
+            }
+        }
+
+        public static implicit operator string(variant v)
+        {
+            switch (v.TYPE)
+            {
+                case V_TYPE.INT:
+                    return ((int)v.data).ToString();
+                case V_TYPE.DOUBLE:
+                    return ((double)v.data).ToString();
+                case V_TYPE.FLOAT:
+                    return ((float)v.data).ToString();
+                case V_TYPE.OBJECT:
+                    return ((object)v.data).ToString();
+                case V_TYPE.STRING:
+                    return (string)v.data;
+                default:
+                    return "";
+            }
+        }
+
+        public static variant operator +(variant v, int i)
+        {
+            switch (v.TYPE)
+            {
+                case V_TYPE.INT:
+                    return new variant((int)v.data + i);
+                case V_TYPE.FLOAT:
+                    return new variant((float)v.data + i);
+                case V_TYPE.DOUBLE:
+                    return new variant((double)v.data + i);
+                case V_TYPE.STRING:
+                    return new variant((string)v.data + i.ToString());
+                default:
+                    return new variant();
+            }
+        }
+
+        public static variant operator +(variant v, float i)
+        {
+            switch (v.TYPE)
+            {
+                case V_TYPE.INT:
+                    return new variant((int)v.data + i);
+                case V_TYPE.FLOAT:
+                    return new variant((float)v.data + i);
+                case V_TYPE.DOUBLE:
+                    return new variant((double)v.data + i);
+                case V_TYPE.STRING:
+                    return new variant((string)v.data + i.ToString());
+                default:
+                    return new variant();
+            }
+        }
+
+        public static variant operator +(variant v, double i)
+        {
+            switch (v.TYPE)
+            {
+                case V_TYPE.INT:
+                    return new variant((int)v.data + i);
+                case V_TYPE.FLOAT:
+                    return new variant((float)v.data + i);
+                case V_TYPE.DOUBLE:
+                    return new variant((double)v.data + i);
+                case V_TYPE.STRING:
+                    return new variant((string)v.data + i.ToString());
+                default:
+                    return new variant();
+            }
+        }
+
+        public static variant operator +(variant v, string i)
+        {
+            switch (v.TYPE)
+            {
+                case V_TYPE.INT:
+                    return new variant((int)v.data + int.Parse(i));
+                case V_TYPE.FLOAT:
+                    return new variant((float)v.data + float.Parse(i));
+                case V_TYPE.DOUBLE:
+                    return new variant((double)v.data + double.Parse(i));
+                case V_TYPE.STRING:
+                    return new variant((string)v.data + i);
+                default:
+                    return new variant();
+            }
+        }
+
+        public override string ToString()
+        {
+            switch (TYPE)
+            {
+                case V_TYPE.INT:
+                case V_TYPE.DOUBLE:
+                case V_TYPE.FLOAT:
+                case V_TYPE.STRING:
+                    return (string)this;
+                default:
+                    return "";
+            }
+        }
+
+    }
+    class Program
+    {
+        static void Main(string[] args)
+        {
+            variant v = 5;
+            Console.WriteLine(v.ToString());
+            int x = v;
+            Console.WriteLine(x);
+            v += 10;
+            Console.WriteLine(v.ToString());
+            v += "10";
+            Console.WriteLine(v.ToString());
+            string s = v;
+            Console.WriteLine(s);
+
+            x = 20;
+            v = x;
+            s = v;
+            x = v;
+            Console.WriteLine("{0} - {1} - {2}", x, v, s);
+
+            /*object var1, var2, var3;
+            var1 = 4;
+            var2 = 5;
+            var3 = var1 + var2;*/
+
+        }
+    }
+}