On Fri, 10 Jun 2022 10:15:52 -0500
olcott <NoOne@NoWhere.com> wrote:

> 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.

A halting P isn't non-input though; your H gets the answer wrong if
P would have halted after calling H and H isn't a recursive call into a
simulator.

/Flibble