**Can anyone point out any error in the following conclusion?**

The x86utm operating system was created so that the halting problem could be examined concretely in the high level language of C. x86utm UTM tape elements are 32-bit unsigned integers. H examines the behavior of the x86 emulation of its input. As soon as a non-halting behavior pattern is matched H aborts the simulation of its input and decides not halting.

```
int Simulate(u32 P, u32 I)
{
((void(*)(u32))P)(I);
return 1;
}
// Simplified Linz Ĥ (Linz:1990:319)
void H_Hat(u32 P)
{
// Linz H as a simulating partial halt decider
u32 Input_Halts = H(P, P);
if (Input_Halts)
HERE: goto HERE;
}
void H_Hat2(u32 P)
{
u32 Input_Halts = Simulate(P, P);
if (Input_Halts)
HERE: goto HERE;
}
int main()
{
H_Hat2((u32)H_Hat2);
H_Hat((u32)H_Hat);
}
```

Anyone that knows C programming very well will know that line 1 of main() won’t halt and line 2 of main() will only halt if simulating partial halt decider H() stops simulating H_Hat(). A simulating halt decider that never stops simulating its input is simply a simulator on this input.

When we know that the UTM simulation of TM Description P on input I would never halt we know that the execution of TM P(I) would never halt.

**Conclusion:** On this basis we know that any computation that must have its simulation aborted to prevent its otherwise infinite execution is correctly rejected as non-halting.

**Linz, Peter 1990.** An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company.