On 3/22/25 10:52 AM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call EEE(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

When finite integer N instructions of the above x86
machine language DD are emulated by each x86 emulator
EEE[N] at machine address [000015c3] according to the
semantics of the x86 language no DD ever reaches its own
"ret" instruction at machine address [00002155] and
terminates normally.

Your can't emulate the above code for N > 4, as you get into undefine
memory.

If EEE is defined to be a correct emulator, then yes, the correct
emulation of this will not halt, but then EEE is not a correct halt
decider either.

Note, the "proof program" that shows the decider is wrong is a specific
program for each decider that we want to prove wrong, so that one shows
that a correct emulator is not a correct halt decider.

Since none of your HHH's are that correct emulator (at least not if you
claim they return an answer) this behavior is irrelevent, as you looked
at the wrong program. DD needs to call the EXACT code of the decider you
want to claim to be correct, and that code is consider part of the input.

Thus, you are just showing the fraud in your arguement, as you seem to
be saying that EEE and HHH can both reside at the same address and be
different programs, which is, of course, impossible.

Sorry, you are just proving your utter stupidity.

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

On 3/22/25 2:00 PM, olcott wrote:

On 3/22/2025 12:34 PM, Richard Damon wrote:

On 3/22/25 10:52 AM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call EEE(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

When finite integer N instructions of the above x86
machine language DD are emulated by each x86 emulator
EEE[N] at machine address [000015c3] according to the
semantics of the x86 language no DD ever reaches its own
"ret" instruction at machine address [00002155] and
terminates normally.

Your can't emulate the above code for N > 4, as you get into undefine
memory.

I have already addressed this objection dozens of times.

No you haven't. You have given several different LIES about it.

As I have pointed out, if you don't include Halt7.c as part of the
definition, then you can't do it as you are looking at undefined memory.

If you DO include Halt7.c, then you will only have ONE value of N ever
looked at, unless you change your input, and thus you can't compare the
values.

Sorry, you are just proving that your "logic" is just a FRAUD based on
lying about what things mean.

Note, you prove that you are being intentionally deceptive by the fact
that you trim out important parts of the context, thus showing that you
know you are lying.

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

On 2025-03-23 03:57:30 +0000, olcott said:

On 3/22/2025 9:53 PM, Richard Damon wrote:

On 3/22/25 2:00 PM, olcott wrote:

On 3/22/2025 12:34 PM, Richard Damon wrote:

On 3/22/25 10:52 AM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call EEE(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

When finite integer N instructions of the above x86
machine language DD are emulated by each x86 emulator
EEE[N] at machine address [000015c3] according to the
semantics of the x86 language no DD ever reaches its own
"ret" instruction at machine address [00002155] and
terminates normally.

Your can't emulate the above code for N > 4, as you get into undefine memory.

I have already addressed this objection dozens of times.

No you haven't. You have given several different LIES about it.

As I have pointed out, if you don't include Halt7.c as part of the
definition, then you can't do it as you are looking at undefined memory.

Your lack of technical competence is showing.
(1) We are talking about a hypothetical infinite
set of pure x86 emulators that have no decider code.

(2) The memory space of x86 machine code is not
in the C source file, it is in the object file.

It isn't in the object file, either. Only the initial values of some
memory locations are there. The object file does not even specify
where in the memory space those locations are. The execution of a
program requires a memory space larger than the object file.

--
Mikko

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

On 3/22/25 11:57 PM, olcott wrote:

On 3/22/2025 9:53 PM, Richard Damon wrote:

On 3/22/25 2:00 PM, olcott wrote:

On 3/22/2025 12:34 PM, Richard Damon wrote:

On 3/22/25 10:52 AM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call EEE(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

When finite integer N instructions of the above x86
machine language DD are emulated by each x86 emulator
EEE[N] at machine address [000015c3] according to the
semantics of the x86 language no DD ever reaches its own
"ret" instruction at machine address [00002155] and
terminates normally.

Your can't emulate the above code for N > 4, as you get into
undefine memory.

I have already addressed this objection dozens of times.

No you haven't. You have given several different LIES about it.

As I have pointed out, if you don't include Halt7.c as part of the
definition, then you can't do it as you are looking at undefined memory.

Your lack of technical competence is showing.
(1) We are talking about a hypothetical infinite
set of pure x86 emulators that have no decider code.

(2) The memory space of x86 machine code is not
in the C source file, it is in the object file.

Then your "input" isn't the C source files, but the memory, and ALL of
it, and thus in your (1), each member of the set got a different input
(as reference memory changed) and none of those apply to your case with HHH.

You just continue to prove that you don't understand the meaning of the
terms you are using, or you are intentionally hiding your fradulant
change of meaning of those terms.

Your logic is just build on self-contradictions and thus is unsound.

Sorry, you are just proving your utter stupidity and ignorance of what
you speak about.

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

On 3/23/25 1:38 PM, olcott wrote:

On 3/23/2025 6:08 AM, Richard Damon wrote:

On 3/22/25 11:57 PM, olcott wrote:

On 3/22/2025 9:53 PM, Richard Damon wrote:

On 3/22/25 2:00 PM, olcott wrote:

On 3/22/2025 12:34 PM, Richard Damon wrote:

On 3/22/25 10:52 AM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call EEE(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

When finite integer N instructions of the above x86
machine language DD are emulated by each x86 emulator
EEE[N] at machine address [000015c3] according to the
semantics of the x86 language no DD ever reaches its own
"ret" instruction at machine address [00002155] and
terminates normally.

Your can't emulate the above code for N > 4, as you get into
undefine memory.

I have already addressed this objection dozens of times.

No you haven't. You have given several different LIES about it.

As I have pointed out, if you don't include Halt7.c as part of the
definition, then you can't do it as you are looking at undefined
memory.

Your lack of technical competence is showing.
(1) We are talking about a hypothetical infinite
set of pure x86 emulators that have no decider code.

(2) The memory space of x86 machine code is not
in the C source file, it is in the object file.

Then your "input" isn't the C source files, but the memory, and ALL of
it, and thus in your (1), each member of the set got a different input
(as reference memory changed) and none of those apply to your case
with HHH.

You just continue to prove that you don't understand the meaning of
the terms you are using, or you are intentionally hiding your
fradulant change of meaning of those terms.

Command line arguments:
x86utm Halt7.obj > Halt7out.txt

All of the x86 functions remain at their same fixed
offset from the beginning of Halt7.obj

So?

You still need to make the decision, is Halt7.c / Halt7.obj part of the
INPUT to the decider, and thus either you can't change the code in it,
or you need to consider each version a different input, or

do you consider it NOT part of the input, and thus you criteria BREAKS
when you look at "data" that isn't part of the input.

Of course you get strange results when you allow your decider to be
influenced by things that aren't part of the official question, and if
you are saying that is allowed, your system becomes thus pretty much
worthless, and any decider could use data not part of its input and thus
claim wrong answers to be correct.

Sorry, but until you show that indeterminate program are a worthwhile
thing to consider, you are just proving your whole system is just a fraud.

Your logic is just build on self-contradictions and thus is unsound.

Sorry, you are just proving your utter stupidity and ignorance of what
you speak about.

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

On 3/23/25 6:56 PM, olcott wrote:

On 3/23/2025 4:46 PM, Richard Damon wrote:

On 3/23/25 1:38 PM, olcott wrote:

On 3/23/2025 6:08 AM, Richard Damon wrote:

On 3/22/25 11:57 PM, olcott wrote:

On 3/22/2025 9:53 PM, Richard Damon wrote:

On 3/22/25 2:00 PM, olcott wrote:

On 3/22/2025 12:34 PM, Richard Damon wrote:

On 3/22/25 10:52 AM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping >>>>>>>>> [00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call EEE(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

When finite integer N instructions of the above x86
machine language DD are emulated by each x86 emulator
EEE[N] at machine address [000015c3] according to the
semantics of the x86 language no DD ever reaches its own
"ret" instruction at machine address [00002155] and
terminates normally.

Your can't emulate the above code for N > 4, as you get into
undefine memory.

I have already addressed this objection dozens of times.

No you haven't. You have given several different LIES about it.

As I have pointed out, if you don't include Halt7.c as part of the >>>>>> definition, then you can't do it as you are looking at undefined
memory.

Your lack of technical competence is showing.
(1) We are talking about a hypothetical infinite
set of pure x86 emulators that have no decider code.

(2) The memory space of x86 machine code is not
in the C source file, it is in the object file.

Then your "input" isn't the C source files, but the memory, and ALL
of it, and thus in your (1), each member of the set got a different
input (as reference memory changed) and none of those apply to your
case with HHH.

You just continue to prove that you don't understand the meaning of
the terms you are using, or you are intentionally hiding your
fradulant change of meaning of those terms.

Command line arguments:
x86utm Halt7.obj > Halt7out.txt

All of the x86 functions remain at their same fixed
offset from the beginning of Halt7.obj

So?

You still need to make the decision, is Halt7.c / Halt7.obj part of
the INPUT to the decider, and thus either you can't change the code in
it, or you need to consider each version a different input, or

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

In other words an infinite set of pure x86 emulators
with each one stored at machine address 000015d2
that can be called from the above fixed finite string
of machine code IS UTTERLY BEYOND ANYTHING THAT YOU
CAN POSSIBLY IMAGINE.

I don't buy it. You are  neither that stupid nor
that ignorant.

You can't have two different programs in one memory location at the same
time.

Since the emulation of the program III will look at that memory, it must
be part of the input, or you are just admitting to an incorrect
emulation of THE INPUT.

Sorry, you are just proving that you are nothing but a stupid liar.

Note also, the III that calls an actual pure x86 emulator will actually
be non-halting, as the only thing such a program can do is emulate
without every breaking.

The issue is, that means that III is not the proof program, as that, by
its definition, calls the decider to gets its answer, and we have
established that the decider can't be that "pure x86 emulator" as if it
was, it wouldn't answer.

So, you are just admitting that you logic is based on strawmen and lies.

Sorry, you are just proving how stupid your logic is, by the way you
keep on repeating the same mistakes, and keep on claiming they must be
right, but make no attempt to actually refute the basic point that was
shown in the error, but try to go off on some side tangent based on more
lies.

Sorry, your reputation is already sunk to the bottom of that lake of
fire, and you will be joining it soon.

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

On 2025-03-23 17:10:48 +0000, olcott said:

On 3/23/2025 4:11 AM, Mikko wrote:

On 2025-03-23 03:57:30 +0000, olcott said:

On 3/22/2025 9:53 PM, Richard Damon wrote:

On 3/22/25 2:00 PM, olcott wrote:

On 3/22/2025 12:34 PM, Richard Damon wrote:

On 3/22/25 10:52 AM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping
[00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local >>>>>>> [00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call EEE(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

When finite integer N instructions of the above x86
machine language DD are emulated by each x86 emulator
EEE[N] at machine address [000015c3] according to the
semantics of the x86 language no DD ever reaches its own
"ret" instruction at machine address [00002155] and
terminates normally.

Your can't emulate the above code for N > 4, as you get into undefine memory.

I have already addressed this objection dozens of times.

No you haven't. You have given several different LIES about it.

As I have pointed out, if you don't include Halt7.c as part of the
definition, then you can't do it as you are looking at undefined memory. >>>>

Your lack of technical competence is showing.
(1) We are talking about a hypothetical infinite
set of pure x86 emulators that have no decider code.

(2) The memory space of x86 machine code is not
in the C source file, it is in the object file.

It isn't in the object file, either. Only the initial values of some
memory locations are there. The object file does not even specify
where in the memory space those locations are. The execution of a
program requires a memory space larger than the object file.

I patch the Halt7.obj file so that functions
are at a fixed address. This file is never linked.

Doesn't affect the fact that important parts of the memory space are not containted in the object file.

--
Mikko

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

On 3/23/25 9:24 PM, olcott wrote:

On 3/23/2025 6:55 PM, Richard Damon wrote:

On 3/23/25 6:56 PM, olcott wrote:

On 3/23/2025 4:46 PM, Richard Damon wrote:

On 3/23/25 1:38 PM, olcott wrote:

On 3/23/2025 6:08 AM, Richard Damon wrote:

On 3/22/25 11:57 PM, olcott wrote:

On 3/22/2025 9:53 PM, Richard Damon wrote:

On 3/22/25 2:00 PM, olcott wrote:

On 3/22/2025 12:34 PM, Richard Damon wrote:

On 3/22/25 10:52 AM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping >>>>>>>>>>> [00002134] 8bec       mov ebp,esp   ; housekeeping >>>>>>>>>>> [00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call EEE(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

When finite integer N instructions of the above x86
machine language DD are emulated by each x86 emulator
EEE[N] at machine address [000015c3] according to the
semantics of the x86 language no DD ever reaches its own >>>>>>>>>>> "ret" instruction at machine address [00002155] and
terminates normally.

Your can't emulate the above code for N > 4, as you get into >>>>>>>>>> undefine memory.

I have already addressed this objection dozens of times.

No you haven't. You have given several different LIES about it. >>>>>>>>
As I have pointed out, if you don't include Halt7.c as part of >>>>>>>> the definition, then you can't do it as you are looking at
undefined memory.

Your lack of technical competence is showing.
(1) We are talking about a hypothetical infinite
set of pure x86 emulators that have no decider code.

(2) The memory space of x86 machine code is not
in the C source file, it is in the object file.

Then your "input" isn't the C source files, but the memory, and
ALL of it, and thus in your (1), each member of the set got a
different input (as reference memory changed) and none of those
apply to your case with HHH.

You just continue to prove that you don't understand the meaning
of the terms you are using, or you are intentionally hiding your
fradulant change of meaning of those terms.

Command line arguments:
x86utm Halt7.obj > Halt7out.txt

All of the x86 functions remain at their same fixed
offset from the beginning of Halt7.obj

So?

You still need to make the decision, is Halt7.c / Halt7.obj part of
the INPUT to the decider, and thus either you can't change the code
in it, or you need to consider each version a different input, or

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

In other words an infinite set of pure x86 emulators
with each one stored at machine address 000015d2
that can be called from the above fixed finite string
of machine code IS UTTERLY BEYOND ANYTHING THAT YOU
CAN POSSIBLY IMAGINE.

I don't buy it. You are  neither that stupid nor
that ignorant.

You can't have two different programs in one memory location at the
same time.

I will dumb it down for you.
Try to come up with one x86 emulator EEE at machine
address 000015d2 that emulates III according to the
semantics of the x86 language and this emulated III
reaches its own machine address 000015d2.

No, you are showing yourself to be dumb.

You can't redefine what "Correct Emulation" means without loosing the
ability to use it to answer the problem, as we can only look as
emulations instead of the original machine BECAUSE the are defined to be
the same.

The big problem with your example is that the fact that there doesn't
exist an EEE that can correct emulate this input to it final state, is
that all this proves is that this sort of emulator can never "prove"
that this sort of input is halting.

We also have the fact that none of the inputs you are looking at
actually match the inputs given to your deciders, because, as been
shown, the code at 000015d2 must be included in the input, or your
decider fails to be the "pure function" you agree it must be.

And if it is, it won't match the code of the decider, since EEE is not
the same program as HHH.

So, all you have done is proven that your logic is based on lies, and on creating strawmen with those lies.

Your credibility is now in that lake of fire that you will be joining in
the not to distant future. Sorry, but that is the facts unless you make
a radical change in your behavior, and admit your error.

But then, it seems you are just too ignorant to be able to see your
error, because you brainwashed yourself into being ignorant out of a
fear of being brainwashed by the truth.

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

On 3/24/25 10:08 AM, olcott wrote:

On 3/24/2025 2:30 AM, Mikko wrote:

On 2025-03-23 17:10:48 +0000, olcott said:

On 3/23/2025 4:11 AM, Mikko wrote:

On 2025-03-23 03:57:30 +0000, olcott said:

On 3/22/2025 9:53 PM, Richard Damon wrote:

On 3/22/25 2:00 PM, olcott wrote:

On 3/22/2025 12:34 PM, Richard Damon wrote:

On 3/22/25 10:52 AM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping >>>>>>>>> [00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call EEE(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

When finite integer N instructions of the above x86
machine language DD are emulated by each x86 emulator
EEE[N] at machine address [000015c3] according to the
semantics of the x86 language no DD ever reaches its own
"ret" instruction at machine address [00002155] and
terminates normally.

Your can't emulate the above code for N > 4, as you get into
undefine memory.

I have already addressed this objection dozens of times.

No you haven't. You have given several different LIES about it.

As I have pointed out, if you don't include Halt7.c as part of the >>>>>> definition, then you can't do it as you are looking at undefined
memory.

Your lack of technical competence is showing.
(1) We are talking about a hypothetical infinite
set of pure x86 emulators that have no decider code.

(2) The memory space of x86 machine code is not
in the C source file, it is in the object file.

It isn't in the object file, either. Only the initial values of some
memory locations are there. The object file does not even specify
where in the memory space those locations are. The execution of a
program requires a memory space larger than the object file.

I patch the Halt7.obj file so that functions
are at a fixed address. This file is never linked.

Doesn't affect the fact that important parts of the memory space are not
containted in the object file.
i

Richard stupidly complained that III could not call EEE
because he stupidly believed that there were in different
memory spaces.

LIAR.

I said it can't call EEE if the code for EEE isn't made part of the
progran, and thus needs to be part of the input describing it.

You are just proving that you are nothing but a pathological liar that
is too stupid t understand the meaning of the words you use.

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

On 2025-03-24 14:08:27 +0000, olcott said:

On 3/24/2025 2:30 AM, Mikko wrote:

On 2025-03-23 17:10:48 +0000, olcott said:

On 3/23/2025 4:11 AM, Mikko wrote:

On 2025-03-23 03:57:30 +0000, olcott said:

On 3/22/2025 9:53 PM, Richard Damon wrote:

On 3/22/25 2:00 PM, olcott wrote:

On 3/22/2025 12:34 PM, Richard Damon wrote:

On 3/22/25 10:52 AM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping >>>>>>>>> [00002134] 8bec       mov ebp,esp   ; housekeeping
[00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call EEE(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

When finite integer N instructions of the above x86
machine language DD are emulated by each x86 emulator
EEE[N] at machine address [000015c3] according to the
semantics of the x86 language no DD ever reaches its own
"ret" instruction at machine address [00002155] and
terminates normally.

Your can't emulate the above code for N > 4, as you get into undefine memory.

I have already addressed this objection dozens of times.

No you haven't. You have given several different LIES about it.

As I have pointed out, if you don't include Halt7.c as part of the >>>>>> definition, then you can't do it as you are looking at undefined memory. >>>>>>

Your lack of technical competence is showing.
(1) We are talking about a hypothetical infinite
set of pure x86 emulators that have no decider code.

(2) The memory space of x86 machine code is not
in the C source file, it is in the object file.

It isn't in the object file, either. Only the initial values of some
memory locations are there. The object file does not even specify
where in the memory space those locations are. The execution of a
program requires a memory space larger than the object file.

I patch the Halt7.obj file so that functions
are at a fixed address. This file is never linked.

Doesn't affect the fact that important parts of the memory space are not
containted in the object file.
i

Richard stupidly complained that III could not call EEE
because he stupidly believed that there were in different
memory spaces.

Irrelevant to anything I said.

Anyway, it is not a good idea to lie about another person.

--
Mikko

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

On 3/24/25 10:10 PM, olcott wrote:

On 3/24/2025 8:28 PM, Richard Damon wrote:

On 3/24/25 10:08 AM, olcott wrote:

On 3/24/2025 2:30 AM, Mikko wrote:

On 2025-03-23 17:10:48 +0000, olcott said:

On 3/23/2025 4:11 AM, Mikko wrote:

On 2025-03-23 03:57:30 +0000, olcott said:

On 3/22/2025 9:53 PM, Richard Damon wrote:

On 3/22/25 2:00 PM, olcott wrote:

On 3/22/2025 12:34 PM, Richard Damon wrote:

On 3/22/25 10:52 AM, olcott wrote:

_DD()
[00002133] 55         push ebp      ; housekeeping >>>>>>>>>>> [00002134] 8bec       mov ebp,esp   ; housekeeping >>>>>>>>>>> [00002136] 51         push ecx      ; make space for local
[00002137] 6833210000 push 00002133 ; push DD
[0000213c] e882f4ffff call 000015c3 ; call EEE(DD)
[00002141] 83c404     add esp,+04
[00002144] 8945fc     mov [ebp-04],eax
[00002147] 837dfc00   cmp dword [ebp-04],+00
[0000214b] 7402       jz 0000214f
[0000214d] ebfe       jmp 0000214d
[0000214f] 8b45fc     mov eax,[ebp-04]
[00002152] 8be5       mov esp,ebp
[00002154] 5d         pop ebp
[00002155] c3         ret
Size in bytes:(0035) [00002155]

When finite integer N instructions of the above x86
machine language DD are emulated by each x86 emulator
EEE[N] at machine address [000015c3] according to the
semantics of the x86 language no DD ever reaches its own >>>>>>>>>>> "ret" instruction at machine address [00002155] and
terminates normally.

Your can't emulate the above code for N > 4, as you get into >>>>>>>>>> undefine memory.

I have already addressed this objection dozens of times.

No you haven't. You have given several different LIES about it. >>>>>>>>
As I have pointed out, if you don't include Halt7.c as part of >>>>>>>> the definition, then you can't do it as you are looking at
undefined memory.

Your lack of technical competence is showing.
(1) We are talking about a hypothetical infinite
set of pure x86 emulators that have no decider code.

(2) The memory space of x86 machine code is not
in the C source file, it is in the object file.

It isn't in the object file, either. Only the initial values of some >>>>>> memory locations are there. The object file does not even specify
where in the memory space those locations are. The execution of a
program requires a memory space larger than the object file.

I patch the Halt7.obj file so that functions
are at a fixed address. This file is never linked.

Doesn't affect the fact that important parts of the memory space are
not
containted in the object file.
i

Richard stupidly complained that III could not call EEE
because he stupidly believed that there were in different
memory spaces.

LIAR.

I said it can't call EEE if the code for EEE isn't made part of the
progran

I told you too damn many times that all this stuff
is in the same global memory space of the compiled
object file.

And thus either all the global memory space is what is defined to be the
input, and thus every case you think of is a different input, or your
"decider" fails to meet the requirements of being the pure function that
you have admited to be a known base requirement.

Sorry, you are just proving that everything you say is likely a lie,
because you just can remember the meaning of the words so you create
your own, INCONSISTENT meaning as you go.

Sorry, you are just proving your ignorance.

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