Free Hero Mesh

AnimationSlot anim_slot[8];
Uint8 keymask[256/8];
Uint16 array_size;
Uint16*orders;
Uint8 norders;
Uint16 control_class;

char*ll_head;
DisplayColumn*ll_disp;
Uint8 ll_ndisp;
DataColumn*ll_data;
Uint8 ll_ndata;
Uint8 ll_naggregate;
Uint16*ll_code;

#define HASH_SIZE 8888
#define LOCAL_HASH_SIZE 5555
typedef struct {
  Uint16 id;
  char*txt;
} Hash;

        case OP_CONTROL: if(i==control_class) goto found; break;
      }
      continue;
      found: classes[i]->order=j; break;
    }
  }
}

static int level_table_code(int ptr,Hash*hash) {
  int flowdepth=0;
  Uint16 flowptr[64];
  int x;
  for(;;) {
    if(ptr>=0xFFFA) ParseError("Out of memory\n");
    nxttok();
    if(Tokenf(TF_MACRO)) ParseError("Unexpected macro\n");
    if(tokent==TF_CLOSE) {
      ll_code[ptr++]=OP_RET;
      return ptr;
    } else if(Tokenf(TF_NAME)) {
      switch(tokenv) {
        case OP_IF:
          if(flowdepth==64) ParseError("Too much flow control nesting\n");
          ll_code[ptr++]=OP_IF;
          flowptr[flowdepth++]=ptr++;
          break;
        case OP_ELSE:
          if(!flowdepth) ParseError("Flow control mismatch\n");
          ll_code[flowptr[flowdepth-1]]=ptr+2;
          ll_code[ptr++]=OP_GOTO;
          flowptr[flowdepth-1]=ptr++;
          break;
        case OP_THEN:
          if(!flowdepth) ParseError("Flow control mismatch\n");
          ll_code[flowptr[--flowdepth]]=ptr;
          break;
        case OP_STRING:
          ll_code[ptr++]=OP_STRING;
          ll_code[ptr++]=pool_string(tokenstr);
          break;
        case OP_LOCAL:
          x=look_hash(hash,LOCAL_HASH_SIZE,0x200,0x23F,ll_naggregate+0x200,"aggregates")?:(ll_naggregate++)+0x200;
          ll_code[ptr++]=OP_LOCAL;
          ll_code[ptr++]=x-0x200;
          break;
        case OP_USERFLAG:
          if(Tokenf(TF_COMMA|TF_EQUAL)) ParseError("Invalid instruction token\n");
          x=look_hash(glohash,HASH_SIZE,0x1000,0x10FF,0,"user flags");
          if(!x) ParseError("User flag ^%s not defined\n",tokenstr);
          ll_code[ptr++]=OP_USERFLAG;
          ll_code[ptr++]=x;
          break;
        default:
          if(Tokenf(TF_ABNORMAL)) ParseError("Invalid instruction token\n");
          ll_code[ptr++]=tokenv;
      }
    } else {
      ParseError("Invalid instruction token\n");
    }
  }
}

static void level_table_definition(void) {
  sqlite3_str*str=sqlite3_str_new(0);
  unsigned char buf[0x2000];
  Hash*hash=calloc(LOCAL_HASH_SIZE,sizeof(Hash));
  DataColumn*datac=calloc(0x41,sizeof(DataColumn));
  DataColumn*aggrc=calloc(0x41,sizeof(DataColumn));
  DisplayColumn*dispc=calloc(0x41,sizeof(DisplayColumn));
  int ptr=0;
  int last=0;
  int i;
  if(ll_naggregate || ll_ndata || ll_ndisp || ll_head || ll_code) ParseError("LevelTable block is already defined\n");
  ll_code=malloc(0x10000*sizeof(Uint16));
  if(!hash || !ll_code || !datac || !aggrc || !dispc) fatal("Allocation failed\n");
  sqlite3_str_appendchar(str,1,0xB3);
  for(;;) {
    nxttok();
    if(tokent==TF_EOF) ParseError("Unexpected end of file\n");
    if(tokent==TF_CLOSE) break;
    if(tokent!=TF_OPEN) ParseError("Expected ( or )\n");
    nxttok();
    if(!Tokenf(TF_NAME)) ParseError("Unexpected token in (LevelTable) block\n");
    switch(tokenv) {
      case OP_LABEL:
        i=look_hash(hash,LOCAL_HASH_SIZE,0x100,0x13F,ll_ndata+0x100,"data columns")?:(ll_ndata++)+0x100;
        i-=0x100;
        if(datac[i].name) ParseError("Duplicate definition\n");
        datac[i].name=strdup(tokenstr);
        if(datac[i].name) fatal("Allocation failed\n");
        datac[i].ptr=ptr;
        ptr=level_table_code(ptr,hash);
        break;
      case OP_STRING:
        if(last) ParseError("Extra columns after fill column\n");
        for(i=0;tokenstr[i];i++) if(!(tokenstr[i]&~31)) ParseError("Improper column heading\n");
        strcpy(buf,tokenstr);
        // Data
        nxttok();
        if(Tokenf(TF_NAME) && tokenv==OP_LABEL) {
          i=look_hash(hash,LOCAL_HASH_SIZE,0x100,0x13F,ll_ndata+0x100,"display columns")?:(ll_ndata++)+0x100;
          dispc[ll_ndisp].data=i-0x100;
        } else {
          ParseError("Syntax error\n");
        }
        // Width
        nxttok();
        if(tokent==TF_INT && tokenv>0 && tokenv<=255) {
          dispc[ll_ndisp].width=tokenv;
        } else if(Tokenf(TF_NAME) && tokenv==OP_MUL) {
          dispc[ll_ndisp].width=255;
          dispc[ll_ndisp].flag|=1;
        } else {
          ParseError("Syntax error\n");
        }
        // Format
        nxttok();
        if(!Tokenf(TF_NAME) || tokenv!=OP_STRING || !*tokenstr) ParseError("Syntax error\n");
        if(*tokenstr<32 || *tokenstr>126) ParseError("Syntax error\n");
        if(tokenstr[1]>0 && tokenstr[1]<31) ParseError("Syntax error\n");
        if(tokenstr[1]==31) tokenstr[1]=tokenstr[2],tokenstr[2]=tokenstr[3];
        if(tokenstr[1] && tokenstr[2]) ParseError("Syntax error\n");
        memcpy(dispc[ll_ndisp].form,tokenstr,2);
        // Colour
        nxttok();
        if(tokent==TF_INT) {
          if(tokenv&~255) ParseError("Color out of range\n");
          dispc[ll_ndisp].color=tokenv;
          nxttok();
          if(tokent!=TF_CLOSE) ParseError("Syntax error\n");
        } else if(tokent==TF_OPEN) {
          dispc[ll_ndisp].flag|=2;
          dispc[ll_ndisp].ptr=ptr;
          for(;;) {
            if(++dispc[ll_ndisp].color==255) ParseError("Too many colors\n");
            nxttok();
            if(tokent!=TF_INT) ParseError("Number expected\n");
            i=tokenv;
            if(i<-127 || i>127) ParseError("Number out of range\n");
            nxttok();
            if(tokent!=TF_INT) ParseError("Number expected\n");
            if(ptr>=0xFFFE) ParseError("Out of memory\n");
            if(tokenv&~255) ParseError("Color out of range\n");
            ll_code[ptr++]=tokenv|((i+128)<<8);
            nxttok();
            if(tokent!=TF_CLOSE) ParseError("Close parenthesis expected\n");
            nxttok();
            if(tokent==TF_CLOSE) break;
            if(tokent!=TF_OPEN) ParseError("Syntax error\n");
          };
        } else if(tokent==TF_CLOSE) {
          dispc[ll_ndisp].color=0xFF;
        }
        // End
        if(dispc[ll_ndisp].flag&1) {
          last=1;
          sqlite3_str_appendall(str,buf);
        } else {
          i=dispc[ll_ndisp].width;
          sqlite3_str_appendf(str,"%-*.*s\xB3",i,i,buf);
        }
        ll_ndisp++;
        break;
      case OP_LOCAL:
        i=look_hash(hash,LOCAL_HASH_SIZE,0x200,0x23F,ll_naggregate+0x200,"aggregates")?:(ll_naggregate++)+0x200;
        i-=0x200;
        if(aggrc[i].ag) ParseError("Duplicate definition\n");
        nxttok();
        if(!Tokenf(TF_NAME)) ParseError("Improper aggregate\n");
        switch(tokenv) {
          case OP_ADD: aggrc[i].ag=1; break;
          case OP_MIN: aggrc[i].ag=2; break;
          case OP_MAX: aggrc[i].ag=3; break;
          case OP_MIN_C: aggrc[i].ag=4; break;
          case OP_MAX_C: aggrc[i].ag=5; break;
          default: ParseError("Improper aggregate\n");
        }
        aggrc[i].ptr=ptr;
        ptr=level_table_code(ptr,hash);
        break;
      default: ParseError("Unexpected token in (LevelTable) block\n");
    }
  }
  ll_head=sqlite3_str_finish(str);
  if(!ll_head) fatal("Allocation failed\n");
  for(i=0;i<ll_ndata;i++) if(!datac[i].name) ParseError("Undefined data column\n");
  for(i=0;i<ll_naggregate;i++) if(!aggrc[i].ag) ParseError("Undefined aggregate\n");
  ll_data=realloc(datac,(ll_ndata+ll_naggregate)*sizeof(DataColumn));
  if(!ll_data) fatal("Allocation failed\n");
  for(i=0;i<ll_naggregate;i++) ll_data[i+ll_ndata]=aggrc[i];
  free(aggrc);
  // The next line will result in an invalid pointer if ptr is zero,
  // but this is harmless, since ll_code is never accessed if ptr is zero.
  ll_code=realloc(ll_code,ptr*sizeof(Uint16))?:ll_code;
  for(i=0;i<LOCAL_HASH_SIZE;i++) free(hash[i].txt);
  free(hash);
}

