// Decompiled by Jad v1.5.7f. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   serverServer_Stub.java

package boggle.server.comms;

import boggle.server.player;
import java.io.*;
import java.rmi.*;
import java.rmi.server.*;

// Referenced classes of package boggle.server.comms:
//            serverInterface

public final class serverServer_Stub extends RemoteStub
    implements serverInterface, Remote
{

    public serverServer_Stub()
    {
    }

    public serverServer_Stub(RemoteRef remoteref)
    {
        super(remoteref);
    }

    public void addNewPlayer(String s, int i, player player)
        throws RemoteException
    {
        int j = 0;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, j, 0x1aa32c0d2d6f5acbL);
        try
        {
            ObjectOutput objectoutput = remotecall.getOutputStream();
            objectoutput.writeObject(s);
            objectoutput.writeInt(i);
            objectoutput.writeObject(player);
        }
        catch(IOException ioexception)
        {
            throw new MarshalException("Error marshaling arguments", ioexception);
        }
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        remoteref.done(remotecall);
    }

    public boolean attach(String s)
        throws RemoteException
    {
        int i = 1;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, i, 0x1aa32c0d2d6f5acbL);
        try
        {
            ObjectOutput objectoutput = remotecall.getOutputStream();
            objectoutput.writeObject(s);
        }
        catch(IOException ioexception)
        {
            throw new MarshalException("Error marshaling arguments", ioexception);
        }
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        boolean flag;
        try
        {
            ObjectInput objectinput = remotecall.getInputStream();
            flag = objectinput.readBoolean();
        }
        catch(IOException ioexception1)
        {
            throw new UnmarshalException("Error unmarshaling return", ioexception1);
        }
        catch(Exception exception2)
        {
            throw new UnexpectedException("Unexpected exception", exception2);
        }
        finally
        {
            remoteref.done(remotecall);
        }
        return flag;
    }

    public void broadcast(String s, String s1, int i)
        throws RemoteException
    {
        byte byte0 = 2;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            ObjectOutput objectoutput = remotecall.getOutputStream();
            objectoutput.writeObject(s);
            objectoutput.writeObject(s1);
            objectoutput.writeInt(i);
        }
        catch(IOException ioexception)
        {
            throw new MarshalException("Error marshaling arguments", ioexception);
        }
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        remoteref.done(remotecall);
    }

    public void changeServer(String s, String s1)
        throws RemoteException
    {
        byte byte0 = 3;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            ObjectOutput objectoutput = remotecall.getOutputStream();
            objectoutput.writeObject(s);
            objectoutput.writeObject(s1);
        }
        catch(IOException ioexception)
        {
            throw new MarshalException("Error marshaling arguments", ioexception);
        }
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        remoteref.done(remotecall);
    }

    public void finalscore(String s, int i, int j, int k)
        throws RemoteException
    {
        byte byte0 = 4;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            ObjectOutput objectoutput = remotecall.getOutputStream();
            objectoutput.writeObject(s);
            objectoutput.writeInt(i);
            objectoutput.writeInt(j);
            objectoutput.writeInt(k);
        }
        catch(IOException ioexception)
        {
            throw new MarshalException("Error marshaling arguments", ioexception);
        }
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        remoteref.done(remotecall);
    }

    public String[] getAlternateServers()
        throws RemoteException
    {
        byte byte0 = 5;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        String as[];
        try
        {
            ObjectInput objectinput = remotecall.getInputStream();
            as = (String[])objectinput.readObject();
        }
        catch(IOException ioexception)
        {
            throw new UnmarshalException("Error unmarshaling return", ioexception);
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new UnmarshalException("Return value class not found", classnotfoundexception);
        }
        catch(Exception exception2)
        {
            throw new UnexpectedException("Unexpected exception", exception2);
        }
        finally
        {
            remoteref.done(remotecall);
        }
        return as;
    }

    public String[] getGameDefinitions()
        throws RemoteException
    {
        byte byte0 = 6;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        String as[];
        try
        {
            ObjectInput objectinput = remotecall.getInputStream();
            as = (String[])objectinput.readObject();
        }
        catch(IOException ioexception)
        {
            throw new UnmarshalException("Error unmarshaling return", ioexception);
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new UnmarshalException("Return value class not found", classnotfoundexception);
        }
        catch(Exception exception2)
        {
            throw new UnexpectedException("Unexpected exception", exception2);
        }
        finally
        {
            remoteref.done(remotecall);
        }
        return as;
    }

    public String[] getGameDescriptions()
        throws RemoteException
    {
        byte byte0 = 7;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        String as[];
        try
        {
            ObjectInput objectinput = remotecall.getInputStream();
            as = (String[])objectinput.readObject();
        }
        catch(IOException ioexception)
        {
            throw new UnmarshalException("Error unmarshaling return", ioexception);
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new UnmarshalException("Return value class not found", classnotfoundexception);
        }
        catch(Exception exception2)
        {
            throw new UnexpectedException("Unexpected exception", exception2);
        }
        finally
        {
            remoteref.done(remotecall);
        }
        return as;
    }

    public int[] getGameLanguageList()
        throws RemoteException
    {
        byte byte0 = 8;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        int ai[];
        try
        {
            ObjectInput objectinput = remotecall.getInputStream();
            ai = (int[])objectinput.readObject();
        }
        catch(IOException ioexception)
        {
            throw new UnmarshalException("Error unmarshaling return", ioexception);
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new UnmarshalException("Return value class not found", classnotfoundexception);
        }
        catch(Exception exception2)
        {
            throw new UnexpectedException("Unexpected exception", exception2);
        }
        finally
        {
            remoteref.done(remotecall);
        }
        return ai;
    }

    public String[] getGameNames()
        throws RemoteException
    {
        byte byte0 = 9;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        String as[];
        try
        {
            ObjectInput objectinput = remotecall.getInputStream();
            as = (String[])objectinput.readObject();
        }
        catch(IOException ioexception)
        {
            throw new UnmarshalException("Error unmarshaling return", ioexception);
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new UnmarshalException("Return value class not found", classnotfoundexception);
        }
        catch(Exception exception2)
        {
            throw new UnexpectedException("Unexpected exception", exception2);
        }
        finally
        {
            remoteref.done(remotecall);
        }
        return as;
    }

    public int[] getGameTypeList()
        throws RemoteException
    {
        byte byte0 = 10;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        int ai[];
        try
        {
            ObjectInput objectinput = remotecall.getInputStream();
            ai = (int[])objectinput.readObject();
        }
        catch(IOException ioexception)
        {
            throw new UnmarshalException("Error unmarshaling return", ioexception);
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new UnmarshalException("Return value class not found", classnotfoundexception);
        }
        catch(Exception exception2)
        {
            throw new UnexpectedException("Unexpected exception", exception2);
        }
        finally
        {
            remoteref.done(remotecall);
        }
        return ai;
    }

    public String[] getLanguages()
        throws RemoteException
    {
        byte byte0 = 11;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        String as[];
        try
        {
            ObjectInput objectinput = remotecall.getInputStream();
            as = (String[])objectinput.readObject();
        }
        catch(IOException ioexception)
        {
            throw new UnmarshalException("Error unmarshaling return", ioexception);
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new UnmarshalException("Return value class not found", classnotfoundexception);
        }
        catch(Exception exception2)
        {
            throw new UnexpectedException("Unexpected exception", exception2);
        }
        finally
        {
            remoteref.done(remotecall);
        }
        return as;
    }

    public int[] getLoggedInList()
        throws RemoteException
    {
        byte byte0 = 12;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        int ai[];
        try
        {
            ObjectInput objectinput = remotecall.getInputStream();
            ai = (int[])objectinput.readObject();
        }
        catch(IOException ioexception)
        {
            throw new UnmarshalException("Error unmarshaling return", ioexception);
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new UnmarshalException("Return value class not found", classnotfoundexception);
        }
        catch(Exception exception2)
        {
            throw new UnexpectedException("Unexpected exception", exception2);
        }
        finally
        {
            remoteref.done(remotecall);
        }
        return ai;
    }

    public player[] getPlayerList()
        throws RemoteException
    {
        byte byte0 = 13;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        player aplayer[];
        try
        {
            ObjectInput objectinput = remotecall.getInputStream();
            aplayer = (player[])objectinput.readObject();
        }
        catch(IOException ioexception)
        {
            throw new UnmarshalException("Error unmarshaling return", ioexception);
        }
        catch(ClassNotFoundException classnotfoundexception)
        {
            throw new UnmarshalException("Return value class not found", classnotfoundexception);
        }
        catch(Exception exception2)
        {
            throw new UnexpectedException("Unexpected exception", exception2);
        }
        finally
        {
            remoteref.done(remotecall);
        }
        return aplayer;
    }

    public void joingame(String s, int i, int j)
        throws RemoteException
    {
        byte byte0 = 14;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            ObjectOutput objectoutput = remotecall.getOutputStream();
            objectoutput.writeObject(s);
            objectoutput.writeInt(i);
            objectoutput.writeInt(j);
        }
        catch(IOException ioexception)
        {
            throw new MarshalException("Error marshaling arguments", ioexception);
        }
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        remoteref.done(remotecall);
    }

    public void login(String s, int i, int j)
        throws RemoteException
    {
        byte byte0 = 15;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            ObjectOutput objectoutput = remotecall.getOutputStream();
            objectoutput.writeObject(s);
            objectoutput.writeInt(i);
            objectoutput.writeInt(j);
        }
        catch(IOException ioexception)
        {
            throw new MarshalException("Error marshaling arguments", ioexception);
        }
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        remoteref.done(remotecall);
    }

    public void logout(String s, int i)
        throws RemoteException
    {
        byte byte0 = 16;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            ObjectOutput objectoutput = remotecall.getOutputStream();
            objectoutput.writeObject(s);
            objectoutput.writeInt(i);
        }
        catch(IOException ioexception)
        {
            throw new MarshalException("Error marshaling arguments", ioexception);
        }
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        remoteref.done(remotecall);
    }

    public void newgame(String s, int i, String s1, String s2, int j, int k)
        throws RemoteException
    {
        byte byte0 = 17;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            ObjectOutput objectoutput = remotecall.getOutputStream();
            objectoutput.writeObject(s);
            objectoutput.writeInt(i);
            objectoutput.writeObject(s1);
            objectoutput.writeObject(s2);
            objectoutput.writeInt(j);
            objectoutput.writeInt(k);
        }
        catch(IOException ioexception)
        {
            throw new MarshalException("Error marshaling arguments", ioexception);
        }
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        remoteref.done(remotecall);
    }

    public void takeOver(String s, String as[])
        throws RemoteException
    {
        byte byte0 = 18;
        RemoteRef remoteref = ref;
        RemoteCall remotecall = remoteref.newCall(this, operations, byte0, 0x1aa32c0d2d6f5acbL);
        try
        {
            ObjectOutput objectoutput = remotecall.getOutputStream();
            objectoutput.writeObject(s);
            objectoutput.writeObject(as);
        }
        catch(IOException ioexception)
        {
            throw new MarshalException("Error marshaling arguments", ioexception);
        }
        try
        {
            remoteref.invoke(remotecall);
        }
        catch(RemoteException remoteexception)
        {
            throw remoteexception;
        }
        catch(Exception exception)
        {
            throw new UnexpectedException("Unexpected exception", exception);
        }
        remoteref.done(remotecall);
    }

    private static Operation operations[] = {
        new Operation("void addNewPlayer(java.lang.String, int, boggle.server.player)"), new Operation("boolean attach(java.lang.String)"), new Operation("void broadcast(java.lang.String, java.lang.String, int)"), new Operation("void changeServer(java.lang.String, java.lang.String)"), new Operation("void finalscore(java.lang.String, int, int, int)"), new Operation("java.lang.String getAlternateServers()[]"), new Operation("java.lang.String getGameDefinitions()[]"), new Operation("java.lang.String getGameDescriptions()[]"), new Operation("int getGameLanguageList()[]"), new Operation("java.lang.String getGameNames()[]"), 
        new Operation("int getGameTypeList()[]"), new Operation("java.lang.String getLanguages()[]"), new Operation("int getLoggedInList()[]"), new Operation("boggle.server.player getPlayerList()[]"), new Operation("void joingame(java.lang.String, int, int)"), new Operation("void login(java.lang.String, int, int)"), new Operation("void logout(java.lang.String, int)"), new Operation("void newgame(java.lang.String, int, java.lang.String, java.lang.String, int, int)"), new Operation("void takeOver(java.lang.String, java.lang.String[])")
    };
    private static final long interfaceHash = 0x1aa32c0d2d6f5acbL;

}