protected internal override void ReceiveTransition(Management_ReceiveFSMContext context, SetEmergency msg, Receive.Body.ReceiveRec transportData)
                {
                    Management_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Shutdown.ReceiveTransition(, SetEmergency msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                    Management_ReceiveFSMState endState = context.State;

                    context.ClearState();

                    try
                    {
                        ctxt.StoreIDAction(transportData);
                        ctxt.processNotifications("Receiving_Ready_NotControlled_NotAvailable_Emergency", null);
                    }
                    finally
                    {
                        context.State = endState;
                        context.PushState(Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Emergency);
                        context.State.Entry(context);
                    }

                    return;
                }
                protected internal override void InternalStateChange_To_Management_ReceiveFSM_Receiving_Ready_NotControlled_NotAvailable_InitTransition(Management_ReceiveFSMContext context, InternalEvent ie)
                {
                    Management_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Shutdown.InternalStateChange_To_Management_ReceiveFSM_Receiving_Ready_NotControlled_NotAvailable_InitTransition(, InternalEvent ie)");
                    #endif

                    context.State.Exit(context);
                    context.ClearState();

                    try
                    {
                        ctxt.initializeAction();
                        ctxt.processNotifications("Receiving_Ready_NotControlled_NotAvailable_Init", ie);
                    }
                    finally
                    {
                        context.State = Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Init;
                        context.State.Entry(context);
                    }

                    return;
                }
                protected internal override void ReceiveTransition(Management_ReceiveFSMContext context, QueryStatus msg, Receive.Body.ReceiveRec transportData)
                {
                    Management_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Shutdown.ReceiveTransition(, QueryStatus msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                        Management_ReceiveFSMState endState = context.State;

                        context.ClearState();

                        try
                        {
                        ctxt.SendAction("ReportStatus", transportData);
                        }
                        finally
                        {
                            context.State = endState;
                        }

                    return;
                }
                protected internal override void FailureTransition(Management_ReceiveFSMContext context)
                {
                    Management_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Shutdown.FailureTransition()");
                    #endif

                    context.State.Exit(context);
                        context.ClearState();

                        try
                        {
                        ctxt.processNotifications("Receiving_Ready_NotControlled_NotAvailable_Failure", null);
                        }
                        finally
                        {
                        context.State = Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Failure;
                        context.State.Entry(context);
                        }

                    return;
                }
                protected internal override void ReceiveTransition(Management_ReceiveFSMContext context, RequestControl msg, Receive.Body.ReceiveRec transportData)
                {
                    Management_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Emergency.ReceiveTransition(, RequestControl msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                        Management_ReceiveFSMState endState = context.State;

                        context.ClearState();

                        try
                        {
                        ctxt.SendAction("ConfirmControl", "NOT_AVAILABLE", transportData);
                        }
                        finally
                        {
                            context.State = endState;
                        }

                    return;
                }
                protected internal override void ReceiveTransition(Management_ReceiveFSMContext context, ClearEmergency msg, Receive.Body.ReceiveRec transportData)
                {
                    Management_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Emergency.ReceiveTransition(, ClearEmergency msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                    if (ctxt.isIDStored( transportData ))
                    {

                        context.State.Exit(context);
                    context.ClearState();

                    try
                    {
                            ctxt.popWrapper_367bc5868aa53b23a6c5a07701058fbf(msg, transportData);
                            ctxt.processNotifications(context.peakTopStateStack(), null);
                    }
                    finally
                    {
                            context.PopState();
                    }

                    }
                    else                    {
                        base.ReceiveTransition(context, msg, transportData);
                    }

                    return;
                }
                protected internal override void ReceiveTransition(Management_ReceiveFSMContext context, Shutdown msg, Receive.Body.ReceiveRec transportData)
                {
                    Management_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_Controlled_NotAvailable_Emergency.ReceiveTransition(, Shutdown msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                    if (ctxt.isControllingClient( transportData ))
                    {

                        context.State.Exit(context);
                        context.ClearState();

                        try
                        {
                            ctxt.SendAction("RejectControl", "CONTROL_RELEASED", transportData);
                            ctxt.processNotifications("Receiving_Ready_NotControlled_NotAvailable_Shutdown", null);
                        }
                        finally
                        {
                            context.State = Management_ReceiveFSM_SM.Receiving_Ready_NotControlled_NotAvailable_Shutdown;
                            context.State.Entry(context);
                        }

                    }
                    else                    {
                        base.ReceiveTransition(context, msg, transportData);
                    }

                    return;
                }
                protected internal override void ReceiveTransition(Management_ReceiveFSMContext context, Resume msg, Receive.Body.ReceiveRec transportData)
                {
                    Management_ReceiveFSM ctxt = context.Owner;

                    #if TRACE
                    Trace.WriteLine(
                        "TRANSITION   : Management_ReceiveFSM_SM.Receiving_Ready_Controlled_Available_Standby.ReceiveTransition(, Resume msg, Receive.Body.ReceiveRec transportData)");
                    #endif

                    if (ctxt.isControllingClient( transportData ))
                    {

                        context.State.Exit(context);
                        context.ClearState();

                        try
                        {
                            ctxt.processNotifications("Receiving_Ready_Controlled_Available_Ready", null);
                        }
                        finally
                        {
                            context.State = Management_ReceiveFSM_SM.Receiving_Ready_Controlled_Available_Ready;
                            context.State.Entry(context);
                        }

                    }
                    else                    {
                        base.ReceiveTransition(context, msg, transportData);
                    }

                    return;
                }