void load_classes(void) {
  int i;
  int gloptr=0;
  Hash*glolocalhash;
  char*nam=sqlite3_mprintf("%s.class",basefilename);
  sqlite3_stmt*vst=0;

        case OP_CONTROL:
          if(control_class) ParseError("Extra (Control) block\n");
          strcpy(tokenstr,"(Control)");
          control_class=look_class_name();
          if(!(classes[control_class]->cflags&CF_NOCLASS1)) ParseError("Conflicting definition of (Control) class\n");
          class_definition(control_class,vst);
          break;
        case OP_LEVELTABLE:
          level_table_definition();
          break;
        default:
          ParseError("Invalid top level definition: %s\n",tokenstr);
      }
    } else {
      ParseError("Invalid top level definition\n");
    }
  }

  created, destroyed, or moved. It still receives broadcast messages
  normally, and can also be addressed specifically.

(CollisionLayers <userflags...>)
  Define user flags as CollisionLayers bits; the first defined flag is
  bit0. Up to 8 flags can be defined in this way.

(LevelTable <definitions...>)
  Define the level table. See the section about level table definition
  for details. Can only occur once.

(Misc4 <userflags...>)
  Define user flags as Misc4 bits; the first defined flag is bit0. Up to
  32 flags can be defined in this way.

(Misc5 <userflags...>)
  Define user flags as Misc5 bits; the first defined flag is bit0. Up to
  32 flags can be defined in this way.

* The way that the trigger phase works is different.

* In the ARRIVED and DEPARTED messages, Arg1 is always zero.

* Diagonal shoving is not possible.


=== Level table definition ===

The following blocks are allowed in a level table definition:

