On 6/9/2022 6:09 PM, Richard Damon wrote:
> On 6/9/22 6:37 PM, olcott wrote:
>> On 6/9/2022 5:33 PM, Richard Damon wrote:
>>> On 6/9/22 6:18 PM, olcott wrote:
>>>> On 6/9/2022 5:15 PM, Mr Flibble wrote:
>>>>> On Thu, 9 Jun 2022 17:09:08 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/9/2022 4:54 PM, Richard Damon wrote:
>>>>>>> On 6/9/22 5:29 PM, olcott wrote:
>>>>>>>> On 6/9/2022 4:13 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 6/9/22 5:00 PM, olcott wrote:
>>>>>>>>>> On 6/9/2022 3:25 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/9/22 4:13 PM, olcott wrote:
>>>>>>>>>>>> On 6/9/2022 2:57 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 6/9/22 3:52 PM, olcott wrote:
>>>>>>>>>>>>>> On 6/9/2022 2:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 6/9/22 3:26 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 6/9/2022 1:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 6/9/22 1:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 6/9/2022 12:46 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:39:32 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:06 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 12:54 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 11:34 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> void P(u32 x)
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>       if (H(x, x))
>>>>>>>>>>>>>>>>>>>>>>>>>>         HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>       return;
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>       P(P);
>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ea](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed](01)  50              push eax
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ee](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f1](01)  51              push ecx
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2](05)  e880feffff      call 00001177 //
>>>>>>>>>>>>>>>>>>>>>>>>>> call H [000012f7](03)  83c408          add
>>>>>>>>>>>>>>>>>>>>>>>>>> esp,+08 [000012fa](02)  85c0            test
>>>>>>>>>>>>>>>>>>>>>>>>>> eax,eax [000012fc](02)  7402            jz
>>>>>>>>>>>>>>>>>>>>>>>>>> 00001300 [000012fe](02)  ebfe            jmp
>>>>>>>>>>>>>>>>>>>>>>>>>> 000012fe [00001300](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001301](01)  c3              ret
>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [00001301]
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001308](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>> [0000130a](05)  68e7120000      push 000012e7 //
>>>>>>>>>>>>>>>>>>>>>>>>>> push P [0000130f](05)  e8d3ffffff      call
>>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7 // call P [00001314](03)  83c404
>>>>>>>>>>>>>>>>>>>>>>>>>>    add esp,+04 [00001317](02)  33c0
>>>>>>>>>>>>>>>>>>>>>>>>>> xor eax,eax [00001319](01)  5d              pop
>>>>>>>>>>>>>>>>>>>>>>>>>> ebp [0000131a](01)  c3              ret
>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0020) [0000131a]
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>      machine   stack     stack     machine
>>>>>>>>>>>>>>>>>>>>>>>>>> assembly address   address   data      code
>>>>>>>>>>>>>>>>>>>>>>>>>>   language ========  ========  ========
>>>>>>>>>>>>>>>>>>>>>>>>>> ========= =============
>>>>>>>>>>>>>>>>>>>>>>>>>> [00001307][00102190][00000000] 55         push
>>>>>>>>>>>>>>>>>>>>>>>>>> ebp [00001308][00102190][00000000] 8bec
>>>>>>>>>>>>>>>>>>>>>>>>>> mov ebp,esp [0000130a][0010218c][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>> 68e7120000 push 000012e7 //
>>>>>>>>>>>>>>>>>>>>>>>>>> push P [0000130f][00102188][00001314] e8d3ffffff
>>>>>>>>>>>>>>>>>>>>>>>>>> call 000012e7
>>>>>>>>>>>>>>>>>>>>>>>>>> // call P [000012e7][00102184][00102190] 55 push
>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter executed P
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00102184][00102190] 8bec       mov
>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00102184][00102190] 8b4508
>>>>>>>>>>>>>>>>>>>>>>>>>>   mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][00102180][000012e7] 50         push
>>>>>>>>>>>>>>>>>>>>>>>>>> eax      //
>>>>>>>>>>>>>>>>>>>>>>>>>> push P [000012ee][00102180][000012e7] 8b4d08
>>>>>>>>>>>>>>>>>>>>>>>>>> mov ecx,[ebp+08] [000012f1][0010217c][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00102178][000012f7] e880feffff
>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Begin Local Halt Decider Simulation   Execution
>>>>>>>>>>>>>>>>>>>>>>>>>> Trace Stored
>>>>>>>>>>>>>>>>>>>>>>>>>> at:212244 [000012e7][00212230][00212234] 55 push
>>>>>>>>>>>>>>>>>>>>>>>>>> ebp // enter emulated P
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][00212230][00212234] 8bec        mov
>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][00212230][00212234] 8b4508
>>>>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0021222c][000012e7] 50          push
>>>>>>>>>>>>>>>>>>>>>>>>>> eax      //
>>>>>>>>>>>>>>>>>>>>>>>>>> push P [000012ee][0021222c][000012e7] 8b4d08
>>>>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][00212228][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][00212224][000012f7] e880feffff
>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So, by what instruction reference manual is a
>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177
>>>>>>>>>>>>>>>>>>>>>>>>> followedby the execution of the instruction at
>>>>>>>>>>>>>>>>>>>>>>>>> 000012e7.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Your "CPU" is broken, or emulation incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e7][0025cc58][0025cc5c] 55          push
>>>>>>>>>>>>>>>>>>>>>>>>>> ebp      //
>>>>>>>>>>>>>>>>>>>>>>>>>> enter emulated P
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012e8][0025cc58][0025cc5c] 8bec        mov
>>>>>>>>>>>>>>>>>>>>>>>>>> ebp,esp [000012ea][0025cc58][0025cc5c] 8b4508
>>>>>>>>>>>>>>>>>>>>>>>>>>    mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012ed][0025cc54][000012e7] 50          push
>>>>>>>>>>>>>>>>>>>>>>>>>> eax      //
>>>>>>>>>>>>>>>>>>>>>>>>>> push P [000012ee][0025cc54][000012e7] 8b4d08
>>>>>>>>>>>>>>>>>>>>>>>>>>   mov ecx,[ebp+08] [000012f1][0025cc50][000012e7]
>>>>>>>>>>>>>>>>>>>>>>>>>> 51 push ecx      // push P
>>>>>>>>>>>>>>>>>>>>>>>>>> [000012f2][0025cc4c][000012f7] e880feffff
>>>>>>>>>>>>>>>>>>>>>>>>>> call 00001177 // call H Local Halt Decider:
>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite Recursion
>>>>>>>>>>>>>>>>>>>>>>>>>> Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is completely obvious that when H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>> correctly emulates
>>>>>>>>>>>>>>>>>>>>>>>>>> its input that it must emulate the first seven
>>>>>>>>>>>>>>>>>>>>>>>>>> instructions of
>>>>>>>>>>>>>>>>>>>>>>>>>> P. Because the seventh instruction of P repeats
>>>>>>>>>>>>>>>>>>>>>>>>>> this process we
>>>>>>>>>>>>>>>>>>>>>>>>>> know with complete certainty that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>> and complete
>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of P by H would never reach its final
>>>>>>>>>>>>>>>>>>>>>>>>>> “ret” instruction, thus never halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Problem, the 7th intruction DOESN't "Just repeat
>>>>>>>>>>>>>>>>>>>>>>>>> the procedure",
>>>>>>>>>>>>>>>>>>>>>>>>> because that H always has the option to abort its
>>>>>>>>>>>>>>>>>>>>>>>>> simulation,
>>>>>>>>>>>>>>>>>>>>>>>>> just like this onne did, and return to its P and
>>>>>>>>>>>>>>>>>>>>>>>>> see it halt.
>>>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS
>>>>>>>>>>>>>>>>>>>>>>>> IS NO ACTUAL
>>>>>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The partial correct x86 emulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) conclusively proves that the complete and
>>>>>>>>>>>>>>>>>>>>>>>> correct x86 emulation
>>>>>>>>>>>>>>>>>>>>>>>> would never stop running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You SAY that, but you don't answer the actual
>>>>>>>>>>>>>>>>>>>>>>> questions about HOW.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS
>>>>>>>>>>>>>>>>>>>>>> NO EVIDENCE
>>>>>>>>>>>>>>>>>>>>>> WHAT-SO-EVER THAT I DID NOT COMPLETELY PROVE THAT
>>>>>>>>>>>>>>>>>>>>>> THE CORRECT
>>>>>>>>>>>>>>>>>>>>>> PARTIAL EMULATION OF THE INPUT TO H(P,P)
>>>>>>>>>>>>>>>>>>>>>> CONCLUSIVELY PROVES THAT
>>>>>>>>>>>>>>>>>>>>>> THE CORRECT AND COMPLETE X86 EMULATION OF THE INPUT
>>>>>>>>>>>>>>>>>>>>>> TO H(P,P)
>>>>>>>>>>>>>>>>>>>>>> WOULD NEVER STOP RUNNING.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is completely obvious that when H(P,P) correctly
>>>>>>>>>>>>>>>>>>>>>> emulates its
>>>>>>>>>>>>>>>>>>>>>> input that it must emulate the first seven
>>>>>>>>>>>>>>>>>>>>>> instructions of P.
>>>>>>>>>>>>>>>>>>>>>> Because the seventh instruction of P repeats this
>>>>>>>>>>>>>>>>>>>>>> process we know
>>>>>>>>>>>>>>>>>>>>>> with complete certainty that the correct and
>>>>>>>>>>>>>>>>>>>>>> complete emulation of
>>>>>>>>>>>>>>>>>>>>>> P by H would never reach its final “ret”
>>>>>>>>>>>>>>>>>>>>>> instruction, thus never
>>>>>>>>>>>>>>>>>>>>>> halts.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If P should have halted (i.e. no infinite loop) then
>>>>>>>>>>>>>>>>>>>>> your simulation
>>>>>>>>>>>>>>>>>>>>> detector, S (not H), gets the answer wrong.  You S is
>>>>>>>>>>>>>>>>>>>>> NOT a halting
>>>>>>>>>>>>>>>>>>>>> decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> THAT YOU ARE SIMPLY TOO STUPID TO UNDERSTAND THIS IS
>>>>>>>>>>>>>>>>>>>> NO ACTUAL
>>>>>>>>>>>>>>>>>>>> REBUTTAL AT ALL.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>>>> [00001352](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>> [00001353](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00001355](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>> [00001358](01)  50              push eax      // push P
>>>>>>>>>>>>>>>>>>>> [00001359](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>> [0000135c](01)  51              push ecx      // push P
>>>>>>>>>>>>>>>>>>>> [0000135d](05)  e840feffff      call 000011a2 // call H
>>>>>>>>>>>>>>>>>>>> [00001362](03)  83c408          add esp,+08
>>>>>>>>>>>>>>>>>>>> [00001365](02)  85c0            test eax,eax
>>>>>>>>>>>>>>>>>>>> [00001367](02)  7402            jz 0000136b
>>>>>>>>>>>>>>>>>>>> [00001369](02)  ebfe            jmp 00001369
>>>>>>>>>>>>>>>>>>>> [0000136b](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>> [0000136c](01)  c3              ret
>>>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is completely obvious that when H(P,P) correctly
>>>>>>>>>>>>>>>>>>>> emulates its
>>>>>>>>>>>>>>>>>>>> input that it must emulate the first seven
>>>>>>>>>>>>>>>>>>>> instructions of P. Because
>>>>>>>>>>>>>>>>>>>> the seventh instruction of P repeats this process we
>>>>>>>>>>>>>>>>>>>> know with
>>>>>>>>>>>>>>>>>>>> complete certainty that the correct and complete
>>>>>>>>>>>>>>>>>>>> emulation of P by H
>>>>>>>>>>>>>>>>>>>> would never reach its final “ret” instruction, thus
>>>>>>>>>>>>>>>>>>>> never halts.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> We are going around and around and around in circles. I
>>>>>>>>>>>>>>>>>>> will try again:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If you replace the opcodes "EB FE" at 00001369 with the
>>>>>>>>>>>>>>>>>>> opcodes "90 90"
>>>>>>>>>>>>>>>>>>> then your H gets the answer wrong: P should have halted.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> As I already said before this is merely your
>>>>>>>>>>>>>>>>>> cluelessness that when H(P,P) is invoked the correct x86
>>>>>>>>>>>>>>>>>> emulation of the input to H(P,P) makes and code after
>>>>>>>>>>>>>>>>>> [0000135d] unreachable.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Wrong, because when that H return the value 0, it will
>>>>>>>>>>>>>>>>> get there.
>>>>>>>>>>>>>>>> Like I said people that are dumber than a box of rocks
>>>>>>>>>>>>>>>> won't be able to correctly understand this.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When H(P,P) is invoked the correctly emulated input to
>>>>>>>>>>>>>>>> H(P,P) cannot possibly reach any instruction beyond
>>>>>>>>>>>>>>>> [0000135d].
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So, you are defining that you H(P,P) never returns because
>>>>>>>>>>>>>>> it is caught in the infinite rcursion.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thats fine, just says it can't be the correctly answering
>>>>>>>>>>>>>>> decider you claim it to be.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have corrected you on this too many times.
>>>>>>>>>>>>>
>>>>>>>>>>>>> How. You need to define what H(P,P) actually does.
>>>>>>>>>>>>
>>>>>>>>>>>> I have explained that too many times.
>>>>>>>>>>>>
>>>>>>>>>>>> To understand that H(P,P)==0 is correct we only need to know
>>>>>>>>>>>> that H performs a correct x86 emulation of its input and then
>>>>>>>>>>>> examine the execution trace.
>>>>>>>>>>>
>>>>>>>>>>> And a CORRECT emulation of the code will Halt if H(P,P) returns
>>>>>>>>>>> 0, which it can only do if it does not actually do a correct
>>>>>>>>>>> emulation
>>>>>>>>>>
>>>>>>>>>> The correctly emulated input to H(P,P) never gets past its
>>>>>>>>>> machine address [0000135d].
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Only if H actually doesn't return 0. Yes, H can't correctly
>>>>>>>>> return 0 if it correctly emulates its input, but you can't drop
>>>>>>>>> that requirement.
>>>>>>>>
>>>>>>>> void P(u32 x)
>>>>>>>> {
>>>>>>>>     if (H(x, x))
>>>>>>>>       HERE: goto HERE;
>>>>>>>>     return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>     Output("Input_Halts = ", H((u32)P, (u32)P));
>>>>>>>> }
>>>>>>>>
>>>>>>>> When H returns 0 it does not returns 0 to P it returns 0 to
>>>>>>>> main().
>>>>>>>
>>>>>>> But it also return 0 to the computation P(P), maybe not the copy
>>>>>>> that it is simulating, since it aborts that before it get to it,
>>>>>>
>>>>>> Finally you are not stupid or deceptive.
>>>>>
>>>>> If H never returns a value to P then H is not a halting decider; if H
>>>>> returns a value of 0 to main() when P halts then H is not a halting
>>>>> decider.
>>>>>
>>>>> H is not a halting decider; H is a simulation detector, S.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> In other words you are saying the infintely nested emulation only
>>>> excutes for a few steps and then it stops on its own.
>>>>
>>>
>>> No, the "infinitely nested emulation" halts when the first H(P,P)
>>> that P(P) called aborts it simulation.
>>
>> When I tell you that an input only halts when it reaches its final
>> state and I tell you this many hundreds of times because you are a God
>> damned liar you pretend that I never said this.
>>
>
> Right, and when H(P,P) returns 0, the P that called it reaches its final
> state/the ret instrucion.

YOU GOD DAMNED LIAR main() calls H(P,P) and H returns to main()

void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
return;
}

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P));
}

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer