This function proves that only the outermost HHH examines the execution trace

This is meant for Mike, Joes and Fred don't have the technical competence to understand it.
Richard might be able to understand it yet the fact that he is
stuck in rebuttal mode makes any understanding that he may have
utterly useless.
Mike: It seems that HHH has been a pure function of its inputs
and never has provided data downward to its slaves that corrupts
their halt status decision. They don't even make a halt status
decision thus cannot make a corrupted one.
I could change the code so that the slave instances can and do
try to form a halt status decision on the basis of the execution
trace that they do have.
There is no sense in doing that because they can't possibly have
enough data, they will always be one whole execution trace behind
the next outer instance of HHH.
As they are the slaves perform their proper function of showing
the actual behavior of DDD correctly emulated by HHH.
u32 Decide_Halting_HH(u32**                   Aborted,
                       u32**                   execution_trace,
                       Decoded_Line_Of_Code**  decoded,
                       u32                     code_end,
                       u32                     End_Of_Code,
                       Registers**             master_state,
                       Registers**             slave_state,
                       u32**                   slave_stack,
                       u32                     Root)
{
   u32 aborted_temp = 0;  // 2024-06-05
   u32 Current_Length_Of_Execution_Trace = 0;
   while (aborted_temp == 0) // 2024-06-05
   {
     u32 EIP = (*slave_state)->EIP; // Save EIP of this instruction
     DebugStep(*master_state, *slave_state, *decoded); // Execute it
     if (EIP > Last_Address_Of_Operating_System())     // Ignore OS code
     {
       PushBack(**execution_trace, (u32)*decoded,
                sizeof(Decoded_Line_Of_Code));
     }
     if (EIP == code_end)
       return 1;
     if (Root)  // Master UTM halt decider
     {
       u32* address = (u32*)**execution_trace;
       u32 size  = (u32)*(address-1);
       // Detects slave appended an instruction to its execution_trace
       if (size > Current_Length_Of_Execution_Trace)
       {
         Current_Length_Of_Execution_Trace = size;
         aborted_temp =     // 2024-06-05
         Needs_To_Be_Aborted_HH
         ((Decoded_Line_Of_Code*)**execution_trace);
       }
     }
   }
   if (aborted_temp == 1) // 2021-01-26 Must be aborted
     return 0;
   return 1;           // 2021-01-26 Need not be aborted
}