Everyone makes sure to avoid addressing this exact point

[olcott]

typedef void (*ptr)();
int HHH(ptr P);

void Infinite_Loop()
{
HERE: goto HERE;
return;
}

void Infinite_Recursion()
{
Infinite_Recursion();
return;
}

void DDD()
{
HHH(DDD);
return;
}

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

When HHH correctly emulates N steps of the above
functions none of them can possibly reach their own
"return" instruction and terminate normally.

[dbush]

Post by olcott
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
  HERE: goto HERE;
  return;
}
void Infinite_Recursion()
{
  Infinite_Recursion();
  return;
}
void DDD()
{
  HHH(DDD);
  return;
}
int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}
When HHH correctly emulates N steps of the above
functions none of them can possibly reach their own
"return" instruction and terminate normally.

Changing the input is not allowed.

[Richard Damon]

Post by olcott
typedef void (*ptr)();
int HHH(ptr P);
void Infinite_Loop()
{
  HERE: goto HERE;
  return;
}
void Infinite_Recursion()
{
  Infinite_Recursion();
  return;
}
void DDD()
{
  HHH(DDD);
  return;
}
int DD()
{
  int Halt_Status = HHH(DD);
  if (Halt_Status)
    HERE: goto HERE;
  return Halt_Status;
}
When HHH correctly emulates N steps of the above
functions none of them can possibly reach their own
"return" instruction and terminate normally.

Which, since your DD isn't a program, and neither is HHH, is an
impossiblity.

Your just can't properly emulate N steps of the DD above (unless N is
something like 2) as it is IMPOSSIBLE to correctly emulate a call to an
underfined in the input function.

And, if we add that HHH is defined as that it emulates only N steps of
its input and then returns 0, we see from THAT definition, that HHH
correctlng emulating that behavior will see DD call HHH(DD) which you
just defined to return to its caller after emulating N steps, which you
admit will not see the final state, so the return is 0, and thus it will
see Halt_Status be set to 0, and then DD retuns 0.

So, HHH CAN "correctly emulate" the input per your definitions but
doesn't, and thus gives the wrong answer.

What else is the correct emution of that input?

Your problem is that you whole theory is based on yoru FRAUD of
redefining terms.

Sorry, you are just proving your utter stupidity.

Note, the reason we can come up with multiple ways you claim is wrong is
because your FRAUD has created an inconsistant system, so it shows
contradictory things.