Chaos.cpp

// *********************************************************
//  This collection of code is a translation of the
//  'Create New Adventure' function.  It reads an
//  old Dungeon Master  or Prison save file and creates
//  a new Chaos Strikes Back  save file.
// *********************************************************

#include "stdafx.h"

// #include "Objects.h"
#include "Dispatch.h"
#include "UI.h"
#include "CSB.h"
#include "Data.h"

#include <stdio.h>

static void DontDoThis(i32 n)
{
   char msg[1000];
   sprintf(msg, "Don't Do This #0x%x\n"
                "The UTILITY functions are designed to create a\n"
                " Chaos Strikes Back game from a Prison SAVEGAME\n"
                " and a 'mini.dat' file.  It will not import nor\n"
                " edit characters nor anything else.  You load a\n"
                " prison savegame, press 'Make New Adventure' twice\n"
                " choose a name for the new adventure, and quit.\n"
                " You can then RESTART at the prison door and\n"
                " and select your new game to play.  You will\n"
                " start naked in a dark room filled with worms.\n"
                " If you try to use this program in any other \n"
                " way you will probably be unhappy with the\n"
                " results.  But you need not complain.  I won't listen.",
           n);
   UI_MessageBox(msg, "Error", MESSAGE_OK);
}

#define CHAOSFILL(a, b) i8 fill##a[a - b];
i32 ReadExtendedFeatures(i32 handle);
ui32 FormChecksum(ui8 *buf, i32 num);
void info(char *, unsigned int);
ui16 countDSAs();
void WriteDSAs(i32 handle);
void WriteDSALevelIndex(i32 handle);

// extern bool ForcedScreenDraw;
extern i32 keyboardMode;
extern char ExtendedFeaturesVersion;
extern bool indirectText;
extern bool bigActuators;
extern bool sequencedTimers;
extern bool extendedTimers;
extern bool DefaultDirectXOption;
extern ui32 cellflagArraySize;
extern DSAINDEX DSAIndex;

#pragma pack(1)

void _CALL0(CODESTATE s);
void _CALL1(CODESTATE s, i32 a);
void _CALL2(CODESTATE s, i32 a, i32 b);
void _CALL3(CODESTATE s, i32 a, i32 b, i32);
void _CALL4(CODESTATE s, i32 a, i32 b, i32 c, i32 d);
void _CALL5(CODESTATE s, i32 a, i32 b, i32 c, i32 d, i32 e);
void _CALL6(CODESTATE s, i32 a, i32 b, i32 c, i32 d, i32 e, i32 f);
void _CALL7(CODESTATE s, i32 a, i32 b, i32 c, i32 d, i32 e, i32 f, i32 g);
void _CALL8(CODESTATE s, i32 a, i32 b, i32 c, i32 d, i32 e, i32 f, i32 g, i32 h);
void _CALL9(CODESTATE s, i32 a, i32 b, i32 c, i32 d, i32 e, i32 f, i32 g, i32 h, i32 i);

struct DlgButton
{
   i8 byte0;
   i8 byte1;
   wordRectPos rectPos2;
   i8 byte10;
   i8 byte11;
};

struct S12406
{
   i8 byte0;
   i8 byte1;
   DlgButton *pDlgButton2; // An array of DlgButton
   pnt pnt6;
   pnt pnt10;
};

struct STRUCT6
{
   i32 int0;
   i16 word4;
};

struct STRUCT12
{
   i32 long0;
   i16 word4;
   i16 word6;
   void (*fnc8)(pnt);
};

#define size3764 880

struct E
{
   // PALETTE palette24862; (Use palette24862)
   // pnt     Byte24830[16];(use byte24830)
   i16 Word24814;
   pnt Pnt24812;
   i16 Word24808;
   i16 Word24806;
   i16 Word24804;
   i16 Word24802;
   i16 Word24800;
   i16 Word24798;
   i16 Word24796;
   i16 Word24794;
   // i8      Byte24792;
   // i8      adjust24792;
   pnt Pnt24792;
   i32 Long24300;
   pnt Pnt24296[100];
   pnt Pnt23896[100];
   i16 Word23496;
   char Byte23494[1];
   CHAOSFILL(23493, 23414)
   // RectPos rectPos23414; (use rectPos23414)
   i16 Word23398;
   i16 Word23396;
   ui8 Byte23394[10608]; // bitmap 102 lines by 104 bytes
   // pnt     UtilityDiskMessages; //12786
   // pnt     Pnt12782;  // to
   // pnt     Pnt12678;   // 12618
   // i32     Long12658;   // are
   // i32     Long12654;    // 42 string pointers.
   //                        // (use UtilityDiskMessages[i])
   // pnt     Pnt12446;//use pnt12446;
   // i8      Byte12406;(use s12406)
   //  never referenced i8      Byte12392;
   // pnt     Pnt12364;(use pnt12364);
   i8 Byte12336[6]; // actually i32 and i16
   // pnt     Pnt12246;(use pnt12246)
   // pnt     Pnt12242;(use pnt12242)
   // pnt     Pnt12238;(use pnt12238)
   // pnt     Pnt12226;(use pnt12226)
   // pnt     Pnt12222;(use pnt12222)
   i16 Word12196;
   i16 GameFile; // 12194;
   i16 Word12184;
   PALETTE palette10938;
   i32 Long9220;
   i16 FirstQueuedMouseEvent; // 9216;
   i16 LastQueuedMouseEvent;  // 9214;
   i8 Byte9212;
   i8 Byte9211;
   i16 Word9210;
   i16 Word9208;
   i16 Word9206;
   i16 Word9204;
   i8 Byte9202[30]; // 5 * (i32+i16) ???
   i8 Byte9172[6];  // i32 and i16??
   // pnt     Pnt9142;//use pPnt9142
   // i16     Word9138[7];//use word9138
   i16 Word9124;
   i16 Word9122;
   i16 Word9120;
   i16 Word9116;
   i16 Word9110;
   i16 Word9108;
   i16 Word9106;
   i16 Word9104;
   i16 Word9102;
   i16 Word9098;
   i16 Word8842[1];
   // never referenced i8      Byte8586[1];
   i16 Word8330[1];
   i16 Word8328[1];
   i16 Word8074;
   i16 Word8072;
   i16 Word8070;
   i16 Word8068;
   i16 Word8066;
   pnt Pnt8064;
   pnt Pnt8060;
   i16 Word8056;
   i16 Word8054;
   ui8 *PhysicalBase; // 8052;
   i16 Word8048;
   i16 Word7062;
   i16 ActualCharacter;         // Word7060
   i8 CharacterImages[4 * 464]; // Byte7058
   i8 Byte5202[24];
   i16 Word5178;
   wordRectPos wRectPos5176;
   i16 Word5168;
   i16 EditBoxSelected; // Word5166 //either NAME or TITLE
   i16 EditBoxPosition; // Word5164
   // wordRectPos wRectPos5162;(use wRectPos5162)
   // wordRectPos wRectPos5154;(use wRectPos5154)
   // wordRectPos wRectPos5146;(use wRectPos5146)
   // wordRectPos wRectPos5138[4];(use wRectPos5138)
   // wordRectPos wRectPos5106[4];(use wRectPos5106)
   // wordRectPos wRectPos5066;(use wRectPos5066)
   // wordREctPos wRectPos5058;(use wREctPos5058)
   // DlgButton dlgButton5050[4];//(use dlgButton5050)
   i8 Byte4930[1];
   CHAOSFILL(4929, 4712)
   // i8      Byte4712[16];(use byte4712)
   i16 Word4696;
   i8 Byte4694[464];
   CHAOSFILL(4230, 4228)
   i8 Byte4228[464];
   i8 Byte3764[size3764];
   i16 Word3122;
   i16 Word826[5];
   i16 Word816[16];
   i16 Word784[17];
   i16 Word750[8];
   i16 Word734[6];
   i16 Word722[6];
   i16 *Pnt714[7];
   i16 Word686;
   i16 *pw664;
   pnt Pnt660;
   i16 *pw656;
   i16 *pw652;
   pnt pAllocDBank434;
   pnt Pnt430;
   i16 Word426;
   i16 Word424;
   pnt pDBank422;
   i16 Word418;
   i32 DBankLen416;
   i8 Byte412[8];
};

E e;

unsigned char SelectedColor;

PALETTE palette24862 = {
    0x0000, 0x0333, 0x0444, 0x0310, 0x0066, 0x0420, 0x0040, 0x0060, 0x0700, 0x0750, 0x0643, 0x0770, 0x0222, 0x0555, 0x0007, 0x0777};

i8 byte24830[16] ALIGN4 = {4, 6, 4, 8, 16, 4, 4, 4, 4, 8, 4, 0, 0, 0, 8, 4};

wordRectPos rectPos23414 = {0, 193, 0, 101};
wordRectPos rectPos23406 = {62, 255, 48, 149};

static i32 textArraySize; // Number of words
static char *textArray;
static DB2 *DB2Address;
static i32 DB2Size;
static i32 compressedTextSize;
char *compressedText = NULL;

const char *positions = "CSBGAME\nCSBGAME2\nCSBGAME3\nCSBGAME4\nCANCEL";

// ARGHH!
const char *filenames[] = {
    "CSBGAME.DAT",
    "CSBGAME2.DAT",
    "CSBGAME3.DAT",
    "CSBGAME4.DAT",
};

const char *UtilityDiskMessages[43] =
    {
        "\nPLEASE PUT A\nSAVE GAME DISK IN @",                                  // 0
        "\nPUT PORTRAIT DISK\nIN @",                                            // 1
        "\nPUT A BLANK DISK\nIN @",                                             // 2
        "",                                                                     // 3
        "",                                                                     // 4
        "",                                                                     // 5
        "\n\nREPLACE EXISTING SAVED GAME?",                                     // 6
        "",                                                                     // 7
        "\n\nREPLACE $'s PORTRAIT?",                                            // 8
        "\n\nPLEASE WAIT . . .\nLOADING SAVED GAME",                            // 9
        "\n\nPLEASE WAIT . . .\nSAVING GAME",                                   // 10
        "",                                                                     // 11
        "\n\nCAN'T FIND SAVED GAME",                                            // 12
        "",                                                                     // 13
        "\nSAVED GAME ERROR",                                                   // 14
        "\nERROR WHILE\nSAVING GAME",                                           // 15
        "",                                                                     // 16
        "",                                                                     // 17
        "",                                                                     // 18
        "",                                                                     // 19
        "\nEACH CHAMPION MUST\nHAVE A UNIQUE FIRST NAME!",                      // 20
        "",                                                                     // 21
        "\n\nPLEASE WAIT . .\nLOADING SAVED ADVENTURE",                         // 22
        "\n\nPLEASE WAIT . .\nSAVING NEW ADVENTURE",                            // 23
        "CAN'T FIND\nNEW ADVENTURE\nMINI.DAT",                                  // 24
        "\nTHE NEW ADVENTURE\nIS DAMAGED",                                      // 25
        "",                                                                     // 26
        "",                                                                     // 27
        "\nERROR WHILE SAVING\nNEW ADVENTURE",                                  // 28
        "THE NEW ADVENTURE\nCAN ONLY BE MADE AFTER\nA SAVED GAME IS LOADED.",   // 29
        "\nCAN'T MAKE NEW ADVENTURE\nFROM THIS SAVED GAME.\nALREADY UTILIZED.", // 30
        "LOAD WHICH SAVED GAME?",                                               // 31
        "OK",                                                                   // 32
        "OK\nCANCEL",                                                           // 33
        "SAVE\nFORMAT\nCANCEL",                                                 // 34
        "MAKE NEW ADVENTURE\nFORMAT\nCANCEL",                                   // 35
        "YES\nNO",                                                              // 36
        "",                                                                     // 37
        "",                                                                     // 38
        "DUNGEON MASTER\nCHAOS STRIKES BACK\nCANCEL",                           // 39
        "",                                                                     // 40
        "",                                                                     // 41
        "\nPLEASE CHOOSE A\nSAVE GAME SLOT",                                    // 42
};

#ifdef _MSVC_INTEL
#pragma warning(disable : 4305)
#pragma warning(disable : 4309)
#endif

i8 byte12618[] ALIGN4 = {01, 00, 00, 13, 00, 00, 00, 00};

DlgButton dlgButton_12610[] = {
    {0x01, 0x00, {0x0050, 0x00ed, 0x0080, 0x0088}, 0x00, 0x01},
    {0x00, 0x00, {0x0000, 0x0000, 0x0000, 0x0000}, 0x00, 0x00},
    {0x01, 0x00, {0x0050, 0x0094, 0x0080, 0x0088}, 0x00, 0x01},
    {0x02, 0x00, {0x00a5, 0x00ed, 0x0080, 0x0088}, 0x00, 0x01},
    {0x00, 0x00, {0x0000, 0x0000, 0x0000, 0x0000}, 0x00, 0x00},
    {0x01, 0x00, {0x0050, 0x0094, 0x006c, 0x0074}, 0x00, 0x01},
    {0x02, 0x00, {0x00a5, 0x00ed, 0x006c, 0x0074}, 0x00, 0x01},
    {0x03, 0x00, {0x007b, 0x00c4, 0x0080, 0x0088}, 0x00, 0x01},
    {0x00, 0x00, {0x0000, 0x0000, 0x0000, 0x0000}, 0x00, 0x00},
    {0x01, 0x00, {0x0050, 0x00ed, 0x006c, 0x0074}, 0x00, 0x01},
    {0x02, 0x00, {0x0050, 0x0094, 0x0080, 0x0088}, 0x00, 0x01},
    {0x03, 0x00, {0x00a5, 0x00ed, 0x0080, 0x0088}, 0x00, 0x01},
    {0x00, 0x00, {0x0000, 0x0000, 0x0000, 0x0000}, 0x00, 0x00},
    {0x01, 0x00, {0x0050, 0x00ed, 0x0058, 0x0060}, 0x00, 0x01},
    {0x02, 0x00, {0x0050, 0x00ed, 0x006c, 0x0074}, 0x00, 0x01},
    {0x03, 0x00, {0x0050, 0x00ed, 0x0080, 0x0088}, 0x00, 0x01},
    {0x00, 0x00, {0x0000, 0x0000, 0x0000, 0x0000}, 0x00, 0x00}};

DlgButton four_dlgButon[] = {
    {0x01, 0x00, {0x0050, 0x0094, 0x0070, 0x0078}, 0x00, 0x01},
    {0x02, 0x00, {0x00a5, 0x00ed, 0x0070, 0x0078}, 0x00, 0x01},
    {0x03, 0x00, {0x0050, 0x0094, 0x0080, 0x0088}, 0x00, 0x01},
    {0x04, 0x00, {0x00a5, 0x00ed, 0x0080, 0x0088}, 0x00, 0x01},
    {0x00, 0x00, {0x0000, 0x0000, 0x0000, 0x0000}, 0x00, 0x00}};

#ifdef _MSVC_INTEL
#pragma warning(default : 4305)
#pragma warning(default : 4309)
#endif

S12406 s12406[] = {
    {00, 00, &dlgButton_12610[0], byte12618, NULL},
    {00, 00, &dlgButton_12610[2], NULL, NULL},
    {00, 00, &dlgButton_12610[5], NULL, NULL},
    {00, 00, &dlgButton_12610[9], NULL, NULL},
    {00, 00, &dlgButton_12610[13], NULL, NULL}};

S12406 fourbuttons[] = {
    {00, 00, &four_dlgButon[0], NULL, NULL}};

const char *pnt12246 = "DMGAME.DAT";
const char *pnt12242 = "DMGAME.BAK";
const char *pnt12238 = "CSBGAME.DAT";
const char *pnt12234 = "CSBGAME.BAK";
const char *pnt12222 = "DRIVE B:";
const char *pnt12226 = "DRIVE A:";

S12406 *pS12406_9166[6] = {NULL, NULL, NULL, NULL, NULL, NULL}; // guessed size!
S12406 **ppS12406_9142 = pS12406_9166;

i16 word9138[] = {
    0x4737,  // turn right
    0x4838,  // forward
    0x4b34,  // slide left
    0x4d36,  // slide right
    0x5032,  // backup
    0x5230,  // turn left
    0x532e}; // delete

ui32 FrameImage[246] = // byte8046
    {
        0xffff0000, 0xffff0000, 0xffff0000, 0xffff0000, 0xfff00000, 0xfff00000, 0xbfff3fff, 0x80000000, 0xffffffff, 0x00000000, 0xfff0fff0, 0x00000000, 0xdfff5fff, 0x80000000, 0xffffffff, 0x00000000, 0xfff0ffd0, 0x00200000, 0xefff6fff, 0x80000000, 0xffffffff, 0x00000000, 0xfff0ff90, 0x00600000, 0xf7ff77ff, 0x80000000, 0xffffffff, 0x00000000, 0xfff0ff10, 0x00e00000, 0xfbff7bff, 0x80000000, 0xffffffff, 0x00000000, 0xfff0fe10, 0x01e00000, 0xfc307c30, 0x83ff0030, 0x00e400e4, 0xffff00e4, 0x03f00010, 0xffe00000, 0xfc607c60, 0x83ff0060, 0x01c801c8, 0xffff01c8, 0x03f00010, 0xffe00000, 0xfc807c80, 0x83ff0080, 0x03800380, 0xffff0380, 0x07f00410, 0xffe00400, 0xfc007c00, 0x83ff0000, 0x07000700, 0xffff0700, 0x0ff00c10, 0xffe00c00, 0xfc007c00, 0x83ff0000, 0x1e001e00, 0xffff1e00, 0x0bf00810, 0xffe00800, 0xfc007c00, 0x83ff0000, 0x7c007c00, 0xffff7c00, 0x13f01010, 0xffe01000, 0xfc007c00, 0x83ff0000, 0xf800f800, 0xfffff800, 0x23f02010, 0xffe02000, 0xfc017c01, 0x83ff0001, 0xf000f000, 0xfffff000, 0x43f04010, 0xffe04000, 0xfc037c03, 0x83ff0003, 0xe000e000, 0xffffe000, 0x03f00010, 0xffe00000, 0xfc077c07, 0x83ff0007, 0x00000000, 0xffff0000, 0x03f00010, 0xffe00000, 0xfc0c7c0c, 0x83ff000c, 0x00000000, 0xffff0000, 0x03f00010, 0xffe00000, 0xfc187c18, 0x83ff0018, 0x00000000, 0xffff0000, 0x03f00010, 0xffe00000, 0xfc207c20, 0x83ff0020, 0x00000000, 0xffff0000, 0x03f00010, 0xffe00000, 0xfc407c40, 0x83ff0040, 0x00000000, 0xffff0000, 0x03f00010, 0xffe00000, 0xfc807c80, 0x83ff0080, 0x00000000, 0xffff0000, 0x03f00010, 0xffe00000, 0xfc007c00, 0x83ff0000, 0x00000000, 0xffff0000, 0x23f02010, 0xffe02000, 0xfc007c00, 0x83ff0000, 0x00000000, 0xffff0000, 0x43f04010, 0xffe04000, 0xfc007c00, 0x83ff0000, 0x00010001, 0xffff0001, 0x83f08010, 0xffe08000, 0xfc007c00, 0x83ff0000, 0x00030003, 0xffff0003, 0x03f00010, 0xffe00000, 0xfc007c00, 0x83ff0000, 0x000e000e, 0xffff000e, 0x03f00010, 0xffe00000, 0xfc007c00, 0x83ff0000, 0x001c001c, 0xffff001c, 0x03f00010, 0xffe00000, 0xfc207c20, 0x83ff0020, 0x00380038, 0xffff0038, 0x03f00010, 0xffe00000, 0xfc407c40, 0x83ff0040, 0x00780078, 0xffff0078, 0x07f00410, 0xffe00400, 0xfd807d80, 0x83ff0180, 0x00700070, 0xffff0070, 0x0ff00c10, 0xffe00c00, 0xff007f00, 0x83ff0300, 0x00e000e0, 0xffff00e0, 0x3bf03810, 0xffe03800, 0xfe007e00, 0x83ff0200, 0x00e000e0, 0xffff00e0, 0x73f07010, 0xffe07000, 0xfc007c00, 0x83ff0000, 0x81c081c0, 0xffff81c0, 0x43f04010, 0xffe04000, 0xfc037c03, 0x83ff0003, 0x07800780, 0xffff0780, 0x83f08010, 0xffe08000, 0xfc0e7c0e, 0x83ff000e, 0x0f000f00, 0xffff0f00, 0x03f00010, 0xffe00000, 0xffff7c00, 0x83ff0000, 0xffff0000, 0xffff0000, 0xfff00210, 0xfde00000, 0xffff7800, 0x87ff0000, 0xffff0000, 0xffff0000, 0xfff00110, 0xfee00000, 0xffff7000, 0x8fff0000, 0xffff0000, 0xffff0000, 0xfff00090, 0xff600000, 0xffff6000, 0x9fff0000, 0xffff0000, 0xffff0000, 0xfff00050, 0xffa00000, 0xffff4000, 0xbfff0000, 0xffff0000, 0xffff0000, 0xfff00030, 0xffc00000, 0xffff7fff, 0x80000000, 0xffffffff, 0x00000000, 0xfff0fff0, 0x00000000};

wordRectPos wRectPos5162 = {0x009d, 0x00fc, 0x003c, 0x0092};
wordRectPos wRectPos5154 = {0x011e, 0x012f, 0x002b, 0x00a9};
wordRectPos wRectPos5146 = {0x011c, 0x0131, 0x0029, 0x00ab};
wordRectPos wRectPos5138[4] =
    {
        {0x000b, 0x002a, 0x000e, 0x002a},
        {0x004e, 0x006d, 0x000e, 0x002a},
        {0x0091, 0x00b0, 0x000e, 0x002a},
        {0x00d3, 0x00f2, 0x000e, 0x002a}};

wordRectPos wRectPos5106[7] =
    {
        {0x000b, 0x002a, 0x000e, 0x002a}, //[0]=5106
        {0x004e, 0x006d, 0x000e, 0x002a}, //[1]=5098
        {0x0091, 0x00b0, 0x000e, 0x002a}, //[2]=5090
        {0x00d3, 0x00f2, 0x000e, 0x002a}, //[3]=5082
        {0x004d, 0x0078, 0x0038, 0x0060}, //[4]=5074
        {0x0053, 0x0072, 0x003e, 0x005a}, //[5]=5066
        {0x0000, 0x0098, 0x0072, 0x00af}, //[6]=5058
};

DlgButton dlgButton5050[17] =
    {
        {0x01, 0, {4, 48, 3, 42}, 0, 1},       //[ 0]=5050
        {0x02, 0, {71, 115, 3, 42}, 0, 1},     //[ 1]=5038
        {0x03, 0, {138, 182, 3, 42}, 0, 1},    //[ 2]=5026
        {0x04, 0, {205, 249, 3, 42}, 0, 1},    //[ 3]=5014
        {0x05, 0, {157, 252, 60, 146}, 0, 1},  //[ 4]=5002
        {0x06, 0, {157, 252, 60, 146}, 0, 2},  //[ 5]=4990
        {0x07, 0, {286, 303, 43, 169}, 0, 1},  //[ 6]=4978
        {0x08, 0, {156, 196, 159, 167}, 0, 1}, //[ 7]=4966
        {0x09, 0, {225, 253, 159, 167}, 0, 1}, //[ 8]=4954
        {0x64, 0, {350, 349, 250, 249}, 0, 0}, //[ 9]=4942
        {0x0b, 0, {2, 92, 186, 194}, 0, 1},    //[10]=4930
        {0x0c, 0, {102, 192, 186, 194}, 0, 1}, //[11]=4918
        {0x0d, 0, {202, 316, 186, 194}, 0, 1}, //[12]=4906
        {0x0e, 0, {15, 59, 87, 95}, 0, 1},     //[13]=4894
        {0x0f, 0, {15, 131, 100, 108}, 0, 1},  //[14]=4882
        {0x66, 0, {350, 349, 250, 249}, 0, 0}, //[15]=4870
        {0x11, 0, {288, 316, 5, 13}, 0, 1},    //[16]=4858
};

i8 byte4846[8] ALIGN4 = {0x09, 0x00, 0x61, 0x00, 0x01, 0x00, 0x3b, 0x00};

S12406 s12406_4802 =
    {
        01, 00, &dlgButton5050[0], byte4846, NULL};

const char *pnt4788[] =
    {
        "FIGHTER",
        "NINJA",
        "PRIEST",
        "WIZARD"};

const char *pnt4772[16] =
    {
        "NEOPHYTE   ",
        "NOVICE     ",
        "APPRENTICE ",
        "JOURNEYMAN ",
        "CRAFTSMAN  ",
        "ARTISAN    ",
        "ADEPT      ",
        "EXPERT     ",
        "` MASTER   ",
        "a MASTER   ",
        "b MASTER   ",
        "c MASTER   ",
        "d MASTER   ",
        "e MASTER   ",
        "ARCHMASTER "};

i8 byte4712[16] ALIGN4 = {0x00, 0x0c, 0x01, 0x02, 0x0d, 0x0f, 0x03, 0x05, 0x0a, 0x08, 0x09, 0x0b, 0x07, 0x06, 0x04, 0x0e};

i8 Byte1278[420] ALIGN4 = {
    0x00, 0x06, 0x1b, 0x0a, 0x0f, 0x19, 0x0c, 0x06, 0x06, 0x0c, 0x09, 0x04, 0x00, 0x00, 0x00, 0x03, 0x0e, 0x02, 0x1e, 0x1e, 0x06, 0x1e, 0x0e, 0x1f, 0x0e, 0x0e, 0x06, 0x06, 0x03, 0x00, 0x0c, 0x0e, 0x0e, 0x0e, 0x1e, 0x0f, 0x1e, 0x1f, 0x1f, 0x0f, 0x11, 0x1f, 0x01, 0x09, 0x08, 0x11, 0x11, 0x0e, 0x1e, 0x0e, 0x1e, 0x0f, 0x1f, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1f, 0x0f, 0x18, 0x0f, 0x04, 0x00, 0x04, 0x1f, 0x00, 0x04, 0x18, 0x01, 0x00, 0x06, 0x1b, 0x1f, 0x14, 0x1a, 0x1a, 0x06, 0x0c, 0x06, 0x06, 0x04, 0x00, 0x00, 0x00, 0x06, 0x13, 0x06, 0x01, 0x01, 0x0a, 0x10, 0x10, 0x01, 0x11, 0x11, 0x06, 0x06, 0x06, 0x0f, 0x06, 0x13, 0x11, 0x11, 0x11, 0x10, 0x11, 0x10, 0x10, 0x10, 0x11, 0x04, 0x01, 0x0a, 0x08, 0x1b, 0x19, 0x11, 0x11, 0x11, 0x11, 0x10, 0x04, 0x11, 0x11, 0x11, 0x0a, 0x11, 0x02, 0x0c, 0x0c, 0x03, 0x0e, 0x00, 0x09, 0x11, 0x1f, 0x0a, 0x04, 0x03, 0x00, 0x06, 0x12, 0x0a, 0x0e, 0x04, 0x0c, 0x0c, 0x0c, 0x06, 0x0f, 0x1f, 0x00, 0x0f, 0x00, 0x0c, 0x15, 0x02, 0x0e, 0x0e, 0x12, 0x1e, 0x1e, 0x02, 0x0e, 0x0f, 0x00, 0x00, 0x0c, 0x00, 0x03, 0x06, 0x17, 0x1f, 0x1e, 0x10, 0x11, 0x1e, 0x1e, 0x13, 0x1f, 0x04, 0x01, 0x0c, 0x08, 0x15, 0x15, 0x11, 0x1e, 0x11, 0x1e, 0x0e, 0x04, 0x11, 0x11, 0x15, 0x04, 0x0a, 0x04, 0x0c, 0x06, 0x03, 0x1b, 0x00, 0x12, 0x11, 0x00, 0x11, 0x07, 0x05, 0x00, 0x06, 0x00, 0x1f, 0x05, 0x0b, 0x1d, 0x00, 0x0c, 0x06, 0x06, 0x04, 0x06, 0x00, 0x06, 0x18, 0x19, 0x02, 0x10, 0x01, 0x1f, 0x01, 0x11, 0x04, 0x11, 0x01, 0x06, 0x06, 0x06, 0x0f, 0x06, 0x06, 0x16, 0x11, 0x11, 0x10, 0x11, 0x10, 0x10, 0x11, 0x11, 0x04, 0x11, 0x0a, 0x08, 0x11, 0x13, 0x11, 0x10, 0x11, 0x14, 0x01, 0x04, 0x11, 0x0a, 0x1b, 0x0a, 0x04, 0x08, 0x0c, 0x03, 0x03, 0x00, 0x00, 0x09, 0x11, 0x1f, 0x0a, 0x04, 0x09, 0x00, 0x00, 0x00, 0x0a, 0x1e, 0x13, 0x1a, 0x00, 0x06, 0x0c, 0x09, 0x04, 0x06, 0x00, 0x06, 0x10, 0x0e, 0x02, 0x1f, 0x1e, 0x02, 0x1e, 0x0e, 0x04, 0x0e, 0x0e, 0x06, 0x02, 0x03, 0x00, 0x0c, 0x00, 0x10, 0x11, 0x1e, 0x0f, 0x1e, 0x1f, 0x10, 0x0f, 0x11, 0x1f, 0x0e, 0x09, 0x0f, 0x11, 0x11, 0x0e, 0x10, 0x0e, 0x13, 0x1e, 0x04, 0x0f, 0x04, 0x11, 0x11, 0x04, 0x1f, 0x0f, 0x01, 0x0f, 0x00, 0x00, 0x04, 0x1f, 0x00, 0x04, 0x18, 0x1f, 0x00, 0x06, 0x00, 0x00, 0x04, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x06, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

ui32 Long954[4] = {
    0xfff0fff0, 0xfff8fff8, 0xfffcfffc, 0xfffefffe};
ui32 Long938[4] = {
    0x7fff7fff, 0x3fff3fff, 0x1fff1fff, 0x0fff0fff};

void reverseBMP(ui32 *bmp, i32 n)
{
   ASSERT(((uintptr_t)bmp & 3) == 0, "bmp");
   for(i32 i = 0; i < n; i++)
      bmp[i] = LE32(bmp[i]);
}

void InitializeE()
{
   memset(&e, 0, sizeof(e));
   reverseBMP(FrameImage, 246);
}

void pumper(); // Pump any queued Windows messages
ui8 *MALLOC(i32 size);
void MFREE(ui8 *address);
// i32  DIRECT_CONIN(); // Trap 1 #0x07
// i16  CONSTAT();      // Trap 1 #0x0b
void SetSupervisorMode();
void ClearSupervisorMode();
// void ClearMemory(pnt dest, i16 numByte); // TAG000a84
ui8 *physbase();
void SetDLogicalBase(ui8 *);
// i16  OPEN(char *name, i32 ref);
// i16  CREATE(char *name, i16 flag);
i32 READ(i32 file, i32 len, ui8 *buf);
i32 WRITE(i16 file, i32 len, ui8 *buf);
i16 CLOSE(i32 handle);
void StrCpy(char *dst, const char *src);          // TAG003264
i16 StrLen(const char *string);                   // TAG0032ba
void MemMove(ui8 *src, ui8 *dest, i16 byteCount); // TAG0009dc
// void TextToScreen(i32, i32, i32, i32, pnt);//TAG001c42
i16 Unscramble(ui8 *buf, i32 initialChecksum, i32 numwordM1);
i16 GenChecksum(ui8 *buf, i16 initSum, i32 numword); // TAG01d076
//   TAG000c04
static i16 MyWriteScrambled(ui8 *, i16, ui16, ui16 *); // TAG01d0ea

//     TAG0000d6
ui32 Times(ui32, ui32);
void TAG00022a(i16);
void TAG0002b0();
void TAG0002c2();
void TAG0002d0();
void TAG00031c();
ui8 *AllocateMemory(i32);                          // TAG000328
void ReleaseMemory(ui8 *);                         // TAG0003a0
char *GetSubString(const char *, char *, i16);     // TAG000472
void PrintDialogText(const char *, i32, i32, i32); // TAG0004ec
void TAG00054a();
void TAG0006e4();
i16 TAG0008dc(i16);
i16 TAG000952();
void TAG0009a8();
i16 ReadGameFile(ui8 *, i32);  // TAG000aee
i16 WriteGameFile(ui8 *, i16); // TAG000b28
// i16    TAG000b94(pnt,i16,i16);(use GenChecksum)
//      TAG000bc8
static i16 MyUnscrambleStream(ui8 *buf, i32 size, i16 initialHash, i16 Checksum);
i16 ReadAndChecksum(ui8 *buf, i16 *pChecksum, i32 size); // TAG000c52
static i16 MyWriteAndChecksum(ui8 *, ui16 *, i32);       // TAG000c98
i16 ReadGameBlock1(ui8 *);                               // TAG000cde
i16 UnscrambleBlock1(ui8 *, i16);                        // TAG000d08
i16 WriteFirstBlock(ui8 *, i16);                         // TAG000d7c
void TAG00136c();
i16 TAG00142e(ui8 *);
void TAG001676(ui8 *, i16);
void TAG002724();
i16 TestInRectangle(wordRectPos *, i32 x, i32 y); // TAG002c70
void TAG002ca8();
i16 TAG002cdc(DlgButton *, i32, i32, i32);
void EnqueMouseClick(i32, i32, i32); // TAG002d3c
void CheckPendingMouseClick();       // TAG002e2c
void TAG002e4a(i32);
i16 TAG002faa(S12406 *P1);
// i16    TAG002faa(pnt);
//      TAG003000
S12406 **SetActiveDialog(S12406 **); // Actually an array of (6) &S12406
void TAG003106(i16);
void TAG0031a6(i16);
void TAG00323c();
void TAG00324c();
void TAG003264();
void TAG003294(i16, i16);
void TAG0032b4(i16, i16);
void BitBltSquareImage(pnt, const wordRectPos *, i16, i16); // TAG0033b6
//     TAG0033e6
void FillScreenRectangle(wordRectPos *, i16);
void DrawNameTitleCarret(i16, i16); // TAG003406
//     TAG0034dc
void ExpandRectangle(wordRectPos *, wordRectPos *, i16, i16);
//     TAG0035cc
void DrawDialogBoxOutline(wordRectPos *, i16, i16, i16);
void PrintCharacterName(i16);                         // TAG003748
void DrawCharacterHeader(i16, i16);                   // TAG0037ac
void AddDialogButton(DlgButton *, const char *, i16); // TAG003860
void TAG0039a8();
void FillCharacterNameEditBox(const char *, i16, i16); // TAG0039ea
void PrintAttributeValue(const char *, i32, i32);      // TAG003a7c
void DrawMagnifiedCharacterImage();                    // TAG0036c0
void GetPalleteItemRect(i16, wordRectPos *);           // TAG0038ea
void DrawSelectedColor(i16);                           // TAG003922
void TAG00439e();
// void TAG004a32(char *); //FadeToPalette
//    TAG004bbc
void TextOutB(ui8 *dest,
              i32 destWidth,
              i32 x,
              i32 y,
              i32 color,
              i32 P6,
              const char *text);
void TextToScreen(i32, i32, i32, i32, const char *); // TAG004e76
i16 TAG004ec0(i32);
void TAG004ea2(i16 *);
i16 TAG00507e();
i16 TAG0050d2();
i16 TAG005868(i16 *, i16 *, i16 *, i16 *);
void TAG00589e(i16, i16);
// void TAG005c50(i32); //Trap #14
void TAG005c92(pnt);
void TAG005cd6(pnt *);
void TAG005cf6();
void TAG005d12(i16 *, i16 *, i16 *);
void TAG005d8e(i16 *, i16 *, i16 *);
void TAG005df2(i16);
void TAG0061ba(i16, i16);
void TAG0061e2(i16);
void TAG006202(i16, i16 *, i16 *, i16 *);
void TAG00623a(i16, char *, char **);
void TAG00626e(i16, char *, char **);
pnt FormatInteger(pnt, ui32, i16); // TAG0064b4
// void   TAG006520(pnt,pnt);StrCpy
// i16    TAG00654e(pnt, pnt);strcmp
// i16    TAG0065bc(pnt);//StrLen
i32 atari_sprintf(char *, const char *, intptr_t, intptr_t, intptr_t = 0); // TAG0065e0
i32 GetPixel(pnt, i16, i16, i16);                                          // TAG006700
// void   TAG006892(...) //Use TAG0088b2 from Graphics.cpp
// void   TAG00716a(pnt, RectPos *, i16 color, i16 dstwidth); (FillRectangle)
ui8 *TAG0073b0(ui8 *);
ui8 *TAG0073d4(ui8 *);
void TAG007416(char *, char *);
void TAG00744c(ui8 *, ui8 *);
void TAG0074ae(char *, i32, char *);
void TAG0074ea(ui8 *, i32, ui8 *);
ui8 *TAG007552(i32, ui8 *, i16 *);
i16 TAG007904(char **, i32);
ui8 *TAG007a1a(i16);
char *TAG007ac0(ui8 **);
void TAG007b68(ui8 *);
char *TAG007bba(STRUCT6 *);
ui8 *TAG007cc6(i32, i16, char *);
ui8 *TAG007d4c(STRUCT12 *);
void TAG007e16(ui8 *, ui8 *);
i32 TAG007e42(i16, i16);
void TAG007f54();
ui8 *TAG007f64(i32, i16);
i32 TAG007f92(ui8 *);
ui8 *TAG007fe8(ui8 *);
void TAG00801e(ui8 *);
i32 TAG0080e0(ui8 *);
//     TAG00858c
void MemoryMove(ui8 *, ui8 *, i16, i16, i32); // like MemMove
// void TAG0086a8(pnt, i32);//ClearMemory
i32 TAG008788(i16, i32, ui32);
void EditCharacterName(char key);

void StorePnt(ui8 *addr, ui8 *data)
{
   // A little explanation is in order here, perhaps.
   // Some platforms require that 32-bit words be on 4-byte
   // boundaries.  In the runtime we moved all 32-bit words
   // to conform with this requirement.  But here we simply
   // fetch and store them by referencing two 16-bit words.
#ifdef _bigEndian
   xxxxx
#else
   *((ui16 *)(addr)) = (ui16)((ui32)data);
   *((ui16 *)(addr + 2)) = (ui16)(((ui32)data) >> 16);
#endif
}
void StorePnt(aReg addr, aReg data)
{
   StorePnt((ui8 *)addr, (ui8 *)data);
}

void StorePnt(aReg addr, ui8 *data)
{
   StorePnt((ui8 *)addr, data);
}

ui8 *LoadPnt(ui8 *addr)
{
   // A little explanation is in order here, perhaps.
   // Some platforms require that 32-bit words be on 4-byte
   // boundaries.  In the runtime we moved all 32-bit words
   // to conform with this requirement.  But here we simply
   // fetch and store them by referencing two 16-bit words.
#ifdef _bigEndian
   xxxxx
#else
   return (ui8 *)((*(ui16 *)(addr)) | ((ui32)((*(ui16 *)(addr + 2))) << 16));
#endif
}
ui8 *LoadPnt(aReg addr)
{
   return LoadPnt((ui8 *)addr);
}

void StoreLong(ui8 *addr, i32 data)
{
   // A little explanation is in order here, perhaps.
   // Some platforms require that 32-bit words be on 4-byte
   // boundaries.  In the runtime we moved all 32-bit words
   // to conform with this requirement.  But here we simply
   // fetch and store them by referencing two 16-bit words.
#ifdef _bigEndian
   xxxxx
#else
   *((ui16 *)(addr)) = (ui16)((ui32)data);
   *((ui16 *)(addr + 2)) = (ui16)(((ui32)data) >> 16);
#endif
}

void StoreLong(aReg addr, i32 data)
{
   StoreLong((ui8 *)addr, data);
}

i32 LoadLong(ui8 *addr)
{
   // A little explanation is in order here, perhaps.
   // Some platforms require that 32-bit words be on 4-byte
   // boundaries.  In the runtime we moved all 32-bit words
   // to conform with this requirement.  But here we simply
   // fetch and store them by referencing two 16-bit words.
#ifdef _bigEndian
   xxxxx
#else
   return (i32)((*(ui16 *)(addr)) | ((ui32)((*(ui16 *)(addr + 2))) << 16));
#endif
}

i32 LoadLong(aReg addr)
{
   return LoadLong((ui8 *)addr);
}

void StorePnt(ui8 *addr, aReg data)
{
   // A little explanation is in order here, perhaps.
   // Some platforms require that 32-bit words be on 4-byte
   // boundaries.  In the runtime we moved all 32-bit words
   // to conform with this requirement.  But here we simply
   // fetch and store them by referencing two 16-bit words.
#ifdef _bigEndian
   xxxxx
#else
   *((ui16 *)((pnt)addr)) = (ui16)((ui32)data);
   *((ui16 *)((pnt)addr + 2)) = (ui16)(((ui32)data) >> 16);
#endif
}

void Storepi16(i16 **addr, i16 *data)
{
   // A little explanation is in order here, perhaps.
   // Some platforms require that 32-bit words be on 4-byte
   // boundaries.  In the runtime we moved all 32-bit words
   // to conform with this requirement.  But here we simply
   // fetch and store them by referencing two 16-bit words.
#ifdef _bigEndian
   xxxxx
#else
   *((ui16 *)((pnt)addr)) = (ui16)((ui32)data);
   *((ui16 *)((pnt)addr + 2)) = (ui16)(((ui32)data) >> 16);
#endif
}

i16 *Loadpi16(i16 **addr)
{
   // A little explanation is in order here, perhaps.
   // Some platforms require that 32-bit words be on 4-byte
   // boundaries.  In the runtime we moved all 32-bit words
   // to conform with this requirement.  But here we simply
   // fetch and store them by referencing two 16-bit words.
#ifdef _bigEndian
   xxxxx
#else
   return (i16 *)((*(ui16 *)((pnt)addr)) | ((ui32)((*(ui16 *)((pnt)addr + 2))) << 16));
#endif
}

// *********************************************************
//
// *********************************************************
//   TAG0000d6
ui32 Times(ui32 P1, ui32 P2)
{
   return P1 * P2;
}

// *********************************************************
//
// *********************************************************
void TAG00022a(i16 P1)
{ // Set/unSet VBL interrupt routine?????
   //;;;;;;;;;;;;;;;;;;;;;
   switch(P1)
   {
      case 1:
         SetSupervisorMode();
         // TAG0002b0();
         ClearSupervisorMode();
         break;
      case 2:
         SetSupervisorMode();
         // TAG0002c2();
         ClearSupervisorMode();
         break;

   }; // switch(P1)
}

// *********************************************************
//
// *********************************************************
void TAG0002d0()
{
   i32 i;
   //;;;;;;;;;;;;;
   e.Word23496 = 0;
   for(i = 0; i < 100; i++)
   {
      StorePnt((ui8 *)&e.Pnt23896[i], (ui8 *)NULL);
      StorePnt((ui8 *)&e.Pnt24296[i], (ui8 *)NULL);

      //
   }
   TAG007e42(100, 50);
}

// *********************************************************
//
// *********************************************************
void TAG00031c()
{
   TAG007f54();
}

// *********************************************************
//
// *********************************************************
//  TAG000328
ui8 *AllocateMemory(i32 P1)
{
   dReg D0;
   ui8 *pnt_8;
   ui8 *pnt_4;
   //;;;;;;;;;;;;;;;;;;;
   pnt_4 = TAG007f64(P1, 0x400);
   D0B = (UI8)(pnt_4 == NULL ? 1 : 0);
   D0W = sw(-D0B);
   if(D0W != 0)
   {
      die(0, "FATAL ERROR: OUT OF MEMORY\nREBOOT");
      for(;;)
      {
      }
   }
   pnt_8 = TAG007fe8(pnt_4);
   StorePnt((ui8 *)&e.Pnt23896[e.Word23496], pnt_8);
   StorePnt((ui8 *)&e.Pnt24296[e.Word23496], pnt_4);
   e.Word23496++;
   return pnt_8;
}

// *********************************************************
//
// *********************************************************
//   TAG0003a0
void ReleaseMemory(ui8 *P1)
{
   ui8 **pntA0, **pntA1;
   i16 w_6;
   ui8 *pnt_4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;
   pnt_4 = NULL;
   for(w_6 = 0; w_6 < e.Word23496; w_6++)
   {
      pntA0 = (ui8 **)&e.Pnt23896[w_6];
      if(P1 != *pntA0)
         continue;
      pntA0 = (ui8 **)&e.Pnt24296[w_6];
      pnt_4 = *pntA0;
      e.Word23496--;
      if(w_6 < e.Word23496)
      {
         pntA0 = (ui8 **)&e.Pnt23896[w_6];
         pntA1 = (ui8 **)&e.Pnt23896[e.Word23496];
         pntA0 = pntA1;
         pntA0 = (ui8 **)&e.Pnt24296[w_6];
         pntA1 = (ui8 **)&e.Pnt24296[e.Word23496];
         pntA0 = pntA1;
      }
      pntA0 = (ui8 **)&e.Pnt23896[e.Word23496];
      *pntA0 = NULL;
      pntA0 = (ui8 **)&e.Pnt24296[e.Word23496];
      *pntA0 = NULL;
      //
      //
   }
   if(pnt_4 == NULL)
      return;
   TAG00801e(pnt_4);
   TAG007f92((ui8 *)pnt_4);
}

// *********************************************************
//
// *********************************************************
char *GetSubString(const char *P1, char *P2, i16 P3)
{
   dReg D6, D7;
   aReg A0, A3, A4;
   const char *pnt_4;
   //;;;;;;;;;
   A4 = (aReg)P1;
   A3 = (aReg)P2;
   D7W = P3;
   while((D6B = *(A4++)) != 0)
   {
      if(D6B == D7B)
      {
         *A3 = 0;
         return (char *)A4;
      }
      if(D6B == 64)
      {
         pnt_4 = TranslateLanguage(pnt12222);
         goto tag0004aa;
      }
      if(D6B != 35)
         goto tag0004be;
      pnt_4 = TranslateLanguage(pnt12226);
   tag0004aa:
      A0 = A3++;
      *A0 = *(pnt_4++);
      if(*A0 != 0)
         goto tag0004aa;
      A3--;
      continue;
   tag0004be:
      if(D6B == 36)
      {
         pnt_4 = (char *)LoadPnt((ui8 *)&e.Pnt24792);
         goto tag0004aa;
      }
      *(A3++) = D6B;
      //
   }
   A4 = NULL;
   *A3 = 0;
   return (char *)A4;
}

// *********************************************************
//
// *********************************************************
void PrintDialogText(const char *P1, i32 P2, i32 P3, i32 P4)
{
   dReg D0, D1;
   char b_40[40];
   //;;;;;;;;;;;;;;;;;;
   while(P1 != NULL)
   {
      P1 = GetSubString(P1, b_40, 10);
      D0W = StrLen(b_40);
      D0W = sw(6 * D0W / 2);
      D1W = sw(P2 - D0W);
      TextToScreen(D1W, P3, P4, 12, b_40);
      P3 += 13;
      //
   }
}

// *********************************************************
//
// *********************************************************
void TAG00054a()
{
   //;;;;;;;;;;;;;;
   if(e.Word23398 == 0)
      return;
   e.Word23398 = 0;
   TAG0088b2(e.Byte23394,                     // src
             LoadPnt((ui8 *)&e.PhysicalBase), // dest
             (RectPos *)&rectPos23406,        // dest position
             0,
             0,
             104,
             160,
             -1);
   if(e.Word23396 != 0)
      e.Word23396--;
   TAG003264();
}

// *********************************************************
//
// *********************************************************
//          TAG000588
RESTARTABLE _UtilityDialogBox(const char *P1, const i32 p2, const char *p3, S12406 *P4)
{ //(i16)
   // Generic Diaog Box??
   static dReg D4, D5, D6;
   static DlgButton *sA4;
   static char b_78[50];
   static S12406 *pS12406_28[6];
   static S12406 **ppS12406_4;
   static i32 P2;
   static const char *P3;
   RESTARTMAP
   RESTART(1)
   RESTART(2)
   END_RESTARTMAP
   P2 = p2;
   P3 = p3;
   //;;;;;;;;;;;;;;;;;;;;
   ClearMemory((ui8 *)pS12406_28, 24);
   pS12406_28[0] = P4;
   D4W = uw(P2 & 0x8000);
   P2 &= 0x7fff;
   if(e.Word23396 == 0)
   {
      e.Word23396++;
      TAG00324c();
   }
   if(e.Word23398 == 0)
   {
      e.Word23398 = 1;
      TAG0088b2(LoadPnt((ui8 *)&e.PhysicalBase), // src
                (ui8 *)e.Byte23394,              // dst
                (RectPos *)&rectPos23414,        // dstPos
                62,                              // srcOffsetX
                48,                              // srcOffsetY
                160,                             // srcByteWidth
                104,                             // dstByteWidth
                -1);                             // P8
   }
   DrawDialogBoxOutline(&rectPos23406, -2, 15, 12);
   PrintDialogText(P1, 159, 65, P2);
   if(P4 == 0)
      RETURN_i16(0);
   for(D5L = 0, sA4 = P4->pDlgButton2;
       (sA4->byte0 != 0) && (P3 != 0);
       D5W++, sA4++)
   {
      P3 = GetSubString(P3, b_78, 10);
      AddDialogButton(sA4, b_78, 2);
      //
      //
   }
   ppS12406_4 = SetActiveDialog(pS12406_28); // save old value
   TAG003264();
   do
   {
      TAG00301c(_1_, e.Byte12336);
      D6W = i16Result;
   } while(D6W == 0);
   TAG00324c();
   if(D4W != 0)
   {
      if((D6W & 255) <= D5W)
      {
         InvertButton(_2_, &P4->pDlgButton2[D6W - 1].rectPos2);
      }
   }
   else
   {
      TAG00054a();
   }
   SetActiveDialog(ppS12406_4);
   RETURN_i16(D6W);
}

void TAG0006e4()
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;
   SetSupervisorMode();
   // SetCriticalErrorHandler();
   ClearSupervisorMode();
   e.Word12196 = 1;
}