(<label> <code...>)
  Define a data column. The SQL name of the data column will be that of
  the label name, preceded by a underscore, and some characters will be
  stripped out.

(<string> <label> <width> <format> <color>)
  Defines a display column. The <label> is the name of the data column.
  The <width> is a number 1 to 255 or it can be * for fill width. The
  <format> is a string of one or two characters; see the below list of
  possible formats. The <color> is the text colour, and is optional; it
  can be a number from 1 to 255, or it can be a sequence of parenthesized
  pairs of a number (-127 to +127) and colour, to mean use those colour if
  the value of this column is in range. It uses the colour for all values
  up to and including the specified number, so the numbers should be listed
  in ascending order, in order to work. The <string> is the heading; it is
  not allowed to include control characters, nor can it include graphic
  characters with code number less than 32.

(<local> <type> <code...>)
  Defines a aggregate calculation. The <local> is the name of the aggregate
  to be referred by other blocks. The <type> is the type of aggregate,
  which can be one of: + for the sum, min for the least value (unsigned),
  max for the greatest value (unsigned), ,min for the least value (signed),
  and ,max for the greatest value (signed).

(TODO: Mention valid instructions.)

void set_cursor(int id);
const char*log_if_error(const char*t);

#define FIL_SOLUTION 1
#define FIL_LEVEL 0
#define LUMP_LEVEL_IDX (-1)
#define LUMP_CLASS_DEF (-2)
#define LUMP_DIVISION_IDX (-3)

#define read_lump(a,b,c) read_lump_or_userstate(a,b,c,0)
#define read_userstate(a,b,c) read_lump_or_userstate(a,b,c,1)

// == picture ==

extern SDL_Surface*screen;

extern AnimationSlot anim_slot[8];
extern Uint8 keymask[256/8];
extern Uint16 array_size;
extern Uint16*orders;
extern Uint8 norders;
extern Uint16 control_class;

typedef struct {
  // Flags: 1=fill-width, 2=multi-colours, 4=built-in-data
  Uint8 width,data,color,flag;
  Uint8 form[2];
  Uint16 ptr;
} DisplayColumn;

typedef struct {
  union {
    char*name; // free when loading table
    Uint8 ag; // aggregate type
  };
  Uint16 ptr;
} DataColumn;

extern char*ll_head;
extern DisplayColumn*ll_disp;
extern Uint8 ll_ndisp;
extern DataColumn*ll_data;
extern Uint8 ll_ndata;
extern Uint8 ll_naggregate; // Aggregates will be listed in ll_data after the data columns
extern Uint16*ll_code;

Uint16 get_message_ptr(int c,int m);
void load_classes(void);

// == bindings ==

