I can't figure why I'm getting a parsing error with my C# Code.

What is my parsing error on line 16? I can't figure out what is wrong with it, I know it's just staring me in the face but I just don't see it. Here is the the code, line 16 is the one with (public var gameName : String = "Example4";):

// Converted from UnityScript to C# at http://www.M2H.nl/files/js_to_c.php - by Mike Hergaarden
// Do test the code! You usually need to change a few small bits.

using UnityEngine;
using System.Collections;

public class target : MonoBehaviour {
/* 
*  This file is part of the Unity networking tutorial by M2H (http://www.M2H.nl)
*  The original author of this code is Mike Hergaarden, even though some small parts 
*  are copied from the Unity tutorials/manuals.
*  Feel free to use this code for your own projects, drop us a line if you made something exciting! 
*/

public var gameName : String = "Example4";
public var serverPort : int =  35001;

public HostData[] hostData;

private ConnectionTesterStatus natCapable = ConnectionTesterStatus.Undetermined;
public var filterNATHosts : boolean = false;
private var probingPublicIP : boolean = false;
private var doneTestingNAT : boolean = false;
private float timer = 0.0f;

private var hideTest : boolean = false;
private var testMessage : String= "Undetermined NAT capabilities";

private bool  tryingToConnectPlayNow = false;
public int tryingToConnectPlayNowNumber = 0;

private int[] remotePort = new int[3];
private string[] remoteIP = new string[3];
public string connectionInfo = "";

public bool  lastMSConnectionAttemptForcedNat= false;
private bool  NAToptionWasSwitchedForTesting = false;
private bool  officialNATstatus = Network.useNat;
public string errorMessage = "";
private float lastPlayNowConnectionTime;

public bool  nowConnecting = false;

void  Awake (){
    sortedHostList = new Array ();

    // Start connection test
    natCapable = Network.TestConnection();

    // What kind of IP does this machine have? TestConnection also indicates this in the
    // test results
    if (Network.HavePublicAddress()){
        Debug.Log("This machine has a public IP address");
    }else{
        Debug.Log("This machine has a private IP address");
    }   

    /* //If you dont want to use the Unity masterserver..
    Network.natFacilitatorIP = myMasterServerIP;
    Network.natFacilitatorPort = 11111;//Change this
    MasterServer.ipAddress = myMasterServerIP;
    MasterServer.port = 22222;//Change this
    Network.connectionTesterIP = myMasterServerIP;
    Network.connectionTesterPort = 33333;//Change this
    */

}

void  Start (){//must be in start because of coroutine

    yield return new WaitForSeconds(0.5f);
    int tries=0;
    while(tries<=10){       
        if(hostData && hostData.length>0){
            //Waiting for hostData
        }else{
            FetchHostList(true);
        }
        yield return new WaitForSeconds(0.5f);
        tries++;
    }
}

void  OnFailedToConnectToMasterServer ( NetworkConnectionError info  ){
    //Yikes
}

void  OnFailedToConnect ( NetworkConnectionError info  ){
    Debug.Log("FailedToConnect info:"+info);
    FailedConnRetry(info);      
}

void  Connect ( string ip ,   int port ,   bool usenat  ){
     // Enable NAT functionality based on what the hosts if configured to do
    Network.useNat = usenat;
    lastMSConnectionAttemptForcedNat = usenat;

    Debug.Log("Connecting to "+ip+":"+port+" NAT:"+usenat);
    Network.Connect(ip, port);      
    nowConnecting=true; 
}

//This second definition of Connect can handle the ip string[] passed by the masterserver
void  Connect ( string[] ip ,   int port ,   bool usenat  ){
     // Enable NAT functionality based on what the hosts if configured to do
    Network.useNat = usenat;
    lastMSConnectionAttemptForcedNat = usenat;

    Debug.Log("Connecting to "+ip[0]+":"+port+" NAT:"+usenat);
    Network.Connect(ip, port);      
    nowConnecting=true; 
}

void  StartHost ( int players ,   int port  ){
    if(players<=1){
        players=1;
    }
    //Network.InitializeSecurity();
    Network.InitializeServer(players, port);
}

void  OnConnectedToServer (){
    //Stop communication until in the game
    Network.isMessageQueueRunning = false;

    //Save these details so we can use it in the next scene
    PlayerPrefs.SetString("connectIP", Network.connections[0].ipAddress);
    PlayerPrefs.SetInt("connectPort", Network.connections[0].port);
}

void  FailedConnRetry ( NetworkConnectionError info  ){
    if(info == NetworkConnectionError.InvalidPassword){
        mayRetry=false;
    }

    nowConnecting=false;

    //Quickplay
    if(tryingToConnectPlayNow){
        //Try again without NAT if we used NAT
        if(mayRetry && Network.useNat && lastMSConnectionAttemptForcedNat){
            Debug.Log("Failed connect 1A: retry without NAT");

            remotePort[0]=serverPort;//Fall back to default server port
            Connect(remoteIP, remotePort[0], false);
            lastPlayNowConnectionTime=Time.time;
        }else{
            //We didn't use NAT and failed
            Debug.Log("Failed connect 1B: Don't retry");

            //Reset NAT to org. value
            Network.useNat=officialNATstatus;

            //Connect to next playnow/quickplay host
            tryingToConnectPlayNowNumber++;
            tryingToConnectPlayNow=false;
        }
    }else{
        //Direct connect or via host list manually
        connectionInfo="Failed to connect!";

        if(mayRetry && Network.useNat && lastMSConnectionAttemptForcedNat){
            //Since the last connect forced NAT usage,
            // let's try again without NAT.     
            Network.useNat=false;
            Network.Connect(remoteIP, remotePort[0]);
            nowConnecting=true;
            lastPlayNowConnectionTime=Time.time;

        }else{
            Debug.Log("Failed 2b");

            if(info == NetworkConnectionError.InvalidPassword){
                errorMessage="Failed to connect: Wrong password supplied";
            }else if(info == NetworkConnectionError.TooManyConnectedPlayers){
                errorMessage="Failed to connect: Server is full";
            }else{
                errorMessage="Failed to connect";
            }

            //reset to default port
            remotePort[0]=serverPort;

            //Reset nat to tested value
            Network.useNat=officialNATstatus;

        }
    }   
}

public float CONNECT_TIMEOUT = 0.75f;
public float CONNECT_NAT_TIMEOUT = 5.00f;

//Our quickplay function: Go trough the gameslist and try to connect to all games
void  PlayNow ( float timeStarted   ){

        int i=0;

        foreach(var myElement in sortedHostList)
        {
            var element : int = hostData[myElement];

            // Do not try NAT enabled games if we cannot do NAT punchthrough
            // Do not try connecting to password protected games
            if ( !(filterNATHosts && element.useNat) && !element.passwordProtected  )
            {
                aHost=1;

                if(element.connectedPlayers<element.playerLimit)
                {                   
                    if(tryingToConnectPlayNow){
                        var natText;
                        if(Network.useNat){
                            natText=" with option 1/2";
                        }else{
                            natText=" with option 2/2";
                        }
                        if((!Network.useNat && lastPlayNowConnectionTime+CONNECT_TIMEOUT<=Time.time) || (Network.useNat  && lastPlayNowConnectionTime+CONNECT_NAT_TIMEOUT<=Time.time)){
                            Debug.Log("Interrupted by timer, NAT:"+Network.useNat);
                            FailedConnRetry(NetworkConnectionError.ConnectionFailed);                           
                        }
                        return "Trying to connect to host "+(tryingToConnectPlayNowNumber+1)+"/"+sortedHostList.length+" "+natText; 
                    }       
                    if(!tryingToConnectPlayNow && tryingToConnectPlayNowNumber<=i){
                        Debug.Log("Trying to connect to game NR "+i+" & "+tryingToConnectPlayNowNumber);
                        tryingToConnectPlayNow=true;
                        tryingToConnectPlayNowNumber=i;

                        // Enable NAT functionality based on what the hosts if configured to do
                        lastMSConnectionAttemptForcedNat=element.useNat;
                        Network.useNat = element.useNat;
                        int connectPort=element.port;
                        if (Network.useNat){
                            print("Using Nat punchthrough to connect");
                        }else{
                            //connectPort=serverPort; //bad idea!
                            print("Connecting directly to host");
                        }
                        Debug.Log("connecting to "+element.gameName+" "+element.ip+":"+connectPort);
                        Network.Connect(element.ip, connectPort);   
                        lastPlayNowConnectionTime=Time.time;
                    }
                    i++;        
                }
            }           
        }

        //If we reach this point then either we've parsed the whole list OR the list is still empty

        //Dont give up yet: Give MS 7 seconds to feed the list
        if(Time.time<timeStarted+7){
            FetchHostList(true);    
            return "Waiting for masterserver..."+Mathf.Ceil((timeStarted+7)-Time.time); 
        }

        if(!tryingToConnectPlayNow){
            return "failed";
        }

}

void  Update (){
    // If network test is undetermined, keep running
    if (!doneTestingNAT) {
        TestConnection();
    }
}

void  TestConnection (){
    // Start/Poll the connection test, report the results in a label and react to the results accordingly
    natCapable = Network.TestConnection();
    switch (natCapable) {
        case ConnectionTesterStatus.Error: 
            testMessage = "Problem determining NAT capabilities";
            doneTestingNAT = true;
            break;

        case ConnectionTesterStatus.Undetermined: 
            testMessage = "Undetermined NAT capabilities";
            doneTestingNAT = false;
            break;

        case ConnectionTesterStatus.PrivateIPNoNATPunchthrough: 
            testMessage = "Cannot do NAT punchthrough, filtering NAT enabled hosts for client connections, local LAN games only.";
            filterNATHosts = true;
            Network.useNat = true;
            doneTestingNAT = true;
            break;

        case ConnectionTesterStatus.PrivateIPHasNATPunchThrough:
            if (probingPublicIP)
                testMessage = "Non-connectable public IP address (port "+ serverPort +" blocked), NAT punchthrough can circumvent the firewall.";
            else
                testMessage = "NAT punchthrough capable. Enabling NAT punchthrough functionality.";
            // NAT functionality is enabled in case a server is started,
            // clients should enable this based on if the host requires it
            Network.useNat = true;
            doneTestingNAT = true;
            break;

        case ConnectionTesterStatus.PublicIPIsConnectable:
            testMessage = "Directly connectable public IP address.";
            Network.useNat = false;
            doneTestingNAT = true;
            break;

        // This case is a bit special as we now need to check if we can 
        // cicrumvent the blocking by using NAT punchthrough
        case ConnectionTesterStatus.PublicIPPortBlocked:
            testMessage = "Non-connectble public IP address (port " + serverPort +" blocked), running a server is impossible.";
            Network.useNat = false;
            // If no NAT punchthrough test has been performed on this public IP, force a test
            if (!probingPublicIP)
            {
                Debug.Log("Testing if firewall can be circumnvented");
                natCapable = Network.TestConnectionNAT();
                probingPublicIP = true;
                timer = Time.time + 10;
            }
            // NAT punchthrough test was performed but we still get blocked
            else if (Time.time > timer)
            {
                probingPublicIP = false;        // reset
                Network.useNat = true;
                doneTestingNAT = true;
            }
            break;
        case ConnectionTesterStatus.PublicIPNoServerStarted:
            testMessage = "Public IP address but server not initialized, it must be started to check server accessibility. Restart connection test when ready.";
            break;
        default: 
            testMessage = "Error in test routine, got " + natCapable;
    }
    officialNATstatus=Network.useNat;
    if(doneTestingNAT){
        Debug.Log("TestConn:"+testMessage);
        Debug.Log("TestConn:"+natCapable + " " + probingPublicIP + " " + doneTestingNAT);
    }
}

private float lastHostListRequest = 0;

//Request the host limit, but we limit these requests
//Max once every two minutes automatically, max once every 5 seconds when manually requested
void  FetchHostList ( bool manual  ){
     int timeout = 120;
    if(manual){
        timeout=5;
    }

    if(lastHostListRequest==0 || Time.realtimeSinceStartup > lastHostListRequest + timeout){
            lastHostListRequest = Time.realtimeSinceStartup;
            MasterServer.RequestHostList (gameName);            
            yield return new WaitForSeconds(1);//We gotta wait :/           
            hostData = MasterServer.PollHostList();
            yield return new WaitForSeconds(1);//We gotta wait :/   
            CreateSortedArray();
            Debug.Log("Requested new host list, got: "+hostData.length);
    }

}

//The code below is all about sorting the game list by playeramount

public Array sortedHostList;

void  CreateSortedArray (){

    sortedHostList = new Array();   

    int i=0;
    HostData[] data = hostData;
    foreach(var element in data)
    {
        AddToArray(i);
        i++;        
    }           
}

void  AddToArray ( int nr  ){
    sortedHostList.Add (nr);    
    SortLastItem();
}

void  SortLastItem (){
    if(sortedHostList.length<=1){
        return;
    }
    for(var i = sortedHostList.length-1;i>0;i--){
    int value1= hostData[sortedHostList[i-1]].connectedPlayers;
    int value2 = hostData[sortedHostList*].connectedPlayers;*
 *if(value1<value2){*
 *SwapArrayItem((i-1), i);*
 *}else{*
 *//Sorted!*
 *return;*
 *}*
 *}*
*}*
*void  SwapArrayItem (nr1, nr2){*
 *var tmp=sortedHostList[nr1];*
 *sortedHostList[nr1]=sortedHostList[nr2];*
 *sortedHostList[nr2]=tmp;*
*}*
*}*
*```*

That's not how you declare variables in C#.

In JS it's like this

var VarName : VarType = whatever;

In C# it's like this

VarType VarName = whatever;

Also the type in C# is `bool` and not `boolean`.

More info here: http://answers.unity3d.com/questions/5507/what-are-the-syntax-differences-in-c-and-javascript