// *********************************************************
//
// *********************************************************
i16 TAG000952()
{
   //;;;;;;;;;;;;

   TAG0008dc(0);
   return 1;
}

// *********************************************************
//
// *********************************************************
void TAG0009a8()
{
   DontDoThis(0x9a8);
}

// *********************************************************
//
// *********************************************************
//  TAG000aee
i16 ReadGameFile(ui8 *buf, i32 len)
{
   dReg D0, D7;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   D7L = len;
   if(D7L == 0)
      return 1;
   D0L = READ(e.GameFile, D7L, buf);
   if(D7L == D0L)
      return 1;
   return 0;
}

// *********************************************************
//
// *********************************************************
//  TAG000b28
i16 WriteGameFile(ui8 *buf, i16 size)
{
   dReg D0, D7;
   //;;;;;;;;;;;;;;;;;;;
   D7L = size;
   if(D7L == 0)
      return 1;
   D0L = WRITE(e.GameFile, D7L, buf);
   if(D0L == D7L)
      return 1;
   return 0;
}

// *********************************************************
//
// *********************************************************
i16 TAG000b94(pnt buf, i16 initSum, i16 numword)
{
   return GenChecksum((ui8 *)buf, initSum, numword);
}

// *********************************************************
//
// *********************************************************
//    TAG000bc8
static i16 MyUnscrambleStream(ui8 *buf,
                              i32 size,
                              i16 initialHash,
                              i16 Checksum)
{
   dReg D0;
   //;;;;
   D0W = ReadGameFile(buf, size);
   if(D0W == 0)
      return 0;
   D0W = Unscramble(buf, initialHash, size / 2);
   if(D0W != Checksum)
      return 0;
   return 1;
}

// *********************************************************
//
// *********************************************************
//  TAG01d0ea
i16 MyWriteScrambled(ui8 *buf,
                     i16 byteCount,
                     ui16 initialHash,
                     ui16 *checksum)
{
   dReg D0, D6, D7;
   aReg A3;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   A3 = (aReg)buf;
   D6W = sw(byteCount / 2);
   D0W = Unscramble((ui8 *)A3, initialHash, D6W);
   *checksum = D0W;
   D7W = WriteGameFile((ui8 *)A3, byteCount);
   D0W = Unscramble((ui8 *)A3, initialHash, D6W);
   return D7W;
}

// *********************************************************
//
// *********************************************************
//  TAG000c52
i16 ReadAndChecksum(ui8 *buf, i16 *pChecksum, i32 size)
{
   dReg D0, D6;
   // aReg A4;
   // i16 *wA3;
   //;;;;;;;
   // A4 = P1;
   // wA3 = P2;
   // D7W = sw(P3);
   D6W = 0;
   D0W = ReadGameFile(buf, size);
   if(D0W == 0)
      return 0;
   while((size--) != 0)
   {
      D6W = (UI16)(D6W + ub(*(buf++)));
   }
   *pChecksum = (UI16)(*pChecksum + D6W);
   return 1;
}

// *********************************************************
//
// *********************************************************
//  TAG000c98
i16 MyWriteAndChecksum(ui8 *P1, ui16 *P2, i32 P3)
{
   dReg D0, D6, D7;
   aReg A4;
   ui16 *uwA3;
   //;;;;;;;;;;;;;;;;;;;;;;;;
   A4 = (aReg)P1;
   uwA3 = P2;
   D7W = sw(P3);
   D6W = 0;
   D0W = WriteGameFile((ui8 *)A4, D7W);
   if(D0W == 0)
      return 0;
   while(D7W != 0)
   {
      D6W = (UI16)(D6W + ub(*(A4++)));

      D7W--;
   }
   *uwA3 = (UI16)(*uwA3 + D6W);
   return 1;
}

// *********************************************************
//
// *********************************************************
//  TAG000cde
i16 ReadGameBlock1(ui8 *P1)
{
   dReg D0;
   aReg A4;
   //;;;;;;;;;;;;;;;;;;;;;;
   A4 = (aReg)P1;
   D0W = ReadGameFile((ui8 *)A4, 512);
   if(D0W == 0)
      return 0;
   return 1;
}

// *********************************************************
//
// *********************************************************
//  TAG000d08
i16 UnscrambleBlock1(ui8 *P1, i16 P2)
{
   dReg D5, D6, D7;
   pnt A0, A4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;
   A4 = (aReg)P1;
   D7L = 32;
   D6L = 0;
   do
   {
      D6W = (UI16)(D6W + LE16(wordGear(A4)));
      D6W ^= LE16(wordGear(A4 + 2));
      D6W = (UI16)(D6W - LE16(wordGear(A4 + 4)));
      D6W = (UI16)(D6W ^ LE16(wordGear(A4 + 6)));
      A4 += 8;
      D7W--;
   } while(D7W != 0);
   Unscramble((ui8 *)A4, LE16(wordGear(P1 + 2 * P2)), 128);
   D5W = 0;
   D7W = 128;
   do
   {
      A0 = A4;
      A4 += 2;
      D5W = (UI16)(D5W + LE16(wordGear(A0)));
      D7W--;
   } while(D7W != 0);
   if(D5W == D6W)
      return 1;
   return 0;
}

// *********************************************************
//
// *********************************************************
//  TAG000d7c
i16 WriteFirstBlock(ui8 *buf, i16 offset)
{
   dReg D5, D6, D7;
   aReg A0, A4;
   //;;;;;;;;;;;;;;;;;
   D5W = 0;
   D7W = 128;
   A4 = (aReg)buf + 256;
   do
   {
      D5W = (I16)(D5W + LE16(wordGear(A4))); // Second half-block checksum
      A4 += 2;
      D7W--;
   } while(D7W != 0);
   D7W = 32;
   D6W = 0;
   A4 = (aReg)buf;
   for(;;)
   { // 32 times 4 random 16-bit words = 256 bytes.
      // Except we skip the last word in the block.
      wordGear(A4) = 0; //(i16)STRandom();
      D6W = (UI16)(D6W + LE16(wordGear(A4)));
      A4 += 2;
      wordGear(A4) = 0; //(i16)STRandom();
      D6W ^= LE16(wordGear(A4));
      A4 += 2;
      wordGear(A4) = 0; //(i16)STRandom();
      D6W = (UI16)(D6W - LE16(wordGear(A4)));
      A4 += 2;
      D7W--;
      if(D7W == 0)
         break;
      wordGear(A4) = 0; //(i16)STRandom();
      D6W ^= LE16(wordGear(A4));
      A4 += 2;
   }
   wordGear(A4) = LE16((ui16)(D6W ^ D5W));
   A4 += 2;
   A0 = (aReg)buf + 2 * offset;
   Unscramble((ui8 *)A4, LE16(wordGear(A0)), 128);
   D7W = WriteGameFile(buf, 512);
   A0 = (aReg)buf + 2 * offset;
   Unscramble((ui8 *)A4, LE16(wordGear(A0)), 128);
   return D7W;
};

// *********************************************************
//
// *********************************************************
i16 TAG0008dc(i16)
{
   return 1;
}

// *********************************************************
//
// *********************************************************
//  TAG000e64
RESTARTABLE _CheckChampionNames()
{ //(i16)
   static dReg D0, D6, D7;
   static aReg A0, A4;
   RESTARTMAP
   RESTART(1)
   END_RESTARTMAP
   //;;;;;;;;;;;;;;;;;;;;;;
   for(D7L = 0; D7W < e.Word24814; D7W++)
   {
      A4 = (aReg)LoadPnt((ui8 *)&e.Pnt24812) + 800 * D7W + 772;
      if(A4[0] == 0)
      {
      tag000e84:
         UtilityDialogBox(_1_, UtilityDiskMessages[20], 8, UtilityDiskMessages[32], s12406);
         RETURN_i16(0);
      }
      for(D6W = sw(D7W + 1); D6W < e.Word24814; D6W++)
      {
         A0 = (aReg)LoadPnt((ui8 *)&e.Pnt24812) + 800 * D6W + 772;
         D0W = sw(strcmp((char *)A4, (char *)A0));
         if(D0W == 0)
            goto tag000e84;
         //
         //
      }
      //
   }
   RETURN_i16(1);
}

// *********************************************************
//
// *********************************************************
RESTARTABLE _TAG000ede(const i32 P1, char *P2)
{ //(i16)
   static dReg D0;
   static aReg A0;
   static i16 w_2;
   RESTARTMAP
   RESTART(1)
   RESTART(2)
   RESTART(3)
   RESTART(4)
   END_RESTARTMAP
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   do
   {
      for(;;)
      {
         if(P1 == 0)
         {
            UtilityDialogBox(_1_,
                             UtilityDiskMessages[2],
                             (unsigned)0x800f,
                             UtilityDiskMessages[35],
                             &s12406[3]);
            D0W = i16Result;
            w_2 = D0W;
         }
         else
         {
            if(P1 == 1)
            {
               A0 = (aReg)UtilityDiskMessages[0];
            }
            else
            {
               A0 = (aReg)UtilityDiskMessages[1];
            }
            UtilityDialogBox(_2_,
                             A0,
                             (unsigned)0x800f,
                             UtilityDiskMessages[34],
                             &s12406[2]);
            D0W = i16Result;
            w_2 = D0W;
         }
         if(w_2 == 3)
         {
            RETURN_i16(0);
         }
         D0W = TAG0008dc(1);

         if(w_2 != 2)
            break;
         TAG0009a8();
      }
      // ask to which game we want to write
      // inserted by LK
      UtilityDialogBox(_3_,
                       UtilityDiskMessages[42],
                       (unsigned)0x800f,
                       positions,
                       &fourbuttons[0]);

      strcpy(P2, filenames[i16Result - 1]);

      // end of insertion
      D0W = OPEN(P2, "rb");
      if(D0W < 0)
         break;
      if(P1 <= 1)
      {
         A0 = (aReg)UtilityDiskMessages[6];
      }
      else
      {
         A0 = (aReg)UtilityDiskMessages[8];
      }

      UtilityDialogBox(_4_,
                       A0,
                       (unsigned)0x8008,
                       UtilityDiskMessages[36],
                       &s12406[1]);
      D0W = i16Result;
   } while(D0W != 1);
   RETURN_i16(1);
}

/*
// *********************************************
static ui32 WCSRCSchecksum;

static ui32 chaosWCS()
{
  ui32 temp;
  temp = WCSRCSchecksum;
  WCSRCSchecksum = 0xffff;
  return temp;
}
*/
/*
static ui32 RCS(i32 handle)
{
  ui32 temp;
  WCSRCShandle = handle;
  temp = WCSRCSchecksum;
  WCSRCSchecksum = 0xffff;
  return temp;
}
*/
/*
void chaosWCS(ui8 *buf, i32 n)
{
  i32 i;
  for (i=0; i<n; i++)
  {
    WCSRCSchecksum *= (ui32)0xbb40e62d;
    WCSRCSchecksum += 11 + buf[i];
}
  WriteGameFile((char *)buf, (ui16)n);
}
*/
/*

static void RCS(ui8 *buf, i32 n)
{
  i32 i;
  READ(WCSRCShandle, n, (char *)buf);
  for (i=0; i<n; i++)
  {
    WCSRCSchecksum *= (ui32)0xbb40e62d;
    WCSRCSchecksum += 11 + buf[i];
}
}

static void WCS(ui32 *i, i32 n)
{
  WCS((ui8 *)i, 4*n);
}

static void RCS(ui32 *i, i32 n)
{
  RCS((ui8 *)i, 4*n);
}
*/
/*
void chaosWCS(i32 *i, i32 n)
{
  chaosWCS((ui8 *)i, 4*n);
}
/*
static void RCS(i32 *i, i32 n)
{
  RCS((ui8 *)i, 4*n);
}

static void WCS(ui16 *i, i32 n)
{
  WCS((ui8 *)i, 2*n);
}

static void RCS(ui16 *i, i32 n)
{
  RCS((ui8 *)i, 2*n);
}

static void WCS(char *c, i32 n)
{
  WCS((ui8 *)c, n);
}

static void RCS(char *c, i32 n)
{
  RCS((ui8 *)c, n);
}
*/
// *********************************************************
//
// *********************************************************
RESTARTABLE _TAG000fc4(const i32 P1)
{ //()
   static dReg D0, D1, D3, D7;
   static ui8 *pD0, *pD1, *pD2;
   static aReg A0, A1, A4;
   static ui16 *uwA3;
   static ui8 *pnt_116;
   static ui8 *pnt_112;
   static ui8 *pnt_108;
   static ui8 *pnt_104;
   static i8 b_100[96];
   static ui16 uw_4;
   static ui16 uw_2;
   RESTARTMAP
   RESTART(1)
   RESTART(2)
   RESTART(3)
   RESTART(4)
   END_RESTARTMAP
   //;;;This is only function that calls 'MyWriteScrambled'
   //;;; and this function is called from two places
   A4 = (aReg)LoadPnt((ui8 *)&e.Pnt24812) + 4112 * P1;
   if(LoadPnt((ui8 *)&e.Pnt24812) == NULL)
      RETURN;
   if(e.Word24814 == 0)
      RETURN;
   CheckChampionNames(_1_);
   D0W = i16Result;
   if(D0W == 0)
      RETURN;
   TAG000ede(_2_, 1 - P1, A4 + 4);
   D0W = i16Result;
   if(D0W != 0)
   {
      if(P1 != 0)
      {
         A0 = (aReg)UtilityDiskMessages[23];
      }
      else
      {
         A0 = (aReg)UtilityDiskMessages[10];
      }
      UtilityDialogBox(_3_, A0, 15, 0, 0);
      e.GameFile = CREATE((char *)A4 + 4, "wb", true);
      if(e.GameFile < 0)
         goto tag001328;
      ClearMemory((ui8 *)b_100, 96);
      StorePnt(b_100, A4 + 550);
      wordGear(b_100 + 4) = 128;
      StorePnt(b_100 + 6, LoadPnt(A4 + 4100));
      wordGear(b_100 + 10) = sw(16 * LE16(wordGear(A4 + 596)));
      StorePnt(b_100 + 12, A4 + 772);
      wordGear(b_100 + 16) = 3328;
      StorePnt(b_100 + 18, LoadPnt(A4 + 4104));
      {
         int timerSize;
         // timerSize = sequencedTimers?sizeof(TIMER):10;
         timerSize = sequencedTimers ? 12 : 10;
         timerSize = extendedTimers ? 16 : timerSize;
         wordGear(b_100 + 22) = sw(timerSize * LE16(wordGear(A4 + 578)));
      }
      StoreLong(b_100 + 24, LoadLong(A4 + 4108));
      wordGear(b_100 + 28) = sw(2 * LE16(wordGear(A4 + 578)));
      pnt_104 = (ui8 *)A4 + 38;
      if(wordGear(A4 + 2) == 2)
      {
         pnt_108 = pnt_104 + 344;
         pnt_112 = pnt_104 + 312;
         pnt_104[300] = 2;
      }
      else
      {
         pnt_108 = (ui8 *)A4 + 380;
         pnt_112 = (ui8 *)A4 + 348;
         A4[336] = 2;
      }
      for(D7W = 0; D7W < 16; D7W++)
      {
         pnt_116 = pnt_112 + 2 * D7W;
         D0W = 0; //(i16)STRandom();
         wordGear(pnt_116) = D0W;
         //
      }
      for(D7L = 0; D7W < 5; D7W++)
      {
         pD0 = pnt_108 + 2 * D7W;
         pD1 = (ui8 *)b_100 + 6 * D7W;
         pD2 = pnt_112 + 2 * D7W;
         A0 = b_100 + 6 * D7W;
         D3W = wordGear(A0 + 4); // Random number generated above
         pnt_116 = pD0;
         D3W /= 2;
         D0W = GenChecksum(LoadPnt(pD1),        // buffer
                           LE16(wordGear(pD2)), // initial hash
                           D3W);                // # words
         wordGear(pnt_116) = LE16(D0W);
         //
         //
      }
      if(ExtendedFeaturesVersion != '@')
      {
         EXTENDEDFEATURESBLOCK efb;
         memset(&efb, 0, 512);
         strcpy(efb.sentinel, " Extended Features ");
         efb.dataMapLength = dataMapLength;
         efb.version = ExtendedFeaturesVersion;
         efb.dataIndexMapChecksum = FormChecksum((ui8 *)dataIndexMap, 2 * dataMapLength);
         efb.dataTypeMapChecksum = FormChecksum(dataTypeMap, dataMapLength);
         efb.numDSA = countDSAs();
         efb.flags |= EXTENDEDFEATURESBLOCK::BigActuators;
         if(indirectText)
         {
            efb.flags |= EXTENDEDFEATURESBLOCK::IndirectText;
         }
         if(sequencedTimers)
         {
            efb.extendedFlags |= EXTENDEDFEATURESBLOCK::SequencedTimers;
         }
         if(extendedTimers)
         {
            efb.extendedFlags |= EXTENDEDFEATURESBLOCK::ExtendedTimers;
         }
         if(DefaultDirectXOption)
         {
            efb.extendedFlags |= EXTENDEDFEATURESBLOCK::DefaultDirectX;
         }
         if(efb.numDSA != 0)
         {
            efb.flags |= EXTENDEDFEATURESBLOCK::LevelDSAInfoPresent;
         }
         efb.extendedFeaturesChecksum = 0;
         efb.extendedFeaturesChecksum = FormChecksum((ui8 *)&efb, 512);
         WriteGameFile((ui8 *)&efb, 512);
         WriteGameFile(dataTypeMap, (ui16)dataMapLength);
         WriteGameFile((ui8 *)dataIndexMap, (ui16)(2 * dataMapLength));
         if(efb.numDSA != 0)
         {
            WriteDSAs(e.GameFile);
            WriteDSALevelIndex(e.GameFile);
            //{
            // i32 i;
            // ui32 checksum;
            // WCS(e.GameFile); //Discard old checksum and start new.
            // for (i=0; i<256; i++)
            //{
            //  if (DSAIndex.GetDSA(i) == NULL) continue;
            //  WCS(&i,1);
            //  DSAIndex.GetDSA(i)->Write();
            //};
            // checksum = WCS(0);
            // WriteGameFile((char *)&checksum, 4);
            //}
         }
      }
      D0W = WriteFirstBlock((ui8 *)A4 + 38, wordGear(A4 + 36));
      if(D0W == 0)
         goto tag001328;
      for(D7W = 0; D7W < 5; D7W++)
      {
         D0W = MyWriteScrambled(LoadPnt(b_100 + 6 * D7W),
                                wordGear(b_100 + 6 * D7W + 4),
                                LE16(wordGear(pnt_112 + 2 * D7W)),
                                &uw_2);
         if(D0W == 0)
            goto tag001328;
         A0 = (aReg)pnt_108 + 2 * D7W;
         if(uw_2 == LE16(wordGear(A0)))
            continue;
         pD0 = pnt_108 + 2 * D7W;
         pD1 = pnt_112 + 2 * D7W;
         atari_sprintf(e.Byte23494,
                       "SAVEGAME():CHECKSUM %d != %d (KEY = %d)\n",
                       LE16(wordGear(pD0)),
                       uw_2,
                       LE16(wordGear(pD1)));
         UI_MessageBox(e.Byte23494, NULL, MESSAGE_OK);
         //
         //
      }
      uwA3 = &uw_4;
      uw_4 = 0;
      D0W = MyWriteAndChecksum(LoadPnt(A4 + 690), uwA3, 44);
      if(D0W == 0)
         goto tag001328;

      D0W = sw(16 * (UI8)(LoadPnt(A4 + 690)[4]));
      D0W = MyWriteAndChecksum(LoadPnt(A4 + 686), uwA3, D0W); // levelDescriptors
      if(D0W == 0)
         goto tag001328;

      D0W = MyWriteAndChecksum(LoadPnt(A4 + 694), uwA3, 2 * wordGear(A4 + 702)); // objectListIndex
      if(D0W == 0)
         goto tag001328;

      D0W = sw(2 * LE16(wordGear(LoadPnt(A4 + 690) + 10)));
      D0W = MyWriteAndChecksum(LoadPnt(A4 + 704), uwA3, D0W); // objectList
      if(D0W == 0)
         goto tag001328;

      D0W = sw(2 * LE16(wordGear(LoadPnt(A4 + 690) + 6)));
      if(indirectText)
         D0W *= 2;
      D0W = MyWriteAndChecksum(LoadPnt(A4 + 678), uwA3, D0W); // indirectTextIndex
      if(D0W == 0)
         goto tag001328;
      if(indirectText)
      {
         D0W = MyWriteAndChecksum((ui8 *)&compressedTextSize, uwA3, 4);
         if(D0W == 0)
            goto tag001328;
         D0W = MyWriteAndChecksum((ui8 *)compressedText, uwA3, 2 * compressedTextSize);
         if(D0W == 0)
            goto tag001328;
      }

      {
         int dbNum;
         for(dbNum = 0; dbNum < 16; dbNum++)
         {
            ui16 entrySize;
            pD0 = (ui8 *)A4 + 4 * dbNum;
            A0 = &byte24830[dbNum];
            entrySize = *A0;
            if((dbNum == dbSCROLL) && (ExtendedFeaturesVersion >= 'B'))
            {
               entrySize = 6;
            }
            if((dbNum == dbACTUATOR) && bigActuators)
            {
               entrySize = 10;
            }
            if(dbNum == dbEXPOOL)
            {
               entrySize = (ui16)sizeof(DB11);
            }
            A1 = (aReg)LoadPnt(A4 + 690) + 2 * dbNum;
            D1W = sw(entrySize * LE16(wordGear(A1 + 12))); // # entries
            D0W = MyWriteAndChecksum(LoadPnt(pD0 + 708), uwA3, D1W);
            if(D0W == 0)
               goto tag001328;
            //
            //
         }
      }
      D0W = MyWriteAndChecksum(LoadPnt(A4 + 682),
                               uwA3,
                               LE16(wordGear(LoadPnt(A4 + 690) + 2)));
      if(D0W == 0)
         goto tag001328;
      *uwA3 = LE16(*uwA3);
      WriteGameFile((ui8 *)uwA3, 2);
      if(D0W == 0)
      {
      tag001328:
         if(P1 != 0)
         {
            A0 = (aReg)UtilityDiskMessages[28];
         }
         else
         {
            A0 = (aReg)UtilityDiskMessages[15];
         }
         UtilityDialogBox(_4_, A0, 8, UtilityDiskMessages[32], &s12406[0]);
      }
      CLOSE(e.GameFile);
      e.GameFile = -1;
   }
   TAG000952();
   TAG00054a();
   RETURN;
}

// *********************************************************
//
// *********************************************************
void TAG00136c()
{
   dReg D0;
   aReg A0;
   pnt pnt_8;
   char *pnt_4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;
   pnt_4 = (char *)LoadPnt((ui8 *)&e.Pnt24812);
   e.Word24808 = (unsigned)0x91a7;
   A0 = (aReg)pnt_4 + 38;
   pnt_8 = A0;
   if(wordGear(pnt_4 + 2) == 2)
   {
      A0 = pnt_8;
      e.Word24806 = wordGear(A0 + 378);
      D0W = (UI8)(pnt_8[301]);
      if(D0W == 1)
      {
         e.Word24804 = 1;
         e.Word24806 = 10;
      }
      else
      {
         A0 = pnt_8;
         e.Word24804 = wordGear(A0 + 376);
         e.Word24806 = wordGear(A0 + 378);
      }
   }
   else
   {
      A0 = (aReg)pnt_4;
      e.Word24806 = wordGear(A0 + 414);
      if(A0[337] == 1)
      {
         e.Word24804 = 1;
         e.Word24806 = 10;
      }
      else
      {
         A0 = (aReg)pnt_4;
         e.Word24804 = wordGear(A0 + 412);
         e.Word24806 = wordGear(A0 + 414);
      }
   }
   e.Word24802 = 1;
   e.Word24800 = 1;
   e.Word24798 = 0;
   e.Word24796 = 0;
   e.Word24794 = 0;
   // never referenced e.Byte24792 = 0;
}

// *********************************************************
//
// *********************************************************
i16 TAG00142e(pnt P1)
{
   dReg D0, D1, D4, D5, D6, D7;
   aReg A0, A4;
   pnt pnt_8;
   i16 w_4;
   i16 w_2;
   //;;;;;;;;;;;;;;;;;;;;
   A4 = P1;
   w_4 = 0;
   A0 = (aReg)AllocateMemory(44);
   StorePnt(A4 + 690, A0);
   D0W = ReadAndChecksum(LoadPnt(A4 + 690), &w_4, 44); // d.dungeonDatIndex
   if(D0W == 0)
      return 0;
   D7W = (UI8)(*(LoadPnt(A4 + 690) + 4));                    // Number of levels
   StorePnt(A4 + 686, AllocateMemory(16 * D7W));             // For level descriptors
   D0W = ReadAndChecksum(LoadPnt(A4 + 686), &w_4, 16 * D7W); // Level descriptors
   if(D0W == 0)
      return 0;
   StorePnt(A4 + 698, AllocateMemory(2 * D7W));
   for(D4L = D5L = 0; D5W < D7W; D5W++)
   { // For each level
      A0 = (aReg)LoadPnt(A4 + 698) + 2 * D5W;
      wordGear(A0) = LE16(D4W);
      A0 = (aReg)LoadPnt(A4 + 686) + 16 * D5W;
      D0W = sw((LE16(wordGear(A0 + 8)) & 0x07c0) / 64 + 1);
      D4W = sw(D4W + D0W);
      //
      //
   }
   wordGear(A4 + 702) = D4W;
   A0 = (aReg)LoadPnt(A4 + 690);
   D5W = LE16(wordGear(A0 + 10));

   StorePnt(A4 + 694, AllocateMemory(2 * D4W)); // d.objectListIndex
   A0 = (aReg)LoadPnt(A4 + 690);
   D0W = LE16(wordGear(A0 + 10));

   StorePnt(A4 + 704, AllocateMemory(2 * D0W)); // d.objectList
   A0 = (aReg)LoadPnt(A4 + 690);
   D0W = LE16(wordGear(A0 + 6));
   if(indirectText)
      D0W = (i16)(2 * D0W);
   StorePnt(A4 + 678, AllocateMemory(2 * D0UW)); // d.indirectTextArray

   D0W = ReadAndChecksum(LoadPnt(A4 + 694), &w_4, 2 * D4W); // d.objectListIndex
   if(D0W == 0)
      return 0;
   D0W = ReadAndChecksum(LoadPnt(A4 + 704), &w_4, 2 * D5W); // d.objectList
   if(D0W == 0)
      return 0;

   A0 = (aReg)LoadPnt(A4 + 690);
   D0W = LE16(wordGear(A0 + 6)); // numberOfEntriesInTextArray
   if(indirectText)
      D0W = (i16)(2 * D0W);
   D0W = ReadAndChecksum(LoadPnt(A4 + 678), &w_4, 2 * D0W); // d.indirectTextIndex
   textArraySize = D0W;                                     // Number of words
   textArray = (char *)LoadPnt(A4 + 678);
   if(D0W == 0)
      return 0;
   if(indirectText)
   {
      // If the indirectText flag is set then read
      //  1) a 32-bit word giving the size of text
      //  2) the text itself;
      D0W = ReadAndChecksum((ui8 *)&compressedTextSize, &w_4, 4); // d.sizeOfCompressedText
      if(D0W == 0)
         return 0;
      compressedText = (char *)malloc(2 * compressedTextSize);
      D0W = ReadAndChecksum((ui8 *)compressedText, &w_4, 2 * compressedTextSize); // d.compressedText
      if(D0W == 0)
         return 0;
   }
   for(D6W = 0; D6W < 16; D6W++)
   {
      A0 = (aReg)LoadPnt(A4 + 690) + 2 * D6W;
      D5W = LE16(wordGear(A0 + 12));
      A0 = byte24830 + D6W; // DB sizes?
      D4W = (UI8)(*A0);
      if((D6W == dbSCROLL) && (ExtendedFeaturesVersion >= 'B'))
      {
         D4W = 6;
      }
      if((D6W == dbACTUATOR) && bigActuators)
      {
         D4W = 10;
      }
      if(D6W == dbEXPOOL)
      {
         D4W = sizeof(DB11);
      }
      pnt_8 = A4 + 4 * D6W;
      A0 = (aReg)LoadPnt(A4 + 690) + 2 * D6W;
      D1L = D4UW * LE16(wordGear(A0 + 12));
      if(D6W == 2)
      {
         DB2Size = LE16(wordGear(A0 + 12));
      }
      A0 = pnt_8;
      StorePnt(A0 + 708, AllocateMemory(D1L));
      if(D6W == 2)
      {
         DB2Address = (DB2 *)LoadPnt(A0 + 708);
      }
      D0W = ReadAndChecksum(LoadPnt(A4 + 4 * D6W + 708), &w_4, D4UW * D5UW);
      if(D0W == 0)
         return 0;
      //
      // if (D6W == 2) ReadExtendedFeatures();
   }
   A0 = (aReg)LoadPnt(A4 + 690);
   {
      ui32 cellArraySize;
      cellArraySize = LE16(wordGear(A0 + 2));
      if(cellflagArraySize != 0)
         cellArraySize = cellflagArraySize;
      StorePnt(A4 + 682, AllocateMemory(cellArraySize));
      D0W = ReadAndChecksum(LoadPnt(A4 + 682), &w_4, cellArraySize);
      if(D0W == 0)
         return 0;
   }
   D0W = ReadGameFile((ui8 *)&w_2, 2); // Final checksum
   if(D0W == 0)
      return 1;
   w_2 = LE16(w_2);
   if(w_2 == w_4)
      return 1;
   return 0;
}

// *********************************************************
//
// *********************************************************
void TAG001676(ui8 *P1, i16 P2)
{
   dReg D7;
   aReg A0, A4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   A4 = (aReg)P1;
   if(LoadLong(A4 + 4100) != 0)
   {
      ReleaseMemory(LoadPnt(A4 + 4100));
   }
   StoreLong(A4 + 4100, 0);
   if(LoadLong(A4 + 4104) != 0)
   {
      ReleaseMemory(LoadPnt(A4 + 4104));
   }
   StorePnt(A4 + 4104, (ui8 *)NULL);
   if(LoadPnt(A4 + 4108) != NULL)
   {
      ReleaseMemory(LoadPnt(A4 + 4108));
   }
   StorePnt(A4 + 4108, (ui8 *)NULL);
   if(LoadPnt(A4 + 678) != NULL)
      ReleaseMemory(LoadPnt(A4 + 678));
   StorePnt(A4 + 678, (ui8 *)NULL);
   if(LoadPnt(A4 + 682) != NULL)
      ReleaseMemory(LoadPnt(A4 + 682));
   StorePnt(A4 + 682, (ui8 *)NULL);
   if(LoadPnt(A4 + 686) != NULL)
      ReleaseMemory(LoadPnt(A4 + 686));
   StorePnt(A4 + 686, (ui8 *)NULL);
   if(LoadPnt(A4 + 690) != NULL)
      ReleaseMemory(LoadPnt(A4 + 690));
   StorePnt(A4 + 690, (ui8 *)NULL);
   if(LoadPnt(A4 + 694) != NULL)
      ReleaseMemory(LoadPnt(A4 + 694));
   StorePnt(A4 + 694, (ui8 *)NULL);
   if(LoadPnt(A4 + 698) != NULL)
      ReleaseMemory(LoadPnt(A4 + 698));
   StorePnt(A4 + 698, (ui8 *)NULL);
   if(LoadPnt(A4 + 704) != NULL)
      ReleaseMemory(LoadPnt(A4 + 704));
   StorePnt(A4 + 704, (ui8 *)NULL);
   for(D7W = 0; D7W < 16; D7W++)
   {
      A0 = A4 + 708 + 4 * D7W;
      if(LoadPnt(A0) != NULL)
         ReleaseMemory(LoadPnt(A0));
      StorePnt(A0, (ui8 *)NULL);
      //
      //
   }
   if(P2 == 0)
      e.Word24814 = 0;
   wordGear(A4) = 0;
}

// *********************************************************
//
// *********************************************************
RESTARTABLE _TAG00179c(const i32 P1)
{ //(i16)
   static dReg D0, D5, D6, D7;
   static aReg A0;
   RESTARTMAP
   RESTART(1)
   RESTART(2)
   RESTART(3)
   END_RESTARTMAP
   //;;;;;;;;;;;;;;
   D7W = uw(P1); // (0x8001 for example)
   if(D7W == 2)
   {
      DontDoThis(0x17ae);

      D6W = 1;
   }
   else
   {
      D5L = 1;
      while(D7W & 0x8000)
      {
         D7W &= 0x7fff;
         if(D5W == 0)
         {
            UtilityDialogBox(_1_,
                             UtilityDiskMessages[27],
                             (unsigned)0x8008,
                             UtilityDiskMessages[32],
                             &s12406[0]);
         }
         D5L = 0;
         if(D7W == 0)
         {
            UtilityDialogBox(_2_,
                             UtilityDiskMessages[0],
                             (unsigned)0x800f,
                             UtilityDiskMessages[32],
                             &s12406[0]);
            D6W = i16Result;
         }
         else
         {
            if(D7W == 1)
            {
               A0 = (aReg)UtilityDiskMessages[42];
            }
            else
            {
               A0 = (aReg)UtilityDiskMessages[1];
            }
            UtilityDialogBox(_3_,
                             A0,
                             (unsigned)0x800f,
                             positions,
                             &fourbuttons[0]);
            D6W = i16Result;
            // we dont need this coz there is 4 buttons with four saves, no cancel
            // if (D6W == 2) RETURN_i16(0);
         }
         //
      }
      D0W = TAG0008dc(1);
   }
   RETURN_i16(D6W);
}

// *********************************************************
//
// *********************************************************
//  TAG001868
RESTARTABLE _ReadSavedGame(const i32 P1)
{ //(i16)
   // P1 non-zero means read MINI.DAT
   static dReg D0, D7;
   static aReg A0, A1, A4;
   static ui8 *pnt_4654;
   static const char *pnt_4650;
   static ui8 *pnt_4646;
   static ui8 *pnt_4642;
   static i8 b_4638[512];
   static ui8 *pnt_4126;
   static i16 w_4122;
   static i16 w_4120;
   static i8 b_4118[4112];
   static i16 w_6;
   static i16 w_4;
   static i16 w_2;
   static char *savegame;

   RESTARTMAP
   RESTART(1)
   RESTART(2)
   RESTART(3)
   RESTART(4)
   RESTART(5)
   RESTART(6)
   END_RESTARTMAP
   //;;;;;;;;;;;;;;;;;;Reads a gamefile????
   D7W = sw(P1);
   A4 = b_4118;
   ClearMemory((ui8 *)A4, 4112);
   pnt_4126 = (ui8 *)A4 + 38;
   w_6 = 1;
   do
   {
      if(D7W != 0)
      { // We are supposed to read MINI.DAT
         TAG000952();
         pnt_4650 = pnt12238; // Where game will be written
         e.GameFile = OPEN("mini.dat", "rb");
         if(e.GameFile < 0)
         {
            UtilityDialogBox(_1_, UtilityDiskMessages[24], 8, UtilityDiskMessages[32], s12406);
            RETURN_i16(-1);
         }
         w_2 = 1;
      }
      else
      {
         TAG00179c(_2_, w_6 | 0x8000);
         D0W = i16Result;
         savegame = (char *)filenames[D0W - 1];

         if(D0W == 0)
         {
            if(e.Word12184 == 0)
            {
               D0L = -1;
            }
            else
            {
               D0L = -99;
            }
            w_2 = D0W;
            goto tag001d9a;
         }
         w_2 = 1;
         w_4122 = 1;
         w_4120 = 1;
         pnt_4650 = pnt12246;
         e.GameFile = OPEN(pnt12246, "rb"); //"DMGAME.DAT"
         if(e.GameFile < 0)
         {
            pnt_4650 = pnt12242;
            e.GameFile = OPEN(pnt12242, "rb"); // DMGAME.BAK
            if(e.GameFile < 0)
               w_4120 = 0;
         }
         if(e.GameFile >= 0)
            CLOSE(e.GameFile);
         // pnt_4654 = pnt12238;
         pnt_4654 = (ui8 *)savegame;
         e.GameFile = OPEN(savegame, "rb");
         if(e.GameFile < 0)
         {
            // pnt_4654 = pnt12234;
            // e.GameFile = OPEN(pnt12234,"rb");
            if(e.GameFile < 0)
               w_4122 = 0;
         }
         if(e.GameFile >= 0)
            CLOSE(e.GameFile);
         if(w_4120 + w_4122 < 1)
         {
            UtilityDialogBox(_3_,
                             UtilityDiskMessages[12],
                             (unsigned)0x8008,
                             UtilityDiskMessages[32],
                             &s12406[0]);
            w_6 |= 0x8000;
            w_2 = 0;
         }
         else
         {
            if(w_4120 + w_4122 > 1)
            {
               UtilityDialogBox(_4_,
                                UtilityDiskMessages[31],
                                (unsigned)0x800f,
                                UtilityDiskMessages[39],
                                &s12406[4]);
               w_4 = i16Result;
               if(w_4 == 1)
                  goto tag001a4c;
               if(w_4 == 2)
               {
                  pnt_4650 = (char *)pnt_4654;
                  goto tag001a4c;
               }
               if(e.Word12184 == 0)
               {
                  D0L = 1;
               }
               else
               {
                  D0L = 99;
               }
               w_2 = D0W;
               goto tag001d9a;
            }
            if(w_4122 != 0)
            {
               pnt_4650 = (char *)pnt_4654;
            }
         tag001a4c:
            e.GameFile = OPEN(pnt_4650, "rb");
            if(e.GameFile < 0)
               w_2 = 0;
         }
      }
   } while(w_2 != 1);
   StrCpy((char *)A4 + 4, pnt_4650);
   if(D7W != 0)
   {
      A0 = (aReg)UtilityDiskMessages[22];
   }
   else
   {
      A0 = (aReg)UtilityDiskMessages[9];
   }
   UtilityDialogBox(_5_, A0, 15, NULL, NULL);
   wordGear(A4 + 36) = 29;
   wordGear(A4 + 2) = 2;
   ReadExtendedFeatures(e.GameFile);
   D0W = ReadGameBlock1((ui8 *)A4 + 38);
   if(D0W == 0)
      goto tag001da8;
   MemoryMove((ui8 *)A4 + 38, (ui8 *)b_4638, 0x400, 0x400, 512);
   // We just saved the scrambled version at b_4638
   D0W = UnscrambleBlock1((ui8 *)A4 + 38, wordGear(A4 + 36));
   if(D0W == 0)
   { // It didn't work with that key!
      wordGear(A4 + 36) = 10;
      wordGear(A4 + 2) = 1;
      MemoryMove((ui8 *)b_4638, (ui8 *)A4 + 38, 0x400, 0x400, 512);
      // We have replaced buffer with original, scrambled version
      D0W = UnscrambleBlock1((ui8 *)A4 + 38, wordGear(A4 + 36));
      // Now unscramble with word 10 as initial hash.
      if(D0W == 0)
         goto tag001da8;
   }
   if(wordGear(A4 + 2) == 2)
   {
      pnt_4642 = pnt_4126 + 344;
      pnt_4646 = pnt_4126 + 312;
   }
   else
   {
      pnt_4642 = (ui8 *)A4 + 380;
      pnt_4646 = (ui8 *)A4 + 348;
   }
   D0W = MyUnscrambleStream((ui8 *)A4 + 550, // block 2
                            128,
                            LE16(wordGear(pnt_4646)),
                            LE16(wordGear(pnt_4642)));
   if(D0W == 0)
      goto tag001da8;
   StorePnt(A4 + 4100, AllocateMemory(16 * LE16(wordGear(A4 + 596))));
   {
      int timerSize;
      // timerSize = sequencedTimers?sizeof(TIMER):10;
      timerSize = sequencedTimers ? 12 : 10;
      timerSize = extendedTimers ? 16 : timerSize;
      StorePnt(A4 + 4104, AllocateMemory(timerSize * LE16(wordGear(A4 + 578))));
   }
   StorePnt(A4 + 4108, AllocateMemory(2 * LE16(wordGear(A4 + 578))));
   D0W = MyUnscrambleStream(LoadPnt(A4 + 4100), // Item16
                            16 * LE16(wordGear(A4 + 596)),
                            LE16(wordGear(pnt_4646 + 2)),
                            LE16(wordGear(pnt_4642 + 2)));
   if(D0W == 0)
      goto tag001da8;
   // Next is the character data.
   D0W = MyUnscrambleStream((ui8 *)A4 + 772, // characters
                            3328,
                            LE16(wordGear(pnt_4646 + 4)),
                            LE16(wordGear(pnt_4642 + 4)));
   if(D0W == 0)
      goto tag001da8;
   for(w_2 = 0; w_2 < LE16(wordGear(A4 + 560)); w_2++)
   {
      for(w_4 = 0; w_4 < 8; w_4++)
      {
         A0 = A4 + 800 * w_2 + w_4;
         if(A0[772] == 0)
            break;
         //
         //
      }
      while(w_4 < 8)
      {
         A0 = A4 + 800 * w_2 + w_4;
         A0[772] = 0;
         w_4++;
         //
      }
      for(w_4 = 0; w_4 < 20; w_4++)
      {
         A0 = A4 + 800 * w_2 + w_4;
         if(A0[780] == 0)
            break;
         //
         //
      }
      while(w_4 < 20)
      {
         A0 = A4 + 800 * w_2 + w_4;
         A0[780] = 0;
         w_4++;
      }
      //
      //
   }
   {
      // int timerSize = sequencedTimers?sizeof(TIMER):10;
      int timerSize = sequencedTimers ? 12 : 10;
      timerSize = extendedTimers ? 16 : timerSize;
      D0W = MyUnscrambleStream(LoadPnt(A4 + 4104), // Timers
                               timerSize * LE16(wordGear(A4 + 578)),
                               LE16(wordGear(pnt_4646 + 6)),
                               LE16(wordGear(pnt_4642 + 6)));
   }
   if(D0W == 0)
      goto tag001da8;
   D0W = MyUnscrambleStream(LoadPnt(A4 + 4108),
                            2 * LE16(wordGear(A4 + 578)),
                            LE16(wordGear(pnt_4646 + 8)),
                            LE16(wordGear(pnt_4642 + 8)));
   if(D0W == 0)
      goto tag001da8;
   D0W = TAG00142e(A4); // Text (numWordsInTextArray)
   if(D0W == 0)
      goto tag001da8;
   e.Word12184 = 0;
   A0 = (aReg)LoadPnt((ui8 *)&e.Pnt24812) + 4112 * D7W;
   if(wordGear(A0) != 0)
   {
      TAG001676(LoadPnt((ui8 *)&e.Pnt24812) + 4112 * D7W, D7W);
   }
   if(D7W == 0)
   {
      e.Word24814 = LE16(wordGear(A4 + 560));
      TAG00136c();
   }
   wordGear(A4) = 1;
   A0 = (aReg)LoadPnt((ui8 *)&e.Pnt24812) + 4112 * D7W;
   A1 = A4;
   memmove(A0, A1, 4112);
   w_2 = 1;
   CLOSE(e.GameFile);
   e.GameFile = -1;
tag001d9a:
   TAG000952();
   TAG00054a();
   RETURN_i16(w_2);

tag001da8:
   if(D7W != 0)
   {
      A0 = (aReg)UtilityDiskMessages[25];
   }
   else
   {
      A0 = (aReg)UtilityDiskMessages[14];
   }
   UtilityDialogBox(_6_, A0, 8, UtilityDiskMessages[32], &s12406[0]);
   TAG001676((ui8 *)A4, 0);
   w_2 = -1;
   if(e.GameFile >= 0)
   {
      CLOSE(e.GameFile);
      e.GameFile = -1;
   }
   goto tag001d9a;
   // RETURN_i16(0);
}

// *********************************************************
//
// *********************************************************
RESTARTABLE _TAG00260e()
{ //(i16)
   static const char *pnt_12;
   static ui8 *pBlock1;
   static char *pnt_4;
   RESTARTMAP
   RESTART(1)
   RESTART(2)
   END_RESTARTMAP
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   pnt_4 = (char *)LoadPnt((ui8 *)&e.Pnt24812);
   pnt_12 = UtilityDiskMessages[30];
   for(;;)
   {
      if((wordGear(LoadPnt((ui8 *)&e.Pnt24812)) == 0) || (e.Word24814 == 0))
      {
         pnt_12 = UtilityDiskMessages[29];
      }
      else
      {
         pBlock1 = (ui8 *)pnt_4 + 38;
         if(wordGear((ui8 *)pnt_4 + 2) != 1)
         {
            if((pBlock1[301] != 1) && (LE16(wordGear(pBlock1 + 376)) != 1))
               break; // Word22594
            if(LE16(wordGear(pBlock1 + 378)) > 13)
               break; // Word22592
                      // original        if (LE16(wordGear(pBlock1+378)) > 12) break; //Word22592
                      // Error if !DungeonMaster savegame?
         }
         else
         {
            if(pnt_4[337] > 1)
            {
               if(wordGear(pnt_4 + 412) != 1)
                  break;
               if(wordGear(pnt_4 + 414) > 12)
                  break;
            }
         }
         CheckChampionNames(_1_);
         RETURN_i16(i16Result);
      }
      break;
   }; // while (false);
   UtilityDialogBox(_2_, pnt_12, 8, UtilityDiskMessages[32], s12406);
   RETURN_i16(0);
}

// *********************************************************
//
// *********************************************************
RESTARTABLE _TAG0026c4(pnt P1)
{ //(i16)
   static const char *pnt_8;
   static pnt pnt_4;
   RESTARTMAP
   RESTART(1)
   END_RESTARTMAP
   //;;;;;;;;;;;;;;;;;;;;;;;;;;
   pnt_8 = UtilityDiskMessages[30];
   pnt_4 = P1 + 38;
   if((wordGear(P1 + 2) == 2) && ((UI8)(pnt_4[301]) >= 2) && (LE16(wordGear(pnt_4 + 378)) == 13))
      RETURN_i16(1);
   UtilityDialogBox(_1_, pnt_8, 8, UtilityDiskMessages[32], s12406);
   RETURN_i16(0);
}

// *********************************************************
//
// *********************************************************
void TAG002724()
{
   dReg D0, D6, D7;
   aReg A0, A1, A4;
   char *pnt_8;
   char *pnt_4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;
   pnt_4 = (char *)LoadPnt((ui8 *)&e.Pnt24812) + 4150;
   if(wordGear(LoadPnt((ui8 *)&e.Pnt24812) + 2) == 2)
   {
      pnt_8 = (char *)LoadPnt((ui8 *)&e.Pnt24812) + 38;
   }
   else
   {
      pnt_8 = NULL;
   }
   if(pnt_8 != NULL)
   {
      MemoryMove((ui8 *)pnt_8 + 256, (ui8 *)pnt_4 + 256, 0x400, 0x400, 32);
      MemoryMove((ui8 *)pnt_8 + 288, (ui8 *)pnt_4 + 288, 0x400, 0x400, 8);
      StoreLong((ui8 *)pnt_4 + 308, LoadLong((ui8 *)pnt_8 + 308) + 1);
      if(pnt_8[301] == 1)
      {
         ASSERT(0, "pnt_8"); // check for LE
         wordGear(pnt_4 + 376) = 1;
      }
      else
      {
         wordGear(pnt_4 + 376) = wordGear(pnt_8 + 376);
      }
   }
   else
   {
      MemoryMove(LoadPnt((ui8 *)&e.Pnt24812) + 294, (ui8 *)pnt_4 + 256, 0x400, 0x400, 32);
      MemoryMove(LoadPnt((ui8 *)&e.Pnt24812) + 326, (ui8 *)pnt_4 + 288, 0x400, 0x400, 8);
      ASSERT(0, "pnt_8"); // check for LE
      StoreLong((ui8 *)pnt_4 + 308, LoadLong(LoadPnt((ui8 *)&e.Pnt24812) + 344) + 1);
      if(LoadPnt((ui8 *)&e.Pnt24812)[337] == 1)
      {
         ASSERT(0, "pnt24812"); // check for LE
         wordGear(pnt_4 + 376) = 1;
      }
      else
      {
         wordGear(pnt_4 + 376) = wordGear(LoadPnt((ui8 *)&e.Pnt24812) + 412);
      }
   }
   StrCpy((char *)LoadPnt((ui8 *)&e.Pnt24812) + 4116, pnt12238);
   MemoryMove(LoadPnt((ui8 *)&e.Pnt24812) + 772, LoadPnt((ui8 *)&e.Pnt24812) + 4884, 0x400, 0x400, 3200);
   wordGear(LoadPnt((ui8 *)&e.Pnt24812) + 4672) = LE16(e.Word24814);
   for(D7W = 0, A4 = (aReg)LoadPnt((ui8 *)&e.Pnt24812) + 4884;
       D7W < e.Word24814;
       D7W++, A4 += 800)
   {
      A0 = (aReg)LoadPnt((ui8 *)&e.Pnt24812);
      A1 = (aReg)LoadPnt((ui8 *)&e.Pnt24812);
      D6W = (UI16)(LE16(wordGear(A1 + 4678)) - LE16(wordGear(A0 + 566)));
      if(D6W != 0)
      {
         D6W += 4;
         A4[29] = (UI8)((A4[29] + D6W) & 3);
         A4[28] = (UI8)((A4[28] + D6W) & 3);
      }
      A4[30] = 1;
      A4[31] = 2;
      A4[32] = -1;
      A4[33] = 0;
      A4[34] = 0;
      A4[40] = 0;
      A4[41] = 0;
      A4[42] = 0;
      wordGear(A4 + 44) = (unsigned)0xffff;
      wordGear(A4 + 46) = (unsigned)0xffff;
      wordGear(A4 + 48) = LE16(LE16((ui16)(wordGear(A4 + 48) & 16)));
      wordGear(A4 + 50) = 0;
      wordGear(A4 + 52) = wordGear(A4 + 54);
      wordGear(A4 + 56) = wordGear(A4 + 58);
      wordGear(A4 + 60) = wordGear(A4 + 62);
      wordGear(A4 + 64) = 0;
      D0W = (i16)STRandom();
      D0W = sw((D0W & 255) + 1500);
      wordGear(A4 + 66) = LE16(D0W);
      D0W = (i16)STRandom();
      D0W = sw((D0W & 255) + 1500);
      wordGear(A4 + 68) = LE16(D0W);
      for(D6W = 0; D6W <= 6; D6W++)
      {
         A0 = A4 + 3 * D6W + 70;
         A0[2] = 30;
         A0[1] = A0[0];
         //
         //
      }
      A4[72] = 10;
      for(D6W = 0; D6W < 20; D6W++)
      {
         A0 = A4 + 6 * D6W + 92;
         wordGear(A0) = 0;
      }
      for(D6W = 0; D6W < 30; D6W++)
      { // possessions <- empty
         A0 = A4 + 2 * D6W + 212;
         wordGear(A0) = (unsigned)0xffff;
      }
      wordGear(A4 + 272) = 0;
      wordGear(A4 + 274) = 0;
      //
      //
   }
}

// *********************************************************
//
// *********************************************************
//   TAG002a38
RESTARTABLE _StartChaos(const CSB_UI_MESSAGE *)
{ //()
   static i16 w_130;
   RESTARTMAP
   RESTART(1)
   RESTART(2)
   RESTART(3)
   RESTART(4)
   END_RESTARTMAP
   //;; This is the main program
   //;;;;;;;;;;Does something and then reads a gamefile and then
   //;;;;;;;;;;does something else.
   //;;;;;;;;;;Calls function that reads gamefile, fiddles with
   //;;;;;;;;;;characters and writes gamefile.
   keyboardMode = 2;
   InitializeE();
   w_130 = 1;
   // What sense does this make?????
   if(w_130 == 2)
   {
      DontDoThis(0x2a4a);
   }
   FadeToPalette(_1_, &e.palette10938);
   TAG0002d0();
   TAG0031a6(0);
   StorePnt((ui8 *)&e.PhysicalBase, physbase());
   SetDLogicalBase(LoadPnt((ui8 *)&e.PhysicalBase));
   TAG0032b4(1, e.Word9124);
   TAG003294(e.Word9124, 0);
   TAG00022a(1);
   TAG0006e4(); // Set critical error handler
   TAG00324c();
   ClearMemory(LoadPnt((ui8 *)&e.PhysicalBase), 32000);
   TAG003264();
   FadeToPalette(_2_, &palette24862);
   StorePnt((ui8 *)&e.Pnt24812, AllocateMemory(8224)); // Room for two games.?? (4112 byes each)
   ClearMemory(LoadPnt((ui8 *)&e.Pnt24812), 8224);
   w_130 = -1;
   while(w_130 == -1)
   {
      ReadSavedGame(_3_, 0);
      w_130 = i16Result;
      //
   }

   // ROQUEN: Comparison always true
   // if (w_130 != 0xff9d)
   {
      TAG004518(_4_);
   }
   TAG001676(LoadPnt((ui8 *)&e.Pnt24812), 0);
   TAG001676(LoadPnt((ui8 *)&e.Pnt24812) + 4112, 1);
   ReleaseMemory(LoadPnt((ui8 *)&e.Pnt24812));
   TAG000952();
   TAG00022a(2);
   TAG0032b4(2, e.Word9124);
   TAG00323c();
   TAG00031c();
   RETURN;
}

// *********************************************************
//
// *********************************************************
//  TAG002c18
// i16 Random()
//{
//  dReg D0;
//;;;;;;;;;;;;;;;;;
//  if (LoadLong(&e.Long9220) == 0)
//  {
//    StoreLong(&e.Long9220, LoadLong(&e.Long24300) + 1023013);
//  };
//  D0L = Times(LoadLong(&e.Long9220), 314159) + 11;
//  StoreLong(&e.Long9220, D0L);
//  return (D0L >> 8) & 0xffffff;
//}

// *********************************************************
//
// *********************************************************
//  TAG002c70
i16 TestInRectangle(wordRectPos *rect, i32 x, i32 y)
{
   dReg D6, D7;
   wordRectPos *rectA4;
   rectA4 = rect;
   D7W = sw(x);
   D6W = sw(y);
   if(D7W > rectA4->x2)
      return 0;
   if(D7W < rectA4->x1)
      return 0;
   if(D6W > rectA4->y2)
      return 0;
   if(D6W < rectA4->y1)
      return 0;
   return 1;
}

// *********************************************************
// Discard any queued keystrokes
// *********************************************************
void TAG002ca8()
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;
   while(UI_CONSTAT() != 0)
   {
      UI_DIRECT_CONIN();
   }
   e.Byte9212 = -128;
   e.FirstQueuedMouseEvent = 0;
   e.LastQueuedMouseEvent = 4;
   e.Word9210 = 0;
   e.Byte9212 = 0;
}

// *********************************************************
//
// *********************************************************
i16 TAG002cdc(DlgButton *P1, i32 x, i32 y, i32 leftRight)
{
   dReg D0, D5, D6, D7;
   DlgButton *dlgButtonA4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   dlgButtonA4 = P1;
   D7W = sw(x);
   D6W = sw(y);
   if(dlgButtonA4 == NULL)
      return 0;
   while((D5W = dlgButtonA4->byte0) != 0)
   {
      D0W = TestInRectangle(&dlgButtonA4->rectPos2, D7W, D6W);
      if(D0W != 0)
      {
         if(leftRight & dlgButtonA4->byte11)
         {
            if((dlgButtonA4->byte1 & 1) == 0)
            {
               return D5W;
            }
         }
      }
      dlgButtonA4++;
   }
   return D5W;
}

// *********************************************************
//
// *********************************************************
//   TAG002d3c
void EnqueMouseClick(i32 P1, i32 P2, i32 P3)
{
   dReg D0, D4, D5, D6, D7;
   aReg A0;
   S12406 **pS12406A4;
   i16 w_2;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   D7W = sw(P1);
   D6W = sw(P2);
   if(e.Byte9212 != 0)
   { // Que is busy.  Put click in pending state.
      e.Word9210 = 1;
      e.Word9208 = D7W;
      e.Word9206 = D6W;
      e.Word9204 = sw(P3);
      return;
   }
   D5W = sw(e.LastQueuedMouseEvent + 2);
   if(D5W > 4)
      D5W -= 5;
   if(D5W == e.FirstQueuedMouseEvent)
      return;
   for(w_2 = 0, pS12406A4 = ppS12406_9142;
       w_2 < 6;
       w_2++, pS12406A4++)
   {
      if(*pS12406A4 == NULL)
         continue;
      if((*pS12406A4)->byte1 & 1)
         continue;
      D4W = TAG002cdc((*pS12406A4)->pDlgButton2, D7W, D6W, P3);
      if(D4W == 0)
         continue;
      D0W = D5W;
      D5W--;
      if(D0W == 0)
         D5W = 4;
      e.LastQueuedMouseEvent = D5W; // Last item in queue
      A0 = e.Byte9202 + 6 * D5W;
      A0[0] = D4B;
      A0[1] = (i8)w_2;
      wordGear(A0 + 2) = D7W;
      wordGear(A0 + 4) = D6W;
      break;
      //
      //
   }
   e.Byte9212 = 0;
}

// *********************************************************
//
// *********************************************************
//   TAG002e2c
void CheckPendingMouseClick()
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   if(e.Word9210 == 0)
      return;
   e.Word9210 = 0;
   EnqueMouseClick(e.Word9208, e.Word9206, e.Word9204);
}

// *********************************************************
//
// *********************************************************
void TAG002e4a(i32 P1)
{
   dReg D0, D1, D4, D5, D6, D7;
   aReg A0, A3;
   S12406 **pS12406A4;
   i16 w_4 = 0x1ccc;
   i16 w_2;
   //;;;;;;;;;;;;;;;;;;;;;;;;;
   D7L = P1;
   if(D7W == 0)
   {
      D7L >>= 8;
   }
   else
   {
      D0L = D7L & 0xff;
      D1L = D7L >> 8 & 0xff00;
      D4W = sw(D0W | D1W); // UpperHalf,LowerHalf in D4
      for(D5L = 0;
          (D5L < 7) && (D4W >= word9138[D5W]);
          D5W++)
      {
         if(D4W != word9138[D5W])
            continue;
         D7L = D4UW;
         break;
         //
         //
      }
   }
   e.Byte9212 = -128;
   D6W = sw(e.LastQueuedMouseEvent + 2);
   if(D6W > 4)
      D6W -= 5;
   if(D6W != e.FirstQueuedMouseEvent)
   {
      w_2 = 0;
      for(D5L = 0, pS12406A4 = ppS12406_9142;
          D5W < 6;
          D5W++, pS12406A4++)
      {
         if(*pS12406A4 == NULL)
            continue;
         if((*pS12406A4)->byte1 & 1)
            continue;
         A3 = (*pS12406A4)->pnt6;
         if(A3 == NULL)
            continue;
         for(;
             (D4W = sw(A3[0] & 255)) != 0;
             A3 += 4)
         {
            if(A3[1] & 1)
               continue;
            if(wordGear(A3 + 2) == D7W)
            {
            tag002f10:
               D0W = D6W;
               D6W--;
               if(D0W == 0)
                  D6W = 4;
               e.LastQueuedMouseEvent = D6W;
               A0 = e.Byte9202 + 6 * D6W;
               A0[0] = D4B;
               A0[1] = D5B;
               wordGear(A0 + 2) = (ui16)-1;
               wordGear(A0 + 4) = D7W;
               goto tag002f9a;
            }
            if(wordGear(A3 + 2) == -1)
            {
               w_2 = D4W;
               w_4 = D5W;
            }
            //
            //
         }
         //
      }
      if(w_2 != 0)
      {
         D4W = w_2;
         ASSERT(w_4 != 0x1ccc, "w_4");
         D5W = w_4;
         goto tag002f10;
      }
   }
tag002f9a:
   e.Byte9212 = 0;
   CheckPendingMouseClick();
}

// *********************************************************
//
// *********************************************************
i16 TAG002faa(S12406 *P1)
{
   dReg D7;
   S12406 **pS12406A4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;
   for(D7W = 0, pS12406A4 = ppS12406_9142; D7W < 6; D7W++, pS12406A4++)
   {
      if(*pS12406A4 != NULL)
         continue;
      *pS12406A4 = P1;
      TAG002ca8();
      return D7W;
      //
   }
   return -1;
}

// *********************************************************
//
// *********************************************************
//       TAG003000
S12406 **SetActiveDialog(S12406 **P1)
{
   S12406 **ppS12406_4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;
   ppS12406_4 = ppS12406_9142;
   ppS12406_9142 = P1;
   TAG002ca8();
   return ppS12406_4;
}

// *********************************************************
//
// *********************************************************
RESTARTABLE _TAG00301c(pnt P1)
{ //(i16)
   static dReg D0, D7;
   static S12406 *S12406A0;
   static aReg A0, A1, A3, A4;
   static i32 pressed_key;
   RESTARTMAP
   RESTART(1)
   END_RESTARTMAP
   //;;;;;;;;;;;;;;;;;;;;;;
   A4 = P1;
   // while (pumper(), wvbl(), CONSTAT() != 0)
   for(;;)
   {
      wvbl(_1_);
      if(UI_CONSTAT() == 0)
         break;
      pressed_key = UI_DIRECT_CONIN();
      TAG002e4a(pressed_key);
      if(pressed_key)
         EditCharacterName((char)pressed_key);
   }
   e.Byte9212 = -128;
   D7W = sw(e.LastQueuedMouseEvent + 1);
   if(D7W > 4)
      D7W = 0;
   if(D7W == e.FirstQueuedMouseEvent)
   { // Means queue is empty
      A0 = A4;
      A1 = e.Byte9172;
      StoreLong(A0, LoadLong(A1));
      wordGear(A0 + 4) = wordGear(A1 + 4);
      A0 += 6;
      A1 += 6;
   }
   else
   {
      A0 = &e.Byte9202[6 * e.FirstQueuedMouseEvent];
      A1 = A4;
      StoreLong(A1, LoadLong(A0));
      wordGear(A1 + 4) = wordGear(A0 + 4);
      e.FirstQueuedMouseEvent++;
      if(e.FirstQueuedMouseEvent > 4)
         e.FirstQueuedMouseEvent = 0;
   }
   e.Byte9212 = 0;
   CheckPendingMouseClick();
   if(*A4 != 0)
   {
      D7W = (UI8)(A4[1]);
      S12406A0 = ppS12406_9142[D7W];
      A4[1] = S12406A0->byte0;
      S12406A0 = ppS12406_9142[D7W];
      A3 = S12406A0->pnt10;
      if(A3 != NULL)
      {
         DontDoThis(0x30e0);
         ; // What to do here?
           //(A3)(A4);
      }
   }
   if(A4[0] == 0)
      A4[1] = 0;
   RETURN_i16((UI16)(((A4[1] << 8) & 0xff00) | (A4[0] & 0xff)));
}

// *********************************************************
//
// *********************************************************
void TAG003106(i16)
{
   DontDoThis(0x3106);
}

// *********************************************************
//
// *********************************************************
void TAG0031a6(i16 P1)
{
   i16 w_138[57];
   i16 w_24[10];
   i16 w_4;
   i16 w_2;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   TAG00507e();
   e.Word9124 = TAG005868(&w_2, &w_2, &w_2, &w_2);
   for(w_2 = 0; w_2 < 10; w_2++)
   {
      w_24[w_2] = 1;
      //
   }
   w_4 = 2;
   if(P1 == 0)
   {
      TAG005d8e(w_24, &e.Word9124, w_138);
   }
   else
   {
      TAG003106(1);
      TAG005d12(w_24, &e.Word9124, w_138);
      TAG003106(2);
   }
}

// *********************************************************
//
// *********************************************************
void TAG00323c()
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   TAG005df2(e.Word9124);
   TAG0050d2();
}

// *********************************************************
//
// *********************************************************
void TAG00324c()
{
   dReg D0;
   //;;;;;;;;;;;;;;;;;;;;;
   D0W = e.Word8074;
   e.Word8074++;
   if(D0W == 0)
   {
      TAG0061e2(e.Word8054);
   }
}

// *********************************************************
//
// *********************************************************
void TAG003264()
{
   dReg D0;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   D0W = e.Word8074;
   e.Word8074--;
   if(D0W == 1)
      TAG0061ba(e.Word8054, 1);
}

// *********************************************************
//
// *********************************************************
void TAG003294(i16 P1, i16 P2)
{
   //;;;;;;;;;;;;;;;;;;;;
   TAG00589e(0, P2);
   TAG0061ba(P1, 0);
}

// *********************************************************
//
// *********************************************************
void TAG00334c(dReg &D0, dReg &D1)
{
   if(e.Word8066 != 0)
   {
      D0W = e.Word8070;
      D1W = e.Word8068;
   }
   else
   {
      e.Word8070 = D0W;
      e.Word8068 = D1W;
   }
}

// *********************************************************
//
// *********************************************************
void TAG003372(dReg &D0)
{
   dReg D3;
   if(e.Word8056 == 0)
   {
      D3W = e.Word8072;
      if((D3W != 0) && (D0W != 0))
      {
         e.Word8072 = D0W;
      }
      else
      {
         e.Word8072 = D0W;
         if(D0W != 0)
         {
            EnqueMouseClick(e.Word8070, e.Word8068, D0W);
         }
      }
      e.Word8056 = 0;
   }
}

// *********************************************************
//
// *********************************************************
void TAG0032b4(i16 P1, i16 P2)
{
   aReg A4;
   pnt pnt_10;
   i16 w_6;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   switch(P1)
   {
      case 1:
         e.Word8054 = P2;
         TAG006202(e.Word8054, &w_6, &e.Word8070, &e.Word8068);
         A4 = (pnt)0x00334c;
         TAG00626e(e.Word8054, (char *)A4, (char **)&e.Pnt8064);
         A4 = (pnt)0x003372;
         TAG00623a(e.Word8054, (char *)A4, (char **)&e.Pnt8060);
         break;
      case 2:
         TAG00626e(e.Word8054, (char *)LoadPnt((ui8 *)&e.Pnt8064), (char **)&pnt_10);
         TAG00623a(e.Word8054, (char *)LoadPnt((ui8 *)&e.Pnt8060), (char **)&pnt_10);
         break;
         //;;;;;;;;;;;;;;;;;;;;;;;;;
      default: {
      }
   }; // switch (P1);
}

// *********************************************************
//
// *********************************************************
//   TAG0033b6
void BitBltSquareImage(pnt P1, const wordRectPos *rect, i16 P3, i16 P4)
{
   //;;;;;;;;;;;;;;;
   e.Word8048 = 0;
   TAG0088b2((ui8 *)P1,
             LoadPnt((ui8 *)&e.PhysicalBase),
             (RectPos *)rect,
             0,
             0,
             P3,
             160,
             P4);
}

// *********************************************************
//
// *********************************************************
//   TAG0033e6
void FillScreenRectangle(wordRectPos *rp, i16 P2)
{
   //;;;;;;;;;;
   FillRectangle(LoadPnt((ui8 *)&e.PhysicalBase),
                 (RectPos *)rp,
                 P2,
                 160);
}

// *********************************************************
//
// *********************************************************
//   TAG0034dc
void ExpandRectangle(wordRectPos *rp1,
                     wordRectPos *rp2,
                     i16 deltaX,
                     i16 deltaY)
{
   rp2->x1 = sw(rp1->x1 - deltaX);
   rp2->x2 = sw(rp1->x2 + deltaX);
   rp2->y1 = sw(rp1->y1 - deltaY);
   rp2->y2 = sw(rp1->y2 + deltaY);
}

// *********************************************************
//
// *********************************************************
//   TAG003406
void DrawNameTitleCarret(i16 P1, i16 P2)
{
   dReg D0;
   wordRectPos *rectA4;
   //;;;;;;;;;;;;;;;;;;;;

   rectA4 = &dlgButton5050[P1 + 13].rectPos2;
   e.EditBoxSelected = P1;
   e.EditBoxPosition = P2;
   TAG00324c();
   if(e.Word5168 != 0)
   {
      FillScreenRectangle(&e.wRectPos5176, 1);
   }
   D0W = sw(rectA4->x1 + 6 * P2 + 1);
   e.wRectPos5176.x2 = D0W;
   e.wRectPos5176.x1 = D0W;
   e.wRectPos5176.y1 = rectA4->y1;
   e.wRectPos5176.y2 = rectA4->y2;
   FillScreenRectangle(&e.wRectPos5176, 15);
   TAG003264();
   e.Word5168 = 1;
   e.Word5178 = 30;
}

// *********************************************************
//
// *********************************************************
//          _TAG00352c
RESTARTABLE _InvertButton(const wordRectPos *pRect)
{ //()
   static dReg D5, D6, D7;
   static aReg A3;
   const static wordRectPos *rectA4;
   static wordRectPos rect_8;
   static i32 i;
   RESTARTMAP
   RESTART(1)
   END_RESTARTMAP
   //;;;;;;;;;;;;;;
   rectA4 = pRect;
   rect_8.x1 = 0;
   rect_8.y1 = 0;
   D6W = sw(rectA4->x2 - rectA4->x1);
   rect_8.x2 = sw(D6W + 1);
   D5W = sw(rectA4->y2 - rectA4->y1 + 1);
   rect_8.y2 = sw(D5W + 1);
   D6W = sw(((D6W + 15) & 0xfff0) / 2);
   TAG00324c();
   A3 = e.Byte3764;
   ASSERT(size3764 >= D6W * (rect_8.y2 + 1), "size3467");
   TAG0088b2(LoadPnt((ui8 *)&e.PhysicalBase), // src
             (ui8 *)A3,                       // dst
             (RectPos *)&rect_8,              // dst position
             rectA4->x1,                      // src x offset
             rectA4->y1,                      // src y offset
             160,                             // src byte width
             D6W,                             // dst byte width
             -1);
   for(D7W = sw((D6W * D5W) / 4);
       D7W > 0;
       D7W--)
   {
      StoreLong(A3, LoadLong(A3) ^ -1);
      A3 += 4;
   }
   BitBltSquareImage(e.Byte3764, rectA4, D6W, -1);
   for(i = 0; i < 5; i++)
   {
      wvbl(_1_);
   }
   TAG003264();
   RETURN;
}

// *********************************************************
//
// *********************************************************
void TAG004ea2(i16 *)
{
   HopefullyNotNeeded(0xcd89);
   // This appears to do nothing on the Atari.
   // A parameter of 115 does something.  But 200 does nothing.
   //;;;;;;;;;;;;;;;;;;;;;;;;
}

// file = chaos.ftl      offset =68ec
//
char data004f1c[348] = {
    0, 1, 0, 2, 1, 1, 2, 1, 1, 0, 1, 1, 2, 1, 1, 1,
    // 004f2c
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    0,
    0,
    1,
    // 004f3c
    0,
    3,
    5,
    0,
    5,
    5,
    0,
    0,
    1,
    1,
    2,
    1,
    0,
    16,
    7,
    1,
    // 004f4c
    2,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    1,
    2,
    // 004f5c
    1,
    1,
    2,
    1,
    1,
    2,
    1,
    1,
    1,
    1,
    2,
    1,
    1,
    1,
    0,
    0,
    // 004f6c
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    2,
    1,
    1,
    1,
    1,
    1,
    // 004f7c
    6,
    1,
    1,
    4,
    1,
    1,
    1,
    3,
    1,
    2,
    1,
    1,
    4,
    2,
    1,
    8,
    // 004f8c
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    1,
    9,
    1,
    1,
    1,
    1,
    // 004f9c
    1,
    1,
    1,
    0,
    0,
    5,
    1,
    3,
    3,
    1,
    2,
    2,
    1,
    0,
    0,
    0,
    // 004fac
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    // 004fbc
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    // 004fcc
    0,
    0,
    0,
    0,
    4,
    3,
    0,
    8,
    3,
    0,
    6,
    1,
    0,
    8,
    1,
    0,
    // 004fdc
    8,
    1,
    0,
    4,
    1,
    1,
    3,
    1,
    1,
    0,
    5,
    0,
    1,
    1,
    1,
    0,
    // 004fec
    5,
    0,
    0,
    1,
    1,
    0,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    // 004ffc
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    // 00500c
    0,
    2,
    2,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    // 00501c
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    5,
    1,
    // 00502c
    0,
    5,
    1,
    0,
    1,
    1,
    0,
    1,
    1,
    0,
    2,
    5,
    0,
    6,
    1,
    0,
    // 00503c
    2,
    1,
    0,
    1,
    1,
    0,
    6,
    5,
    0,
    0,
    0,
    0,
    0,
    1,
    1,
    0,
    // 00504c
    1,
    0,
    2,
    1,
    0,
    2,
    1,
    1,
    1,
    1,
    1,
    0,
    0,
    0,
    0,
    0,
    // 00505c
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    1,
    2,
    3,
    1,
    2,
    // 00506c
    1,
    1,
    1,
    1,
    1,
    1,
    0,
    1,
    1,
    0,
    1,
    2};

// *********************************************************
//
// *********************************************************
//   TAG0035cc
void DrawDialogBoxOutline(wordRectPos *rectPos,
                          i16 P2,
                          i16 P3,
                          i16 P4)
{
   dReg D6, D7;
   wordRectPos rectPos_24;
   wordRectPos rectPos_16;
   wordRectPos rectPos_8;
   wordRectPos *rpA4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   rpA4 = rectPos;
   D7W = P2;
   if(D7W < 0)
   {
      ExpandRectangle(rpA4, &rectPos_8, D7W, D7W);
      D7W = sw(-D7W);
   }
   else
   {
      MemoryMove((ui8 *)rpA4, (ui8 *)&rectPos_8, 0x400, 0x400, 8);
   }
   FillScreenRectangle(&rectPos_8, P4);
   if(D7W == 0)
      return;
   ExpandRectangle(&rectPos_8, &rectPos_16, D7W, D7W);
   D7W--;
   for(D6W = 0; D6W < 4; D6W++)
   {
      MemoryMove((ui8 *)&rectPos_16, (ui8 *)&rectPos_24, 0x400, 0x400, 8);
      switch(D6W)
      {
         case 0:
            rectPos_24.x2 = sw(rectPos_24.x1 + D7W);
            break;
         case 1:
            rectPos_24.x1 = sw(rectPos_24.x2 - D7W);
            break;
         case 2:
            rectPos_24.y2 = sw(rectPos_24.y1 + D7W);
            break;
         case 3:
            rectPos_24.y1 = sw(rectPos_24.y2 - D7W);
      }; // case (D6W)
      FillScreenRectangle(&rectPos_24, P3);
      //
   }
}

// *********************************************************
//
// *********************************************************
//   TAG0036c0
void DrawMagnifiedCharacterImage()
{
   dReg D0, D6, D7;
   aReg A4;
   wordRectPos rect_8;
   //;;;;;;;;;;;;;;;;;;;;;;
   A4 = e.CharacterImages + 464 * e.ActualCharacter;
   rect_8.x1 = wRectPos5162.x1;
   TAG00324c();
   for(D7W = 0; D7W < 32; D7W++)
   {
      rect_8.x2 = sw(rect_8.x1 + 2);
      rect_8.y1 = wRectPos5162.y1;
      for(D6W = 0; D6W < 29; D6W++)
      {
         rect_8.y2 = sw(rect_8.y1 + 2);
         D0W = sw(GetPixel(A4, D7W, D6W, 16));
         FillScreenRectangle(&rect_8, D0W);
         rect_8.y1 += 3;
         //
      }
      rect_8.x1 += 3;
      //
      //
   }
   TAG003264();
}

// *********************************************************
//
// *********************************************************
//   TAG003748
void PrintCharacterName(i16 chIdx)
{
   dReg D0;
   aReg A1;
   wordRectPos *rectA4;
   char name[9];
   i32 i;
   //;;;;;;;;;;;;;;
   ASSERT(chIdx < 4, "chidx");
   rectA4 = &wRectPos5138[chIdx];
   FillScreenRectangle(rectA4, 1);
   if(chIdx != e.ActualCharacter)
   {
      D0L = 15;
   }
   else
   {
      D0L = 9;
   }
   A1 = (aReg)LoadPnt((ui8 *)&e.Pnt24812) + 800 * chIdx + 772;
   // character name should be redrawn completely
   strcpy(name, (char *)LoadPnt((ui8 *)&e.Pnt24812) + 800 * chIdx + 772);
   for(i = 0; i < 8; i++)
   {
      if((name[i] == 0) || (name[i] < 'A') || (name[i] > 'Z'))
         name[i] = 32;
   }
   name[8] = 0;
   TextToScreen(rectA4->x1 + 2, 9, D0W, 1, name);
}

// *********************************************************
//
// *********************************************************
//   TAG0037ac
void DrawCharacterHeader(i16 P1, i16 P2)
{
   aReg A0;
   wordRectPos *rectA0, *rectA1;
   DlgButton *dlgButtonA0;
   wordRectPos rect_8;
   //;;;;;;;;;;;;;;;;;;;
   TAG00324c();
   if(P1 < e.Word24814)
   {
      PrintCharacterName(P1);
      rectA0 = &wRectPos5106[P1];
      DrawDialogBoxOutline(rectA0, 1, P2, 1);
      A0 = e.CharacterImages + 464 * P1;
      rectA1 = &wRectPos5106[P1];
      BitBltSquareImage(A0, rectA1, 16, -1);
   }
   else
   {
      dlgButtonA0 = &dlgButton5050[P1];
      MemoryMove((ui8 *)dlgButtonA0 + 2, (ui8 *)&rect_8, 0x400, 0x400, 8);
      rect_8.y2--;
      FillScreenRectangle(&rect_8, 0);
   }
   TAG003264();
}

// *********************************************************
//
// *********************************************************
//   TAG003860
void AddDialogButton(DlgButton *P1, const char *P2, i16 P3)
{
   dReg D0, D1;
   DlgButton *dlgButtonA4;
   i16 w_18;
   wordRectPos rectPos_8;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   dlgButtonA4 = P1;
   TAG00324c();
   MemoryMove((ui8 *)&dlgButtonA4->rectPos2, (ui8 *)&rectPos_8, 0x400, 0x400, 8);
   DrawDialogBoxOutline(&rectPos_8, 2, P3, 0);
   w_18 = sw((rectPos_8.x1 + rectPos_8.x2) / 2);
   D0W = sw(3 * StrLen(P2));
   D1W = sw(w_18 - D0W);
   TextToScreen(D1W + 1, rectPos_8.y2 - 2, 15, 0, P2);
   TAG003264();
}

// *********************************************************
//
// *********************************************************
//   TAG0038ea
void GetPalleteItemRect(i16 P1, wordRectPos *rect)
{
   wordRectPos *rectA4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   rectA4 = rect;
   rectA4->x1 = wRectPos5154.x1;
   rectA4->x2 = wRectPos5154.x2;
   rectA4->y1 = sw(wRectPos5154.y1 + 8 * P1);
   rectA4->y2 = sw(rectA4->y1 + 6);
}

// *********************************************************
//
// *********************************************************
//   TAG003922
void DrawSelectedColor(i16 P1)
{
   dReg D0;
   wordRectPos rect_8;
   //;;;;;;;;;;;;;;;;;;;;;;;
   if(P1 == e.Word7062)
      return;
   TAG00324c();
   if(e.Word7062 >= 0)
   {
      GetPalleteItemRect(e.Word7062, &rect_8);
      D0L = byte4712[e.Word7062];
      DrawDialogBoxOutline(&rect_8, 1, 0, D0W);
   }
   e.Word7062 = P1;
   GetPalleteItemRect(e.Word7062, &rect_8);
   D0W = byte4712[e.Word7062];
   DrawDialogBoxOutline(&rect_8, 1, 15, D0W);
   TAG003264();
}

// *********************************************************
//
// *********************************************************
void TAG0039a8()
{
   aReg A0;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   A0 = e.Byte5202 + 6 * e.ActualCharacter;
   e.Word4696 = ub(A0[4]);
   A0 = e.CharacterImages + 464 * e.ActualCharacter;
   MemoryMove((ui8 *)A0, (ui8 *)e.Byte4694, 0x400, 0x400, 464);
}

// *********************************************************
//
// *********************************************************
//   TAG0039ea
void FillCharacterNameEditBox(const char *P1, i16 P2, i16 P3)
{
   dReg D0, D1, D5, D6, D7;
   wordRectPos *rectA4;
   //;;;;;;;;;;;;;;;;;;
   rectA4 = &dlgButton5050[P2].rectPos2;
   D5W = StrLen(P1);
   e.Word5168 = 0;
   FillScreenRectangle(rectA4, 1);
   D7W = sw(rectA4->x1 + 2);
   D6W = sw(rectA4->y2 - 2);
   TextToScreen(D7W, D6W, 9, 1, P1);
   D0W = sw(6 * D5W + D7W);
   D1W = sw(P3 - D5W);
   TextToScreen(D0W,
                D6W,
                9,
                1,
                "___________________" + 19 - D1W);
}

// *********************************************************
//
// *********************************************************
//   TAG003a7c
void PrintAttributeValue(const char *P1, i32 P2, i32 P3)
{
   char b_20[20];
   //;;;;;;;;;;;;;;;;;;;;;;
   atari_sprintf(b_20, "%s %d", (intptr_t)P1, P2);
   TextToScreen(17, P3, 13, 0, b_20);
}

// *********************************************************
//
// *********************************************************
//          _TAG003ab6
RESTARTABLE _DrawCharacterDetails(const i32 P1, const i32 P2)
{ //()
   static dReg D0, D3, D4, D5, D6, D7;
   static aReg A0, A1, A4;
   static char b_28[20];
   static wordRectPos rect_8;
   RESTARTMAP
   RESTART(1)
   RESTART(2)
   END_RESTARTMAP
   //;;;;;;;;;;;;;;;;;;;;;;
   D7W = sw(P1);
   D6W = e.ActualCharacter;
   if(D7W == D6W)
      RETURN;
   e.ActualCharacter = D7W;
   TAG00324c();
   if(D6W >= 0)
   {
      DrawCharacterHeader(D6W, 0);
   }
   if(P2 != 0)
   {
      TAG0039a8();
   }
   DrawCharacterHeader(D7W, 15);
   wvbl(_1_);
   BitBltSquareImage((i8 *)FrameImage, &wRectPos5106[4], 24, -1);
   wvbl(_2_);
   A0 = e.CharacterImages + 464 * D7W;
   BitBltSquareImage(A0, &wRectPos5106[5], 16, 1);
   FillScreenRectangle(&wRectPos5106[6], 0);
   A4 = (aReg)LoadPnt((ui8 *)&e.Pnt24812) + 800 * D7W + 772;
   FillCharacterNameEditBox((char *)A4, 13, 7);
   FillCharacterNameEditBox((char *)A4 + 8, 14, 19);
   D0W = StrLen((char *)A4);
   DrawNameTitleCarret(0, D0W);
   for(D5L = 121, D6L = 0; D6W < 4; D6W++)
   {
      A0 = A4 + 6 * D6W;
      D3L = LE32(LoadLong(A0 + 94));
      for(D4L = 0; D3L >= 500; D3L >>= 1, D4W++)
      {
      }
      //

      if(D4W == 0)
         continue;
      D4W--;
      if(D4W >= 15)
         D4W = 14;
      A0 = (aReg)pnt4772[D4W];
      A1 = (aReg)pnt4788[D6W];
      atari_sprintf(b_28, "%s %s", (intptr_t)A0, (intptr_t)A1);
      TextToScreen(17, D5W, 13, 0, (char *)b_28);
      D5W += 7;
      //
   }
   if(D5W < 149)
   {
      rect_8.x1 = 17;
      rect_8.x2 = 131;
      rect_8.y1 = sw(D5W - 6);
      rect_8.y2 = 149;
      FillScreenRectangle(&rect_8, 0);
   }
   PrintAttributeValue("HEALTH     ", LE16(wordGear(A4 + 54)), 154);
   PrintAttributeValue("STAMINA    ", LE16(wordGear(A4 + 58)) / 10, 161);
   PrintAttributeValue("MANA       ", LE16(wordGear(A4 + 62)), 168);
   DrawMagnifiedCharacterImage();
   TAG003264();
   RETURN;
}

// *********************************************************
//
// *********************************************************
//          _TAG003f12
RESTARTABLE _DrawCharacterEditorScreen()
{ //()
   static dReg D7;
   static wordRectPos rect_8;
   RESTARTMAP
   RESTART(1)
   END_RESTARTMAP
   //;;;;;;;;;;;;;;;
   TAG00324c();
   ClearMemory(LoadPnt((ui8 *)&e.PhysicalBase), 32000);
   AddDialogButton(&dlgButton5050[10], "LOAD CHAMPIONS", 2);
   AddDialogButton(&dlgButton5050[11], "SAVE CHAMPIONS", 2);
   AddDialogButton(&dlgButton5050[12], "MAKE NEW ADVENTURE", 2);
   AddDialogButton(&dlgButton5050[7], "REVERT", 2);
   AddDialogButton(&dlgButton5050[8], "UNDO", 2);
   AddDialogButton(&dlgButton5050[16], "QUIT", 2);
   DrawDialogBoxOutline(&wRectPos5162, 3, 3, 0);
   DrawDialogBoxOutline(&wRectPos5146, 2, 2, 0);
   DrawCharacterDetails(_1_, 0, 1);
   for(D7W = 1; D7W < e.Word24814; D7W++)
   {
      DrawCharacterHeader(D7W, 0);
      //
   }
   DrawSelectedColor(0);
   for(D7W = 1; D7W < 16; D7W++)
   {
      GetPalleteItemRect(D7W, &rect_8);
      FillScreenRectangle(&rect_8, byte4712[D7W]);
      //
      //
   }
   TAG003264();
   RETURN;
}

// *********************************************************
//
// *********************************************************
void TAG00439e()
{
   dReg D7;
   //;;;;;;;;;;;;;;;
   for(D7W = 0; D7W < e.Word24814; D7W++)
   {
      MemoryMove(LoadPnt(e.Byte5202 + 6 * D7W),
                 (ui8 *)e.Byte4228,
                 0x400,
                 0x400,
                 464);
      MemoryMove((ui8 *)e.CharacterImages + 464 * D7W,
                 LoadPnt(e.Byte5202 + 6 * D7W),
                 0x400,
                 0x400,
                 464);
      MemoryMove((ui8 *)e.Byte4228,
                 (ui8 *)e.CharacterImages + 464 * D7W,
                 0x400,
                 0x400,
                 464);
      //
      //
   }
}

// *********************************************************
//
// *********************************************************
RESTARTABLE _TAG004430(i32 P1)
{ //()
   static dReg D7;
   static aReg A0, A1;
   RESTARTMAP
   RESTART(1)
   END_RESTARTMAP
   //;;;;;;;;;;;;;
   e.ActualCharacter = -1;
   for(D7L = 0; D7W < 4; D7W++)
   {
      if(D7W < e.Word24814)
      {
         A0 = e.Byte5202 + 6 * D7W;
         StorePnt(A0, LoadPnt((ui8 *)&e.Pnt24812) + 800 * D7W + 1108);
         A1 = e.CharacterImages + 464 * D7W;
         MemoryMove(LoadPnt(A0), (ui8 *)A1, 0x400, 0x400, 464);
      }
      else
      {
         A0 = e.Byte5202 + 6 * D7W;
         StoreLong(A0, 0);
         A0 = e.CharacterImages + 464 * D7W;
         ClearMemory((ui8 *)A0, 464);
      }
      A0 = e.Byte5202 + 6 * D7W;
      A0[4] = 0;
      //
   }
   if(P1 == 0)
      RETURN;
   if(e.Word24814 != 0)
   {
      DrawCharacterDetails(_1_, 0, 1);
   }
   else
   {
      DrawCharacterHeader(0, 0);
   }
   for(D7W = 1; D7W < 4; D7W++)
   {
      DrawCharacterHeader(D7W, 0);
      //
      //
   }
   RETURN;
}

// *********************************************************
//
// *********************************************************
RESTARTABLE _TAG004518()
{ //()
   static dReg D0;
   static unsigned char buffer[6];
   RESTARTMAP
   RESTART(1)
   RESTART(2)
   RESTART(3)
   RESTART(4)
   RESTART(5)
   RESTART(6)
   RESTART(7)
   RESTART(8)
   RESTART(9)
   RESTART(10)
   RESTART(11)
   END_RESTARTMAP
   //;;;Lots of something. Read game file.  Fiddle with characters
   //;;;WriteGamefile
   e.Word8048 = 0;
   e.Word7062 = -1;
   TAG004430(_6_, 0);
   DrawCharacterEditorScreen(_7_);
   TAG002faa(&s12406_4802);
   do
   {
      TAG00301c(_1_, buffer);
      D0W = i16Result;
      switch(D0W & 255)
      {
         case 1:
         case 2:
         case 3:
         case 4:
            DrawCharacterDetails(_11_, (D0W & 255) - 1, 1);
            if(e.Word5178 == 0)
               RETURN;
            break;
         case 5: {
            // image size 22x21
            // i32 mousex=(buffer[2]-156)/4;
            // i32 mousey=(buffer[4]-60)/4;
            // i8* start = (i8*)(e.CharacterImages + 464*e.ActualCharacter) + (mousey * 22) + mousex;
            //(*start) = SelectedColor;
            // does not work - graphics is stored in planar structure, not chunky!
            // must rewrite it later
            BitBltSquareImage(e.CharacterImages + 464 * e.ActualCharacter, &wRectPos5106[e.ActualCharacter], 16, -1);
            BitBltSquareImage((i8 *)FrameImage, &wRectPos5106[4], 24, -1);
            BitBltSquareImage(e.CharacterImages + 464 * e.ActualCharacter, &wRectPos5106[5], 16, 1);
            DrawMagnifiedCharacterImage();
            // Edit character image
         }
         break;
         case 6:
            DontDoThis(0x45d0);
            goto case17;
            break;
         case 7:
            // choose color
            SelectedColor = (unsigned char)((buffer[4] - 42) / 8);
            DrawSelectedColor(SelectedColor);
            break;
         case 8:
            // MessageBox(NULL,"I do not plan to implement this function","Error",MB_OK|MB_TASKMODAL);
            DontDoThis(0x4616);
            goto case17;
            break;
         case 9:
            // I have encountered it sometimes
            // DontDoThis(0x46ae);  goto case17;
            break;
         case 11:
            DontDoThis(0x476a);
            goto case17;
            break;
         case 12:
            DontDoThis(0x4872);
            goto case17;
            break;
         case 13: // Make New Adventure
            InvertButton(_8_, &dlgButton5050[12].rectPos2);
            TAG00260e(_2_);
            D0W = i16Result;
            if(D0W != 0)
            {
               if(wordGear(LoadPnt((ui8 *)&e.Pnt24812) + 4112) == 0)
               {
                  ReadSavedGame(_3_, 1);
               }
               if(wordGear(LoadPnt((ui8 *)&e.Pnt24812) + 4112) != 0)
               {
                  TAG0026c4(_4_, LoadPnt((ui8 *)&e.Pnt24812) + 4112);
                  D0W = i16Result;
                  if(D0W != 0)
                  {
                     TAG00439e();
                     TAG002724();
                     TAG00439e();
                     TAG000fc4(_5_, 1);
                  }
               }
            }
            InvertButton(_9_, &dlgButton5050[12].rectPos2);
            break;
         case 14:
            // Change character name
            {
               // First get character name and determine length
               i16 desired_pos, pos;
               desired_pos = (i16)(((buffer[2] - 17) / 6) + 1);
               char *name = (char *)LoadPnt((ui8 *)&e.Pnt24812) + 800 * e.ActualCharacter + 772;
               // Then get desired carret position and fix it
               pos = (i16)strlen(name);

               if(desired_pos > pos)
                  desired_pos = pos;
               // Draw carret
               DrawNameTitleCarret(0, desired_pos);
               break;
            }
            break;
         case 15:
            // Change character title
            {
               // First get character name and determine length
               i16 desired_pos = (i16)(((buffer[2] - 17) / 6) + 1);
               i16 pos;
               char *title = (char *)LoadPnt((ui8 *)&e.Pnt24812) + 800 * e.ActualCharacter + 780;

               // Then get desired carret position and fix it
               pos = (i16)strlen(title);
               if(desired_pos > pos)
                  desired_pos = pos;

               // Draw carret
               // DrawNameTitleCarret(1,desired_pos);
               desired_pos += 32; // I can see if editing name or title 'coz position could not be larger than 32
            }
            break;
         case 16:
            DontDoThis(0x49c0);
            goto case17;
            break;
         case 17:
         case17:
            InvertButton(_10_, &dlgButton5050[16].rectPos2);
            RETURN;
         case 10:
         default:
            break;
      }; // case
   } while(e.Word5178 != 0);
   DontDoThis(0x49e0);
   RETURN;
}

// Internal function to make TextOut easier to read
void TAG004d4a(dReg &D2,
               dReg &D3,
               dReg &D4,
               dReg &D5,
               aReg &A2,
               aReg A3,
               i32 A3inc,
               i32 jA0,
               i32 jA1)
{
   dReg D0, D1, D6, D7;
loop:
   StoreLong(A3 + 0, LoadLong(A3 + 0) & LE32(D2L));
   StoreLong(A3 + 4, LoadLong(A3 + 4) & LE32(D2L));
   D0L = (UI8)(*A2);
   switch(D5W)
   {
      case 0:
         D0W <<= 11 - D3W;
         break;
      case 8:
         D0W >>= D3W - 11;
         break;
      case 18:
         D0W <<= 27 - D3W;
         break;
      default: DontDoThis(0x4d6e);
   }
   D1H1 = D0H2;
   D1H2 = D0H2;
   // D1W = D0W;
   // SWAP(D1);
   // D1W = D0W;
   // SWAP(D0);
   D0L = ((D0L & 0xffff) << 16) | ((D0L >> 16) & 0xffff);
   D6L = 0;
   D7L = 0;
   switch(jA0 & 0xffff)
   {
      case 1: D6L = D0L; break;
      case 2: D6W = D1W; break;
      case 3: D6L = D1L; break;
      case 4: D7L = D0L; break;
      case 5:
         D6L = D0L;
         D7L = D0L;
         break;
      case 6:
         D6W = D1W;
         D7L = D0L;
         break;
      case 7:
         D6L = D1L;
         D7L = D0L;
         break;
      case 8: D7W = D1W; break;
      case 9:
         D6L = D0L;
         D7W = D1W;
         break;
      case 10:
         D6W = D1W;
         D7W = D1W;
         break;
      case 11:
         D6L = D1L;
         D7W = D1W;
         break;
      case 12: D7L = D1L; break;
      case 13:
         D6L = D0L;
         D7L = D1L;
         break;
      case 14:
         D6W = D1W;
         D7L = D1L;
         break;
      case 15:
         D6L = D1L;
         D7L = D1L;
         break;
      case 0: break;
      default: DontDoThis(0x4db0);
   }
   D0L |= D2L;
   D0L ^= 0xffffffff;
   D0W = 0;
   D1L |= D2L;
   D1L ^= 0xffffffff;
   switch(jA1 & 0xffff)
   {
      case 1: D6L |= D0L; break;
      case 2: D6L |= D1L; break;
      case 3: D6L |= D1L; break;
      case 4: D7L |= D0L; break;
      case 5:
         D6L |= D0L;
         D7L |= D0L;
         break;
      case 6:
         D6L |= D1L;
         D7L |= D0L;
         break;
      case 7:
         D6L |= D1L;
         D7L |= D0L;
         break;
      case 8: D7L |= D1L; break;
      case 9:
         D6L |= D0L;
         D7L |= D1L;
         break;
      case 10:
         D6L |= D1L;
         D7L |= D1L;
         break;
      case 11:
         D6L |= D1L;
         D7L |= D1L;
         break;
      case 12: D7L |= D1L; break;
      case 13:
         D6L |= D0L;
         D7L |= D1L;
         break;
      case 14:
         D6L |= D1L;
         D7L |= D1L;
         break;
      case 15:
         D6L |= D1L;
         D7L |= D1L;
         break;
      case 0: break;
      default: DontDoThis(0x4de8);
   }
   StoreLong(A3 + 0, LoadLong(A3 + 0) | LE32(D6L));
   StoreLong(A3 + 4, LoadLong(A3 + 4) | LE32(D7L));
   D4W--;
   if(D4W == 0)
      return;
   A2 += 70;
   A3 += A3inc;
   goto loop;
}

// *********************************************************
//
// *********************************************************
//   TAG004bbc
void TextOutB(ui8 *dest,
              i32 destWidth,
              i32 x,
              i32 y,
              i32 color,
              i32 P6,
              const char *text)
{
   dReg D2, D3, D4, D5, D6, D7;
   i32 saveD2;
   aReg A2, A4, saveA2, saveA4;
   const char *A0;
   i32 jA0, jA1;
   A2 = NULL;
   A4 = (aReg)dest;
   D7W = sw(x);
   D6W = sw(y);
   // D5W = P5;
   D4W = sw(P6);
   A0 = text;
   if(*A0 == 0)
      return;
   A4 += (D6W - 4) * destWidth;
   A4 += (D7W & 0xfff0) >> 1;
   D3W = (UI16)(D7W & 15);
   jA0 = color; // 16 colors
   jA1 = D4W;
tag004cce:
   for(;;)
   {
      do
      {
         D2L = 0;
         D2B = *text;
         if(D2W == 0)
            return;
         text++;
         A2 = Byte1278 + D2W - 32;
         if(D3W > 11)
            goto tag004d12;
         D4L = 6;
         D2L = 0x07ff07ff;
         D2L >>= D3W;
         D2H1 = D2W;
         D5L = 0;
         TAG004d4a(D2, D3, D4, D5, A2, A4, destWidth, jA0, jA1);
         D3W += 6;
      } while(D3W < 16);
      D3W &= 1;
      A4 += 8;
   }
tag004d12:
   D4L = 6;
   saveA4 = A4 + 8;
   saveA2 = A2;
   D2L = Long954[D3W - 12];
   saveD2 = Long938[D3W - 12];
   A2 = saveA2;
   D5L = 8;
   TAG004d4a(D2, D3, D4, D5, A2, A4, destWidth, jA0, jA1);
   D2L = saveD2;
   A2 = saveA2;
   A4 = saveA4;
   ;
   D4L = 6;
   D5L = 18;
   TAG004d4a(D2, D3, D4, D5, A2, A4, destWidth, jA0, jA1);

   A4 = saveA4;
   D3W -= 10;
   goto tag004cce;
}

// *********************************************************
//
// *********************************************************
void TextToScreen(i32 xPixel, i32 yPixel, i32 P3, i32 P4, const char *P5)
{
   TextOutB(LoadPnt((ui8 *)&e.PhysicalBase),
            160,
            xPixel,
            yPixel,
            P3,
            P4,
            P5);
}

// *********************************************************
//
// *********************************************************
i16 TAG004ec0(i32 P1)
{
   aReg A1, A4;
   i16 *wA0;
   i32 i;
   //;;;;;;;;;;;;;
   e.Word826[0] = sw(P1);
   ASSERT(P1 < 111, "P1>=111"); // Else expand table
   A4 = (aReg)data004f1c + 3 * (P1 - 10);
   for(i = 1; i < 5; i++)
   {
      wA0 = &e.Word826[i];
      A1 = A4;
      A4 += 1;
      *wA0 = (UI16)(*A1 & 0xff);
      //
      //
   }
   TAG004ea2(Loadpi16(&e.Pnt714[6]));
   return e.Word750[0];
   //
   //
   // file = chaos.ftl      offset =6a48
   //
}

// *********************************************************
//
// *********************************************************
i16 TAG00507e()
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   Storepi16(&e.Pnt714[0], e.Word826);
   Storepi16(&e.Pnt714[1], e.Word816);
   Storepi16(&e.Pnt714[2], e.Word784);
   Storepi16(&e.Pnt714[3], e.Word750);
   Storepi16(&e.Pnt714[4], e.Word734);
   Storepi16(&e.Pnt714[5], e.Word722);
   Storepi16(&e.Pnt714[6], (i16 *)e.Pnt714);
   TAG004ec0(10);
   e.Word686 = e.Word750[0];
   return e.Word686;
}

// *********************************************************
//
// *********************************************************
i16 TAG0050d2()
{
   TAG004ec0(19);
   return 1;
}

// *********************************************************
//
// *********************************************************
i16 TAG005868(i16 *P1, i16 *P2, i16 *P3, i16 *P4)
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   TAG004ec0(77);
   *P1 = e.Word750[1];
   *P2 = e.Word750[2];
   *P3 = e.Word750[3];
   *P4 = e.Word750[4];
   return e.Word750[0];
}

// *********************************************************
//
// *********************************************************
void TAG00589e(i16 P1, i16 P2)
{
   //;;;;;;;;;;;;;;;;
   e.Word784[0] = P1;
   e.Word734[0] = P2;
   TAG004ec0(78);
}

// *********************************************************
//
// *********************************************************
void TAG005c92(char *P1)
{ // Splits an address into two words.
   dReg D0;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;
   D0L = (i32)P1 >> 16;
   e.Word9108 = D0W;
   e.Word9106 = (UI16)((i32)P1 & 0xffff);
}

// *********************************************************
//
// *********************************************************
void TAG005cd6(char **P1)
{ // Reassemble a pointer from two words.
   dReg D0;
   //;;;;;;;;;;;;;;;;
   D0L = e.Word9104 << 16;
   D0W = e.Word9102;
   StoreLong((pnt)P1, D0L);
   //*P1 = (pnt)D0L;
}

// *********************************************************
//
// *********************************************************
void TAG005cf6()
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;
   // Trap #2 with parameter 115 does do something on the
   // Atari.  I don't know what.
   HopefullyNotNeeded(0xcd8a);
}

// *********************************************************
//
// *********************************************************
void TAG005d12(i16 *, i16 *, i16 *)
{
   DontDoThis(0x5d12);
}

// *********************************************************
//
// *********************************************************
void TAG005d8e(i16 *P1, i16 *P2, i16 *P3)
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   Storepi16(&e.pw664, P1);
   Storepi16(&e.pw656, P3);
   Storepi16(&e.pw652, P3 + 45);
   e.Word9122 = 100;
   e.Word9120 = 0;
   e.Word9116 = 11;
   e.Word9110 = *P2;
   TAG005cf6();
   *P2 = e.Word9110;
   Storepi16(&e.pw664, &e.Word9098);
   Storepi16(&e.pw656, e.Word8842);
   Storepi16(&e.pw652, e.Word8330);
   // never referenced//e.Pnt660 = e.Byte8586;
}

// *********************************************************
//
// *********************************************************
void TAG005df2(i16 P1)
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   e.Word9122 = 101;
   e.Word9120 = 0;
   e.Word9116 = 0;
   e.Word9110 = P1;
   TAG005cf6();
}

// *********************************************************
//
// *********************************************************
void TAG0061ba(i16 P1, i16 P2)
{
   //;;;;;;;;;;;;;;;;
   e.Word9098 = P2;
   e.Word9122 = 122;
   e.Word9120 = 0;
   e.Word9116 = 1;
   e.Word9110 = P1;
   TAG005cf6();
}

// *********************************************************
//
// *********************************************************
void TAG0061e2(i16 P1)
{
   //;;;;;;;;;;;;;;;;;;;
   e.Word9122 = 123;
   e.Word9120 = 0;
   e.Word9116 = 0;
   e.Word9110 = P1;
   TAG005cf6();
}

// *********************************************************
//
// *********************************************************
void TAG006202(i16 P1, i16 *P2, i16 *P3, i16 *P4)
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   e.Word9122 = 124;
   e.Word9120 = 0;
   e.Word9116 = 0;
   e.Word9110 = P1;
   TAG005cf6();
   *P2 = e.Word8842[0];
   *P3 = e.Word8330[0];
   *P4 = e.Word8328[0];
}

// *********************************************************
//
// *********************************************************
void TAG00623a(i16 P1, char *P2, char **P3)
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   TAG005c92(P2);
   e.Word9122 = 125;
   e.Word9120 = 0;
   e.Word9116 = 0;
   e.Word9110 = P1;
   TAG005cf6();
   TAG005cd6(P3);
}

// *********************************************************
//
// *********************************************************
void TAG00626e(i16 P1, char *P2, char **P3)
{
   //;;;;;;;;;;;;;;;;;;
   TAG005c92(P2);
   e.Word9122 = 126;
   e.Word9120 = 0;
   e.Word9116 = 0;
   e.Word9110 = P1;
   TAG005cf6();
   TAG005cd6(P3);
}

// *********************************************************
//
// *********************************************************
//  TAG0064b4
pnt FormatInteger(pnt rslt, ui32 num, i16 hex)
{
   dReg D5, D6;
   aReg A3, A4;
   static char digits[] = "0123456789ABCDEF";
   char b_12[12];
   A4 = rslt;
   D6L = 0;
   A3 = (aReg)b_12;
   D5W = (UI16)(hex ? 16 : 10);
   do
   {
      *(A3++) = digits[num % D5W];
      num /= D5W;
      D6W++;
   } while(num != 0);
   while((D6W--) != 0)
   {
      *(A4++) = *(--A3);
   }
   return A4;
}

