int main( void )
{
int const xs[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
printf( "Testing subset slice...\n" );
int const ws[] = { SLICE( xs, 3, 4 ) };
ASSERT( NELEM( ws ) == 4,
ws[ 0 ] == xs[ 3 ],
ws[ 1 ] == xs[ 4 ],
ws[ 2 ] == xs[ 5 ],
ws[ 3 ] == xs[ 6 ] );
( void ) ws;
printf( "Testing total slice...\n" );
int const ys[] = { SLICE( xs, 0, 6 ) };
ASSERT( NELEM( ys ) == 6,
ys[ 0 ] == xs[ 0 ],
ys[ 1 ] == xs[ 1 ],
ys[ 2 ] == xs[ 2 ],
ys[ 3 ] == xs[ 3 ],
ys[ 4 ] == xs[ 4 ],
ys[ 5 ] == xs[ 5 ] );
( void ) ys;
printf( "Testing empty slice...\n" );
int const zs[] = { 0, SLICE( xs, 2, 0 ) };
ASSERT( NELEM( zs ) == 1 );
( void ) zs;
printf( "SLICE() tests passed.\n" );
}
unsigned bitmap_ffs(const uint32_t *bitmap, unsigned from, unsigned size) {
unsigned index_last = BITMAP_WORD(size - 1);
unsigned from_word = BITMAP_WORD(from);
if (from_word == index_last) {
uint32_t mask = SLICE(~0u, (size - 1) % BITS_PER_WORD, from % BITS_PER_WORD)
<< (from % BITS_PER_WORD);
uint32_t word = bitmap[from_word] & mask;
if (word != 0)
return from_word * BITS_PER_WORD + bit_ffs(word) - 1;
else
return size;
}
if (bitmap[from_word] != 0) {
uint32_t first_mask = SLICE(~0u, BITS_PER_WORD - 1, from % BITS_PER_WORD)
<< (from % BITS_PER_WORD);
uint32_t first_word = bitmap[from_word] & first_mask;
if (first_word != 0)
return from_word * BITS_PER_WORD + bit_ffs(first_word) - 1;
}
for (unsigned w = from_word + 1; w < index_last; ++w) {
if (bitmap[w] != 0)
return w * BITS_PER_WORD + bit_ffs(bitmap[w]) - 1;
}
if (index_last != from_word) {
uint32_t last = bitmap[index_last] & BITMAP_MASK_LAST(size);
if (last != 0)
return index_last * BITS_PER_WORD + bit_ffs(last) - 1;
}
return size;
}
// Find the last non-zero word, last bit set in word has index
// [bit_fls(word)].
unsigned bitmap_fls(const uint32_t *bitmap, unsigned from, unsigned size) {
unsigned from_word = BITMAP_WORD(from);
unsigned index_last = BITMAP_WORD(size - 1);
uint32_t last = bitmap[index_last] & BITMAP_MASK_LAST(size);
if (index_last == from_word) {
uint32_t mask = SLICE(~0u, (size - 1) % BITS_PER_WORD, from % BITS_PER_WORD)
<< (from % BITS_PER_WORD);
last = last & mask;
}
if (last != 0)
return index_last * BITS_PER_WORD + bit_fls(last);
for (int w = index_last - 1; w >= (int)from_word; --w) {
if (bitmap[w] != 0)
return w * BITS_PER_WORD + bit_fls(bitmap[w]);
}
if (index_last != from_word && bitmap[from_word] != 0) {
uint32_t first_mask = SLICE(~0u, BITS_PER_WORD - 1, from % BITS_PER_WORD)
<< (from % BITS_PER_WORD);
uint32_t first_word = bitmap[from_word] & first_mask;
if (first_word != 0)
return from_word * BITS_PER_WORD + bit_fls(first_word);
}
return size;
}
void fn0C00_0100(word16 cx, Eq_13 Eq_14::*bx, byte Eq_21::*di, Eq_14 * ds)
{
bios_video_set_mode(0x13);
__outw(0x03D4, DPB(ax, 0x20, 8, 8));
ptr32 es_ax_12 = Mem0[ds:bx + 0x0000:segptr32];
Eq_19 al_13 = (byte) es_ax_12;
Eq_21 * es_15 = SLICE(es_ax_12, selector, 16);
do
{
__outb(0x03C9, al_13);
al_13 = al_13 + 0x95 + C;
C = cond(al_13);
if (al_13 != 0x00)
continue;
do
{
es_15->*di = (byte) cx_57 ^ SLICE(cx_57, byte, 8);
C = false;
di = di + 1;
cx = cx_57 - 0x0001;
word16 cx_57 = cx;
} while (cx != 0x0000);
word16 ax_50 = DPB(cx_57, __inb(0x60), 0, 8);
al_13 = (byte) (ax_50 - 0x0001);
} while (ax_50 != 0x0001);
return;
}
void fn0C00_0100(Eq_36 * ds)
{
bios_video_set_mode(0x13);
__outb(0x03C8, 0x00);
byte al_11 = 0x00;
do
{
__outb(0x03C9, al_11);
al_11 = al_11 + 0x01;
} while (al_11 != 0x00);
byte ah_19 = SLICE(cs, byte, 8);
Eq_23 * ax_21 = DPB(cs, ah_19 + 0x10, 8, 8);
Eq_23 * ax_24 = DPB(cs, ah_19 + 0x20, 8, 8);
Eq_31 Eq_23::*bx_30 = Eq_23::a0000;
do
{
rLoc2 = sin(rLoc2) * (real64) ds->ptr01C6;
(ax_24->*bx_30).w0000 = (int16) rLoc2;
(ax_21->*bx_30).w0000 = 0x0000;
word16 bx_48 = &bx_30->w0000;
bx_30 = bx_48 + 0x0001;
} while (bx_48 != 0x0001);
Eq_56 Eq_36::*di_55 = &Eq_36::t010A;
do
{
word16 si_66 = (ds->*di_55).w0000;
byte Eq_23::*bx_67 = Eq_23::a0000;
int8 bl_68 = 0x00;
int8 bh_69 = 0x00;
do
{
if (bh_69 *s bh_69 + bl_68 *s bl_68 <=u 0x09C3)
bx_67[si_66] = 0xC9;
bx_67 = bx_67 + 1;
bl_68 = (byte) bx_67;
bh_69 = SLICE(bx_67, byte, 8);
} while (bx_67 != Eq_23::a0000);
word16 di_91 = di_55 - 0x0001;
di_55 = di_91 - 0x0001;
} while (di_91 != 0xFF01);
do
{
byte Z_95 = fn0C00_0171(0xA000, ds, ax_21, ax_24);
byte al_96;
bios_kbd_check_keystroke(out al_96);
} while (Z_95);
bios_video_set_mode(0x03);
return;
}
static int slice_enumerate(Manager *m) {
Unit *u;
int r;
assert(m);
u = manager_get_unit(m, SPECIAL_ROOT_SLICE);
if (!u) {
u = unit_new(m, sizeof(Slice));
if (!u)
return log_oom();
r = unit_add_name(u, SPECIAL_ROOT_SLICE);
if (r < 0) {
unit_free(u);
return log_error_errno(r, "Failed to add -.slice name");
}
}
u->default_dependencies = false;
u->no_gc = true;
SLICE(u)->deserialized_state = SLICE_ACTIVE;
if (!u->description)
u->description = strdup("Root Slice");
if (!u->documentation)
(void) strv_extend(&u->documentation, "man:systemd.special(7)");
unit_add_to_load_queue(u);
unit_add_to_dbus_queue(u);
return 0;
}
static void slice_done(Unit *u) {
Slice *s = SLICE(u);
assert(u);
cgroup_context_done(&s->cgroup_context);
}
static int slice_load(Unit *u) {
Slice *s = SLICE(u);
int r;
assert(s);
r = unit_load_fragment_and_dropin_optional(u);
if (r < 0)
return r;
/* This is a new unit? Then let's add in some extras */
if (u->load_state == UNIT_LOADED) {
r = unit_patch_contexts(u);
if (r < 0)
return r;
r = slice_add_parent_slice(s);
if (r < 0)
return r;
if (u->default_dependencies) {
r = slice_add_default_dependencies(s);
if (r < 0)
return r;
}
}
return slice_verify(s);
}
static void slice_init(Unit *u) {
Slice *s = SLICE(u);
assert(u);
assert(u->load_state == UNIT_STUB);
cgroup_context_init(&s->cgroup_context);
}
void fn0040112B(word32 ecx, word32 edx, word32 ebx, word32 ebp, word32 edi, selector fs)
{
byte al_15 = (byte) ebx;
byte v12_20 = Mem0[ebx + 0x00000000:byte] + al_15;
Mem21[ebx + 0x00000000:byte] = v12_20;
byte v14_22 = Mem21[ebx + 0x00000000:byte] + al_15;
Mem23[ebx + 0x00000000:byte] = v14_22;
byte v15_24 = Mem23[ebx + 0x00000000:byte] + al_15;
Mem25[ebx + 0x00000000:byte] = v15_24;
byte v16_26 = Mem25[ebx + 0x00000000:byte] + al_15;
Mem27[ebx + 0x00000000:byte] = v16_26;
byte v17_28 = Mem27[ebx + 0x00000000:byte] + al_15;
Mem29[ebx + 0x00000000:byte] = v17_28;
byte v18_30 = Mem29[ebx + 0x00000000:byte] + al_15;
Mem31[ebx + 0x00000000:byte] = v18_30;
byte v19_32 = Mem31[ebx + 0x00000000:byte] + al_15;
Mem33[ebx + 0x00000000:byte] = v19_32;
byte v20_34 = Mem33[ebx + 0x00000000:byte] + al_15;
Mem35[ebx + 0x00000000:byte] = v20_34;
byte v21_36 = Mem35[ebx + 0x00000000:byte] + al_15;
Mem37[ebx + 0x00000000:byte] = v21_36;
byte v22_38 = Mem37[ebx + 0x00000000:byte] + al_15;
Mem39[ebx + 0x00000000:byte] = v22_38;
byte v23_40 = Mem39[ebx + 0x00000000:byte] + al_15;
Mem41[ebx + 0x00000000:byte] = v23_40;
byte v24_42 = Mem41[ebx + 0x00000000:byte] + al_15;
Mem43[ebx + 0x00000000:byte] = v24_42;
byte v25_44 = Mem43[ebx + 0x00000000:byte] + al_15;
Mem45[ebx + 0x00000000:byte] = v25_44;
byte v26_46 = Mem45[ebx + 0x00000000:byte] + al_15;
Mem47[ebx + 0x00000000:byte] = v26_46;
byte v27_48 = Mem47[ebx + 0x00000000:byte] + al_15;
Mem49[ebx + 0x00000000:byte] = v27_48;
byte v28_50 = Mem49[ebx + 0x00000000:byte] + al_15;
Mem51[ebx + 0x00000000:byte] = v28_50;
byte v29_52 = Mem51[ebx + 0x00000000:byte] + al_15;
Mem53[ebx + 0x00000000:byte] = v29_52;
word32 edi_10 = ~edi;
word32 edi_55 = DPB(edi_10, (word16) edi_10 + 0xFF84, 0, 16);
Mem53[0x00401093:word32]();
word32 edi_96 = edi_55 + (ebp - 0xFFFFFFF9);
word32 eax_89 = __rol(ebx, 0x05);
word32 esp_112 = fp;
word16 di_110 = (word16) edi_96;
word32 ecx_99 = DPB(0x00009090, Mem53[ebp - 0xFFFFFFF9:word16] ^ 0x9090, 0, 16);
byte dh_102 = SLICE((edx & 0x6AD47C2E) + 0x00000001 - 0x00000001, byte, 8);
if (ecx_99 != 0x00000000)
{
ExitThread(edi_96);
Mem283[ebx - 0x00000035:byte] = Mem53[ebx - 0x00000035:byte] + (byte) (eax_89 + edi_96 | 0x0014008D);
word32 ecx_278 = DPB(ecx_99, 0x00, 8, 8);
Mem288[ecx_278 + 0x00000000:byte] = Mem283[ecx_278 + 0x00000000:byte] + dh_102;
word32 eax_290 = DPB(ecx_99, Mem288[0x00DDB800:byte], 0, 8);
Mem292[eax_290 + 0x66017000 + eax_290:byte] = Mem288[eax_290 + 0x66017000 + eax_290:byte] + SLICE(ecx_99, byte, 8);
di_110 = (word16) (edi_96 - 0x00000001);
esp_112 = fp - 0x00000004;
}
static int slice_serialize(Unit *u, FILE *f, FDSet *fds) {
Slice *s = SLICE(u);
assert(s);
assert(f);
assert(fds);
unit_serialize_item(u, f, "state", slice_state_to_string(s->state));
return 0;
}
static int slice_start(Unit *u) {
Slice *t = SLICE(u);
assert(t);
assert(t->state == SLICE_DEAD);
unit_realize_cgroup(u);
slice_set_state(t, SLICE_ACTIVE);
return 1;
}
static int slice_coldplug(Unit *u) {
Slice *t = SLICE(u);
assert(t);
assert(t->state == SLICE_DEAD);
if (t->deserialized_state != t->state)
slice_set_state(t, t->deserialized_state);
return 0;
}
void fn0C00_0100(word16 cx, segptr32 Eq_3::*bx, Eq_15 Eq_2::*di, Eq_3 * ds)
{
Eq_2 * es_6 = SLICE(ds->*bx, selector, 16);
bios_video_set_mode(0x13);
while (true)
{
di = &di->b0000 + 0x0001;
do
{
byte al_29 = 0x1E;
if ((cl & 0x1E) != 0x00 && (ch & 0x1E) != 0x00)
al_29 = (ch ^ cl) & 0x38;
(es_6->*di).b0000 = al_29;
cx = cx - 0x0001;
di = di;
cl = (byte) cx;
ch = SLICE(cx, byte, 8);
} while (cx != 0x0000);
}
}
static int slice_stop(Unit *u) {
Slice *t = SLICE(u);
assert(t);
assert(t->state == SLICE_ACTIVE);
/* We do not need to destroy the cgroup explicitly,
* unit_notify() will do that for us anyway. */
slice_set_state(t, SLICE_DEAD);
return 1;
}
static void slice_dump(Unit *u, FILE *f, const char *prefix) {
Slice *t = SLICE(u);
assert(t);
assert(f);
fprintf(f,
"%sSlice State: %s\n",
prefix, slice_state_to_string(t->state));
cgroup_context_dump(&t->cgroup_context, f, prefix);
}
int bus_slice_set_property(
Unit *u,
const char *name,
sd_bus_message *message,
UnitSetPropertiesMode mode,
sd_bus_error *error) {
Slice *s = SLICE(u);
assert(name);
assert(u);
return bus_cgroup_set_property(u, &s->cgroup_context, name, message, mode, error);
}
DBusHandlerResult bus_slice_message_handler(Unit *u, DBusConnection *c, DBusMessage *message) {
Slice *s = SLICE(u);
const BusBoundProperties bps[] = {
{ "org.freedesktop.systemd1.Unit", bus_unit_properties, u },
{ "org.freedesktop.systemd1.Slice", bus_unit_cgroup_properties, u },
{ "org.freedesktop.systemd1.Slice", bus_cgroup_context_properties, &s->cgroup_context },
{}
};
SELINUX_UNIT_ACCESS_CHECK(u, c, message, "status");
return bus_default_message_handler(c, message, INTROSPECTION, INTERFACES_LIST, bps);
}
void fn0C00_0100(byte cl, byte ah)
{
bios_video_set_mode(0x13);
do
{
cx = DPB(cx, 0xFA, 8, 8);
do
{
ah = ah + ((byte) cx + SLICE(cx, byte, 8));
(0xA000->*cx).bFFFFFFFF = ah;
cx = cx - 0x0001;
} while (cx != &Eq_13::t0000);
} while (__inb(0x60) != 0x01);
msdos_terminate_program20();
}
byte fn0C00_0171(Eq_92 * es, Eq_36 * ds, Eq_23 * fs, Eq_23 * gs)
{
Eq_38 Eq_23::*bx_4 = ds->ptr01C6;
ds->w01CE = (gs->*bx_4).w0000;
word16 si_24 = (gs->*bx_4).w4000;
word16 dx_107 = 0x0000;
word16 bp_106 = 0x0000;
byte Eq_92::*di_105 = &Eq_92::b0000;
word16 cx_110 = 0x00C8;
do
{
word16 cx_50 = 0x0140;
di_54 = di_105;
bp_55 = bp_106;
dx_56 = dx_107;
do
{
byte Eq_92::*di_54;
word16 bp_55;
word16 dx_56;
dx_56 = dx_56 + ds->w01CE;
bp_55 = bp_55 + si_24;
Eq_140 bx_119 = DPB(bp_55, SLICE(dx_56, byte, 8), 0, 8);
byte al_121 = 0x14;
do
{
if (Mem7[fs:bx_119 + Mem7[ds:0x01CC:word16]:byte] != 0x00)
break;
bx_119 = bx_119 * 0x0002;
al_121 = al_121 - 0x04;
} while (al_121 != 0x00);
es->*di_54 = al_121;
di_54 = di_54 + 1;
cx_50 = cx_50 - 0x0001;
} while (cx_50 != 0x0000);
di_105 = di_105 + 0x0140;
bp_106 = bp_106 - ds->w01CE;
dx_107 = dx_107 + si_24;
cx_110 = cx_110 - 0x0001;
} while (cx_110 != 0x0000);
ds->b01C7 = ds->b01C7 + 0x01;
byte v23_113 = ds->b01CD + 0x04;
ds->b01CD = v23_113;
return cond(v23_113);
}
void fn0C00_0100(byte ch, byte bh)
{
bios_video_set_mode(0x13);
byte bl_118 = 0x03;
word16 bx_119 = DPB(bx, 0x03, 0, 8);
do
{
cx = DPB(cx, 0xC8, 0, 8);
byte Eq_25::*di_35 = &Eq_25::b0000;
do
{
uint32 dx_ax_47 = cx *u cx;
uint16 ax_110 = (word16) dx_ax_47;
uint16 dx_112 = SLICE(dx_ax_47, word16, 16);
word16 si_53 = 0x0280;
do
{
uint16 dx_61 = SEQ(dx_112, ax_110 + 0x0281 - si_53) % bx_119;
0xA000->*di_35 = (byte) dx_61 & 0x0F;
word16 si_77 = si_53 - 0x0001;
di_35 = di_35 + 1;
ax_110 = dx_61;
dx_112 = 0x0000;
si_53 = si_77 - 0x0001;
} while (si_77 != 0x0001);
cx = cx - 0x0001;
} while (cx != 0x0000);
do
{
word16 ax_90 = DPB(ax_110, __inb(0x60), 0, 8);
if (ax_90 == 0x0001)
goto l0C00_013F;
uint16 ax_108 = DPB(ax_90 - 0x0001, 0x0000->b046C & 0x0F, 0, 8);
ax_110 = dx_122;
dx_112 = ax_108;
uint16 dx_122 = dx_112;
} while ((byte) dx_122 - (byte) ax_108 <=u 0x00);
bl_118 = bl_118 + 0x01;
bx_119 = DPB(bx_119, bl_118, 0, 8);
} while (bl_118 != 0x00);
return;
}
int bus_slice_set_property(
Unit *u,
const char *name,
DBusMessageIter *i,
UnitSetPropertiesMode mode,
DBusError *error) {
Slice *s = SLICE(u);
int r;
assert(name);
assert(u);
assert(i);
r = bus_cgroup_set_property(u, &s->cgroup_context, name, i, mode, error);
if (r != 0)
return r;
return 0;
}
void fn0C00_0100(Eq_20 bx, word16 di, byte ah)
{
bios_video_set_mode(0x12);
uint16 ax_27 = DPB(ax, 0x12, 0, 8);
word16 bp_28 = 0x0000;
word16 cx_10 = 0x01E0;
do
{
word16 wLoc02_34 = cx_10;
word16 cx_35 = 0x027F;
bp_28 = bp_28 - 0x027F + 0x0001;
do
{
word16 cx_113 = 0x0000;
byte cl_112 = 0x00;
word16 dx_108 = SLICE(bx *u ax_27, word16, 16);
do
{
Eq_20 ax_71 = (word16) ((dx_108 + bx) *s (bx - dx_108)) + bp_28;
bx = ax_71;
if (ax_71 > 0x0000)
break;
cl_112 = ~cl_112;
dx_108 = dx_108 + di;
cx_113 = DPB(cx_113, cl_112, 0, 8);
} while (dx_108 != 0x0000);
__syscall(0x10);
wLoc02_34 = wLoc02_114;
bx.u0 = 0x0000;
ax_27 = DPB(cx_113, 0x0C, 8, 8);
bp_28 = bp_28 + 0x0000;
cx_35 = cx_35 - 0x0001;
word16 wLoc02_114 = wLoc02_34;
} while (cx_35 != 0x0000);
di = di + 0x0001;
cx_10 = wLoc02_114 - 0x0001;
} while (cx_10 != 0x0000);
__syscall(0x16);
return;
}
static int slice_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
Slice *s = SLICE(u);
assert(u);
assert(key);
assert(value);
assert(fds);
if (streq(key, "state")) {
SliceState state;
state = slice_state_from_string(value);
if (state < 0)
log_debug("Failed to parse state value %s", value);
else
s->deserialized_state = state;
} else
log_debug("Unknown serialization key '%s'", key);
return 0;
}
void fn0C00_0100()
{
bios_video_set_mode(0x13);
word16 ax_12 = 0x0013;
Eq_9 Eq_17::*di_13 = &Eq_17::t0000;
do
{
word16 ax_14 = ax_12 + di_13;
Eq_13 al_17 = (byte) ax_14 + SLICE(ax_14, byte, 8);
(0xA000->*di_13).t0000 = al_17;
Eq_9 Eq_17::*di_20 = di_13 + 1;
ax_12 = DPB(ax_14, al_17, 0, 8);
di_13 = di_20;
} while (di_20 != &Eq_17::t0000);
Mem26[ss:fp - 0x0002:word16] = 0xA000;
Eq_13 Eq_17::*si_30 = Eq_17::a002D;
while (true)
{
Mem34[0xA000:di_13 + 0x0000:word16] = Mem26[0xA000:si_30 + 0x0000:word16];
si_30 = si_30 + 1;
di_13 = di_13 + 2;
}
}
void fn0C00_0100(byte bh, Eq_10 * ds)
{
bios_video_set_mode(0x13);
Eq_9 Eq_10::*si_18 = &Eq_10::t01BC;
do
{
word16 ax_17 = Mem0[ds:si_18 + 0x0000:word16];
byte dh_22 = SLICE(ax_17, byte, 8);
bios_video_set_cursor_position(bh, dh_22, (byte) ax_17);
si_18 = si_18 + 0x0002 + 0x0001;
dx = ax_17;
word16 ax_25 = DPB(dx, 0x02, 8, 8);
do
{
byte al_30 = Mem0[ds:si_18 + 0x0000:byte];
msdos_write_console_char(al_30);
ax_25 = DPB(ax_25, al_30, 0, 8);
si_18 = si_18;
dx = DPB(dx, al_30, 0, 8);
} while (al_30 != 0x00);
} while (dh_22 != 0x00);
do
{
__outb(0x03C9, al_30);
word16 ax_50 = __rol(DPB(ax_25, ~al_30, 0, 8), 0x01);
__outb(0x03C9, (byte) ax_50);
word16 ax_53 = __ror(ax_50, 0x01);
byte al_54 = (byte) ax_53;
__outb(0x03C9, al_54);
word16 ax_57 = DPB(ax_53, ~al_54, 0, 8);
ax_25 = ax_57 + 0x0001;
al_30 = (byte) (ax_57 + 0x0001);
} while (ax_57 != 0x0001);
Eq_79 Eq_104::*di_111 = Eq_104::a0000;
byte bl_116 = 0xCC;
word16 bx_114 = DPB(bx, 0xCC, 0, 8);
do
{
word16 cx_112 = 0x0140;
byte cl_113 = 0x40;
do
{
Eq_93 al_107;
if ((0xA000->*di_111).t0000 == 0x00)
{
word16 ax_160 = __aam(cl_113 | bl_116);
al_107 = ((byte) ax_160 | SLICE(ax_160, byte, 8)) & 0x3F;
}
else
{
Eq_87 al_168 = cl_113 - bl_116;
al_107 = al_168 - cl_113 - (al_168 <u 0x00);
}
(0xA000->*di_111).t0000 = al_107;
cx_112 = cx_112 - 0x0001;
di_111 = di_111 + 1;
cl_113 = (byte) cx_112;
} while (cx_112 != 0x0000);
bx_114 = bx_114 - 0x0001;
bl_116 = (byte) bx_114;
} while (bx_114 != 0x0000);
__outb(0x0331, 0x3F);
Mem129[ss:fp - 0x0002:word16] = 0xFA00;
byte Eq_104::*si_122 = Eq_104::a0000;
byte Eq_104::*di_125 = Eq_104::aFFFFFA00;
word16 cx_126 = 0x0140;
do
{
0xA000->*di_125 = 0xA000->*si_122;
si_122 = si_122 + 1;
di_125 = di_125 + 1;
cx_126 = cx_126 - 0x0001;
} while (cx_126 != 0x0000);
Mem151[ss:fp - 0x0002:word16] = 0x0177;
do
;
while (((byte) __inw(0x03DA) & 0x08) == 0x00);
return;
}
_pure_ static const char *slice_sub_state_to_string(Unit *u) {
assert(u);
return slice_state_to_string(SLICE(u)->state);
}
_pure_ static UnitActiveState slice_active_state(Unit *u) {
assert(u);
return state_translation_table[SLICE(u)->state];
}