I have been working in the x86 language back when my work
computer at the US Army corps of engineers was an IBM PC
with an 8088 processor, 512K of RAM and dual floppy drives.

I was creating dBASE III systems on this computer. This was
before the 8086 processor even existed thus the name x86
language did not yet exist.

HHH and HH and the original H have proved that they simulate
themselves simulating DDD, DD and P for three years now.

They did this by deriving the correct execution trace that
simulating themselves simulating their input would derive.

Maybe all of my reviewers have been saying that I am wrong
about this on the basis of pure bluster in that they are
totally confused by assembly language and don't have the
slightest clue what it means.

Feigning competence with the x86 language for the purpose
of rebutting my work <is> deception.

_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]

_main()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6872210000 push 00002172 ; push DDD
[0000219a] e833f4ffff call 000015d2 ; call HHH(DDD)
[0000219f] 83c404 add esp,+04
[000021a2] 50 push eax
[000021a3] 6843070000 push 00000743
[000021a8] e8b5e5ffff call 00000762
[000021ad] 83c408 add esp,+08
[000021b0] 33c0 xor eax,eax
[000021b2] 5d pop ebp
[000021b3] c3 ret
Size in bytes:(0034) [000021b3]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00002192][00103820][00000000] 55 push ebp [00002193][00103820][00000000] 8bec mov ebp,esp [00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD [0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:1038c4

Begin Local Halt Decider Simulation Execution Trace Stored at:1138cc [00002172][001138bc][001138c0] 55 push ebp ; housekeeping [00002173][001138bc][001138c0] 8bec mov ebp,esp ; housekeeping [00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD [0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:14e2ec

*The fact that this is the first instruction of DDD proves*
*that HHH did correctly emulate itself emulating DDD even if*
*each HHH did this by a wild guess*

[00002172][0015e2e4][0015e2e8] 55 push ebp ; housekeeping [00002173][0015e2e4][0015e2e8] 8bec mov ebp,esp ; housekeeping [00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD [0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

[0000219f][00103820][00000000] 83c404 add esp,+04 [000021a2][0010381c][00000000] 50 push eax [000021a3][00103818][00000743] 6843070000 push 00000743 [000021a8][00103818][00000743] e8b5e5ffff call 00000762
Input_Halts = 0
[000021ad][00103820][00000000] 83c408 add esp,+08 [000021b0][00103820][00000000] 33c0 xor eax,eax [000021b2][00103824][00000018] 5d pop ebp [000021b3][00103828][00000000] c3 ret
Number of Instructions Executed(10069) == 150 Pages

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/5/24 11:16 AM, olcott wrote:

I have been working in the x86 language back when my work
computer at the US Army corps of engineers was an IBM PC
with an 8088 processor, 512K of RAM and dual floppy drives.

You started late. My first computer had 4096 bytes of ram and a cassette
tape drive as storage media.

I was creating dBASE III systems on this computer. This was
before the 8086 processor even existed thus the name x86
language did not yet exist.

I was programming my computer in ACTUAL 8088 assembly language.

HHH and HH and the original H have proved that they simulate
themselves simulating DDD, DD and P for three years now.

Nope, and the claim just prove you to be stupid.

You have YET to produce a trace as produced by the decider showing such
a simulation.

They did this by deriving the correct execution trace that
simulating themselves simulating their input would derive.

But that isn't a correct emulation of themselves.

Soryy, you just admitted to being a LIAR.

What its output is, and how it got it are two DIFFERENT things.

Maybe all of my reviewers have been saying that I am wrong
about this on the basis of pure bluster in that they are
totally confused by assembly language and don't have the
slightest clue what it means.

Nope, you are wrong about it due to actual definitions, something you
don't seem to understand,.

Feigning competence with the x86 language for the purpose
of rebutting my work <is> deception.

But dispite your claims, you are still just LYING about what a correct
x86 emualtion is.

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

_main()
[00002192] 55         push ebp
[00002193] 8bec       mov ebp,esp
[00002195] 6872210000 push 00002172 ; push DDD
[0000219a] e833f4ffff call 000015d2 ; call HHH(DDD)
[0000219f] 83c404     add esp,+04
[000021a2] 50         push eax
[000021a3] 6843070000 push 00000743
[000021a8] e8b5e5ffff call 00000762
[000021ad] 83c408     add esp,+08
[000021b0] 33c0       xor eax,eax
[000021b2] 5d         pop ebp
[000021b3] c3         ret
Size in bytes:(0034) [000021b3]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  ============= [00002192][00103820][00000000] 55         push ebp [00002193][00103820][00000000] 8bec       mov ebp,esp [00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD [0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:1038c4

The following is NOT a correct emulation of the above instruction.

Begin Local Halt Decider Simulation   Execution Trace Stored at:1138cc [00002172][001138bc][001138c0] 55         push ebp      ; housekeeping
[00002173][001138bc][001138c0] 8bec       mov ebp,esp   ; housekeeping
[00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD [0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:14e2ec

The following is NOT a correct emulation of the above instruction.

*The fact that this is the first instruction of DDD proves*

But since a proper emulation of HHH will never actually get there (since
HHH NEVER "calls" DDD, just CONDITIONALLY emulates it) this just prove
you "proof" is based on LIES.

*that HHH did correctly emulate itself emulating DDD even if*
*each HHH did this by a wild guess*

Nope, it proves you LIE.

Note, since HHH is a CONDITIONAL, a "functional" emualtion could have
been done of HHH showing something like what you showed, but each point
needs to have been prefaced by the fact that it was CONDITIONALLY
emulated by HHH, and thus, the claim of a loop without conditionals can
not be made.

[00002172][0015e2e4][0015e2e8] 55         push ebp      ; housekeeping
[00002173][0015e2e4][0015e2e8] 8bec       mov ebp,esp   ; housekeeping
[00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD [0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

And did so by incorrect logic.

[0000219f][00103820][00000000] 83c404     add esp,+04 [000021a2][0010381c][00000000] 50         push eax [000021a3][00103818][00000743] 6843070000 push 00000743 [000021a8][00103818][00000743] e8b5e5ffff call 00000762
Input_Halts = 0
[000021ad][00103820][00000000] 83c408     add esp,+08 [000021b0][00103820][00000000] 33c0       xor eax,eax [000021b2][00103824][00000018] 5d         pop ebp [000021b3][00103828][00000000] c3         ret
Number of Instructions Executed(10069) == 150 Pages

Yep, you just proved that HHH(DDD), by your logic returns 0, and thus it doesn't correctly emulate DDD when it assumes that the HHH(DDD) that it
calls never returns,

You are just proving that you are just a flat out pathological liar who
doesn't actually know what he is talking about.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-05 15:16:27 +0000, olcott said:

I have been working in the x86 language back when my work
computer at the US Army corps of engineers was an IBM PC
with an 8088 processor, 512K of RAM and dual floppy drives.

I was creating dBASE III systems on this computer. This was
before the 8086 processor even existed thus the name x86
language did not yet exist.

Intel 8088 is a variant of 8086 for less expensive computers.
Intel 8086 already exsted when the first 8088 computers were
sold. Later Intel develped 80188, 80186, and other processors
that cold run programs that were written or compiled for 8086,
so someone coined the term x86 for the family.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/7/2024 1:48 AM, Mikko wrote:

On 2024-08-05 15:16:27 +0000, olcott said:

I have been working in the x86 language back when my work
computer at the US Army corps of engineers was an IBM PC
with an 8088 processor, 512K of RAM and dual floppy drives.

I was creating dBASE III systems on this computer. This was
before the 8086 processor even existed thus the name x86
language did not yet exist.

Intel 8088 is a variant of 8086 for less expensive computers.
Intel 8086 already exsted when the first 8088 computers were
sold. Later Intel develped 80188, 80186, and other processors
that cold run programs that were written or compiled for 8086,
so someone coined the term x86 for the family.

Can you write programs in this language?
I have written many interrupt intercept TSR
programs in the 8088 versions of the language.
I was doing my own time slicing back in 1987.

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/7/24 9:07 AM, olcott wrote:

On 8/7/2024 1:48 AM, Mikko wrote:

On 2024-08-05 15:16:27 +0000, olcott said:

I have been working in the x86 language back when my work
computer at the US Army corps of engineers was an IBM PC
with an 8088 processor, 512K of RAM and dual floppy drives.

I was creating dBASE III systems on this computer. This was
before the 8086 processor even existed thus the name x86
language did not yet exist.

Intel 8088 is a variant of 8086 for less expensive computers.
Intel 8086 already exsted when the first 8088 computers were
sold. Later Intel develped 80188, 80186, and other processors
that cold run programs that were written or compiled for 8086,
so someone coined the term x86 for the family.

Can you write programs in this language?
I have written many interrupt intercept TSR
programs in the 8088 versions of the language.
I was doing my own time slicing back in 1987.

Then why do you think that the x86 emulation of a call instruction
doesn't show the instructions that are called?

After all, wouldn't the trace of x86 level emulation of the program:

#include <stdio.h>
int main() {
printf("Hello World!");
return 0;
}

be the tracing of the instructions of main puting the addres of the
string on the stack, then calling printf, then printf copying the string
byte by byte to the output as it checks for formatting characters, then returning to main that then returns.

instead of just

Hello World!

The later is NOT the trace of the emulation, but the results of the
program, just like the emulation of the call HHH needs to show the
instructions that HHH executes, and not just a summary of the output
that HHH generates, especially since that fails to note that HHH has the
option to stop its emulation, and thus break the supposed infinite
recursion you claim.

Of course, that is EXACTLY the reason you don't show it, it would show
that you are a liar.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-07 13:07:06 +0000, olcott said:

On 8/7/2024 1:48 AM, Mikko wrote:

On 2024-08-05 15:16:27 +0000, olcott said:

I have been working in the x86 language back when my work
computer at the US Army corps of engineers was an IBM PC
with an 8088 processor, 512K of RAM and dual floppy drives.

I was creating dBASE III systems on this computer. This was
before the 8086 processor even existed thus the name x86
language did not yet exist.

Intel 8088 is a variant of 8086 for less expensive computers.
Intel 8086 already exsted when the first 8088 computers were
sold. Later Intel develped 80188, 80186, and other processors
that cold run programs that were written or compiled for 8086,
so someone coined the term x86 for the family.

Can you write programs in this language?
I have written many interrupt intercept TSR
programs in the 8088 versions of the language.
I was doing my own time slicing back in 1987.

I have done that tor 8088 and some other poocessors but not
recently so my skills may be rusty. Only rarely there is any
need for machine language programming.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)