On 6/10/2022 10:06 AM, Mr Flibble wrote:
> On Fri, 10 Jun 2022 09:54:10 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/10/2022 9:47 AM, Mr Flibble wrote:
>>> On Fri, 10 Jun 2022 09:43:47 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/10/2022 9:37 AM, Mr Flibble wrote:
>>>>> On Fri, 10 Jun 2022 09:32:47 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/10/2022 9:21 AM, Mr Flibble wrote:
>>>>>>> On Fri, 10 Jun 2022 09:15:29 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/10/2022 9:03 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 10 Jun 2022 08:59:17 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/10/2022 8:51 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 10 Jun 2022 08:43:48 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/10/2022 8:35 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 10 Jun 2022 08:33:27 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/10/2022 8:29 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 10 Jun 2022 08:27:28 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 6/10/2022 8:23 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 10 Jun 2022 08:05:57 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 6/10/2022 6:11 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 17:35:05 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 6/9/2022 5:27 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 17:18:38 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> 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.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I am saying that your H is not a halting decider;
>>>>>>>>>>>>>>>>>>>>> I am saying that your H is just a simulation
>>>>>>>>>>>>>>>>>>>>> detector, S.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are saying that you simply "don't believe in"
>>>>>>>>>>>>>>>>>>>> simulating halt deciders.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You haven't got a simulating halt decider, what you
>>>>>>>>>>>>>>>>>>> have got is a simulation detector.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is an easily verified fact that H does correctly
>>>>>>>>>>>>>>>>>> decide the halt status of its input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
>>>>>>>>>>>>>>>>>> H0(Infinite_Loop)); }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>> [00001342](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [00001343](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [00001345](02) ebfe jmp 00001345
>>>>>>>>>>>>>>>>>> [00001347](01) 5d pop ebp
>>>>>>>>>>>>>>>>>> [00001348](01) c3 ret
>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001348]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>>>> [00001372](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [00001373](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [00001375](05) 6842130000 push 00001342
>>>>>>>>>>>>>>>>>> [0000137a](05) e833fdffff call 000010b2
>>>>>>>>>>>>>>>>>> [0000137f](03) 83c404 add esp,+04
>>>>>>>>>>>>>>>>>> [00001382](01) 50 push eax
>>>>>>>>>>>>>>>>>> [00001383](05) 6823040000 push 00000423
>>>>>>>>>>>>>>>>>> [00001388](05) e8e5f0ffff call 00000472
>>>>>>>>>>>>>>>>>> [0000138d](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>> [00001390](02) 33c0 xor eax,eax
>>>>>>>>>>>>>>>>>> [00001392](01) 5d pop ebp
>>>>>>>>>>>>>>>>>> [00001393](01) c3 ret
>>>>>>>>>>>>>>>>>> Size in bytes:(0034) [00001393]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> machine stack stack machine
>>>>>>>>>>>>>>>>>> assembly address address data code
>>>>>>>>>>>>>>>>>> language ======== ======== ======== =========
>>>>>>>>>>>>>>>>>> ============= [00001372][0010228f][00000000] 55
>>>>>>>>>>>>>>>>>> push ebp [00001373][0010228f][00000000] 8bec
>>>>>>>>>>>>>>>>>> mov ebp,esp [00001375][0010228b][00001342]
>>>>>>>>>>>>>>>>>> 6842130000 push 00001342 // push _Infinite_Loop
>>>>>>>>>>>>>>>>>> [0000137a][00102287][0000137f] e833fdffff call
>>>>>>>>>>>>>>>>>> 000010b2 // call H0
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Begin Local Halt Decider Simulation Execution Trace
>>>>>>>>>>>>>>>>>> Stored at:212343 [00001342][00212333][00212337] 55
>>>>>>>>>>>>>>>>>> push ebp [00001343][00212333][00212337] 8bec
>>>>>>>>>>>>>>>>>> mov ebp,esp [00001345][00212333][00212337] ebfe
>>>>>>>>>>>>>>>>>> jmp 00001345 [00001345][00212333][00212337] ebfe
>>>>>>>>>>>>>>>>>> jmp 00001345 Local Halt Decider: Infinite Loop
>>>>>>>>>>>>>>>>>> Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> [0000137f][0010228f][00000000] 83c404 add esp,+04
>>>>>>>>>>>>>>>>>> [00001382][0010228b][00000000] 50 push eax
>>>>>>>>>>>>>>>>>> [00001383][00102287][00000423] 6823040000 push
>>>>>>>>>>>>>>>>>> 00000423 [00001388][00102287][00000423] e8e5f0ffff
>>>>>>>>>>>>>>>>>> call 00000472 Input_Halts = 0
>>>>>>>>>>>>>>>>>> [0000138d][0010228f][00000000] 83c408 add esp,+08
>>>>>>>>>>>>>>>>>> [00001390][0010228f][00000000] 33c0 xor eax,eax
>>>>>>>>>>>>>>>>>> [00001392][00102293][00100000] 5d pop ebp
>>>>>>>>>>>>>>>>>> [00001393][00102297][00000004] c3 ret
>>>>>>>>>>>>>>>>>> Number of Instructions Executed(680)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int Sum(int X, int Y)
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> return X + Y;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H2(Sum, 3, 4));
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _Sum()
>>>>>>>>>>>>>>>>>> [000012b6](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [000012b7](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [000012b9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>> [000012bc](03) 03450c add eax,[ebp+0c]
>>>>>>>>>>>>>>>>>> [000012bf](01) 5d pop ebp
>>>>>>>>>>>>>>>>>> [000012c0](01) c3 ret
>>>>>>>>>>>>>>>>>> Size in bytes:(0011) [000012c0]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>>>> [00001316](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [00001317](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [00001319](02) 6a04 push +04
>>>>>>>>>>>>>>>>>> [0000131b](02) 6a03 push +03
>>>>>>>>>>>>>>>>>> [0000131d](05) 68b6120000 push 000012b6
>>>>>>>>>>>>>>>>>> [00001322](05) e85ffaffff call 00000d86
>>>>>>>>>>>>>>>>>> [00001327](03) 83c40c add esp,+0c
>>>>>>>>>>>>>>>>>> [0000132a](01) 50 push eax
>>>>>>>>>>>>>>>>>> [0000132b](05) 6807040000 push 00000407
>>>>>>>>>>>>>>>>>> [00001330](05) e821f1ffff call 00000456
>>>>>>>>>>>>>>>>>> [00001335](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>> [00001338](02) 33c0 xor eax,eax
>>>>>>>>>>>>>>>>>> [0000133a](01) 5d pop ebp
>>>>>>>>>>>>>>>>>> [0000133b](01) c3 ret
>>>>>>>>>>>>>>>>>> Size in bytes:(0038) [0000133b]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> machine stack stack machine
>>>>>>>>>>>>>>>>>> assembly address address data code
>>>>>>>>>>>>>>>>>> language ======== ======== ======== =========
>>>>>>>>>>>>>>>>>> ============= ...[00001316][001021d7][00000000] 55
>>>>>>>>>>>>>>>>>> push ebp ...[00001317][001021d7][00000000]
>>>>>>>>>>>>>>>>>> 8bec mov ebp,esp ...[00001319][001021d3][00000004]
>>>>>>>>>>>>>>>>>> 6a04 push +04 ...[0000131b][001021cf][00000003] 6a03
>>>>>>>>>>>>>>>>>> push +03 ...[0000131d][001021cb][000012b6]
>>>>>>>>>>>>>>>>>> 68b6120000 push 000012b6
>>>>>>>>>>>>>>>>>> ...[00001322][001021c7][00001327] e85ffaffff call
>>>>>>>>>>>>>>>>>> 00000d86
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Begin Local Halt Decider Simulation Execution Trace
>>>>>>>>>>>>>>>>>> Stored at:21228b ...[000012b6][00212273][00212277] 55
>>>>>>>>>>>>>>>>>> push ebp ...[000012b7][00212273][00212277] 8bec
>>>>>>>>>>>>>>>>>> mov ebp,esp ...[000012b9][00212273][00212277] 8b4508
>>>>>>>>>>>>>>>>>> mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>> ...[000012bc][00212273][00212277] 03450c add
>>>>>>>>>>>>>>>>>> eax,[ebp+0c] ...[000012bf][00212277][00000e54] 5d
>>>>>>>>>>>>>>>>>> pop ebp ...[000012c0][0021227b][00000003] c3 ret
>>>>>>>>>>>>>>>>>> ...[00001327][001021d7][00000000] 83c40c add
>>>>>>>>>>>>>>>>>> esp,+0c ...[0000132a][001021d3][00000001] 50 push eax
>>>>>>>>>>>>>>>>>> ...[0000132b][001021cf][00000407] 6807040000 push
>>>>>>>>>>>>>>>>>> 00000407 ---[00001330][001021cf][00000407] e821f1ffff
>>>>>>>>>>>>>>>>>> call 00000456 Input_Halts = 1
>>>>>>>>>>>>>>>>>> ...[00001335][001021d7][00000000] 83c408 add
>>>>>>>>>>>>>>>>>> esp,+08 ...[00001338][001021d7][00000000] 33c0 xor
>>>>>>>>>>>>>>>>>> eax,eax ...[0000133a][001021db][00100000] 5d pop ebp
>>>>>>>>>>>>>>>>>> ...[0000133b][001021df][00000004] c3 ret Number of
>>>>>>>>>>>>>>>>>> Instructions Executed(660)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> All you are showing here is that your H can decide the
>>>>>>>>>>>>>>>>> halt status of two trivial cases however you have not
>>>>>>>>>>>>>>>>> shown that H can decide the halt status of non-trivial
>>>>>>>>>>>>>>>>> cases.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You said:
>>>>>>>>>>>>>>>> "You haven't got a simulating halt decider"
>>>>>>>>>>>>>>>> Apologize and we can move on.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I posted four paragraphs but you ignored three of them.
>>>>>>>>>>>>>>> Lets try again.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> IF YOU DON'T APOLOGIZE THEN WE CANNOT MOVE ON !!!
>>>>>>>>>>>>>
>>>>>>>>>>>>> It seems I need to try again. Perhaps it will help if I
>>>>>>>>>>>>> combine the four paragraphs into a single paragraph:
>>>>>>>>>>>>>
>>>>>>>>>>>>> All you are showing here is that your H can decide the
>>>>>>>>>>>>> halt status of two trivial cases however you have not
>>>>>>>>>>>>> shown that H can decide the halt status of non-trivial
>>>>>>>>>>>>> cases.
>>>>>>>>>>>>
>>>>>>>>>>>> H is a halt decider for a subset of its inputs.
>>>>>>>>>>>> H is a halt decider for P.
>>>>>>>>>>>> When H is a halt decider for P all of the conventional
>>>>>>>>>>>> halting problem proofs have been refuted.
>>>>>>>>>>>
>>>>>>>>>>> For H to be a halt decider it needs to be a halt decider for
>>>>>>>>>>> all inputs not a subset.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> Publish the source code of your halt
>>>>>>>>>>>>> decider so we can see what classes of programs your H can
>>>>>>>>>>>>> decide. I am interested in deciding the halt status of
>>>>>>>>>>>>> programs containing non-trivial branching logic predicated
>>>>>>>>>>>>> on arbitrary program input.
>>>>>>>>>>>>
>>>>>>>>>>>> These are out-of-scope.
>>>>>>>>>>>
>>>>>>>>>>> You may assert this but that doesn't make your assertion
>>>>>>>>>>> true. If they are out-of-scope then your H is out of scope
>>>>>>>>>>> of the Halting Problem.
>>>>>>>>>>>>
>>>>>>>>>>>>> Crucially if your H cannot return an answer for an
>>>>>>>>>>>>> arbitrary non-halting program in finite time then it
>>>>>>>>>>>>> isn't a halt decider.
>>>>>>>>>>>>
>>>>>>>>>>>> One can either say that H is a halt decider for a subset of
>>>>>>>>>>>> its inputs or that H is a halt determiner. As long as
>>>>>>>>>>>> H(P,P) correctly decides its input all of the conventional
>>>>>>>>>>>> HP proofs have been refuted.
>>>>>>>>>>>
>>>>>>>>>>> If we are to make progress you need to publish the code of
>>>>>>>>>>> your infinite loop detector.
>>>>>>>>>>
>>>>>>>>>> If you can't understand 14 lines of code then this
>>>>>>>>>> conclusively proves that you won't understand hundreds of
>>>>>>>>>> pages of code.
>>>>>>>>>>
>>>>>>>>>> Because people here are only interested in rebuttal and don't
>>>>>>>>>> give a rat's ass about an honest dialogue I make the price
>>>>>>>>>> of a continued dialogue key points of mutual agreement.
>>>>>>>>>>
>>>>>>>>>> If you don't understand that H(P,P)==0 is correct then
>>>>>>>>>> providing the source code will only provide the means for
>>>>>>>>>> denigration based on lack of comprehension. I absolutely
>>>>>>>>>> will not tolerate that.
>>>>>>>>>
>>>>>>>>> If we are to make progress you need to publish the source code
>>>>>>>>> of how your infinite loop detector works as your disassembly
>>>>>>>>> traces DO NOT provide that information.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> I will not do that until many many points of mutual agreement
>>>>>>>> have occurred. Until many many points of mutual agreement have
>>>>>>>> occurred my assessment that my reviewers are lying cheating
>>>>>>>> bastards remains affirmed.
>>>>>>>
>>>>>>> At this point, as you refuse to provide evidence to the
>>>>>>> contrary, I conclude that the only case of non-halting behavior
>>>>>>> you can detect are the execution of the Intel x86 opcodes "EB
>>>>>>> FE". Being only able to detect a single case of non-halting
>>>>>>> behavior out of a total 2^n cases obviously does not qualify as
>>>>>>> a halting decider.
>>>>>>>
>>>>>>> You know what you must do to refute this conclusion: provide
>>>>>>> evidence in the form of source code.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> That I prove that H(P,P)==0 by itself refutes the halting problem
>>>>>> proofs that claim that neither 0 nor 1 is correct.
>>>>>
>>>>> Your H gets the answer wrong if P would have halted as only your
>>>>
>>>> That people with shit for brains think that is gets the wrong
>>>> answer is no rebuttal at all.
>>>
>>> Shit for brains? Your insults are definitely increasing in
>>> intensity, have you checked your blood pressure recently?
>>>
>>> /Flibble
>>>
>>
>> My proof has gotten down to the point that it is proven correct on
>> the basis of easily verified facts. Lying cheating bastards disagree
>> with these easily verified facts.
>
> Why don't you just take a step back for a minute and consider what if
> you are wrong and there isn't actually a grand conspiracy of liars
> acting against you?

When I say that H(P,P)==0 on the basis of the actual behavior of the
actual input all of the rebuttals are of the form that H is wrong on the
basis of the behavior of a non-input.

This is the same as I say that I have a white dog in my living room and
people say that I am wrong because I do not have a black cat in my kitchen.

>
> When was the last time you saw a shrink? Are you on medication?
>
> /Flibble
>

--
Copyright 2022 Pete Olcott

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