public ConfigureEvent(int id, MachineId[] servers, MachineId manager)
     : base()
 {
     this.Id = id;
     this.Servers = servers;
     this.ClusterManager = manager;
 }

 /// <summary>
 /// Constructor.
 /// </summary>
 /// <param name="senderMachineId">Sender machine id</param>
 /// <param name="senderMachineName">Sender machine name</param>
 /// <param name="senderStateName">Sender state name</param>
 internal EventOriginInfo(MachineId senderMachineId, string senderMachineName,
     string senderStateName)
 {
     this.SenderMachineId = senderMachineId;
     this.SenderMachineName = senderMachineName;
     this.SenderStateName = senderStateName;
 }

 public ConfigureEvent(MachineId env, MachineId manager, int id)
     : base()
 {
     this.Environment = env;
     this.NodeManager = manager;
     this.Id = id;
 }

 public SentLog(int nextSeqId, MachineId client, int key, int val)
 {
     this.NextSeqId = nextSeqId;
     this.Client = client;
     this.Key = key;
     this.Value = val;
 }

 public Config(List<MachineId> servers, MachineId parentServer, int myRank)
     : base(-1, -1)
 {
     this.Servers = servers;
     this.ParentServer = parentServer;
     this.MyRank = myRank;
 }

 public Prepare(MachineId id, int nextSlot, Tuple<int, int> nextProposal, int myRank)
     : base(-1, -1)
 {
     this.Node = id;
     this.NextSlotForProposer = nextSlot;
     this.NextProposal = nextProposal;
     this.MyRank = myRank;
 }

            public int LastLogTerm; // term of candidate’s last log entry

            public VoteRequest(int term, MachineId candidateId, int lastLogIndex, int lastLogTerm)
                : base()
            {
                this.Term = term;
                this.CandidateId = candidateId;
                this.LastLogIndex = lastLogIndex;
                this.LastLogTerm = lastLogTerm;
            }

 public monitor_valueChosen(MachineId id, int nextSlot, Tuple<int, int> nextProposal, int proposeVal)
     : base(-1, -1)
 {
     this.Node = id;
     this.NextSlotForProposer = nextSlot;
     this.NextProposal = nextProposal;
     this.ProposeVal = proposeVal;
 }

            public MachineId ReceiverEndpoint; // client

            public AppendEntriesRequest(int term, MachineId leaderId, int prevLogIndex,
                int prevLogTerm, List<Log> entries, int leaderCommit, MachineId client)
                : base()
            {
                this.Term = term;
                this.LeaderId = leaderId;
                this.PrevLogIndex = prevLogIndex;
                this.PrevLogTerm = prevLogTerm;
                this.Entries = entries;
                this.LeaderCommit = leaderCommit;
                this.ReceiverEndpoint = client;
            }

        void InitOnEntry()
        {
            this.Servers = (this.Payload as object[])[0] as List<MachineId>;
            this.ParentServer = (this.Payload as object[])[1] as MachineId;
            this.MyRank = (int)(this.Payload as object[])[2];

            this.CurrentLeader = Tuple.Create(this.MyRank, this.Id);

            this.CommunicateLeaderTimeout = this.CreateMachine(typeof(Timer), this.Id, 100);
            this.BroadCastTimeout = this.CreateMachine(typeof(Timer), this.Id, 10);

            this.Raise(new local());
        }

        void InitOnEntry()
        {
            this.PaxosNodes = new List<MachineId>();

            this.PaxosNodes.Insert(0, this.CreateMachine(typeof(PaxosNode), 3));
            this.PaxosNodes.Insert(0, this.CreateMachine(typeof(PaxosNode), 2));
            this.PaxosNodes.Insert(0, this.CreateMachine(typeof(PaxosNode), 1));

            foreach (var node in this.PaxosNodes)
            {
                this.Send(node, new allNodes(), this.PaxosNodes);
            }

            this.Client = this.CreateMachine(typeof(Client), this.PaxosNodes);
        }

		void Configure()
        {
            this.Environment = (this.ReceivedEvent as Events.NodeManagerConfigEvent).env_id;
            this.DataNodeMachines = new List<MachineId>();

            for (int idx = 0; idx < 3; idx++)
            {
                this.DataNodeMachines.Add(this.CreateMachine(typeof(DataNodeMachine)));
            }
            
            this.NodeManager = new NodeManagerWrapper(this.DataNodeMachines);

            this.Send(this.Environment, new Events.ConfigAckEvent(this.DataNodeMachines));
            this.Raise(new Events.UnitEvent());
        }

        void EntryOnInit()
        {
            this.NumberOfServers = 5;
            this.LeaderTerm = 0;

            this.Servers = new MachineId[this.NumberOfServers];

            for (int idx = 0; idx < this.NumberOfServers; idx++)
            {
                this.Servers[idx] = this.CreateMachine(typeof(Server));
            }

            this.Client = this.CreateMachine(typeof(Client));

            this.Raise(new LocalEvent());
        }

        void EntryOnInit()
        {
            this.NumberOfReplicas = 3;
            this.NumberOfFaults = 1;
            this.AliveNodes = new List<MachineId>();

            this.Monitor<LivenessMonitor>(new LivenessMonitor.ConfigureEvent(this.NumberOfReplicas));

            this.NodeManager = this.CreateMachine(typeof(NodeManager));
            this.Client = this.CreateMachine(typeof(Client));

            this.FailureTimer = this.CreateMachine(typeof(FailureTimer));
            this.Send(this.FailureTimer, new FailureTimer.ConfigureEvent(this.Id));

            this.Raise(new LocalEvent());
        }

        void Configure()
        {
            this.Nodes = new List<MachineId>();
            this.Clients = new Dictionary<MachineId, bool>();
            this.Alive = new Dictionary<MachineId, bool>();
            this.Responses = new Dictionary<MachineId, bool>();

            this.Nodes = (this.ReceivedEvent as Config).Nodes;
            foreach (var node in this.Nodes)
            {
                this.Alive.Add(node, true);
            }

            this.Timer = this.CreateMachine(typeof(Timer));
            this.Send(this.Timer, new Timer.Config(this.Id));

            this.Raise(new Unit());
        }

        void Configure()
        {
            this.NodeId = (this.ReceivedEvent as Config).Id;
            this.Keys = (this.ReceivedEvent as Config).Keys;
            this.Manager = (this.ReceivedEvent as Config).Manager;

            var nodes = (this.ReceivedEvent as Config).Nodes;
            var nodeIds = (this.ReceivedEvent as Config).NodeIds;

            this.NumOfIds = (int)Math.Pow(2, nodes.Count);

            for (var idx = 1; idx <= nodes.Count; idx++)
            {
                var start = (this.NodeId + (int)Math.Pow(2, (idx - 1))) % this.NumOfIds;
                var end = (this.NodeId + (int)Math.Pow(2, idx)) % this.NumOfIds;

                var nodeId = this.GetSuccessorNodeId(start, nodeIds);
                this.FingerTable.Add(start, new Finger(start, end, nodes[nodeId]));
            }

            for (var idx = 0; idx < nodeIds.Count; idx++)
            {
                if (nodeIds[idx] == this.NodeId)
                {
                    this.Predecessor = nodes[this.WrapSubtract(idx, 1, nodeIds.Count)];
                    break;
                }
            }

            this.Raise(new Local());
        }

        void InitOnEntry()
        {
            this.Bank = this.CreateMachine(typeof(Bank), new Bank.Config(this.Id));
            this.ATM = this.CreateMachine(typeof(ATM), new ATM.Config(this.Bank));

            this.Goto(typeof(Test1));
        }

        void DoHook()
        {
            var creature = (this.ReceivedEvent as Hook).Creature;
            var colour = (this.ReceivedEvent as Hook).Colour;

            if (this.TotalRendezvous == 0)
            {
                this.TotalStoppedCreatures++;
                this.DoPostRoundProcessing();
                return;
            }

            if (this.FirstHooker == null)
            {
                this.FirstHooker = creature;
                this.FirstColour = colour;
            }
            else
            {
                this.Send(this.FirstHooker, new Hook(creature, colour));
                this.Send(creature, new Hook(this.FirstHooker, this.FirstColour));
                this.FirstHooker = null;
                this.TotalRendezvous = this.TotalRendezvous - 1;
            }
        }

        void ProcessBecomeHead()
        {
            this.IsHead = true;
            this.Predecessor = this.Id;

            var target = (this.ReceivedEvent as ChainReplicationMaster.BecomeHead).Target;
            this.Send(target, new ChainReplicationMaster.HeadChanged());
        }

        void Configure()
        {
            this.ProcessId = (this.ReceivedEvent as Config).Id;
            this.RightProcess = (this.ReceivedEvent as Config).RightProcess;
            this.MaxProcessId = this.ProcessId;
            this.IsActive = true;

            this.Goto(typeof(Active));
        }