Vector3 GetPosition(Struct.DoubleIndex index)
    {
        Vector3 worldPosition = new Vector3(field.position.x + index.first, 0, field.position.z + index.second);
        worldPosition += wallSize / 2;

        return worldPosition;
    }

 public static int Main()
 {
     object
     o
     =
     new
     Struct
     (1);
     Struct
     s
     =
     new
     Struct
     (2);
     if
     (s.a
     !=
     2)
     return
     1;
     if
     (((Struct)o).a
     !=
     1)
     return
     2;
     return
     0;
 }

    public static List<Struct.DoubleIndex> Dfs(char [,] map, Struct.DoubleIndex current, Struct.DoubleIndex target, char wall, bool isNew = true)
    {
        if (isNew) {
            currentPath.Clear ();
            bestPath = null;
        }

        currentPath.Insert (0, current.Clone());

        if (current.Equals (target) && (bestPath == null || bestPath.Count > currentPath.Count))
            bestPath = new List<Struct.DoubleIndex> (currentPath);

        if (bestPath != null && bestPath.Count <= currentPath.Count)
            return bestPath;

        for (int i = 0; i < directionsX.Length; i++) {
            current.first  += directionsY[i];
            current.second += directionsX[i];

            if(!currentPath.Contains(current) && CanMove(map, current, wall))
                Dfs (map, current, target, wall, false);

            current.first  -= directionsY[i];
            current.second -= directionsX[i];
        }

        currentPath.RemoveAt (0);

        return bestPath;
    }

 /// <summary>
 /// Initializes a new instance of the PlanePosition class.
 /// </summary>
 public SurfacesPosition(Struct pos)
 {
     Throttle = pos.throttle;
     Rudder = pos.rudder;
     Elevator = pos.elevator;
     Aileron = pos.aileron;
 }

 public RatHatchBrush(Struct.Pattern pattern)
 {
     this.pattern=pattern;
     this.pen = null;
     this.color = pattern.ForeColor;
     this.opacity = ((float) this.color.A) / 255f;
 }

        public void GetPrivateValueField()
        {
            Struct instance = new Struct(privateValueField: 1);

            GetMethod result = sut.GetFieldGetter(privateValueField);

            Assert.AreEqual(1, result(instance));
        }

        public void GetPrivateValueProperty()
        {
            Struct instance = new Struct(privateValueProperty: 1);

            GetMethod result = sut.GetPropertyGetter(privateValueProperty);

            Assert.AreEqual(1, result(instance));
        }

    public static void Main()
    {
        Struct s  = pointer_reference.get();
        if (s.value != 10) throw new Exception("get test failed");

        Struct ss = new Struct(20);
        pointer_reference.set(ss);
        if (Struct.instance.value != 20) throw new Exception("set test failed");
    }

        public void GetPublicClassProperty()
        {
            object expected = new object();
            Struct instance = new Struct { PublicClassProperty = expected };

            GetMethod result = sut.GetPropertyGetter(publicClassProperty);

            Assert.AreSame(expected, result(instance));
        }

        public void GetPublicClassField()
        {
            object expected = new object();
            Struct instance = new Struct { PublicClassField = expected };

            GetMethod result = sut.GetFieldGetter(publicClassField);

            Assert.AreSame(expected, result(instance));
        }

        public void GetPrivateClassField()
        {
            object expected = new object();
            Struct instance = new Struct(privateClassField: expected);

            GetMethod result = sut.GetFieldGetter(privateClassField);

            Assert.AreSame(expected, result(instance));
        }

            private WeakRefTracker _tracker;        // storage for weak proxy's

            private void Initialize(Struct s) {
                _formatString = s._formatString;
                _formats = s._formats;
                _isStandardized = s._isStandardized;
                _isLittleEndian = s._isLittleEndian;
                _encodingCount = s._encodingCount;
                _encodingSize = s._encodingSize;
                _tracker = s._tracker;
            }

    public static void Main(string[] args)
    {
        object foo = new Foo();
        NullRefTest containsnullref = new NullRefTest();

        Struct s = new Struct(1);
        Outer();
        GC.KeepAlive(foo);
        GC.KeepAlive(containsnullref);
    }

 public Struct Get(Struct klass)
 {
     foreach (Struct st in _mystructs)
     {
         if (Equals(st.GetType(), klass.GetType()))
         {
             return st;
         }
     }
     return null;
 }

        /// <summary>
        /// Initializes a new instance of the PlaneControl class.
        /// </summary>
        public PlaneControl(Struct pkt)
        {
            double ScaleFactor = 1.0;

            Roll = (pkt.roll / ScaleFactor) * 100.0;
            Pitch = (pkt.pitch / ScaleFactor) * 100.0;
            Rudder = (pkt.rudder / ScaleFactor) * 100.0;

            // Throttle must be reversed
            Throttle = (pkt.throttle / ScaleFactor) * 100.0;
        }

	public static void Main() {
		
		Struct s = new Struct();
		
		s.x = 1;
		s.y = 2;
		
		System.Console.WriteLine("{0} {1} {2}", s.x, s.y, s.z);
		
		TestS(ref s);
	}	

    public static void Main (string[] args) {
        var a = new Struct[10];

        for (var i = 0; i < a.Length; i++)
            a[i] = new Struct {
                I = i
            };

        foreach (var s in a)
            Console.WriteLine(s);
    }

  public static void Main() {
    Struct s  = pointer_reference.get();
    if (s.value != 10) throw new Exception("get test failed");

    Struct ss = new Struct(20);
    pointer_reference.set(ss);
    if (Struct.instance.value != 20) throw new Exception("set test failed");

    if (pointer_reference.overloading(1) != 111) throw new Exception("overload test 1 failed");
    if (pointer_reference.overloading(ss) != 222) throw new Exception("overload test 2 failed");
  }

	public static int Main ()
	{
		Struct s = new Struct ("1");
		var t = s.AsyncMethod ();
		if (!Task.WaitAll (new[] { t }, 2000))
			return 1;
		
		if (!t.Result)
			return 2;
		
		return 0;
	}

 private static void Inner(object i)
 {
     bool b = true;
     char c = 'c';
     object d = 43.0;
     Struct st = new Struct(1);
     if (b)
     {
         string s = "hello world";
         throw new Exception();
     }
 }