typedef struct {
  char cmd;

=Finished

; Top level definitions
-Background
-CodePage
-Order
Control
-LevelTable

; Class definitions
-Input
-Quiz
-InPlace
-DefaultImage
-Help

#define OP_KEY 32897
#define OP_FINISHED 32898
#define OP_FINISHED_E 36994
#define OP_BACKGROUND 32899
#define OP_CODEPAGE 32900
#define OP_ORDER 32901
#define OP_CONTROL 32902
#define OP_LEVELTABLE 32903
#define OP_INPUT 32904
#define OP_QUIZ 32905
#define OP_INPLACE 32906
#define OP_DEFAULTIMAGE 32907
#define OP_HELP 32908
#define OP_EDITORHELP 32909
#define OP_OTHERS 32910
#define OP_SUBS 32911
#define OP_ANIMATE 32912
#define OP_ANIMATE_E 37008
#define OP_ANIMATEDEAD 32913
#define OP_ANIMATEDEAD_E 37009
#define OP_ASSASSINATE 32914
#define OP_ASSASSINATE_C 34962
#define OP_BROADCAST 32915
#define OP_BROADCAST_D 41107
#define OP_BROADCASTAND 32916
#define OP_BROADCASTANDEX 32917
#define OP_BROADCASTCLASS 32918
#define OP_BROADCASTEX 32919
#define OP_BROADCASTEX_D 41111
#define OP_BROADCASTLIST 32920
#define OP_BROADCASTLISTEX 32921
#define OP_BROADCASTSUM 32922
#define OP_BROADCASTSUMEX 32923
#define OP_CHAIN 32924
#define OP_CHEBYSHEV 32925
#define OP_CHEBYSHEV_C 34973
#define OP_COLOC 32926
#define OP_COLOC_C 34974
#define OP_CREATE 32927
#define OP_CREATE_D 41119
#define OP_DATA 32928
#define OP_DELINVENTORY 32929
#define OP_DELTA 32930
#define OP_DESTROY 32931
#define OP_DESTROY_C 34979
#define OP_DESTROY_D 41123
#define OP_DESTROY_CD 43171
#define OP_FLUSHCLASS 32932
#define OP_FLUSHOBJ 32933
#define OP_FLUSHOBJ_C 34981
#define OP_GETINVENTORY 32934
#define OP_HEIGHTAT 32935
#define OP_HITME 32936
#define OP_IGNOREKEY 32937
#define OP_INTMOVE 32938
#define OP_INTMOVE_C 34986
#define OP_INTMOVE_D 41130
#define OP_INTMOVE_CD 43178
#define OP_JUMPTO 32939
#define OP_JUMPTO_C 34987
#define OP_JUMPTO_D 41131
#define OP_JUMPTO_CD 43179
#define OP_LOC 32940
#define OP_LOC_C 34988
#define OP_LOCATEME 32941
#define OP_LOCATEME_C 34989
#define OP_LOSELEVEL 32942
#define OP_MANHATTAN 32943
#define OP_MANHATTAN_C 34991
#define OP_MAXINVENTORY 32944
#define OP_MOVE 32945
#define OP_MOVE_C 34993
#define OP_MOVE_D 41137
#define OP_MOVE_CD 43185
#define OP_MOVEPLUS 32946
#define OP_MOVEPLUS_C 34994
#define OP_MOVEPLUS_D 41138
#define OP_MOVEPLUS_CD 43186
#define OP_MOVETO 32947
#define OP_MOVETO_C 34995
#define OP_MOVETO_D 41139
#define OP_MOVETO_CD 43187
#define OP_PLUSMOVE 32948
#define OP_PLUSMOVE_C 34996
#define OP_PLUSMOVE_D 41140
#define OP_PLUSMOVE_CD 43188
#define OP_MINUSMOVE 32949
#define OP_MINUSMOVE_C 34997
#define OP_MINUSMOVE_D 41141
#define OP_MINUSMOVE_CD 43189
#define OP_NEWX 32950
#define OP_NEWXY 32951
#define OP_NEWY 32952
#define OP_OBJABOVE 32953
#define OP_OBJABOVE_C 35001
#define OP_OBJBELOW 32954
#define OP_OBJBELOW_C 35002
#define OP_OBJBOTTOMAT 32955
#define OP_OBJCLASSAT 32956
#define OP_OBJDIR 32957
#define OP_OBJDIR_C 35005
#define OP_OBJLAYERAT 32958
#define OP_OBJMOVINGTO 32959
#define OP_OBJTOPAT 32960
#define OP_POPUP 32961
#define OP_POPUPARGS 32962
#define OP_REL 32963
#define OP_REL_C 35011
#define OP_SEEK 32964
#define OP_SEEK_C 35012
#define OP_SEND 32965
#define OP_SEND_C 35013
#define OP_SEND_D 41157
#define OP_SEND_CD 43205
#define OP_SENDEX 32966
#define OP_SENDEX_C 35014
#define OP_SENDEX_D 41158
#define OP_SENDEX_CD 43206
#define OP_SETINVENTORY 32967
#define OP_SOUND 32968
#define OP_SWEEP 32969
#define OP_SWEEPEX 32970
#define OP_SYNCHRONIZE 32971
#define OP_TARGET 32972
#define OP_TARGET_C 35020
#define OP_TRACE 32973
#define OP_TRIGGER 32974
#define OP_TRIGGERAT 32975
#define OP_VOLUMEAT 32976
#define OP_WINLEVEL 32977
#define OP_XDIR 32978
#define OP_XDIR_C 35026
#define OP_XYDIR 32979
#define OP_YDIR 32980
#define OP_YDIR_C 35028
#define OP_MARK 32981
#define OP_TMARK 32982
#define OP_IN 32983
#define OP_NIN 32984
#define OP_MBEGIN 32985
#define OP_FLIP 32986
#define OP_COUNT 32987
#define OP_CLEAR 32988
#define OP_UNIQ 32989
#define OP_ARRAY 32990
#define OP_GETARRAY 32991
#define OP_INITARRAY 32992
#define OP_SETARRAY 32993
#define OP_ARRAYCELL 32994
#define OP_ARRAYSLICE 32995
#define OP_COPYARRAY 32996
#define OP_DOTPRODUCT 32997
#define OP_PATTERN 32998
#define OP_PATTERN_C 35046
#define OP_PATTERN_E 37094
#define OP_PATTERN_EC 39142
#define OP_PATTERNS 32999
#define OP_PATTERNS_C 35047
#define OP_PATTERNS_E 37095
#define OP_PATTERNS_EC 39143
#define OP_ROOK 33000
#define OP_BISHOP 33001
#define OP_QUEEN 33002
#define OP_CUT 33003
#define OP_BIZARRO 33004
#define OP_BIZARRO_C 35052
#define OP_BIZARRO_E 37100
#define OP_BIZARRO_EC 39148
#define OP_BIZARROSWAP 33005
#define OP_BIZARROSWAP_D 41197
#define OP_SWAPWORLD 33006
#define OP_ABSTRACT 33007
#define OP_SUPER 33008
#define OP_SUPER_C 35056
#define OP_FUNCTION 33009
#define OP_LOCAL 33010
#define OP_LABEL 33011
#define OP_STRING 33012
#define OP_INT16 33013
#define OP_INT32 33014
#define OP_DISPATCH 33015
#define OP_USERFLAG 33016
#ifdef HEROMESH_CLASS
static const Op_Names op_names[]={
{"*",8486940},
{"+",8421402},
{"+Move",10584244},
{"-",8421403},
{"-Move",10584245},
{"-rot",8421382},
{".",10518528},
{"/",8486941},
{"ANHH",8389394},
{"ARRIVED",8389124},
{"Abstract",8683759},
{"Animate",8552592},
{"AnimateDead",8552593},
{"Arg1",8552572},
{"Arg2",8552573},
{"Arg3",8552574},
{"Array",8683742},
{"ArrayCell",8421602},
{"ArraySlice",8421603},
{"Arrivals",8618089},
{"Arrived",8618087},
{"Assassinate",8487058},
{"B",9437196},
{"BANG",8389380},
{"BEDOINGNG",8389406},
{"BEEDEEP",8389404},
{"BEGIN_TURN",8389123},
{"BLOCKED",8389144},
{"BOOOM",8389410},
{"BOUNCE",8389415},
{"BRRREEET",8389396},
{"BRRRT",8389395},
{"BUZZER",8389420},
{"BWEEP",8389397},
{"Background",8683651},
{"Bishop",8683753},
{"Bizarro",8618220},
{"BizarroSwap",10518765},
{"Broadcast",10518675},
{"BroadcastAnd",8421524},
{"BroadcastAndEx",8421525},
{"BroadcastEx",10518679},
{"BroadcastList",8421528},
{"BroadcastListEx",8421529},
{"BroadcastSum",8421530},
{"BroadcastSumEx",8421531},
{"Busy",8618091},
{"CHEEP",8389393},
{"CHYEW",8389392},
{"CLICK",8389388},
{"COLLIDE",8389142},
{"COLLIDEBY",8389141},
{"COLLIDING",8389143},
{"CONFLICT",8389140},
{"CREATE",8389121},
{"CREATED",8389137},
{"Chebyshev",8487069},
{"Class",8486973},
{"Climb",9142353},
{"CodePage",8683652},
{"CollisionLayers",8487032},
{"Coloc",8487070},
{"Compatible",8487031},
{"Control",8421510},
{"CopyArray",8421604},
{"Create",10518687},
{"DEEP_POP",8389417},
{"DEPARTED",8389125},
{"DESTROY",8389122},
{"DESTROYED",8389136},
{"DINK",8389390},
{"DOOR",8389378},
{"DRLRLRINK",8389398},
{"DYUPE",8389413},
{"Data",8421536},
{"DefaultImage",8683659},
{"DelInventory",8421537},
{"Delta",8421538},
{"Density",9142345},
{"Departed",8618088},
{"Departures",8618090},
{"Destroy",10584227},
{"Destroyed",8487029},
{"Dir",8618051},
{"Distance",9142343},
{"Done",8618100},
{"DotProduct",8421605},
{"E",9437184},
{"END_TURN",8389139},
{"EditorHelp",8683661},
{"F",9437192},
{"FAROUT",8389421},
{"FFFFTT",8389399},
{"FLOATED",8389132},
{"FROG",8389383},
{"Finished",8552578},
{"FlushClass",8421540},
{"FlushObj",8487077},
{"From",8421499},
{"GLASS",8389379},
{"GLISSANT",8389419},
{"GetArray",8421599},
{"GetInventory",8421542},
{"HAWK",8389425},
{"HEARTBEAT",8389407},
{"HIT",8389134},
{"HITBY",8389135},
{"Hard",8618069},
{"Height",9142351},
{"HeightAt",8421543},
{"Help",8683660},
{"HitMe",8421544},
{"INIT",8389120},
{"IgnoreKey",8421545},
{"Image",8618052},
{"InPlace",8683658},
{"Inertia",9142341},
{"InitArray",8421600},
{"Input",8683656},
{"IntMove",10584234},
{"Invisible",8618092},
{"JAYAYAYNG",8389416},
{"JUMPED",8389128},
{"JumpTo",10584235},
{"KEWEL",8389422},
{"KEY",8389129},
{"KLECK",8389387},
{"KLINKK",8389385},
{"Key",8421505},
{"KeyCleared",8618093},
{"L",9437194},
{"LASTIMAGE",8389126},
{"LB",9437195},
{"LF",9437193},
{"LOCK",8389408},
{"LOOP",8388610},
{"Level",8421504},
{"LevelTable",8683655},
{"Loc",8487084},
{"LocateMe",8487085},
{"LoseLevel",8421550},
{"MOVED",8389127},
{"MOVING",8389130},
{"Manhattan",8487087},
{"MaxInventory",8421552},
{"Misc1",9142361},
{"Misc2",9142363},
{"Misc3",9142365},
{"Misc4",9142367},
{"Misc5",9142369},
{"Misc6",9142371},
{"Misc7",9142373},
{"Move",10584241},
{"Move+",10584242},
{"MoveNumber",8552575},
{"MoveTo",10584243},
{"Moved",8618098},
{"Moving",8618099},
{"Msg",8421498},
{"N",9437186},
{"NE",9437185},
{"NW",9437187},
{"NewX",8421558},
{"NewXY",8421559},
{"NewY",8421560},
{"OLDPHONE",8389402},
{"ONCE",8388609},
{"OSC",8388616},
{"OSCLOOP",8388618},
{"ObjAbove",8487097},
{"ObjBelow",8487098},
{"ObjBottomAt",8421563},
{"ObjClassAt",8421564},
{"ObjDir",8487101},
{"ObjLayerAt",8421566},
{"ObjMovingTo",8421567},
{"ObjTopAt",8421568},
{"Order",8683653},
{"Others",8683662},
{"P",8880358},
{"P*",8880359},
{"PLAYERMOVING",8389133},
{"POSTINIT",8389138},
{"POUR",8389377},
{"POWER",8389386},
{"Player",8487030},
{"PopUp",8421569},
{"Queen",8683754},
{"Quiz",8683657},
{"R",9437198},
{"RATCHET1",8389418},
{"RATCHET2",8389412},
{"RATTLE",8389403},
{"RB",9437197},
{"RF",9437199},
{"Rel",8487107},
{"Rook",8683752},
{"S",9437190},
{"SE",9437191},
{"SMALL_POP",8389389},
{"SPLASH",8389376},
{"STEAM",8389424},
{"STOP",8388608},
{"SUBS",8683663},
{"SUNK",8389131},
{"SW",9437189},
{"Seek",8487108},
{"Self",8421497},
{"Send",10584261},
{"SendEx",10584262},
{"SetArray",8421601},
{"SetInventory",8421575},
{"Shape",8618048},
{"ShapeDir",8618071},
{"Sharp",8618070},
{"Shovable",8618072},
{"Sound",8421576},
{"Stealthy",8618097},
{"Strength",9142355},
{"Super",8487152},
{"SwapWorld",8421614},
{"Sweep",8421577},
{"SweepEx",8421578},
{"Synchronize",8421579},
{"TAHTASHH",8389409},
{"THMP_thmp",8389405},
{"THWIT",8389384},
{"TICK",8389391},
{"Target",8487116},
{"Temperature",9142334},
{"Trace",8421581},
{"Trigger",8421582},
{"TriggerAt",8421583},
{"UH_OH",8389382},
{"UNCORK",8389414},
{"UNHH",8389381},
{"UserSignal",8618094},
{"UserState",8618095},
{"VACUUM",8389411},
{"VisualOnly",8618096},
{"Volume",9142347},
{"VolumeAt",8421584},
{"W",9437188},
{"WAHOO",8389400},
{"WHACK",8389423},
{"Weight",9142349},
{"WinLevel",8421585},
{"XDir",8487122},
{"XYDir",8421587},
{"Xloc",8486977},
{"YDir",8487124},
{"YEEHAW",8389401},
{"Yloc",8486978},
{"_",8421589},
{"a?",8421436},
{"again",8683533},
{"and",8683544},
{"band",8421412},
{"begin",8683532},
{"bit",8683560},
{"bit0",8388609},

{"bit8",8423400},
{"bit9",8423401},
{"bnot",8421415},
{"bor",8421413},
{"bxor",8421414},
{"c?",8421430},
{"case",8683542},
{"chain",8421532},
{"clear",8421596},
{"count",8421595},
{"cut",8683755},
{"cz?",8421431},
{"dup",8421377},
{"else",8683530},
{"eq",8421421},
{"eq2",8421422},
{"flip",8421594},
{"for",8683537},
{"fork",8683545},
{"ge",8486962},
{"gt",8486960},
{"if",8683529},
{"in",8421591},
{"is",8421428},
{"land",8421417},
{"le",8486963},
{"lnot",8421420},
{"lor",8421418},
{"lsh",8421410},
{"lt",8486961},
{"lxor",8421419},
{"m?",8421432},
{"max",8486945},
{"mbegin",8683737},
{"min",8486944},
{"mod",8486942},
{"n?",8421429},
{"ne",8421423},
{"neg",8421407},
{"next",8683538},
{"nin",8421592},
{"nip",8421379},
{"o?",8421434},
{"or",8683543},
{"over",8421384},
{"oz?",8421435},
{"pick",8421383},
{"repeat",8683536},
{"ret",8421397},
{"rot",8421381},
{"rsh",8486947},
{"s?",8421433},
{"swap",8421378},
{"then",8683531},
{"tmark",8421590},
{"tuck",8421380},
{"uniq",8421597},
{"until",8683534},
{"while",8683535},
};
#define N_OP_NAMES 349
#endif