Re: DD correctly emulated by HHH --- Kicking the straw-man deception out on its ass

On 3/2/25 11:19 PM, olcott wrote:

On 3/2/2025 9:46 PM, Richard Damon wrote:

On 3/2/25 9:22 PM, olcott wrote:

On 3/2/2025 6:42 PM, Richard Damon wrote:

On 3/2/25 4:49 PM, olcott wrote:

On 3/2/2025 3:29 PM, Richard Damon wrote:

On 3/2/25 4:21 PM, olcott wrote:

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>
_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call HHH(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]
>
DD emulated by HHH according to the behavior that DD
specifies cannot possibly reach its own "ret" instruction
and terminate normally.

>
WHich only shows that HHH can not correctly emulate its input and give an answer.
>

>
The fact that HHH does correctly determine that DD
emulated by HHH cannot possibly reach its own "ret"
instruction and terminate normally proves that your
claim is counter factual.

>
You say that, but it isn't true,

>
You keep trying to get away with saying that the
fact that DD calls its own emulator in recursive
emulation does not change the behavior from the
behavior of the directly executed DD.
>
AT THIS POINT THAT BECOMES VERY STUPIDLY WRONG.
SINCE WE KNOW THAT YOU ARE NOT THAT STUPID WHAT ELSE IS LEFT?
>
>

>
And you keep on making the claim without evidence!!!!
>
>
What instruction acted differently between the to, that was directly executied and correctly emulated to different results.
>

 The call to HHH(DD) from the directly executed DD returns
to DD. The call to HHH(DD) from DD correctly emulated by
HHH cannot possibly return BECAUSE IT CALLS ITS OWN EMULATOR.
 I never said it that clearly ever before.
 

Except that isn't what it does, because a program can't do that. A Program can't know if or by who it is being emulated or decided.
DD calls a copy of the DECIDER that claims to correctly decide it.
All copies of that DECIDER behave the same, so if the HHH(DD) that DD calls gets stuck, so does your outer HHH(DD)
You have accepted that by failing to point out what exact step the functions differed in behavior.
Sorry, you are just proving how stupid you are.