On Friday, June 10, 2022 at 11:30:03 AM UTC-4, olcott wrote:
> On 6/10/2022 10:19 AM, Mr Flibble wrote:
> > On Fri, 10 Jun 2022 10:15:52 -0500
> > olcott <No...@NoWhere.com> wrote:
> >
> >> On 6/10/2022 10:06 AM, Mr Flibble wrote:
> >>> On Fri, 10 Jun 2022 09:54:10 -0500
> >>> olcott <No...@NoWhere.com> wrote:
> >>>
> >>>> On 6/10/2022 9:47 AM, Mr Flibble wrote:
> >>>>> On Fri, 10 Jun 2022 09:43:47 -0500
> >>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/10/2022 9:37 AM, Mr Flibble wrote:
> >>>>>>> On Fri, 10 Jun 2022 09:32:47 -0500
> >>>>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/10/2022 9:21 AM, Mr Flibble wrote:
> >>>>>>>>> On Fri, 10 Jun 2022 09:15:29 -0500
> >>>>>>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/10/2022 9:03 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Fri, 10 Jun 2022 08:59:17 -0500
> >>>>>>>>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/10/2022 8:51 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 10 Jun 2022 08:43:48 -0500
> >>>>>>>>>>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/10/2022 8:35 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 10 Jun 2022 08:33:27 -0500
> >>>>>>>>>>>>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 6/10/2022 8:29 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Fri, 10 Jun 2022 08:27:28 -0500
> >>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 6/10/2022 8:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Fri, 10 Jun 2022 08:05:57 -0500
> >>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> On 6/10/2022 6:11 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 17:35:05 -0500
> >>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 5:27 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 17:18:38 -0500
> >>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 5:15 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 17:09:08 -0500
> >>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@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
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <No...@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 6/9/2022 12:28 PM, Mr
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 9 Jun 2022 12:15:24
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> -0500 olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> <No...@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
> >
> You don't even understand the simple concept of unreachable code.
>
> It is an easily verified fact that the actual behavior of the actual
> input to H(P,P) conclusively proves that it never reaches its "ret"
> instruction thus never halts.

And the actual behavior of the actual input to Ha3(N,5) conclusively proves that it never reaches its "ret" instruction thus never halts.

This is obviously wrong, therefore the fact that H(P,P) is unable to simulate its input to a final state proves nothing.

>
> The complete and correct x86 emulation of the input to H(P,P) by H would
> never stop running.

The only way that H performs a complete and correct simulation of its input is if it is Hn (meaning the P that calls it is Pn). Hn(Pn,Pn) does not halt and fails to be a decider.

If H is able to abort, then H is Ha and the P that calls it is Pa. Since Ha aborts, it is by definition not a complete and correct simulation.

Yes, Ha can still correctly detect that Infinite_Loop is non-halting even though it did not perform a complete simulation, but an actual complete simulation i.e. UTM(Infinite_Loop,"") does not halt which shows that Ha(Infinite_Loop,"")==0 is correct.

A complete and correct simulation of the input to Ha(Pa,Pa) i.e. UTM(Pa,Pa) does halt which proves that Ha(Pa,Pa)==0 is wrong.