// *********************************************************
//
// *********************************************************
//  TAG0065e0
i32 atari_sprintf(char *dst, const char *fmt, intptr_t V1, intptr_t V2, intptr_t V3)
{ // returns length of result
   dReg D5;
   aReg A2, A3, A4;
   bool fmtSpec, lSpec, uSpec, hex;
   pnt pnt_8;
   intptr_t stack[] = {V1, V2, V3};
   intptr_t *pStack = stack;
   //;;;;;;;;;;;;;;;;;;
   A4 = (aReg)dst;
   pnt_8 = A4;
   A3 = (aReg)fmt;
   // pnt_4 = (pnt)&V1;
   while(*A3 != 0)
   {
      if(*A3 != '%')
      {
         *(A4++) = *(A3++);
         continue; // That was rather the easier case.
      }

      A3++;
      fmtSpec = true;
      lSpec = false;
      uSpec = false;
      while(fmtSpec)
      {
         switch(*(A3++))
         {
            case 'l':
               lSpec = true;
               break;
            case 'u':
               uSpec = true;
               break;
            case 'd':
            case 'x':
               hex = (*A3 == 'x');
               if(lSpec)
               {
                  D5L = (i32)(*pStack++); // next value
                  if((!uSpec) && (!hex))
                  {
                     if(D5L & 0x80000000)
                     {
                        *(A4++) = '-';
                        D5L = -D5L;
                     }
                  }
               }
               else
               {
                  D5L = (i32)((*pStack++) & 0xffff);
                  if((!uSpec) && (!hex))
                  {
                     if(D5W & 0x8000)
                     {
                        *(A4++) = '-';
                        D5W = sw(-D5W);
                     }
                  }
               }
               A4 = FormatInteger(A4, D5L, hex);
               fmtSpec = false;
               break;
            case 's':
               A2 = (aReg)(*pStack++);
               while(*A2 != 0)
               {
                  *(A4++) = *(A2++);
               }
               fmtSpec = false;
               break;
            default:
               *(A4++) = *A3;
               fmtSpec = false;
         }; // case
      }; // while (fmtSpec)
      //
      //
   }
   *A4 = 0;
   return A4 - pnt_8;
}

// *********************************************************
//
// *********************************************************
//  TAG006700
i32 GetPixel(pnt P1, i16 x, i16 y, i16 width)
{
   dReg D0, D1, D2, D3, D5;
   aReg A0;
   //;;;;;;;;;;;;;;;;;;
   D1W = x;
   D2W = (UI16)(D1W & 15);
   A0 = P1;
   D0L = y * width;
   D1W = (UI16)((D1W / 2) & 0xf8);
   D0W = sw(D0W + D1W);
   A0 += D0W;
   D5W = sw(15 - D2W);
   D0W = (UI16)(((LE16(wordGear(A0 + 0)) >> D5W) << 0) & 1);
   D1W = (UI16)(((LE16(wordGear(A0 + 2)) >> D5W) << 1) & 2);
   D2W = (UI16)(((LE16(wordGear(A0 + 4)) >> D5W) << 2) & 4);
   D3W = (UI16)(((LE16(wordGear(A0 + 6)) >> D5W) << 3) & 8);
   return D3W | D2W | D1W | D0W;
}

// *********************************************************
//
// *********************************************************
ui8 *TAG0073b0(ui8 *P1)
{
   dReg D0;
   aReg A0, A4;
   //;;;;;;;;;;;;;;;;;;;;;;
   A0 = (aReg)LoadPnt(P1);
   A4 = A0 - 2;
   D0L = 0;
   D0W = wordGear(A4);
   D0L += 12;
   return (ui8 *)A4 - D0L;
}

// *********************************************************
//
// *********************************************************
ui8 *TAG0073d4(pnt P1)
{
   dReg D7;
   aReg A3, A4;
   //;;;;;;;;;;;;;;;;;;;
   A4 = P1;
   for(D7L = 0, A3 = (pnt)&e.pDBank422;
       D7W < e.Word424;
       D7W++, A3 += 18)
   {
      if((ui8 *)A4 >= LoadPnt(A3))
      {
         if((ui8 *)A4 <= LoadPnt(A3) + LoadLong(A3 + 6))
            break;
      }
      //
      //
   }
   if(D7W == e.Word424)
      A3 = NULL;
   return (ui8 *)A3;
}

// *********************************************************
//
// *********************************************************
void TAG007416(char *P1, char *P2)
{
   aReg A2, A3, A4;
   //;;;;;;;;;;
   A4 = (aReg)P1;
   A2 = (aReg)LoadPnt(A4 + 4);
   A3 = (aReg)LoadPnt(A4 + 8);
   if(A2 != NULL)
   {
      StorePnt(A2 + 8, A3);
   }
   else
   {
      StorePnt((ui8 *)P2 + 10, (ui8 *)A3);
   }
   if(A3 != NULL)
      StorePnt(A3 + 4, A2);
}

// *********************************************************
//
// *********************************************************
void TAG00744c(char *P1, char *P2)
{
   dReg D7;
   aReg A2, A3, A4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;
   A4 = (aReg)P1;
   A3 = (aReg)LoadPnt((ui8 *)P2 + 10);
   A2 = NULL;
   D7L = LoadLong(A4) & 0x7fffffff;
   while(A3 != NULL)
   {
      if(D7L <= (LoadLong(A3) & 0x7fffffff))
         A2 = A3;
      A3 = (aReg)LoadPnt(A3 + 8);
      //
   }
   if(A2 != NULL)
   {
      StorePnt(A2 + 8, A4);
   }
   else
   {
      StorePnt((ui8 *)P2 + 10, (ui8 *)A4);
   }
   if(A3 != NULL)
   {
      StorePnt(A3 + 4, A4);
   }
   StorePnt(A4 + 8, A3);
   StorePnt(A4 + 4, A2);
}

void TAG0074ae(char *P1, i32 P2, char *P3)
{
   dReg D6, D7;
   aReg A3, A4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   A4 = (aReg)P1;
   D7L = P2;
   A3 = (aReg)P3;
   D6L = D7L | 0x80000000;
   StoreLong(A4, D6L);
   StoreLong(A4 + D7L - 4, D6L);
   TAG00744c((char *)A4, (char *)A3);
}

// *********************************************************
//
// *********************************************************
void TAG0074ea(pnt P1, i32 P2, pnt P3)
{
   dReg D6, D7;
   aReg A0, A3, A4;
   //;;;;;;;;;;;;;;
   A4 = P1;
   D7L = P2;
   A3 = P3;
   D6L = LoadLong(A4 - 4);
   if(D6L & 0x80000000)
   {
      D6L &= 0x7fffffff;
      A4 -= D6L;
      TAG007416((char *)A4, (char *)A3);
      D7L += D6L;
   }
   A0 = A4 + D7L;
   D6L = LoadLong(A0);
   if(D6L & 0x80000000)
   {
      D6L &= 0x7fffffff;
      TAG007416((char *)A4 + D7L, (char *)A3);
      D7L += D6L;
   }
   TAG0074ae((char *)A4, D7L, (char *)A3);
}

// *********************************************************
//
// *********************************************************
ui8 *TAG007552(i32 P1, ui8 *P2, i16 *P3)
{
   dReg D6, D7;
   aReg A2, A3, A4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   D7L = P1;
   A4 = (aReg)P2;
   D7L |= 0x80000000;
   A3 = (aReg)LoadPnt(A4 + 10);
   A2 = NULL;
   while(A3 != NULL)
   {
      D6L = LoadLong(A3);
      if(D6L < D7L)
         break;
      if(D6L - D7L <= 34)
         A2 = A3;
      A3 = (aReg)LoadPnt(A3 + 8);
      //
   }
   if(A2 == NULL)
   {
      A3 = (aReg)LoadPnt(A4 + 10);
      if(D7L > LoadLong(A3))
         return (ui8 *)A2;
      A2 = A3;
      *P3 = 0;
   }
   else
   {
      *P3 = 1;
   }
   return (ui8 *)A2;
}

// *********************************************************
//
// *********************************************************
i16 TAG007904(char *, i32)
{
   DontDoThis(0x7904);
   return 0;
}

ui8 *TAG007a1a(i16 P1)
{
   dReg D6, D7;
   aReg A2, A3, A4;
   STRUCT6 s6_12;
   //;;;;;;;;;;;;;;;;;;;;;;
   D7W = P1;
   A4 = NULL;
   D6L = 4 * D7UW + 20;
   A3 = (aReg)LoadPnt((ui8 *)&e.Pnt430);
   s6_12.word4 = 1024;
   s6_12.int0 = D6L;
   A2 = (aReg)TAG007bba(&s6_12);
   if(A2 != NULL)
   {
      A4 = (aReg)TAG007cc6(D6L, 1024, (char *)A2);
      if(A4 != NULL)
      {
         A4[4] = -1;
         A4[5] = -128;
         StoreLong(A4 + 6, 0);
         wordGear(A4 + 10) = D7W;
         wordGear(A4 + 12) = 0;
         wordGear(A4 + 14) = 0;
         ClearMemory((ui8 *)A4 + 16, D6L - 20);
         if(A3 != NULL)
         {
            while(LoadLong(A3 + 6) != 0)
            {
               A3 = (aReg)LoadPnt(A3 + 6);
            }
            StorePnt(A3 + 6, A4);
         }
         else
         {
            StorePnt((ui8 *)&e.Pnt430, A4);
         }
      }
   }
   return (ui8 *)A4;
}

// *********************************************************
//
// *********************************************************
char *TAG007ac0(pnt *P1)
{
   dReg D0, D5, D6, D7;
   aReg A2, A3;
   pnt *pA4;
   A3 = (pnt)0xbaddade; // debugging
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   pA4 = P1;
   D5L = 0;
   for(A2 = (aReg)LoadPnt((ui8 *)&e.Pnt430); A2 != NULL; A2 = (aReg)LoadPnt(A2 + 6))
   {
      if(wordGear(A2 + 12) >= wordGear(A2 + 10))
         continue;
      D6W = wordGear(A2 + 14);
      D0L = (D6UW << 2) & 0xffff;
      A3 = A2 + D0L + 16;
      for(D7W = wordGear(A2 + 10); (D7W--) != 0;)
      {
         if(wordGear(A2 + 10) == D6W)
         {
            D6L = 0;
            A3 = A2 + 16;
         }
         if(LoadPnt(A3) == NULL)
         {
            wordGear(A2 + 14) = D6W;
            wordGear(A2 + 12)++;
            D5W = 1;
            break;
         }
         D6W++;
         A3 += 4;
         //
      }
      if(D5W)
         break;
      //
      //
   }
   if(D5W == 0)
   {
      A2 = (aReg)TAG007a1a(e.Word426);
      if(A2 != NULL)
      {
         A3 = A2 + 16;
         wordGear(A2 + 12)++;
         D5W = 1;
      }
   }
   if(D5W == 0)
      A3 = NULL;
   *pA4 = A2;
   ASSERT(A3 != (pnt)0xbaddade, "A3 not initialized");
   return (char *)A3;
}

// *********************************************************
//
// *********************************************************
void TAG007b68(pnt P1)
{
   dReg D0;
   aReg A0, A3, A4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   A4 = P1;
   for(A3 = (aReg)LoadPnt((ui8 *)&e.Pnt430); A3 != NULL; A3 = (aReg)LoadPnt(A3 + 6))
   {
      if(A3 > A4)
         continue;
      D0L = 4 * (UI16)(wordGear(A3 + 10));
      A0 = A3 + D0L + 20;
      if(A4 >= A0)
         continue;
      StoreLong(A4, 0);
      wordGear(A3 + 12)--;
      D0L = A4 - A3;
      D0L -= 16;
      D0L /= 4;
      wordGear(A3 + 14) = D0W;
      break;
      //
      //
   }
}

// *********************************************************
//
// *********************************************************
char *TAG007bba(STRUCT6 *P1)
{
   dReg D0, D1, D3, D4, D5, D6, D7;
   aReg A2, A3;
   STRUCT6 *s6A4;
   //;;;;;;;;;;;;;;;;
   s6A4 = P1;
   if(s6A4->word4 & 0x01)
   {
      D7L = 1;
      A3 = (aReg)&e.pDBank422;
   }
   else
   {
      D7L = -1;
      A3 = (pnt)&e.pDBank422 + 18 * (e.Word424 - 1);
   }
   D5L = s6A4->int0;
   A2 = A3;
   for(;;)
   {
      D4L = 0;
      D3L = 0;
      for(D6L = 0; D6W < e.Word424; D6W++, A3 += 18 * D7W)
      {
         D0W = sw(wordGear(A3 + 4) & s6A4->word4);
         D1W = (UI16)(s6A4->word4 & 0x7f8);
         if(D0W != D1W)
            continue;
         D4L = 1;
         D0L = LoadLong(LoadPnt(A3 + 10)) & 0x7fffffff;
         if(D0L >= D5L)
         {
            D3L = 1;
            break;
         }
         //

      }; /// for (D6W)
      if(D4W == 0)
      {
         TAG008788(1, 0x010d0005, s6A4->word4 & 0xffff);
      }
      if(D3W == 0)
      {
         A3 = A2;
         for(D6L = 0; D6W < e.Word424; D6W++, A3 += 18 * D7W)
         {
            D0W = sw(wordGear(A3 + 4) & s6A4->word4);
            D1W = (UI16)(s6A4->word4 & 0x07f8);
            if(D0W != D1W)
               continue;
            if(TAG007904((char *)A3, D5L) == 0)
               break;
            //
            //
         }
         if(e.Word424 == 0)
         {
            D0L = TAG008788(0, 0x010d0001, s6A4->word4 & 0xffff);
            if(D0L != 0x010d0001)
            {
               A3 = A2;
               continue;
            }
         }
      }
      return (char *)A3;
   }
}

// *********************************************************
//
// *********************************************************
ui8 *TAG007cc6(i32 P1, i16 P2, char *P3)
{
   dReg D5, D6, D7;
   aReg A0, A2, A3, A4;
   i16 w_2;
   //;;;;;;;;;;;;;;;;;;;;;
   D7L = P1;
   D6W = P2;
   A4 = (aReg)P3;
   A3 = (aReg)TAG007552(D7L, (ui8 *)A4, &w_2);
   if(A3 != NULL)
   {
      TAG007416((char *)A3, (char *)A4);
      D5L = LoadLong(A3) & 0x7fffffff;
      if(w_2 != 0)
      {
         D7L = D5L;
      }
      else
      {
         D5L -= D7L;
         if(D6L & 1)
         {
            A2 = A3 + D7L;
         }
         else
         {
            A2 = A3;
            A3 += D5L;
         }
         TAG0074ae((char *)A2, D5L, (char *)A4);
      }
      StoreLong(A4 + 14, LoadLong(A4 + 14) - D7L);
      StoreLong(A3, D7L);
      A0 = A3 + D7L;
      StoreLong(A0 - 4, D7L);
   }
   return (ui8 *)A3;
}

// *********************************************************
//
// *********************************************************
ui8 *TAG007d4c(STRUCT12 *P1)
{
   dReg D0, D7;
   aReg A0, A2, A3;
   STRUCT12 *s12A4;
   pnt pnt_8;
   char *pnt_4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   s12A4 = P1;
   D0L = s12A4->word6 & 0xffff;
   D7L = D0L + s12A4->long0 + 18;
   if(D7L & 1)
      D7L++;
   s12A4->long0 = D7L;
   A2 = (aReg)TAG007ac0(&pnt_8);
   if(A2 == NULL)
      return NULL;
   pnt_4 = TAG007bba((STRUCT6 *)s12A4);

   if((pnt_4 != NULL) && ((A3 = (aReg)TAG007cc6(D7L, s12A4->word4, pnt_4)) != NULL))
   {
      StorePnt(A2, A3 + (s12A4->word6 & 0xffff) + 14);
      A3[4] = 0;
      A3[5] = (UI8)(s12A4->word4 & 7);
      wordGear(A3 + 10) = s12A4->word4;
      StorePnt(A3 + 6, A2);
      A3 += 12;

      if((s12A4->fnc8 != NULL) && (s12A4->word6 != 0))
      {
         (*s12A4->fnc8)(A3);
      }
      A0 = A3 + (s12A4->word6 & 0xffff);
      wordGear(A0) = s12A4->word6;
      return (ui8 *)A2;
   }
   else
   {
      wordGear(pnt_8 + 12)--;
      return NULL;
   }
}

// *********************************************************
//
// *********************************************************
void TAG007e16(ui8 *P1, ui8 *P2)
{
   dReg D7;
   aReg A3, A4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   A4 = (aReg)P1;
   A3 = (aReg)P2;
   D7L = LoadLong(A4);
   StoreLong(A3 + 14, LoadLong(A3 + 14) + D7L);
   TAG0074ea(A4, D7L, A3);
}

// *********************************************************
//
// *********************************************************
i32 TAG007e42(i16 P1, i16 P2)
{
   dReg D5, D7;
   aReg A0, A3, A4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   // D7L = MALLOC(-1);
   D7L = 240000;
   if(D7L < 120000)
   {
      DontDoThis(0x7e62);
   }
   D7L = (D7L & -2) - 4000;
   A4 = (aReg)MALLOC(D7L);
   if(A4 == NULL)
   {
      DontDoThis(0x7e96);
   }
   StorePnt((ui8 *)&e.pAllocDBank434, (ui8 *)A4);
   D7L &= -2;
   e.Word424 = 1;
   StorePnt((ui8 *)&e.pDBank422, (ui8 *)A4);
   StoreLong((pnt)&e.DBankLen416, D7L);
   e.Word418 = 2040;
   for(D5L = 0, A3 = (pnt)&e.pDBank422;
       D5W < e.Word424;
       A3 += 18, D5W++)
   {
      A4 = (aReg)LoadPnt(A3);
      StoreLong(A4, 0);
      A0 = A4 + LoadLong(A3 + 6);
      StoreLong(A0 - 4, 0);
      A4 += 4;
      StorePnt(A3, A4);
      StoreLong(A3 + 6, LoadLong(A3 + 6) - 8);
      StoreLong(A3 + 14, LoadLong(A3 + 6));
      StoreLong(A3 + 10, 0);
      TAG0074ae((char *)A4, LoadLong(A3 + 14), (char *)A3);
      //
      //
   };
   e.Word426 = P2;
   StorePnt((ui8 *)&e.Pnt430, (ui8 *)NULL);
   if(TAG007a1a(P1) == NULL)
   {
      DontDoThis(0x7f34);
   }
   return 0;
}

// *********************************************************
//
// *********************************************************
void TAG007f54()
{
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   MFREE(LoadPnt((ui8 *)&e.pAllocDBank434));
}

// *********************************************************
//
// *********************************************************
ui8 *TAG007f64(i32 P1, i16 P2)
{
   STRUCT12 s_12;
   //;;;;;;;;;;;;;;;;;;;;;;
   s_12.long0 = P1;
   s_12.word4 = P2;
   s_12.word6 = 0;
   s_12.fnc8 = NULL;
   return TAG007d4c(&s_12);
}

// *********************************************************
//
// *********************************************************
i32 TAG007f92(ui8 *P1)
{
   dReg D7;
   aReg A3, A4;
   //;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   A4 = (aReg)P1;
   D7L = TAG0080e0((ui8 *)A4);
   if(D7L == 0)
   {
      A3 = (aReg)TAG0073b0((ui8 *)A4);
      TAG007e16((ui8 *)A3, TAG0073d4(A3));
   }
   if((D7L == 0) || (D7L == 0x010d0003))
   {
      TAG007b68(A4);
      D7L = 0;
   }
   return D7L;
}

// *********************************************************
//
// *********************************************************
ui8 *TAG007fe8(ui8 *P1)
{
   dReg D7;
   aReg A2, A3, A4;
   //;;;;;;;;;;;;;;
   A4 = (aReg)P1;
   A2 = NULL;
   D7L = TAG0080e0((ui8 *)A4);
   if(D7L == 0)
   {
      A3 = (aReg)TAG0073b0((ui8 *)A4);
      A3[4]++;
      A2 = (aReg)LoadPnt(A4);
   }
   return (ui8 *)A2;
}

// *********************************************************
//
// *********************************************************
void TAG00801e(ui8 *P1)
{
   TAG0073b0(P1)[4]--;
}

// *********************************************************
//
// *********************************************************
i32 TAG0080e0(ui8 *P1)
{
   dReg D7;
   aReg A3, A4;
   D7L = 0xbaddade; // debugging
   //;;;;;;;;
   A4 = (aReg)P1;
   if((A4 == NULL) || (LoadLong(A4) == 0))
   {
      TAG008788(1, 0x010d0002, (ui32)A4);
   }
   else
   {
      if(LoadLong(A4) == -1)
      {
         D7L = 0x010d0003;
      }
      else
      {
         A3 = (aReg)TAG0073b0((ui8 *)A4);
         if(TAG0073d4(A3) == NULL)
         {
            D7L = 0x010d0002;
         }
         else
         {
            D7L = 0;
         }
      }
   }
   ASSERT(D7L != 0xbaddade, "D7 not initialized");
   return D7L;
}

// *********************************************************
//
// *********************************************************
//   TAG00858c
void MemoryMove(ui8 *src,
                ui8 *dst,
                i16, // garbage
                i16, // garbage
                i32 len)
{
   MemMove(src, dst, len);
}

// *********************************************************
//
// *********************************************************
i32 TAG008788(i16, i32, ui32)
{
   DontDoThis(0x8788);
   return 0;
   //;;;;;;;;;;;;;

   // file = chaos.ftl      offset =a1bc

   // file = chaos.ftl      offset =a1dc
}

void EditCharacterName(char key)
{
   char *name;
   i32 len;
   i32 max_len;
   i32 position;

   name = (char *)LoadPnt((ui8 *)&e.Pnt24812) + 800 * e.ActualCharacter + 772;
   if(e.EditBoxSelected == 1) // TITLE
   {
      name += 8;
      max_len = 18;
   }
   else
      max_len = 7;
   len = strlen(name);

   // first check for backspace key
   if(key == 8)
   {
      if(e.EditBoxPosition == 0)
         return;
      if(e.EditBoxPosition == len) // deleting from the end
      {
         name[--len] = 0;
      }
      else // deleting from the middle
      {    // insert in the middle
         i32 i;
         for(i = e.EditBoxPosition; i < max_len; i++)
            name[i - 1] = name[i];
         name[len] = 0;
      }
      position = e.EditBoxPosition - 1;
   }
   else
   {
      if(len == max_len) // maximum name lenght
         return;

      if(key != 32)
         key &= ~32;                                  // uppercase
      if((key != 32) && ((key < 'A') || (key > 'Z'))) // bad key pressed
         return;

      if(e.EditBoxPosition == len) // appending to the end
         name[len++] = key;
      else
      { // insert in the middle
         i32 i;
         for(i = max_len; i >= e.EditBoxPosition; i--)
            name[i + 1] = name[i];
         name[e.EditBoxPosition] = key;
      }
      position = e.EditBoxPosition + 1;
   }

   if(e.EditBoxSelected == 0)
      FillCharacterNameEditBox(name, 13, 7);
   else
      FillCharacterNameEditBox(name, 14, 19);

   DrawNameTitleCarret(e.EditBoxSelected, (i16)position);
}