LXR 6.1/​testsuites/​validation/​tc-task-restart.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:52

 /* SPDX-License-Identifier: BSD-2-Clause */
 
 /**
  * @file
  *
  * @ingroup RtemsTaskReqRestart
  */
 
 /*
  * Copyright (C) 2021 embedded brains GmbH & Co. KG
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
 /*
  * This file is part of the RTEMS quality process and was automatically
  * generated.  If you find something that needs to be fixed or
  * worded better please post a report or patch to an RTEMS mailing list
  * or raise a bug report:
  *
  * https://www.rtems.org/bugs.html
  *
  * For information on updating and regenerating please refer to the How-To
  * section in the Software Requirements Engineering chapter of the
  * RTEMS Software Engineering manual.  The manual is provided as a part of
  * a release.  For development sources please refer to the online
  * documentation at:
  *
  * https://docs.rtems.org
  */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
 #include <limits.h>
 #include <rtems.h>
 #include <setjmp.h>
 #include <rtems/test-scheduler.h>
 #include <rtems/score/statesimpl.h>
 #include <rtems/score/threaddispatch.h>
 #include <rtems/score/threadimpl.h>
 
 #include "tx-support.h"
 
 #include <rtems/test.h>
 
 /**
  * @defgroup RtemsTaskReqRestart spec:/rtems/task/req/restart
  *
  * @ingroup TestsuitesValidationNoClock0
  *
  * @{
  */
 
 typedef enum {
   RtemsTaskReqRestart_Pre_Id_Invalid,
   RtemsTaskReqRestart_Pre_Id_Executing,
   RtemsTaskReqRestart_Pre_Id_Other,
   RtemsTaskReqRestart_Pre_Id_NA
 } RtemsTaskReqRestart_Pre_Id;
 
 typedef enum {
   RtemsTaskReqRestart_Pre_Dormant_Yes,
   RtemsTaskReqRestart_Pre_Dormant_No,
   RtemsTaskReqRestart_Pre_Dormant_NA
 } RtemsTaskReqRestart_Pre_Dormant;
 
 typedef enum {
   RtemsTaskReqRestart_Pre_Suspended_Yes,
   RtemsTaskReqRestart_Pre_Suspended_No,
   RtemsTaskReqRestart_Pre_Suspended_NA
 } RtemsTaskReqRestart_Pre_Suspended;
 
 typedef enum {
   RtemsTaskReqRestart_Pre_Restarting_Yes,
   RtemsTaskReqRestart_Pre_Restarting_No,
   RtemsTaskReqRestart_Pre_Restarting_NA
 } RtemsTaskReqRestart_Pre_Restarting;
 
 typedef enum {
   RtemsTaskReqRestart_Pre_Terminating_Yes,
   RtemsTaskReqRestart_Pre_Terminating_No,
   RtemsTaskReqRestart_Pre_Terminating_NA
 } RtemsTaskReqRestart_Pre_Terminating;
 
 typedef enum {
   RtemsTaskReqRestart_Pre_Protected_Yes,
   RtemsTaskReqRestart_Pre_Protected_No,
   RtemsTaskReqRestart_Pre_Protected_NA
 } RtemsTaskReqRestart_Pre_Protected;
 
 typedef enum {
   RtemsTaskReqRestart_Pre_Context_Task,
   RtemsTaskReqRestart_Pre_Context_Interrupt,
   RtemsTaskReqRestart_Pre_Context_NestedRequest,
   RtemsTaskReqRestart_Pre_Context_NA
 } RtemsTaskReqRestart_Pre_Context;
 
 typedef enum {
   RtemsTaskReqRestart_Pre_State_Ready,
   RtemsTaskReqRestart_Pre_State_Blocked,
   RtemsTaskReqRestart_Pre_State_Enqueued,
   RtemsTaskReqRestart_Pre_State_NA
 } RtemsTaskReqRestart_Pre_State;
 
 typedef enum {
   RtemsTaskReqRestart_Pre_Timer_Inactive,
   RtemsTaskReqRestart_Pre_Timer_Active,
   RtemsTaskReqRestart_Pre_Timer_NA
 } RtemsTaskReqRestart_Pre_Timer;
 
 typedef enum {
   RtemsTaskReqRestart_Pre_RealPriority_Initial,
   RtemsTaskReqRestart_Pre_RealPriority_Changed,
   RtemsTaskReqRestart_Pre_RealPriority_NA
 } RtemsTaskReqRestart_Pre_RealPriority;
 
 typedef enum {
   RtemsTaskReqRestart_Pre_ThreadDispatch_Disabled,
   RtemsTaskReqRestart_Pre_ThreadDispatch_Enabled,
   RtemsTaskReqRestart_Pre_ThreadDispatch_NA
 } RtemsTaskReqRestart_Pre_ThreadDispatch;
 
 typedef enum {
   RtemsTaskReqRestart_Post_Status_Ok,
   RtemsTaskReqRestart_Post_Status_InvId,
   RtemsTaskReqRestart_Post_Status_IncStat,
   RtemsTaskReqRestart_Post_Status_NoReturn,
   RtemsTaskReqRestart_Post_Status_NA
 } RtemsTaskReqRestart_Post_Status;
 
 typedef enum {
   RtemsTaskReqRestart_Post_FatalError_Yes,
   RtemsTaskReqRestart_Post_FatalError_Nop,
   RtemsTaskReqRestart_Post_FatalError_NA
 } RtemsTaskReqRestart_Post_FatalError;
 
 typedef enum {
   RtemsTaskReqRestart_Post_Argument_Set,
   RtemsTaskReqRestart_Post_Argument_Nop,
   RtemsTaskReqRestart_Post_Argument_NA
 } RtemsTaskReqRestart_Post_Argument;
 
 typedef enum {
   RtemsTaskReqRestart_Post_State_Dormant,
   RtemsTaskReqRestart_Post_State_DormantSuspended,
   RtemsTaskReqRestart_Post_State_Blocked,
   RtemsTaskReqRestart_Post_State_Ready,
   RtemsTaskReqRestart_Post_State_Zombie,
   RtemsTaskReqRestart_Post_State_Nop,
   RtemsTaskReqRestart_Post_State_NA
 } RtemsTaskReqRestart_Post_State;
 
 typedef enum {
   RtemsTaskReqRestart_Post_Enqueued_Yes,
   RtemsTaskReqRestart_Post_Enqueued_No,
   RtemsTaskReqRestart_Post_Enqueued_NA
 } RtemsTaskReqRestart_Post_Enqueued;
 
 typedef enum {
   RtemsTaskReqRestart_Post_Timer_Active,
   RtemsTaskReqRestart_Post_Timer_Inactive,
   RtemsTaskReqRestart_Post_Timer_NA
 } RtemsTaskReqRestart_Post_Timer;
 
 typedef enum {
   RtemsTaskReqRestart_Post_Restarting_Yes,
   RtemsTaskReqRestart_Post_Restarting_No,
   RtemsTaskReqRestart_Post_Restarting_NA
 } RtemsTaskReqRestart_Post_Restarting;
 
 typedef enum {
   RtemsTaskReqRestart_Post_Terminating_Yes,
   RtemsTaskReqRestart_Post_Terminating_No,
   RtemsTaskReqRestart_Post_Terminating_NA
 } RtemsTaskReqRestart_Post_Terminating;
 
 typedef enum {
   RtemsTaskReqRestart_Post_Protected_Yes,
   RtemsTaskReqRestart_Post_Protected_No,
   RtemsTaskReqRestart_Post_Protected_NA
 } RtemsTaskReqRestart_Post_Protected;
 
 typedef enum {
   RtemsTaskReqRestart_Post_RestartExtensions_Yes,
   RtemsTaskReqRestart_Post_RestartExtensions_Nop,
   RtemsTaskReqRestart_Post_RestartExtensions_NA
 } RtemsTaskReqRestart_Post_RestartExtensions;
 
 typedef enum {
   RtemsTaskReqRestart_Post_TerminateExtensions_Yes,
   RtemsTaskReqRestart_Post_TerminateExtensions_Nop,
   RtemsTaskReqRestart_Post_TerminateExtensions_NA
 } RtemsTaskReqRestart_Post_TerminateExtensions;
 
 typedef struct {
   uint64_t Skip : 1;
   uint64_t Pre_Id_NA : 1;
   uint64_t Pre_Dormant_NA : 1;
   uint64_t Pre_Suspended_NA : 1;
   uint64_t Pre_Restarting_NA : 1;
   uint64_t Pre_Terminating_NA : 1;
   uint64_t Pre_Protected_NA : 1;
   uint64_t Pre_Context_NA : 1;
   uint64_t Pre_State_NA : 1;
   uint64_t Pre_Timer_NA : 1;
   uint64_t Pre_RealPriority_NA : 1;
   uint64_t Pre_ThreadDispatch_NA : 1;
   uint64_t Post_Status : 3;
   uint64_t Post_FatalError : 2;
   uint64_t Post_Argument : 2;
   uint64_t Post_State : 3;
   uint64_t Post_Enqueued : 2;
   uint64_t Post_Timer : 2;
   uint64_t Post_Restarting : 2;
   uint64_t Post_Terminating : 2;
   uint64_t Post_Protected : 2;
   uint64_t Post_RestartExtensions : 2;
   uint64_t Post_TerminateExtensions : 2;
 } RtemsTaskReqRestart_Entry;
 
 /**
  * @brief Test context for spec:/rtems/task/req/restart test case.
  */
 typedef struct {
   /**
    * @brief This member provides the scheduler operation records.
    */
   T_scheduler_log_10 scheduler_log;
 
   /**
    * @brief This member provides a jump context to resume a thread dispatch.
    */
   jmp_buf thread_dispatch_context;
 
   /**
    * @brief This member provides the context to wrap thread queue operations.
    */
   WrapThreadQueueContext wrap_tq_ctx;
 
   /**
    * @brief This member contains the identifier of the runner scheduler.
    */
   rtems_id scheduler_id;
 
   /**
    * @brief This member contains the identifier of the runner task.
    */
   rtems_id runner_id;
 
   /**
    * @brief This member contains the identifier of the mutex.
    */
   rtems_id mutex_id;
 
   /**
    * @brief This member provides an event set used to set up the blocking
    *   conditions of the task to restart.
    */
   rtems_event_set events;
 
   /**
    * @brief This member contains the identifier of the worker task.
    */
   rtems_id worker_id;
 
   /**
    * @brief This member references the TCB of the worker task.
    */
   rtems_tcb *worker_tcb;
 
   /**
    * @brief This member contains the worker state at the end of the
    *   rtems_task_restart() call.
    */
   States_Control worker_state;
 
   /**
    * @brief This member contains the worker thread life state at the end of the
    *   rtems_task_restart() call.
    */
   Thread_Life_state worker_life_state;
 
   /**
    * @brief This member contains the identifier of the deleter task.
    */
   rtems_id deleter_id;
 
   /**
    * @brief This member references the TCB of the deleter task.
    */
   rtems_tcb *deleter_tcb;
 
   /**
    * @brief This member contains the identifier of the test user extensions.
    */
   rtems_id extension_id;
 
   /**
    * @brief This member contains extension calls.
    */
   ExtensionCalls calls;
 
   /**
    * @brief This member contains extension calls after the rtems_task_restart()
    *   call.
    */
   ExtensionCalls calls_after_restart;
 
   /**
    * @brief This member contains the actual argument passed to the entry point.
    */
   rtems_task_argument actual_argument;
 
   /**
    * @brief This member contains the restart counter.
    */
   uint32_t restart_counter;
 
   /**
    * @brief If this member is true, then the worker shall be dormant before the
    *   rtems_task_restart() call.
    */
   bool dormant;
 
   /**
    * @brief If this member is true, then the worker shall be suspended before
    *   the rtems_task_restart() call.
    */
   bool suspended;
 
   /**
    * @brief If this member is true, then the thread life of the worker shall be
    *   protected before the rtems_task_restart() call.
    */
   bool protected;
 
   /**
    * @brief If this member is true, then the worker shall be restarting before
    *   the rtems_task_restart() call.
    */
   bool restarting;
 
   /**
    * @brief If this member is true, then the worker shall be terminating before
    *   the rtems_task_restart() call.
    */
   bool terminating;
 
   /**
    * @brief If this member is true, then the rtems_task_restart() shall be
    *   called from within interrupt context.
    */
   bool interrupt;
 
   /**
    * @brief If this member is true, then the rtems_task_restart() shall be
    *   called during another rtems_task_restart() call with the same task as a
    *   nested request.
    */
   bool nested_request;
 
   /**
    * @brief If this member is true, then the worker shall be blocked before the
    *   rtems_task_restart() call.
    */
   bool blocked;
 
   /**
    * @brief If this member is true, then the worker shall be enqueued on a wait
    *   queue before the rtems_task_restart() call.
    */
   bool enqueued;
 
   /**
    * @brief If this member is true, then the timer of the worker shall be
    *   active before the rtems_task_restart() call.
    */
   bool timer_active;
 
   /**
    * @brief If this member is true, then the real priority of the worker shall
    *   be equal to its initial priority before the rtems_task_restart() call.
    */
   bool real_priority_is_initial;
 
   /**
    * @brief If this member is true, then thread dispatching is disabled by the
    *   worker task before the rtems_task_restart() call.
    */
   bool dispatch_disabled;
 
   /**
    * @brief If this member is true, then it is expected to delete the worker.
    */
   bool delete_worker_expected;
 
   /**
    * @brief This member contains the return value of the rtems_task_restart()
    *   call.
    */
   rtems_status_code status;
 
   /**
    * @brief This member specifies if the ``id`` parameter value.
    */
   rtems_id id;
 
   struct {
     /**
      * @brief This member defines the pre-condition indices for the next
      *   action.
      */
     size_t pci[ 11 ];
 
     /**
      * @brief This member defines the pre-condition states for the next action.
      */
     size_t pcs[ 11 ];
 
     /**
      * @brief If this member is true, then the test action loop is executed.
      */
     bool in_action_loop;
 
     /**
      * @brief This member contains the next transition map index.
      */
     size_t index;
 
     /**
      * @brief This member contains the current transition map entry.
      */
     RtemsTaskReqRestart_Entry entry;
 
     /**
      * @brief If this member is true, then the current transition variant
      *   should be skipped.
      */
     bool skip;
   } Map;
 } RtemsTaskReqRestart_Context;
 
 static RtemsTaskReqRestart_Context
   RtemsTaskReqRestart_Instance;
 
 static const char * const RtemsTaskReqRestart_PreDesc_Id[] = {
   "Invalid",
   "Executing",
   "Other",
   "NA"
 };
 
 static const char * const RtemsTaskReqRestart_PreDesc_Dormant[] = {
   "Yes",
   "No",
   "NA"
 };
 
 static const char * const RtemsTaskReqRestart_PreDesc_Suspended[] = {
   "Yes",
   "No",
   "NA"
 };
 
 static const char * const RtemsTaskReqRestart_PreDesc_Restarting[] = {
   "Yes",
   "No",
   "NA"
 };
 
 static const char * const RtemsTaskReqRestart_PreDesc_Terminating[] = {
   "Yes",
   "No",
   "NA"
 };
 
 static const char * const RtemsTaskReqRestart_PreDesc_Protected[] = {
   "Yes",
   "No",
   "NA"
 };
 
 static const char * const RtemsTaskReqRestart_PreDesc_Context[] = {
   "Task",
   "Interrupt",
   "NestedRequest",
   "NA"
 };
 
 static const char * const RtemsTaskReqRestart_PreDesc_State[] = {
   "Ready",
   "Blocked",
   "Enqueued",
   "NA"
 };
 
 static const char * const RtemsTaskReqRestart_PreDesc_Timer[] = {
   "Inactive",
   "Active",
   "NA"
 };
 
 static const char * const RtemsTaskReqRestart_PreDesc_RealPriority[] = {
   "Initial",
   "Changed",
   "NA"
 };
 
 static const char * const RtemsTaskReqRestart_PreDesc_ThreadDispatch[] = {
   "Disabled",
   "Enabled",
   "NA"
 };
 
 static const char * const * const RtemsTaskReqRestart_PreDesc[] = {
   RtemsTaskReqRestart_PreDesc_Id,
   RtemsTaskReqRestart_PreDesc_Dormant,
   RtemsTaskReqRestart_PreDesc_Suspended,
   RtemsTaskReqRestart_PreDesc_Restarting,
   RtemsTaskReqRestart_PreDesc_Terminating,
   RtemsTaskReqRestart_PreDesc_Protected,
   RtemsTaskReqRestart_PreDesc_Context,
   RtemsTaskReqRestart_PreDesc_State,
   RtemsTaskReqRestart_PreDesc_Timer,
   RtemsTaskReqRestart_PreDesc_RealPriority,
   RtemsTaskReqRestart_PreDesc_ThreadDispatch,
   NULL
 };
 
 #if CPU_SIZEOF_POINTER > 4
 #define RESTART_ARGUMENT 0xfedcba0987654321U
 #else
 #define RESTART_ARGUMENT 0x87654321U
 #endif
 
 #define UNSET_ARGUMENT 1
 
 typedef RtemsTaskReqRestart_Context Context;
 
 static void PrepareRealPriority( Context *ctx )
 {
   if ( !ctx->real_priority_is_initial ) {
     SetScheduler( ctx->worker_id, ctx->scheduler_id, PRIO_LOW );
     SetPriority( ctx->worker_id, PRIO_NORMAL );
   }
 }
 
 static void CaptureWorkerState( Context *ctx )
 {
   T_scheduler_log *log;
 
   log = T_scheduler_record( NULL );
 
   if ( log != NULL ) {
     T_eq_ptr( &log->header, &ctx->scheduler_log.header );
 
     ctx->worker_state = ctx->worker_tcb->current_state;
     ctx->worker_life_state = ctx->worker_tcb->Life.state;
     CopyExtensionCalls( &ctx->calls, &ctx->calls_after_restart );
   }
 }
 
 static void VerifyTaskPreparation( const Context *ctx )
 {
   if ( ctx->id != INVALID_ID ) {
     States_Control state;
     Thread_Life_state life_state;
 
     state = STATES_READY;
     life_state = ctx->worker_tcb->Life.state;
 
     if ( ctx->suspended ) {
       state |= STATES_SUSPENDED;
     }
 
     if ( ctx->dormant ) {
       T_eq_int( life_state, 0 );
       state |= STATES_DORMANT;
     } else {
       T_eq( ctx->protected, ( life_state & THREAD_LIFE_PROTECTED ) != 0 );
       T_eq( ctx->restarting, ( life_state & THREAD_LIFE_RESTARTING ) != 0 );
       T_eq( ctx->terminating, ( life_state & THREAD_LIFE_TERMINATING ) != 0 );
 
       if ( ctx->blocked ) {
         if ( ctx->enqueued ) {
           state |= STATES_WAITING_FOR_MUTEX;
         } else {
           state |= STATES_WAITING_FOR_EVENT;
         }
       }
 
       if ( ctx->nested_request ) {
         state |= STATES_LIFE_IS_CHANGING;
       }
     }
 
     T_eq_u32( ctx->worker_tcb->current_state, state );
   }
 }
 
 static void Restart( void *arg )
 {
   Context         *ctx;
   T_scheduler_log *log;
 
   ctx = arg;
 
   if ( ctx->suspended && ctx->id != INVALID_ID ) {
     if ( ctx->id != RTEMS_SELF || ctx->interrupt ) {
       SuspendTask( ctx->worker_id );
     } else {
       Per_CPU_Control *cpu_self;
 
       /*
        * Where the system was built with SMP support enabled, a suspended
        * executing thread during the rtems_task_restart() call can happen
        * if the thread was suspended by another processor and the
        * inter-processor interrupt did not yet arrive.  Where the system was
        * built with SMP support disabled, this state cannot happen with the
        * current implementation.  However, we still specify and validate this
        * behaviour unconditionally since there exist alternative
        * implementations which would lead to such a state if the executing
        * thread is suspended by an ISR.
        */
       cpu_self = _Thread_Dispatch_disable();
       SuspendSelf();
       cpu_self->dispatch_necessary = false;
       _Thread_Dispatch_enable( cpu_self );
     }
   }
 
   if ( ctx->dispatch_disabled ) {
     _Thread_Dispatch_disable();
   }
 
   VerifyTaskPreparation( ctx );
   ClearExtensionCalls( &ctx->calls );
 
   log = T_scheduler_record_10( &ctx->scheduler_log );
   T_null( log );
 
   ctx->status = rtems_task_restart( ctx->id, RESTART_ARGUMENT );
 
   CaptureWorkerState( ctx );
 
   if ( ctx->dispatch_disabled ) {
     _Thread_Dispatch_enable( _Per_CPU_Get() );
   }
 }
 
 static void Block( Context *ctx )
 {
   rtems_interval ticks;
 
   if ( ctx->timer_active ) {
     ticks = UINT32_MAX;
   } else {
     ticks = RTEMS_NO_TIMEOUT;
   }
 
   if ( ctx->enqueued ) {
     ObtainMutexTimed( ctx->mutex_id, ticks );
   } else {
     /*
      * Do not use a stack variable for the event set, since we may jump out
      * of the directive call.
      */
     (void) rtems_event_receive(
       RTEMS_ALL_EVENTS,
       RTEMS_EVENT_ANY | RTEMS_WAIT,
       ticks,
       &ctx->events
     );
   }
 }
 
 static void BlockDone( const Context *ctx )
 {
   if ( ctx->enqueued ) {
     ReleaseMutex( ctx->mutex_id );
   }
 }
 
 static void Fatal(
   rtems_fatal_source source,
   rtems_fatal_code   code,
   void              *arg
 )
 {
   Context         *ctx;
   Per_CPU_Control *cpu_self;
 
   T_eq_int( source, INTERNAL_ERROR_CORE );
   T_eq_ulong( code, INTERNAL_ERROR_BAD_THREAD_DISPATCH_DISABLE_LEVEL );
 
   ctx = arg;
   ++ctx->calls.fatal;
   T_assert_eq_int( ctx->calls.fatal, 1 );
 
   CaptureWorkerState( ctx );
 
   _ISR_Set_level( 0 );
   cpu_self = _Per_CPU_Get();
   _Thread_Dispatch_unnest( cpu_self );
   _Thread_Dispatch_direct_no_return( cpu_self );
 }
 
 static void ResumeThreadDispatch(
   rtems_fatal_source source,
   rtems_fatal_code   code,
   void              *arg
 )
 {
   Context *ctx;
 
   T_eq_int( source, INTERNAL_ERROR_CORE );
   T_eq_ulong( code, INTERNAL_ERROR_BAD_THREAD_DISPATCH_DISABLE_LEVEL );
 
   ctx = arg;
   SetFatalHandler( Fatal, ctx );
   _ISR_Set_level( 0 );
   longjmp( ctx->thread_dispatch_context, 1 );
 }
 
 static void TriggerNestedRequestViaSelfRestart(
   Context         *ctx,
   Per_CPU_Control *cpu_self
 )
 {
   WrapThreadQueueExtract( &ctx->wrap_tq_ctx, ctx->worker_tcb );
   SetFatalHandler( ResumeThreadDispatch, ctx );
 
   if ( setjmp( ctx->thread_dispatch_context ) == 0 ) {
     (void) rtems_task_restart(
       RTEMS_SELF,
       (rtems_task_argument) ctx
     );
   } else {
     _Thread_Dispatch_unnest( cpu_self );
   }
 }
 
 static void Signal( rtems_signal_set signals )
 {
   Context *ctx;
 
   (void) signals;
   ctx = T_fixture_context();
 
   if ( ctx->id == RTEMS_SELF ) {
     Per_CPU_Control *cpu_self;
 
     SetPriority( ctx->runner_id, PRIO_VERY_LOW );
     SetPriority( ctx->deleter_id, PRIO_VERY_LOW );
 
     if ( ctx->interrupt || ctx->nested_request ) {
       if ( ctx->blocked ) {
         SetFatalHandler( ResumeThreadDispatch, ctx );
         cpu_self = _Thread_Dispatch_disable();
 
         if ( setjmp( ctx->thread_dispatch_context ) == 0 ) {
           Block( ctx );
         } else {
           _Thread_Dispatch_unnest( cpu_self );
         }
 
         if ( ctx->interrupt ) {
           CallWithinISR( Restart, ctx );
         } else {
           TriggerNestedRequestViaSelfRestart( ctx, cpu_self );
         }
 
         _Thread_Dispatch_direct( cpu_self );
         BlockDone( ctx );
       } else {
         if ( ctx->interrupt ) {
           CallWithinISR( Restart, ctx );
         } else {
           cpu_self = _Thread_Dispatch_disable();
           TriggerNestedRequestViaSelfRestart( ctx, cpu_self );
           _Thread_Dispatch_direct( cpu_self );
         }
       }
     } else {
       Restart( ctx );
     }
   } else {
     if ( ctx->blocked ) {
       Block( ctx );
       BlockDone( ctx );
     } else if ( ctx->nested_request ) {
       Yield();
     } else {
       SetPriority( ctx->runner_id, PRIO_VERY_HIGH );
     }
   }
 
   if ( ctx->protected ) {
     _Thread_Set_life_protection( 0 );
   }
 }
 
 static void Deleter( rtems_task_argument arg )
 {
   Context *ctx;
 
   ctx = (Context *) arg;
 
   if ( ctx != NULL ) {
     if ( ctx->real_priority_is_initial ) {
       /*
        * We have to prevent a potential priority boost in the task delete
        * below.
        */
       if ( ctx->nested_request ) {
         /* Lower the priority to PRIO_NORMAL without an * implicit yield */
         SetSelfPriorityNoYield( PRIO_NORMAL );
       } else {
         SetScheduler( ctx->worker_id, ctx->scheduler_id, PRIO_HIGH );
       }
     }
 
     if ( ctx->nested_request ) {
       WrapThreadQueueExtract( &ctx->wrap_tq_ctx, ctx->worker_tcb );
       DeleteTask( ctx->worker_id );
     } else {
       DeleteTask( ctx->worker_id );
     }
   }
 
   SuspendSelf();
 }
 
 static void Worker( rtems_task_argument arg )
 {
   Context          *ctx;
   rtems_status_code sc;
 
   ctx = T_fixture_context();
 
   if ( arg == 0 ) {
     sc = rtems_signal_catch( Signal, RTEMS_NO_ASR );
     T_rsc_success( sc );
 
     if ( ctx->protected ) {
       _Thread_Set_life_protection( THREAD_LIFE_PROTECTED );
     }
 
     Yield();
   } else {
     ctx->actual_argument = arg;
     ++ctx->restart_counter;
 
     CaptureWorkerState( ctx );
     SuspendSelf();
   }
 }
 
 static void ThreadDelete( rtems_tcb *executing, rtems_tcb *deleted )
 {
   Context *ctx;
 
   ctx = T_fixture_context();
   ++ctx->calls.thread_delete;
 
   T_eq_u32( executing->Object.id, ctx->runner_id );
 
   if ( ctx->delete_worker_expected ) {
     T_eq_u32( deleted->Object.id, ctx->worker_id );
   }
 }
 
 static void ThreadRestart( rtems_tcb *executing, rtems_tcb *restarted )
 {
   Context *ctx;
 
   ctx = T_fixture_context();
   ++ctx->calls.thread_restart;
 }
 
 static void ThreadTerminate( rtems_tcb *executing )
 {
   Context *ctx;
 
   ctx = T_fixture_context();
   ++ctx->calls.thread_terminate;
 
   T_eq_u32( executing->Object.id, ctx->worker_id );
 }
 
 static const rtems_extensions_table extensions = {
   .thread_delete = ThreadDelete,
   .thread_restart = ThreadRestart,
   .thread_terminate = ThreadTerminate
 };
 
 static void RtemsTaskReqRestart_Pre_Id_Prepare(
   RtemsTaskReqRestart_Context *ctx,
   RtemsTaskReqRestart_Pre_Id   state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Pre_Id_Invalid: {
       /*
        * While the ``id`` parameter is not associated with a task.
        */
       ctx->id = INVALID_ID;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Id_Executing: {
       /*
        * While the ``id`` parameter is associated with the calling task.
        */
       ctx->id = RTEMS_SELF;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Id_Other: {
       /*
        * While the ``id`` parameter is associated with a task other than the
        * calling task.
        */
       ctx->id = ctx->worker_id;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Id_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Pre_Dormant_Prepare(
   RtemsTaskReqRestart_Context    *ctx,
   RtemsTaskReqRestart_Pre_Dormant state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Pre_Dormant_Yes: {
       /*
        * While the task specified by the ``id`` parameter is dormant.
        */
       ctx->dormant = true;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Dormant_No: {
       /*
        * While the task specified by the ``id`` parameter is not dormant.
        */
       ctx->dormant = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Dormant_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Pre_Suspended_Prepare(
   RtemsTaskReqRestart_Context      *ctx,
   RtemsTaskReqRestart_Pre_Suspended state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Pre_Suspended_Yes: {
       /*
        * While the task specified by the ``id`` parameter is suspended.
        */
       ctx->suspended = true;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Suspended_No: {
       /*
        * While the task specified by the ``id`` parameter is not suspended.
        */
       ctx->suspended = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Suspended_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Pre_Restarting_Prepare(
   RtemsTaskReqRestart_Context       *ctx,
   RtemsTaskReqRestart_Pre_Restarting state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Pre_Restarting_Yes: {
       /*
        * While the task specified by the ``id`` parameter is restarting.
        */
       ctx->restarting = true;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Restarting_No: {
       /*
        * While the task specified by the ``id`` parameter is not restarting.
        */
       ctx->restarting = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Restarting_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Pre_Terminating_Prepare(
   RtemsTaskReqRestart_Context        *ctx,
   RtemsTaskReqRestart_Pre_Terminating state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Pre_Terminating_Yes: {
       /*
        * While the task specified by the ``id`` parameter is terminating.
        */
       ctx->terminating = true;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Terminating_No: {
       /*
        * While the task specified by the ``id`` parameter is not terminating.
        */
       ctx->terminating = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Terminating_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Pre_Protected_Prepare(
   RtemsTaskReqRestart_Context      *ctx,
   RtemsTaskReqRestart_Pre_Protected state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Pre_Protected_Yes: {
       /*
        * While thread life of the task specified by the ``id`` parameter is
        * protected.
        */
       ctx->protected = true;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Protected_No: {
       /*
        * While thread life of the task specified by the ``id`` parameter is not
        * protected.
        */
       ctx->protected = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Protected_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Pre_Context_Prepare(
   RtemsTaskReqRestart_Context    *ctx,
   RtemsTaskReqRestart_Pre_Context state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Pre_Context_Task: {
       /*
        * While the rtems_task_restart() directive is called from within task
        * context.
        */
       ctx->interrupt = false;
       ctx->nested_request = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Context_Interrupt: {
       /*
        * While the rtems_task_restart() directive is called from within
        * interrupt context.
        */
       ctx->interrupt = true;
       ctx->nested_request = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Context_NestedRequest: {
       /*
        * While the rtems_task_restart() directive is called during another
        * rtems_task_restart() call with the same task as a nested request.
        */
       ctx->interrupt = false;
       ctx->nested_request = true;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Context_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Pre_State_Prepare(
   RtemsTaskReqRestart_Context  *ctx,
   RtemsTaskReqRestart_Pre_State state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Pre_State_Ready: {
       /*
        * While the task specified by the ``id`` parameter is a ready task or
        * scheduled task.
        */
       ctx->blocked = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_State_Blocked: {
       /*
        * While the task specified by the ``id`` parameter is blocked.
        */
       ctx->blocked = true;
       ctx->enqueued = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_State_Enqueued: {
       /*
        * While the task specified by the ``id`` parameter is enqueued on a wait
        * queue.
        */
       ctx->blocked = true;
       ctx->enqueued = true;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_State_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Pre_Timer_Prepare(
   RtemsTaskReqRestart_Context  *ctx,
   RtemsTaskReqRestart_Pre_Timer state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Pre_Timer_Inactive: {
       /*
        * While timer of the task specified by the ``id`` parameter is inactive.
        */
       ctx->timer_active = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Timer_Active: {
       /*
        * While timer of the task specified by the ``id`` parameter is active.
        */
       ctx->timer_active = true;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_Timer_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Pre_RealPriority_Prepare(
   RtemsTaskReqRestart_Context         *ctx,
   RtemsTaskReqRestart_Pre_RealPriority state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Pre_RealPriority_Initial: {
       /*
        * While real priority of the task specified by the ``id`` parameter is
        * equal to the initial priority.
        */
       ctx->real_priority_is_initial = true;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_RealPriority_Changed: {
       /*
        * While real priority of the task specified by the ``id`` parameter is
        * not equal to the initial priority.
        */
       ctx->real_priority_is_initial = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_RealPriority_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Pre_ThreadDispatch_Prepare(
   RtemsTaskReqRestart_Context           *ctx,
   RtemsTaskReqRestart_Pre_ThreadDispatch state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Pre_ThreadDispatch_Disabled: {
       /*
        * While thread dispatching is disabled for the calling task.
        */
       ctx->dispatch_disabled = true;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_ThreadDispatch_Enabled: {
       /*
        * While thread dispatching is enabled for the calling task.
        */
       ctx->dispatch_disabled = false;
       break;
     }
 
     case RtemsTaskReqRestart_Pre_ThreadDispatch_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Post_Status_Check(
   RtemsTaskReqRestart_Context    *ctx,
   RtemsTaskReqRestart_Post_Status state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Post_Status_Ok: {
       /*
        * The return status of rtems_task_restart() shall be RTEMS_SUCCESSFUL.
        */
       T_rsc_success( ctx->status );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Status_InvId: {
       /*
        * The return status of rtems_task_restart() shall be RTEMS_INVALID_ID.
        */
       T_rsc( ctx->status, RTEMS_INVALID_ID );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Status_IncStat: {
       /*
        * The return status of rtems_task_restart() shall be
        * RTEMS_INCORRECT_STATE.
        */
       T_rsc( ctx->status, RTEMS_INCORRECT_STATE );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Status_NoReturn: {
       /*
        * The rtems_task_restart() call shall not return.
        */
       T_rsc( ctx->status, RTEMS_NOT_IMPLEMENTED );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Status_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Post_FatalError_Check(
   RtemsTaskReqRestart_Context        *ctx,
   RtemsTaskReqRestart_Post_FatalError state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Post_FatalError_Yes: {
       /*
        * The fatal error with a fatal source of INTERNAL_ERROR_CORE and a fatal
        * code of INTERNAL_ERROR_BAD_THREAD_DISPATCH_DISABLE_LEVEL shall occur
        * through the rtems_task_restart() call.
        */
       T_eq_u32( ctx->calls.fatal, 1 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_FatalError_Nop: {
       /*
        * No fatal error shall occur through the rtems_task_restart() call.
        */
       T_eq_u32( ctx->calls.fatal, 0 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_FatalError_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Post_Argument_Check(
   RtemsTaskReqRestart_Context      *ctx,
   RtemsTaskReqRestart_Post_Argument state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Post_Argument_Set: {
       /*
        * The entry point argument of the task specified by the ``id`` parameter
        * shall be set to the value specified by the ``argument`` parameter
        * before the task is unblocked by the rtems_task_restart() call.
        */
       if ( ctx->restart_counter != 0 ) {
         #if CPU_SIZEOF_POINTER > 4
         T_eq_u64( ctx->actual_argument, RESTART_ARGUMENT );
         #else
         T_eq_u32( ctx->actual_argument, RESTART_ARGUMENT );
         #endif
 
         T_eq_u32( ctx->restart_counter, 1 );
       } else {
         #if CPU_SIZEOF_POINTER > 4
         T_eq_u64(
           ctx->worker_tcb->Start.Entry.Kinds.Numeric.argument,
           RESTART_ARGUMENT
         );
         T_eq_u64( ctx->actual_argument, UNSET_ARGUMENT );
         #else
         T_eq_u32(
           ctx->worker_tcb->Start.Entry.Kinds.Numeric.argument,
           RESTART_ARGUMENT
         );
         T_eq_u32( ctx->actual_argument, UNSET_ARGUMENT );
         #endif
       }
       break;
     }
 
     case RtemsTaskReqRestart_Post_Argument_Nop: {
       /*
        * No entry point argument of a task shall be modified by the
        * rtems_task_restart() call.
        */
       T_eq_u32( ctx->actual_argument, UNSET_ARGUMENT );
       T_eq_u32( ctx->restart_counter, 0 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Argument_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Post_State_Check(
   RtemsTaskReqRestart_Context   *ctx,
   RtemsTaskReqRestart_Post_State state
 )
 {
   const T_scheduler_event *event;
   size_t                   index;
 
   index = 0;
 
   switch ( state ) {
     case RtemsTaskReqRestart_Post_State_Dormant: {
       /*
        * The state of the task specified by the ``id`` parameter shall be
        * dormant after the rtems_task_restart() call.
        */
       T_eq_u32( ctx->worker_state, STATES_DORMANT )
 
       event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
       T_eq_int( event->operation, T_SCHEDULER_NOP );
       break;
     }
 
     case RtemsTaskReqRestart_Post_State_DormantSuspended: {
       /*
        * The state of the task specified by the ``id`` parameter shall be
        * dormant and suspended after the rtems_task_restart() call.
        */
       T_eq_u32( ctx->worker_state, STATES_DORMANT | STATES_SUSPENDED )
 
       event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
       T_eq_int( event->operation, T_SCHEDULER_NOP );
       break;
     }
 
     case RtemsTaskReqRestart_Post_State_Blocked: {
       /*
        * The state of the task specified by the ``id`` parameter shall be
        * blocked after the rtems_task_restart() call.
        */
       T_ne_u32( ctx->worker_state & STATES_BLOCKED, 0 )
       T_eq_u32( ctx->worker_state & STATES_BLOCKED, ctx->worker_state )
 
       if ( ctx->suspended && !ctx->blocked ) {
         event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
         T_eq_int( event->operation, T_SCHEDULER_UNBLOCK );
         T_eq_ptr( event->thread, ctx->worker_tcb );
       }
 
       if ( !ctx->real_priority_is_initial && !ctx->terminating ) {
         event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
         T_eq_int( event->operation, T_SCHEDULER_UPDATE_PRIORITY );
         T_eq_ptr( event->thread, ctx->worker_tcb );
       }
 
       event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
       T_eq_int( event->operation, T_SCHEDULER_NOP );
       break;
     }
 
     case RtemsTaskReqRestart_Post_State_Ready: {
       /*
        * The state of the task specified by the ``id`` parameter shall be ready
        * after the rtems_task_restart() call.
        */
       T_eq_u32( ctx->worker_state, STATES_READY )
 
       if ( ctx->protected ) {
         if ( ctx->suspended ) {
           event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
           T_eq_int( event->operation, T_SCHEDULER_UNBLOCK );
           T_eq_ptr( event->thread, ctx->worker_tcb );
         }
       } else {
         if ( ctx->suspended || ctx->blocked ) {
           event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
           T_eq_int( event->operation, T_SCHEDULER_UNBLOCK );
           T_eq_ptr( event->thread, ctx->worker_tcb );
         } else {
           event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
           T_eq_int( event->operation, T_SCHEDULER_BLOCK );
           T_eq_ptr( event->thread, ctx->worker_tcb );
 
           event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
           T_eq_int( event->operation, T_SCHEDULER_UNBLOCK );
           T_eq_ptr( event->thread, ctx->worker_tcb );
         }
       }
 
       if ( !ctx->real_priority_is_initial && !ctx->terminating ) {
         event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
         T_eq_int( event->operation, T_SCHEDULER_UPDATE_PRIORITY );
         T_eq_ptr( event->thread, ctx->worker_tcb );
       }
 
       event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
       T_eq_int( event->operation, T_SCHEDULER_NOP );
       break;
     }
 
     case RtemsTaskReqRestart_Post_State_Zombie: {
       /*
        * The state of the task specified by the ``id`` parameter shall be the
        * zombie state after the rtems_task_restart() call.
        */
       T_eq_u32( ctx->worker_state, STATES_ZOMBIE )
 
       if ( ctx->protected ) {
         if ( ctx->suspended ) {
           event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
           T_eq_int( event->operation, T_SCHEDULER_UNBLOCK );
           T_eq_ptr( event->thread, ctx->worker_tcb );
         }
       } else {
         if ( ctx->suspended ) {
           event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
           T_eq_int( event->operation, T_SCHEDULER_UNBLOCK );
           T_eq_ptr( event->thread, ctx->worker_tcb );
         } else {
           event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
           T_eq_int( event->operation, T_SCHEDULER_BLOCK );
           T_eq_ptr( event->thread, ctx->worker_tcb );
 
           event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
           T_eq_int( event->operation, T_SCHEDULER_UNBLOCK );
           T_eq_ptr( event->thread, ctx->worker_tcb );
         }
       }
 
       if ( !ctx->real_priority_is_initial && !ctx->terminating ) {
         event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
         T_eq_int( event->operation, T_SCHEDULER_UPDATE_PRIORITY );
         T_eq_ptr( event->thread, ctx->worker_tcb );
       }
 
       /* Set zombie state */
       event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
       T_eq_int( event->operation, T_SCHEDULER_BLOCK );
       T_eq_ptr( event->thread, ctx->worker_tcb );
 
       /* Wake up deleter */
       event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
       T_eq_int( event->operation, T_SCHEDULER_UNBLOCK );
       T_eq_ptr( event->thread, ctx->deleter_tcb );
 
       event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
       T_eq_int( event->operation, T_SCHEDULER_NOP );
       break;
     }
 
     case RtemsTaskReqRestart_Post_State_Nop: {
       /*
        * The state of the task specified by the ``id`` parameter shall not be
        * modified by the rtems_task_restart() call.
        */
       T_ne_u32( ctx->worker_state & STATES_LIFE_IS_CHANGING, 0 )
 
       if ( !ctx->real_priority_is_initial ) {
         event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
         T_eq_int( event->operation, T_SCHEDULER_UPDATE_PRIORITY );
         T_eq_ptr( event->thread, ctx->worker_tcb );
       }
 
       event = T_scheduler_next_any( &ctx->scheduler_log.header, &index );
       T_eq_int( event->operation, T_SCHEDULER_NOP );
       break;
     }
 
     case RtemsTaskReqRestart_Post_State_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Post_Enqueued_Check(
   RtemsTaskReqRestart_Context      *ctx,
   RtemsTaskReqRestart_Post_Enqueued state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Post_Enqueued_Yes: {
       /*
        * The task specified by the ``id`` parameter shall be enqueued on a wait
        * queue after the rtems_task_restart() call.
        */
       T_not_null( ctx->worker_tcb->Wait.queue );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Enqueued_No: {
       /*
        * The task specified by the ``id`` parameter shall not be enqueued on a
        * wait queue after the rtems_task_restart() call.
        */
       T_null( ctx->worker_tcb->Wait.queue );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Enqueued_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Post_Timer_Check(
   RtemsTaskReqRestart_Context   *ctx,
   RtemsTaskReqRestart_Post_Timer state
 )
 {
   TaskTimerInfo info;
 
   switch ( state ) {
     case RtemsTaskReqRestart_Post_Timer_Active: {
       /*
        * The timer of the task specified by the ``id`` parameter shall be
        * active after the rtems_task_restart() call.
        */
       GetTaskTimerInfoByThread( ctx->worker_tcb, &info);
       T_eq_int( info.state, TASK_TIMER_TICKS );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Timer_Inactive: {
       /*
        * The timer of the task specified by the ``id`` parameter shall be
        * inactive after the rtems_task_restart() call.
        */
       GetTaskTimerInfoByThread( ctx->worker_tcb, &info);
       T_eq_int( info.state, TASK_TIMER_INACTIVE );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Timer_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Post_Restarting_Check(
   RtemsTaskReqRestart_Context        *ctx,
   RtemsTaskReqRestart_Post_Restarting state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Post_Restarting_Yes: {
       /*
        * The task specified by the ``id`` parameter shall be restarting after
        * the rtems_task_restart() call.
        */
       T_ne_int( ctx->worker_life_state & THREAD_LIFE_RESTARTING, 0 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Restarting_No: {
       /*
        * The task specified by the ``id`` parameter shall not be restarting
        * after the rtems_task_restart() call.
        */
       T_eq_int( ctx->worker_life_state & THREAD_LIFE_RESTARTING, 0 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Restarting_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Post_Terminating_Check(
   RtemsTaskReqRestart_Context         *ctx,
   RtemsTaskReqRestart_Post_Terminating state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Post_Terminating_Yes: {
       /*
        * The task specified by the ``id`` parameter shall be terminating after
        * the rtems_task_restart() call.
        */
       T_ne_int( ctx->worker_life_state & THREAD_LIFE_TERMINATING, 0 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Terminating_No: {
       /*
        * The task specified by the ``id`` parameter shall not be terminating
        * after the rtems_task_restart() call.
        */
       T_eq_int( ctx->worker_life_state & THREAD_LIFE_TERMINATING, 0 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Terminating_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Post_Protected_Check(
   RtemsTaskReqRestart_Context       *ctx,
   RtemsTaskReqRestart_Post_Protected state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Post_Protected_Yes: {
       /*
        * The thread life of the task specified by the ``id`` parameter be
        * protected after the rtems_task_restart() call.
        */
       T_ne_int( ctx->worker_life_state & THREAD_LIFE_PROTECTED, 0 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Protected_No: {
       /*
        * The thread life of the task specified by the ``id`` parameter shall
        * not be protected after the rtems_task_restart() call.
        */
       T_eq_int( ctx->worker_life_state & THREAD_LIFE_PROTECTED, 0 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_Protected_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Post_RestartExtensions_Check(
   RtemsTaskReqRestart_Context               *ctx,
   RtemsTaskReqRestart_Post_RestartExtensions state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Post_RestartExtensions_Yes: {
       /*
        * The thread restart user extensions shall be invoked by the
        * rtems_task_restart() call.
        */
       T_eq_u32( ctx->calls_after_restart.thread_restart, 1 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_RestartExtensions_Nop: {
       /*
        * The thread restart user extensions shall not be invoked by the
        * rtems_task_restart() call.
        */
       T_eq_u32( ctx->calls_after_restart.thread_restart, 0 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_RestartExtensions_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Post_TerminateExtensions_Check(
   RtemsTaskReqRestart_Context                 *ctx,
   RtemsTaskReqRestart_Post_TerminateExtensions state
 )
 {
   switch ( state ) {
     case RtemsTaskReqRestart_Post_TerminateExtensions_Yes: {
       /*
        * The thread terminate user extensions shall be invoked by the
        * rtems_task_restart() call.
        */
       T_eq_u32( ctx->calls_after_restart.thread_terminate, 1 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_TerminateExtensions_Nop: {
       /*
        * The thread terminate user extensions shall not be invoked by the
        * rtems_task_restart() call.
        */
       T_eq_u32( ctx->calls_after_restart.thread_terminate, 0 );
       break;
     }
 
     case RtemsTaskReqRestart_Post_TerminateExtensions_NA:
       break;
   }
 }
 
 static void RtemsTaskReqRestart_Setup( RtemsTaskReqRestart_Context *ctx )
 {
   rtems_status_code sc;
 
   ctx->runner_id = rtems_task_self();
   ctx->scheduler_id = GetSelfScheduler();
   ctx->mutex_id = CreateMutexNoProtocol();
   ObtainMutex( ctx->mutex_id );
   WrapThreadQueueInitialize( &ctx->wrap_tq_ctx, Restart, ctx );
 
   sc = rtems_extension_create(
     rtems_build_name( 'T', 'E', 'S', 'T' ),
     &extensions,
     &ctx->extension_id
   );
   T_rsc_success( sc );
 
   SetFatalHandler( Fatal, ctx );
   SetSelfPriority( PRIO_NORMAL );
 
   ctx->deleter_id = CreateTask( "DELE", PRIO_HIGH );
   ctx->deleter_tcb = GetThread( ctx->deleter_id );
   StartTask( ctx->deleter_id, Deleter, NULL );
 }
 
 static void RtemsTaskReqRestart_Setup_Wrap( void *arg )
 {
   RtemsTaskReqRestart_Context *ctx;
 
   ctx = arg;
   ctx->Map.in_action_loop = false;
   RtemsTaskReqRestart_Setup( ctx );
 }
 
 static void RtemsTaskReqRestart_Teardown( RtemsTaskReqRestart_Context *ctx )
 {
   rtems_status_code sc;
 
   sc = rtems_extension_delete( ctx->extension_id );
   T_rsc_success( sc );
 
   SetFatalHandler( NULL, NULL );
   DeleteTask( ctx->deleter_id );
   ReleaseMutex( ctx->mutex_id );
   DeleteMutex( ctx->mutex_id );
   RestoreRunnerASR();
   RestoreRunnerPriority();
   WrapThreadQueueDestroy( &ctx->wrap_tq_ctx );
 }
 
 static void RtemsTaskReqRestart_Teardown_Wrap( void *arg )
 {
   RtemsTaskReqRestart_Context *ctx;
 
   ctx = arg;
   ctx->Map.in_action_loop = false;
   RtemsTaskReqRestart_Teardown( ctx );
 }
 
 static void RtemsTaskReqRestart_Prepare( RtemsTaskReqRestart_Context *ctx )
 {
   ctx->status = RTEMS_NOT_IMPLEMENTED;
   ctx->actual_argument = UNSET_ARGUMENT;
   ctx->restart_counter = 0;
 
   ctx->delete_worker_expected = false;
   ctx->worker_id = CreateTask( "WORK", PRIO_NORMAL );
   ctx->delete_worker_expected = true;
 
   ctx->worker_tcb = GetThread( ctx->worker_id );
   ctx->worker_state = UINT32_MAX;
   ctx->worker_life_state = INT_MAX;
 
   SetPriority( ctx->deleter_id, PRIO_HIGH );
 }
 
 static void RtemsTaskReqRestart_Action( RtemsTaskReqRestart_Context *ctx )
 {
   rtems_status_code sc;
 
   if ( ctx->id != INVALID_ID ) {
     if ( ctx->dormant ) {
       PrepareRealPriority( ctx );
     } else {
       StartTask( ctx->worker_id, Worker, NULL );
 
       /* Let the worker catch signals and set the thread life protection state */
       Yield();
 
       sc = rtems_signal_send( ctx->worker_id, RTEMS_SIGNAL_0 );
       T_rsc_success( sc );
 
       if (
         ctx->restarting &&
         ( !ctx->nested_request || ( ctx->nested_request && ctx->terminating ) )
       ) {
         sc = rtems_task_restart( ctx->worker_id, (rtems_task_argument) ctx );
         T_rsc_success( sc );
       }
 
       if ( ctx->terminating && !ctx->nested_request ) {
         sc = rtems_task_restart( ctx->deleter_id, (rtems_task_argument) ctx );
         T_rsc_success( sc );
       } else {
         PrepareRealPriority( ctx );
         Yield();
       }
     }
   }
 
   if ( ctx->id == RTEMS_SELF ) {
     CaptureWorkerState( ctx );
   } else {
     if ( ctx->nested_request ) {
       if ( ctx->terminating ) {
         sc = rtems_task_restart( ctx->deleter_id, (rtems_task_argument) ctx );
         T_rsc_success( sc );
       } else {
         WrapThreadQueueExtract( &ctx->wrap_tq_ctx, ctx->worker_tcb );
 
         sc = rtems_task_restart( ctx->worker_id, (rtems_task_argument) ctx );
         T_rsc_success( sc );
       }
     } else {
       SetSelfPriority( PRIO_VERY_HIGH );
 
       if ( ctx->interrupt ) {
         CallWithinISR( Restart, ctx );
       } else {
         Restart( ctx );
       }
     }
   }
 }
 
 static void RtemsTaskReqRestart_Cleanup( RtemsTaskReqRestart_Context *ctx )
 {
   SetSelfPriority( PRIO_VERY_LOW );
 
   if ( ctx->protected && ctx->blocked ) {
     if ( ctx->enqueued ) {
       ReleaseMutex( ctx->mutex_id );
       ObtainMutex( ctx->mutex_id );
     } else {
       SendEvents( ctx->worker_id, RTEMS_EVENT_0 );
     }
   }
 
   if ( ctx->id == INVALID_ID || ctx->dormant || !ctx->terminating ) {
     DeleteTask( ctx->worker_id );
   }
 
   SetSelfPriority( PRIO_NORMAL );
 }
 
 static const RtemsTaskReqRestart_Entry
 RtemsTaskReqRestart_Entries[] = {
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_NA,
     RtemsTaskReqRestart_Post_FatalError_NA,
     RtemsTaskReqRestart_Post_Argument_NA, RtemsTaskReqRestart_Post_State_NA,
     RtemsTaskReqRestart_Post_Enqueued_NA, RtemsTaskReqRestart_Post_Timer_NA,
     RtemsTaskReqRestart_Post_Restarting_NA,
     RtemsTaskReqRestart_Post_Terminating_NA,
     RtemsTaskReqRestart_Post_Protected_NA,
     RtemsTaskReqRestart_Post_RestartExtensions_NA,
     RtemsTaskReqRestart_Post_TerminateExtensions_NA },
   { 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, RtemsTaskReqRestart_Post_Status_InvId,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_NA, RtemsTaskReqRestart_Post_State_NA,
     RtemsTaskReqRestart_Post_Enqueued_NA, RtemsTaskReqRestart_Post_Timer_NA,
     RtemsTaskReqRestart_Post_Restarting_NA,
     RtemsTaskReqRestart_Post_Terminating_NA,
     RtemsTaskReqRestart_Post_Protected_NA,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_NA,
     RtemsTaskReqRestart_Post_FatalError_NA,
     RtemsTaskReqRestart_Post_Argument_NA, RtemsTaskReqRestart_Post_State_NA,
     RtemsTaskReqRestart_Post_Enqueued_NA, RtemsTaskReqRestart_Post_Timer_NA,
     RtemsTaskReqRestart_Post_Restarting_NA,
     RtemsTaskReqRestart_Post_Terminating_NA,
     RtemsTaskReqRestart_Post_Protected_NA,
     RtemsTaskReqRestart_Post_RestartExtensions_NA,
     RtemsTaskReqRestart_Post_TerminateExtensions_NA },
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_NA,
     RtemsTaskReqRestart_Post_FatalError_NA,
     RtemsTaskReqRestart_Post_Argument_NA, RtemsTaskReqRestart_Post_State_NA,
     RtemsTaskReqRestart_Post_Enqueued_NA, RtemsTaskReqRestart_Post_Timer_NA,
     RtemsTaskReqRestart_Post_Restarting_NA,
     RtemsTaskReqRestart_Post_Terminating_NA,
     RtemsTaskReqRestart_Post_Protected_NA,
     RtemsTaskReqRestart_Post_RestartExtensions_NA,
     RtemsTaskReqRestart_Post_TerminateExtensions_NA },
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_NA,
     RtemsTaskReqRestart_Post_FatalError_NA,
     RtemsTaskReqRestart_Post_Argument_NA, RtemsTaskReqRestart_Post_State_NA,
     RtemsTaskReqRestart_Post_Enqueued_NA, RtemsTaskReqRestart_Post_Timer_NA,
     RtemsTaskReqRestart_Post_Restarting_NA,
     RtemsTaskReqRestart_Post_Terminating_NA,
     RtemsTaskReqRestart_Post_Protected_NA,
     RtemsTaskReqRestart_Post_RestartExtensions_NA,
     RtemsTaskReqRestart_Post_TerminateExtensions_NA },
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_NA,
     RtemsTaskReqRestart_Post_FatalError_NA,
     RtemsTaskReqRestart_Post_Argument_NA, RtemsTaskReqRestart_Post_State_NA,
     RtemsTaskReqRestart_Post_Enqueued_NA, RtemsTaskReqRestart_Post_Timer_NA,
     RtemsTaskReqRestart_Post_Restarting_NA,
     RtemsTaskReqRestart_Post_Terminating_NA,
     RtemsTaskReqRestart_Post_Protected_NA,
     RtemsTaskReqRestart_Post_RestartExtensions_NA,
     RtemsTaskReqRestart_Post_TerminateExtensions_NA },
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_NA,
     RtemsTaskReqRestart_Post_FatalError_NA,
     RtemsTaskReqRestart_Post_Argument_NA, RtemsTaskReqRestart_Post_State_NA,
     RtemsTaskReqRestart_Post_Enqueued_NA, RtemsTaskReqRestart_Post_Timer_NA,
     RtemsTaskReqRestart_Post_Restarting_NA,
     RtemsTaskReqRestart_Post_Terminating_NA,
     RtemsTaskReqRestart_Post_Protected_NA,
     RtemsTaskReqRestart_Post_RestartExtensions_NA,
     RtemsTaskReqRestart_Post_TerminateExtensions_NA },
   { 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0,
     RtemsTaskReqRestart_Post_Status_IncStat,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Nop,
     RtemsTaskReqRestart_Post_State_DormantSuspended,
     RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_No,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_No,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0,
     RtemsTaskReqRestart_Post_Status_IncStat,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Nop,
     RtemsTaskReqRestart_Post_State_Dormant,
     RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_No,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_No,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_NA,
     RtemsTaskReqRestart_Post_FatalError_NA,
     RtemsTaskReqRestart_Post_Argument_NA, RtemsTaskReqRestart_Post_State_NA,
     RtemsTaskReqRestart_Post_Enqueued_NA, RtemsTaskReqRestart_Post_Timer_NA,
     RtemsTaskReqRestart_Post_Restarting_NA,
     RtemsTaskReqRestart_Post_Terminating_NA,
     RtemsTaskReqRestart_Post_Protected_NA,
     RtemsTaskReqRestart_Post_RestartExtensions_NA,
     RtemsTaskReqRestart_Post_TerminateExtensions_NA },
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_NA,
     RtemsTaskReqRestart_Post_FatalError_NA,
     RtemsTaskReqRestart_Post_Argument_NA, RtemsTaskReqRestart_Post_State_NA,
     RtemsTaskReqRestart_Post_Enqueued_NA, RtemsTaskReqRestart_Post_Timer_NA,
     RtemsTaskReqRestart_Post_Restarting_NA,
     RtemsTaskReqRestart_Post_Terminating_NA,
     RtemsTaskReqRestart_Post_Protected_NA,
     RtemsTaskReqRestart_Post_RestartExtensions_NA,
     RtemsTaskReqRestart_Post_TerminateExtensions_NA },
   { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_NA,
     RtemsTaskReqRestart_Post_FatalError_NA,
     RtemsTaskReqRestart_Post_Argument_NA, RtemsTaskReqRestart_Post_State_NA,
     RtemsTaskReqRestart_Post_Enqueued_NA, RtemsTaskReqRestart_Post_Timer_NA,
     RtemsTaskReqRestart_Post_Restarting_NA,
     RtemsTaskReqRestart_Post_Terminating_NA,
     RtemsTaskReqRestart_Post_Protected_NA,
     RtemsTaskReqRestart_Post_RestartExtensions_NA,
     RtemsTaskReqRestart_Post_TerminateExtensions_NA },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Ready, RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_Yes,
     RtemsTaskReqRestart_Post_Protected_No,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Ready, RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_No,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set, RtemsTaskReqRestart_Post_State_Nop,
     RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_No,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set, RtemsTaskReqRestart_Post_State_Nop,
     RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_Yes,
     RtemsTaskReqRestart_Post_Protected_No,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Ready, RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_Yes,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Blocked,
     RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_Yes,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Blocked,
     RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Active,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_Yes,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Blocked,
     RtemsTaskReqRestart_Post_Enqueued_Yes,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_Yes,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Blocked,
     RtemsTaskReqRestart_Post_Enqueued_Yes,
     RtemsTaskReqRestart_Post_Timer_Active,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_Yes,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Ready, RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Blocked,
     RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Blocked,
     RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Active,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Blocked,
     RtemsTaskReqRestart_Post_Enqueued_Yes,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, RtemsTaskReqRestart_Post_Status_Ok,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Blocked,
     RtemsTaskReqRestart_Post_Enqueued_Yes,
     RtemsTaskReqRestart_Post_Timer_Active,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     RtemsTaskReqRestart_Post_Status_NoReturn,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Zombie,
     RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_Yes,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Yes },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     RtemsTaskReqRestart_Post_Status_NoReturn,
     RtemsTaskReqRestart_Post_FatalError_Nop,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Ready, RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_No,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_No,
     RtemsTaskReqRestart_Post_RestartExtensions_Yes,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     RtemsTaskReqRestart_Post_Status_NoReturn,
     RtemsTaskReqRestart_Post_FatalError_Yes,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Ready, RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_Yes,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     RtemsTaskReqRestart_Post_Status_NoReturn,
     RtemsTaskReqRestart_Post_FatalError_Yes,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Ready, RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_Yes,
     RtemsTaskReqRestart_Post_Protected_No,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     RtemsTaskReqRestart_Post_Status_NoReturn,
     RtemsTaskReqRestart_Post_FatalError_Yes,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Ready, RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_Yes,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop },
   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     RtemsTaskReqRestart_Post_Status_NoReturn,
     RtemsTaskReqRestart_Post_FatalError_Yes,
     RtemsTaskReqRestart_Post_Argument_Set,
     RtemsTaskReqRestart_Post_State_Ready, RtemsTaskReqRestart_Post_Enqueued_No,
     RtemsTaskReqRestart_Post_Timer_Inactive,
     RtemsTaskReqRestart_Post_Restarting_Yes,
     RtemsTaskReqRestart_Post_Terminating_No,
     RtemsTaskReqRestart_Post_Protected_No,
     RtemsTaskReqRestart_Post_RestartExtensions_Nop,
     RtemsTaskReqRestart_Post_TerminateExtensions_Nop }
 };
 
 static const uint8_t
 RtemsTaskReqRestart_Map[] = {
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0,
   1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2,
   2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
   3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
   3, 0, 3, 0, 3, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
   4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 3, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0,
   3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 11, 11, 11, 11,
   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
   11, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 4, 4,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0,
   3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 4, 4, 4, 4, 4, 4, 4, 4,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
   3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
   3, 0, 3, 0, 3, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 3, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0,
   3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 4, 4, 4, 4, 4, 4,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
   3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0,
   3, 0, 3, 0, 3, 0, 3, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,
   0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3,
   0, 3, 0, 3, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
   4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
   3, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 3, 3, 3,
   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 3, 0, 3,
   0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 3, 0, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 28, 26, 28, 26, 10, 10,
   10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 16, 0, 16, 0, 10, 0,
   10, 0, 17, 0, 17, 0, 18, 0, 18, 0, 19, 0, 19, 0, 20, 0, 20, 0, 4, 4, 4, 4, 4,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 29, 26, 29, 26, 10,
   10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 12, 0, 12, 0, 10,
   0, 10, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 4, 4, 4, 4,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 30, 27, 30, 27,
   10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 21, 0, 21, 0,
   10, 0, 10, 0, 22, 0, 22, 0, 23, 0, 23, 0, 24, 0, 24, 0, 25, 0, 25, 0, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 31, 27, 31,
   27, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 13, 0,
   13, 0, 10, 0, 10, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0,
   14, 0, 14, 0, 10, 0, 10, 0, 14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 14, 0,
   14, 0, 28, 26, 28, 26, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
   9, 9, 9, 16, 0, 16, 0, 10, 0, 10, 0, 17, 0, 17, 0, 18, 0, 18, 0, 19, 0, 19,
   0, 20, 0, 20, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
   4, 4, 4, 4, 29, 26, 29, 26, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
   9, 9, 9, 9, 9, 12, 0, 12, 0, 10, 0, 10, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0,
   12, 0, 12, 0, 12, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
   4, 4, 4, 4, 4, 30, 27, 30, 27, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
   9, 9, 9, 9, 9, 9, 21, 0, 21, 0, 10, 0, 10, 0, 22, 0, 22, 0, 23, 0, 23, 0, 24,
   0, 24, 0, 25, 0, 25, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 31, 27, 31, 27, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9,
   9, 9, 9, 9, 9, 9, 9, 13, 0, 13, 0, 10, 0, 10, 0, 13, 0, 13, 0, 13, 0, 13, 0,
   13, 0, 13, 0, 13, 0, 13, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 28, 26, 28, 26, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9,
   9, 9, 9, 9, 9, 9, 9, 9, 9, 16, 0, 16, 0, 10, 0, 10, 0, 17, 0, 17, 0, 18, 0,
   18, 0, 19, 0, 19, 0, 20, 0, 20, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 29, 26, 29, 26, 10, 10, 10, 10, 9, 9, 9, 9, 9,
   9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 12, 0, 12, 0, 10, 0, 10, 0, 12, 0, 12, 0,
   12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 30, 27, 30, 27, 10, 10, 10, 10, 9, 9, 9,
   9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 21, 0, 21, 0, 10, 0, 10, 0, 22, 0, 22,
   0, 23, 0, 23, 0, 24, 0, 24, 0, 25, 0, 25, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 31, 27, 31, 27, 10, 10, 10, 10, 9, 9,
   9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 13, 0, 13, 0, 10, 0, 10, 0, 13, 0,
   13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 14, 0, 14, 0, 10, 0, 10, 0,
   14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 28, 26, 28, 26, 10,
   10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 16, 0, 16, 0, 10,
   0, 10, 0, 17, 0, 17, 0, 18, 0, 18, 0, 19, 0, 19, 0, 20, 0, 20, 0, 4, 4, 4, 4,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 29, 26, 29, 26,
   10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 12, 0, 12, 0,
   10, 0, 10, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 4, 4,
   4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 30, 27, 30,
   27, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 21, 0,
   21, 0, 10, 0, 10, 0, 22, 0, 22, 0, 23, 0, 23, 0, 24, 0, 24, 0, 25, 0, 25, 0,
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 31,
   27, 31, 27, 10, 10, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
   13, 0, 13, 0, 10, 0, 10, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0,
   13, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
   0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 5, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 7, 7, 7, 7, 7,
   7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 7, 0, 7, 0, 7,
   0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 11, 11, 11, 11, 11, 11,
   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 7, 7,
   7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 7, 0,
   7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 5, 5, 5, 5, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7,
   7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0,
   7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11,
   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 7, 7, 7, 7, 7, 7,
   7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 7, 0, 7, 0, 7, 0,
   7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
   7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0,
   7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
   7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0,
   7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
   7, 7, 7, 7, 7, 7, 7, 7, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0, 7, 0,
   7, 0, 7, 0, 7, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
   8, 8, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 8, 8,
   8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 0,
   8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 11, 11, 11, 11,
   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
   11, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
   8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 8, 8, 8, 8,
   8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 0, 8, 0,
   8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 11, 11, 11, 11, 11, 11,
   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 8, 8,
   8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 0,
   8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 5, 5, 5, 5, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 8, 8, 8, 8, 8, 8, 8, 8,
   8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0,
   8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 11, 11, 11, 11, 11, 11, 11, 11, 11,
   11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 8, 8, 8, 8, 8, 8,
   8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 0, 8, 0, 8, 0,
   8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
   8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 8, 0,
   8, 0, 8, 0, 8, 0, 8, 0, 8, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 16, 16, 16, 16, 10, 10, 10, 10, 17, 17, 17, 17, 18,
   18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 16, 0, 16, 0, 10, 0, 10, 0, 17,
   0, 17, 0, 18, 0, 18, 0, 19, 0, 19, 0, 20, 0, 20, 0, 5, 5, 5, 5, 5, 5, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 12, 12, 12, 12, 10, 10, 10,
   10, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0,
   12, 0, 10, 0, 10, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0,
   15, 0, 15, 0, 10, 0, 10, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15, 0,
   15, 0, 21, 21, 21, 21, 10, 10, 10, 10, 22, 22, 22, 22, 23, 23, 23, 23, 24,
   24, 24, 24, 25, 25, 25, 25, 21, 0, 21, 0, 10, 0, 10, 0, 22, 0, 22, 0, 23, 0,
   23, 0, 24, 0, 24, 0, 25, 0, 25, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 13, 13, 13, 13, 10, 10, 10, 10, 13, 13, 13, 13,
   13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 0, 13, 0, 10, 0, 10, 0,
   13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 14, 0, 14, 0, 10, 0,
   10, 0, 14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 16, 16, 16,
   16, 10, 10, 10, 10, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20,
   20, 20, 16, 0, 16, 0, 10, 0, 10, 0, 17, 0, 17, 0, 18, 0, 18, 0, 19, 0, 19, 0,
   20, 0, 20, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
   5, 5, 5, 12, 12, 12, 12, 10, 10, 10, 10, 12, 12, 12, 12, 12, 12, 12, 12, 12,
   12, 12, 12, 12, 12, 12, 12, 12, 0, 12, 0, 10, 0, 10, 0, 12, 0, 12, 0, 12, 0,
   12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 15, 0, 15, 0, 10, 0, 10, 0, 15, 0, 15, 0,
   15, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15, 0, 21, 21, 21, 21, 10, 10, 10, 10, 22,
   22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 21, 0, 21, 0, 10,
   0, 10, 0, 22, 0, 22, 0, 23, 0, 23, 0, 24, 0, 24, 0, 25, 0, 25, 0, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 13, 13, 13, 13,
   10, 10, 10, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
   13, 13, 0, 13, 0, 10, 0, 10, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13,
   0, 13, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 16, 16, 16, 16, 10, 10, 10, 10, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19,
   19, 19, 20, 20, 20, 20, 16, 0, 16, 0, 10, 0, 10, 0, 17, 0, 17, 0, 18, 0, 18,
   0, 19, 0, 19, 0, 20, 0, 20, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 12, 12, 12, 12, 10, 10, 10, 10, 12, 12, 12, 12,
   12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 0, 12, 0, 10, 0, 10, 0,
   12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 15, 0, 15, 0, 10, 0,
   10, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15, 0, 21, 21, 21,
   21, 10, 10, 10, 10, 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25,
   25, 25, 21, 0, 21, 0, 10, 0, 10, 0, 22, 0, 22, 0, 23, 0, 23, 0, 24, 0, 24, 0,
   25, 0, 25, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
   5, 5, 5, 13, 13, 13, 13, 10, 10, 10, 10, 13, 13, 13, 13, 13, 13, 13, 13, 13,
   13, 13, 13, 13, 13, 13, 13, 13, 0, 13, 0, 10, 0, 10, 0, 13, 0, 13, 0, 13, 0,
   13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 14, 0, 14, 0, 10, 0, 10, 0, 14, 0, 14, 0,
   14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 14, 0, 16, 16, 16, 16, 10, 10, 10, 10, 17,
   17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 16, 0, 16, 0, 10,
   0, 10, 0, 17, 0, 17, 0, 18, 0, 18, 0, 19, 0, 19, 0, 20, 0, 20, 0, 5, 5, 5, 5,
   5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 12, 12, 12, 12,
   10, 10, 10, 10, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
   12, 12, 0, 12, 0, 10, 0, 10, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12, 0, 12,
   0, 12, 0, 15, 0, 15, 0, 10, 0, 10, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15, 0, 15,
   0, 15, 0, 15, 0, 21, 21, 21, 21, 10, 10, 10, 10, 22, 22, 22, 22, 23, 23, 23,
   23, 24, 24, 24, 24, 25, 25, 25, 25, 21, 0, 21, 0, 10, 0, 10, 0, 22, 0, 22, 0,
   23, 0, 23, 0, 24, 0, 24, 0, 25, 0, 25, 0, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 13, 13, 13, 13, 10, 10, 10, 10, 13, 13,
   13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 0, 13, 0, 10, 0,
   10, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 13, 0, 6, 6, 6, 6, 6,
   6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6
 };
 
 static size_t RtemsTaskReqRestart_Scope( void *arg, char *buf, size_t n )
 {
   RtemsTaskReqRestart_Context *ctx;
 
   ctx = arg;
 
   if ( ctx->Map.in_action_loop ) {
     return T_get_scope( RtemsTaskReqRestart_PreDesc, buf, n, ctx->Map.pcs );
   }
 
   return 0;
 }
 
 static T_fixture RtemsTaskReqRestart_Fixture = {
   .setup = RtemsTaskReqRestart_Setup_Wrap,
   .stop = NULL,
   .teardown = RtemsTaskReqRestart_Teardown_Wrap,
   .scope = RtemsTaskReqRestart_Scope,
   .initial_context = &RtemsTaskReqRestart_Instance
 };
 
 static inline RtemsTaskReqRestart_Entry RtemsTaskReqRestart_PopEntry(
   RtemsTaskReqRestart_Context *ctx
 )
 {
   size_t index;
 
   index = ctx->Map.index;
   ctx->Map.index = index + 1;
   return RtemsTaskReqRestart_Entries[
     RtemsTaskReqRestart_Map[ index ]
   ];
 }
 
 static void RtemsTaskReqRestart_SetPreConditionStates(
   RtemsTaskReqRestart_Context *ctx
 )
 {
   ctx->Map.pcs[ 0 ] = ctx->Map.pci[ 0 ];
 
   if ( ctx->Map.entry.Pre_Dormant_NA ) {
     ctx->Map.pcs[ 1 ] = RtemsTaskReqRestart_Pre_Dormant_NA;
   } else {
     ctx->Map.pcs[ 1 ] = ctx->Map.pci[ 1 ];
   }
 
   if ( ctx->Map.entry.Pre_Suspended_NA ) {
     ctx->Map.pcs[ 2 ] = RtemsTaskReqRestart_Pre_Suspended_NA;
   } else {
     ctx->Map.pcs[ 2 ] = ctx->Map.pci[ 2 ];
   }
 
   if ( ctx->Map.entry.Pre_Restarting_NA ) {
     ctx->Map.pcs[ 3 ] = RtemsTaskReqRestart_Pre_Restarting_NA;
   } else {
     ctx->Map.pcs[ 3 ] = ctx->Map.pci[ 3 ];
   }
 
   if ( ctx->Map.entry.Pre_Terminating_NA ) {
     ctx->Map.pcs[ 4 ] = RtemsTaskReqRestart_Pre_Terminating_NA;
   } else {
     ctx->Map.pcs[ 4 ] = ctx->Map.pci[ 4 ];
   }
 
   if ( ctx->Map.entry.Pre_Protected_NA ) {
     ctx->Map.pcs[ 5 ] = RtemsTaskReqRestart_Pre_Protected_NA;
   } else {
     ctx->Map.pcs[ 5 ] = ctx->Map.pci[ 5 ];
   }
 
   ctx->Map.pcs[ 6 ] = ctx->Map.pci[ 6 ];
 
   if ( ctx->Map.entry.Pre_State_NA ) {
     ctx->Map.pcs[ 7 ] = RtemsTaskReqRestart_Pre_State_NA;
   } else {
     ctx->Map.pcs[ 7 ] = ctx->Map.pci[ 7 ];
   }
 
   if ( ctx->Map.entry.Pre_Timer_NA ) {
     ctx->Map.pcs[ 8 ] = RtemsTaskReqRestart_Pre_Timer_NA;
   } else {
     ctx->Map.pcs[ 8 ] = ctx->Map.pci[ 8 ];
   }
 
   if ( ctx->Map.entry.Pre_RealPriority_NA ) {
     ctx->Map.pcs[ 9 ] = RtemsTaskReqRestart_Pre_RealPriority_NA;
   } else {
     ctx->Map.pcs[ 9 ] = ctx->Map.pci[ 9 ];
   }
 
   ctx->Map.pcs[ 10 ] = ctx->Map.pci[ 10 ];
 }
 
 static void RtemsTaskReqRestart_TestVariant( RtemsTaskReqRestart_Context *ctx )
 {
   RtemsTaskReqRestart_Pre_Id_Prepare( ctx, ctx->Map.pcs[ 0 ] );
   RtemsTaskReqRestart_Pre_Dormant_Prepare( ctx, ctx->Map.pcs[ 1 ] );
   RtemsTaskReqRestart_Pre_Suspended_Prepare( ctx, ctx->Map.pcs[ 2 ] );
   RtemsTaskReqRestart_Pre_Restarting_Prepare( ctx, ctx->Map.pcs[ 3 ] );
   RtemsTaskReqRestart_Pre_Terminating_Prepare( ctx, ctx->Map.pcs[ 4 ] );
   RtemsTaskReqRestart_Pre_Protected_Prepare( ctx, ctx->Map.pcs[ 5 ] );
   RtemsTaskReqRestart_Pre_Context_Prepare( ctx, ctx->Map.pcs[ 6 ] );
   RtemsTaskReqRestart_Pre_State_Prepare( ctx, ctx->Map.pcs[ 7 ] );
   RtemsTaskReqRestart_Pre_Timer_Prepare( ctx, ctx->Map.pcs[ 8 ] );
   RtemsTaskReqRestart_Pre_RealPriority_Prepare( ctx, ctx->Map.pcs[ 9 ] );
   RtemsTaskReqRestart_Pre_ThreadDispatch_Prepare( ctx, ctx->Map.pcs[ 10 ] );
   RtemsTaskReqRestart_Action( ctx );
   RtemsTaskReqRestart_Post_Status_Check( ctx, ctx->Map.entry.Post_Status );
   RtemsTaskReqRestart_Post_FatalError_Check(
     ctx,
     ctx->Map.entry.Post_FatalError
   );
   RtemsTaskReqRestart_Post_Argument_Check( ctx, ctx->Map.entry.Post_Argument );
   RtemsTaskReqRestart_Post_State_Check( ctx, ctx->Map.entry.Post_State );
   RtemsTaskReqRestart_Post_Enqueued_Check( ctx, ctx->Map.entry.Post_Enqueued );
   RtemsTaskReqRestart_Post_Timer_Check( ctx, ctx->Map.entry.Post_Timer );
   RtemsTaskReqRestart_Post_Restarting_Check(
     ctx,
     ctx->Map.entry.Post_Restarting
   );
   RtemsTaskReqRestart_Post_Terminating_Check(
     ctx,
     ctx->Map.entry.Post_Terminating
   );
   RtemsTaskReqRestart_Post_Protected_Check(
     ctx,
     ctx->Map.entry.Post_Protected
   );
   RtemsTaskReqRestart_Post_RestartExtensions_Check(
     ctx,
     ctx->Map.entry.Post_RestartExtensions
   );
   RtemsTaskReqRestart_Post_TerminateExtensions_Check(
     ctx,
     ctx->Map.entry.Post_TerminateExtensions
   );
 }
 
 /**
  * @fn void T_case_body_RtemsTaskReqRestart( void )
  */
 T_TEST_CASE_FIXTURE( RtemsTaskReqRestart, &RtemsTaskReqRestart_Fixture )
 {
   RtemsTaskReqRestart_Context *ctx;
 
   ctx = T_fixture_context();
   ctx->Map.in_action_loop = true;
   ctx->Map.index = 0;
 
   for (
     ctx->Map.pci[ 0 ] = RtemsTaskReqRestart_Pre_Id_Invalid;
     ctx->Map.pci[ 0 ] < RtemsTaskReqRestart_Pre_Id_NA;
     ++ctx->Map.pci[ 0 ]
   ) {
     for (
       ctx->Map.pci[ 1 ] = RtemsTaskReqRestart_Pre_Dormant_Yes;
       ctx->Map.pci[ 1 ] < RtemsTaskReqRestart_Pre_Dormant_NA;
       ++ctx->Map.pci[ 1 ]
     ) {
       for (
         ctx->Map.pci[ 2 ] = RtemsTaskReqRestart_Pre_Suspended_Yes;
         ctx->Map.pci[ 2 ] < RtemsTaskReqRestart_Pre_Suspended_NA;
         ++ctx->Map.pci[ 2 ]
       ) {
         for (
           ctx->Map.pci[ 3 ] = RtemsTaskReqRestart_Pre_Restarting_Yes;
           ctx->Map.pci[ 3 ] < RtemsTaskReqRestart_Pre_Restarting_NA;
           ++ctx->Map.pci[ 3 ]
         ) {
           for (
             ctx->Map.pci[ 4 ] = RtemsTaskReqRestart_Pre_Terminating_Yes;
             ctx->Map.pci[ 4 ] < RtemsTaskReqRestart_Pre_Terminating_NA;
             ++ctx->Map.pci[ 4 ]
           ) {
             for (
               ctx->Map.pci[ 5 ] = RtemsTaskReqRestart_Pre_Protected_Yes;
               ctx->Map.pci[ 5 ] < RtemsTaskReqRestart_Pre_Protected_NA;
               ++ctx->Map.pci[ 5 ]
             ) {
               for (
                 ctx->Map.pci[ 6 ] = RtemsTaskReqRestart_Pre_Context_Task;
                 ctx->Map.pci[ 6 ] < RtemsTaskReqRestart_Pre_Context_NA;
                 ++ctx->Map.pci[ 6 ]
               ) {
                 for (
                   ctx->Map.pci[ 7 ] = RtemsTaskReqRestart_Pre_State_Ready;
                   ctx->Map.pci[ 7 ] < RtemsTaskReqRestart_Pre_State_NA;
                   ++ctx->Map.pci[ 7 ]
                 ) {
                   for (
                     ctx->Map.pci[ 8 ] = RtemsTaskReqRestart_Pre_Timer_Inactive;
                     ctx->Map.pci[ 8 ] < RtemsTaskReqRestart_Pre_Timer_NA;
                     ++ctx->Map.pci[ 8 ]
                   ) {
                     for (
                       ctx->Map.pci[ 9 ] = RtemsTaskReqRestart_Pre_RealPriority_Initial;
                       ctx->Map.pci[ 9 ] < RtemsTaskReqRestart_Pre_RealPriority_NA;
                       ++ctx->Map.pci[ 9 ]
                     ) {
                       for (
                         ctx->Map.pci[ 10 ] = RtemsTaskReqRestart_Pre_ThreadDispatch_Disabled;
                         ctx->Map.pci[ 10 ] < RtemsTaskReqRestart_Pre_ThreadDispatch_NA;
                         ++ctx->Map.pci[ 10 ]
                       ) {
                         ctx->Map.entry = RtemsTaskReqRestart_PopEntry( ctx );
 
                         if ( ctx->Map.entry.Skip ) {
                           continue;
                         }
 
                         RtemsTaskReqRestart_SetPreConditionStates( ctx );
                         RtemsTaskReqRestart_Prepare( ctx );
                         RtemsTaskReqRestart_TestVariant( ctx );
                         RtemsTaskReqRestart_Cleanup( ctx );
                       }
                     }
                   }
                 }
               }
             }
           }
         }
       }
     }
   }
 }
 
 /** @} */

This page was automatically generated by the 2.3.7 LXR engine. The LXR team