private static void ArgumentCheck(Side side, int m, int n, int k, int ilo, int ihi, Object A, int lda, Object tau, Object C, int ldc) {
   if ( A == null ) {
     throw new ArgumentNullException("A","A cannot be null.");
   }
   if ( tau == null ) {
     throw new ArgumentNullException("tau","tau cannot be null.");
   }
   if ( C == null ) {
     throw new ArgumentNullException("C","C cannot be null.");
   }
   if ( m<0 ) {
     throw new ArgumentException("m must be at least zero.", "m");
   }
   if ( n<0 ) {
     throw new ArgumentException("n must be at least zero.", "n");
   }
   if( side == Side.Left ){
     if( k < 0 || k > m ){
       throw new ArgumentException("k must be positive and less than or equal to m.", "k");
     }
     if (m>0) {
       if (ilo<1 || ilo>m || ilo>ihi)
         throw new ArgumentException("ilo must be a positive number and less than or equal to min(ihi,m) if m>0", "ilo");
       if (ihi<1 || ihi>m)
         throw new ArgumentException("ihi must be between 1 and m if m>0", "ihi");
     } else {
       if (ilo!=1)
         throw new ArgumentException("ilo must be 1 if m=0", "ilo");
       if (ihi!=0)
         throw new ArgumentException("ihi must be 0 if m=0", "ihi");
     }
   }else{
     if( k < 0 || k > n ){
       throw new ArgumentException("k must be positive and less than or equal to n.", "k");
     }
     if (n>0) {
       if (ilo<1 || ilo>n || ilo>ihi)
         throw new ArgumentException("ilo must be a positive number and less than or equal to min(ihi,n) if n>0", "ilo");
       if (ihi<1 || ihi>n)
         throw new ArgumentException("ihi must be a positive number and less than or equal to n if n>0", "ihi");
     } else {
       if (ilo!=1)
         throw new ArgumentException("ilo must be 1 if n=0", "ilo");
       if (ihi!=0)
         throw new ArgumentException("ihi must be 0 if n=0", "ihi");
     }
   }
   if( side == Side.Left ){
     if ( lda < System.Math.Max(1,m) ) {
       throw new ArgumentException("lda must be at least max(1,m)", "lda");
     }
   }else{
     if ( lda < System.Math.Max(1,n) ) {
       throw new ArgumentException("lda must be at least max(1,n)", "lda");
     }
   }
   if ( ldc < System.Math.Max(1,m) ) {
     throw new ArgumentException("ldc must be at least max(1,m)", "ldc");
   }
 }

 public static Side RotateSide(Side side, int steps)
 {
     int index = Array.IndexOf(allSides, side);
     index += steps;
     index = Mathf.CeilToInt(Mathf.Repeat(index, allSides.Length));
     return allSides[index];
 }

    ///<summary>Check arguments so that errors don't occur in native code</summary>
    private static void ArgumentCheck( Side side, int m, int n, object A, int lda, object B, int ldb ) {
      if ( A == null ) {
        throw new ArgumentNullException("A", "A cannot be null.");
      }
      if ( B == null ) {
        throw new ArgumentNullException("B", "B cannot be null.");
      }
      if ( m < 0) {
        throw new ArgumentException("m must be zero or greater", "m");
      }
      if ( n < 0) {
        throw new ArgumentException("n must be zero or greater", "n");
      }
    
      if (side == Side.Left) {
        if(lda < System.Math.Max(1,m)){
          throw new ArgumentException("lda must be at least max(1,m).", "lda");
        }
      }else{
        if(lda < System.Math.Max(1,n)){
          throw new ArgumentException("lda must be at least max(1,n).","lda");
        }
      }
      if(ldb < System.Math.Max(1,m)){
        throw new ArgumentException("lda must be at least max(1,m).","ldb");
      }

    }

 public Person(int helthPoint, int x, int y, Side team)
 {
     this.HelthPoint = helthPoint;
     this.x = x;
     this.y = y;
     this.Team = team;
 }

	private IEnumerator WaitForPosition()
	{
		yield return new WaitForEndOfFrame();

		int dir = 1;
		lastSide = Side.Right;

		Vector3 viewportPosition = Camera.main.WorldToViewportPoint (transform.position);
		if((viewportPosition.x < 0 && viewportPosition.y > 0.5f) ||
		   (viewportPosition.x > 1 && viewportPosition.y < 0.5f) ||
		   (viewportPosition.y < 0 && viewportPosition.x < 0.5f) ||
		   (viewportPosition.y > 1 && viewportPosition.x > 0.5f))
		{
			dir = -1;
			lastSide = Side.Left;
		}

		sideVelocity = (Vector2)transform.up * dir;
		frontVelocity = (Vector2)transform.right;
		finalVelocity = (frontVelocity + sideVelocity).normalized;

		myAnimator.SetInteger ("State", (lastSide == Side.Right) ? 0 : 1);

		yield return new WaitForEndOfFrame();

		myAnimator.SetInteger("State", 2);

		angle = Mathf.Atan2 (finalVelocity.y, finalVelocity.x) * Mathf.Rad2Deg;
		
		StartCoroutine (ChangeDirection (timeToChangeDirection.Random ()));
	}

 public Player(string name, Side side)
 {
     Name = name;
     Side = side;
     win = 0;
     lose = 0;
 }

        private void AdvanceState(Side side)
        {
            if (StillPlaying())
            {
                if (HasEnteredDeuce())
                {
                    this.state = GameState.Deuce;

                    if (GetPointState(side) == PointState.Advantage)
                    {
                        this.state = DetermineWinner(side);
                        return;
                    }

                    if((sideOnePoints == PointState.Deuce && sideTwoPoints == PointState.Deuce)
                        || (sideOnePoints == PointState.Forty && sideTwoPoints == PointState.Forty))
                    {
                        SetPointState(side, PointState.Advantage);
                        return;
                    }

                    sideOnePoints = PointState.Deuce;
                    sideTwoPoints = PointState.Deuce;
                    return;
                }

                RollPoints(side);

                if (((int)GetPointState(side)) > 4)
                {
                    this.state = DetermineWinner(side);
                }
            }
        }

 public Slot this[Side index]
 {
     // access to neighby slots on the index
     get {
         return slot.nearSlot[index];
     }
 }

        private async void MoveWindowOutOfScreen(Side side)
        {
            BaseWindow.Topmost = true;
            MoveOut?.Invoke(this, EventArgs.Empty);
            if (side == Side.Left)
            {
                for (var i = 0; i > -32; i--)
                {
                    await Task.Delay(1);
                    BaseWindow.Left = i * 10 + WpfScreen.MostLeftX;
                }
            }
            else
            {
                for (int i = 0; i < 32; i++)
                {
                    await Task.Delay(1);
                    BaseWindow.Left = WpfScreen.MostRightX - BaseWindow.Width + i * 10;
                }
            }

            _movedOut = true;
            BaseWindow.ShowInTaskbar = false;
            _movedOutSide = side;
            StartMagic();
        }

 public Position getPosition(Instrument instrument, Side orderMode)
 {
     IntPtr cPtr = ContextModulePINVOKE.NetPositions_getPosition(swigCPtr, Instrument.getCPtr(instrument), (int)orderMode);
     Position ret = (cPtr == IntPtr.Zero) ? null : new Position(cPtr, false);
     if (ContextModulePINVOKE.SWIGPendingException.Pending) throw ContextModulePINVOKE.SWIGPendingException.Retrieve();
     return ret;
 }

 public DbWords(int CardId, Side ListSide, WordType ListType, ParentClass parentClass)
 {
     id = CardId;
     side = ListSide;
     type = ListType;
     parent = parentClass;
 }

 static void ShowSidesInfo(Side[] sides)
 {
     foreach (var side in sides)
     {
         Console.WriteLine(side.Length);
     }
 }

        public bool getAveragePrice(MarketData md, int qty, Side side, int leg)
        {
            long tempPrice = 0;
            long tempQty = 0;
            for (int i = 0; i < 5; ++i)
            {
                long p = md.getPrice(side, i + 1);
                long q = md.getQty(side, i + 1);

                tempPrice += p * q;
                tempQty += q;

                if (tempQty >= qty)
                    break;
            }

            if (tempQty < qty)
            {
                if (leg == 1)
                    _data.avgPriceFirstLeg = 0;
                else
                    _data.avgPriceSecondLeg = 0;
                return false;
            }
            if (leg == 1)
                _data.avgPriceFirstLeg = (int)(tempPrice / tempQty);
            else
                _data.avgPriceSecondLeg = (int)(tempPrice / tempQty);

            return true;
        }

        /// <summary>
        /// Inicializa el Jugador a partir de su <see cref="Side"/>
        /// </summary>
        /// <param name="side"></param>
        public Jugador(Side side)
        {
            //Inicializamos las variables
            paddlePosition = new Point();
            paddlePositionPast = new Point();
            position = new Point();
            this.side = side;
            score = 0;

            //Creamos el puntero para ver donde se encuentra la mano del jugador
            mark = new Ellipse();
            mark.Width = Utilities.PLAYER_ELLIPSE_RADIUS;
            mark.Height = Utilities.PLAYER_ELLIPSE_RADIUS;

            //Creamos la barra del jugador
            shape = new Rectangle();
            shape.Width = Utilities.PADDLE_WIDTH;
            shape.Height = Utilities.PADDLE_HEIGHT; ;
            shape.Stroke = new SolidColorBrush(Colors.White);
            shape.StrokeThickness = 2;

            //Coloreamos según el jugador que sea
            switch (side) {
                case Side.Player1:
                mark.Fill = new SolidColorBrush(Utilities.PLAYER1_COLOR);
                shape.Fill = new SolidColorBrush(Utilities.PLAYER1_COLOR);
                break;
                case Side.Player2:
                mark.Fill = new SolidColorBrush(Utilities.PLAYER2_COLOR);
                shape.Fill = new SolidColorBrush(Utilities.PLAYER2_COLOR);
                break;
            }
            isConnected = false;
        }

 private void bt_right_Click(object sender, EventArgs e)
 {
     bt_left.Enabled = false;
     bt_right.Enabled = false;
     _Side = Side.Right;
     lb_status.Text = "Press space to save right point";
 }

 public void ChangeVisibility(Side side, Mode mode)
 {
     Transform sideObject = this.transform.FindChild(SidesNames [(int)side]);
     Mesh leftMesh, rightMesh, midMesh;
     switch (mode)
     {
         case Mode.Full:
             leftMesh =  fullMeshLeft;
             rightMesh = fullMeshRight;
             midMesh = fullMesh;
             break;
         case Mode.Half:
             leftMesh = halfMeshLeft;
             rightMesh = halfMeshRight;
             midMesh = halfMesh;
             break;
         case Mode.Empty:
             leftMesh = null;
             rightMesh = null;
             midMesh = emptyMesh;
             break;
         default:
             throw new ArgumentException();
     }
     sideObject.FindChild("LeftSide").GetComponent<MeshFilter>().sharedMesh= leftMesh;
     sideObject.FindChild("LeftSide").GetComponent<MeshCollider>().sharedMesh = leftMesh;
     sideObject.FindChild("RightSide").GetComponent<MeshFilter>().sharedMesh = rightMesh;
     sideObject.FindChild("RightSide").GetComponent<MeshCollider>().sharedMesh = rightMesh;
     sideObject.FindChild("Middle").GetComponent<MeshFilter>().sharedMesh = midMesh;
     sideObject.FindChild("Middle").GetComponent<MeshCollider>().sharedMesh = midMesh;
 }

 public bool GetSensor(Axis axis, Side side)
 {
     if (axis == Axis.X)
     {
         if (side == Side.POSITIVE && GetSensorValue(axis) >= thresholdX)
             return true;
         else if (side == Side.NEGATIVE && GetSensorValue(axis) <= -thresholdX)
             return true;
         else
             return false;
     }
     else if (axis == Axis.Y)
     {
         if (side == Side.POSITIVE && GetSensorValue(axis) >= thresholdY)
             return true;
         else if (side == Side.NEGATIVE && GetSensorValue(axis) <= -thresholdY)
             return true;
         else
             return false;
     }
     else if (axis == Axis.Z)
     {
         if (side == Side.POSITIVE && GetSensorValue(axis) >= thresholdZ)
             return true;
         else if (side == Side.NEGATIVE && GetSensorValue(axis) <= thresholdZ)
             return true;
         else
             return false;
     }
     else
         return false;
 }

        public Side side; // The side that it would be played on

        #endregion Fields

        #region Constructors

        public TurnOption(Dom inPlayed, Side inSide, List<Dom> inHand, List<int> inBoard)
        {
            played = inPlayed;
            side = inSide;
            hand = inHand;
            board = inBoard;
        }

 public Bishop(Position pos, Side side, ChessField chessfield)
     : base(pos, side, chessfield)
 {
     FigureType = FigureTypes.Bishop;
     movepolitics = new MovePolitics[] {
                                 chessfield.DiagMovePolitics};
 }

 public Knight(Position pos, Side side, ChessField chessfield)
     : base(pos, side, chessfield)
 {
     FigureType = FigureTypes.Knight;
     movepolitics = new MovePolitics[] {
                                 chessfield.KnightMovePolitics};
 }