Commit magic patch v13

36 files changed, 11748 insertions, 154 deletions

diff --git a/src/map/GNUmakefile b/src/map/GNUmakefile
index 852bbb9..4597c6d 100644
--- a/src/map/GNUmakefile
+++ b/src/map/GNUmakefile
@@ -1,3 +1,6 @@
+LEX=flex

+BISON=bison

+

 all: txt sql

 

 txt: txtobj map-server

@@ -13,7 +16,7 @@ sqlobj:
 COMMON_OBJ = ../common/core.o ../common/socket.o ../common/timer.o ../common/grfio.o ../common/db.o ../common/lock.o ../common/nullpo.o ../common/malloc.o

 LIBS = -lz -lm

 

-map-server: txtobj/map.o txtobj/chrif.o txtobj/clif.o txtobj/pc.o txtobj/npc.o txtobj/chat.o txtobj/path.o txtobj/itemdb.o txtobj/mob.o txtobj/script.o txtobj/storage.o txtobj/skill.o txtobj/atcommand.o txtobj/battle.o txtobj/intif.o txtobj/trade.o txtobj/party.o txtobj/vending.o txtobj/guild.o txtobj/pet.o $(COMMON_OBJ)

+map-server: txtobj/magic-interpreter-lexer.o txtobj/magic-interpreter-parser.o txtobj/magic-interpreter-base.o txtobj/magic-expr.o txtobj/magic-stmt.o txtobj/magic.o txtobj/map.o txtobj/chrif.o txtobj/clif.o txtobj/pc.o txtobj/npc.o txtobj/chat.o txtobj/path.o txtobj/itemdb.o txtobj/mob.o txtobj/script.o txtobj/storage.o txtobj/skill.o txtobj/atcommand.o txtobj/battle.o txtobj/intif.o txtobj/trade.o txtobj/party.o txtobj/vending.o txtobj/guild.o txtobj/pet.o $(COMMON_OBJ)

 	$(CC) -o ../../$@ $^ $(LIBS)

 

 map-server_sql: sqlobj/map.o sqlobj/chrif.o sqlobj/clif.o sqlobj/pc.o sqlobj/npc.o sqlobj/chat.o sqlobj/path.o sqlobj/itemdb.o sqlobj/mob.o sqlobj/script.o sqlobj/storage.o sqlobj/skill.o sqlobj/atcommand.o sqlobj/battle.o sqlobj/intif.o sqlobj/trade.o sqlobj/party.o sqlobj/vending.o sqlobj/guild.o sqlobj/pet.o sqlobj/mail.o $(COMMON_OBJ)

@@ -25,9 +28,21 @@ txtobj/%.o: %.c
 sqlobj/%.o: %.c

 	$(COMPILE.c) $(OUTPUT_OPTION) $<

 

+magic-interpreter-lexer.c: magic-interpreter.l

+	$(LEX) -o magic-interpreter-lexer.c magic-interpreter.l

+

+magic-interpreter-parser.c: magic-interpreter-parser.y

+	$(BISON) -v -d -o magic-interpreter-parser.c magic-interpreter-parser.y

+

+txtobj/magic-interpreter-lexer.o: magic-interpreter-lexer.c magic-interpreter-parser.c magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

+txtobj/magic-interpreter-parser.o: magic-interpreter-parser.c magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

+txtobj/magic-interpreter-base.o: magic-interpreter-base.c magic-expr-eval.h magic-interpreter-aux.h magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

+txtobj/magic-expr.o: magic-expr.c magic-expr-eval.h magic-interpreter-aux.h magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

+txtobj/magic-stmt.o: magic-stmt.c magic-expr-eval.h magic-interpreter-aux.h magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

+txtobj/magic.o: magic.c magic.h magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

 txtobj/map.o: map.c map.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

 txtobj/chrif.o: chrif.c map.h battle.h chrif.h clif.h intif.h pc.h npc.h ../common/socket.h ../common/timer.h ../common/mmo.h

-txtobj/clif.o: clif.c map.h chrif.h clif.h mob.h intif.h pc.h npc.h itemdb.h chat.h script.h storage.h party.h guild.h atcommand.h pet.h atcommand.h ../common/socket.h ../common/timer.h ../common/mmo.h ../common/version.h

+txtobj/clif.o: magic.h clif.c map.h chrif.h clif.h mob.h intif.h pc.h npc.h itemdb.h chat.h script.h storage.h party.h guild.h atcommand.h pet.h atcommand.h ../common/socket.h ../common/timer.h ../common/mmo.h ../common/version.h

 txtobj/pc.o: pc.c map.h clif.h intif.h pc.h npc.h mob.h itemdb.h battle.h skill.h script.h party.h guild.h pet.h trade.h storage.h chat.h vending.h ../common/timer.h ../common/mmo.h ../common/db.h

 txtobj/npc.o: npc.c map.h npc.h clif.h pc.h script.h mob.h itemdb.h battle.h ../common/db.h ../common/timer.h ../common/mmo.h

 txtobj/chat.o: chat.c map.h clif.h pc.h chat.h ../common/db.h ../common/mmo.h

diff --git a/src/map/Makefile b/src/map/Makefile
index 3f5396e..70fc049 100644
--- a/src/map/Makefile
+++ b/src/map/Makefile
@@ -1,3 +1,6 @@
+LEX=flex

+BISON=bison

+

 all: txt sql

 

 txt: txtobj map-server

@@ -13,7 +16,7 @@ sqlobj:
 COMMON_OBJ = ../common/core.o ../common/socket.o ../common/timer.o ../common/grfio.o ../common/db.o ../common/lock.o ../common/nullpo.o ../common/malloc.o

 LIBS = -lz -lm

 

-map-server: txtobj/map.o txtobj/chrif.o txtobj/clif.o txtobj/pc.o txtobj/npc.o txtobj/chat.o txtobj/path.o txtobj/itemdb.o txtobj/mob.o txtobj/script.o txtobj/storage.o txtobj/skill.o txtobj/atcommand.o txtobj/battle.o txtobj/intif.o txtobj/trade.o txtobj/party.o txtobj/vending.o txtobj/guild.o txtobj/pet.o $(COMMON_OBJ)

+map-server: txtobj/magic-interpreter-lexer.o txtobj/magic-interpreter-parser.o txtobj/magic-interpreter-base.o txtobj/magic-expr.o txtobj/magic-stmt.o txtobj/magic.o txtobj/map.o txtobj/chrif.o txtobj/clif.o txtobj/pc.o txtobj/npc.o txtobj/chat.o txtobj/path.o txtobj/itemdb.o txtobj/mob.o txtobj/script.o txtobj/storage.o txtobj/skill.o txtobj/atcommand.o txtobj/battle.o txtobj/intif.o txtobj/trade.o txtobj/party.o txtobj/vending.o txtobj/guild.o txtobj/pet.o $(COMMON_OBJ)

 	$(CC) -o ../../$@ $> $(LIBS)

 

 map-server_sql: sqlobj/map.o sqlobj/chrif.o sqlobj/clif.o sqlobj/pc.o sqlobj/npc.o sqlobj/chat.o sqlobj/path.o sqlobj/itemdb.o sqlobj/mob.o sqlobj/script.o sqlobj/storage.o sqlobj/skill.o sqlobj/atcommand.o sqlobj/battle.o sqlobj/intif.o sqlobj/trade.o sqlobj/party.o sqlobj/vending.o sqlobj/guild.o sqlobj/pet.o sqlobj/mail.o $(COMMON_OBJ)

@@ -25,9 +28,21 @@ txtobj/%.o: %.c
 sqlobj/%.o: %.c

 	$(COMPILE.c) $(OUTPUT_OPTION) $<

 

+magic-interpreter-lexer.c: magic-interpreter.l

+	$(LEX) -o magic-interpreter-lexer.c magic-interpreter.l

+

+magic-interpreter-parser.c: magic-interpreter-parser.y

+	$(BISON) -v -d -o magic-interpreter-parser.c magic-interpreter-parser.y

+

+txtobj/magic-interpreter-lexer.o: magic-interpreter-lexer.c magic-interpreter-parser.c magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

+txtobj/magic-interpreter-parser.o: magic-interpreter-parser.c magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

+txtobj/magic-interpreter-base.o: magic-interpreter-base.c magic-expr-eval.h magic-interpreter-aux.h magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

+txtobj/magic-expr.o: magic-expr.c magic-expr-eval.h magic-interpreter-aux.h magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

+txtobj/magic-stmt.o: magic-stmt.c magic-expr-eval.h magic-interpreter-aux.h magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

+txtobj/magic.o: magic.c magic.h magic-expr.h magic-interpreter.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

 txtobj/map.o: map.c map.h chrif.h clif.h npc.h pc.h mob.h chat.h skill.h itemdb.h storage.h party.h pet.h atcommand.h ../common/core.h ../common/timer.h ../common/db.h ../common/grfio.h ../common/mmo.h

 txtobj/chrif.o: chrif.c map.h battle.h chrif.h clif.h intif.h pc.h npc.h ../common/socket.h ../common/timer.h ../common/mmo.h

-txtobj/clif.o: clif.c map.h chrif.h clif.h mob.h intif.h pc.h npc.h itemdb.h chat.h script.h storage.h party.h guild.h atcommand.h pet.h atcommand.h ../common/socket.h ../common/timer.h ../common/mmo.h ../common/version.h

+txtobj/clif.o: magic.h clif.c map.h chrif.h clif.h mob.h intif.h pc.h npc.h itemdb.h chat.h script.h storage.h party.h guild.h atcommand.h pet.h atcommand.h ../common/socket.h ../common/timer.h ../common/mmo.h ../common/version.h

 txtobj/pc.o: pc.c map.h clif.h intif.h pc.h npc.h mob.h itemdb.h battle.h skill.h script.h party.h guild.h pet.h trade.h storage.h chat.h vending.h ../common/timer.h ../common/mmo.h ../common/db.h

 txtobj/npc.o: npc.c map.h npc.h clif.h pc.h script.h mob.h itemdb.h battle.h ../common/db.h ../common/timer.h ../common/mmo.h

 txtobj/chat.o: chat.c map.h clif.h pc.h chat.h ../common/db.h ../common/mmo.h

diff --git a/src/map/atcommand.c b/src/map/atcommand.c
index 03e7675..ca2c38a 100644
--- a/src/map/atcommand.c
+++ b/src/map/atcommand.c
@@ -210,6 +210,8 @@ ATCOMMAND_FUNC(adjgmlvl); // by MouseJstr
 ATCOMMAND_FUNC(adjcmdlvl); // by MouseJstr
 ATCOMMAND_FUNC(trade); // by MouseJstr
 ATCOMMAND_FUNC(unmute); // [Valaris]
+ATCOMMAND_FUNC(set_magic);
+ATCOMMAND_FUNC(magic_info);
 
 #ifndef TXT_ONLY
 ATCOMMAND_FUNC(checkmail); // [Valaris]
@@ -454,6 +456,8 @@ static AtCommandInfo atcommand_info[] = {
 	{ AtCommand_AdjCmdLvl,      "@adjcmdlvl", 99, atcommand_adjcmdlvl },
 	{ AtCommand_Trade,      "@trade", 60, atcommand_trade },
 	{ AtCommand_UnMute,	"@unmute", 60, atcommand_unmute }, // [Valaris]
+        { AtCommand_SetMagic,  "@setmagic", 99, atcommand_set_magic }, // [Fate]
+        { AtCommand_MagicInfo, "@magicinfo", 99, atcommand_magic_info }, // [Fate]
 
 #ifndef TXT_ONLY // sql-only commands
 	{ AtCommand_CheckMail,		 "@checkmail",	      1, atcommand_listmail }, // [Valaris]
@@ -1976,7 +1980,7 @@ int atcommand_item(
 				item_tmp.nameid = item_id;
 				item_tmp.identify = 1;
 				if ((flag = pc_additem((struct map_session_data*)sd, &item_tmp, get_count)))
-					clif_additem((struct map_session_data*)sd, 0, 0, flag);
+                                        clif_additem((struct map_session_data*)sd, 0, 0, flag);
 			}
 		}
 		clif_displaymessage(fd, msg_table[18]); // Item created.
@@ -7761,3 +7765,101 @@ int atcommand_refreshonline(
 }
 
 #endif /* end sql only */
+
+/* Magic atcommands by Fate */
+
+static int magic_base = TMW_MAGIC;
+#define magic_skills_nr 6
+static char *magic_skill_names[magic_skills_nr] = {"magic", "life", "war", "transmute", "nature", "ether"};
+
+int
+atcommand_magic_info(const int fd, struct map_session_data* sd,
+                     const char* command, const char* message)
+{
+	char character[100];
+        char buf[200];
+	struct map_session_data *pl_sd;
+
+	memset(character, '\0', sizeof(character));
+
+	if (!message || !*message || sscanf(message, "%99[^\n]", character) < 1) {
+		clif_displaymessage(fd, "Usage: @magicinfo <char_name>");
+		return -1;
+	}
+
+	if ((pl_sd = map_nick2sd(character)) != NULL) {
+                int i;
+
+                sprintf(buf, "`%s' has the following magic skills:", character);
+                clif_displaymessage(fd, buf);
+
+                for (i = 0; i < magic_skills_nr; i++) {
+                        sprintf(buf, "%d in %s", pl_sd->status.skill[i + magic_base].lv, magic_skill_names[i]);
+                        if (pl_sd->status.skill[i + magic_base].id == i + magic_base)
+                                clif_displaymessage(fd, buf);
+                }
+
+                return 0;
+        } else
+                clif_displaymessage(fd, "Character not found.");
+
+        return -1;
+}
+
+static void
+set_skill(struct map_session_data* sd, int i, int level)
+{
+        sd->status.skill[i].id = level? i : 0;
+        sd->status.skill[i].lv = level;
+        sd->status.skill[i].flag = 0;
+}
+
+int
+atcommand_set_magic(const int fd, struct map_session_data* sd,
+                    const char* command, const char* message)
+{
+	char character[100];
+        char magic_type[20];
+        int skill_index = -1; // 0: all
+        int value;
+	struct map_session_data *pl_sd;
+
+	memset(character, '\0', sizeof(character));
+
+	if (!message || !*message || sscanf(message, "%99s %19s %i", character, magic_type, &value) < 1) {
+		clif_displaymessage(fd, "Usage: @setmagic <char_name> <school> <value>, where <school> is either `magic', one of the school names, or `all'.");
+		return -1;
+	}
+
+        if (!strcasecmp("all", magic_type))
+                skill_index = 0;
+        else {
+                int i;
+                for (i = 0; i < magic_skills_nr; i++) {
+                        if (!strcasecmp(magic_skill_names[i], magic_type)) {
+                                skill_index = i + magic_base;
+                                break;
+                        }
+                }
+        }
+
+        if (skill_index == -1) {
+		clif_displaymessage(fd, "Incorrect school of magic.  Use `magic', `nature', `life', `war', `transmute', `ether', or `all'.");
+                return -1;
+        }
+
+	if ((pl_sd = map_nick2sd(character)) != NULL) {
+                int i;
+                if (skill_index == 0)
+                        for (i = 0; i < magic_skills_nr; i++)
+                                set_skill(pl_sd, i + magic_base, value);
+                else
+                        set_skill(pl_sd, skill_index, value);
+
+                return 0;
+        } else
+                clif_displaymessage(fd, "Character not found.");
+
+        return -1;
+}
+
diff --git a/src/map/atcommand.h b/src/map/atcommand.h
index 06029a5..7f6d469 100644
--- a/src/map/atcommand.h
+++ b/src/map/atcommand.h
@@ -208,6 +208,8 @@ enum AtCommandType {
 	// SQL-only commands end
 #endif
 	
+        AtCommand_SetMagic,
+        AtCommand_MagicInfo,
 	// end
 	AtCommand_Unknown,
 	AtCommand_MAX
diff --git a/src/map/battle.c b/src/map/battle.c
index 1a954f3..d455d78 100644
--- a/src/map/battle.c
+++ b/src/map/battle.c
@@ -275,7 +275,7 @@ int battle_get_vit(struct block_list *bl)
 		vit=mob_db[((struct pet_data *)bl)->class].vit;
 	if(sc_data) {
 		if(sc_data[SC_STRIPARMOR].timer != -1 && bl->type!=BL_PC)
-		vit = vit*60/100;
+                    vit = vit*60/100;
 		if(sc_data[SC_TRUESIGHT].timer!=-1 && bl->type != BL_PC)	// トゥルーサイト
 			vit += 5;
 	}
@@ -785,6 +785,11 @@ int battle_get_mdef(struct block_list *bl)
 	if(mdef < 1000000) {
 		if(sc_data) {
 			//バリアー状態時はMDEF100
+			if(mdef < 90 && sc_data[SC_MBARRIER].timer != -1) {
+                                mdef += sc_data[SC_MBARRIER].val1;
+                                if (mdef > 90)
+                                        mdef = 90;
+                        }
 			if(sc_data[SC_BARRIER].timer != -1)
 				mdef = 100;
 			//凍結、石化時は1.25倍
@@ -957,8 +962,11 @@ int battle_get_adelay(struct block_list *bl)
 			if(sc_data[SC_STEELBODY].timer!=-1)	// 金剛
 				aspd_rate += 25;
 			//増速ポーション使用時は減算
-			if(	sc_data[i=SC_SPEEDPOTION2].timer!=-1 || sc_data[i=SC_SPEEDPOTION1].timer!=-1 || sc_data[i=SC_SPEEDPOTION0].timer!=-1)
+			if(sc_data[i=SC_SPEEDPOTION2].timer!=-1 || sc_data[i=SC_SPEEDPOTION1].timer!=-1 || sc_data[i=SC_SPEEDPOTION0].timer!=-1)
 				aspd_rate -= sc_data[i].val2;
+                        // Fate's `haste' spell works the same as the above
+			if (sc_data[SC_HASTE].timer != -1)
+				aspd_rate -= sc_data[SC_HASTE].val1;
 			//ディフェンダー時は加算
 			if(sc_data[SC_DEFENDER].timer != -1)
 				adelay += (1100 - sc_data[SC_DEFENDER].val1*100);
@@ -1004,8 +1012,10 @@ int battle_get_amotion(struct block_list *bl)
 				aspd_rate += sc_data[SC_DONTFORGETME].val1*3 + sc_data[SC_DONTFORGETME].val2 + (sc_data[SC_DONTFORGETME].val3>>16);
 			if(sc_data[SC_STEELBODY].timer!=-1)	// 金剛
 				aspd_rate += 25;
-			if(	sc_data[i=SC_SPEEDPOTION2].timer!=-1 || sc_data[i=SC_SPEEDPOTION1].timer!=-1 || sc_data[i=SC_SPEEDPOTION0].timer!=-1)
+			if(sc_data[i=SC_SPEEDPOTION2].timer!=-1 || sc_data[i=SC_SPEEDPOTION1].timer!=-1 || sc_data[i=SC_SPEEDPOTION0].timer!=-1)
 				aspd_rate -= sc_data[i].val2;
+			if (sc_data[SC_HASTE].timer != -1)
+				aspd_rate -= sc_data[SC_HASTE].val1;
 			if(sc_data[SC_DEFENDER].timer != -1)
 				amotion += (550 - sc_data[SC_DEFENDER].val1*50);
 		}
@@ -1190,8 +1200,9 @@ int battle_get_mode(struct block_list *bl)
 int battle_get_mexp(struct block_list *bl)
 {
 	nullpo_retr(0, bl);
-	if(bl->type==BL_MOB && (struct mob_data *)bl)
+	if(bl->type==BL_MOB && (struct mob_data *)bl) {
 		return mob_db[((struct mob_data *)bl)->class].mexp;
+        }
 	else if(bl->type==BL_PET && (struct pet_data *)bl)
 		return mob_db[((struct pet_data *)bl)->class].mexp;
 	else
@@ -4316,6 +4327,7 @@ int battle_weapon_attack( struct block_list *src,struct block_list *target,
 	short *opt1;
 	int race = 7, ele = 0;
 	int damage,rdamage = 0;
+        int i;
 	struct Damage wd;
 
 	nullpo_retr(0, src);
@@ -4365,6 +4377,19 @@ int battle_weapon_attack( struct block_list *src,struct block_list *target,
 		}
 		else
 			wd=battle_calc_weapon_attack(src,target,0,0,0);
+
+                // significantly increase injuries for hasted characters
+                if (wd.damage > 0
+                    && (t_sc_data[SC_HASTE].timer != -1)) {
+                    wd.damage = (wd.damage * (16 + t_sc_data[SC_HASTE].val1)) >> 4;
+                }
+
+                if (t_sc_data[SC_PHYS_SHIELD].timer != -1 && target->type == BL_PC) {
+                    wd.damage -= t_sc_data[SC_PHYS_SHIELD].val1;
+                    if (wd.damage < 0)
+                        wd.damage = 0;
+                }
+
 		if((damage = wd.damage + wd.damage2) > 0 && src != target) {
 			if(wd.flag&BF_SHORT) {
 				if(target->type == BL_PC) {
@@ -4388,6 +4413,7 @@ int battle_weapon_attack( struct block_list *src,struct block_list *target,
 					}
 				}
 			}
+
 			if(rdamage > 0)
 				clif_damage(src,src,tick, wd.amotion,0,rdamage,1,4,0);
 		}
@@ -4416,6 +4442,7 @@ int battle_weapon_attack( struct block_list *src,struct block_list *target,
 		if(sd && sd->splash_range > 0 && (wd.damage > 0 || wd.damage2 > 0) )
 			skill_castend_damage_id(src,target,0,-1,tick,0);
 		map_freeblock_lock();
+
 		battle_damage(src,target,(wd.damage+wd.damage2),0);
 		if(target->prev != NULL &&
 			(target->type != BL_PC || (target->type == BL_PC && !pc_isdead((struct map_session_data *)target) ) ) ) {
@@ -4898,6 +4925,7 @@ int battle_config_read(const char *cfgName)
 		battle_config.natural_healsp_interval=8000;
 		battle_config.natural_heal_skill_interval=10000;
 		battle_config.natural_heal_weight_rate=50;
+		battle_config.itemheal_regeneration_factor = 1;
 		battle_config.item_name_override_grffile=1;
 		battle_config.arrow_decrement=1;
 		battle_config.max_aspd = 199;
@@ -5130,6 +5158,7 @@ int battle_config_read(const char *cfgName)
 			{ "natural_healsp_interval",           &battle_config.natural_healsp_interval	},
 			{ "natural_heal_skill_interval",       &battle_config.natural_heal_skill_interval},
 			{ "natural_heal_weight_rate",          &battle_config.natural_heal_weight_rate	},
+			{ "itemheal_regeneration_factor",      &battle_config.itemheal_regeneration_factor	},
 			{ "item_name_override_grffile",        &battle_config.item_name_override_grffile},
 			{ "arrow_decrement",                   &battle_config.arrow_decrement			},
 			{ "max_aspd",                          &battle_config.max_aspd					},
diff --git a/src/map/battle.h b/src/map/battle.h
index 02283c9..f8a3205 100644
--- a/src/map/battle.h
+++ b/src/map/battle.h
@@ -342,6 +342,8 @@ extern struct Battle_Config {
 	int mail_system; // [Valaris]
 #endif
 
+        int itemheal_regeneration_factor; // [Fate] itemheal speed factor
+
 } battle_config;
 
 int battle_config_read(const char *cfgName);
diff --git a/src/map/clif.c b/src/map/clif.c
index 618e05a..98dd0fc 100644
--- a/src/map/clif.c
+++ b/src/map/clif.c
@@ -43,6 +43,7 @@
 #include "guild.h"
 #include "vending.h"
 #include "pet.h"
+#include "magic.h"
 
 #ifdef MEMWATCH
 #include "memwatch.h"
@@ -670,6 +671,16 @@ int clif_clearchar_id(int id, int type, int fd) {
 	return 0;
 }
 
+static int
+current_weapon(struct map_session_data *sd)
+{
+        if (sd->attack_spell_override)
+                return sd->attack_spell_look_override;
+        else {
+                return sd->status.weapon;
+        }
+}
+
 /*==========================================
  *
  *------------------------------------------
@@ -709,7 +720,7 @@ static int clif_set0078(struct map_session_data *sd, unsigned char *buf) {
 	WBUFW(buf,14)= sd->view_class;
 	WBUFW(buf,16)= sd->status.hair;
 	if (sd->view_class != 22)
-		WBUFW(buf,18) = sd->status.weapon;
+		WBUFW(buf,18) = current_weapon(sd);
 	else
 		WBUFW(buf,18)=0;
 	WBUFW(buf,20)=sd->status.head_bottom;
@@ -741,13 +752,17 @@ static int clif_set0078(struct map_session_data *sd, unsigned char *buf) {
 	WBUFW(buf,12) = sd->status.option;
 	WBUFW(buf,14) = sd->view_class;
 	WBUFW(buf,16) = sd->status.hair;
-	if (sd->equip_index[9] >= 0 && sd->inventory_data[sd->equip_index[9]] && sd->view_class != 22) {
-		if (sd->inventory_data[sd->equip_index[9]]->view_id > 0)
-			WBUFW(buf,18) = sd->inventory_data[sd->equip_index[9]]->view_id;
-		else
-			WBUFW(buf,18) = sd->status.inventory[sd->equip_index[9]].nameid;
-	} else
-		WBUFW(buf,18) = 0;
+        if (sd->attack_spell_override)
+                WBUFB(buf, 18) = sd->attack_spell_look_override;
+        else {
+                if (sd->equip_index[9] >= 0 && sd->inventory_data[sd->equip_index[9]] && sd->view_class != 22) {
+                        if (sd->inventory_data[sd->equip_index[9]]->view_id > 0)
+                                WBUFW(buf,18) = sd->inventory_data[sd->equip_index[9]]->view_id;
+                        else
+                                WBUFW(buf,18) = sd->status.inventory[sd->equip_index[9]].nameid;
+                } else
+                        WBUFW(buf,18) = 0;
+        }
 	if (sd->equip_index[8] >= 0 && sd->equip_index[8] != sd->equip_index[9] && sd->inventory_data[sd->equip_index[8]] && sd->view_class != 22) {
 		if (sd->inventory_data[sd->equip_index[8]]->view_id > 0)
 			WBUFW(buf,20) = sd->inventory_data[sd->equip_index[8]]->view_id;
@@ -817,7 +832,7 @@ static int clif_set007b(struct map_session_data *sd,unsigned char *buf) {
 	WBUFW(buf,14)=sd->view_class;
 	WBUFW(buf,16)=sd->status.hair;
 	if(sd->view_class != 22)
-		WBUFW(buf,18)=sd->status.weapon;
+		WBUFW(buf,18)= current_weapon(sd);
 	else
 		WBUFW(buf,18)=0;
 	WBUFW(buf,20)=sd->status.head_bottom;
@@ -1304,6 +1319,39 @@ int clif_spawnnpc(struct npc_data *nd)
 	return 0;
 }
 
+int
+clif_spawn_fake_npc_for_player(struct map_session_data *sd, int fake_npc_id)
+{
+        int fd;
+
+        nullpo_retr(0, sd);
+
+        fd = sd->fd;
+        if (!fd)
+                return 0;
+
+	WFIFOW(fd, 0) = 0x7c;
+	WFIFOL(fd, 2) = fake_npc_id;
+	WFIFOW(fd, 6) = 0;
+	WFIFOW(fd, 20) = 127;
+	WFIFOPOS(fd, 36, sd->bl.x, sd->bl.y);
+        WFIFOSET(fd, packet_len_table[0x7c]);
+
+	WFIFOW(fd, 0)=0x78;
+	WFIFOL(fd, 2) = fake_npc_id;
+	WFIFOW(fd, 6) = 0;
+	WFIFOW(fd, 14) = 127; // identifies as NPC
+	WFIFOW(fd, 20) = 127;
+	WFIFOPOS(fd, 46, sd->bl.x, sd->bl.y);
+	WFIFOPOS(fd, 36, sd->bl.x, sd->bl.y);
+	WFIFOB(fd, 49) = 5;
+	WFIFOB(fd, 50) = 5;
+        WFIFOSET(fd, packet_len_table[0x78]);
+
+        return 0;
+}
+
+
 /*==========================================
  *
  *------------------------------------------
@@ -2413,7 +2461,9 @@ int clif_updatestatus(struct map_session_data *sd,int type)
 		// 013a 終了
 	case SP_ATTACKRANGE:
 		WFIFOW(fd,0)=0x13a;
-		WFIFOW(fd,2)=sd->attackrange;
+		WFIFOW(fd,2) = (sd->attack_spell_override)
+                               ? sd->attack_spell_range
+                               : sd->attackrange;
 		len=4;
 		break;
 
@@ -2550,13 +2600,17 @@ int clif_changelook(struct block_list *bl,int type,int val)
 		}
 		else {
 			WBUFB(buf,6)=2;
-			if(sd->equip_index[9] >= 0 && sd->inventory_data[sd->equip_index[9]] && sd->view_class != 22) {
-				if(sd->inventory_data[sd->equip_index[9]]->view_id > 0)
-					WBUFW(buf,7)=sd->inventory_data[sd->equip_index[9]]->view_id;
-				else
-					WBUFW(buf,7)=sd->status.inventory[sd->equip_index[9]].nameid;
-			} else
-				WBUFW(buf,7)=0;
+                        if (sd->attack_spell_override)
+                                WBUFW(buf, 7) = sd->attack_spell_look_override;
+                        else {
+                                if(sd->equip_index[9] >= 0 && sd->inventory_data[sd->equip_index[9]] && sd->view_class != 22) {
+                                        if(sd->inventory_data[sd->equip_index[9]]->view_id > 0)
+                                                WBUFW(buf,7)=sd->inventory_data[sd->equip_index[9]]->view_id;
+                                        else
+                                                WBUFW(buf,7)=sd->status.inventory[sd->equip_index[9]].nameid;
+                                } else
+                                        WBUFW(buf,7)=0;
+                        }
 			if(sd->equip_index[8] >= 0 && sd->equip_index[8] != sd->equip_index[9] && sd->inventory_data[sd->equip_index[8]] &&
 				sd->view_class != 22) {
 				if(sd->inventory_data[sd->equip_index[8]]->view_id > 0)
@@ -4089,7 +4143,8 @@ int clif_skillinfoblock(struct map_session_data *sd)
 	fd=sd->fd;
 	WFIFOW(fd,0)=0x10f;
 	for ( i = c = 0; i < MAX_SKILL; i++){
-		if( (id=sd->status.skill[i].id)!=0 ){
+		if( (id=sd->status.skill[i].id)!=0
+                    && (i < TMW_MAGIC || i > TMW_MAGIC_END)){ // [Fate] Hack: Prevent killing the client
 			WFIFOW(fd,len  ) = id;
 			WFIFOW(fd,len+2) = skill_get_inf(id);
 			WFIFOW(fd,len+4) = 0;
@@ -7132,7 +7187,7 @@ void clif_parse_LoadEndAck(int fd,struct map_session_data *sd)
 
 	// view equipment item
 #if PACKETVER < 4
-	clif_changelook(&sd->bl,LOOK_WEAPON,sd->status.weapon);
+	clif_changelook(&sd->bl,LOOK_WEAPON, current_weapon(sd));
 	clif_changelook(&sd->bl,LOOK_SHIELD,sd->status.shield);
 #else
 	clif_changelook(&sd->bl,LOOK_WEAPON,0);
@@ -7318,7 +7373,10 @@ void clif_parse_GetCharNameRequest(int fd, struct map_session_data *sd) {
 
 		nullpo_retv(ssd);
 
-		memcpy(WFIFOP(fd,6), ssd->status.name, 24);
+                if (ssd->state.shroud_active)
+                    memset(WFIFOP(fd,6), 0, 24);
+                else
+                    memcpy(WFIFOP(fd,6), ssd->status.name, 24);
 		if (ssd->status.guild_id > 0 && (g = guild_search(ssd->status.guild_id)) != NULL &&
 		    (ssd->status.party_id == 0 || (p = party_search(ssd->status.party_id)) != NULL)) {
 			// ギルド所属ならパケット0195を返す
@@ -7488,12 +7546,18 @@ void clif_parse_GlobalMessage(int fd, struct map_session_data *sd) { // S 008c <
 		}
 		// but for the hacker, we display on his screen (he see/look no difference).
 	} else {
+                int magic_status;
 		// send message to others
 		WBUFW(buf,0) = 0x8d;
 		WBUFW(buf,2) = RFIFOW(fd,2) + 4; // len of message - 4 + 8
 		WBUFL(buf,4) = sd->bl.id;
 		memcpy(WBUFP(buf,8), RFIFOP(fd,4), RFIFOW(fd,2) - 4);
-		clif_send(buf, WBUFW(buf,2), &sd->bl, sd->chatID ? CHAT_WOS : AREA_CHAT_WOC);
+                magic_status = magic_message(sd, buf, WBUFW(buf, 2));
+                if (magic_status)
+                        sd->chat_threshold = 0; /* Don't treat repeated magic as spamming */
+
+                if (magic_status >= 0)
+                        clif_send(buf, WBUFW(buf,2), &sd->bl, sd->chatID ? CHAT_WOS : AREA_CHAT_WOC);
 	}
 
 	// send back message to the speaker
@@ -7852,6 +7916,10 @@ void clif_parse_TakeItem(int fd, struct map_session_data *sd) {
 	if (abs(sd->bl.x - fitem->bl.x) >= 2 || abs(sd->bl.y - fitem->bl.y) >= 2)
 		return; // too far away to pick up
 
+        if (sd->state.shroud_active
+            && sd->state.shroud_disappears_on_pickup)
+            magic_unshroud(sd);
+
 	pc_takeitem(sd, fitem);
 }
 
@@ -8486,7 +8554,7 @@ void clif_parse_NpcSelectMenu(int fd,struct map_session_data *sd)
 	nullpo_retv(sd);
 
 	sd->npc_menu=RFIFOB(fd,6);
-	npc_scriptcont(sd,RFIFOL(fd,2));
+	map_scriptcont(sd,RFIFOL(fd,2));
 }
 
 /*==========================================
@@ -8495,7 +8563,7 @@ void clif_parse_NpcSelectMenu(int fd,struct map_session_data *sd)
  */
 void clif_parse_NpcNextClicked(int fd,struct map_session_data *sd)
 {
-	npc_scriptcont(sd,RFIFOL(fd,2));
+	map_scriptcont(sd,RFIFOL(fd,2));
 }
 
 /*==========================================
@@ -8512,7 +8580,7 @@ void clif_parse_NpcAmountInput(int fd,struct map_session_data *sd)
 
 #undef RFIFOL_
 
-	npc_scriptcont(sd,RFIFOL(fd,2));
+	map_scriptcont(sd,RFIFOL(fd,2));
 }
 
 /*==========================================
@@ -8529,7 +8597,7 @@ void clif_parse_NpcStringInput(int fd,struct map_session_data *sd)
 		sd->npc_str[sizeof(sd->npc_str)-1]=0;
 	} else
 		strcpy(sd->npc_str,RFIFOP(fd,8));
-	npc_scriptcont(sd,RFIFOL(fd,4));
+	map_scriptcont(sd,RFIFOL(fd,4));
 }
 
 /*==========================================
@@ -8538,7 +8606,7 @@ void clif_parse_NpcStringInput(int fd,struct map_session_data *sd)
  */
 void clif_parse_NpcCloseClicked(int fd,struct map_session_data *sd)
 {
-	npc_scriptcont(sd,RFIFOL(fd,2));
+	map_scriptcont(sd,RFIFOL(fd,2));
 }
 
 /*==========================================
diff --git a/src/map/clif.h b/src/map/clif.h
index cdddd8b..d04d821 100644
--- a/src/map/clif.h
+++ b/src/map/clif.h
@@ -34,6 +34,7 @@ int clif_clearchar_delay(unsigned int,struct block_list *,int);
 int clif_clearchar_id(int,int,int);
 int clif_spawnpc(struct map_session_data*);	//area
 int clif_spawnnpc(struct npc_data*);	// area
+int clif_spawn_fake_npc_for_player(struct map_session_data *sd, int fake_npc_id);
 int clif_spawnmob(struct mob_data*);	// area
 int clif_spawnpet(struct pet_data*);	// area
 int clif_walkok(struct map_session_data*);	// self
diff --git a/src/map/magic-expr-eval.h b/src/map/magic-expr-eval.h
new file mode 100644
index 0000000..b859919
--- /dev/null
+++ b/src/map/magic-expr-eval.h
@@ -0,0 +1,43 @@
+#ifndef MAGIC_EXPR_EVAL
+#define MAGIC_EXPR_EVAL
+
+/* Helper definitions for dealing with functions and operations */
+
+static int heading_x[8] = { 0, -1, -1, -1,  0,  1, 1, 1 };
+static int heading_y[8] = { 1,  1,  0, -1, -1, -1, 0, 1 };
+
+int
+magic_signature_check(char *opname, char *funname, char *signature, int args_nr, val_t *args, int line, int column);
+
+void
+magic_area_rect(int *m, int *x, int *y, int *width, int *height, area_t *area);
+
+
+#define ARGINT(x) args[x].v.v_int
+#define ARGDIR(x) args[x].v.v_int
+#define ARGSTR(x) args[x].v.v_string
+#define ARGENTITY(x) args[x].v.v_entity
+#define ARGLOCATION(x) args[x].v.v_location
+#define ARGAREA(x) args[x].v.v_area
+#define ARGSPELL(x) args[x].v.v_spell
+#define ARGINVOCATION(x) args[x].v.v_invocation
+
+#define RESULTINT result->v.v_int
+#define RESULTDIR result->v.v_int
+#define RESULTSTR result->v.v_string
+#define RESULTENTITY result->v.v_entity
+#define RESULTLOCATION result->v.v_location
+#define RESULTAREA result->v.v_area
+#define RESULTSPELL result->v.v_spell
+#define RESULTINVOCATION result->v.v_invocation
+
+#define TY(x) args[x].ty
+#define ETY(x) ARGENTITY(x)->type
+
+#define ARGPC(x)  ((struct map_session_data *)ARGENTITY(x))
+#define ARGNPC(x)  ((struct map_session_data *)ARGENTITY(x))
+#define ARGMOB(x)  ((struct map_session_data *)ARGENTITY(x))
+
+#define ARG_MAY_BE_AREA(x) (TY(x) == TY_AREA || TY(x) == TY_LOCATION)
+
+#endif /* !defined(MAGIC_EXPR_EVAL) */
diff --git a/src/map/magic-expr.c b/src/map/magic-expr.c
new file mode 100644
index 0000000..2fbaa4f
--- /dev/null
+++ b/src/map/magic-expr.c
@@ -0,0 +1,1286 @@
+#include "magic-expr.h"
+#include "magic-expr-eval.h"
+#include "itemdb.h"
+#include <math.h>
+
+#define IS_SOLID(c) ((c) == 1 || (c) == 5)
+
+int
+map_is_solid(int m, int x, int y)
+{
+    return (IS_SOLID(map_getcell(m, x, y)));
+}
+
+#undef IS_SOLID
+
+static void
+free_area(area_t *area)
+{
+        if (!area)
+                return;
+
+        switch (area->ty) {
+        case AREA_UNION:
+                free_area(area->a.a_union[0]);
+                free_area(area->a.a_union[1]);
+                break;
+        default: break;
+        }
+
+        free(area);
+}
+
+static area_t *
+dup_area(area_t *area)
+{
+        area_t *retval = malloc(sizeof(area_t));
+        *retval = *area;
+
+        switch (area->ty) {
+        case AREA_UNION:
+                retval->a.a_union[0] = dup_area(retval->a.a_union[0]);
+                retval->a.a_union[1] = dup_area(retval->a.a_union[1]);
+                break;
+        default: break;
+        }
+
+        return retval;
+}
+
+void
+magic_copy_var(val_t *dest, val_t *src)
+{
+        *dest = *src;
+
+        switch (dest->ty) {
+        case TY_STRING: dest->v.v_string = strdup(dest->v.v_string);
+                break;
+        case TY_AREA: dest->v.v_area = dup_area(dest->v.v_area);
+                break;
+        default: break;
+        }
+        
+}
+
+void
+magic_clear_var(val_t *v)
+{
+        switch (v->ty) {
+        case TY_STRING: free(v->v.v_string);
+                break;
+        case TY_AREA: free_area(v->v.v_area);
+                break;
+        default: break;
+        }
+}
+
+static char *
+show_entity(entity_t *entity)
+{
+        switch (entity->type) {
+        case BL_PC:
+                return ((struct map_session_data *)entity)->status.name;
+        case BL_NPC:
+                return ((struct npc_data *)entity)->name;
+        case BL_MOB:
+                return ((struct mob_data *)entity)->name;
+        case BL_ITEM:
+                /* Sorry about this one... */
+                return ((struct item_data *)(&((struct flooritem_data *)entity)->item_data))->name;
+        case BL_SKILL:
+                return "%skill";
+        case BL_PET:
+                return ((struct pet_data *)entity)->name;
+        case BL_SPELL:
+                return "%invocation(ERROR:this-should-not-be-an-entity)";
+        default:
+                return "%unknown-entity";
+        }
+}
+
+static void
+stringify(val_t *v, int within_op)
+{
+        static char *dirs[8] = {"S", "SW", "W", "NW", "N", "NE", "E", "SE"};
+        char *buf;
+
+        switch (v->ty) {
+        case TY_UNDEF:
+                buf = strdup("UNDEF");
+                break;
+
+        case TY_INT:
+                buf = malloc(32);
+                sprintf(buf, "%i", v->v.v_int);
+                break;
+
+        case TY_STRING:
+                return;
+
+        case TY_DIR:
+                buf = strdup(dirs[v->v.v_int]);
+                break;
+
+        case TY_ENTITY:
+                buf = strdup(show_entity(v->v.v_entity));
+                break;
+
+        case TY_LOCATION:
+                buf = malloc(128);
+                sprintf(buf, "<\"%s\", %d, %d>", map[v->v.v_location.m].name,
+                        v->v.v_location.x, v->v.v_location.y);
+                break;
+
+        case TY_AREA:
+                buf = strdup("%area");
+                free_area(v->v.v_area);
+                break;
+
+        case TY_SPELL:
+                buf = strdup(v->v.v_spell->name);
+                break;
+
+        case TY_INVOCATION: {
+                invocation_t *invocation = within_op
+                                         ? v->v.v_invocation
+                                         : (invocation_t *) map_id2bl(v->v.v_int);
+                buf = strdup(invocation->spell->name);
+        }
+                break;
+
+        default:
+                fprintf(stderr, "[magic] INTERNAL ERROR: Cannot stringify %d\n", v->ty);
+                return;
+        }
+
+        v->v.v_string = buf;
+        v->ty = TY_STRING;
+}
+
+static void
+intify(val_t *v)
+{
+        if (v->ty == TY_INT)
+                return;
+
+        magic_clear_var(v);
+        v->ty = TY_INT;
+        v->v.v_int = 1;
+}
+
+
+area_t *
+area_new(int ty)
+{
+        area_t *retval = (area_t *)aCalloc(sizeof(area_t), 1);
+        retval->ty = ty;
+        return retval;
+}
+
+area_t *
+area_union(area_t *area, area_t *other_area)
+{
+        area_t *retval = area_new(AREA_UNION);
+        retval->a.a_union[0] = area;
+        retval->a.a_union[1] = other_area;
+        retval->size = area->size + other_area->size; /* Assume no overlap */
+        return retval;
+}
+
+/**
+ * Turns location into area, leaves other types untouched
+ */
+static void
+make_area(val_t *v)
+{
+        if (v->ty == TY_LOCATION) {
+                area_t *a = malloc(sizeof (area_t));
+                v->ty = TY_AREA;
+                a->ty = AREA_LOCATION;
+                a->a.a_loc = v->v.v_location;
+                v->v.v_area = a;
+        }
+}
+
+static void
+make_location(val_t *v)
+{
+        if (v->ty == TY_AREA &&
+            v->v.v_area->ty == AREA_LOCATION) {
+                location_t location = v->v.v_area->a.a_loc;
+                free_area(v->v.v_area);
+                v->ty = TY_LOCATION;
+                v->v.v_location = location;
+        }
+}
+
+static int
+fun_add(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (TY(0) == TY_INT  && TY(1) == TY_INT) {
+                /* Integer addition */
+                RESULTINT = ARGINT(0) + ARGINT(1);
+                result->ty = TY_INT;
+        } else if (ARG_MAY_BE_AREA(0) && ARG_MAY_BE_AREA(1)) {
+                /* Area union */
+                make_area(&args[0]);
+                make_area(&args[1]);
+                RESULTAREA = area_union(ARGAREA(0), ARGAREA(1));
+                ARGAREA(0) = NULL;
+                ARGAREA(1) = NULL;
+                result->ty = TY_AREA;
+        } else {
+                /* Anything else -> string concatenation */
+                stringify(&args[0], 1);
+                stringify(&args[1], 1);
+                /* Yes, we could speed this up. */
+                RESULTSTR = (char *) malloc(1 + strlen(ARGSTR(0)) + strlen(ARGSTR(1)));
+                strcpy(RESULTSTR, ARGSTR(0));
+                strcat(RESULTSTR, ARGSTR(1));
+                result->ty = TY_STRING;
+        }
+        return 0;
+}
+
+static int
+fun_sub(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = ARGINT(0) - ARGINT(1);
+        return 0;
+}
+
+
+static int
+fun_mul(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = ARGINT(0) * ARGINT(1);
+        return 0;
+}
+
+
+static int
+fun_div(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (!ARGINT(1))
+                return 1; /* division by zero */
+        RESULTINT = ARGINT(0) / ARGINT(1);
+        return 0;
+}
+
+static int
+fun_mod(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (!ARGINT(1))
+                return 1; /* division by zero */
+        RESULTINT = ARGINT(0) % ARGINT(1);
+        return 0;
+}
+
+static int
+fun_or(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = ARGINT(0) || ARGINT(1);
+        return 0;
+}
+
+static int
+fun_and(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = ARGINT(0) && ARGINT(1);
+        return 0;
+}
+
+static int
+fun_not(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = !ARGINT(0);
+        return 0;
+}
+
+static int
+fun_gte(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (TY(0) == TY_STRING || TY(1) == TY_STRING) {
+                stringify(&args[0], 1);
+                stringify(&args[1], 1);
+                RESULTINT = strcmp(ARGSTR(0), ARGSTR(1)) >= 0;
+        } else {
+                intify(&args[0]);
+                intify(&args[1]);
+                RESULTINT = ARGINT(0) >= ARGINT(1);
+        }
+        return 0;
+}
+
+static int
+fun_gt(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (TY(0) == TY_STRING || TY(1) == TY_STRING) {
+                stringify(&args[0], 1);
+                stringify(&args[1], 1);
+                RESULTINT = strcmp(ARGSTR(0), ARGSTR(1)) > 0;
+        } else {
+                intify(&args[0]);
+                intify(&args[1]);
+                RESULTINT = ARGINT(0) > ARGINT(1);
+        }
+        return 0;
+}
+
+
+static int
+fun_eq(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (TY(0) == TY_STRING || TY(1) == TY_STRING) {
+                stringify(&args[0], 1);
+                stringify(&args[1], 1);
+                RESULTINT = strcmp(ARGSTR(0), ARGSTR(1)) == 0;
+        } else if (TY(0) == TY_DIR && TY(1) == TY_DIR)
+                RESULTINT = ARGDIR(0) == ARGDIR(1);
+        else if (TY(0) == TY_ENTITY && TY(1) == TY_ENTITY)
+                RESULTINT = ARGENTITY(0) == ARGENTITY(1);
+        else if (TY(0) == TY_LOCATION && TY(1) == TY_LOCATION)
+                RESULTINT = (ARGLOCATION(0).x == ARGLOCATION(1).x
+                             && ARGLOCATION(0).y == ARGLOCATION(1).y
+                             && ARGLOCATION(0).m == ARGLOCATION(1).m);
+        else if (TY(0) == TY_AREA && TY(1) == TY_AREA)
+                RESULTINT = ARGAREA(0) == ARGAREA(1); /* Probably not that great an idea... */
+        else if (TY(0) == TY_SPELL && TY(1) == TY_SPELL)
+                RESULTINT = ARGSPELL(0) == ARGSPELL(1);
+        else if (TY(0) == TY_INVOCATION && TY(1) == TY_INVOCATION)
+                RESULTINT = ARGINVOCATION(0) == ARGINVOCATION(1);
+        else {
+                intify(&args[0]);
+                intify(&args[1]);
+                RESULTINT = ARGINT(0) == ARGINT(1);
+        }
+        return 0;
+}
+
+static int
+fun_bitand(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = ARGINT(0) & ARGINT(1);
+        return 0;
+}
+
+static int
+fun_bitor(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = ARGINT(0) | ARGINT(1);
+        return 0;
+}
+
+static int
+fun_bitxor(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = ARGINT(0) ^ ARGINT(1);
+        return 0;
+}
+
+static int
+fun_bitshl(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = ARGINT(0) << ARGINT(1);
+        return 0;
+}
+
+static int
+fun_bitshr(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = ARGINT(0) >> ARGINT(1);
+        return 0;
+}
+
+static int
+fun_max(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = MAX(ARGINT(0), ARGINT(1));
+        return 0;
+}
+
+static int
+fun_min(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = MIN(ARGINT(0), ARGINT(1));
+        return 0;
+}
+
+static int
+fun_if_then_else(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (ARGINT(0))
+                magic_copy_var(result, &args[1]);
+        else
+                magic_copy_var(result, &args[2]);
+        return 0;
+}
+
+void
+magic_area_rect(int *m, int *x, int *y, int *width, int *height, area_t *area)
+{
+        switch (area->ty) {
+        case AREA_UNION: break;
+
+        case AREA_LOCATION:
+                *m = area->a.a_loc.m;
+                *x = area->a.a_loc.x;
+                *y = area->a.a_loc.y;
+                *width = 1;
+                *height = 1;
+                break;
+
+        case AREA_RECT:
+                *m = area->a.a_rect.loc.m;
+                *x = area->a.a_rect.loc.x;
+                *y = area->a.a_rect.loc.y;
+                *width = area->a.a_rect.width;
+                *height = area->a.a_rect.height;
+                break;
+
+        case AREA_BAR: {
+                int tx = area->a.a_bar.loc.x;
+                int ty = area->a.a_bar.loc.y;
+                int twidth = area->a.a_bar.width;
+                int tdepth = area->a.a_bar.width;
+                *m = area->a.a_bar.loc.m;
+
+                switch (area->a.a_bar.dir) {
+                case DIR_S:
+                        *x = tx - twidth;
+                        *y = ty;
+                        *width = twidth * 2 + 1;
+                        *height = tdepth;
+                        break;
+
+                case DIR_W:
+                        *x = tx - tdepth;
+                        *y = ty - twidth;
+                        *width = tdepth;
+                        *height = twidth * 2 + 1;
+                        break;
+
+                case DIR_N:
+                        *x = tx - twidth;
+                        *y = ty - tdepth;
+                        *width = twidth * 2 + 1;
+                        *height = tdepth;
+                        break;
+
+                case DIR_E:
+                        *x = tx;
+                        *y = ty - twidth;
+                        *width = tdepth;
+                        *height = twidth * 2 + 1;
+                        break;
+
+                default:
+                        fprintf(stderr, "Error: Trying to compute area of NE/SE/NW/SW-facing bar");
+                        *x = tx; *y = ty; *width = *height = 1;
+                }
+                break;
+        }        
+        }
+}
+
+static int
+location_in_area(int m, int x, int y, area_t *area)
+{
+        switch (area->ty) {
+        case AREA_UNION:
+                return location_in_area(m, x, y, area->a.a_union[0])
+                        || location_in_area(m, x, y, area->a.a_union[1]);
+        case AREA_LOCATION:
+        case AREA_RECT:
+        case AREA_BAR: {
+                int am;
+                int ax, ay, awidth, aheight;
+                magic_area_rect(&am, &ax, &ay, &awidth, &aheight, area);
+                return (am == m
+                        && (x >= ax) && (y >= ay)
+                        && (x < ax + awidth) && (y < ay + aheight));
+        }
+        default:
+                fprintf(stderr, "INTERNAL ERROR: Invalid area\n");
+                return 0;
+        }
+}
+
+
+static int
+fun_is_in(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = location_in_area(ARGLOCATION(0).m,
+                                     ARGLOCATION(0).x,
+                                     ARGLOCATION(0).y,
+                                     ARGAREA(1));
+        return 0;
+}
+
+static int
+fun_skill(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (ETY(0) != BL_PC
+            || ARGINT(1) < 0
+            || ARGINT(1) >= MAX_SKILL
+            || ARGPC(0)->status.skill[ARGINT(1)].id != ARGINT(1))
+                RESULTINT = 0;
+        else
+                RESULTINT = ARGPC(0)->status.skill[ARGINT(1)].lv;
+        return 0;
+}
+
+static int
+fun_has_shroud(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = (ETY(0) == BL_PC
+                     && ARGPC(0)->state.shroud_active);
+        return 0;
+}
+
+#define BATTLE_GETTER(name) static int fun_get_##name(env_t *env, int args_nr, val_t *result, val_t *args) { RESULTINT = battle_get_##name(ARGENTITY(0)); return 0; }
+
+BATTLE_GETTER(str);
+BATTLE_GETTER(agi);
+BATTLE_GETTER(vit);
+BATTLE_GETTER(dex);
+BATTLE_GETTER(luk);
+BATTLE_GETTER(int);
+BATTLE_GETTER(lv);
+BATTLE_GETTER(hp);
+BATTLE_GETTER(max_hp);
+BATTLE_GETTER(dir);
+
+#define MMO_GETTER(name) static int fun_get_##name(env_t *env, int args_nr, val_t *result, val_t *args) {	\
+                if (ETY(0) == BL_PC)								\
+                	RESULTINT = ARGPC(0)->status.name;					\
+		else										\
+		        RESULTINT = 0;								\
+		return 0; }									
+
+MMO_GETTER(sp);
+MMO_GETTER(max_sp);
+
+static int
+fun_name_of(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (TY(0) == TY_ENTITY) {
+                RESULTSTR = strdup(show_entity(ARGENTITY(0)));
+                return 0;
+        } else if (TY(0) == TY_SPELL) {
+                RESULTSTR = strdup(ARGSPELL(0)->name);
+                return 0;
+        } else if (TY(0) == TY_INVOCATION) {
+                RESULTSTR = strdup(ARGINVOCATION(0)->spell->name);
+                return 0;
+        }
+        return 1;
+}
+
+#define COPY_LOCATION(dest, src) (dest).x = (src).x; (dest).y = (src).y; (dest).m = (src).m;
+
+static int
+fun_location(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        COPY_LOCATION(RESULTLOCATION, *(ARGENTITY(0)));
+        return 0;
+}
+
+/* Recall that glibc's rand() isnt' too bad in the lower bits */
+
+static int
+fun_random(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        int delta = ARGINT(0);
+        if (delta < 0)
+                delta = -delta;
+        if (delta == 0) {
+                RESULTINT = 0;
+                return 0;
+        }
+        RESULTINT = rand() % delta;
+        if (ARGINT(0) < 0)
+                RESULTINT = -RESULTINT;
+        return 0;
+}
+
+static int
+fun_random_dir(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (ARGINT(0))
+                RESULTDIR = rand() & 0x7;
+        else
+                RESULTDIR = (rand() & 0x3) * 2;
+        return 0;
+}
+
+static int
+fun_hash_entity(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = ARGENTITY(0)->id;
+        return 0;
+}
+
+static int
+fun_count_item(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        character_t *chr = (ETY(0) == BL_PC) ? ARGPC(0) : NULL;
+        int item_id;
+
+        if (TY(1) == TY_INT)
+                item_id = ARGINT(1);
+        else if (TY(1) == TY_STRING) {
+                struct item_data *bitem = itemdb_searchname(ARGSTR(1));
+                if (!bitem) {
+                        fprintf(stderr, "Unknown item `%s' used in spell\n", ARGSTR(1));
+                        return 1;
+                } else
+                        item_id = bitem->nameid;
+        } else
+                return 0;
+
+        if (!chr)
+                return 1;
+
+        RESULTINT = pc_count_all_items(chr, item_id);
+        return 0;
+}
+
+
+static int
+fun_is_married(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = (ETY(0) == BL_PC
+                     && ARGPC(0)->status.partner_id);
+        return 0;
+}
+
+static int
+fun_partner(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (ETY(0) == BL_PC
+            && ARGPC(0)->status.partner_id) {
+                RESULTENTITY = (entity_t *) map_nick2sd(map_charid2nick(ARGPC(0)->status.partner_id));
+                return 0;
+        } else
+                return 1;
+}
+
+static int
+fun_awayfrom(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        location_t *loc = &ARGLOCATION(0);
+        int dx = heading_x[ARGDIR(1)];
+        int dy = heading_y[ARGDIR(1)];
+        int distance = ARGINT(2);
+        while (distance-- && !map_is_solid(loc->m, loc->x, loc->y)) {
+                loc->x += dx;
+                loc->y += dy;
+        }
+
+        RESULTLOCATION = *loc;
+        return 0;
+}
+
+static int
+fun_failed(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = TY(0) == TY_FAIL;
+        return 0;
+}
+
+static int
+fun_npc(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTENTITY = (entity_t *)npc_name2id(ARGSTR(0));
+        return RESULTENTITY == NULL;
+}
+
+static int
+fun_pc(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTENTITY = (entity_t *)map_nick2sd(ARGSTR(0));
+        return RESULTENTITY == NULL;
+}
+
+static int
+fun_distance(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (ARGLOCATION(0).m != ARGLOCATION(1).m)
+                RESULTINT = INT_MAX;
+        else
+                RESULTINT = MAX(abs(ARGLOCATION(0).x - ARGLOCATION(1).x),
+                                abs(ARGLOCATION(0).y - ARGLOCATION(1).y));
+        return 0;
+}
+
+
+static int
+fun_rdistance(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (ARGLOCATION(0).m != ARGLOCATION(1).m)
+                RESULTINT = INT_MAX;
+        else {
+                int dx = ARGLOCATION(0).x - ARGLOCATION(1).x;
+                int dy = ARGLOCATION(0).y - ARGLOCATION(1).y;
+                RESULTINT = (int) (sqrt((dx*dx) + (dy*dy)));
+        }
+        return 0;
+}
+
+
+static int
+fun_anchor(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        teleport_anchor_t *anchor = magic_find_anchor(ARGSTR(0));
+
+        if (!anchor)
+                return 1;
+
+        magic_eval(env, result, anchor->location);
+
+        make_area(result);
+        if (result->ty != TY_AREA) {
+                magic_clear_var(result);
+                return 1;
+        } 
+
+        return 0;
+}
+
+
+
+static int
+fun_line_of_sight(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        entity_t e1, e2;
+
+        COPY_LOCATION(e1, ARGLOCATION(0));
+        COPY_LOCATION(e2, ARGLOCATION(1));
+
+        RESULTINT = battle_check_range(&e1, &e2, 0);
+
+        return 0;
+}
+
+void
+magic_random_location(location_t *dest, area_t *area)
+{
+        switch (area->ty) {
+        case AREA_UNION: {
+                int rv = rand() % area->size;
+                if (rv < area->a.a_union[0]->size)
+                        magic_random_location(dest, area->a.a_union[0]);
+                else
+                        magic_random_location(dest, area->a.a_union[1]);
+                break;
+        }
+
+        case AREA_LOCATION:
+        case AREA_RECT:
+        case AREA_BAR: {
+                int m, x, y, w, h;
+                magic_area_rect(&m, &x, &y, &w, &h, area);
+
+                if (w <= 1)
+                        w = 1;
+
+                if (h <= 1)
+                        h = 1;
+
+                x += rand() % w;
+                y += rand() % h;
+
+                if (!map_is_solid(m, x, y)) {
+                        int start_x = x;
+                        int start_y = y;
+                        int i;
+                        int initial_dir = rand() & 0x7;
+                        int dir = initial_dir;
+
+                        /* try all directions, up to a distance to 10, for a free slot */
+                        do {
+                                x = start_x;
+                                y = start_y;
+
+                                for (i = 0; i < 10 && map_is_solid(m, x, y); i++) {
+                                        x += heading_x[dir];
+                                        y += heading_y[dir];
+                                }
+
+                                dir = (dir + 1) & 0x7;
+                        } while (map_is_solid(m, x, y) && dir != initial_dir);
+
+                }
+                /* We've tried our best.  If the map is still solid, the engine will automatically randomise the target location if we try to warp. */
+
+                dest->m = m;
+                dest->x = x;
+                dest->y = y;
+                break;
+        }
+
+        default:
+                fprintf(stderr, "Unknown area type %d\n", area->ty);
+        }
+}
+
+static int
+fun_pick_location(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        magic_random_location(&result->v.v_location, ARGAREA(0));
+        return 0;
+}
+
+static int
+fun_read_script_int(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        entity_t *subject_p = ARGENTITY(0);
+        char *var_name = ARGSTR(1);
+
+        if (subject_p->type != BL_PC)
+                return 1;
+
+        RESULTINT = pc_readglobalreg((character_t *) subject_p, var_name);
+        return 0;
+}
+
+static int
+fun_rbox(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        location_t loc = ARGLOCATION(0);
+        int radius = ARGINT(1);
+
+        RESULTAREA = area_new(AREA_RECT);
+        RESULTAREA->a.a_rect.loc.m = loc.m;
+        RESULTAREA->a.a_rect.loc.x = loc.x - radius;
+        RESULTAREA->a.a_rect.loc.y = loc.y - radius;
+        RESULTAREA->a.a_rect.width = radius * 2 + 1;
+        RESULTAREA->a.a_rect.height = radius * 2 + 1;
+
+        return 0;
+}
+
+static int
+fun_running_status_update(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        if (ETY(0) != BL_PC)
+                return 1;
+
+        RESULTINT = battle_get_sc_data(ARGENTITY(0))[ARGINT(1)].timer != -1;
+        return 0;
+}
+
+static int
+fun_element(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = battle_get_element(ARGENTITY(0)) % 10;
+        return 0;
+}
+
+static int
+fun_element_level(env_t *env, int args_nr, val_t *result, val_t *args)
+{
+        RESULTINT = battle_get_element(ARGENTITY(0)) / 10;
+        return 0;
+}
+
+#define BATTLE_RECORD2(sname, name) { sname, "e", 'i', fun_get_##name }
+#define BATTLE_RECORD(name) BATTLE_RECORD2(#name, name)
+static fun_t functions[] = {
+        { "+", "..", '.', fun_add },
+        { "-", "ii", 'i', fun_sub },
+        { "*", "ii", 'i', fun_mul },
+        { "/", "ii", 'i', fun_div },
+        { "%", "ii", 'i', fun_mod },
+        { "||", "ii", 'i', fun_or },
+        { "&&", "ii", 'i', fun_and },
+        { ">", "..", 'i', fun_gt },
+        { ">=", "..", 'i', fun_gte },
+        { "=", "..", 'i', fun_eq },
+        { "|", "..", 'i', fun_bitor },
+        { "&", "ii", 'i', fun_bitand },
+        { "^", "ii", 'i', fun_bitxor },
+        { "<<", "ii", 'i', fun_bitshl },
+        { ">>", "ii", 'i', fun_bitshr },
+        { "not", "i", 'i', fun_not },
+        { "max", "ii", 'i', fun_max },
+        { "min", "ii", 'i', fun_min },
+        { "is_in", "la", 'i', fun_is_in },
+        { "if_then_else", "i__", '_', fun_if_then_else },
+        { "skill", "ei", 'i', fun_skill },
+        BATTLE_RECORD(str),
+        BATTLE_RECORD(agi),
+        BATTLE_RECORD(vit),
+        BATTLE_RECORD(dex),
+        BATTLE_RECORD(luk),
+        BATTLE_RECORD(int),
+        BATTLE_RECORD2("level", lv),
+        BATTLE_RECORD(hp),
+        BATTLE_RECORD(max_hp),
+        BATTLE_RECORD(sp),
+        BATTLE_RECORD(max_sp),
+        { "dir", "e", 'd', fun_get_dir },
+        { "name_of", ".", 's', fun_name_of },
+        { "location", "e", 'l', fun_location },
+        { "random", "i", 'i', fun_random },
+        { "random_dir", "i", 'd', fun_random_dir },
+        { "hash_entity", "e", 'i', fun_hash_entity },
+        { "is_married", "e", 'i', fun_is_married },
+        { "partner", "e", 'e', fun_partner },
+        { "awayfrom", "ldi", 'l', fun_awayfrom },
+        { "failed", "_", 'i', fun_failed },
+        { "pc", "s", 'e', fun_pc },
+        { "npc", "s", 'e', fun_npc },
+        { "distance", "ll", 'i', fun_distance },
+        { "rdistance", "ll", 'i', fun_rdistance },
+        { "anchor", "s", 'a', fun_anchor },
+        { "random_location", "a", 'l', fun_pick_location },
+        { "script_int", "es", 'i', fun_read_script_int },
+        { "rbox", "li", 'a', fun_rbox },
+        { "count_item", "e.", 'i', fun_count_item },
+        { "line_of_sight", "ll", 'i', fun_line_of_sight },
+        { "running_status_update", "ei", 'i', fun_running_status_update },
+        { "element", "e", 'i', fun_element },
+        { "element_level", "e", 'i', fun_element_level },
+        { "has_shroud", "e", 'i', fun_has_shroud },
+        { NULL, NULL, '.', NULL }
+};
+
+static int functions_are_sorted = 0;
+
+int
+compare_fun(const void *lhs, const void *rhs)
+{
+        return strcmp(((fun_t *)lhs)->name,
+                      ((fun_t *)rhs)->name);
+}
+
+fun_t *
+magic_get_fun(char *name, int *index)
+{
+        static int functions_nr;
+        fun_t *result;
+        fun_t key;
+
+        if (!functions_are_sorted) {
+                fun_t *it = functions;
+
+                while (it->name) ++it;
+                functions_nr = it - functions;
+                
+                qsort(functions, functions_nr, sizeof(fun_t),
+                      compare_fun);
+                functions_are_sorted = 1;
+        }
+
+        key.name = name;
+        result = (fun_t *) bsearch(&key, functions, functions_nr, sizeof(fun_t),
+                                   compare_fun);
+
+        if (result && index)
+                *index = result - functions;
+
+        return result;
+}
+
+static int // 1 on failure
+eval_location(env_t *env, location_t *dest, e_location_t *expr)
+{
+        val_t m, x, y;
+        magic_eval(env, &m, expr->m);
+        magic_eval(env, &x, expr->x);
+        magic_eval(env, &y, expr->y);
+
+        if (CHECK_TYPE(&m, TY_STRING)
+            && CHECK_TYPE(&x, TY_INT)
+            && CHECK_TYPE(&y, TY_INT)) {
+                int map_id = map_mapname2mapid(m.v.v_string);
+                magic_clear_var(&m);
+                if (map_id < 0)
+                        return 1;
+                dest->m = map_id;
+                dest->x = x.v.v_int;
+                dest->y = y.v.v_int;
+                return 0;
+        } else {
+                magic_clear_var(&m);
+                magic_clear_var(&x);
+                magic_clear_var(&y);
+                return 1;
+        }
+}
+
+static area_t *
+eval_area(env_t *env, e_area_t *expr)
+{
+        area_t *area = malloc(sizeof(area_t));
+        area->ty = expr->ty;
+
+        switch (expr->ty) {
+        case AREA_LOCATION:
+                area->size = 1;
+                if (eval_location(env, &area->a.a_loc, &expr->a.a_loc)) {
+                        free(area);
+                        return NULL;
+                } else
+                        return area;
+
+        case AREA_UNION: {
+                int i, fail = 0;
+                for (i = 0; i < 2; i++) {
+                        area->a.a_union[i] = eval_area(env, expr->a.a_union[i]);
+                        if (!area->a.a_union[i])
+                                fail = 1;
+                }
+
+                if (fail) {
+                        for (i = 0; i < 2; i++) {
+                                if (area->a.a_union[i])
+                                        free_area(area->a.a_union[i]);
+                        }
+                        free(area);
+                        return NULL;
+                }
+                area->size = area->a.a_union[0]->size + area->a.a_union[1]->size;
+                return area;
+        }
+
+        case AREA_RECT: {
+                val_t width, height;
+                magic_eval(env, &width, expr->a.a_rect.width);
+                magic_eval(env, &height, expr->a.a_rect.height);
+
+                area->a.a_rect.width = width.v.v_int;
+                area->a.a_rect.height = height.v.v_int;
+
+                if (CHECK_TYPE(&width, TY_INT)
+                    && CHECK_TYPE(&height, TY_INT)
+                    && !eval_location (env, &(area->a.a_rect.loc), &expr->a.a_rect.loc)) {
+                        area->size = area->a.a_rect.width * area->a.a_rect.height;
+                        magic_clear_var(&width);
+                        magic_clear_var(&height);
+                        return area;
+                } else {
+                        free(area);
+                        magic_clear_var(&width);
+                        magic_clear_var(&height);
+                        return NULL;
+                }
+        }
+
+        case AREA_BAR: {
+                val_t width, depth, dir;
+                magic_eval(env, &width, expr->a.a_bar.width);
+                magic_eval(env, &depth, expr->a.a_bar.depth);
+                magic_eval(env, &dir, expr->a.a_bar.dir);
+
+                area->a.a_bar.width = width.v.v_int;
+                area->a.a_bar.depth = depth.v.v_int;
+                area->a.a_bar.dir = dir.v.v_int;
+
+                if (CHECK_TYPE(&width, TY_INT)
+                    && CHECK_TYPE(&depth, TY_INT)
+                    && CHECK_TYPE(&dir, TY_DIR)
+                    && !eval_location (env, &area->a.a_bar.loc, &expr->a.a_bar.loc)) {
+                        area->size = (area->a.a_bar.width * 2 + 1) * area->a.a_bar.depth;
+                        magic_clear_var(&width);
+                        magic_clear_var(&depth);
+                        magic_clear_var(&dir);
+                        return area;
+                } else {
+                        free(area);
+                        magic_clear_var(&width);
+                        magic_clear_var(&depth);
+                        magic_clear_var(&dir);
+                        return NULL;
+                }
+        }
+
+        default:
+                fprintf(stderr, "INTERNAL ERROR: Unknown area type %d\n", area->ty);
+                free(area);
+                return NULL;
+        }
+}
+
+static int
+type_key(char ty_key)
+{
+        switch (ty_key) {
+        case 'i': return TY_INT;
+        case 'd': return TY_DIR;
+        case 's': return TY_STRING;
+        case 'e': return TY_ENTITY;
+        case 'l': return TY_LOCATION;
+        case 'a': return TY_AREA;
+        case 'S': return TY_SPELL;
+        case 'I': return TY_INVOCATION;
+        default: return -1;
+        }
+}
+
+int
+magic_signature_check(char *opname, char *funname, char *signature, int args_nr, val_t *args, int line, int column)
+{
+        int i;
+        for (i = 0; i < args_nr; i++) {
+                val_t *arg = &args[i];
+                char ty_key = signature[i];
+                int ty = arg->ty;
+                int desired_ty = type_key(ty_key);
+
+                if (ty == TY_ENTITY) {
+                        /* Dereference entities in preparation for calling function */
+                        arg->v.v_entity = map_id2bl(arg->v.v_int);
+                        if (!arg->v.v_entity)
+                                ty = arg->ty = TY_FAIL;
+                } else if (ty == TY_INVOCATION) {
+                        arg->v.v_invocation = (invocation_t *) map_id2bl(arg->v.v_int);
+                        if (!arg->v.v_entity)
+                                ty = arg->ty = TY_FAIL;
+                }
+
+                if (!ty_key) {
+                        fprintf(stderr, "[magic-eval]:  L%d:%d: Too many arguments (%d) to %s `%s'\n",
+                                line, column, args_nr, opname, funname);
+                        return 1;
+                }
+
+                if (ty == TY_FAIL
+                    && ty_key != '_')
+                        return 1; /* Fail `in a sane way':  This is a perfectly permissible error */
+
+                if (ty == desired_ty
+                    || desired_ty < 0 /* `dontcare' */)
+                        continue;
+
+                if (ty == TY_UNDEF) {
+                        fprintf(stderr, "[magic-eval]:  L%d:%d: Argument #%d to %s `%s' undefined\n",
+                                line, column, i + 1, opname, funname);
+                        return 1;
+                }
+
+                /* If we are here, we have a type mismatch but no failure _yet_.  Try to coerce. */
+                switch (desired_ty) {
+                case TY_INT:	intify(arg); break; /* 100% success rate */
+                case TY_STRING:	stringify(arg, 1); break; /* 100% success rate */
+                case TY_AREA:	make_area(arg); break; /* Only works for locations */
+                case TY_LOCATION: make_location(arg); break; /* Only works for some areas */
+                default: break; /* We'll fail right below */
+                }
+
+                ty = arg->ty;
+                if (ty != desired_ty) { /* Coercion failed? */
+                        if (ty != TY_FAIL)
+                                fprintf(stderr, "[magic-eval]:  L%d:%d: Argument #%d to %s `%s' of incorrect type (%d)\n",
+                                        line, column, i + 1, opname, funname, ty);
+                        return 1;
+                }
+        }
+
+        return 0;
+}
+
+void
+magic_eval(env_t *env, val_t *dest, expr_t *expr)
+{
+        switch (expr->ty) {
+        case EXPR_VAL:
+                magic_copy_var(dest, &expr->e.e_val);
+                break;
+
+        case EXPR_LOCATION:
+                if (eval_location(env, &dest->v.v_location, &expr->e.e_location))
+                        dest->ty = TY_FAIL;
+                else
+                        dest->ty = TY_LOCATION;
+                break;
+
+        case EXPR_AREA:
+                if ((dest->v.v_area = eval_area(env, &expr->e.e_area)))
+                        dest->ty = TY_AREA;
+                else
+                        dest->ty = TY_FAIL;
+                break;
+
+        case EXPR_FUNAPP: {
+                val_t arguments[MAX_ARGS];
+                int args_nr = expr->e.e_funapp.args_nr;
+                int i;
+                fun_t *f = functions + expr->e.e_funapp.id;
+
+                for (i = 0; i < args_nr; ++i)
+                        magic_eval(env, &arguments[i], expr->e.e_funapp.args[i]);
+                if (magic_signature_check("function", f->name, f->signature, args_nr, arguments,
+                                          expr->e.e_funapp.line_nr, expr->e.e_funapp.column)
+                    || f->fun(env, args_nr, dest, arguments))
+                        dest->ty = TY_FAIL;
+                else {
+                        int dest_ty = type_key(f->ret_ty);
+                        if (dest_ty != -1)
+                                dest->ty = dest_ty;
+
+                        /* translate entity back into persistent int */
+                        if (dest->ty == TY_ENTITY) {
+                                if (dest->v.v_entity)
+                                        dest->v.v_int = dest->v.v_entity->id;
+                                else
+                                        dest->ty = TY_FAIL;
+                        }
+                }
+
+                for (i = 0; i < args_nr; ++i)
+                        magic_clear_var(&arguments[i]);
+                break;
+        }
+
+        case EXPR_ID: {
+                val_t v = VAR(expr->e.e_id);
+                magic_copy_var(dest, &v);
+                break;
+        }
+
+        default:
+                fprintf(stderr, "INTERNAL ERROR: Unknown expression type %d\n", expr->ty);
+                break;
+        }
+}
+
+int
+magic_eval_int(env_t *env, expr_t *expr)
+{
+        val_t result;
+        magic_eval(env, &result, expr);
+
+        if (result.ty == TY_FAIL
+            || result.ty == TY_UNDEF)
+                return 0;
+
+        intify(&result);
+
+        return result.v.v_int;
+}
+
+char *
+magic_eval_str(env_t *env, expr_t *expr)
+{
+        val_t result;
+        magic_eval(env, &result, expr);
+
+        if (result.ty == TY_FAIL
+            || result.ty == TY_UNDEF)
+                return strdup("?");
+
+        stringify(&result, 0);
+
+        return result.v.v_string;
+}
+
+expr_t *
+magic_new_expr(int ty)
+{
+        expr_t *expr = (expr_t *)malloc(sizeof(expr_t));
+        expr->ty = ty;
+        return expr;
+}
diff --git a/src/map/magic-expr.h b/src/map/magic-expr.h
new file mode 100644
index 0000000..5f58d3c
--- /dev/null
+++ b/src/map/magic-expr.h
@@ -0,0 +1,92 @@
+#ifndef MAGIC_EXPR_H_
+#define MAGIC_EXPR_H_
+#include "magic-interpreter.h"
+#include "magic-interpreter-aux.h"
+
+#ifndef MAX
+#  define MAX(x,y) (((x)>(y)) ? (x) : (y))
+#endif
+#ifndef MIN
+#  define MIN(x,y) (((x)<(y)) ? (x) : (y))
+#endif
+
+#ifndef INT_MAX
+#  define INT_MAX (1<<30) // It's more than that, but this is quite sufficient for our purposes.
+#endif
+
+/*
+ * Argument types:
+ *  i : int
+ *  d : dir
+ *  s : string
+ *  e : entity
+ *  l : location
+ *  a : area
+ *  S : spell
+ *  I : invocation
+ *  . : any, except for fail/undef
+ *  _ : any, including fail, but not undef
+ */
+typedef struct fun {
+        char *name;
+        char *signature;
+        char ret_ty;
+        int (*fun)(env_t *env, int args_nr, val_t *result, val_t *args);
+} fun_t;
+
+typedef struct op {
+        char *name;
+        char *signature;
+        int (*op)(env_t *env, int args_nr, val_t *args);
+} op_t;
+
+/**
+ * Retrieves a function by name
+ * @param name The name to look up
+ * @return A function of that name, or NULL, and a function index
+ */
+fun_t *
+magic_get_fun(char *name, int *index);
+
+/**
+ * Retrieves an operation by name
+ * @param name The name to look up
+ * @return An operation of that name, or NULL, and a function index
+ */
+op_t *
+magic_get_op(char *name, int *index);
+
+/**
+ * Evaluates an expression and stores the result in `dest'
+ */
+void
+magic_eval(env_t *env, val_t *dest, expr_t *expr);
+
+/**
+ * Evaluates an expression and coerces the result into an integer
+ */
+int
+magic_eval_int(env_t *env, expr_t *expr);
+
+/**
+ * Evaluates an expression and coerces the result into a string
+ */
+char *
+magic_eval_str(env_t *env, expr_t *expr);
+
+int
+map_is_solid(int m, int x, int y);
+
+expr_t *
+magic_new_expr(int ty);
+
+void
+magic_clear_var(val_t *v);
+
+void
+magic_copy_var(val_t *dest, val_t *src);
+
+void
+magic_random_location(location_t *dest, area_t *area);
+
+#endif /* !defined(MAGIC_EXPR_H_) */
\ No newline at end of file
diff --git a/src/map/magic-interpreter-aux.h b/src/map/magic-interpreter-aux.h
new file mode 100644
index 0000000..975e502
--- /dev/null
+++ b/src/map/magic-interpreter-aux.h
@@ -0,0 +1,8 @@
+#ifndef MAGIC_INTERPRETER_AUX_H_
+#define MAGIC_INTERPRETER_AUX_H_
+
+#define CHECK_TYPE(v, t) ((v)->ty == t)
+
+#define VAR(i) ((!env->vars || env->vars[i].ty == TY_UNDEF)? env->base_env->vars[i] : env->vars[i])
+
+#endif /* !defined(MAGIC_INTERPRETER_AUX_H_) */
diff --git a/src/map/magic-interpreter-base.c b/src/map/magic-interpreter-base.c
new file mode 100644
index 0000000..9be6f81
--- /dev/null
+++ b/src/map/magic-interpreter-base.c
@@ -0,0 +1,540 @@
+#include "magic.h"
+#include "magic-interpreter.h"
+#include "magic-expr.h"
+#include "magic-interpreter-aux.h"
+
+static void
+set_int_p(val_t *v, int i, int t)
+{
+        v->ty = t;
+        v->v.v_int = i;
+}
+#define set_int(v, i) set_int_p(v, i, TY_INT)
+#define set_dir(v, i) set_int_p(v, i, TY_DIR)
+
+#define SETTER(tty, dyn_ty, field) (val_t *v, tty x) { v->ty = dyn_ty; v->v.field = x; }
+
+static void
+set_string SETTER(char *, TY_STRING, v_string);
+
+static void
+set_entity(val_t *v, entity_t *e)
+{
+        v->ty = TY_ENTITY;
+        v->v.v_int = e->id;
+}
+
+static void
+set_invocation(val_t *v, invocation_t *i)
+{
+        v->ty = TY_INVOCATION;
+        v->v.v_int = i->bl.id;
+}
+
+static void
+set_spell SETTER(spell_t *, TY_SPELL, v_spell);
+
+#define setenv(f, v, x) f(&(env->vars[v]), x)
+
+#define set_env_int(v, x) setenv(set_int, v, x)
+#define set_env_dir(v, x) setenv(set_dir, v, x)
+#define set_env_string(v, x) setenv(set_string, v, x)
+#define set_env_entity(v, x) setenv(set_entity, v, x)
+#define set_env_location(v, x) setenv(set_location, v, x)
+#define set_env_area(v, x) setenv(set_area, v, x)
+#define set_env_invocation(v, x) setenv(set_invocation, v, x)
+#define set_env_spell(v, x) setenv(set_spell, v, x)
+
+
+
+magic_conf_t magic_conf; /* Global magic conf */
+env_t magic_default_env = { &magic_conf, NULL };
+
+static int spells_sorted = 0;
+
+char *
+magic_find_invocation(char *spellname)
+{
+        int i;
+
+        for (i = 0; i < abs(magic_conf.spells_nr); i++)
+                if (!strcmp(magic_conf.spells[i]->name, spellname))
+                        return magic_conf.spells[i]->invocation;
+
+        return NULL;
+}
+
+static int
+spell_compare(const void *lhs, const void *rhs)
+{
+        return strcmp((*((spell_t **)lhs))->invocation,
+                      (*((spell_t **)rhs))->invocation);
+}
+
+spell_t *
+magic_find_spell(char *invocation)
+{
+        spell_t key;
+        spell_t *keyp = &key;
+        spell_t **retval;
+
+        if (!spells_sorted) {
+                qsort(magic_conf.spells, magic_conf.spells_nr, sizeof(spell_t *), spell_compare);
+                spells_sorted = 1;
+        }
+
+        key.invocation = invocation;
+
+        retval = ((spell_t **)bsearch(&keyp, magic_conf.spells, magic_conf.spells_nr, sizeof(spell_t *), spell_compare));
+
+        if (!retval)
+                return NULL;
+        else
+                return *retval;
+}
+
+
+/* -------------------------------------------------------------------------------- */
+/* Spell anchors */
+/* -------------------------------------------------------------------------------- */
+
+static int
+compare_teleport_anchor(const void * lhs, const void *rhs)
+{
+        return strcmp((*((teleport_anchor_t **)lhs))->invocation,
+                      (*((teleport_anchor_t **)rhs))->invocation);
+}
+      
+char *
+magic_find_anchor_invocation(char *anchor_name)
+{
+        int i;
+
+        for (i = 0; i < abs(magic_conf.anchors_nr); i++)
+                if (!strcmp(magic_conf.anchors[i]->name, anchor_name))
+                        return magic_conf.anchors[i]->invocation;
+
+        return NULL;
+}
+
+
+teleport_anchor_t *
+magic_find_anchor(char *name)
+{
+        teleport_anchor_t key;
+        teleport_anchor_t *keyp = &key;
+        teleport_anchor_t **retval;
+
+        if (magic_conf.anchors_nr > 0) { /* unsorted */
+                qsort(magic_conf.anchors, magic_conf.anchors_nr, sizeof(teleport_anchor_t *),
+                      compare_teleport_anchor);
+                magic_conf.anchors_nr = -magic_conf.anchors_nr;
+        }
+
+        key.invocation = name;
+
+        retval = (teleport_anchor_t **) bsearch(&keyp,
+                                                magic_conf.anchors, -magic_conf.anchors_nr, sizeof(teleport_anchor_t *),
+                                                compare_teleport_anchor);
+
+        if (!retval)
+                return NULL;
+        else
+                return *retval;
+}
+
+
+/* -------------------------------------------------------------------------------- */
+/* Spell guard checks */
+/* -------------------------------------------------------------------------------- */
+
+static env_t *
+alloc_env(magic_conf_t *conf)
+{
+        env_t *env = (env_t*) aCalloc(sizeof (env_t), 1);
+        env->vars = (val_t *) aCalloc(sizeof (val_t), conf->vars_nr);
+        env->base_env = conf;
+        return env;
+}
+
+static env_t *
+clone_env(env_t *src)
+{
+        env_t *retval = alloc_env(src->base_env);
+        int i;
+
+        for (i = 0; i < src->base_env->vars_nr; i++)
+                magic_copy_var(&retval->vars[i],
+                               &src->vars[i]);
+
+        return retval;
+}
+
+void
+magic_free_env(env_t *env)
+{
+        int i;
+        for (i = 0; i < env->base_env->vars_nr; i++)
+                magic_clear_var(&env->vars[i]);
+        free(env);
+}
+
+env_t *
+spell_create_env(magic_conf_t *conf, spell_t *spell, character_t *caster, int spellpower, char *param)
+{
+        env_t *env = alloc_env(conf);
+
+        switch (spell->spellarg_ty) {
+
+        case SPELLARG_STRING:
+                set_env_string(spell->arg, param);
+                break;
+
+        case SPELLARG_PC:{
+                character_t *subject = map_nick2sd(param);
+                if (!subject)
+                        subject = caster;
+                set_env_entity(spell->arg, &subject->bl);
+                free(param);
+                break;
+        }
+
+        case SPELLARG_NONE:
+                break;
+        default:
+                fprintf(stderr, "Unexpected spellarg type %d\n", spell->spellarg_ty);
+        }
+
+        set_env_entity(VAR_CASTER, &caster->bl);
+        set_env_int(VAR_SPELLPOWER, spellpower);
+        set_env_spell(VAR_SPELL, spell);
+
+        return env;
+}
+
+
+
+static void
+free_components(component_t **component_holder)
+{
+        if (*component_holder == NULL)
+                return;
+        free_components(&(*component_holder)->next);
+        free(*component_holder);
+        *component_holder = NULL;
+}
+
+void
+magic_add_component(component_t **component_holder, int id, int count)
+{
+        if (count <= 0)
+                return;
+
+        if (*component_holder == NULL) {
+                component_t *component = (component_t *)malloc(sizeof(component_t));
+                component->next = NULL;
+                component->item_id = id;
+                component->count = count;
+                *component_holder = component;
+        } else {
+                component_t *component = *component_holder;
+                if (component->item_id == id) {
+                        component->count += count;
+                        return;
+                } else magic_add_component(&component->next, id, count);
+                /* Tail-recurse; gcc can optimise this.  Not that it matters. */
+        }
+}
+
+static void
+copy_components(component_t **component_holder, component_t *component)
+{
+        if (component == NULL)
+                return;
+
+        magic_add_component(component_holder, component->item_id, component->count);
+        copy_components(component_holder, component->next);
+}
+
+
+typedef struct spellguard_check {
+        component_t *catalysts, *components;
+        int mana, casttime;
+} spellguard_check_t;
+
+
+static int
+check_prerequisites(character_t *caster, component_t *component)
+{
+        while (component) {
+                if (pc_count_all_items(caster, component->item_id)
+                    < component->count)
+                        return 0; /* insufficient */
+
+                component = component->next;
+        }
+
+        return 1;
+}
+
+static void
+consume_components(character_t *caster, component_t *component)
+{
+        while (component) {
+                pc_remove_items(caster, component->item_id, component->count);
+                component = component->next;
+        }
+}
+
+
+static int
+spellguard_can_satisfy(spellguard_check_t *check, character_t *caster, env_t *env)
+{
+        int tick = gettick();
+
+        int retval = (caster->cast_tick <= tick /* Hasn't cast a spell too recently */
+                      && check->mana <= caster->status.sp
+                      && check_prerequisites(caster, check->catalysts)
+                      && check_prerequisites(caster, check->components));
+
+        if (retval) {
+                int casttime = check->casttime;
+
+                if (VAR(VAR_MIN_CASTTIME).ty == TY_INT)
+                        casttime = MAX(casttime, VAR(VAR_MIN_CASTTIME).v.v_int);
+
+                caster->cast_tick = tick + casttime; /* Make sure not to cast too frequently */
+
+                consume_components(caster, check->components);
+                pc_heal(caster, 0, -check->mana);
+        }
+
+        return retval;
+}
+
+static effect_set_t *
+spellguard_check_sub(spellguard_check_t *check, spellguard_t *guard, character_t *caster, env_t *env)
+{
+        if (guard == NULL)
+                return NULL;
+
+        switch (guard->ty) {
+        case SPELLGUARD_CONDITION:
+                if (!magic_eval_int(env, guard->s.s_condition))
+                        return NULL;
+                break;
+
+        case SPELLGUARD_COMPONENTS:
+                copy_components(&check->components, guard->s.s_components);
+                break;
+
+        case SPELLGUARD_CATALYSTS:
+                copy_components(&check->catalysts, guard->s.s_catalysts);
+                break;
+
+        case SPELLGUARD_CHOICE: {
+                spellguard_check_t altcheck = *check;
+                effect_set_t *retval;
+
+                altcheck.components = NULL;
+                altcheck.catalysts = NULL;
+
+                copy_components(&altcheck.catalysts, check->catalysts);
+                copy_components(&altcheck.components, check->components);
+
+                retval = spellguard_check_sub(&altcheck, guard->next, caster, env);
+                free_components(&altcheck.catalysts);
+                free_components(&altcheck.components);
+                if (retval)
+                        return retval;
+                else
+                    return spellguard_check_sub(check, guard->s.s_alt, caster, env);
+        }
+
+        case SPELLGUARD_MANA:
+                check->mana += magic_eval_int(env, guard->s.s_mana);
+                break;
+
+        case SPELLGUARD_CASTTIME:
+                check->casttime += magic_eval_int(env, guard->s.s_mana);
+                break;
+
+        case SPELLGUARD_EFFECT:
+                if (spellguard_can_satisfy(check, caster, env))
+                        return &guard->s.s_effect;
+                else
+                        return NULL;    
+
+        default:
+                fprintf(stderr, "Unexpected spellguard type %d\n", guard->ty);
+                return NULL;
+        }
+
+        return spellguard_check_sub(check, guard->next, caster, env);
+}
+
+static effect_set_t *
+check_spellguard(spellguard_t *guard, character_t *caster, env_t *env)
+{
+        spellguard_check_t check;
+        effect_set_t *retval;
+        check.catalysts = NULL;
+        check.components = NULL;
+        check.mana = check.casttime = 0;
+
+        retval = spellguard_check_sub(&check, guard, caster, env);
+
+        free_components(&check.catalysts);
+        free_components(&check.components);
+
+        return retval;
+}
+
+/* -------------------------------------------------------------------------------- */
+/* Public API */
+/* -------------------------------------------------------------------------------- */
+
+
+effect_set_t *
+spell_trigger(spell_t *spell, character_t *caster, env_t *env)
+{
+        int i;
+        spellguard_t *guard = spell->spellguard;
+
+        for (i = 0; i < spell->letdefs_nr; i++)
+                magic_eval(env,
+                           &env->vars[spell->letdefs[i].id],
+                           spell->letdefs[i].expr);
+
+        return check_spellguard(guard, caster, env);
+}
+
+static void
+spell_set_location(invocation_t *invocation, entity_t *entity)
+{
+        magic_clear_var(&invocation->env->vars[VAR_LOCATION]);
+        invocation->env->vars[VAR_LOCATION].ty = TY_LOCATION;
+        invocation->env->vars[VAR_LOCATION].v.v_location.m = entity->m;
+        invocation->env->vars[VAR_LOCATION].v.v_location.x = entity->x;
+        invocation->env->vars[VAR_LOCATION].v.v_location.y = entity->y;
+}
+
+void
+spell_update_location(invocation_t *invocation)
+{
+        if (invocation->spell->flags & SPELL_FLAG_LOCAL)
+                return;
+        else {
+                character_t *owner = (character_t *)map_id2bl(invocation->subject);
+                if (!owner)
+                        return;
+
+                spell_set_location(invocation, (entity_t *) owner);
+        }
+}
+
+invocation_t *
+spell_instantiate(effect_set_t *effect_set, env_t *env)
+{
+        invocation_t *retval = (invocation_t *)aCalloc(sizeof(invocation_t), 1);
+        entity_t *caster;
+
+        retval->env = env;
+
+        retval->caster = VAR(VAR_CASTER).v.v_int;
+        retval->spell = VAR(VAR_SPELL).v.v_spell;
+        retval->stack_size = 0;
+        retval->current_effect = effect_set->effect;
+        retval->trigger_effect = effect_set->at_trigger;
+        retval->end_effect = effect_set->at_end;
+
+        caster = map_id2bl(retval->caster); // must still exist
+	retval->bl.id = map_addobject(&retval->bl);
+	retval->bl.type = BL_SPELL;
+	retval->bl.m = caster->m;
+	retval->bl.x = caster->x;
+	retval->bl.y = caster->y;
+
+	map_addblock(&retval->bl);
+        set_env_invocation(VAR_INVOCATION, retval);
+
+        return retval;
+}
+
+invocation_t *
+spell_clone_effect(invocation_t *base)
+{
+        invocation_t *retval = (invocation_t *)malloc(sizeof(invocation_t));
+        env_t *env;
+
+        memcpy(retval, base, sizeof(invocation_t));
+
+        retval->env = clone_env(retval->env);
+        env = retval->env;
+        retval->current_effect = retval->trigger_effect;
+        retval->next_invocation = NULL;
+        retval->end_effect = NULL;
+        retval->script_pos = 0;
+        retval->stack_size = 0;
+        retval->timer = 0;
+        retval->subject = 0;
+        retval->status_change_refs_nr = 0;
+        retval->status_change_refs = NULL;
+        retval->flags = 0;
+
+        retval->bl.id = 0;
+        retval->bl.prev = NULL;
+        retval->bl.next = NULL;
+
+	retval->bl.id = map_addobject(&retval->bl);
+        set_env_invocation(VAR_INVOCATION, retval);
+
+        return retval;
+}
+
+
+void
+spell_bind(character_t *subject, invocation_t *invocation)
+{
+        /* Only bind nonlocal spells */
+
+        if (!(invocation->spell->flags & SPELL_FLAG_LOCAL)) {
+                if (invocation->flags & INVOCATION_FLAG_BOUND
+                    || invocation->subject
+                    || invocation->next_invocation) {
+                        int *i = NULL;
+                        fprintf(stderr, "[magic] INTERNAL ERROR: Attempt to re-bind spell invocation `%s'\n", invocation->spell->name);
+                        *i = 1;
+                        return;
+                }
+
+                invocation->next_invocation = subject->active_spells;
+                subject->active_spells = invocation;
+                invocation->flags |= INVOCATION_FLAG_BOUND;
+                invocation->subject = subject->bl.id;
+        }
+
+        spell_set_location(invocation, (entity_t*) subject);
+}
+
+int
+spell_unbind(character_t *subject, invocation_t *invocation)
+{
+        invocation_t **seeker = &subject->active_spells;
+
+        while (*seeker) {
+                if (*seeker == invocation) {
+                        *seeker = invocation->next_invocation;
+
+                        invocation->flags &= ~INVOCATION_FLAG_BOUND;
+                        invocation->next_invocation = NULL;
+                        invocation->subject = 0;
+
+                        return 0;
+                }
+                seeker = &((*seeker)->next_invocation);
+        }
+
+        return 1;
+}
+
diff --git a/src/map/magic-interpreter-lexer.c b/src/map/magic-interpreter-lexer.c
new file mode 100644
index 0000000..b5a42a0
--- /dev/null
+++ b/src/map/magic-interpreter-lexer.c
@@ -0,0 +1,2370 @@
+#line 2 "magic-interpreter-lexer.c"
+
+#line 4 "magic-interpreter-lexer.c"
+
+#define  YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define yy_create_buffer magic_frontend__create_buffer
+#define yy_delete_buffer magic_frontend__delete_buffer
+#define yy_flex_debug magic_frontend__flex_debug
+#define yy_init_buffer magic_frontend__init_buffer
+#define yy_flush_buffer magic_frontend__flush_buffer
+#define yy_load_buffer_state magic_frontend__load_buffer_state
+#define yy_switch_to_buffer magic_frontend__switch_to_buffer
+#define yyin magic_frontend_in
+#define yyleng magic_frontend_leng
+#define yylex magic_frontend_lex
+#define yylineno magic_frontend_lineno
+#define yyout magic_frontend_out
+#define yyrestart magic_frontend_restart
+#define yytext magic_frontend_text
+#define yywrap magic_frontend_wrap
+#define yyalloc magic_frontend_alloc
+#define yyrealloc magic_frontend_realloc
+#define yyfree magic_frontend_free
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+#define YY_FLEX_SUBMINOR_VERSION 35
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with  platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types. 
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t; 
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+#endif /* ! C99 */
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN               (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN              (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN              (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX               (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX              (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX              (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX              (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX             (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX             (4294967295U)
+#endif
+
+#endif /* ! FLEXINT_H */
+
+#ifdef __cplusplus
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+#else	/* ! __cplusplus */
+
+/* C99 requires __STDC__ to be defined as 1. */
+#if defined (__STDC__)
+
+#define YY_USE_CONST
+
+#endif	/* defined (__STDC__) */
+#endif	/* ! __cplusplus */
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN (yy_start) = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START (((yy_start) - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE magic_frontend_restart(magic_frontend_in  )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#define YY_BUF_SIZE 16384
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+extern int magic_frontend_leng;
+
+extern FILE *magic_frontend_in, *magic_frontend_out;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+    /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
+     *       access to the local variable yy_act. Since yyless() is a macro, it would break
+     *       existing scanners that call yyless() from OUTSIDE magic_frontend_lex. 
+     *       One obvious solution it to make yy_act a global. I tried that, and saw
+     *       a 5% performance hit in a non-magic_frontend_lineno scanner, because yy_act is
+     *       normally declared as a register variable-- so it is not worth it.
+     */
+    #define  YY_LESS_LINENO(n) \
+            do { \
+                int yyl;\
+                for ( yyl = n; yyl < magic_frontend_leng; ++yyl )\
+                    if ( magic_frontend_text[yyl] == '\n' )\
+                        --magic_frontend_lineno;\
+            }while(0)
+    
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up magic_frontend_text. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		*yy_cp = (yy_hold_char); \
+		YY_RESTORE_YY_MORE_OFFSET \
+		(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+		YY_DO_BEFORE_ACTION; /* set up magic_frontend_text again */ \
+		} \
+	while ( 0 )
+
+#define unput(c) yyunput( c, (yytext_ptr)  )
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+	{
+	FILE *yy_input_file;
+
+	char *yy_ch_buf;		/* input buffer */
+	char *yy_buf_pos;		/* current position in input buffer */
+
+	/* Size of input buffer in bytes, not including room for EOB
+	 * characters.
+	 */
+	yy_size_t yy_buf_size;
+
+	/* Number of characters read into yy_ch_buf, not including EOB
+	 * characters.
+	 */
+	int yy_n_chars;
+
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int yy_is_our_buffer;
+
+	/* Whether this is an "interactive" input source; if so, and
+	 * if we're using stdio for input, then we want to use getc()
+	 * instead of fread(), to make sure we stop fetching input after
+	 * each newline.
+	 */
+	int yy_is_interactive;
+
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int yy_at_bol;
+
+    int yy_bs_lineno; /**< The line count. */
+    int yy_bs_column; /**< The column count. */
+    
+	/* Whether to try to fill the input buffer when we reach the
+	 * end of it.
+	 */
+	int yy_fill_buffer;
+
+	int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+	/* When an EOF's been seen but there's still some text to process
+	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * shouldn't try reading from the input source any more.  We might
+	 * still have a bunch of tokens to match, though, because of
+	 * possible backing-up.
+	 *
+	 * When we actually see the EOF, we change the status to "new"
+	 * (via magic_frontend_restart()), so that the user can continue scanning by
+	 * just pointing magic_frontend_in at a new input file.
+	 */
+#define YY_BUFFER_EOF_PENDING 2
+
+	};
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* Stack of input buffers. */
+static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
+static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
+static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
+                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
+                          : NULL)
+
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
+
+/* yy_hold_char holds the character lost when magic_frontend_text is formed. */
+static char yy_hold_char;
+static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+int magic_frontend_leng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+static int yy_init = 0;		/* whether we need to initialize */
+static int yy_start = 0;	/* start state number */
+
+/* Flag which is used to allow magic_frontend_wrap()'s to do buffer switches
+ * instead of setting up a fresh magic_frontend_in.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void magic_frontend_restart (FILE *input_file  );
+void magic_frontend__switch_to_buffer (YY_BUFFER_STATE new_buffer  );
+YY_BUFFER_STATE magic_frontend__create_buffer (FILE *file,int size  );
+void magic_frontend__delete_buffer (YY_BUFFER_STATE b  );
+void magic_frontend__flush_buffer (YY_BUFFER_STATE b  );
+void magic_frontend_push_buffer_state (YY_BUFFER_STATE new_buffer  );
+void magic_frontend_pop_buffer_state (void );
+
+static void magic_frontend_ensure_buffer_stack (void );
+static void magic_frontend__load_buffer_state (void );
+static void magic_frontend__init_buffer (YY_BUFFER_STATE b,FILE *file  );
+
+#define YY_FLUSH_BUFFER magic_frontend__flush_buffer(YY_CURRENT_BUFFER )
+
+YY_BUFFER_STATE magic_frontend__scan_buffer (char *base,yy_size_t size  );
+YY_BUFFER_STATE magic_frontend__scan_string (yyconst char *yy_str  );
+YY_BUFFER_STATE magic_frontend__scan_bytes (yyconst char *bytes,int len  );
+
+void *magic_frontend_alloc (yy_size_t  );
+void *magic_frontend_realloc (void *,yy_size_t  );
+void magic_frontend_free (void *  );
+
+#define yy_new_buffer magic_frontend__create_buffer
+
+#define yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){ \
+        magic_frontend_ensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            magic_frontend__create_buffer(magic_frontend_in,YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+	}
+
+#define yy_set_bol(at_bol) \
+	{ \
+	if ( ! YY_CURRENT_BUFFER ){\
+        magic_frontend_ensure_buffer_stack (); \
+		YY_CURRENT_BUFFER_LVALUE =    \
+            magic_frontend__create_buffer(magic_frontend_in,YY_BUF_SIZE ); \
+	} \
+	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+	}
+
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+
+#define magic_frontend_wrap(n) 1
+#define YY_SKIP_YYWRAP
+
+typedef unsigned char YY_CHAR;
+
+FILE *magic_frontend_in = (FILE *) 0, *magic_frontend_out = (FILE *) 0;
+
+typedef int yy_state_type;
+
+extern int magic_frontend_lineno;
+
+int magic_frontend_lineno = 1;
+
+extern char *magic_frontend_text;
+#define yytext_ptr magic_frontend_text
+
+static yy_state_type yy_get_previous_state (void );
+static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
+static int yy_get_next_buffer (void );
+static void yy_fatal_error (yyconst char msg[]  );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up magic_frontend_text.
+ */
+#define YY_DO_BEFORE_ACTION \
+	(yytext_ptr) = yy_bp; \
+	magic_frontend_leng = (size_t) (yy_cp - yy_bp); \
+	(yy_hold_char) = *yy_cp; \
+	*yy_cp = '\0'; \
+	(yy_c_buf_p) = yy_cp;
+
+#define YY_NUM_RULES 83
+#define YY_END_OF_BUFFER 84
+/* This struct is not used in this scanner,
+   but its presence is necessary. */
+struct yy_trans_info
+	{
+	flex_int32_t yy_verify;
+	flex_int32_t yy_nxt;
+	};
+static yyconst flex_int16_t yy_accept[230] =
+    {   0,
+        0,    0,   84,   82,   81,   81,   82,   82,   82,   23,
+       33,   17,   18,   21,   19,   28,   20,   22,   76,   76,
+       27,   26,   14,    9,   13,   29,   78,   78,   78,   78,
+        7,   78,   78,   78,   78,   78,    5,   78,   78,   78,
+        1,   78,    3,   31,   32,   34,   82,   30,   12,    0,
+       75,    0,    0,   79,   24,   76,    0,    0,   35,   16,
+       11,   10,   49,   15,   36,   78,   78,   78,   78,   78,
+       78,   72,   78,   78,   78,   78,   67,   47,   78,   78,
+       78,   78,    6,    4,   39,   63,   78,   78,    8,   78,
+       78,   78,   78,    2,   78,   78,   78,   40,   78,    0,
+
+        0,   74,   25,    0,   75,    0,    0,   80,   77,   78,
+       78,   78,   78,   78,   78,   78,   78,   78,   78,   78,
+       48,   78,   71,   46,   78,   78,   64,   78,   78,   78,
+       78,   78,   78,   78,   78,   78,   78,   78,    0,    0,
+       74,   78,   78,   78,   78,   38,   78,   78,   78,   78,
+       78,   69,   78,   78,   78,   54,   78,   78,   78,   56,
+       78,   78,   78,   78,   68,   78,   73,   57,   60,   78,
+       58,   78,   78,   78,   62,   78,   78,   78,   44,   78,
+       78,   78,   45,   78,   78,   78,   78,   78,   78,   78,
+       78,   59,   65,   78,   78,   78,   43,   50,   66,   78,
+
+       78,   78,   78,   78,   78,   70,   78,   51,   78,   41,
+       78,   55,   78,   78,   78,   78,   61,   52,   78,   37,
+       78,   53,   78,   78,   78,   78,   78,   42,    0
+    } ;
+
+static yyconst flex_int32_t yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    4,    5,    6,    1,    7,    8,    1,    9,
+       10,   11,   12,   13,   14,    1,   15,   16,   17,   17,
+       17,   17,   17,   17,   17,   17,   17,   18,   19,   20,
+       21,   22,   23,   24,   25,   26,   27,   28,   29,   30,
+       31,   32,   33,   34,   35,   36,   37,   38,   39,   40,
+       41,   42,   43,   44,   45,   34,   46,   34,   47,   34,
+       48,   49,   50,   51,   23,    1,   52,   52,   52,   52,
+
+       52,   52,   34,   34,   34,   34,   34,   34,   34,   34,
+       34,   34,   34,   34,   34,   34,   34,   34,   34,   53,
+       34,   34,   54,   55,   56,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static yyconst flex_int32_t yy_meta[57] =
+    {   0,
+        1,    1,    1,    2,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    2,    1,    3,    3,    1,    1,    1,
+        1,    1,    2,    1,    3,    3,    3,    3,    3,    3,
+        2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+        2,    2,    2,    2,    2,    2,    2,    1,    1,    1,
+        1,    3,    2,    1,    1,    1
+    } ;
+
+static yyconst flex_int16_t yy_base[238] =
+    {   0,
+        0,    0,  279,  280,  280,  280,  257,   52,  274,  280,
+      268,  280,  280,  280,  280,  280,   42,  260,   44,   46,
+      280,  280,   44,   46,   48,  280,   45,  232,   47,  234,
+       43,  233,    0,   44,   46,   51,   48,  229,   51,  241,
+       63,   79,  244,  280,  280,  280,   31,  213,  280,   78,
+      280,   97,  264,  280,  280,   89,  263,    0,  280,  280,
+      280,  280,  280,  280,  280,    0,  226,   55,  235,   76,
+       76,    0,  233,  219,   82,  219,    0,    0,  216,  232,
+      220,  231,    0,    0,    0,    0,  217,  214,    0,  218,
+      220,  223,  209,    0,  208,  213,  219,  201,  213,   39,
+
+       88,  280,  280,  110,  111,  118,  242,  280,    0,  202,
+      205,  200,  216,  204,  195,  213,  197,  193,  206,  205,
+        0,  200,  203,    0,  206,  205,    0,  202,  183,  198,
+      186,  189,  191,  192,  193,  183,  195,  175,   68,  119,
+       76,  174,  189,  183,  180,    0,  170,  177,  173,  167,
+      183,    0,  165,  183,  171,    0,  177,  172,  166,    0,
+      167,  164,  172,  160,    0,  157,    0,    0,    0,  167,
+        0,  164,  149,  136,    0,  129,  125,  144,    0,  142,
+      127,  122,    0,  134,  120,  124,  134,  130,  121,  114,
+      127,    0,    0,  123,  109,  124,    0,    0,    0,  110,
+
+      108,  121,  120,  104,  109,    0,  103,    0,   99,    0,
+      100,    0,   98,   96,  110,  124,    0,    0,   93,    0,
+      110,    0,   96,  106,   99,   91,   87,    0,  280,  175,
+      178,  180,  183,  186,  189,  125,  192
+    } ;
+
+static yyconst flex_int16_t yy_def[238] =
+    {   0,
+      229,    1,  229,  229,  229,  229,  229,  230,  231,  229,
+      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
+      229,  229,  229,  229,  229,  229,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  229,  229,  229,  233,  229,  229,  230,
+      229,  234,  231,  229,  229,  229,  235,  236,  229,  229,
+      229,  229,  229,  229,  229,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  233,
+
+      237,  229,  229,  230,  230,  234,  235,  229,  236,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  233,  237,
+      233,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,  232,  232,
+      232,  232,  232,  232,  232,  232,  232,  232,    0,  229,
+      229,  229,  229,  229,  229,  229,  229
+    } ;
+
+static yyconst flex_int16_t yy_nxt[337] =
+    {   0,
+        4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
+       14,   15,   16,   17,   18,   19,   20,   21,   22,   23,
+       24,   25,    4,   26,   27,   28,   29,   30,   31,   32,
+       33,   33,   34,   33,   33,   35,   36,   37,   38,   39,
+       33,   40,   41,   42,   33,   43,   33,   44,    4,   45,
+       46,   33,   33,   47,   48,    4,   51,   56,   56,   56,
+       56,   56,   56,   59,   60,   61,   62,   63,   64,   65,
+       67,   70,   73,   77,   79,   81,   83,   86,   74,  101,
+       75,   78,   51,  111,   80,   71,  102,  101,   68,   82,
+      100,   89,   87,   84,  102,   90,   58,   91,  112,   50,
+
+       52,  105,   92,   95,   56,   56,   93,   96,   94,  121,
+       97,  114,  117,  118,   51,   51,  101,   98,  115,  116,
+       50,  100,  105,  102,  101,  122,   52,  109,  228,  227,
+      226,  102,  225,  224,  223,  222,  140,  221,  220,  219,
+      218,  217,  216,  141,  215,  106,  214,  213,  212,  211,
+      210,  209,  208,  207,  206,  205,  204,  203,   52,   52,
+      202,  201,  200,  199,  198,  197,  106,  140,  196,  195,
+      194,  193,  192,  191,  141,   50,   50,   50,   53,   53,
+       53,   66,   66,  100,  100,  100,  104,  104,  104,  107,
+      107,  107,  139,  139,  139,  190,  189,  188,  187,  186,
+
+      185,  184,  183,  182,  181,  180,  179,  178,  177,  176,
+      175,  174,  173,  172,  171,  170,  169,  168,  167,  166,
+      165,  164,  163,  162,  161,  160,  159,  158,  157,  156,
+      155,  154,  153,  152,  151,  150,  149,  148,  147,  146,
+      145,  144,  143,  142,  108,  138,  137,  136,  135,  134,
+      133,  132,  131,  130,  129,  128,  127,  126,  125,  124,
+      123,  120,  119,  113,  110,  108,   54,  103,   99,   88,
+       85,   76,   72,   69,   57,   55,   54,   49,  229,    3,
+      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
+      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
+
+      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
+      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
+      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
+      229,  229,  229,  229,  229,  229
+    } ;
+
+static yyconst flex_int16_t yy_chk[337] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    8,   17,   17,   19,
+       19,   20,   20,   23,   23,   23,   24,   24,   25,   25,
+       27,   29,   31,   34,   35,   36,   37,   39,   31,   47,
+       31,   34,   50,   68,   35,   29,   47,  100,   27,   36,
+      101,   41,   39,   37,  100,   41,   19,   41,   68,   52,
+
+        8,   52,   41,   42,   56,   56,   41,   42,   41,   75,
+       42,   70,   71,   71,  104,  105,  139,   42,   70,   70,
+      106,  140,  106,  139,  141,   75,   50,  236,  227,  226,
+      225,  141,  224,  223,  221,  219,  101,  216,  215,  214,
+      213,  211,  209,  101,  207,   52,  205,  204,  203,  202,
+      201,  200,  196,  195,  194,  191,  190,  189,  104,  105,
+      188,  187,  186,  185,  184,  182,  106,  140,  181,  180,
+      178,  177,  176,  174,  140,  230,  230,  230,  231,  231,
+      231,  232,  232,  233,  233,  233,  234,  234,  234,  235,
+      235,  235,  237,  237,  237,  173,  172,  170,  166,  164,
+
+      163,  162,  161,  159,  158,  157,  155,  154,  153,  151,
+      150,  149,  148,  147,  145,  144,  143,  142,  138,  137,
+      136,  135,  134,  133,  132,  131,  130,  129,  128,  126,
+      125,  123,  122,  120,  119,  118,  117,  116,  115,  114,
+      113,  112,  111,  110,  107,   99,   98,   97,   96,   95,
+       93,   92,   91,   90,   88,   87,   82,   81,   80,   79,
+       76,   74,   73,   69,   67,   57,   53,   48,   43,   40,
+       38,   32,   30,   28,   18,   11,    9,    7,    3,  229,
+      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
+      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
+
+      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
+      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
+      229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
+      229,  229,  229,  229,  229,  229
+    } ;
+
+/* Table of booleans, true if rule could match eol. */
+static yyconst flex_int32_t yy_rule_can_match_eol[84] =
+    {   0,
+0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 
+    0, 1, 0, 0,     };
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+extern int magic_frontend__flex_debug;
+int magic_frontend__flex_debug = 0;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+char *magic_frontend_text;
+#line 1 "magic-interpreter.l"
+#line 2 "magic-interpreter.l"
+#include "magic-interpreter.h"
+#include "magic-interpreter-parser.h"
+
+#ifdef HEADING
+#  undef HEADING
+#endif
+
+#define FIXLOC magic_frontend_lloc.first_line = magic_frontend_lineno
+
+#define HEADING(dir) { magic_frontend_lval.i = dir; FIXLOC; return DIR; }
+
+#define YY_NO_INPUT 1
+#line 658 "magic-interpreter-lexer.c"
+
+#define INITIAL 0
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#ifndef YY_EXTRA_TYPE
+#define YY_EXTRA_TYPE void *
+#endif
+
+static int yy_init_globals (void );
+
+/* Accessor methods to globals.
+   These are made visible to non-reentrant scanners for convenience. */
+
+int magic_frontend_lex_destroy (void );
+
+int magic_frontend_get_debug (void );
+
+void magic_frontend_set_debug (int debug_flag  );
+
+YY_EXTRA_TYPE magic_frontend_get_extra (void );
+
+void magic_frontend_set_extra (YY_EXTRA_TYPE user_defined  );
+
+FILE *magic_frontend_get_in (void );
+
+void magic_frontend_set_in  (FILE * in_str  );
+
+FILE *magic_frontend_get_out (void );
+
+void magic_frontend_set_out  (FILE * out_str  );
+
+int magic_frontend_get_leng (void );
+
+char *magic_frontend_get_text (void );
+
+int magic_frontend_get_lineno (void );
+
+void magic_frontend_set_lineno (int line_number  );
+
+YYSTYPE * magic_frontend_get_lval (void );
+
+void magic_frontend_set_lval (YYSTYPE * yylval_param  );
+
+       YYLTYPE *magic_frontend_get_lloc (void );
+    
+        void magic_frontend_set_lloc (YYLTYPE * yylloc_param  );
+    
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int magic_frontend_wrap (void );
+#else
+extern int magic_frontend_wrap (void );
+#endif
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char *,yyconst char *,int );
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (yyconst char * );
+#endif
+
+#ifndef YY_NO_INPUT
+
+#ifdef __cplusplus
+static int yyinput (void );
+#else
+static int input (void );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO fwrite( magic_frontend_text, magic_frontend_leng, 1, magic_frontend_out )
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+		{ \
+		int c = '*'; \
+		int n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( magic_frontend_in )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( magic_frontend_in ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
+		} \
+	else \
+		{ \
+		errno=0; \
+		while ( (result = fread(buf, 1, max_size, magic_frontend_in))==0 && ferror(magic_frontend_in)) \
+			{ \
+			if( errno != EINTR) \
+				{ \
+				YY_FATAL_ERROR( "input in flex scanner failed" ); \
+				break; \
+				} \
+			errno=0; \
+			clearerr(magic_frontend_in); \
+			} \
+		}\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int magic_frontend_lex \
+               (YYSTYPE * yylval_param,YYLTYPE * yylloc_param );
+
+#define YY_DECL int magic_frontend_lex \
+               (YYSTYPE * yylval_param, YYLTYPE * yylloc_param )
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after magic_frontend_text and magic_frontend_leng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+
+#define YY_RULE_SETUP \
+	YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+	register yy_state_type yy_current_state;
+	register char *yy_cp, *yy_bp;
+	register int yy_act;
+    
+        YYSTYPE * yylval;
+    
+        YYLTYPE * yylloc;
+    
+#line 22 "magic-interpreter.l"
+
+
+#line 855 "magic-interpreter-lexer.c"
+
+    yylval = yylval_param;
+
+    yylloc = yylloc_param;
+
+	if ( !(yy_init) )
+		{
+		(yy_init) = 1;
+
+#ifdef YY_USER_INIT
+		YY_USER_INIT;
+#endif
+
+		if ( ! (yy_start) )
+			(yy_start) = 1;	/* first start state */
+
+		if ( ! magic_frontend_in )
+			magic_frontend_in = stdin;
+
+		if ( ! magic_frontend_out )
+			magic_frontend_out = stdout;
+
+		if ( ! YY_CURRENT_BUFFER ) {
+			magic_frontend_ensure_buffer_stack ();
+			YY_CURRENT_BUFFER_LVALUE =
+				magic_frontend__create_buffer(magic_frontend_in,YY_BUF_SIZE );
+		}
+
+		magic_frontend__load_buffer_state( );
+		}
+
+	while ( 1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = (yy_c_buf_p);
+
+		/* Support of magic_frontend_text. */
+		*yy_cp = (yy_hold_char);
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = (yy_start);
+yy_match:
+		do
+			{
+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+			if ( yy_accept[yy_current_state] )
+				{
+				(yy_last_accepting_state) = yy_current_state;
+				(yy_last_accepting_cpos) = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 230 )
+					yy_c = yy_meta[(unsigned int) yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 280 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = (yy_last_accepting_cpos);
+			yy_current_state = (yy_last_accepting_state);
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+		if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
+			{
+			int yyl;
+			for ( yyl = 0; yyl < magic_frontend_leng; ++yyl )
+				if ( magic_frontend_text[yyl] == '\n' )
+					   
+    magic_frontend_lineno++;
+;
+			}
+
+do_action:	/* This label is used only to access EOF actions. */
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = (yy_hold_char);
+			yy_cp = (yy_last_accepting_cpos);
+			yy_current_state = (yy_last_accepting_state);
+			goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+#line 24 "magic-interpreter.l"
+HEADING(0);
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 25 "magic-interpreter.l"
+HEADING(1);
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 26 "magic-interpreter.l"
+HEADING(2);
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 27 "magic-interpreter.l"
+HEADING(3);
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 28 "magic-interpreter.l"
+HEADING(4);
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 29 "magic-interpreter.l"
+HEADING(5);
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 30 "magic-interpreter.l"
+HEADING(6);
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 31 "magic-interpreter.l"
+HEADING(7);
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 32 "magic-interpreter.l"
+{FIXLOC; return '=';}
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 33 "magic-interpreter.l"
+{FIXLOC; return EQ;}
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 34 "magic-interpreter.l"
+{FIXLOC; return NEQ;}
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 35 "magic-interpreter.l"
+{FIXLOC; return NEQ;}
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 36 "magic-interpreter.l"
+{FIXLOC; return '>';}
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 37 "magic-interpreter.l"
+{FIXLOC; return '<';}
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 38 "magic-interpreter.l"
+{FIXLOC; return GTE;}
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 39 "magic-interpreter.l"
+{FIXLOC; return LTE;}
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 40 "magic-interpreter.l"
+{FIXLOC; return '(';}
+	YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 41 "magic-interpreter.l"
+{FIXLOC; return ')';}
+	YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 42 "magic-interpreter.l"
+{FIXLOC; return '+';}
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
+#line 43 "magic-interpreter.l"
+{FIXLOC; return '-';}
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
+#line 44 "magic-interpreter.l"
+{FIXLOC; return '*';}
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 45 "magic-interpreter.l"
+{FIXLOC; return '/';}
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+#line 46 "magic-interpreter.l"
+{FIXLOC; return '%';}
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 47 "magic-interpreter.l"
+{FIXLOC; return ANDAND;}
+	YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 48 "magic-interpreter.l"
+{FIXLOC; return OROR;}
+	YY_BREAK
+case 26:
+YY_RULE_SETUP
+#line 49 "magic-interpreter.l"
+{FIXLOC; return ';';}
+	YY_BREAK
+case 27:
+YY_RULE_SETUP
+#line 50 "magic-interpreter.l"
+{FIXLOC; return ':';}
+	YY_BREAK
+case 28:
+YY_RULE_SETUP
+#line 51 "magic-interpreter.l"
+{FIXLOC; return ',';}
+	YY_BREAK
+case 29:
+YY_RULE_SETUP
+#line 52 "magic-interpreter.l"
+{FIXLOC; return '@';}
+	YY_BREAK
+case 30:
+YY_RULE_SETUP
+#line 53 "magic-interpreter.l"
+{FIXLOC; return '|';}
+	YY_BREAK
+case 31:
+YY_RULE_SETUP
+#line 54 "magic-interpreter.l"
+{FIXLOC; return '[';}
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
+#line 55 "magic-interpreter.l"
+{FIXLOC; return ']';}
+	YY_BREAK
+case 33:
+YY_RULE_SETUP
+#line 56 "magic-interpreter.l"
+{FIXLOC; return '&';}
+	YY_BREAK
+case 34:
+YY_RULE_SETUP
+#line 57 "magic-interpreter.l"
+{FIXLOC; return '^';}
+	YY_BREAK
+case 35:
+YY_RULE_SETUP
+#line 58 "magic-interpreter.l"
+{FIXLOC; return SHL;}
+	YY_BREAK
+case 36:
+YY_RULE_SETUP
+#line 59 "magic-interpreter.l"
+{FIXLOC; return SHR;}
+	YY_BREAK
+case 37:
+YY_RULE_SETUP
+#line 60 "magic-interpreter.l"
+{FIXLOC; return PROCEDURE;}
+	YY_BREAK
+case 38:
+YY_RULE_SETUP
+#line 61 "magic-interpreter.l"
+{FIXLOC; return CALL;}
+	YY_BREAK
+case 39:
+YY_RULE_SETUP
+#line 62 "magic-interpreter.l"
+{FIXLOC; return OR;}
+	YY_BREAK
+case 40:
+YY_RULE_SETUP
+#line 63 "magic-interpreter.l"
+{FIXLOC; return TO;}
+	YY_BREAK
+case 41:
+YY_RULE_SETUP
+#line 64 "magic-interpreter.l"
+{FIXLOC; return TOWARDS;}
+	YY_BREAK
+case 42:
+YY_RULE_SETUP
+#line 65 "magic-interpreter.l"
+{FIXLOC; return TELEPORT_ANCHOR;}
+	YY_BREAK
+case 43:
+YY_RULE_SETUP
+#line 66 "magic-interpreter.l"
+{FIXLOC; return SILENT;}
+	YY_BREAK
+case 44:
+YY_RULE_SETUP
+#line 67 "magic-interpreter.l"
+{FIXLOC; return LOCAL;}
+	YY_BREAK
+case 45:
+YY_RULE_SETUP
+#line 68 "magic-interpreter.l"
+{FIXLOC; return SPELL;}
+	YY_BREAK
+case 46:
+YY_RULE_SETUP
+#line 69 "magic-interpreter.l"
+{FIXLOC; return LET;}
+	YY_BREAK
+case 47:
+YY_RULE_SETUP
+#line 70 "magic-interpreter.l"
+{FIXLOC; return IN;}
+	YY_BREAK
+case 48:
+YY_RULE_SETUP
+#line 71 "magic-interpreter.l"
+{FIXLOC; return END;}
+	YY_BREAK
+case 49:
+YY_RULE_SETUP
+#line 72 "magic-interpreter.l"
+{FIXLOC; return DARROW;}
+	YY_BREAK
+case 50:
+YY_RULE_SETUP
+#line 73 "magic-interpreter.l"
+{FIXLOC; return STRING_TY;}
+	YY_BREAK
+case 51:
+YY_RULE_SETUP
+#line 74 "magic-interpreter.l"
+{FIXLOC; return REQUIRE;}
+	YY_BREAK
+case 52:
+YY_RULE_SETUP
+#line 75 "magic-interpreter.l"
+{FIXLOC; return CATALYSTS;}
+	YY_BREAK
+case 53:
+YY_RULE_SETUP
+#line 76 "magic-interpreter.l"
+{FIXLOC; return COMPONENTS;}
+	YY_BREAK
+case 54:
+YY_RULE_SETUP
+#line 77 "magic-interpreter.l"
+{FIXLOC; return MANA;}
+	YY_BREAK
+case 55:
+YY_RULE_SETUP
+#line 78 "magic-interpreter.l"
+{FIXLOC; return CASTTIME;}
+	YY_BREAK
+case 56:
+YY_RULE_SETUP
+#line 79 "magic-interpreter.l"
+{FIXLOC; return SKIP;}
+	YY_BREAK
+case 57:
+YY_RULE_SETUP
+#line 80 "magic-interpreter.l"
+{FIXLOC; return ABORT;}
+	YY_BREAK
+case 58:
+YY_RULE_SETUP
+#line 81 "magic-interpreter.l"
+{FIXLOC; return BREAK;}
+	YY_BREAK
+case 59:
+YY_RULE_SETUP
+#line 82 "magic-interpreter.l"
+{FIXLOC; return EFFECT;}
+	YY_BREAK
+case 60:
+YY_RULE_SETUP
+#line 83 "magic-interpreter.l"
+{FIXLOC; return ATEND;}
+	YY_BREAK
+case 61:
+YY_RULE_SETUP
+#line 84 "magic-interpreter.l"
+{FIXLOC; return ATTRIGGER;}
+	YY_BREAK
+case 62:
+YY_RULE_SETUP
+#line 85 "magic-interpreter.l"
+{FIXLOC; return CONST;}
+	YY_BREAK
+case 63:
+YY_RULE_SETUP
+#line 86 "magic-interpreter.l"
+{FIXLOC; return PC_F;}
+	YY_BREAK
+case 64:
+YY_RULE_SETUP
+#line 87 "magic-interpreter.l"
+{FIXLOC; return MOB_F;}
+	YY_BREAK
+case 65:
+YY_RULE_SETUP
+#line 88 "magic-interpreter.l"
+{FIXLOC; return ENTITY_F;}
+	YY_BREAK
+case 66:
+YY_RULE_SETUP
+#line 89 "magic-interpreter.l"
+{FIXLOC; return TARGET_F;}
+	YY_BREAK
+case 67:
+YY_RULE_SETUP
+#line 90 "magic-interpreter.l"
+{FIXLOC; return IF;}
+	YY_BREAK
+case 68:
+YY_RULE_SETUP
+#line 91 "magic-interpreter.l"
+{FIXLOC; return THEN;}
+	YY_BREAK
+case 69:
+YY_RULE_SETUP
+#line 92 "magic-interpreter.l"
+{FIXLOC; return ELSE;}
+	YY_BREAK
+case 70:
+YY_RULE_SETUP
+#line 93 "magic-interpreter.l"
+{FIXLOC; return FOREACH;}
+	YY_BREAK
+case 71:
+YY_RULE_SETUP
+#line 94 "magic-interpreter.l"
+{FIXLOC; return FOR;}
+	YY_BREAK
+case 72:
+YY_RULE_SETUP
+#line 95 "magic-interpreter.l"
+{FIXLOC; return DO;}
+	YY_BREAK
+case 73:
+YY_RULE_SETUP
+#line 96 "magic-interpreter.l"
+{FIXLOC; return SLEEP;}
+	YY_BREAK
+case 74:
+/* rule 74 can match eol */
+YY_RULE_SETUP
+#line 98 "magic-interpreter.l"
+{ char *string = strdup(magic_frontend_text);
+                   magic_frontend_lval.s = string;
+		   FIXLOC;
+                   return SCRIPT_DATA;
+                   }
+	YY_BREAK
+case 75:
+/* rule 75 can match eol */
+YY_RULE_SETUP
+#line 104 "magic-interpreter.l"
+{ char *string = strdup(magic_frontend_text + 1);
+                   char *src = string;
+                   char *dst = string;
+                   while (*src && *src != '"')
+                       if (*src == '\\') {
+                           *dst++ = src[1];
+                           src += 2;
+                       } else
+                           *dst++ = *src++;
+                   *dst = '\0'; /* terminate */
+                   magic_frontend_lval.s = string;
+		   FIXLOC;
+                   return STRING;
+                   }
+	YY_BREAK
+case 76:
+YY_RULE_SETUP
+#line 119 "magic-interpreter.l"
+{ magic_frontend_lval.i = atoi(magic_frontend_text);
+		      FIXLOC;
+                      return INT; }
+	YY_BREAK
+case 77:
+YY_RULE_SETUP
+#line 123 "magic-interpreter.l"
+{ magic_frontend_lval.i = strtol(magic_frontend_text + 2, NULL, 16);
+		      FIXLOC;
+                      return INT; }
+	YY_BREAK
+case 78:
+YY_RULE_SETUP
+#line 127 "magic-interpreter.l"
+{ magic_frontend_lval.s = strdup(magic_frontend_text);
+		            FIXLOC;
+                            return ID; }
+	YY_BREAK
+case 79:
+*yy_cp = (yy_hold_char); /* undo effects of setting up magic_frontend_text */
+(yy_c_buf_p) = yy_cp -= 1;
+YY_DO_BEFORE_ACTION; /* set up magic_frontend_text again */
+YY_RULE_SETUP
+#line 131 "magic-interpreter.l"
+/* Ignore comments */
+	YY_BREAK
+case 80:
+*yy_cp = (yy_hold_char); /* undo effects of setting up magic_frontend_text */
+(yy_c_buf_p) = yy_cp -= 1;
+YY_DO_BEFORE_ACTION; /* set up magic_frontend_text again */
+YY_RULE_SETUP
+#line 132 "magic-interpreter.l"
+/* Ignore comments */
+	YY_BREAK
+case 81:
+/* rule 81 can match eol */
+YY_RULE_SETUP
+#line 133 "magic-interpreter.l"
+/* ignore whitespace */	
+	YY_BREAK
+case 82:
+YY_RULE_SETUP
+#line 134 "magic-interpreter.l"
+fprintf(stderr, "%s: Unexpected character in line %d\n", MAGIC_CONFIG_FILE, magic_frontend_lineno);
+	YY_BREAK
+case 83:
+YY_RULE_SETUP
+#line 137 "magic-interpreter.l"
+ECHO;
+	YY_BREAK
+#line 1399 "magic-interpreter-lexer.c"
+case YY_STATE_EOF(INITIAL):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+		{
+		/* Amount of text matched not including the EOB char. */
+		int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
+
+		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		*yy_cp = (yy_hold_char);
+		YY_RESTORE_YY_MORE_OFFSET
+
+		if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+			{
+			/* We're scanning a new file or input source.  It's
+			 * possible that this happened because the user
+			 * just pointed magic_frontend_in at a new source and called
+			 * magic_frontend_lex().  If so, then we have to assure
+			 * consistency between YY_CURRENT_BUFFER and our
+			 * globals.  Here is the right place to do so, because
+			 * this is the first action (other than possibly a
+			 * back-up) that will match for the new input source.
+			 */
+			(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+			YY_CURRENT_BUFFER_LVALUE->yy_input_file = magic_frontend_in;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+			}
+
+		/* Note that here we test for yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since yy_c_buf_p will
+		 * already have been incremented past the NUL character
+		 * (since all states make transitions on EOB to the
+		 * end-of-buffer state).  Contrast this with the test
+		 * in input().
+		 */
+		if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+			{ /* This was really a NUL. */
+			yy_state_type yy_next_state;
+
+			(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
+
+			yy_current_state = yy_get_previous_state(  );
+
+			/* Okay, we're now positioned to make the NUL
+			 * transition.  We couldn't have
+			 * yy_get_previous_state() go ahead and do it
+			 * for us because it doesn't know how to deal
+			 * with the possibility of jamming (and we don't
+			 * want to build jamming into it because then it
+			 * will run more slowly).
+			 */
+
+			yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+			yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+
+			if ( yy_next_state )
+				{
+				/* Consume the NUL. */
+				yy_cp = ++(yy_c_buf_p);
+				yy_current_state = yy_next_state;
+				goto yy_match;
+				}
+
+			else
+				{
+				yy_cp = (yy_c_buf_p);
+				goto yy_find_action;
+				}
+			}
+
+		else switch ( yy_get_next_buffer(  ) )
+			{
+			case EOB_ACT_END_OF_FILE:
+				{
+				(yy_did_buffer_switch_on_eof) = 0;
+
+				if ( magic_frontend_wrap( ) )
+					{
+					/* Note: because we've taken care in
+					 * yy_get_next_buffer() to have set up
+					 * magic_frontend_text, we can now set up
+					 * yy_c_buf_p so that if some total
+					 * hoser (like flex itself) wants to
+					 * call the scanner after we return the
+					 * YY_NULL, it'll still work - another
+					 * YY_NULL will get returned.
+					 */
+					(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
+
+					yy_act = YY_STATE_EOF(YY_START);
+					goto do_action;
+					}
+
+				else
+					{
+					if ( ! (yy_did_buffer_switch_on_eof) )
+						YY_NEW_FILE;
+					}
+				break;
+				}
+
+			case EOB_ACT_CONTINUE_SCAN:
+				(yy_c_buf_p) =
+					(yytext_ptr) + yy_amount_of_matched_text;
+
+				yy_current_state = yy_get_previous_state(  );
+
+				yy_cp = (yy_c_buf_p);
+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+				goto yy_match;
+
+			case EOB_ACT_LAST_MATCH:
+				(yy_c_buf_p) =
+				&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
+
+				yy_current_state = yy_get_previous_state(  );
+
+				yy_cp = (yy_c_buf_p);
+				yy_bp = (yytext_ptr) + YY_MORE_ADJ;
+				goto yy_find_action;
+			}
+		break;
+		}
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+} /* end of magic_frontend_lex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ *	EOB_ACT_LAST_MATCH -
+ *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ *	EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (void)
+{
+    	register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+	register char *source = (yytext_ptr);
+	register int number_to_move, i;
+	int ret_val;
+
+	if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
+		YY_FATAL_ERROR(
+		"fatal flex scanner internal error--end of buffer missed" );
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+		{ /* Don't try to fill the buffer, so this is an EOF. */
+		if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
+			{
+			/* We matched a single character, the EOB, so
+			 * treat this as a final EOF.
+			 */
+			return EOB_ACT_END_OF_FILE;
+			}
+
+		else
+			{
+			/* We matched some text prior to the EOB, first
+			 * process it.
+			 */
+			return EOB_ACT_LAST_MATCH;
+			}
+		}
+
+	/* Try to read more data. */
+
+	/* First move last chars to start of buffer. */
+	number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
+
+	for ( i = 0; i < number_to_move; ++i )
+		*(dest++) = *(source++);
+
+	if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+		/* don't do the read, it's not guaranteed to return an EOF,
+		 * just force an EOF
+		 */
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
+
+	else
+		{
+			int num_to_read =
+			YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+		while ( num_to_read <= 0 )
+			{ /* Not enough room in the buffer - grow it. */
+
+			/* just a shorter name for the current buffer */
+			YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
+
+			int yy_c_buf_p_offset =
+				(int) ((yy_c_buf_p) - b->yy_ch_buf);
+
+			if ( b->yy_is_our_buffer )
+				{
+				int new_size = b->yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->yy_buf_size += b->yy_buf_size / 8;
+				else
+					b->yy_buf_size *= 2;
+
+				b->yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					magic_frontend_realloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->yy_ch_buf = 0;
+
+			if ( ! b->yy_ch_buf )
+				YY_FATAL_ERROR(
+				"fatal error - scanner input buffer overflow" );
+
+			(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+			num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+						number_to_move - 1;
+
+			}
+
+		if ( num_to_read > YY_READ_BUF_SIZE )
+			num_to_read = YY_READ_BUF_SIZE;
+
+		/* Read in more data. */
+		YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+			(yy_n_chars), (size_t) num_to_read );
+
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	if ( (yy_n_chars) == 0 )
+		{
+		if ( number_to_move == YY_MORE_ADJ )
+			{
+			ret_val = EOB_ACT_END_OF_FILE;
+			magic_frontend_restart(magic_frontend_in  );
+			}
+
+		else
+			{
+			ret_val = EOB_ACT_LAST_MATCH;
+			YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+				YY_BUFFER_EOF_PENDING;
+			}
+		}
+
+	else
+		ret_val = EOB_ACT_CONTINUE_SCAN;
+
+	if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+		/* Extend the array by 50%, plus the number we really need. */
+		yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
+		YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) magic_frontend_realloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
+		if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+			YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+	}
+
+	(yy_n_chars) += number_to_move;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
+	YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
+
+	(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+	return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+    static yy_state_type yy_get_previous_state (void)
+{
+	register yy_state_type yy_current_state;
+	register char *yy_cp;
+    
+	yy_current_state = (yy_start);
+
+	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
+		{
+		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+		if ( yy_accept[yy_current_state] )
+			{
+			(yy_last_accepting_state) = yy_current_state;
+			(yy_last_accepting_cpos) = yy_cp;
+			}
+		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			{
+			yy_current_state = (int) yy_def[yy_current_state];
+			if ( yy_current_state >= 230 )
+				yy_c = yy_meta[(unsigned int) yy_c];
+			}
+		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+		}
+
+	return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ *	next_state = yy_try_NUL_trans( current_state );
+ */
+    static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
+{
+	register int yy_is_jam;
+    	register char *yy_cp = (yy_c_buf_p);
+
+	register YY_CHAR yy_c = 1;
+	if ( yy_accept[yy_current_state] )
+		{
+		(yy_last_accepting_state) = yy_current_state;
+		(yy_last_accepting_cpos) = yy_cp;
+		}
+	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		{
+		yy_current_state = (int) yy_def[yy_current_state];
+		if ( yy_current_state >= 230 )
+			yy_c = yy_meta[(unsigned int) yy_c];
+		}
+	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+	yy_is_jam = (yy_current_state == 229);
+
+	return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+    static int yyinput (void)
+#else
+    static int input  (void)
+#endif
+
+{
+	int c;
+    
+	*(yy_c_buf_p) = (yy_hold_char);
+
+	if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
+		{
+		/* yy_c_buf_p now points to the character we want to return.
+		 * If this occurs *before* the EOB characters, then it's a
+		 * valid NUL; if not, then we've hit the end of the buffer.
+		 */
+		if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
+			/* This was really a NUL. */
+			*(yy_c_buf_p) = '\0';
+
+		else
+			{ /* need more input */
+			int offset = (yy_c_buf_p) - (yytext_ptr);
+			++(yy_c_buf_p);
+
+			switch ( yy_get_next_buffer(  ) )
+				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					magic_frontend_restart(magic_frontend_in );
+
+					/*FALLTHROUGH*/
+
+				case EOB_ACT_END_OF_FILE:
+					{
+					if ( magic_frontend_wrap( ) )
+						return EOF;
+
+					if ( ! (yy_did_buffer_switch_on_eof) )
+						YY_NEW_FILE;
+#ifdef __cplusplus
+					return yyinput();
+#else
+					return input();
+#endif
+					}
+
+				case EOB_ACT_CONTINUE_SCAN:
+					(yy_c_buf_p) = (yytext_ptr) + offset;
+					break;
+				}
+			}
+		}
+
+	c = *(unsigned char *) (yy_c_buf_p);	/* cast for 8-bit char's */
+	*(yy_c_buf_p) = '\0';	/* preserve magic_frontend_text */
+	(yy_hold_char) = *++(yy_c_buf_p);
+
+	if ( c == '\n' )
+		   
+    magic_frontend_lineno++;
+;
+
+	return c;
+}
+#endif	/* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * 
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+    void magic_frontend_restart  (FILE * input_file )
+{
+    
+	if ( ! YY_CURRENT_BUFFER ){
+        magic_frontend_ensure_buffer_stack ();
+		YY_CURRENT_BUFFER_LVALUE =
+            magic_frontend__create_buffer(magic_frontend_in,YY_BUF_SIZE );
+	}
+
+	magic_frontend__init_buffer(YY_CURRENT_BUFFER,input_file );
+	magic_frontend__load_buffer_state( );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * 
+ */
+    void magic_frontend__switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
+{
+    
+	/* TODO. We should be able to replace this entire function body
+	 * with
+	 *		magic_frontend_pop_buffer_state();
+	 *		magic_frontend_push_buffer_state(new_buffer);
+     */
+	magic_frontend_ensure_buffer_stack ();
+	if ( YY_CURRENT_BUFFER == new_buffer )
+		return;
+
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*(yy_c_buf_p) = (yy_hold_char);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+	magic_frontend__load_buffer_state( );
+
+	/* We don't actually know whether we did this switch during
+	 * EOF (magic_frontend_wrap()) processing, but the only time this flag
+	 * is looked at is after magic_frontend_wrap() is called, so it's safe
+	 * to go ahead and always set it.
+	 */
+	(yy_did_buffer_switch_on_eof) = 1;
+}
+
+static void magic_frontend__load_buffer_state  (void)
+{
+    	(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+	(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+	magic_frontend_in = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+	(yy_hold_char) = *(yy_c_buf_p);
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * 
+ * @return the allocated buffer state.
+ */
+    YY_BUFFER_STATE magic_frontend__create_buffer  (FILE * file, int  size )
+{
+	YY_BUFFER_STATE b;
+    
+	b = (YY_BUFFER_STATE) magic_frontend_alloc(sizeof( struct yy_buffer_state )  );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in magic_frontend__create_buffer()" );
+
+	b->yy_buf_size = size;
+
+	/* yy_ch_buf has to be 2 characters longer than the size given because
+	 * we need to put in 2 end-of-buffer characters.
+	 */
+	b->yy_ch_buf = (char *) magic_frontend_alloc(b->yy_buf_size + 2  );
+	if ( ! b->yy_ch_buf )
+		YY_FATAL_ERROR( "out of dynamic memory in magic_frontend__create_buffer()" );
+
+	b->yy_is_our_buffer = 1;
+
+	magic_frontend__init_buffer(b,file );
+
+	return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with magic_frontend__create_buffer()
+ * 
+ */
+    void magic_frontend__delete_buffer (YY_BUFFER_STATE  b )
+{
+    
+	if ( ! b )
+		return;
+
+	if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+		YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+	if ( b->yy_is_our_buffer )
+		magic_frontend_free((void *) b->yy_ch_buf  );
+
+	magic_frontend_free((void *) b  );
+}
+
+#ifndef __cplusplus
+extern int isatty (int );
+#endif /* __cplusplus */
+    
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a magic_frontend_restart() or at EOF.
+ */
+    static void magic_frontend__init_buffer  (YY_BUFFER_STATE  b, FILE * file )
+
+{
+	int oerrno = errno;
+    
+	magic_frontend__flush_buffer(b );
+
+	b->yy_input_file = file;
+	b->yy_fill_buffer = 1;
+
+    /* If b is the current buffer, then magic_frontend__init_buffer was _probably_
+     * called from magic_frontend_restart() or through yy_get_next_buffer.
+     * In that case, we don't want to reset the lineno or column.
+     */
+    if (b != YY_CURRENT_BUFFER){
+        b->yy_bs_lineno = 1;
+        b->yy_bs_column = 0;
+    }
+
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+    
+	errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * 
+ */
+    void magic_frontend__flush_buffer (YY_BUFFER_STATE  b )
+{
+    	if ( ! b )
+		return;
+
+	b->yy_n_chars = 0;
+
+	/* We always need two end-of-buffer characters.  The first causes
+	 * a transition to the end-of-buffer state.  The second causes
+	 * a jam in that state.
+	 */
+	b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+	b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+	b->yy_buf_pos = &b->yy_ch_buf[0];
+
+	b->yy_at_bol = 1;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	if ( b == YY_CURRENT_BUFFER )
+		magic_frontend__load_buffer_state( );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ *  the current state. This function will allocate the stack
+ *  if necessary.
+ *  @param new_buffer The new state.
+ *  
+ */
+void magic_frontend_push_buffer_state (YY_BUFFER_STATE new_buffer )
+{
+    	if (new_buffer == NULL)
+		return;
+
+	magic_frontend_ensure_buffer_stack();
+
+	/* This block is copied from magic_frontend__switch_to_buffer. */
+	if ( YY_CURRENT_BUFFER )
+		{
+		/* Flush out information for old buffer. */
+		*(yy_c_buf_p) = (yy_hold_char);
+		YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
+		YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
+		}
+
+	/* Only push if top exists. Otherwise, replace top. */
+	if (YY_CURRENT_BUFFER)
+		(yy_buffer_stack_top)++;
+	YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+	/* copied from magic_frontend__switch_to_buffer. */
+	magic_frontend__load_buffer_state( );
+	(yy_did_buffer_switch_on_eof) = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ *  The next element becomes the new top.
+ *  
+ */
+void magic_frontend_pop_buffer_state (void)
+{
+    	if (!YY_CURRENT_BUFFER)
+		return;
+
+	magic_frontend__delete_buffer(YY_CURRENT_BUFFER );
+	YY_CURRENT_BUFFER_LVALUE = NULL;
+	if ((yy_buffer_stack_top) > 0)
+		--(yy_buffer_stack_top);
+
+	if (YY_CURRENT_BUFFER) {
+		magic_frontend__load_buffer_state( );
+		(yy_did_buffer_switch_on_eof) = 1;
+	}
+}
+
+/* Allocates the stack if it does not exist.
+ *  Guarantees space for at least one push.
+ */
+static void magic_frontend_ensure_buffer_stack (void)
+{
+	int num_to_alloc;
+    
+	if (!(yy_buffer_stack)) {
+
+		/* First allocation is just for 2 elements, since we don't know if this
+		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
+		 * immediate realloc on the next call.
+         */
+		num_to_alloc = 1;
+		(yy_buffer_stack) = (struct yy_buffer_state**)magic_frontend_alloc
+								(num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in magic_frontend_ensure_buffer_stack()" );
+								  
+		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+				
+		(yy_buffer_stack_max) = num_to_alloc;
+		(yy_buffer_stack_top) = 0;
+		return;
+	}
+
+	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
+
+		/* Increase the buffer to prepare for a possible push. */
+		int grow_size = 8 /* arbitrary grow size */;
+
+		num_to_alloc = (yy_buffer_stack_max) + grow_size;
+		(yy_buffer_stack) = (struct yy_buffer_state**)magic_frontend_realloc
+								((yy_buffer_stack),
+								num_to_alloc * sizeof(struct yy_buffer_state*)
+								);
+		if ( ! (yy_buffer_stack) )
+			YY_FATAL_ERROR( "out of dynamic memory in magic_frontend_ensure_buffer_stack()" );
+
+		/* zero only the new slots.*/
+		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
+		(yy_buffer_stack_max) = num_to_alloc;
+	}
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * 
+ * @return the newly allocated buffer state object. 
+ */
+YY_BUFFER_STATE magic_frontend__scan_buffer  (char * base, yy_size_t  size )
+{
+	YY_BUFFER_STATE b;
+    
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return 0;
+
+	b = (YY_BUFFER_STATE) magic_frontend_alloc(sizeof( struct yy_buffer_state )  );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in magic_frontend__scan_buffer()" );
+
+	b->yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
+	b->yy_buf_pos = b->yy_ch_buf = base;
+	b->yy_is_our_buffer = 0;
+	b->yy_input_file = 0;
+	b->yy_n_chars = b->yy_buf_size;
+	b->yy_is_interactive = 0;
+	b->yy_at_bol = 1;
+	b->yy_fill_buffer = 0;
+	b->yy_buffer_status = YY_BUFFER_NEW;
+
+	magic_frontend__switch_to_buffer(b  );
+
+	return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to magic_frontend_lex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * 
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ *       magic_frontend__scan_bytes() instead.
+ */
+YY_BUFFER_STATE magic_frontend__scan_string (yyconst char * yystr )
+{
+    
+	return magic_frontend__scan_bytes(yystr,strlen(yystr) );
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to magic_frontend_lex() will
+ * scan from a @e copy of @a bytes.
+ * @param bytes the byte buffer to scan
+ * @param len the number of bytes in the buffer pointed to by @a bytes.
+ * 
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE magic_frontend__scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
+{
+	YY_BUFFER_STATE b;
+	char *buf;
+	yy_size_t n;
+	int i;
+    
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = _yybytes_len + 2;
+	buf = (char *) magic_frontend_alloc(n  );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in magic_frontend__scan_bytes()" );
+
+	for ( i = 0; i < _yybytes_len; ++i )
+		buf[i] = yybytes[i];
+
+	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = magic_frontend__scan_buffer(buf,n );
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in magic_frontend__scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->yy_is_our_buffer = 1;
+
+	return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yy_fatal_error (yyconst char* msg )
+{
+    	(void) fprintf( stderr, "%s\n", msg );
+	exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+	do \
+		{ \
+		/* Undo effects of setting up magic_frontend_text. */ \
+        int yyless_macro_arg = (n); \
+        YY_LESS_LINENO(yyless_macro_arg);\
+		magic_frontend_text[magic_frontend_leng] = (yy_hold_char); \
+		(yy_c_buf_p) = magic_frontend_text + yyless_macro_arg; \
+		(yy_hold_char) = *(yy_c_buf_p); \
+		*(yy_c_buf_p) = '\0'; \
+		magic_frontend_leng = yyless_macro_arg; \
+		} \
+	while ( 0 )
+
+/* Accessor  methods (get/set functions) to struct members. */
+
+/** Get the current line number.
+ * 
+ */
+int magic_frontend_get_lineno  (void)
+{
+        
+    return magic_frontend_lineno;
+}
+
+/** Get the input stream.
+ * 
+ */
+FILE *magic_frontend_get_in  (void)
+{
+        return magic_frontend_in;
+}
+
+/** Get the output stream.
+ * 
+ */
+FILE *magic_frontend_get_out  (void)
+{
+        return magic_frontend_out;
+}
+
+/** Get the length of the current token.
+ * 
+ */
+int magic_frontend_get_leng  (void)
+{
+        return magic_frontend_leng;
+}
+
+/** Get the current token.
+ * 
+ */
+
+char *magic_frontend_get_text  (void)
+{
+        return magic_frontend_text;
+}
+
+/** Set the current line number.
+ * @param line_number
+ * 
+ */
+void magic_frontend_set_lineno (int  line_number )
+{
+    
+    magic_frontend_lineno = line_number;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param in_str A readable stream.
+ * 
+ * @see magic_frontend__switch_to_buffer
+ */
+void magic_frontend_set_in (FILE *  in_str )
+{
+        magic_frontend_in = in_str ;
+}
+
+void magic_frontend_set_out (FILE *  out_str )
+{
+        magic_frontend_out = out_str ;
+}
+
+int magic_frontend_get_debug  (void)
+{
+        return magic_frontend__flex_debug;
+}
+
+void magic_frontend_set_debug (int  bdebug )
+{
+        magic_frontend__flex_debug = bdebug ;
+}
+
+static int yy_init_globals (void)
+{
+        /* Initialization is the same as for the non-reentrant scanner.
+     * This function is called from magic_frontend_lex_destroy(), so don't allocate here.
+     */
+
+    /* We do not touch magic_frontend_lineno unless the option is enabled. */
+    magic_frontend_lineno =  1;
+    
+    (yy_buffer_stack) = 0;
+    (yy_buffer_stack_top) = 0;
+    (yy_buffer_stack_max) = 0;
+    (yy_c_buf_p) = (char *) 0;
+    (yy_init) = 0;
+    (yy_start) = 0;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+    magic_frontend_in = stdin;
+    magic_frontend_out = stdout;
+#else
+    magic_frontend_in = (FILE *) 0;
+    magic_frontend_out = (FILE *) 0;
+#endif
+
+    /* For future reference: Set errno on error, since we are called by
+     * magic_frontend_lex_init()
+     */
+    return 0;
+}
+
+/* magic_frontend_lex_destroy is for both reentrant and non-reentrant scanners. */
+int magic_frontend_lex_destroy  (void)
+{
+    
+    /* Pop the buffer stack, destroying each element. */
+	while(YY_CURRENT_BUFFER){
+		magic_frontend__delete_buffer(YY_CURRENT_BUFFER  );
+		YY_CURRENT_BUFFER_LVALUE = NULL;
+		magic_frontend_pop_buffer_state();
+	}
+
+	/* Destroy the stack itself. */
+	magic_frontend_free((yy_buffer_stack) );
+	(yy_buffer_stack) = NULL;
+
+    /* Reset the globals. This is important in a non-reentrant scanner so the next time
+     * magic_frontend_lex() is called, initialization will occur. */
+    yy_init_globals( );
+
+    return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
+{
+	register int i;
+	for ( i = 0; i < n; ++i )
+		s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (yyconst char * s )
+{
+	register int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+}
+#endif
+
+void *magic_frontend_alloc (yy_size_t  size )
+{
+	return (void *) malloc( size );
+}
+
+void *magic_frontend_realloc  (void * ptr, yy_size_t  size )
+{
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return (void *) realloc( (char *) ptr, size );
+}
+
+void magic_frontend_free (void * ptr )
+{
+	free( (char *) ptr );	/* see magic_frontend_realloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+#line 137 "magic-interpreter.l"
+
+
+
diff --git a/src/map/magic-interpreter-parser.c b/src/map/magic-interpreter-parser.c
new file mode 100644
index 0000000..09ddce2
--- /dev/null
+++ b/src/map/magic-interpreter-parser.c
@@ -0,0 +1,3198 @@
+/* A Bison parser, made by GNU Bison 2.3.  */
+
+/* Skeleton implementation for Bison's Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+   simplifying the original so-called "semantic" parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Bison version.  */
+#define YYBISON_VERSION "2.3"
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 0
+
+/* Using locations.  */
+#define YYLSP_NEEDED 1
+
+/* Substitute the variable and function names.  */
+#define yyparse magic_frontend_parse
+#define yylex   magic_frontend_lex
+#define yyerror magic_frontend_error
+#define yylval  magic_frontend_lval
+#define yychar  magic_frontend_char
+#define yydebug magic_frontend_debug
+#define yynerrs magic_frontend_nerrs
+#define yylloc magic_frontend_lloc
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     INT = 258,
+     STRING = 259,
+     ID = 260,
+     DIR = 261,
+     CONST = 262,
+     PROCEDURE = 263,
+     CALL = 264,
+     SILENT = 265,
+     LOCAL = 266,
+     SHL = 267,
+     SHR = 268,
+     EQ = 269,
+     NEQ = 270,
+     GTE = 271,
+     LTE = 272,
+     ANDAND = 273,
+     OROR = 274,
+     SCRIPT_DATA = 275,
+     TO = 276,
+     TOWARDS = 277,
+     TELEPORT_ANCHOR = 278,
+     SPELL = 279,
+     LET = 280,
+     IN = 281,
+     END = 282,
+     DARROW = 283,
+     STRING_TY = 284,
+     REQUIRE = 285,
+     CATALYSTS = 286,
+     COMPONENTS = 287,
+     MANA = 288,
+     CASTTIME = 289,
+     SKIP = 290,
+     ABORT = 291,
+     BREAK = 292,
+     EFFECT = 293,
+     ATEND = 294,
+     ATTRIGGER = 295,
+     PC_F = 296,
+     MOB_F = 297,
+     ENTITY_F = 298,
+     TARGET_F = 299,
+     IF = 300,
+     THEN = 301,
+     ELSE = 302,
+     FOREACH = 303,
+     FOR = 304,
+     DO = 305,
+     SLEEP = 306,
+     OR = 307
+   };
+#endif
+/* Tokens.  */
+#define INT 258
+#define STRING 259
+#define ID 260
+#define DIR 261
+#define CONST 262
+#define PROCEDURE 263
+#define CALL 264
+#define SILENT 265
+#define LOCAL 266
+#define SHL 267
+#define SHR 268
+#define EQ 269
+#define NEQ 270
+#define GTE 271
+#define LTE 272
+#define ANDAND 273
+#define OROR 274
+#define SCRIPT_DATA 275
+#define TO 276
+#define TOWARDS 277
+#define TELEPORT_ANCHOR 278
+#define SPELL 279
+#define LET 280
+#define IN 281
+#define END 282
+#define DARROW 283
+#define STRING_TY 284
+#define REQUIRE 285
+#define CATALYSTS 286
+#define COMPONENTS 287
+#define MANA 288
+#define CASTTIME 289
+#define SKIP 290
+#define ABORT 291
+#define BREAK 292
+#define EFFECT 293
+#define ATEND 294
+#define ATTRIGGER 295
+#define PC_F 296
+#define MOB_F 297
+#define ENTITY_F 298
+#define TARGET_F 299
+#define IF 300
+#define THEN 301
+#define ELSE 302
+#define FOREACH 303
+#define FOR 304
+#define DO 305
+#define SLEEP 306
+#define OR 307
+
+
+
+
+/* Copy the first part of user declarations.  */
+#line 1 "magic-interpreter-parser.y"
+
+#include "magic-interpreter.h"
+#include "magic-expr.h"
+#include <stdarg.h>
+
+magic_conf_t magic_conf;
+
+static int
+intern_id(char *id_name);
+
+
+static expr_t *
+fun_expr(char *name, int args_nr, expr_t **args, int line, int column);
+
+#define BIN_EXPR(x, name, arg1, arg2, line, column) { expr_t *e[2]; e[0] = arg1; e[1] = arg2; x = fun_expr(name, 2, e, line, column); }
+
+static int failed_flag = 0;
+
+static void
+magic_frontend_error(const char *msg);
+
+static void
+fail(int line, int column, char *fmt, ...);
+
+static spell_t *
+new_spell(spellguard_t *guard);
+
+static spellguard_t *
+spellguard_implication(spellguard_t *a, spellguard_t *b);
+
+static spellguard_t *
+new_spellguard(int ty);
+
+static effect_t *
+new_effect(int ty);
+
+static effect_t *
+set_effect_continuation(effect_t *src, effect_t *continuation);
+
+static void
+add_spell(spell_t *spell, int line_nr);
+
+static void
+add_teleport_anchor(teleport_anchor_t *anchor, int line_nr);
+
+static effect_t *
+op_effect(char *name, int args_nr, expr_t **args, int line, int column);
+
+int
+magic_frontend_lex();
+
+static void
+install_proc(proc_t *proc);
+
+static effect_t *
+call_proc(char *name, int args_nr, expr_t **args, int line_nr, int column);
+
+static void
+bind_constant(char *name, val_t *val, int line_nr);
+
+static val_t *
+find_constant(char *name);
+
+
+
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* Enabling the token table.  */
+#ifndef YYTOKEN_TABLE
+# define YYTOKEN_TABLE 0
+#endif
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
+#line 71 "magic-interpreter-parser.y"
+{
+    int i;
+    char *s;
+    int op;
+    magic_conf_t *magic_conf;
+    val_t value;
+    expr_t *expr;
+    e_location_t location;
+    e_area_t area;
+    args_rec_t arg_list;
+    struct { int letdefs_nr; letdef_t *letdefs; } letdefs;
+    spell_t *spell;
+    struct { int id, ty; } spellarg_def;
+    letdef_t vardef;
+    spellguard_t *spellguard;
+    component_t *components;
+    struct {int id, count; } component;
+    effect_t *effect;
+    proc_t *proc;
+}
+/* Line 187 of yacc.c.  */
+#line 295 "magic-interpreter-parser.c"
+	YYSTYPE;
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+
+/* Copy the second part of user declarations.  */
+
+
+/* Line 216 of yacc.c.  */
+#line 320 "magic-interpreter-parser.c"
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#elif (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+typedef signed char yytype_int8;
+#else
+typedef short int yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+#  define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+#  define YYSIZE_T size_t
+# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# else
+#  define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if YYENABLE_NLS
+#  if ENABLE_NLS
+#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+#   define YY_(msgid) dgettext ("bison-runtime", msgid)
+#  endif
+# endif
+# ifndef YY_
+#  define YY_(msgid) msgid
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E.  */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(e) ((void) (e))
+#else
+# define YYUSE(e) /* empty */
+#endif
+
+/* Identity function, used to suppress warnings about constant conditions.  */
+#ifndef lint
+# define YYID(n) (n)
+#else
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static int
+YYID (int i)
+#else
+static int
+YYID (i)
+    int i;
+#endif
+{
+  return i;
+}
+#endif
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   elif defined __BUILTIN_VA_ARG_INCR
+#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
+#   elif defined _AIX
+#    define YYSTACK_ALLOC __alloca
+#   elif defined _MSC_VER
+#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
+#    define alloca _alloca
+#   else
+#    define YYSTACK_ALLOC alloca
+#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#     ifndef _STDLIB_H
+#      define _STDLIB_H 1
+#     endif
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's `empty if-body' warning.  */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+    /* The OS might guarantee only one guard page at the bottom of the stack,
+       and a page size can be as small as 4096 bytes.  So we cannot safely
+       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
+       to allow for a few compiler-allocated temporary stack slots.  */
+#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+#  endif
+# else
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+#  ifndef YYSTACK_ALLOC_MAXIMUM
+#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+#  endif
+#  if (defined __cplusplus && ! defined _STDLIB_H \
+       && ! ((defined YYMALLOC || defined malloc) \
+	     && (defined YYFREE || defined free)))
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   ifndef _STDLIB_H
+#    define _STDLIB_H 1
+#   endif
+#  endif
+#  ifndef YYMALLOC
+#   define YYMALLOC malloc
+#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+#  ifndef YYFREE
+#   define YYFREE free
+#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+#   endif
+#  endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+     && (! defined __cplusplus \
+	 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
+	     && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  yytype_int16 yyss;
+  YYSTYPE yyvs;
+    YYLTYPE yyls;
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+      + 2 * YYSTACK_GAP_MAXIMUM)
+
+/* Copy COUNT objects from FROM to TO.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#  else
+#   define YYCOPY(To, From, Count)		\
+      do					\
+	{					\
+	  YYSIZE_T yyi;				\
+	  for (yyi = 0; yyi < (Count); yyi++)	\
+	    (To)[yyi] = (From)[yyi];		\
+	}					\
+      while (YYID (0))
+#  endif
+# endif
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack)					\
+    do									\
+      {									\
+	YYSIZE_T yynewbytes;						\
+	YYCOPY (&yyptr->Stack, Stack, yysize);				\
+	Stack = &yyptr->Stack;						\
+	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+	yyptr += yynewbytes / sizeof (*yyptr);				\
+      }									\
+    while (YYID (0))
+
+#endif
+
+/* YYFINAL -- State number of the termination state.  */
+#define YYFINAL  16
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   920
+
+/* YYNTOKENS -- Number of terminals.  */
+#define YYNTOKENS  72
+/* YYNNTS -- Number of nonterminals.  */
+#define YYNNTS  32
+/* YYNRULES -- Number of rules.  */
+#define YYNRULES  108
+/* YYNRULES -- Number of states.  */
+#define YYNSTATES  247
+
+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   307
+
+#define YYTRANSLATE(YYX)						\
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
+static const yytype_uint8 yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,    14,    22,     2,
+      70,    71,    12,    10,    16,    11,     2,    13,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,    17,    18,
+       8,     7,     9,     2,    15,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,    20,     2,    21,    23,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,    19,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,    24,    25,    26,    27,    28,    29,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
+      62,    63,    64,    65,    66,    67,    68,    69
+};
+
+#if YYDEBUG
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+   YYRHS.  */
+static const yytype_uint16 yyprhs[] =
+{
+       0,     0,     3,     4,     8,     9,    12,    13,    15,    17,
+      21,    25,    30,    37,    45,    54,    55,    58,    61,    62,
+      68,    70,    72,    74,    76,    78,    80,    82,    84,    88,
+      92,    96,   100,   104,   108,   112,   116,   120,   124,   128,
+     132,   136,   140,   144,   148,   152,   156,   160,   165,   169,
+     170,   172,   174,   178,   187,   189,   198,   208,   210,   215,
+     217,   221,   225,   227,   231,   235,   239,   244,   245,   248,
+     249,   252,   254,   258,   262,   264,   268,   271,   274,   277,
+     280,   283,   287,   289,   293,   297,   299,   301,   303,   305,
+     307,   309,   311,   313,   317,   320,   323,   326,   329,   334,
+     342,   351,   358,   363,   367,   373,   375,   382,   383
+};
+
+/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
+static const yytype_int8 yyrhs[] =
+{
+      73,     0,    -1,    -1,    77,    74,    73,    -1,    -1,    74,
+      18,    -1,    -1,    76,    -1,     5,    -1,    76,    16,     5,
+      -1,     5,     7,    82,    -1,    24,     5,     7,    82,    -1,
+      40,     5,    17,    82,     7,    82,    -1,    25,     5,    70,
+      75,    71,     7,   103,    -1,    78,    41,     5,    79,    17,
+      82,     7,    87,    -1,    -1,    28,    78,    -1,    27,    78,
+      -1,    -1,    70,     5,    17,    80,    71,    -1,    58,    -1,
+      46,    -1,     6,    -1,     3,    -1,     4,    -1,    81,    -1,
+       5,    -1,    86,    -1,    82,    10,    82,    -1,    82,    11,
+      82,    -1,    82,    12,    82,    -1,    82,    14,    82,    -1,
+      82,    13,    82,    -1,    82,     8,    82,    -1,    82,     9,
+      82,    -1,    82,    22,    82,    -1,    82,    23,    82,    -1,
+      82,    19,    82,    -1,    82,    29,    82,    -1,    82,    30,
+      82,    -1,    82,    34,    82,    -1,    82,    33,    82,    -1,
+      82,    35,    82,    -1,    82,    36,    82,    -1,    82,    31,
+      82,    -1,    82,     7,    82,    -1,    82,    32,    82,    -1,
+       5,    70,    83,    71,    -1,    70,    82,    71,    -1,    -1,
+      84,    -1,    82,    -1,    84,    16,    82,    -1,    15,    70,
+      82,    16,    82,    16,    82,    71,    -1,    85,    -1,    85,
+      15,    10,    70,    82,    16,    82,    71,    -1,    85,    39,
+      82,    17,    70,    82,    16,    82,    71,    -1,    90,    -1,
+      42,    88,    43,    90,    -1,    74,    -1,    88,    89,    74,
+      -1,     5,     7,    82,    -1,    91,    -1,    91,    19,    90,
+      -1,    94,    45,    91,    -1,    70,    90,    71,    -1,    55,
+     103,    92,    93,    -1,    -1,    57,   103,    -1,    -1,    56,
+     103,    -1,    96,    -1,    94,    69,    94,    -1,    70,    95,
+      71,    -1,    94,    -1,    94,    16,    95,    -1,    47,    82,
+      -1,    48,    97,    -1,    49,    97,    -1,    50,    82,    -1,
+      51,    82,    -1,    20,    98,    21,    -1,    99,    -1,    98,
+      16,    99,    -1,     3,    12,   100,    -1,   100,    -1,     4,
+      -1,     3,    -1,    58,    -1,    59,    -1,    60,    -1,    41,
+      -1,    61,    -1,    70,   103,    71,    -1,    52,    18,    -1,
+      53,    18,    -1,    44,    18,    -1,    54,    18,    -1,     5,
+       7,    82,    18,    -1,    65,   101,     5,    43,    82,    67,
+     102,    -1,    66,     5,     7,    82,    38,    82,    67,   102,
+      -1,    62,    82,    63,   102,    64,   102,    -1,    62,    82,
+      63,   102,    -1,    68,    82,    18,    -1,     5,    70,    83,
+      71,    18,    -1,    37,    -1,    26,     5,    70,    83,    71,
+      18,    -1,    -1,   102,    74,   103,    -1
+};
+
+/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
+static const yytype_uint16 yyrline[] =
+{
+       0,   206,   206,   207,   213,   214,   220,   221,   225,   231,
+     238,   249,   255,   266,   275,   288,   289,   294,   302,   303,
+     309,   311,   316,   319,   322,   328,   331,   342,   345,   347,
+     349,   351,   353,   355,   357,   359,   361,   363,   365,   367,
+     369,   371,   373,   375,   377,   379,   381,   384,   389,   394,
+     395,   400,   405,   412,   416,   420,   426,   436,   438,   447,
+     451,   460,   473,   475,   484,   486,   488,   499,   500,   506,
+     507,   512,   514,   520,   525,   527,   532,   536,   540,   544,
+     548,   555,   560,   564,   571,   573,   578,   587,   592,   594,
+     596,   598,   600,   605,   607,   609,   611,   613,   615,   626,
+     633,   640,   646,   652,   656,   660,   667,   674,   675
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "INT", "STRING", "ID", "DIR", "'='",
+  "'<'", "'>'", "'+'", "'-'", "'*'", "'/'", "'%'", "'@'", "','", "':'",
+  "';'", "'|'", "'['", "']'", "'&'", "'^'", "CONST", "PROCEDURE", "CALL",
+  "SILENT", "LOCAL", "SHL", "SHR", "EQ", "NEQ", "GTE", "LTE", "ANDAND",
+  "OROR", "SCRIPT_DATA", "TO", "TOWARDS", "TELEPORT_ANCHOR", "SPELL",
+  "LET", "IN", "END", "DARROW", "STRING_TY", "REQUIRE", "CATALYSTS",
+  "COMPONENTS", "MANA", "CASTTIME", "SKIP", "ABORT", "BREAK", "EFFECT",
+  "ATEND", "ATTRIGGER", "PC_F", "MOB_F", "ENTITY_F", "TARGET_F", "IF",
+  "THEN", "ELSE", "FOREACH", "FOR", "DO", "SLEEP", "OR", "'('", "')'",
+  "$accept", "spellconf", "semicolons", "proc_formals_list",
+  "proc_formals_list_ne", "spellconf_option", "spell_flags", "argopt",
+  "arg_ty", "value", "expr", "arg_list", "arg_list_ne", "location", "area",
+  "spelldef", "defs", "def", "spellbody_list", "spellbody",
+  "maybe_trigger", "maybe_end", "spellguard", "spellguard_list", "prereq",
+  "items", "item_list", "item", "item_name", "selection", "effect",
+  "effect_list", 0
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+   token YYLEX-NUM.  */
+static const yytype_uint16 yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,    61,    60,    62,
+      43,    45,    42,    47,    37,    64,    44,    58,    59,   124,
+      91,    93,    38,    94,   262,   263,   264,   265,   266,   267,
+     268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
+     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
+     288,   289,   290,   291,   292,   293,   294,   295,   296,   297,
+     298,   299,   300,   301,   302,   303,   304,   305,   306,   307,
+      40,    41
+};
+# endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const yytype_uint8 yyr1[] =
+{
+       0,    72,    73,    73,    74,    74,    75,    75,    76,    76,
+      77,    77,    77,    77,    77,    78,    78,    78,    79,    79,
+      80,    80,    81,    81,    81,    82,    82,    82,    82,    82,
+      82,    82,    82,    82,    82,    82,    82,    82,    82,    82,
+      82,    82,    82,    82,    82,    82,    82,    82,    82,    83,
+      83,    84,    84,    85,    86,    86,    86,    87,    87,    88,
+      88,    89,    90,    90,    91,    91,    91,    92,    92,    93,
+      93,    94,    94,    94,    95,    95,    96,    96,    96,    96,
+      96,    97,    98,    98,    99,    99,   100,   100,   101,   101,
+     101,   101,   101,   102,   102,   102,   102,   102,   102,   102,
+     102,   102,   102,   102,   102,   102,   102,   103,   103
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const yytype_uint8 yyr2[] =
+{
+       0,     2,     0,     3,     0,     2,     0,     1,     1,     3,
+       3,     4,     6,     7,     8,     0,     2,     2,     0,     5,
+       1,     1,     1,     1,     1,     1,     1,     1,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     4,     3,     0,
+       1,     1,     3,     8,     1,     8,     9,     1,     4,     1,
+       3,     3,     1,     3,     3,     3,     4,     0,     2,     0,
+       2,     1,     3,     3,     1,     3,     2,     2,     2,     2,
+       2,     3,     1,     3,     3,     1,     1,     1,     1,     1,
+       1,     1,     1,     3,     2,     2,     2,     2,     4,     7,
+       8,     6,     4,     3,     5,     1,     6,     0,     3
+};
+
+/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
+   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
+   means the default is an error.  */
+static const yytype_uint8 yydefact[] =
+{
+       2,     0,     0,     0,    15,    15,     0,     0,     4,     0,
+       0,     0,     0,    17,    16,     0,     1,     2,     0,    23,
+      24,    26,    22,     0,     0,    25,    10,    54,    27,     0,
+       6,     0,     5,     3,    18,    49,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,    11,
+       8,     0,     7,     0,     0,     0,    51,     0,    50,     0,
+      48,    45,    33,    34,    28,    29,    30,    32,    31,    37,
+      35,    36,    38,    39,    44,    46,    41,    40,    42,    43,
+       0,     0,     0,     0,     0,     0,     0,    47,     0,     0,
+       0,     0,   107,     9,    45,     0,     0,    52,     0,     0,
+       0,     0,     0,   105,     0,     0,     0,     0,     0,     0,
+       0,     0,   107,     4,    13,    21,    20,     0,     0,     0,
+       0,     0,     0,    49,     0,    96,    94,    95,    97,     0,
+      91,    88,    89,    90,    92,     0,     0,     0,     0,   107,
+      19,     4,     0,     0,     0,     0,     0,   107,     0,    14,
+      57,    62,     0,    71,     0,     0,     0,     0,     0,    49,
+       0,     0,     0,   103,    93,   108,    59,     0,    76,     0,
+      77,    78,    79,    80,    67,     0,    74,     0,     0,     0,
+       0,    53,    55,     0,    98,     0,     0,   102,     0,     0,
+       0,     0,     4,    87,    86,     0,    82,    85,   107,    69,
+      65,     0,    73,     0,    63,    64,     0,    72,    56,   104,
+       0,     0,     0,     0,     0,    58,    60,     0,     0,    81,
+      68,   107,    66,    74,    75,   106,   101,     0,     0,    61,
+      87,    84,    83,    70,    99,     0,   100
+};
+
+/* YYDEFGOTO[NTERM-NUM].  */
+static const yytype_int16 yydefgoto[] =
+{
+      -1,     7,    17,    61,    62,     8,     9,    65,   127,    25,
+      66,    67,    68,    27,    28,   159,   177,   202,   185,   161,
+     209,   232,   162,   187,   163,   180,   205,   206,   207,   145,
+     123,   124
+};
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
+#define YYPACT_NINF -170
+static const yytype_int16 yypact[] =
+{
+     100,     5,    18,    53,   -18,   -18,    56,    16,  -170,    26,
+       0,    67,    10,  -170,  -170,    64,  -170,   150,    80,  -170,
+    -170,    17,  -170,    27,     0,  -170,   730,    12,  -170,     0,
+      91,     0,  -170,  -170,    28,     0,     0,   238,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,    89,     0,   730,
+    -170,    31,    93,   760,    99,    90,   730,    39,   101,   520,
+    -170,   109,   877,   877,   890,   890,   236,   236,   236,   109,
+     109,   109,   109,   109,   877,   877,   877,   877,   849,   820,
+      51,   550,   119,   118,     0,   114,     0,  -170,     0,     0,
+       0,    63,   174,  -170,   288,    11,   790,   730,   580,   610,
+       0,     1,   127,  -170,   126,   129,   135,   136,     0,    54,
+     152,     0,   174,  -170,  -170,  -170,  -170,    98,    88,     0,
+       0,   640,     0,     0,   102,  -170,  -170,  -170,  -170,   453,
+    -170,  -170,  -170,  -170,  -170,   154,   163,   670,   105,   155,
+    -170,  -170,     0,   160,   160,     0,     0,   174,   146,  -170,
+    -170,   115,    14,  -170,   268,   311,     0,   700,   111,     0,
+     174,   140,     0,  -170,  -170,  -170,   166,     6,   730,    60,
+    -170,  -170,   730,   730,   128,   131,     9,   132,   116,   116,
+     183,  -170,  -170,   341,  -170,   169,   133,   125,     0,   488,
+     191,   116,  -170,   193,  -170,    -3,  -170,  -170,   174,   156,
+    -170,   183,  -170,   116,  -170,  -170,   183,  -170,  -170,  -170,
+     188,   174,   384,     0,     0,  -170,   166,    62,    60,  -170,
+    -170,   174,  -170,    -9,  -170,  -170,  -170,   174,   414,   730,
+    -170,  -170,  -170,  -170,  -170,   174,  -170
+};
+
+/* YYPGOTO[NTERM-NUM].  */
+static const yytype_int16 yypgoto[] =
+{
+    -170,   198,  -101,  -170,  -170,  -170,    68,  -170,  -170,  -170,
+     -10,  -116,  -170,  -170,  -170,  -170,  -170,  -170,  -126,    21,
+    -170,  -170,  -134,     8,  -170,    70,  -170,    -6,     2,  -170,
+    -169,  -102
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule which
+   number is the opposite.  If zero, do what YYDEFACT says.
+   If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF -16
+static const yytype_int16 yytable[] =
+{
+      26,   197,   160,    19,    20,    21,    22,   211,   132,     4,
+       5,   200,    10,   228,    37,    23,    16,   168,   229,    59,
+     148,    63,   149,    11,   186,   211,    69,    57,    71,    72,
+      73,    74,    75,    76,    77,    78,    79,    80,    81,    82,
+      83,    84,    85,    86,    87,    88,    89,   175,    91,   201,
+     176,    58,   236,   196,   189,   184,   217,   125,    12,   189,
+     190,    15,   214,   203,   204,   240,   204,    18,   244,   126,
+      24,   133,    13,    14,    29,   225,   246,   233,   190,   186,
+      30,    31,   233,   190,   104,    34,   106,    35,   107,   108,
+     109,    19,    20,    21,    22,   140,    60,    36,    64,    90,
+     131,   226,    92,    23,    95,     1,   230,    96,   139,    93,
+      97,   147,   141,   142,   143,   144,    38,    98,    71,   164,
+     165,   100,   167,   103,     2,     3,   102,     4,     5,   243,
+     151,   105,   134,   110,   188,   152,   153,   154,   155,   156,
+       6,   -15,   178,   157,   135,   182,   183,   136,    37,    19,
+      20,    21,    22,   137,   138,     1,   193,   146,   158,   171,
+     111,    23,   199,   152,   153,   154,   155,   156,    32,   150,
+     172,   157,   169,    32,     2,     3,   174,     4,     5,   111,
+     179,   112,   195,   198,    32,   208,   213,   219,   222,   221,
+       6,   -15,   113,   152,   153,   154,   155,   156,   224,   114,
+     112,   157,   210,   212,   220,   227,   235,   115,   116,   117,
+     215,   113,   231,   238,   239,    33,   158,   118,   114,   234,
+     119,   120,   242,   121,   181,   122,   115,   116,   117,   241,
+     152,   153,   154,   155,   156,     0,   118,     0,     0,   119,
+     120,     0,   121,    38,   122,    38,    39,    40,    41,    42,
+      43,    44,    45,   216,     0,    46,     0,    46,    47,    48,
+      47,    48,     0,     0,     0,    49,    50,    49,    50,    51,
+      52,    53,    54,    55,    56,    38,    39,    40,    41,    42,
+      43,    44,    45,     0,     0,     0,     0,    46,   -12,     0,
+      47,    48,     0,   -12,     0,    38,     0,    49,    50,    51,
+      52,    53,    54,    55,    56,     0,   -12,     0,     0,    70,
+       0,     0,   -12,   -12,     0,   -12,   -12,     0,    38,    39,
+      40,    41,    42,    43,    44,    45,     0,     0,   -12,   -12,
+      46,     0,     0,    47,    48,     0,     0,     0,     0,   191,
+      49,    50,    51,    52,    53,    54,    55,    56,    38,    39,
+      40,    41,    42,    43,    44,    45,     0,     0,     0,     0,
+      46,     0,     0,    47,    48,     0,     0,     0,     0,     0,
+      49,    50,    51,    52,    53,    54,    55,    56,     0,     0,
+       0,     0,   192,     0,     0,     0,     0,     0,     0,     0,
+       0,    38,    39,    40,    41,    42,    43,    44,    45,     0,
+       0,     0,     0,    46,     0,     0,    47,    48,     0,     0,
+       0,     0,   218,    49,    50,    51,    52,    53,    54,    55,
+      56,    38,    39,    40,    41,    42,    43,    44,    45,     0,
+       0,     0,     0,    46,     0,     0,    47,    48,     0,     0,
+       0,     0,     0,    49,    50,    51,    52,    53,    54,    55,
+      56,   237,     0,     0,     0,     0,     0,     0,     0,     0,
+      38,    39,    40,    41,    42,    43,    44,    45,     0,     0,
+       0,     0,    46,     0,     0,    47,    48,     0,     0,     0,
+       0,   245,    49,    50,    51,    52,    53,    54,    55,    56,
+       0,     0,     0,     0,     0,    38,    39,    40,    41,    42,
+      43,    44,    45,     0,     0,     0,     0,    46,     0,     0,
+      47,    48,     0,     0,     0,     0,   170,    49,    50,    51,
+      52,    53,    54,    55,    56,     0,   223,    38,    39,    40,
+      41,    42,    43,    44,    45,     0,    99,     0,     0,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50,    51,    52,    53,    54,    55,    56,    38,    39,    40,
+      41,    42,    43,    44,    45,     0,     0,   101,     0,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50,    51,    52,    53,    54,    55,    56,    38,    39,    40,
+      41,    42,    43,    44,    45,     0,   129,     0,     0,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50,    51,    52,    53,    54,    55,    56,    38,    39,    40,
+      41,    42,    43,    44,    45,     0,   130,     0,     0,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50,    51,    52,    53,    54,    55,    56,    38,    39,    40,
+      41,    42,    43,    44,    45,     0,   166,     0,     0,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50,    51,    52,    53,    54,    55,    56,    38,    39,    40,
+      41,    42,    43,    44,    45,     0,     0,     0,   173,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50,    51,    52,    53,    54,    55,    56,    38,    39,    40,
+      41,    42,    43,    44,    45,     0,     0,     0,   194,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50,    51,    52,    53,    54,    55,    56,    38,    39,    40,
+      41,    42,    43,    44,    45,     0,     0,     0,     0,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50,    51,    52,    53,    54,    55,    56,    94,    39,    40,
+      41,    42,    43,    44,    45,     0,     0,     0,     0,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50,    51,    52,    53,    54,    55,    56,   128,    39,    40,
+      41,    42,    43,    44,    45,     0,     0,     0,     0,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50,    51,    52,    53,    54,    55,    56,    38,    39,    40,
+      41,    42,    43,    44,    45,     0,     0,     0,     0,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50,    51,    52,    53,    54,    55,    38,    39,    40,    41,
+      42,    43,    44,    45,     0,     0,     0,     0,    46,     0,
+       0,    47,    48,     0,     0,     0,     0,     0,    49,    50,
+      51,    52,    53,    54,    38,     0,     0,    41,    42,    43,
+      44,    45,     0,     0,     0,     0,    46,    38,     0,    47,
+      48,     0,    43,    44,    45,     0,    49,    50,     0,    46,
+       0,     0,    47,    48,     0,     0,     0,     0,     0,    49,
+      50
+};
+
+static const yytype_int16 yycheck[] =
+{
+      10,   170,   128,     3,     4,     5,     6,    16,     7,    27,
+      28,     5,     7,    16,    24,    15,     0,   133,    21,    29,
+     122,    31,   123,     5,   158,    16,    36,    15,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53,    54,    55,    56,   149,    58,    43,
+     151,    39,   221,   169,    45,   157,   190,    46,     5,    45,
+      69,     5,   188,     3,     4,     3,     4,    41,   237,    58,
+      70,    70,     4,     5,     7,   201,   245,   211,    69,   213,
+      70,    17,   216,    69,    94,     5,    96,    70,    98,    99,
+     100,     3,     4,     5,     6,    41,     5,    70,    70,    10,
+     110,   202,    71,    15,     5,     5,   208,    17,   118,    16,
+      71,   121,    58,    59,    60,    61,     7,    16,   128,   129,
+     130,    70,   132,     5,    24,    25,     7,    27,    28,   231,
+      42,    17,     5,    70,    19,    47,    48,    49,    50,    51,
+      40,    41,   152,    55,    18,   155,   156,    18,   158,     3,
+       4,     5,     6,    18,    18,     5,   166,     5,    70,     5,
+       5,    15,   172,    47,    48,    49,    50,    51,    18,    71,
+       7,    55,    70,    18,    24,    25,    71,    27,    28,     5,
+      20,    26,    71,    43,    18,    57,    70,    18,   198,    64,
+      40,    41,    37,    47,    48,    49,    50,    51,     7,    44,
+      26,    55,    71,    71,    71,    12,    18,    52,    53,    54,
+     189,    37,    56,   223,   224,    17,    70,    62,    44,   211,
+      65,    66,   228,    68,   154,    70,    52,    53,    54,   227,
+      47,    48,    49,    50,    51,    -1,    62,    -1,    -1,    65,
+      66,    -1,    68,     7,    70,     7,     8,     9,    10,    11,
+      12,    13,    14,    70,    -1,    19,    -1,    19,    22,    23,
+      22,    23,    -1,    -1,    -1,    29,    30,    29,    30,    31,
+      32,    33,    34,    35,    36,     7,     8,     9,    10,    11,
+      12,    13,    14,    -1,    -1,    -1,    -1,    19,     0,    -1,
+      22,    23,    -1,     5,    -1,     7,    -1,    29,    30,    31,
+      32,    33,    34,    35,    36,    -1,    18,    -1,    -1,    71,
+      -1,    -1,    24,    25,    -1,    27,    28,    -1,     7,     8,
+       9,    10,    11,    12,    13,    14,    -1,    -1,    40,    41,
+      19,    -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    71,
+      29,    30,    31,    32,    33,    34,    35,    36,     7,     8,
+       9,    10,    11,    12,    13,    14,    -1,    -1,    -1,    -1,
+      19,    -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,
+      29,    30,    31,    32,    33,    34,    35,    36,    -1,    -1,
+      -1,    -1,    71,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,     7,     8,     9,    10,    11,    12,    13,    14,    -1,
+      -1,    -1,    -1,    19,    -1,    -1,    22,    23,    -1,    -1,
+      -1,    -1,    71,    29,    30,    31,    32,    33,    34,    35,
+      36,     7,     8,     9,    10,    11,    12,    13,    14,    -1,
+      -1,    -1,    -1,    19,    -1,    -1,    22,    23,    -1,    -1,
+      -1,    -1,    -1,    29,    30,    31,    32,    33,    34,    35,
+      36,    67,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+       7,     8,     9,    10,    11,    12,    13,    14,    -1,    -1,
+      -1,    -1,    19,    -1,    -1,    22,    23,    -1,    -1,    -1,
+      -1,    67,    29,    30,    31,    32,    33,    34,    35,    36,
+      -1,    -1,    -1,    -1,    -1,     7,     8,     9,    10,    11,
+      12,    13,    14,    -1,    -1,    -1,    -1,    19,    -1,    -1,
+      22,    23,    -1,    -1,    -1,    -1,    63,    29,    30,    31,
+      32,    33,    34,    35,    36,    -1,    38,     7,     8,     9,
+      10,    11,    12,    13,    14,    -1,    16,    -1,    -1,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30,    31,    32,    33,    34,    35,    36,     7,     8,     9,
+      10,    11,    12,    13,    14,    -1,    -1,    17,    -1,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30,    31,    32,    33,    34,    35,    36,     7,     8,     9,
+      10,    11,    12,    13,    14,    -1,    16,    -1,    -1,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30,    31,    32,    33,    34,    35,    36,     7,     8,     9,
+      10,    11,    12,    13,    14,    -1,    16,    -1,    -1,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30,    31,    32,    33,    34,    35,    36,     7,     8,     9,
+      10,    11,    12,    13,    14,    -1,    16,    -1,    -1,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30,    31,    32,    33,    34,    35,    36,     7,     8,     9,
+      10,    11,    12,    13,    14,    -1,    -1,    -1,    18,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30,    31,    32,    33,    34,    35,    36,     7,     8,     9,
+      10,    11,    12,    13,    14,    -1,    -1,    -1,    18,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30,    31,    32,    33,    34,    35,    36,     7,     8,     9,
+      10,    11,    12,    13,    14,    -1,    -1,    -1,    -1,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30,    31,    32,    33,    34,    35,    36,     7,     8,     9,
+      10,    11,    12,    13,    14,    -1,    -1,    -1,    -1,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30,    31,    32,    33,    34,    35,    36,     7,     8,     9,
+      10,    11,    12,    13,    14,    -1,    -1,    -1,    -1,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30,    31,    32,    33,    34,    35,    36,     7,     8,     9,
+      10,    11,    12,    13,    14,    -1,    -1,    -1,    -1,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30,    31,    32,    33,    34,    35,     7,     8,     9,    10,
+      11,    12,    13,    14,    -1,    -1,    -1,    -1,    19,    -1,
+      -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,    30,
+      31,    32,    33,    34,     7,    -1,    -1,    10,    11,    12,
+      13,    14,    -1,    -1,    -1,    -1,    19,     7,    -1,    22,
+      23,    -1,    12,    13,    14,    -1,    29,    30,    -1,    19,
+      -1,    -1,    22,    23,    -1,    -1,    -1,    -1,    -1,    29,
+      30
+};
+
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+   symbol of state STATE-NUM.  */
+static const yytype_uint8 yystos[] =
+{
+       0,     5,    24,    25,    27,    28,    40,    73,    77,    78,
+       7,     5,     5,    78,    78,     5,     0,    74,    41,     3,
+       4,     5,     6,    15,    70,    81,    82,    85,    86,     7,
+      70,    17,    18,    73,     5,    70,    70,    82,     7,     8,
+       9,    10,    11,    12,    13,    14,    19,    22,    23,    29,
+      30,    31,    32,    33,    34,    35,    36,    15,    39,    82,
+       5,    75,    76,    82,    70,    79,    82,    83,    84,    82,
+      71,    82,    82,    82,    82,    82,    82,    82,    82,    82,
+      82,    82,    82,    82,    82,    82,    82,    82,    82,    82,
+      10,    82,    71,    16,     7,     5,    17,    71,    16,    16,
+      70,    17,     7,     5,    82,    17,    82,    82,    82,    82,
+      70,     5,    26,    37,    44,    52,    53,    54,    62,    65,
+      66,    68,    70,   102,   103,    46,    58,    80,     7,    16,
+      16,    82,     7,    70,     5,    18,    18,    18,    18,    82,
+      41,    58,    59,    60,    61,   101,     5,    82,   103,    74,
+      71,    42,    47,    48,    49,    50,    51,    55,    70,    87,
+      90,    91,    94,    96,    82,    82,    16,    82,    83,    70,
+      63,     5,     7,    18,    71,   103,    74,    88,    82,    20,
+      97,    97,    82,    82,   103,    90,    94,    95,    19,    45,
+      69,    71,    71,    82,    18,    71,    83,   102,    43,    82,
+       5,    43,    89,     3,     4,    98,    99,   100,    57,    92,
+      71,    16,    71,    70,    90,    91,    70,    94,    71,    18,
+      71,    64,    82,    38,     7,    90,    74,    12,    16,    21,
+     103,    56,    93,    94,    95,    18,   102,    67,    82,    82,
+       3,   100,    99,   103,   102,    67,   102
+};
+
+#define yyerrok		(yyerrstatus = 0)
+#define yyclearin	(yychar = YYEMPTY)
+#define YYEMPTY		(-2)
+#define YYEOF		0
+
+#define YYACCEPT	goto yyacceptlab
+#define YYABORT		goto yyabortlab
+#define YYERROR		goto yyerrorlab
+
+
+/* Like YYERROR except do call yyerror.  This remains here temporarily
+   to ease the transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  */
+
+#define YYFAIL		goto yyerrlab
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)					\
+do								\
+  if (yychar == YYEMPTY && yylen == 1)				\
+    {								\
+      yychar = (Token);						\
+      yylval = (Value);						\
+      yytoken = YYTRANSLATE (yychar);				\
+      YYPOPSTACK (1);						\
+      goto yybackup;						\
+    }								\
+  else								\
+    {								\
+      yyerror (YY_("syntax error: cannot back up")); \
+      YYERROR;							\
+    }								\
+while (YYID (0))
+
+
+#define YYTERROR	1
+#define YYERRCODE	256
+
+
+/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
+   If N is 0, then set CURRENT to the empty location which ends
+   the previous symbol: RHS[0] (always defined).  */
+
+#define YYRHSLOC(Rhs, K) ((Rhs)[K])
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)				\
+    do									\
+      if (YYID (N))                                                    \
+	{								\
+	  (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;	\
+	  (Current).first_column = YYRHSLOC (Rhs, 1).first_column;	\
+	  (Current).last_line    = YYRHSLOC (Rhs, N).last_line;		\
+	  (Current).last_column  = YYRHSLOC (Rhs, N).last_column;	\
+	}								\
+      else								\
+	{								\
+	  (Current).first_line   = (Current).last_line   =		\
+	    YYRHSLOC (Rhs, 0).last_line;				\
+	  (Current).first_column = (Current).last_column =		\
+	    YYRHSLOC (Rhs, 0).last_column;				\
+	}								\
+    while (YYID (0))
+#endif
+
+
+/* YY_LOCATION_PRINT -- Print the location on the stream.
+   This macro was not mandated originally: define only if we know
+   we won't break user code: when these are the locations we know.  */
+
+#ifndef YY_LOCATION_PRINT
+# if YYLTYPE_IS_TRIVIAL
+#  define YY_LOCATION_PRINT(File, Loc)			\
+     fprintf (File, "%d.%d-%d.%d",			\
+	      (Loc).first_line, (Loc).first_column,	\
+	      (Loc).last_line,  (Loc).last_column)
+# else
+#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+# endif
+#endif
+
+
+/* YYLEX -- calling `yylex' with the right arguments.  */
+
+#ifdef YYLEX_PARAM
+# define YYLEX yylex (YYLEX_PARAM)
+#else
+# define YYLEX yylex ()
+#endif
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)			\
+do {						\
+  if (yydebug)					\
+    YYFPRINTF Args;				\
+} while (YYID (0))
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)			  \
+do {									  \
+  if (yydebug)								  \
+    {									  \
+      YYFPRINTF (stderr, "%s ", Title);					  \
+      yy_symbol_print (stderr,						  \
+		  Type, Value, Location); \
+      YYFPRINTF (stderr, "\n");						  \
+    }									  \
+} while (YYID (0))
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
+#else
+static void
+yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
+    YYLTYPE const * const yylocationp;
+#endif
+{
+  if (!yyvaluep)
+    return;
+  YYUSE (yylocationp);
+# ifdef YYPRINT
+  if (yytype < YYNTOKENS)
+    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# else
+  YYUSE (yyoutput);
+# endif
+  switch (yytype)
+    {
+      default:
+	break;
+    }
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
+#else
+static void
+yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE const * const yyvaluep;
+    YYLTYPE const * const yylocationp;
+#endif
+{
+  if (yytype < YYNTOKENS)
+    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+  else
+    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+
+  YY_LOCATION_PRINT (yyoutput, *yylocationp);
+  YYFPRINTF (yyoutput, ": ");
+  yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp);
+  YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
+#else
+static void
+yy_stack_print (bottom, top)
+    yytype_int16 *bottom;
+    yytype_int16 *top;
+#endif
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)				\
+do {								\
+  if (yydebug)							\
+    yy_stack_print ((Bottom), (Top));				\
+} while (YYID (0))
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule)
+#else
+static void
+yy_reduce_print (yyvsp, yylsp, yyrule)
+    YYSTYPE *yyvsp;
+    YYLTYPE *yylsp;
+    int yyrule;
+#endif
+{
+  int yynrhs = yyr2[yyrule];
+  int yyi;
+  unsigned long int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+	     yyrule - 1, yylno);
+  /* The symbols being reduced.  */
+  for (yyi = 0; yyi < yynrhs; yyi++)
+    {
+      fprintf (stderr, "   $%d = ", yyi + 1);
+      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
+		       &(yyvsp[(yyi + 1) - (yynrhs)])
+		       , &(yylsp[(yyi + 1) - (yynrhs)])		       );
+      fprintf (stderr, "\n");
+    }
+}
+
+# define YY_REDUCE_PRINT(Rule)		\
+do {					\
+  if (yydebug)				\
+    yy_reduce_print (yyvsp, yylsp, Rule); \
+} while (YYID (0))
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef	YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined __GLIBC__ && defined _STRING_H
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static YYSIZE_T
+yystrlen (const char *yystr)
+#else
+static YYSIZE_T
+yystrlen (yystr)
+    const char *yystr;
+#endif
+{
+  YYSIZE_T yylen;
+  for (yylen = 0; yystr[yylen]; yylen++)
+    continue;
+  return yylen;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+#else
+static char *
+yystpcpy (yydest, yysrc)
+    char *yydest;
+    const char *yysrc;
+#endif
+{
+  char *yyd = yydest;
+  const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+   quotes and backslashes, so that it's suitable for yyerror.  The
+   heuristic is that double-quoting is unnecessary unless the string
+   contains an apostrophe, a comma, or backslash (other than
+   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
+   null, do not copy; instead, return the length of what the result
+   would have been.  */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+  if (*yystr == '"')
+    {
+      YYSIZE_T yyn = 0;
+      char const *yyp = yystr;
+
+      for (;;)
+	switch (*++yyp)
+	  {
+	  case '\'':
+	  case ',':
+	    goto do_not_strip_quotes;
+
+	  case '\\':
+	    if (*++yyp != '\\')
+	      goto do_not_strip_quotes;
+	    /* Fall through.  */
+	  default:
+	    if (yyres)
+	      yyres[yyn] = *yyp;
+	    yyn++;
+	    break;
+
+	  case '"':
+	    if (yyres)
+	      yyres[yyn] = '\0';
+	    return yyn;
+	  }
+    do_not_strip_quotes: ;
+    }
+
+  if (! yyres)
+    return yystrlen (yystr);
+
+  return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into YYRESULT an error message about the unexpected token
+   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
+   including the terminating null byte.  If YYRESULT is null, do not
+   copy anything; just return the number of bytes that would be
+   copied.  As a special case, return 0 if an ordinary "syntax error"
+   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
+   size calculation.  */
+static YYSIZE_T
+yysyntax_error (char *yyresult, int yystate, int yychar)
+{
+  int yyn = yypact[yystate];
+
+  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
+    return 0;
+  else
+    {
+      int yytype = YYTRANSLATE (yychar);
+      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
+      YYSIZE_T yysize = yysize0;
+      YYSIZE_T yysize1;
+      int yysize_overflow = 0;
+      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+      int yyx;
+
+# if 0
+      /* This is so xgettext sees the translatable formats that are
+	 constructed on the fly.  */
+      YY_("syntax error, unexpected %s");
+      YY_("syntax error, unexpected %s, expecting %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
+      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
+# endif
+      char *yyfmt;
+      char const *yyf;
+      static char const yyunexpected[] = "syntax error, unexpected %s";
+      static char const yyexpecting[] = ", expecting %s";
+      static char const yyor[] = " or %s";
+      char yyformat[sizeof yyunexpected
+		    + sizeof yyexpecting - 1
+		    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
+		       * (sizeof yyor - 1))];
+      char const *yyprefix = yyexpecting;
+
+      /* Start YYX at -YYN if negative to avoid negative indexes in
+	 YYCHECK.  */
+      int yyxbegin = yyn < 0 ? -yyn : 0;
+
+      /* Stay within bounds of both yycheck and yytname.  */
+      int yychecklim = YYLAST - yyn + 1;
+      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+      int yycount = 1;
+
+      yyarg[0] = yytname[yytype];
+      yyfmt = yystpcpy (yyformat, yyunexpected);
+
+      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+	  {
+	    if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+	      {
+		yycount = 1;
+		yysize = yysize0;
+		yyformat[sizeof yyunexpected - 1] = '\0';
+		break;
+	      }
+	    yyarg[yycount++] = yytname[yyx];
+	    yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+	    yysize_overflow |= (yysize1 < yysize);
+	    yysize = yysize1;
+	    yyfmt = yystpcpy (yyfmt, yyprefix);
+	    yyprefix = yyor;
+	  }
+
+      yyf = YY_(yyformat);
+      yysize1 = yysize + yystrlen (yyf);
+      yysize_overflow |= (yysize1 < yysize);
+      yysize = yysize1;
+
+      if (yysize_overflow)
+	return YYSIZE_MAXIMUM;
+
+      if (yyresult)
+	{
+	  /* Avoid sprintf, as that infringes on the user's name space.
+	     Don't have undefined behavior even if the translation
+	     produced a string with the wrong number of "%s"s.  */
+	  char *yyp = yyresult;
+	  int yyi = 0;
+	  while ((*yyp = *yyf) != '\0')
+	    {
+	      if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
+		{
+		  yyp += yytnamerr (yyp, yyarg[yyi++]);
+		  yyf += 2;
+		}
+	      else
+		{
+		  yyp++;
+		  yyf++;
+		}
+	    }
+	}
+      return yysize;
+    }
+}
+#endif /* YYERROR_VERBOSE */
+
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+/*ARGSUSED*/
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
+#else
+static void
+yydestruct (yymsg, yytype, yyvaluep, yylocationp)
+    const char *yymsg;
+    int yytype;
+    YYSTYPE *yyvaluep;
+    YYLTYPE *yylocationp;
+#endif
+{
+  YYUSE (yyvaluep);
+  YYUSE (yylocationp);
+
+  if (!yymsg)
+    yymsg = "Deleting";
+  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+  switch (yytype)
+    {
+
+      default:
+	break;
+    }
+}
+
+
+/* Prevent warnings from -Wmissing-prototypes.  */
+
+#ifdef YYPARSE_PARAM
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void *YYPARSE_PARAM);
+#else
+int yyparse ();
+#endif
+#else /* ! YYPARSE_PARAM */
+#if defined __STDC__ || defined __cplusplus
+int yyparse (void);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
+
+
+
+/* The look-ahead symbol.  */
+int yychar;
+
+/* The semantic value of the look-ahead symbol.  */
+YYSTYPE yylval;
+
+/* Number of syntax errors so far.  */
+int yynerrs;
+/* Location data for the look-ahead symbol.  */
+YYLTYPE yylloc;
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+#ifdef YYPARSE_PARAM
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void *YYPARSE_PARAM)
+#else
+int
+yyparse (YYPARSE_PARAM)
+    void *YYPARSE_PARAM;
+#endif
+#else /* ! YYPARSE_PARAM */
+#if (defined __STDC__ || defined __C99__FUNC__ \
+     || defined __cplusplus || defined _MSC_VER)
+int
+yyparse (void)
+#else
+int
+yyparse ()
+
+#endif
+#endif
+{
+  
+  int yystate;
+  int yyn;
+  int yyresult;
+  /* Number of tokens to shift before error messages enabled.  */
+  int yyerrstatus;
+  /* Look-ahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+#if YYERROR_VERBOSE
+  /* Buffer for error messages, and its allocated size.  */
+  char yymsgbuf[128];
+  char *yymsg = yymsgbuf;
+  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+  /* Three stacks and their tools:
+     `yyss': related to states,
+     `yyvs': related to semantic values,
+     `yyls': related to locations.
+
+     Refer to the stacks thru separate pointers, to allow yyoverflow
+     to reallocate them elsewhere.  */
+
+  /* The state stack.  */
+  yytype_int16 yyssa[YYINITDEPTH];
+  yytype_int16 *yyss = yyssa;
+  yytype_int16 *yyssp;
+
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  YYSTYPE *yyvsp;
+
+  /* The location stack.  */
+  YYLTYPE yylsa[YYINITDEPTH];
+  YYLTYPE *yyls = yylsa;
+  YYLTYPE *yylsp;
+  /* The locations where the error started and ended.  */
+  YYLTYPE yyerror_range[2];
+
+#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
+
+  YYSIZE_T yystacksize = YYINITDEPTH;
+
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+  YYLTYPE yyloc;
+
+  /* The number of symbols on the RHS of the reduced rule.
+     Keep to zero when no symbol should be popped.  */
+  int yylen = 0;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+
+  yyssp = yyss;
+  yyvsp = yyvs;
+  yylsp = yyls;
+#if YYLTYPE_IS_TRIVIAL
+  /* Initialize the default location before parsing starts.  */
+  yylloc.first_line   = yylloc.last_line   = 1;
+  yylloc.first_column = yylloc.last_column = 0;
+#endif
+
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed.  So pushing a state here evens the stacks.  */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+	/* Give user a chance to reallocate the stack.  Use copies of
+	   these so that the &'s don't force the real ones into
+	   memory.  */
+	YYSTYPE *yyvs1 = yyvs;
+	yytype_int16 *yyss1 = yyss;
+	YYLTYPE *yyls1 = yyls;
+
+	/* Each stack pointer address is followed by the size of the
+	   data in use in that stack, in bytes.  This used to be a
+	   conditional around just the two extra args, but that might
+	   be undefined if yyoverflow is a macro.  */
+	yyoverflow (YY_("memory exhausted"),
+		    &yyss1, yysize * sizeof (*yyssp),
+		    &yyvs1, yysize * sizeof (*yyvsp),
+		    &yyls1, yysize * sizeof (*yylsp),
+		    &yystacksize);
+	yyls = yyls1;
+	yyss = yyss1;
+	yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyexhaustedlab;
+# else
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+	goto yyexhaustedlab;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+	yystacksize = YYMAXDEPTH;
+
+      {
+	yytype_int16 *yyss1 = yyss;
+	union yyalloc *yyptr =
+	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+	if (! yyptr)
+	  goto yyexhaustedlab;
+	YYSTACK_RELOCATE (yyss);
+	YYSTACK_RELOCATE (yyvs);
+	YYSTACK_RELOCATE (yyls);
+#  undef YYSTACK_RELOCATE
+	if (yyss1 != yyssa)
+	  YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+      yylsp = yyls + yysize - 1;
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+		  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
+	YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  goto yybackup;
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+  /* Do appropriate processing given the current state.  Read a
+     look-ahead token if we need one and don't already have one.  */
+
+  /* First try to decide what to do without reference to look-ahead token.  */
+  yyn = yypact[yystate];
+  if (yyn == YYPACT_NINF)
+    goto yydefault;
+
+  /* Not known => get a look-ahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = YYLEX;
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yyn == 0 || yyn == YYTABLE_NINF)
+	goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  /* Shift the look-ahead token.  */
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+  /* Discard the shifted token unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
+  yystate = yyn;
+  *++yyvsp = yylval;
+  *++yylsp = yylloc;
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     `$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+  /* Default location.  */
+  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+        case 2:
+#line 206 "magic-interpreter-parser.y"
+    {;}
+    break;
+
+  case 3:
+#line 208 "magic-interpreter-parser.y"
+    {;}
+    break;
+
+  case 4:
+#line 213 "magic-interpreter-parser.y"
+    {;}
+    break;
+
+  case 5:
+#line 215 "magic-interpreter-parser.y"
+    {;}
+    break;
+
+  case 6:
+#line 220 "magic-interpreter-parser.y"
+    { (yyval.proc) = aCalloc(sizeof(proc_t), 1); ;}
+    break;
+
+  case 7:
+#line 222 "magic-interpreter-parser.y"
+    { (yyval.proc) = (yyvsp[(1) - (1)].proc); ;}
+    break;
+
+  case 8:
+#line 226 "magic-interpreter-parser.y"
+    { (yyval.proc) = aCalloc(sizeof(proc_t), 1);
+                            (yyval.proc)->args_nr = 1;
+                            (yyval.proc)->args = malloc(sizeof(int));
+                            (yyval.proc)->args[0] = intern_id((yyvsp[(1) - (1)].s));
+                          ;}
+    break;
+
+  case 9:
+#line 232 "magic-interpreter-parser.y"
+    { (yyval.proc) = (yyvsp[(1) - (3)].proc);
+                            (yyval.proc)->args = realloc((yyval.proc)->args, sizeof(int) * (1 + (yyval.proc)->args_nr));
+                            (yyval.proc)->args[(yyval.proc)->args_nr++] = intern_id((yyvsp[(3) - (3)].s));
+                          ;}
+    break;
+
+  case 10:
+#line 239 "magic-interpreter-parser.y"
+    {
+                            int var_id;
+                            if (find_constant((yyvsp[(1) - (3)].s))) {
+                                    fail((yylsp[(1) - (3)]).first_line, 0, "Attempt to redefine constant `%s' as global\n", (yyvsp[(1) - (3)].s));
+                                    free((yyvsp[(1) - (3)].s));
+                            } else {
+                                    var_id = intern_id((yyvsp[(1) - (3)].s));
+                                    magic_eval(&magic_default_env, &magic_conf.vars[var_id], (yyvsp[(3) - (3)].expr));
+                            }
+                          ;}
+    break;
+
+  case 11:
+#line 250 "magic-interpreter-parser.y"
+    {
+                            val_t var;
+                            magic_eval(&magic_default_env, &var, (yyvsp[(4) - (4)].expr));
+                            bind_constant((yyvsp[(2) - (4)].s), &var, (yylsp[(1) - (4)]).first_line);
+                          ;}
+    break;
+
+  case 12:
+#line 256 "magic-interpreter-parser.y"
+    {
+                              teleport_anchor_t *anchor = calloc(sizeof(teleport_anchor_t), 1);
+                              anchor->name = (yyvsp[(2) - (6)].s);
+                              anchor->invocation = magic_eval_str(&magic_default_env, (yyvsp[(4) - (6)].expr));
+                              anchor->location = (yyvsp[(6) - (6)].expr);
+
+                              if (!failed_flag)
+                                  add_teleport_anchor(anchor, (yylsp[(1) - (6)]).first_line);
+                              failed_flag = 0;
+                          ;}
+    break;
+
+  case 13:
+#line 267 "magic-interpreter-parser.y"
+    {
+                              proc_t *proc = (yyvsp[(4) - (7)].proc);
+                              proc->name = (yyvsp[(2) - (7)].s);
+                              proc->body = (yyvsp[(7) - (7)].effect);
+                              if (!failed_flag)
+                                  install_proc(proc);
+                              failed_flag = 0;
+                          ;}
+    break;
+
+  case 14:
+#line 276 "magic-interpreter-parser.y"
+    { spell_t *spell = (yyvsp[(8) - (8)].spell);
+                            spell->name = (yyvsp[(3) - (8)].s);
+                            spell->invocation = magic_eval_str(&magic_default_env, (yyvsp[(6) - (8)].expr));
+                            spell->arg = (yyvsp[(4) - (8)].spellarg_def).id;
+                            spell->spellarg_ty = (yyvsp[(4) - (8)].spellarg_def).ty;
+                            spell->flags = (yyvsp[(1) - (8)].i);
+                            if (!failed_flag)
+                                add_spell(spell, (yylsp[(1) - (8)]).first_line);
+                            failed_flag = 0;
+                          ;}
+    break;
+
+  case 15:
+#line 288 "magic-interpreter-parser.y"
+    { (yyval.i) = 0; ;}
+    break;
+
+  case 16:
+#line 290 "magic-interpreter-parser.y"
+    { if ((yyvsp[(2) - (2)].i) & SPELL_FLAG_LOCAL)
+                                        fail((yylsp[(1) - (2)]).first_line, (yylsp[(1) - (2)]).first_column, "`LOCAL' specified more than once");
+                                   (yyval.i) = (yyvsp[(2) - (2)].i) | SPELL_FLAG_LOCAL;
+                                ;}
+    break;
+
+  case 17:
+#line 295 "magic-interpreter-parser.y"
+    { if ((yyvsp[(2) - (2)].i) & SPELL_FLAG_SILENT)
+                                        fail((yylsp[(1) - (2)]).first_line, (yylsp[(1) - (2)]).first_column, "`SILENT' specified more than once");
+                                   (yyval.i) = (yyvsp[(2) - (2)].i) | SPELL_FLAG_SILENT;
+                                ;}
+    break;
+
+  case 18:
+#line 302 "magic-interpreter-parser.y"
+    { (yyval.spellarg_def).ty = SPELLARG_NONE; ;}
+    break;
+
+  case 19:
+#line 304 "magic-interpreter-parser.y"
+    { (yyval.spellarg_def).id = intern_id((yyvsp[(2) - (5)].s));
+                            (yyval.spellarg_def).ty = (yyvsp[(4) - (5)].i); ;}
+    break;
+
+  case 20:
+#line 310 "magic-interpreter-parser.y"
+    { (yyval.i) = SPELLARG_PC; ;}
+    break;
+
+  case 21:
+#line 312 "magic-interpreter-parser.y"
+    { (yyval.i) = SPELLARG_STRING; ;}
+    break;
+
+  case 22:
+#line 317 "magic-interpreter-parser.y"
+    { (yyval.value).ty = TY_DIR;
+                                  (yyval.value).v.v_int = (yyvsp[(1) - (1)].i); ;}
+    break;
+
+  case 23:
+#line 320 "magic-interpreter-parser.y"
+    { (yyval.value).ty = TY_INT;
+                                  (yyval.value).v.v_int = (yyvsp[(1) - (1)].i); ;}
+    break;
+
+  case 24:
+#line 323 "magic-interpreter-parser.y"
+    { (yyval.value).ty = TY_STRING;
+                                  (yyval.value).v.v_string = (yyvsp[(1) - (1)].s); ;}
+    break;
+
+  case 25:
+#line 329 "magic-interpreter-parser.y"
+    { (yyval.expr) = magic_new_expr(EXPR_VAL);
+                                  (yyval.expr)->e.e_val = (yyvsp[(1) - (1)].value); ;}
+    break;
+
+  case 26:
+#line 332 "magic-interpreter-parser.y"
+    {
+                                        val_t *val;
+                                        if ((val = find_constant((yyvsp[(1) - (1)].s)))) {
+                                                (yyval.expr) = magic_new_expr(EXPR_VAL);
+                                                (yyval.expr)->e.e_val = *val;
+                                        } else {
+                                                (yyval.expr) = magic_new_expr(EXPR_ID);
+                                                (yyval.expr)->e.e_id = intern_id((yyvsp[(1) - (1)].s));
+                                        }
+                                ;}
+    break;
+
+  case 27:
+#line 343 "magic-interpreter-parser.y"
+    { (yyval.expr) = magic_new_expr(EXPR_AREA);
+                                  (yyval.expr)->e.e_area = (yyvsp[(1) - (1)].area); ;}
+    break;
+
+  case 28:
+#line 346 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "+", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 29:
+#line 348 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "-", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 30:
+#line 350 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "*", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 31:
+#line 352 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "%", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 32:
+#line 354 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "/", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 33:
+#line 356 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), ">", (yyvsp[(3) - (3)].expr), (yyvsp[(1) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 34:
+#line 358 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), ">", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 35:
+#line 360 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "&", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 36:
+#line 362 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "^", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 37:
+#line 364 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "|", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 38:
+#line 366 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "<<", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 39:
+#line 368 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), ">>", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 40:
+#line 370 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), ">=", (yyvsp[(3) - (3)].expr), (yyvsp[(1) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 41:
+#line 372 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), ">=", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 42:
+#line 374 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "&&", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 43:
+#line 376 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "||", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 44:
+#line 378 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "=", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 45:
+#line 380 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "=", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 46:
+#line 382 "magic-interpreter-parser.y"
+    { BIN_EXPR((yyval.expr), "=", (yyvsp[(1) - (3)].expr), (yyvsp[(3) - (3)].expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column);
+                                  (yyval.expr) = fun_expr("not", 1, &(yyval.expr), (yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column); ;}
+    break;
+
+  case 47:
+#line 385 "magic-interpreter-parser.y"
+    { (yyval.expr) = fun_expr((yyvsp[(1) - (4)].s), (yyvsp[(3) - (4)].arg_list).args_nr, (yyvsp[(3) - (4)].arg_list).args, (yylsp[(1) - (4)]).first_line, (yylsp[(1) - (4)]).first_column);
+                                  if ((yyvsp[(3) - (4)].arg_list).args)
+                                          free((yyvsp[(3) - (4)].arg_list).args);
+                                  free((yyvsp[(1) - (4)].s)); ;}
+    break;
+
+  case 48:
+#line 390 "magic-interpreter-parser.y"
+    { (yyval.expr) = (yyvsp[(2) - (3)].expr); ;}
+    break;
+
+  case 49:
+#line 394 "magic-interpreter-parser.y"
+    { (yyval.arg_list).args_nr = 0; ;}
+    break;
+
+  case 50:
+#line 396 "magic-interpreter-parser.y"
+    { (yyval.arg_list) = (yyvsp[(1) - (1)].arg_list) ;}
+    break;
+
+  case 51:
+#line 401 "magic-interpreter-parser.y"
+    { (yyval.arg_list).args = aCalloc(sizeof(expr_t *), 1);
+                                  (yyval.arg_list).args_nr = 1;
+                                  (yyval.arg_list).args[0] = (yyvsp[(1) - (1)].expr);
+                                ;}
+    break;
+
+  case 52:
+#line 406 "magic-interpreter-parser.y"
+    { (yyval.arg_list).args = realloc((yyval.arg_list).args, (1 + (yyval.arg_list).args_nr) * sizeof(expr_t *));
+                                  (yyval.arg_list).args[(yyval.arg_list).args_nr++] = (yyvsp[(3) - (3)].expr);
+                                ;}
+    break;
+
+  case 53:
+#line 413 "magic-interpreter-parser.y"
+    { (yyval.location).m = (yyvsp[(3) - (8)].expr); (yyval.location).x = (yyvsp[(5) - (8)].expr); (yyval.location).y = (yyvsp[(7) - (8)].expr); ;}
+    break;
+
+  case 54:
+#line 417 "magic-interpreter-parser.y"
+    { (yyval.area).ty = AREA_LOCATION;
+                                  (yyval.area).a.a_loc = (yyvsp[(1) - (1)].location);
+				;}
+    break;
+
+  case 55:
+#line 421 "magic-interpreter-parser.y"
+    { (yyval.area).ty = AREA_RECT;
+                                  (yyval.area).a.a_rect.loc = (yyvsp[(1) - (8)].location);
+                                  (yyval.area).a.a_rect.width = (yyvsp[(5) - (8)].expr);
+                                  (yyval.area).a.a_rect.height = (yyvsp[(7) - (8)].expr);
+                                ;}
+    break;
+
+  case 56:
+#line 427 "magic-interpreter-parser.y"
+    { (yyval.area).ty = AREA_BAR;
+                                  (yyval.area).a.a_bar.loc = (yyvsp[(1) - (9)].location);
+                                  (yyval.area).a.a_bar.width = (yyvsp[(6) - (9)].expr);
+                                  (yyval.area).a.a_bar.depth = (yyvsp[(8) - (9)].expr);
+                                  (yyval.area).a.a_bar.dir = (yyvsp[(3) - (9)].expr);
+                                ;}
+    break;
+
+  case 57:
+#line 437 "magic-interpreter-parser.y"
+    {  (yyval.spell) = new_spell((yyvsp[(1) - (1)].spellguard)); ;}
+    break;
+
+  case 58:
+#line 439 "magic-interpreter-parser.y"
+    {  (yyval.spell) = new_spell((yyvsp[(4) - (4)].spellguard)); 
+                                   (yyval.spell)->letdefs_nr = (yyvsp[(2) - (4)].letdefs).letdefs_nr;
+                                   (yyval.spell)->letdefs = (yyvsp[(2) - (4)].letdefs).letdefs;
+                                   (yyval.spell)->spellguard = (yyvsp[(4) - (4)].spellguard);
+                                ;}
+    break;
+
+  case 59:
+#line 448 "magic-interpreter-parser.y"
+    { (yyval.letdefs).letdefs_nr = 0;
+                                  (yyval.letdefs).letdefs = (letdef_t *) malloc(1);
+                                ;}
+    break;
+
+  case 60:
+#line 452 "magic-interpreter-parser.y"
+    { (yyval.letdefs) = (yyvsp[(1) - (3)].letdefs);
+                                  (yyval.letdefs).letdefs_nr++;
+                                  (yyval.letdefs).letdefs = realloc((yyval.letdefs).letdefs, sizeof(letdef_t) * (yyval.letdefs).letdefs_nr);
+                                  (yyval.letdefs).letdefs[(yyvsp[(1) - (3)].letdefs).letdefs_nr] = (yyvsp[(2) - (3)].vardef);
+                                ;}
+    break;
+
+  case 61:
+#line 461 "magic-interpreter-parser.y"
+    {
+                                        if (find_constant((yyvsp[(1) - (3)].s))) {
+                                                fail((yylsp[(1) - (3)]).first_line, (yylsp[(1) - (3)]).first_column, "Attempt to re-define constant `%s' as LET-bound variable.\n", (yyvsp[(1) - (3)].s));
+                                                free((yyvsp[(1) - (3)].s));
+                                        } else {
+                                                (yyval.vardef).id = intern_id((yyvsp[(1) - (3)].s));
+                                                (yyval.vardef).expr = (yyvsp[(3) - (3)].expr);
+                                        }
+                                ;}
+    break;
+
+  case 62:
+#line 474 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = (yyvsp[(1) - (1)].spellguard); ;}
+    break;
+
+  case 63:
+#line 476 "magic-interpreter-parser.y"
+    { spellguard_t *sg = new_spellguard(SPELLGUARD_CHOICE);
+                                  sg->next = (yyvsp[(1) - (3)].spellguard);
+                                  sg->s.s_alt = (yyvsp[(3) - (3)].spellguard);
+                                  (yyval.spellguard) = sg;
+                                ;}
+    break;
+
+  case 64:
+#line 485 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = spellguard_implication((yyvsp[(1) - (3)].spellguard), (yyvsp[(3) - (3)].spellguard)); ;}
+    break;
+
+  case 65:
+#line 487 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = (yyvsp[(2) - (3)].spellguard); ;}
+    break;
+
+  case 66:
+#line 489 "magic-interpreter-parser.y"
+    { spellguard_t *sg = new_spellguard(SPELLGUARD_EFFECT);
+                                  sg->s.s_effect.effect = (yyvsp[(2) - (4)].effect);
+                                  sg->s.s_effect.at_trigger = (yyvsp[(3) - (4)].effect);
+                                  sg->s.s_effect.at_end = (yyvsp[(4) - (4)].effect);
+                                  (yyval.spellguard) = sg;
+                                ;}
+    break;
+
+  case 67:
+#line 499 "magic-interpreter-parser.y"
+    { (yyval.effect) = NULL; ;}
+    break;
+
+  case 68:
+#line 501 "magic-interpreter-parser.y"
+    { (yyval.effect) = (yyvsp[(2) - (2)].effect); ;}
+    break;
+
+  case 69:
+#line 506 "magic-interpreter-parser.y"
+    { (yyval.effect) = NULL; ;}
+    break;
+
+  case 70:
+#line 508 "magic-interpreter-parser.y"
+    { (yyval.effect) = (yyvsp[(2) - (2)].effect); ;}
+    break;
+
+  case 71:
+#line 513 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = (yyvsp[(1) - (1)].spellguard); ;}
+    break;
+
+  case 72:
+#line 515 "magic-interpreter-parser.y"
+    { spellguard_t *sg = new_spellguard(SPELLGUARD_CHOICE);
+                                  sg->next = (yyvsp[(1) - (3)].spellguard);
+                                  sg->s.s_alt = (yyvsp[(3) - (3)].spellguard);
+                                  (yyval.spellguard) = sg;
+                                ;}
+    break;
+
+  case 73:
+#line 521 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = (yyvsp[(2) - (3)].spellguard); ;}
+    break;
+
+  case 74:
+#line 526 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = (yyvsp[(1) - (1)].spellguard); ;}
+    break;
+
+  case 75:
+#line 528 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = spellguard_implication ((yyvsp[(1) - (3)].spellguard), (yyvsp[(3) - (3)].spellguard)); ;}
+    break;
+
+  case 76:
+#line 533 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = new_spellguard(SPELLGUARD_CONDITION);
+                                  (yyval.spellguard)->s.s_condition = (yyvsp[(2) - (2)].expr);
+                                ;}
+    break;
+
+  case 77:
+#line 537 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = new_spellguard(SPELLGUARD_CATALYSTS);
+                                  (yyval.spellguard)->s.s_catalysts = (yyvsp[(2) - (2)].components);
+                                ;}
+    break;
+
+  case 78:
+#line 541 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = new_spellguard(SPELLGUARD_COMPONENTS);
+                                  (yyval.spellguard)->s.s_components = (yyvsp[(2) - (2)].components);
+                                ;}
+    break;
+
+  case 79:
+#line 545 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = new_spellguard(SPELLGUARD_MANA);
+                                  (yyval.spellguard)->s.s_mana = (yyvsp[(2) - (2)].expr);
+                                ;}
+    break;
+
+  case 80:
+#line 549 "magic-interpreter-parser.y"
+    { (yyval.spellguard) = new_spellguard(SPELLGUARD_CASTTIME);
+                                  (yyval.spellguard)->s.s_casttime = (yyvsp[(2) - (2)].expr);
+                                ;}
+    break;
+
+  case 81:
+#line 556 "magic-interpreter-parser.y"
+    { (yyval.components) = (yyvsp[(2) - (3)].components); ;}
+    break;
+
+  case 82:
+#line 561 "magic-interpreter-parser.y"
+    { (yyval.components) = NULL;
+                                  magic_add_component(&(yyval.components), (yyvsp[(1) - (1)].component).id, (yyvsp[(1) - (1)].component).count);
+                                ;}
+    break;
+
+  case 83:
+#line 565 "magic-interpreter-parser.y"
+    { (yyval.components) = (yyvsp[(1) - (3)].components);
+                                  magic_add_component(&(yyval.components), (yyvsp[(3) - (3)].component).id, (yyvsp[(3) - (3)].component).count);
+                                ;}
+    break;
+
+  case 84:
+#line 572 "magic-interpreter-parser.y"
+    { (yyval.component).id = (yyvsp[(3) - (3)].i); (yyval.component).count = (yyvsp[(1) - (3)].i); ;}
+    break;
+
+  case 85:
+#line 574 "magic-interpreter-parser.y"
+    { (yyval.component).id = (yyvsp[(1) - (1)].i); (yyval.component).count = 1; ;}
+    break;
+
+  case 86:
+#line 579 "magic-interpreter-parser.y"
+    { struct item_data *item = itemdb_searchname((yyvsp[(1) - (1)].s));
+                                  if (!item) {
+                                          fail ((yylsp[(1) - (1)]).first_line, (yylsp[(1) - (1)]).first_column, "Unknown item `%s'\n", (yyvsp[(1) - (1)].s));
+                                          (yyval.i) = 0;
+                                  } else
+                                          (yyval.i) = item->nameid;
+                                  free ((yyvsp[(1) - (1)].s));
+                                ;}
+    break;
+
+  case 87:
+#line 588 "magic-interpreter-parser.y"
+    { (yyval.i) = (yyvsp[(1) - (1)].i); ;}
+    break;
+
+  case 88:
+#line 593 "magic-interpreter-parser.y"
+    { (yyval.i) = FOREACH_FILTER_PC; ;}
+    break;
+
+  case 89:
+#line 595 "magic-interpreter-parser.y"
+    { (yyval.i) = FOREACH_FILTER_MOB; ;}
+    break;
+
+  case 90:
+#line 597 "magic-interpreter-parser.y"
+    { (yyval.i) = FOREACH_FILTER_ENTITY; ;}
+    break;
+
+  case 91:
+#line 599 "magic-interpreter-parser.y"
+    { (yyval.i) = FOREACH_FILTER_SPELL; ;}
+    break;
+
+  case 92:
+#line 601 "magic-interpreter-parser.y"
+    { (yyval.i) = FOREACH_FILTER_TARGET; ;}
+    break;
+
+  case 93:
+#line 606 "magic-interpreter-parser.y"
+    { (yyval.effect) = (yyvsp[(2) - (3)].effect); ;}
+    break;
+
+  case 94:
+#line 608 "magic-interpreter-parser.y"
+    { (yyval.effect) = new_effect(EFFECT_SKIP); ;}
+    break;
+
+  case 95:
+#line 610 "magic-interpreter-parser.y"
+    { (yyval.effect) = new_effect(EFFECT_ABORT); ;}
+    break;
+
+  case 96:
+#line 612 "magic-interpreter-parser.y"
+    { (yyval.effect) = new_effect(EFFECT_END); ;}
+    break;
+
+  case 97:
+#line 614 "magic-interpreter-parser.y"
+    { (yyval.effect) = new_effect(EFFECT_BREAK); ;}
+    break;
+
+  case 98:
+#line 616 "magic-interpreter-parser.y"
+    {
+                                        if (find_constant((yyvsp[(1) - (4)].s))) {
+                                                fail((yylsp[(1) - (4)]).first_line, (yylsp[(1) - (4)]).first_column, "Attempt to re-define constant `%s' in assignment.", (yyvsp[(1) - (4)].s));
+                                                free((yyvsp[(1) - (4)].s));
+                                        } else {
+                                                (yyval.effect) = new_effect(EFFECT_ASSIGN);
+                                                (yyval.effect)->e.e_assign.id = intern_id((yyvsp[(1) - (4)].s));
+                                                (yyval.effect)->e.e_assign.expr = (yyvsp[(3) - (4)].expr);
+                                        }
+                                ;}
+    break;
+
+  case 99:
+#line 627 "magic-interpreter-parser.y"
+    { (yyval.effect) = new_effect(EFFECT_FOREACH);
+                                  (yyval.effect)->e.e_foreach.id = intern_id((yyvsp[(3) - (7)].s));
+                                  (yyval.effect)->e.e_foreach.area = (yyvsp[(5) - (7)].expr);
+                                  (yyval.effect)->e.e_foreach.body = (yyvsp[(7) - (7)].effect);
+                                  (yyval.effect)->e.e_foreach.filter = (yyvsp[(2) - (7)].i);
+                                ;}
+    break;
+
+  case 100:
+#line 634 "magic-interpreter-parser.y"
+    { (yyval.effect) = new_effect(EFFECT_FOR);
+                                  (yyval.effect)->e.e_for.id = intern_id((yyvsp[(2) - (8)].s));
+                                  (yyval.effect)->e.e_for.start = (yyvsp[(4) - (8)].expr);
+                                  (yyval.effect)->e.e_for.stop = (yyvsp[(6) - (8)].expr);
+                                  (yyval.effect)->e.e_for.body = (yyvsp[(8) - (8)].effect);
+                                ;}
+    break;
+
+  case 101:
+#line 641 "magic-interpreter-parser.y"
+    { (yyval.effect) = new_effect(EFFECT_IF);
+                                  (yyval.effect)->e.e_if.cond = (yyvsp[(2) - (6)].expr);
+                                  (yyval.effect)->e.e_if.true_branch = (yyvsp[(4) - (6)].effect);
+                                  (yyval.effect)->e.e_if.false_branch = (yyvsp[(6) - (6)].effect);
+                                ;}
+    break;
+
+  case 102:
+#line 647 "magic-interpreter-parser.y"
+    { (yyval.effect) = new_effect(EFFECT_IF);
+                                  (yyval.effect)->e.e_if.cond = (yyvsp[(2) - (4)].expr);
+                                  (yyval.effect)->e.e_if.true_branch = (yyvsp[(4) - (4)].effect);
+                                  (yyval.effect)->e.e_if.false_branch = new_effect(EFFECT_SKIP);
+                                ;}
+    break;
+
+  case 103:
+#line 653 "magic-interpreter-parser.y"
+    { (yyval.effect) = new_effect(EFFECT_SLEEP);
+                                  (yyval.effect)->e.e_sleep = (yyvsp[(2) - (3)].expr);
+                                ;}
+    break;
+
+  case 104:
+#line 657 "magic-interpreter-parser.y"
+    { (yyval.effect) = op_effect((yyvsp[(1) - (5)].s), (yyvsp[(3) - (5)].arg_list).args_nr, (yyvsp[(3) - (5)].arg_list).args, (yylsp[(1) - (5)]).first_line, (yylsp[(1) - (5)]).first_column);
+                                  free((yyvsp[(1) - (5)].s));
+                                ;}
+    break;
+
+  case 105:
+#line 661 "magic-interpreter-parser.y"
+    { (yyval.effect) = new_effect(EFFECT_SCRIPT);
+                                  (yyval.effect)->e.e_script = parse_script((unsigned char *) (yyvsp[(1) - (1)].s), (yylsp[(1) - (1)]).first_line);
+                                  free((yyvsp[(1) - (1)].s));
+                                  if ((yyval.effect)->e.e_script == NULL)
+                                      fail((yylsp[(1) - (1)]).first_line, (yylsp[(1) - (1)]).first_column, "Failed to compile script\n");
+                                ;}
+    break;
+
+  case 106:
+#line 668 "magic-interpreter-parser.y"
+    { (yyval.effect) = call_proc((yyvsp[(2) - (6)].s), (yyvsp[(4) - (6)].arg_list).args_nr, (yyvsp[(4) - (6)].arg_list).args, (yylsp[(1) - (6)]).first_line, (yylsp[(1) - (6)]).first_column);
+                                  free((yyvsp[(2) - (6)].s));
+                                ;}
+    break;
+
+  case 107:
+#line 674 "magic-interpreter-parser.y"
+    { (yyval.effect) = new_effect(EFFECT_SKIP); ;}
+    break;
+
+  case 108:
+#line 676 "magic-interpreter-parser.y"
+    { (yyval.effect) = set_effect_continuation((yyvsp[(1) - (3)].effect), (yyvsp[(3) - (3)].effect)); ;}
+    break;
+
+
+/* Line 1267 of yacc.c.  */
+#line 2600 "magic-interpreter-parser.c"
+      default: break;
+    }
+  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;
+  *++yylsp = yyloc;
+
+  /* Now `shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTOKENS];
+
+  goto yynewstate;
+
+
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+#if ! YYERROR_VERBOSE
+      yyerror (YY_("syntax error"));
+#else
+      {
+	YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
+	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
+	  {
+	    YYSIZE_T yyalloc = 2 * yysize;
+	    if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
+	      yyalloc = YYSTACK_ALLOC_MAXIMUM;
+	    if (yymsg != yymsgbuf)
+	      YYSTACK_FREE (yymsg);
+	    yymsg = (char *) YYSTACK_ALLOC (yyalloc);
+	    if (yymsg)
+	      yymsg_alloc = yyalloc;
+	    else
+	      {
+		yymsg = yymsgbuf;
+		yymsg_alloc = sizeof yymsgbuf;
+	      }
+	  }
+
+	if (0 < yysize && yysize <= yymsg_alloc)
+	  {
+	    (void) yysyntax_error (yymsg, yystate, yychar);
+	    yyerror (yymsg);
+	  }
+	else
+	  {
+	    yyerror (YY_("syntax error"));
+	    if (yysize != 0)
+	      goto yyexhaustedlab;
+	  }
+      }
+#endif
+    }
+
+  yyerror_range[0] = yylloc;
+
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse look-ahead token after an
+	 error, discard it.  */
+
+      if (yychar <= YYEOF)
+	{
+	  /* Return failure if at end of input.  */
+	  if (yychar == YYEOF)
+	    YYABORT;
+	}
+      else
+	{
+	  yydestruct ("Error: discarding",
+		      yytoken, &yylval, &yylloc);
+	  yychar = YYEMPTY;
+	}
+    }
+
+  /* Else will try to reuse look-ahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+  /* Pacify compilers like GCC when the user code never invokes
+     YYERROR and the label yyerrorlab therefore never appears in user
+     code.  */
+  if (/*CONSTCOND*/ 0)
+     goto yyerrorlab;
+
+  yyerror_range[0] = yylsp[1-yylen];
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYERROR.  */
+  YYPOPSTACK (yylen);
+  yylen = 0;
+  YY_STACK_PRINT (yyss, yyssp);
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (yyn != YYPACT_NINF)
+	{
+	  yyn += YYTERROR;
+	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+	    {
+	      yyn = yytable[yyn];
+	      if (0 < yyn)
+		break;
+	    }
+	}
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+	YYABORT;
+
+      yyerror_range[0] = *yylsp;
+      yydestruct ("Error: popping",
+		  yystos[yystate], yyvsp, yylsp);
+      YYPOPSTACK (1);
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  *++yyvsp = yylval;
+
+  yyerror_range[1] = yylloc;
+  /* Using YYLLOC is tempting, but would change the location of
+     the look-ahead.  YYLOC is available though.  */
+  YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
+  *++yylsp = yyloc;
+
+  /* Shift the error token.  */
+  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#ifndef yyoverflow
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here.  |
+`-------------------------------------------------*/
+yyexhaustedlab:
+  yyerror (YY_("memory exhausted"));
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+  if (yychar != YYEOF && yychar != YYEMPTY)
+     yydestruct ("Cleanup: discarding lookahead",
+		 yytoken, &yylval, &yylloc);
+  /* Do not reclaim the symbols of the rule which action triggered
+     this YYABORT or YYACCEPT.  */
+  YYPOPSTACK (yylen);
+  YY_STACK_PRINT (yyss, yyssp);
+  while (yyssp != yyss)
+    {
+      yydestruct ("Cleanup: popping",
+		  yystos[*yyssp], yyvsp, yylsp);
+      YYPOPSTACK (1);
+    }
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+#if YYERROR_VERBOSE
+  if (yymsg != yymsgbuf)
+    YYSTACK_FREE (yymsg);
+#endif
+  /* Make sure YYID is used.  */
+  return YYID (yyresult);
+}
+
+
+#line 680 "magic-interpreter-parser.y"
+
+
+/* We do incremental realloc here to store our results.  Since this happens only once
+ * during startup for a relatively manageable set of configs, it should be fine. */
+
+static int
+intern_id(char *id_name)
+{
+        int i;
+
+        for (i = 0; i < magic_conf.vars_nr; i++)
+                if (!strcmp(id_name, magic_conf.var_name[i])) {
+                        free(id_name);
+                        return i;
+                }
+
+        /* Must add new */
+        i = magic_conf.vars_nr++;
+        magic_conf.var_name = realloc(magic_conf.var_name, magic_conf.vars_nr * sizeof(char *));
+        magic_conf.var_name[i] = id_name;
+        magic_conf.vars = realloc(magic_conf.vars, magic_conf.vars_nr * sizeof(val_t));
+        magic_conf.vars[i].ty = TY_UNDEF;
+
+        return i;
+}
+
+static void
+add_spell(spell_t *spell, int line_nr)
+{
+        int index = magic_conf.spells_nr;
+        int i;
+
+        for (i = 0; i < index; i++) {
+                if (!strcmp(magic_conf.spells[i]->name, spell->name)) {
+                        fail(line_nr, 0, "Attempt to redefine spell `%s'\n", spell->name);
+                        return;
+                }
+                if (!strcmp(magic_conf.spells[i]->invocation, spell->invocation)) {
+                        fail(line_nr, 0, "Attempt to redefine spell invocation `%s' between spells `%s' and `%s'\n",
+                             spell->invocation, magic_conf.spells[i]->name, spell->name);
+                        return;
+                }
+        }
+        magic_conf.spells_nr++;
+
+        magic_conf.spells = realloc(magic_conf.spells, magic_conf.spells_nr * sizeof (spell_t*));
+        magic_conf.spells[index] = spell;
+
+            
+}
+
+static void
+add_teleport_anchor(teleport_anchor_t *anchor, int line_nr)
+{
+        int index = magic_conf.anchors_nr;
+        int i;
+
+        for (i = 0; i < index; i++) {
+                if (!strcmp(magic_conf.anchors[i]->name, anchor->name)) {
+                        fail(line_nr, 0, "Attempt to redefine teleport anchor `%s'\n", anchor->name);
+                        return;
+                }
+                if (!strcmp(magic_conf.anchors[i]->invocation, anchor->invocation)) {
+                        fail(line_nr, 0, "Attempt to redefine anchor invocation `%s' between anchors `%s' and `%s'\n",
+                             anchor->invocation, magic_conf.anchors[i]->name, anchor->name);
+                        return;
+                }
+        }
+        magic_conf.anchors_nr++;
+
+        magic_conf.anchors = realloc(magic_conf.anchors, magic_conf.anchors_nr * sizeof (teleport_anchor_t*));
+        magic_conf.anchors[index] = anchor;
+}
+
+
+static void
+fail(int line, int column, char *fmt, ...)
+{
+        va_list ap;
+        fprintf(stderr, "[magic-init]  L%d:%d: ", line, column);
+        va_start(ap, fmt);
+        vfprintf(stderr, fmt, ap);
+        failed_flag = 1;
+}
+
+static expr_t *
+fun_expr(char *name, int args_nr, expr_t **args, int line, int column)
+{
+        int id;
+        expr_t *expr;
+        fun_t *fun = magic_get_fun(name, &id);
+
+        if (!fun) {
+                fail(line, column, "Unknown function `%s'\n", name);
+        } else if (strlen(fun->signature) != args_nr) {
+                fail(line, column, "Incorrect number of arguments to function `%s': Expected %d, found %d\n", name, strlen(fun->signature), args_nr);
+                fun = NULL;
+        }
+
+        if (fun) {
+                int i;
+
+                expr = magic_new_expr(EXPR_FUNAPP);
+                expr->e.e_funapp.line_nr = line;
+                expr->e.e_funapp.column = column;
+                expr->e.e_funapp.id = id;
+                expr->e.e_funapp.args_nr = args_nr;
+
+                for (i = 0; i < args_nr; i++)
+                        expr->e.e_funapp.args[i] = args[i];
+        } else { /* failure */
+                expr = magic_new_expr(EXPR_VAL);
+                expr->e.e_val.ty = TY_FAIL;
+        }
+
+        return expr;
+}
+
+static spell_t *
+new_spell(spellguard_t *guard)
+{
+        spell_t *retval = calloc(1, sizeof(spell_t));
+        retval->spellguard = guard;
+        return retval;
+}
+
+static spellguard_t *
+new_spellguard(int ty)
+{
+        spellguard_t *retval = calloc(1, sizeof(spellguard_t));
+        retval->ty = ty;
+        return retval;
+}
+
+static spellguard_t *
+spellguard_implication(spellguard_t *a, spellguard_t *b)
+{
+        spellguard_t *retval = a;
+
+        if (a == b) /* This can happen due to reference sharing:
+                     * e.g.,
+                     *  (R0 -> (R1 | R2)) => (R3)
+                     * yields
+                     *  (R0 -> (R1 -> R3 | R2 -> R3))
+                     *
+                     * So if we now add => R4 to that, we want
+                     *  (R0 -> (R1 -> R3 -> R4 | R2 -> R3 -> R4))
+                     *
+                     * but we only need to add it once, because the R3 reference is shared.
+                    */
+                return retval;
+
+                /* If the premise is a disjunction, b is the continuation of _all_ branches */
+        if (a->ty == SPELLGUARD_CHOICE)
+                spellguard_implication(a->s.s_alt, b);
+        if (a->next)
+                spellguard_implication(a->next, b);
+        else
+                a->next = b;
+                
+
+        return retval;
+}
+
+static effect_t *
+new_effect(int ty)
+{
+        effect_t *effect = (effect_t *) calloc(1, sizeof(effect_t));
+        effect->ty = ty;
+        return effect;
+}
+
+static effect_t *
+set_effect_continuation(effect_t *src, effect_t *continuation)
+{
+        effect_t *retval = src;
+        /* This function is completely analogous to `spellguard_implication' above; read the control flow implications above first before pondering it. */
+
+        if (src == continuation)
+                return retval;
+
+        /* For FOR and FOREACH, we use special stack handlers and thus don't have to set
+         * the continuation.  It's only IF that we need to handle in this fashion. */
+        if (src->ty == EFFECT_IF) {
+                set_effect_continuation(src->e.e_if.true_branch, continuation);
+                set_effect_continuation(src->e.e_if.false_branch, continuation);
+        }
+        if (src->next)
+                set_effect_continuation(src->next, continuation);
+        else
+                src->next = continuation;
+
+        return retval;
+}
+
+static effect_t *
+op_effect(char *name, int args_nr, expr_t **args, int line, int column)
+{
+        int id;
+        effect_t *effect;
+        op_t *op = magic_get_op(name, &id);
+
+        if (!op)
+                fail(line, column, "Unknown operation `%s'\n", name);
+        else if (strlen(op->signature) != args_nr) {
+                fail(line, column, "Incorrect number of arguments to operation `%s': Expected %d, found %d\n", name, strlen(op->signature), args_nr);
+                op = NULL;
+        }
+
+        if (op) {
+                int i;
+
+                effect = new_effect(EFFECT_OP);
+                effect->e.e_op.line_nr = line;
+                effect->e.e_op.column = column;
+                effect->e.e_op.id = id;
+                effect->e.e_op.args_nr = args_nr;
+
+                for (i = 0; i < args_nr; i++)
+                        effect->e.e_op.args[i] = args[i];
+        } else /* failure */
+                effect = new_effect(EFFECT_SKIP);
+
+        return effect;
+}
+
+
+proc_t *procs = NULL;
+int procs_nr = 0;
+
+
+static void
+install_proc(proc_t *proc)
+{
+        if (!procs) {
+                procs = proc;
+                procs_nr = 1;
+        } else {
+                procs = realloc(procs, sizeof(proc_t) * (1 + procs_nr));
+                procs[procs_nr++] = *proc;
+        }
+}
+
+static effect_t *
+call_proc(char *name, int args_nr, expr_t **args, int line_nr, int column)
+{
+        proc_t *p = NULL;
+        int i;
+        effect_t *retval;
+
+        for (i = 0; i < procs_nr; i++)
+                if (!strcmp(procs[i].name, name)) {
+                        p = &procs[i];
+                        break;
+                }
+
+        if (!p) {
+                fail(line_nr, column, "Unknown procedure `%s'\n", name);
+                return new_effect(EFFECT_SKIP);
+        }
+
+        if (p->args_nr != args_nr) {
+                fail(line_nr, column, "Procedure %s/%d invoked with %d parameters\n", name, p->args_nr, args_nr);
+                return new_effect(EFFECT_SKIP);
+        }
+
+        retval = new_effect(EFFECT_CALL);
+        retval->e.e_call.body = p->body;
+        retval->e.e_call.args_nr = args_nr;
+        retval->e.e_call.formals = p->args;
+        retval->e.e_call.actuals = args;
+        return retval;
+}
+
+struct const_def_rec {
+        char *name;
+        val_t val;
+} *const_defs = NULL;
+
+int const_defs_nr = 0;
+
+static void
+bind_constant(char *name, val_t *val, int line_nr)
+{
+        if (find_constant(name)) {
+                fail(line_nr, 0, "Redefinition of constant `%s'\n", name);
+                return;
+        }
+
+        if (!const_defs)
+                const_defs = (struct const_def_rec *)malloc(sizeof(struct const_def_rec));
+        else
+                const_defs = (struct const_def_rec *)realloc(const_defs,
+                                                             (const_defs_nr + 1) * sizeof(struct const_def_rec));
+
+        const_defs[const_defs_nr].name = name;
+        const_defs[const_defs_nr].val = *val;
+        ++const_defs_nr;
+}
+
+static val_t *
+find_constant(char *name)
+{
+        int i;
+        for (i = 0; i < const_defs_nr; i++) {
+                if (!strcmp(const_defs[i].name, name)) {
+                        free(name);
+                        return &const_defs[i].val;
+                }
+        }
+
+        return NULL;
+}
+
+
+
+
+#define INTERN_ASSERT(name, id) { int zid = intern_id(name); if (zid != id) fprintf(stderr, "[magic-conf] INTERNAL ERROR: Builtin special var %s interned to %d, not %d as it should be!\n", name, zid, id); error_flag = 1; }
+
+extern FILE *magic_frontend_in;
+
+int
+magic_init(char *conffile) // must be called after itemdb initialisation
+{
+        int error_flag = 0;
+
+        magic_conf.vars_nr = 0;
+        magic_conf.var_name = (char **)malloc(1);
+        magic_conf.vars = (val_t *)malloc(1);
+
+        magic_conf.obscure_chance = 95;
+        magic_conf.min_casttime = 100;
+
+        magic_conf.spells_nr = 0;
+        magic_conf.spells = (spell_t **)malloc(1);
+
+        magic_conf.anchors_nr = 0;
+        magic_conf.anchors = (teleport_anchor_t **)malloc(1);
+
+        INTERN_ASSERT("min_casttime", VAR_MIN_CASTTIME);
+        INTERN_ASSERT("obscure_chance", VAR_OBSCURE_CHANCE);
+        INTERN_ASSERT("caster", VAR_CASTER);
+        INTERN_ASSERT("spellpower", VAR_SPELLPOWER);
+        INTERN_ASSERT("self_spell", VAR_SPELL);
+        INTERN_ASSERT("self_invocation", VAR_INVOCATION);
+        INTERN_ASSERT("target", VAR_TARGET);
+        INTERN_ASSERT("script_target", VAR_SCRIPTTARGET);
+        INTERN_ASSERT("location", VAR_LOCATION);
+
+        magic_frontend_in = fopen(conffile, "r");
+        if (!magic_frontend_in) {
+                fprintf(stderr, "[magic-conf] Magic configuration file `%s' not found -> no magic.\n", conffile);
+                return 0;
+        }
+        magic_frontend_parse();
+
+        if (magic_conf.vars[VAR_MIN_CASTTIME].ty == TY_INT)
+                magic_conf.min_casttime = magic_conf.vars[VAR_MIN_CASTTIME].v.v_int;
+
+        if (magic_conf.vars[VAR_OBSCURE_CHANCE].ty == TY_INT)
+                magic_conf.obscure_chance = magic_conf.vars[VAR_OBSCURE_CHANCE].v.v_int;
+
+        printf("[magic-conf] Magic initialised; obscure at %d%%.  %d spells, %d teleport anchors.\n",
+               magic_conf.obscure_chance, magic_conf.spells_nr, magic_conf.anchors_nr);
+
+        if (procs)
+                free(procs);
+        return error_flag;
+}
+
+extern int magic_frontend_lineno;
+
+static void
+magic_frontend_error(const char *msg)
+{
+    fprintf(stderr, "[magic-conf] Parse error: %s at line %d\n", msg, magic_frontend_lineno);
+    failed_flag = 1;
+}
+
diff --git a/src/map/magic-interpreter-parser.h b/src/map/magic-interpreter-parser.h
new file mode 100644
index 0000000..f327d78
--- /dev/null
+++ b/src/map/magic-interpreter-parser.h
@@ -0,0 +1,195 @@
+/* A Bison parser, made by GNU Bison 2.3.  */
+
+/* Skeleton interface for Bison's Yacc-like parsers in C
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
+   Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+/* As a special exception, you may create a larger work that contains
+   part or all of the Bison parser skeleton and distribute that work
+   under terms of your choice, so long as that work isn't itself a
+   parser generator using the skeleton or a modified version thereof
+   as a parser skeleton.  Alternatively, if you modify or redistribute
+   the parser skeleton itself, you may (at your option) remove this
+   special exception, which will cause the skeleton and the resulting
+   Bison output files to be licensed under the GNU General Public
+   License without this special exception.
+
+   This special exception was added by the Free Software Foundation in
+   version 2.2 of Bison.  */
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     INT = 258,
+     STRING = 259,
+     ID = 260,
+     DIR = 261,
+     CONST = 262,
+     PROCEDURE = 263,
+     CALL = 264,
+     SILENT = 265,
+     LOCAL = 266,
+     SHL = 267,
+     SHR = 268,
+     EQ = 269,
+     NEQ = 270,
+     GTE = 271,
+     LTE = 272,
+     ANDAND = 273,
+     OROR = 274,
+     SCRIPT_DATA = 275,
+     TO = 276,
+     TOWARDS = 277,
+     TELEPORT_ANCHOR = 278,
+     SPELL = 279,
+     LET = 280,
+     IN = 281,
+     END = 282,
+     DARROW = 283,
+     STRING_TY = 284,
+     REQUIRE = 285,
+     CATALYSTS = 286,
+     COMPONENTS = 287,
+     MANA = 288,
+     CASTTIME = 289,
+     SKIP = 290,
+     ABORT = 291,
+     BREAK = 292,
+     EFFECT = 293,
+     ATEND = 294,
+     ATTRIGGER = 295,
+     PC_F = 296,
+     MOB_F = 297,
+     ENTITY_F = 298,
+     TARGET_F = 299,
+     IF = 300,
+     THEN = 301,
+     ELSE = 302,
+     FOREACH = 303,
+     FOR = 304,
+     DO = 305,
+     SLEEP = 306,
+     OR = 307
+   };
+#endif
+/* Tokens.  */
+#define INT 258
+#define STRING 259
+#define ID 260
+#define DIR 261
+#define CONST 262
+#define PROCEDURE 263
+#define CALL 264
+#define SILENT 265
+#define LOCAL 266
+#define SHL 267
+#define SHR 268
+#define EQ 269
+#define NEQ 270
+#define GTE 271
+#define LTE 272
+#define ANDAND 273
+#define OROR 274
+#define SCRIPT_DATA 275
+#define TO 276
+#define TOWARDS 277
+#define TELEPORT_ANCHOR 278
+#define SPELL 279
+#define LET 280
+#define IN 281
+#define END 282
+#define DARROW 283
+#define STRING_TY 284
+#define REQUIRE 285
+#define CATALYSTS 286
+#define COMPONENTS 287
+#define MANA 288
+#define CASTTIME 289
+#define SKIP 290
+#define ABORT 291
+#define BREAK 292
+#define EFFECT 293
+#define ATEND 294
+#define ATTRIGGER 295
+#define PC_F 296
+#define MOB_F 297
+#define ENTITY_F 298
+#define TARGET_F 299
+#define IF 300
+#define THEN 301
+#define ELSE 302
+#define FOREACH 303
+#define FOR 304
+#define DO 305
+#define SLEEP 306
+#define OR 307
+
+
+
+
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+typedef union YYSTYPE
+#line 71 "magic-interpreter-parser.y"
+{
+    int i;
+    char *s;
+    int op;
+    magic_conf_t *magic_conf;
+    val_t value;
+    expr_t *expr;
+    e_location_t location;
+    e_area_t area;
+    args_rec_t arg_list;
+    struct { int letdefs_nr; letdef_t *letdefs; } letdefs;
+    spell_t *spell;
+    struct { int id, ty; } spellarg_def;
+    letdef_t vardef;
+    spellguard_t *spellguard;
+    component_t *components;
+    struct {int id, count; } component;
+    effect_t *effect;
+    proc_t *proc;
+}
+/* Line 1489 of yacc.c.  */
+#line 174 "magic-interpreter-parser.h"
+	YYSTYPE;
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+
+extern YYSTYPE magic_frontend_lval;
+
+#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
+typedef struct YYLTYPE
+{
+  int first_line;
+  int first_column;
+  int last_line;
+  int last_column;
+} YYLTYPE;
+# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
+# define YYLTYPE_IS_DECLARED 1
+# define YYLTYPE_IS_TRIVIAL 1
+#endif
+
+extern YYLTYPE magic_frontend_lloc;
diff --git a/src/map/magic-interpreter-parser.y b/src/map/magic-interpreter-parser.y
new file mode 100644
index 0000000..6d310bd
--- /dev/null
+++ b/src/map/magic-interpreter-parser.y
@@ -0,0 +1,1057 @@
+%{
+#include "magic-interpreter.h"
+#include "magic-expr.h"
+#include <stdarg.h>
+
+magic_conf_t magic_conf;
+
+static int
+intern_id(char *id_name);
+
+
+static expr_t *
+fun_expr(char *name, int args_nr, expr_t **args, int line, int column);
+
+#define BIN_EXPR(x, name, arg1, arg2, line, column) { expr_t *e[2]; e[0] = arg1; e[1] = arg2; x = fun_expr(name, 2, e, line, column); }
+
+static int failed_flag = 0;
+
+static void
+magic_frontend_error(const char *msg);
+
+static void
+fail(int line, int column, char *fmt, ...);
+
+static spell_t *
+new_spell(spellguard_t *guard);
+
+static spellguard_t *
+spellguard_implication(spellguard_t *a, spellguard_t *b);
+
+static spellguard_t *
+new_spellguard(int ty);
+
+static effect_t *
+new_effect(int ty);
+
+static effect_t *
+set_effect_continuation(effect_t *src, effect_t *continuation);
+
+static void
+add_spell(spell_t *spell, int line_nr);
+
+static void
+add_teleport_anchor(teleport_anchor_t *anchor, int line_nr);
+
+static effect_t *
+op_effect(char *name, int args_nr, expr_t **args, int line, int column);
+
+int
+magic_frontend_lex();
+
+static void
+install_proc(proc_t *proc);
+
+static effect_t *
+call_proc(char *name, int args_nr, expr_t **args, int line_nr, int column);
+
+static void
+bind_constant(char *name, val_t *val, int line_nr);
+
+static val_t *
+find_constant(char *name);
+
+
+%}
+
+%name-prefix="magic_frontend_"
+
+%locations
+
+%union {
+    int i;
+    char *s;
+    int op;
+    magic_conf_t *magic_conf;
+    val_t value;
+    expr_t *expr;
+    e_location_t location;
+    e_area_t area;
+    args_rec_t arg_list;
+    struct { int letdefs_nr; letdef_t *letdefs; } letdefs;
+    spell_t *spell;
+    struct { int id, ty; } spellarg_def;
+    letdef_t vardef;
+    spellguard_t *spellguard;
+    component_t *components;
+    struct {int id, count; } component;
+    effect_t *effect;
+    proc_t *proc;
+};
+
+%expect 7
+
+%token <i> INT
+%token <s> STRING
+%token <s> ID
+%token <i> DIR
+
+%token '='
+%token '<'
+%token '>'
+%token '+'
+%token '-'
+%token '*'
+%token '/'
+%token '%'
+%token '@'
+%token ','
+%token ':'
+%token ';'
+%token '|'
+%token '['
+%token ']'
+%token '&'
+%token '^'
+
+%token CONST
+%token PROCEDURE
+%token CALL
+%token SILENT
+%token LOCAL
+%token SHL
+%token SHR
+%token EQ
+%token NEQ
+%token GTE
+%token LTE
+%token ANDAND
+%token OROR
+%token <s> SCRIPT_DATA
+%token TO
+%token TOWARDS
+%token TELEPORT_ANCHOR
+%token SPELL
+%token LET
+%token IN
+%token END
+%token DARROW
+%token STRING_TY
+%token REQUIRE
+%token CATALYSTS
+%token COMPONENTS
+%token MANA
+%token CASTTIME
+%token SKIP
+%token ABORT
+%token BREAK
+%token EFFECT
+%token ATEND
+%token ATTRIGGER
+%token PC_F
+%token MOB_F
+%token ENTITY_F
+%token TARGET_F
+%token IF
+%token THEN
+%token ELSE
+%token FOREACH
+%token FOR
+%token DO
+%token SLEEP
+
+%type <value> value
+%type <location> location
+%type <area> area
+%type <arg_list> arg_list
+%type <arg_list> arg_list_ne
+%type <letdefs> defs
+%type <spell> spelldef
+%type <spellarg_def> argopt
+%type <vardef> def
+%type <spellguard> spellbody_list
+%type <spellguard> spellbody
+%type <spellguard> spellguard
+%type <spellguard> spellguard_list
+%type <spellguard> prereq
+%type <component> item
+%type <components> items
+%type <components> item_list
+%type <i> item_name
+%type <i> selection;
+%type <effect> effect
+%type <effect> effect_list
+%type <effect> maybe_trigger
+%type <effect> maybe_end
+%type <i> spell_flags;
+
+%type <expr> expr
+%type <i> arg_ty
+%type <proc> proc_formals_list
+%type <proc> proc_formals_list_ne
+
+%left OROR
+%left ANDAND
+%left '<' '>' GTE LTE NEQ EQ
+%left '+' '-'
+%left '*' '/' '%'
+%left SHL SHR '&' '^' '|'
+%right '='
+%left OR
+%left DARROW
+
+%%
+
+spellconf		: /* empty */
+                          {}
+                        | spellconf_option semicolons spellconf
+                          {}
+			;
+
+
+semicolons		: /* empty */
+			  {}
+                        | semicolons ';'
+                          {}
+			;
+
+
+proc_formals_list	: /* empty  */
+                          { $$ = aCalloc(sizeof(proc_t), 1); }
+			| proc_formals_list_ne
+                          { $$ = $1; }
+			;
+
+proc_formals_list_ne	: ID
+                          { $$ = aCalloc(sizeof(proc_t), 1);
+                            $$->args_nr = 1;
+                            $$->args = malloc(sizeof(int));
+                            $$->args[0] = intern_id($1);
+                          }
+			| proc_formals_list_ne ',' ID
+                          { $$ = $1;
+                            $$->args = realloc($$->args, sizeof(int) * (1 + $$->args_nr));
+                            $$->args[$$->args_nr++] = intern_id($3);
+                          }
+			;
+
+spellconf_option	: ID '=' expr
+			  {
+                            int var_id;
+                            if (find_constant($1)) {
+                                    fail(@1.first_line, 0, "Attempt to redefine constant `%s' as global\n", $1);
+                                    free($1);
+                            } else {
+                                    var_id = intern_id($1);
+                                    magic_eval(&magic_default_env, &magic_conf.vars[var_id], $3);
+                            }
+                          }
+			| CONST ID '=' expr
+			  {
+                            val_t var;
+                            magic_eval(&magic_default_env, &var, $4);
+                            bind_constant($2, &var, @1.first_line);
+                          }
+                        | TELEPORT_ANCHOR ID ':' expr '=' expr
+                          {
+                              teleport_anchor_t *anchor = calloc(sizeof(teleport_anchor_t), 1);
+                              anchor->name = $2;
+                              anchor->invocation = magic_eval_str(&magic_default_env, $4);
+                              anchor->location = $6;
+
+                              if (!failed_flag)
+                                  add_teleport_anchor(anchor, @1.first_line);
+                              failed_flag = 0;
+                          }
+			| PROCEDURE ID '(' proc_formals_list ')' '=' effect_list
+                          {
+                              proc_t *proc = $4;
+                              proc->name = $2;
+                              proc->body = $7;
+                              if (!failed_flag)
+                                  install_proc(proc);
+                              failed_flag = 0;
+                          }
+                        | spell_flags SPELL ID argopt ':' expr '=' spelldef
+                          { spell_t *spell = $8;
+                            spell->name = $3;
+                            spell->invocation = magic_eval_str(&magic_default_env, $6);
+                            spell->arg = $4.id;
+                            spell->spellarg_ty = $4.ty;
+                            spell->flags = $1;
+                            if (!failed_flag)
+                                add_spell(spell, @1.first_line);
+                            failed_flag = 0;
+                          }
+
+spell_flags		: /* empty */
+				{ $$ = 0; }
+			| LOCAL spell_flags
+                        	{ if ($2 & SPELL_FLAG_LOCAL)
+                                        fail(@1.first_line, @1.first_column, "`LOCAL' specified more than once");
+                                   $$ = $2 | SPELL_FLAG_LOCAL;
+                                }
+			| SILENT spell_flags
+                        	{ if ($2 & SPELL_FLAG_SILENT)
+                                        fail(@1.first_line, @1.first_column, "`SILENT' specified more than once");
+                                   $$ = $2 | SPELL_FLAG_SILENT;
+                                }
+
+
+argopt			: /* empty */
+                          { $$.ty = SPELLARG_NONE; }
+                        | '(' ID ':' arg_ty ')'
+                          { $$.id = intern_id($2);
+                            $$.ty = $4; }
+                        ;
+
+
+arg_ty                  : PC_F
+                          { $$ = SPELLARG_PC; }
+                        | STRING_TY
+                          { $$ = SPELLARG_STRING; }
+                        ;
+
+
+value			: DIR
+				{ $$.ty = TY_DIR;
+                                  $$.v.v_int = $1; }
+			| INT
+				{ $$.ty = TY_INT;
+                                  $$.v.v_int = $1; }
+			| STRING
+				{ $$.ty = TY_STRING;
+                                  $$.v.v_string = $1; }
+			;
+
+
+expr			: value
+				{ $$ = magic_new_expr(EXPR_VAL);
+                                  $$->e.e_val = $1; }
+			| ID
+				{
+                                        val_t *val;
+                                        if ((val = find_constant($1))) {
+                                                $$ = magic_new_expr(EXPR_VAL);
+                                                $$->e.e_val = *val;
+                                        } else {
+                                                $$ = magic_new_expr(EXPR_ID);
+                                                $$->e.e_id = intern_id($1);
+                                        }
+                                }
+			| area
+				{ $$ = magic_new_expr(EXPR_AREA);
+                                  $$->e.e_area = $1; }
+			| expr '+' expr
+	                        { BIN_EXPR($$, "+", $1, $3, @1.first_line, @1.first_column); }
+			| expr '-' expr
+	                        { BIN_EXPR($$, "-", $1, $3, @1.first_line, @1.first_column); }
+			| expr '*' expr
+	                        { BIN_EXPR($$, "*", $1, $3, @1.first_line, @1.first_column); }
+			| expr '%' expr
+	                        { BIN_EXPR($$, "%", $1, $3, @1.first_line, @1.first_column); }
+			| expr '/' expr
+	                        { BIN_EXPR($$, "/", $1, $3, @1.first_line, @1.first_column); }
+			| expr '<' expr
+	                        { BIN_EXPR($$, ">", $3, $1, @1.first_line, @1.first_column); }
+			| expr '>' expr
+	                        { BIN_EXPR($$, ">", $1, $3, @1.first_line, @1.first_column); }
+			| expr '&' expr
+	                        { BIN_EXPR($$, "&", $1, $3, @1.first_line, @1.first_column); }
+			| expr '^' expr
+	                        { BIN_EXPR($$, "^", $1, $3, @1.first_line, @1.first_column); }
+			| expr '|' expr
+	                        { BIN_EXPR($$, "|", $1, $3, @1.first_line, @1.first_column); }
+			| expr SHL expr
+	                        { BIN_EXPR($$, "<<", $1, $3, @1.first_line, @1.first_column); }
+			| expr SHR expr
+	                        { BIN_EXPR($$, ">>", $1, $3, @1.first_line, @1.first_column); }
+			| expr LTE expr
+	                        { BIN_EXPR($$, ">=", $3, $1, @1.first_line, @1.first_column); }
+			| expr GTE expr
+	                        { BIN_EXPR($$, ">=", $1, $3, @1.first_line, @1.first_column); }
+			| expr ANDAND expr
+	                        { BIN_EXPR($$, "&&", $1, $3, @1.first_line, @1.first_column); }
+			| expr OROR expr
+	                        { BIN_EXPR($$, "||", $1, $3, @1.first_line, @1.first_column); }
+			| expr EQ expr
+	                        { BIN_EXPR($$, "=", $1, $3, @1.first_line, @1.first_column); }
+			| expr '=' expr
+	                        { BIN_EXPR($$, "=", $1, $3, @1.first_line, @1.first_column); }
+			| expr NEQ expr
+	                        { BIN_EXPR($$, "=", $1, $3, @1.first_line, @1.first_column);
+                                  $$ = fun_expr("not", 1, &$$, @1.first_line, @1.first_column); }
+			| ID '(' arg_list ')'
+                        	{ $$ = fun_expr($1, $3.args_nr, $3.args, @1.first_line, @1.first_column);
+                                  if ($3.args)
+                                          free($3.args);
+                                  free($1); }
+			| '(' expr ')'
+                        	{ $$ = $2; }
+			;
+
+arg_list		: /* empty */
+				{ $$.args_nr = 0; }
+			| arg_list_ne
+				{ $$ = $1 }
+			;
+
+
+arg_list_ne		: expr
+				{ $$.args = aCalloc(sizeof(expr_t *), 1);
+                                  $$.args_nr = 1;
+                                  $$.args[0] = $1;
+                                }
+			| arg_list_ne ',' expr
+                        	{ $$.args = realloc($$.args, (1 + $$.args_nr) * sizeof(expr_t *));
+                                  $$.args[$$.args_nr++] = $3;
+                                }
+			;
+
+
+location		: '@' '(' expr ',' expr ',' expr ')'
+				{ $$.m = $3; $$.x = $5; $$.y = $7; }
+			;
+
+area			: location
+				{ $$.ty = AREA_LOCATION;
+                                  $$.a.a_loc = $1;
+				}
+			| location '@' '+' '(' expr ',' expr ')'
+				{ $$.ty = AREA_RECT;
+                                  $$.a.a_rect.loc = $1;
+                                  $$.a.a_rect.width = $5;
+                                  $$.a.a_rect.height = $7;
+                                }
+			| location TOWARDS expr ':' '(' expr ',' expr ')'
+				{ $$.ty = AREA_BAR;
+                                  $$.a.a_bar.loc = $1;
+                                  $$.a.a_bar.width = $6;
+                                  $$.a.a_bar.depth = $8;
+                                  $$.a.a_bar.dir = $3;
+                                }
+			;
+
+
+spelldef		: spellbody_list
+                                {  $$ = new_spell($1); }
+			| LET defs IN spellbody_list
+                                {  $$ = new_spell($4); 
+                                   $$->letdefs_nr = $2.letdefs_nr;
+                                   $$->letdefs = $2.letdefs;
+                                   $$->spellguard = $4;
+                                }
+			;
+
+
+defs			: semicolons
+				{ $$.letdefs_nr = 0;
+                                  $$.letdefs = (letdef_t *) malloc(1);
+                                }
+			| defs def semicolons
+	                        { $$ = $1;
+                                  $$.letdefs_nr++;
+                                  $$.letdefs = realloc($$.letdefs, sizeof(letdef_t) * $$.letdefs_nr);
+                                  $$.letdefs[$1.letdefs_nr] = $2;
+                                }
+                        ;
+
+
+def			: ID '=' expr
+				{
+                                        if (find_constant($1)) {
+                                                fail(@1.first_line, @1.first_column, "Attempt to re-define constant `%s' as LET-bound variable.\n", $1);
+                                                free($1);
+                                        } else {
+                                                $$.id = intern_id($1);
+                                                $$.expr = $3;
+                                        }
+                                }
+			;
+
+
+spellbody_list		: spellbody
+				{ $$ = $1; }
+			| spellbody '|' spellbody_list
+                        	{ spellguard_t *sg = new_spellguard(SPELLGUARD_CHOICE);
+                                  sg->next = $1;
+                                  sg->s.s_alt = $3;
+                                  $$ = sg;
+                                }
+			;
+
+
+spellbody		: spellguard DARROW spellbody
+				{ $$ = spellguard_implication($1, $3); }
+			| '(' spellbody_list ')'
+                        	{ $$ = $2; }
+			| EFFECT effect_list maybe_trigger maybe_end
+                        	{ spellguard_t *sg = new_spellguard(SPELLGUARD_EFFECT);
+                                  sg->s.s_effect.effect = $2;
+                                  sg->s.s_effect.at_trigger = $3;
+                                  sg->s.s_effect.at_end = $4;
+                                  $$ = sg;
+                                }
+			;
+
+
+maybe_trigger		: /* empty */
+				{ $$ = NULL; }
+			| ATTRIGGER effect_list
+				{ $$ = $2; }
+			;
+
+
+maybe_end		: /* empty */
+				{ $$ = NULL; }
+			| ATEND effect_list
+				{ $$ = $2; }
+			;
+
+
+spellguard		: prereq
+				{ $$ = $1; }
+			| spellguard OR spellguard
+                        	{ spellguard_t *sg = new_spellguard(SPELLGUARD_CHOICE);
+                                  sg->next = $1;
+                                  sg->s.s_alt = $3;
+                                  $$ = sg;
+                                }
+			| '(' spellguard_list ')'
+                        	{ $$ = $2; }
+			;
+
+
+spellguard_list		: spellguard
+				{ $$ = $1; }
+			| spellguard ',' spellguard_list
+                        	{ $$ = spellguard_implication ($1, $3); }
+			;
+
+
+prereq			: REQUIRE expr
+				{ $$ = new_spellguard(SPELLGUARD_CONDITION);
+                                  $$->s.s_condition = $2;
+                                }
+			| CATALYSTS items
+				{ $$ = new_spellguard(SPELLGUARD_CATALYSTS);
+                                  $$->s.s_catalysts = $2;
+                                }
+			| COMPONENTS items
+				{ $$ = new_spellguard(SPELLGUARD_COMPONENTS);
+                                  $$->s.s_components = $2;
+                                }
+			| MANA expr
+				{ $$ = new_spellguard(SPELLGUARD_MANA);
+                                  $$->s.s_mana = $2;
+                                }
+			| CASTTIME expr
+				{ $$ = new_spellguard(SPELLGUARD_CASTTIME);
+                                  $$->s.s_casttime = $2;
+                                }
+			;
+
+
+items			: '[' item_list ']'
+				{ $$ = $2; }
+			;
+
+
+item_list		: item
+				{ $$ = NULL;
+                                  magic_add_component(&$$, $1.id, $1.count);
+                                }
+			| item_list ',' item
+				{ $$ = $1;
+                                  magic_add_component(&$$, $3.id, $3.count);
+                                }
+			;
+
+
+item			: INT '*' item_name
+				{ $$.id = $3; $$.count = $1; }
+			| item_name
+				{ $$.id = $1; $$.count = 1; }
+			;
+
+
+item_name		: STRING
+				{ struct item_data *item = itemdb_searchname($1);
+                                  if (!item) {
+                                          fail (@1.first_line, @1.first_column, "Unknown item `%s'\n", $1);
+                                          $$ = 0;
+                                  } else
+                                          $$ = item->nameid;
+                                  free ($1);
+                                }
+			| INT
+				{ $$ = $1; }
+			;
+
+
+selection		: PC_F
+				{ $$ = FOREACH_FILTER_PC; }
+			| MOB_F
+				{ $$ = FOREACH_FILTER_MOB; }
+			| ENTITY_F
+				{ $$ = FOREACH_FILTER_ENTITY; }
+			| SPELL
+				{ $$ = FOREACH_FILTER_SPELL; }
+			| TARGET_F
+				{ $$ = FOREACH_FILTER_TARGET; }
+			;
+
+
+effect			: '(' effect_list ')'
+				{ $$ = $2; }
+			| SKIP ';'
+                        	{ $$ = new_effect(EFFECT_SKIP); }
+			| ABORT ';'
+                        	{ $$ = new_effect(EFFECT_ABORT); }
+			| END ';'
+                        	{ $$ = new_effect(EFFECT_END); }
+			| BREAK ';'
+                        	{ $$ = new_effect(EFFECT_BREAK); }
+			| ID '=' expr ';'
+                        	{
+                                        if (find_constant($1)) {
+                                                fail(@1.first_line, @1.first_column, "Attempt to re-define constant `%s' in assignment.", $1);
+                                                free($1);
+                                        } else {
+                                                $$ = new_effect(EFFECT_ASSIGN);
+                                                $$->e.e_assign.id = intern_id($1);
+                                                $$->e.e_assign.expr = $3;
+                                        }
+                                }
+			| FOREACH selection ID IN expr DO effect
+                        	{ $$ = new_effect(EFFECT_FOREACH);
+                                  $$->e.e_foreach.id = intern_id($3);
+                                  $$->e.e_foreach.area = $5;
+                                  $$->e.e_foreach.body = $7;
+                                  $$->e.e_foreach.filter = $2;
+                                }
+			| FOR ID '=' expr TO expr DO effect
+                        	{ $$ = new_effect(EFFECT_FOR);
+                                  $$->e.e_for.id = intern_id($2);
+                                  $$->e.e_for.start = $4;
+                                  $$->e.e_for.stop = $6;
+                                  $$->e.e_for.body = $8;
+                                }
+			| IF expr THEN effect ELSE effect
+                        	{ $$ = new_effect(EFFECT_IF);
+                                  $$->e.e_if.cond = $2;
+                                  $$->e.e_if.true_branch = $4;
+                                  $$->e.e_if.false_branch = $6;
+                                }
+			| IF expr THEN effect
+                        	{ $$ = new_effect(EFFECT_IF);
+                                  $$->e.e_if.cond = $2;
+                                  $$->e.e_if.true_branch = $4;
+                                  $$->e.e_if.false_branch = new_effect(EFFECT_SKIP);
+                                }
+			| SLEEP expr ';'
+                        	{ $$ = new_effect(EFFECT_SLEEP);
+                                  $$->e.e_sleep = $2;
+                                }
+			| ID '(' arg_list ')' ';'
+                                { $$ = op_effect($1, $3.args_nr, $3.args, @1.first_line, @1.first_column);
+                                  free($1);
+                                }
+			| SCRIPT_DATA
+                        	{ $$ = new_effect(EFFECT_SCRIPT);
+                                  $$->e.e_script = parse_script((unsigned char *) $1, @1.first_line);
+                                  free($1);
+                                  if ($$->e.e_script == NULL)
+                                      fail(@1.first_line, @1.first_column, "Failed to compile script\n");
+                                }
+			| CALL ID '(' arg_list ')' ';'
+                        	{ $$ = call_proc($2, $4.args_nr, $4.args, @1.first_line, @1.first_column);
+                                  free($2);
+                                }
+			;
+
+effect_list		: /* empty */
+                        	{ $$ = new_effect(EFFECT_SKIP); }
+			| effect semicolons effect_list
+                        	{ $$ = set_effect_continuation($1, $3); }
+			;
+			
+
+%%
+
+/* We do incremental realloc here to store our results.  Since this happens only once
+ * during startup for a relatively manageable set of configs, it should be fine. */
+
+static int
+intern_id(char *id_name)
+{
+        int i;
+
+        for (i = 0; i < magic_conf.vars_nr; i++)
+                if (!strcmp(id_name, magic_conf.var_name[i])) {
+                        free(id_name);
+                        return i;
+                }
+
+        /* Must add new */
+        i = magic_conf.vars_nr++;
+        magic_conf.var_name = realloc(magic_conf.var_name, magic_conf.vars_nr * sizeof(char *));
+        magic_conf.var_name[i] = id_name;
+        magic_conf.vars = realloc(magic_conf.vars, magic_conf.vars_nr * sizeof(val_t));
+        magic_conf.vars[i].ty = TY_UNDEF;
+
+        return i;
+}
+
+static void
+add_spell(spell_t *spell, int line_nr)
+{
+        int index = magic_conf.spells_nr;
+        int i;
+
+        for (i = 0; i < index; i++) {
+                if (!strcmp(magic_conf.spells[i]->name, spell->name)) {
+                        fail(line_nr, 0, "Attempt to redefine spell `%s'\n", spell->name);
+                        return;
+                }
+                if (!strcmp(magic_conf.spells[i]->invocation, spell->invocation)) {
+                        fail(line_nr, 0, "Attempt to redefine spell invocation `%s' between spells `%s' and `%s'\n",
+                             spell->invocation, magic_conf.spells[i]->name, spell->name);
+                        return;
+                }
+        }
+        magic_conf.spells_nr++;
+
+        magic_conf.spells = realloc(magic_conf.spells, magic_conf.spells_nr * sizeof (spell_t*));
+        magic_conf.spells[index] = spell;
+
+            
+}
+
+static void
+add_teleport_anchor(teleport_anchor_t *anchor, int line_nr)
+{
+        int index = magic_conf.anchors_nr;
+        int i;
+
+        for (i = 0; i < index; i++) {
+                if (!strcmp(magic_conf.anchors[i]->name, anchor->name)) {
+                        fail(line_nr, 0, "Attempt to redefine teleport anchor `%s'\n", anchor->name);
+                        return;
+                }
+                if (!strcmp(magic_conf.anchors[i]->invocation, anchor->invocation)) {
+                        fail(line_nr, 0, "Attempt to redefine anchor invocation `%s' between anchors `%s' and `%s'\n",
+                             anchor->invocation, magic_conf.anchors[i]->name, anchor->name);
+                        return;
+                }
+        }
+        magic_conf.anchors_nr++;
+
+        magic_conf.anchors = realloc(magic_conf.anchors, magic_conf.anchors_nr * sizeof (teleport_anchor_t*));
+        magic_conf.anchors[index] = anchor;
+}
+
+
+static void
+fail(int line, int column, char *fmt, ...)
+{
+        va_list ap;
+        fprintf(stderr, "[magic-init]  L%d:%d: ", line, column);
+        va_start(ap, fmt);
+        vfprintf(stderr, fmt, ap);
+        failed_flag = 1;
+}
+
+static expr_t *
+fun_expr(char *name, int args_nr, expr_t **args, int line, int column)
+{
+        int id;
+        expr_t *expr;
+        fun_t *fun = magic_get_fun(name, &id);
+
+        if (!fun) {
+                fail(line, column, "Unknown function `%s'\n", name);
+        } else if (strlen(fun->signature) != args_nr) {
+                fail(line, column, "Incorrect number of arguments to function `%s': Expected %d, found %d\n", name, strlen(fun->signature), args_nr);
+                fun = NULL;
+        }
+
+        if (fun) {
+                int i;
+
+                expr = magic_new_expr(EXPR_FUNAPP);
+                expr->e.e_funapp.line_nr = line;
+                expr->e.e_funapp.column = column;
+                expr->e.e_funapp.id = id;
+                expr->e.e_funapp.args_nr = args_nr;
+
+                for (i = 0; i < args_nr; i++)
+                        expr->e.e_funapp.args[i] = args[i];
+        } else { /* failure */
+                expr = magic_new_expr(EXPR_VAL);
+                expr->e.e_val.ty = TY_FAIL;
+        }
+
+        return expr;
+}
+
+static spell_t *
+new_spell(spellguard_t *guard)
+{
+        spell_t *retval = calloc(1, sizeof(spell_t));
+        retval->spellguard = guard;
+        return retval;
+}
+
+static spellguard_t *
+new_spellguard(int ty)
+{
+        spellguard_t *retval = calloc(1, sizeof(spellguard_t));
+        retval->ty = ty;
+        return retval;
+}
+
+static spellguard_t *
+spellguard_implication(spellguard_t *a, spellguard_t *b)
+{
+        spellguard_t *retval = a;
+
+        if (a == b) /* This can happen due to reference sharing:
+                     * e.g.,
+                     *  (R0 -> (R1 | R2)) => (R3)
+                     * yields
+                     *  (R0 -> (R1 -> R3 | R2 -> R3))
+                     *
+                     * So if we now add => R4 to that, we want
+                     *  (R0 -> (R1 -> R3 -> R4 | R2 -> R3 -> R4))
+                     *
+                     * but we only need to add it once, because the R3 reference is shared.
+                    */
+                return retval;
+
+                /* If the premise is a disjunction, b is the continuation of _all_ branches */
+        if (a->ty == SPELLGUARD_CHOICE)
+                spellguard_implication(a->s.s_alt, b);
+        if (a->next)
+                spellguard_implication(a->next, b);
+        else
+                a->next = b;
+                
+
+        return retval;
+}
+
+static effect_t *
+new_effect(int ty)
+{
+        effect_t *effect = (effect_t *) calloc(1, sizeof(effect_t));
+        effect->ty = ty;
+        return effect;
+}
+
+static effect_t *
+set_effect_continuation(effect_t *src, effect_t *continuation)
+{
+        effect_t *retval = src;
+        /* This function is completely analogous to `spellguard_implication' above; read the control flow implications above first before pondering it. */
+
+        if (src == continuation)
+                return retval;
+
+        /* For FOR and FOREACH, we use special stack handlers and thus don't have to set
+         * the continuation.  It's only IF that we need to handle in this fashion. */
+        if (src->ty == EFFECT_IF) {
+                set_effect_continuation(src->e.e_if.true_branch, continuation);
+                set_effect_continuation(src->e.e_if.false_branch, continuation);
+        }
+        if (src->next)
+                set_effect_continuation(src->next, continuation);
+        else
+                src->next = continuation;
+
+        return retval;
+}
+
+static effect_t *
+op_effect(char *name, int args_nr, expr_t **args, int line, int column)
+{
+        int id;
+        effect_t *effect;
+        op_t *op = magic_get_op(name, &id);
+
+        if (!op)
+                fail(line, column, "Unknown operation `%s'\n", name);
+        else if (strlen(op->signature) != args_nr) {
+                fail(line, column, "Incorrect number of arguments to operation `%s': Expected %d, found %d\n", name, strlen(op->signature), args_nr);
+                op = NULL;
+        }
+
+        if (op) {
+                int i;
+
+                effect = new_effect(EFFECT_OP);
+                effect->e.e_op.line_nr = line;
+                effect->e.e_op.column = column;
+                effect->e.e_op.id = id;
+                effect->e.e_op.args_nr = args_nr;
+
+                for (i = 0; i < args_nr; i++)
+                        effect->e.e_op.args[i] = args[i];
+        } else /* failure */
+                effect = new_effect(EFFECT_SKIP);
+
+        return effect;
+}
+
+
+proc_t *procs = NULL;
+int procs_nr = 0;
+
+
+static void
+install_proc(proc_t *proc)
+{
+        if (!procs) {
+                procs = proc;
+                procs_nr = 1;
+        } else {
+                procs = realloc(procs, sizeof(proc_t) * (1 + procs_nr));
+                procs[procs_nr++] = *proc;
+        }
+}
+
+static effect_t *
+call_proc(char *name, int args_nr, expr_t **args, int line_nr, int column)
+{
+        proc_t *p = NULL;
+        int i;
+        effect_t *retval;
+
+        for (i = 0; i < procs_nr; i++)
+                if (!strcmp(procs[i].name, name)) {
+                        p = &procs[i];
+                        break;
+                }
+
+        if (!p) {
+                fail(line_nr, column, "Unknown procedure `%s'\n", name);
+                return new_effect(EFFECT_SKIP);
+        }
+
+        if (p->args_nr != args_nr) {
+                fail(line_nr, column, "Procedure %s/%d invoked with %d parameters\n", name, p->args_nr, args_nr);
+                return new_effect(EFFECT_SKIP);
+        }
+
+        retval = new_effect(EFFECT_CALL);
+        retval->e.e_call.body = p->body;
+        retval->e.e_call.args_nr = args_nr;
+        retval->e.e_call.formals = p->args;
+        retval->e.e_call.actuals = args;
+        return retval;
+}
+
+struct const_def_rec {
+        char *name;
+        val_t val;
+} *const_defs = NULL;
+
+int const_defs_nr = 0;
+
+static void
+bind_constant(char *name, val_t *val, int line_nr)
+{
+        if (find_constant(name)) {
+                fail(line_nr, 0, "Redefinition of constant `%s'\n", name);
+                return;
+        }
+
+        if (!const_defs)
+                const_defs = (struct const_def_rec *)malloc(sizeof(struct const_def_rec));
+        else
+                const_defs = (struct const_def_rec *)realloc(const_defs,
+                                                             (const_defs_nr + 1) * sizeof(struct const_def_rec));
+
+        const_defs[const_defs_nr].name = name;
+        const_defs[const_defs_nr].val = *val;
+        ++const_defs_nr;
+}
+
+static val_t *
+find_constant(char *name)
+{
+        int i;
+        for (i = 0; i < const_defs_nr; i++) {
+                if (!strcmp(const_defs[i].name, name)) {
+                        free(name);
+                        return &const_defs[i].val;
+                }
+        }
+
+        return NULL;
+}
+
+
+
+
+#define INTERN_ASSERT(name, id) { int zid = intern_id(name); if (zid != id) fprintf(stderr, "[magic-conf] INTERNAL ERROR: Builtin special var %s interned to %d, not %d as it should be!\n", name, zid, id); error_flag = 1; }
+
+extern FILE *magic_frontend_in;
+
+int
+magic_init(char *conffile) // must be called after itemdb initialisation
+{
+        int error_flag = 0;
+
+        magic_conf.vars_nr = 0;
+        magic_conf.var_name = (char **)malloc(1);
+        magic_conf.vars = (val_t *)malloc(1);
+
+        magic_conf.obscure_chance = 95;
+        magic_conf.min_casttime = 100;
+
+        magic_conf.spells_nr = 0;
+        magic_conf.spells = (spell_t **)malloc(1);
+
+        magic_conf.anchors_nr = 0;
+        magic_conf.anchors = (teleport_anchor_t **)malloc(1);
+
+        INTERN_ASSERT("min_casttime", VAR_MIN_CASTTIME);
+        INTERN_ASSERT("obscure_chance", VAR_OBSCURE_CHANCE);
+        INTERN_ASSERT("caster", VAR_CASTER);
+        INTERN_ASSERT("spellpower", VAR_SPELLPOWER);
+        INTERN_ASSERT("self_spell", VAR_SPELL);
+        INTERN_ASSERT("self_invocation", VAR_INVOCATION);
+        INTERN_ASSERT("target", VAR_TARGET);
+        INTERN_ASSERT("script_target", VAR_SCRIPTTARGET);
+        INTERN_ASSERT("location", VAR_LOCATION);
+
+        magic_frontend_in = fopen(conffile, "r");
+        if (!magic_frontend_in) {
+                fprintf(stderr, "[magic-conf] Magic configuration file `%s' not found -> no magic.\n", conffile);
+                return 0;
+        }
+        magic_frontend_parse();
+
+        if (magic_conf.vars[VAR_MIN_CASTTIME].ty == TY_INT)
+                magic_conf.min_casttime = magic_conf.vars[VAR_MIN_CASTTIME].v.v_int;
+
+        if (magic_conf.vars[VAR_OBSCURE_CHANCE].ty == TY_INT)
+                magic_conf.obscure_chance = magic_conf.vars[VAR_OBSCURE_CHANCE].v.v_int;
+
+        printf("[magic-conf] Magic initialised; obscure at %d%%.  %d spells, %d teleport anchors.\n",
+               magic_conf.obscure_chance, magic_conf.spells_nr, magic_conf.anchors_nr);
+
+        if (procs)
+                free(procs);
+        return error_flag;
+}
+
+extern int magic_frontend_lineno;
+
+static void
+magic_frontend_error(const char *msg)
+{
+    fprintf(stderr, "[magic-conf] Parse error: %s at line %d\n", msg, magic_frontend_lineno);
+    failed_flag = 1;
+}
diff --git a/src/map/magic-interpreter.h b/src/map/magic-interpreter.h
new file mode 100644
index 0000000..94c32bc
--- /dev/null
+++ b/src/map/magic-interpreter.h
@@ -0,0 +1,418 @@
+/* Magic interpreter */
+
+#ifndef MAGIC_INTERPRETER_H
+#define MAGIC_INTERPRETER_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "magic.h"
+#include "malloc.h"
+#include "map.h"
+#include "chrif.h"
+#include "clif.h"
+#include "intif.h"
+#include "pc.h"
+#include "npc.h"
+#include "mob.h"
+#include "pet.h"
+#include "itemdb.h"
+#include "script.h"
+#include "battle.h"
+#include "skill.h"
+#include "party.h"
+#include "guild.h"
+#include "chat.h"
+#include "trade.h"
+#include "storage.h"
+#include "vending.h"
+#include "nullpo.h"
+
+#include "../common/timer.h"
+
+#define SPELLARG_NONE	0	/* No spell parameter */
+#define SPELLARG_PC	1	/* Spell parameter describes pc (defaults to self) */
+#define SPELLARG_STRING	2	/* Spell parameter describes pc (defaults to self) */
+
+
+
+/* ------ */
+/* Values */
+/* ------ */
+
+#define TY_UNDEF	0
+#define TY_INT		1
+#define TY_DIR		2
+#define TY_STRING	3 
+#define TY_ENTITY	5
+#define TY_LOCATION	6
+#define TY_AREA		7
+#define TY_SPELL	8
+#define TY_INVOCATION	9
+#define TY_FAIL		127
+
+#define DIR_S	0
+#define DIR_SW	1
+#define DIR_W	2
+#define DIR_NW	3
+#define DIR_N	4
+#define DIR_NE	5
+#define DIR_E	6
+#define DIR_SE	7
+
+struct expr;
+struct val;
+struct location;
+struct area;
+struct spell;
+struct invocation;
+
+typedef struct location {
+    int m;
+    int x, y;
+} location_t;
+
+#define AREA_LOCATION	0
+#define AREA_UNION	1
+#define AREA_RECT	2
+#define AREA_BAR	3
+
+typedef struct area {
+    union a {
+        location_t a_loc;
+        struct { location_t loc; int width, depth, dir; } a_bar;
+        struct { location_t loc; int width, height; } a_rect;
+        struct area * a_union[2];
+    } a;
+    int size;
+    unsigned char ty;
+} area_t;
+
+typedef struct val {
+    union v {
+        int v_int;
+        char *v_string;
+        entity_t *v_entity; /* Used ONLY during operation/function invocation; otherwise we use v_int */
+        area_t *v_area;
+        location_t v_location;
+        struct invocation *v_invocation;  /* Used ONLY during operation/function invocation; otherwise we use v_int */
+        struct spell *v_spell;
+    } v;
+    unsigned char ty;
+} val_t;
+
+
+/* ----------- */
+/* Expressions */
+/* ----------- */
+
+#define MAX_ARGS 7	/* Max. # of args used in builtin primitive functions */
+
+#define EXPR_VAL	0
+#define EXPR_LOCATION	1
+#define EXPR_AREA	2
+#define EXPR_FUNAPP	3
+#define EXPR_ID		4
+
+typedef struct e_location {
+    struct expr *m, *x, *y;
+} e_location_t;
+
+typedef struct e_area {
+    union a0 {
+        e_location_t a_loc;
+        struct { e_location_t loc; struct expr *width, *depth, *dir; } a_bar;
+        struct { e_location_t loc; struct expr *width, *height; } a_rect;
+        struct e_area* a_union[2];
+    } a;
+    unsigned char ty;
+} e_area_t;
+
+typedef struct expr {
+    union e {
+        val_t e_val;
+        e_location_t e_location;
+        e_area_t e_area;
+        struct { int id, line_nr, column; int args_nr; struct expr *args[MAX_ARGS]; } e_funapp;
+        int e_id;
+    } e;
+    unsigned char ty;
+} expr_t;
+
+
+/* ------- */
+/* Effects */
+/* ------- */
+
+#define EFFECT_SKIP	0
+#define EFFECT_ABORT	1
+#define EFFECT_ASSIGN	2
+#define EFFECT_FOREACH	3
+#define EFFECT_FOR	4
+#define EFFECT_IF	5
+#define EFFECT_SLEEP	6
+#define EFFECT_SCRIPT	7
+#define EFFECT_BREAK	8
+#define EFFECT_OP	9
+#define EFFECT_END	10
+#define EFFECT_CALL	11
+
+#define FOREACH_FILTER_MOB	1
+#define FOREACH_FILTER_PC	2
+#define FOREACH_FILTER_ENTITY	3
+#define FOREACH_FILTER_TARGET	4
+#define FOREACH_FILTER_SPELL	5
+
+typedef struct effect {
+    struct effect* next;
+    union e0 {
+        struct { int id; expr_t *expr; } e_assign;
+        struct { int id;
+                 expr_t *area;
+                 struct effect* body;
+                 unsigned char filter; } e_foreach;
+        struct { int id;
+                 expr_t *start, *stop;
+                 struct effect *body; } e_for;
+        struct { expr_t *cond; struct effect *true_branch, *false_branch; } e_if;
+        expr_t *e_sleep; /* sleep time */
+        unsigned char *e_script;
+        struct { int id; int args_nr; int line_nr, column; expr_t *args[MAX_ARGS]; } e_op;
+        struct { int args_nr, *formals; expr_t **actuals; struct effect *body; } e_call;
+    } e;
+    unsigned char ty;
+} effect_t;
+
+
+/* ---------- */
+/* Components */ 
+/* ---------- */
+
+typedef struct component {
+    struct component *next;
+    int item_id;
+    int count;
+} component_t;
+
+
+/* ----------- */
+/* Spellguards */
+/* ----------- */
+
+#define SPELLGUARD_CONDITION	0
+#define SPELLGUARD_COMPONENTS	1
+#define SPELLGUARD_CATALYSTS	2
+#define SPELLGUARD_CHOICE	3
+#define SPELLGUARD_MANA		4
+#define SPELLGUARD_CASTTIME	5
+#define SPELLGUARD_EFFECT	6
+
+typedef struct effect_set {
+        effect_t *effect, *at_trigger, *at_end;
+} effect_set_t;
+
+typedef struct spellguard {
+    struct spellguard *next;
+    union s {
+        expr_t *s_condition;
+        expr_t *s_mana;
+        expr_t *s_casttime;
+        component_t *s_components;
+        component_t *s_catalysts;
+        struct spellguard *s_alt; /* either `next' or `s.s_alt' */
+        effect_set_t s_effect;
+    } s;
+    unsigned char ty;
+} spellguard_t;
+
+
+/* ------ */
+/* Spells */
+/* ------ */
+
+typedef struct letdef {
+    int id;
+    expr_t *expr;
+} letdef_t;
+
+#define SPELL_FLAG_LOCAL	(1 << 0) // spell associated not with caster but with place
+#define SPELL_FLAG_SILENT	(1 << 1) // spell invocation never uttered
+
+typedef struct spell {
+    char *name;
+    char *invocation;
+    int flags;
+    int arg;
+    int spellarg_ty;
+
+    int letdefs_nr;
+    letdef_t *letdefs;
+
+    spellguard_t *spellguard;
+} spell_t;
+
+/* ------- */
+/* Anchors */
+/* ------- */
+
+typedef struct teleport_anchor {
+    char *name;
+    char *invocation;
+    expr_t *location;
+} teleport_anchor_t;
+
+/* ------------------- */
+/* The big config blob */
+/* ------------------- */
+
+typedef struct {
+    int vars_nr;
+    char **var_name;
+    val_t *vars; /* Initial assignments, if any, or NULL */
+
+    int obscure_chance;
+    int min_casttime;
+
+    int spells_nr;
+    spell_t **spells;
+
+    int anchors_nr; /* NEGATIVE iff we have sorted the anchors */
+    teleport_anchor_t **anchors;
+} magic_conf_t;
+
+
+/* Execution environment */
+
+#define VAR_MIN_CASTTIME	0
+#define VAR_OBSCURE_CHANCE	1
+#define VAR_CASTER		2
+#define VAR_SPELLPOWER		3
+#define VAR_SPELL		4
+#define VAR_INVOCATION		5
+#define VAR_TARGET		6
+#define VAR_SCRIPTTARGET	7
+#define VAR_LOCATION		8
+
+struct magic_config;
+
+typedef struct env {
+    magic_conf_t *base_env;
+    val_t *vars;
+} env_t;
+
+#define MAX_STACK_SIZE 32
+
+#define CONT_STACK_FOREACH	0
+#define CONT_STACK_FOR		1
+#define CONT_STACK_PROC		2
+
+typedef struct cont_activation_record {
+    effect_t *return_location;
+    union c {
+        struct { int id; effect_t *body; int entities_nr; int *entities; int index; } c_foreach;
+        struct { int id; effect_t *body; int current; int stop; } c_for;
+        struct { int args_nr, *formals; val_t *old_actuals; } c_proc;
+    } c;
+    unsigned char ty;
+} cont_activation_record_t;
+
+typedef struct status_change_ref {
+    int sc_type;
+    int bl_id;
+} status_change_ref_t;
+
+#define INVOCATION_FLAG_BOUND		(1 << 0)	/* Bound directly to the caster (i.e., ignore its location) */
+#define INVOCATION_FLAG_ABORTED		(1 << 1)	/* Used `abort' to terminate */
+
+typedef struct invocation {
+    struct block_list bl;
+
+    struct invocation *next_invocation; /* used for spells directly associated with a caster: they form a singly-linked list */
+    int flags;
+
+    env_t *env;
+    spell_t *spell;
+    int caster;  /* this is the person who originally invoked the spell */
+    int subject; /* when this person dies, the spell dies with it */
+
+    int timer; /* spell timer, if any */
+
+    int stack_size;
+    cont_activation_record_t stack[MAX_STACK_SIZE];
+
+    int script_pos; /* Script position; if nonzero, resume the script we were running. */
+    effect_t *current_effect;
+    effect_t *trigger_effect; /* If non-NULL, this is used to spawn a cloned effect based on the same environment */
+    effect_t *end_effect; /* If non-NULL, this is executed when the spell terminates naturally, e.g. when all status changes have run out or all delays are over. */
+
+    /* Status change references:  for status change updates, keep track of whom we updated where */
+    int status_change_refs_nr;
+    status_change_ref_t *status_change_refs;
+
+} invocation_t;
+
+
+extern magic_conf_t magic_conf; /* Global magic conf */
+extern env_t magic_default_env; /* Fake default environment */
+
+
+/**
+ * Adds a component selection to a component holder (which may initially be NULL)
+ */
+void
+magic_add_component(component_t **component_holder, int id, int count);
+
+
+teleport_anchor_t *
+magic_find_anchor(char *name);
+
+/**
+ * The parameter `param' must have been dynamically allocated; ownership is transferred to the resultant env_t.
+ */
+env_t *
+spell_create_env(magic_conf_t *conf, spell_t *spell, character_t *caster, int spellpower, char *param);
+
+void
+magic_free_env(env_t *env);
+
+effect_set_t *
+spell_trigger(spell_t *spell, character_t *caster, env_t *env);
+
+invocation_t *
+spell_instantiate(effect_set_t *effect, env_t *env);
+
+/**
+ * Bind a spell to a subject (this is a no-op for `local' spells).
+ */
+void
+spell_bind(character_t *subject, invocation_t *invocation);
+
+int // 1 on failure
+spell_unbind(character_t *subject, invocation_t *invocation);
+
+
+/**
+ * Clones a spell to run the at_effect field
+ */
+invocation_t *
+spell_clone_effect(invocation_t *source);
+
+spell_t *
+magic_find_spell(char *invocation);
+
+/* The following is used only by the parser: */
+typedef struct args_rec {
+    int args_nr;
+    expr_t **args;
+} args_rec_t;
+
+typedef struct {
+        char *name;
+        int args_nr;
+        int *args;
+        effect_t *body;
+} proc_t;
+
+#endif /* !defined (MAGIC_INTERPRETER_H) */
diff --git a/src/map/magic-interpreter.l b/src/map/magic-interpreter.l
new file mode 100644
index 0000000..ce71320
--- /dev/null
+++ b/src/map/magic-interpreter.l
@@ -0,0 +1,137 @@
+%{
+#include "magic-interpreter.h"
+#include "magic-interpreter-parser.h"
+
+#ifdef HEADING
+#  undef HEADING
+#endif
+
+#define FIXLOC magic_frontend_lloc.first_line = magic_frontend_lineno
+
+#define HEADING(dir) { magic_frontend_lval.i = dir; FIXLOC; return DIR; }
+
+%}
+
+%option yylineno
+%option noyywrap
+%option prefix="magic_frontend_"
+%option nounput
+%option noinput
+%option bison-bridge bison-locations
+
+%%
+
+"S"			HEADING(0);
+"SW"			HEADING(1);
+"W"			HEADING(2);
+"NW"			HEADING(3);
+"N"			HEADING(4);
+"NE"			HEADING(5);
+"E"			HEADING(6);
+"SE"			HEADING(7);
+"="			{FIXLOC; return '=';}
+"=="			{FIXLOC; return EQ;}
+"<>"			{FIXLOC; return NEQ;}
+"!="			{FIXLOC; return NEQ;}
+">"			{FIXLOC; return '>';}
+"<"			{FIXLOC; return '<';}
+">="			{FIXLOC; return GTE;}
+"<="			{FIXLOC; return LTE;}
+"("			{FIXLOC; return '(';}
+")"			{FIXLOC; return ')';}
+"+"			{FIXLOC; return '+';}
+"-"			{FIXLOC; return '-';}
+"*"			{FIXLOC; return '*';}
+"/"			{FIXLOC; return '/';}
+"%"			{FIXLOC; return '%';}
+"&&"			{FIXLOC; return ANDAND;}
+"||"			{FIXLOC; return OROR;}
+";"			{FIXLOC; return ';';}
+":"			{FIXLOC; return ':';}
+","			{FIXLOC; return ',';}
+"@"			{FIXLOC; return '@';}
+"|"			{FIXLOC; return '|';}
+"["			{FIXLOC; return '[';}
+"]"			{FIXLOC; return ']';}
+"&"			{FIXLOC; return '&';}
+"^"			{FIXLOC; return '^';}
+"<<"			{FIXLOC; return SHL;}
+">>"			{FIXLOC; return SHR;}
+"PROCEDURE"		{FIXLOC; return PROCEDURE;}
+"CALL"			{FIXLOC; return CALL;}
+"OR"			{FIXLOC; return OR;}
+"TO"			{FIXLOC; return TO;}
+"TOWARDS"		{FIXLOC; return TOWARDS;}
+"TELEPORT-ANCHOR"	{FIXLOC; return TELEPORT_ANCHOR;}
+"SILENT"		{FIXLOC; return SILENT;}
+"LOCAL"			{FIXLOC; return LOCAL;}
+"SPELL"			{FIXLOC; return SPELL;}
+"LET"			{FIXLOC; return LET;}
+"IN"			{FIXLOC; return IN;}
+"END"			{FIXLOC; return END;}
+"=>"			{FIXLOC; return DARROW;}
+"STRING"		{FIXLOC; return STRING_TY;}
+"REQUIRE"		{FIXLOC; return REQUIRE;}
+"CATALYSTS"		{FIXLOC; return CATALYSTS;}
+"COMPONENTS"		{FIXLOC; return COMPONENTS;}
+"MANA"			{FIXLOC; return MANA;}
+"CASTTIME"		{FIXLOC; return CASTTIME;}
+"SKIP"			{FIXLOC; return SKIP;}
+"ABORT"			{FIXLOC; return ABORT;}
+"BREAK"			{FIXLOC; return BREAK;}
+"EFFECT"		{FIXLOC; return EFFECT;}
+"ATEND"			{FIXLOC; return ATEND;}
+"ATTRIGGER"		{FIXLOC; return ATTRIGGER;}
+"CONST"			{FIXLOC; return CONST;}
+"PC"			{FIXLOC; return PC_F;}
+"MOB"			{FIXLOC; return MOB_F;}
+"ENTITY"		{FIXLOC; return ENTITY_F;}
+"TARGET"		{FIXLOC; return TARGET_F;}
+"IF"			{FIXLOC; return IF;}
+"THEN"			{FIXLOC; return THEN;}
+"ELSE"			{FIXLOC; return ELSE;}
+"FOREACH"		{FIXLOC; return FOREACH;}
+"FOR"			{FIXLOC; return FOR;}
+"DO"			{FIXLOC; return DO;}
+"WAIT"			{FIXLOC; return SLEEP;}
+
+\{([^\}]|\\.)*\} { char *string = strdup(yytext);
+                   magic_frontend_lval.s = string;
+		   FIXLOC;
+                   return SCRIPT_DATA;
+                   }
+
+\"([^\"]|\\.)*\" { char *string = strdup(yytext + 1);
+                   char *src = string;
+                   char *dst = string;
+                   while (*src && *src != '"')
+                       if (*src == '\\') {
+                           *dst++ = src[1];
+                           src += 2;
+                       } else
+                           *dst++ = *src++;
+                   *dst = '\0'; /* terminate */
+                   magic_frontend_lval.s = string;
+		   FIXLOC;
+                   return STRING;
+                   }
+
+"-"?[0-9]+	    { magic_frontend_lval.i = atoi(yytext);
+		      FIXLOC;
+                      return INT; }
+
+"0x"[0-9a-fA-F]+    { magic_frontend_lval.i = strtol(yytext + 2, NULL, 16);
+		      FIXLOC;
+                      return INT; }
+
+[a-zA-Z][-_a-zA-Z0-9?!]*  { magic_frontend_lval.s = strdup(yytext);
+		            FIXLOC;
+                            return ID; }
+
+"#".*$		/* Ignore comments */
+"//".*$		/* Ignore comments */
+[ \n\t\r]	/* ignore whitespace */	
+.       	fprintf(stderr, "%s: Unexpected character in line %d\n", MAGIC_CONFIG_FILE, magic_frontend_lineno);
+
+
+%%
diff --git a/src/map/magic-stmt.c b/src/map/magic-stmt.c
new file mode 100644
index 0000000..49c75b1
--- /dev/null
+++ b/src/map/magic-stmt.c
@@ -0,0 +1,1323 @@
+#include "magic-interpreter.h"
+#include "magic-expr.h"
+#include "magic-expr-eval.h"
+#include "magic-interpreter-aux.h"
+
+int
+clif_spawn_fake_npc_for_player(struct map_session_data *sd, int fake_npc_id);
+
+#define INVISIBLE_NPC 127 /* used for local spell effects */
+
+//#define DEBUG
+
+static void
+print_val(val_t *v)
+{
+        switch (v->ty) {
+        case TY_UNDEF: fprintf(stderr, "UNDEF"); break;
+        case TY_INT: fprintf(stderr, "%d", v->v.v_int); break;
+        case TY_DIR: fprintf(stderr, "dir%d", v->v.v_int); break;
+        case TY_STRING: fprintf(stderr, "`%s'", v->v.v_string); break;
+        default: fprintf(stderr, "ty%d", v->ty); break;
+        }
+}
+
+static void
+dump_env(env_t *env)
+{
+        int i;
+        for (i = 0; i < env->base_env->vars_nr; i++) {
+                val_t *v = &env->vars[i];
+                val_t *bv = &env->base_env->vars[i];
+
+                fprintf(stderr, "%02x %30s ", i, env->base_env->var_name[i]);
+                print_val(v);
+                fprintf(stderr, "\t(");
+                print_val(bv);
+                fprintf(stderr, ")\n");
+        }
+}
+
+static void
+clear_activation_record(cont_activation_record_t *ar)
+{
+        switch (ar->ty) {
+        case CONT_STACK_FOREACH:
+                free(ar->c.c_foreach.entities);
+                break;
+        case CONT_STACK_PROC:
+                free(ar->c.c_proc.old_actuals);
+                break;
+        }
+}
+
+static int
+invocation_timer_callback(int _, unsigned int __, int id, int data)
+{
+        invocation_t *invocation = (invocation_t *) map_id2bl(id);
+
+        if (invocation) {
+                invocation->timer = 0;
+                spell_execute(invocation);
+        }
+        return 0;
+}
+
+static void
+clear_stack(invocation_t *invocation)
+{
+        int i;
+
+        for (i = 0; i < invocation->stack_size; i++)
+                clear_activation_record(&invocation->stack[i]);
+
+        invocation->stack_size = 0;
+}
+
+static void
+free_invocation(invocation_t *invocation)
+{
+        if (invocation->status_change_refs)
+                free(invocation->status_change_refs);
+
+        if (invocation->flags & INVOCATION_FLAG_BOUND) {
+                entity_t *e = map_id2bl(invocation->subject);
+                if (e && e->type == BL_PC)
+                        spell_unbind((character_t *) e, invocation); 
+        }
+
+        clear_stack(invocation);
+
+        if (invocation->timer)
+                delete_timer(invocation->timer, invocation_timer_callback);
+
+        magic_free_env(invocation->env);
+
+	map_delblock(&invocation->bl);
+        map_delobject(invocation->bl.id); // also frees the object
+//        free(invocation);
+}
+
+void
+magic_stop_completely(character_t *c)
+{
+        while (c->active_spells)
+                free_invocation(c->active_spells);
+}
+
+/* Spell execution has finished normally or we have been notified by a finished skill timer */
+static void
+try_to_finish_invocation(invocation_t *invocation)
+{
+        if (invocation->status_change_refs_nr == 0 && !invocation->current_effect) {
+                if (invocation->end_effect) {
+                        clear_stack(invocation);
+                        invocation->current_effect = invocation->end_effect;
+                        invocation->end_effect = NULL;
+                        spell_execute(invocation);
+                } else
+                        free_invocation(invocation);
+        }
+}
+
+static void
+char_set_attack_info(character_t *subject, int speed, int range)
+{
+        subject->attack_spell_delay = speed;
+        subject->attack_spell_range = range;
+
+        if (speed == 0) {
+                pc_calcstatus(subject, 1);
+                clif_updatestatus(subject, SP_ASPD);
+                clif_updatestatus(subject, SP_ATTACKRANGE);
+        } else {
+                subject->aspd = speed;
+                clif_updatestatus(subject, SP_ASPD);
+                clif_updatestatus(subject, SP_ATTACKRANGE);
+        }
+}
+
+static void
+char_set_weapon_icon(character_t *subject, int count, int icon, int look)
+{
+//        const int magic_item_inventory_index = -1;
+//        const int weapon_position = 4;
+
+        // The icon isn't working at the moment.
+
+        subject->attack_spell_icon_override = icon;
+        subject->attack_spell_look_override = look;
+
+        clif_fixpcpos(subject);
+        if (count) {
+//                /* Set it to `override' */
+//                clif_additem(subject, magic_item_inventory_index, count, 0, icon);
+                clif_changelook(&subject->bl, LOOK_WEAPON, look);
+//                clif_equipitemack(subject, magic_item_inventory_index, weapon_position, 1);
+        } else {
+                /* Set it to `normal' */
+                clif_changelook(&subject->bl, LOOK_WEAPON, subject->status.weapon);
+
+//                if (subject->equip_index[weapon_position] == -1)
+//                        clif_equipitemack(subject, 0, weapon_position, 1);
+//                else
+//                        clif_equipitemack(subject, subject->equip_index[weapon_position], weapon_position, 1);
+        }
+}
+
+static int
+trigger_spell(int subject, int spell)
+{
+        invocation_t *invocation = (invocation_t *)map_id2bl(spell);
+
+        if (!invocation)
+                return 0;
+
+        invocation = spell_clone_effect(invocation);
+
+        spell_bind((character_t *)map_id2bl(subject), invocation);
+        magic_clear_var(&invocation->env->vars[VAR_CASTER]);
+        invocation->env->vars[VAR_CASTER].ty = TY_ENTITY;
+        invocation->env->vars[VAR_CASTER].v.v_int = subject;
+
+        return invocation->bl.id;
+}
+
+static void
+entity_warp(entity_t *target, int destm, int destx, int desty);
+
+static void
+char_update(character_t *character)
+{
+        entity_warp((entity_t *)character, character->bl.m, character->bl.x, character->bl.y);
+}
+
+static int
+timer_callback_effect(int _, unsigned int __, int id, int data)
+{
+        clif_misceffect(map_id2bl(id), data);
+        return 0;
+}
+
+static void
+entity_effect(entity_t *entity, int effect_nr, int delay)
+{
+        add_timer(gettick() + delay,
+                  &timer_callback_effect,
+                  entity->id,
+                  effect_nr);
+}
+
+void
+magic_unshroud(character_t *other_char)
+{
+        other_char->state.shroud_active = 0;
+        // Now warp the caster out of and back into here to refresh everyone's display
+        char_update(other_char);
+        clif_displaymessage(other_char->fd, "Your shroud has been dispelled!");
+//        entity_effect(&other_char->bl, MAGIC_EFFECT_REVEAL);
+}
+
+
+static int
+timer_callback_effect_npc_delete(int timer_id, unsigned int odelay, int npc_id, int _)
+{
+    struct npc_data *effect_npc = (struct npc_data *)map_id2bl(npc_id);
+    npc_free(effect_npc);
+
+    return 0;
+}
+
+static struct npc_data *
+local_spell_effect(int m, int x, int y, int effect, int tdelay)
+{
+    int delay = 30000; /* 1 minute should be enough for all interesting spell effects, I hope */
+    struct npc_data *effect_npc = npc_spawn_text(m, x, y,
+                                                 INVISIBLE_NPC, "", NULL);
+    int effect_npc_id = effect_npc->bl.id;
+
+    entity_effect(&effect_npc->bl, effect, tdelay);
+    add_timer(gettick() + delay,
+              timer_callback_effect_npc_delete,
+              effect_npc_id, 0);
+
+    return effect_npc;
+}
+
+
+static int
+op_sfx(env_t *env, int args_nr, val_t *args)
+{
+        int delay = ARGINT(2);
+
+        if (TY(0) == TY_ENTITY) {
+                entity_effect(ARGENTITY(0), ARGINT(1), delay);
+        } else if (TY(0) == TY_LOCATION) {
+                local_spell_effect(ARGLOCATION(0).m,
+                                   ARGLOCATION(0).x,
+                                   ARGLOCATION(0).y,
+                                   ARGINT(1), delay);
+        } else return 1;
+
+        return 0;
+}
+
+
+static int
+op_instaheal(env_t *env, int args_nr, val_t *args)
+{
+        entity_t *caster = (VAR(VAR_CASTER).ty == TY_ENTITY)
+                         ? map_id2bl(VAR(VAR_CASTER).v.v_int)
+                         : NULL;
+        if (!caster)
+                caster = ARGENTITY(0);
+                
+        battle_heal(caster, ARGENTITY(0), ARGINT(1), ARGINT(2), 0);
+        return 0;
+}
+
+
+static int
+op_itemheal(env_t *env, int args_nr, val_t *args)
+{
+        entity_t *subject = ARGENTITY(0);
+        if (subject->type == BL_PC) {
+                pc_itemheal((struct map_session_data *) subject,
+                            ARGINT(1),
+                            ARGINT(2));
+        } else return op_instaheal(env, args_nr, args);
+
+        return 0;
+}
+
+
+#define SHROUD_HIDE_NAME_TALKING_FLAG	(1 << 0)
+#define SHROUD_DISAPPEAR_ON_PICKUP_FLAG	(1 << 1)
+#define SHROUD_DISAPPEAR_ON_TALK_FLAG	(1 << 2)
+
+#define ARGCHAR(n) (ARGENTITY(n)->type == BL_PC) ? (character_t *)(ARGENTITY(n)) : NULL
+
+static int
+op_shroud(env_t *env, int args_nr, val_t *args)
+{
+        character_t *subject = ARGCHAR(0);
+        int arg = ARGINT(1);
+
+        if (!subject)
+                return 0;
+
+        subject->state.shroud_active = 1;
+        subject->state.shroud_hides_name_talking = (arg & SHROUD_HIDE_NAME_TALKING_FLAG) != 0;
+        subject->state.shroud_disappears_on_pickup = (arg & SHROUD_DISAPPEAR_ON_PICKUP_FLAG) != 0;
+        subject->state.shroud_disappears_on_talk = (arg & SHROUD_DISAPPEAR_ON_TALK_FLAG) != 0;
+        return 0;
+}
+
+static int
+op_reveal(env_t *env, int args_nr, val_t *args)
+{
+        character_t *subject = ARGCHAR(0);
+        
+        if (subject && subject->state.shroud_active)
+                magic_unshroud(subject);
+
+        return 0;
+}
+
+static int
+op_message(env_t *env, int args_nr, val_t *args)
+{
+        character_t *subject = ARGCHAR(0);
+
+        if (subject)
+                clif_displaymessage(subject->fd, ARGSTR(1));
+
+        return 0;
+}
+
+static int
+timer_callback_kill_npc(int timer_id, unsigned int odelay, int npc_id, int data)
+{
+        struct npc_data *npc = (struct npc_data *) map_id2bl(npc_id);
+        if (npc)
+                npc_free(npc);
+
+        return 0;
+}
+
+static int
+op_messenger_npc(env_t *env, int args_nr, val_t *args)
+{
+        struct npc_data *npc;
+        location_t *loc = &ARGLOCATION(0);
+
+        npc = npc_spawn_text(loc->m, loc->x, loc->y,
+                             ARGINT(1), ARGSTR(2), ARGSTR(3));
+
+        add_timer(gettick() + ARGINT(4),
+                  &timer_callback_kill_npc,
+                  npc->bl.id,
+                  0);
+
+        return 0;
+}
+
+static void
+entity_warp(entity_t *target, int destm, int destx, int desty)
+{
+        if (target->type == BL_PC
+            || target->type == BL_MOB) {
+
+                switch (target->type) {
+                case BL_PC: {
+                        character_t *character = (character_t *) target;
+                        clif_clearchar_area(&character->bl, 3);
+                        map_delblock(&character->bl);
+                        character->bl.x = destx;
+                        character->bl.y = desty;
+                        character->bl.m = destm;
+
+                        pc_touch_all_relevant_npcs(character);
+
+                        // Note that touching NPCs may have triggered warping and thereby updated x and y:
+                        clif_changemap(character, map[character->bl.m].name, character->bl.x, character->bl.y);
+
+                        break;
+                }
+                case BL_MOB:
+                        target->x = destx;
+                        target->y = desty;
+                        target->m = destm;
+                        clif_fixmobpos((struct mob_data *) target);
+                        break;
+                }
+        }
+}
+
+static int
+op_move(env_t *env, int args_nr, val_t *args)
+{
+        entity_t *subject = ARGENTITY(0);
+        int dir = ARGDIR(1);
+
+        int newx = subject->x + heading_x[dir];
+        int newy = subject->y + heading_y[dir];
+
+        if (!map_is_solid(subject->m, newx, newy))
+                entity_warp(subject, subject->m, newx, newy);
+
+        return 0;
+}
+
+static int
+op_warp(env_t *env, int args_nr, val_t *args)
+{
+        entity_t *subject = ARGENTITY(0);
+        location_t *loc = &ARGLOCATION(1);
+
+        entity_warp(subject, loc->m, loc->x, loc->y);
+
+        return 0;
+}
+
+static int
+op_banish(env_t *env, int args_nr, val_t *args)
+{
+        entity_t *subject = ARGENTITY(0);
+
+        if (subject->type == BL_MOB) {
+                struct mob_data *mob = (struct mob_data *) subject;
+
+                if (mob->mode & MOB_MODE_SUMMONED)
+                        mob_catch_delete(mob, 3);
+        }
+
+        return 0;
+}
+
+static void
+record_status_change(invocation_t *invocation, int bl_id, int sc_id)
+{
+        int index = invocation->status_change_refs_nr++;
+        status_change_ref_t *cr;
+
+        if (invocation->status_change_refs)
+                invocation->status_change_refs = realloc(invocation->status_change_refs,
+                                                         sizeof(status_change_ref_t)
+                                                         * invocation->status_change_refs_nr);
+        else
+                invocation->status_change_refs = malloc(sizeof(status_change_ref_t));
+
+        cr = &invocation->status_change_refs[index];
+
+        cr->sc_type = sc_id;
+        cr->bl_id = bl_id;
+}
+
+static int
+op_status_change(env_t *env, int args_nr, val_t *args)
+{
+        entity_t *subject = ARGENTITY(0);
+        int invocation_id = VAR(VAR_INVOCATION).ty == TY_INVOCATION
+                          ? VAR(VAR_INVOCATION).v.v_int
+                          : 0;
+        invocation_t *invocation = (invocation_t *)map_id2bl(invocation_id);
+
+        skill_status_effect(subject, ARGINT(1), ARGINT(2), ARGINT(3), ARGINT(4), ARGINT(5), ARGINT(6), 0, invocation_id);
+
+        if (invocation)
+                record_status_change(invocation, subject->id, ARGINT(1));
+
+        return 0;
+}
+
+static int
+op_override_attack(env_t *env, int args_nr, val_t *args)
+{
+        entity_t *psubject = ARGENTITY(0);
+        int charges = ARGINT(1);
+        int attack_delay = ARGINT(2);
+        int attack_range = ARGINT(3);
+        int icon = ARGINT(4);
+        int look = ARGINT(5);
+        character_t *subject;
+
+        if (psubject->type != BL_PC)
+                return 0;
+
+        subject = (character_t *) psubject;
+
+        if (subject->attack_spell_override) {
+                invocation_t *old_invocation = (invocation_t *)map_id2bl(subject->attack_spell_override);
+                if (old_invocation)
+                        free_invocation(old_invocation);
+        }
+
+        subject->attack_spell_override = trigger_spell(subject->bl.id, VAR(VAR_INVOCATION).v.v_int);
+        subject->attack_spell_charges = charges;
+
+        if (subject->attack_spell_override) {
+                char_set_weapon_icon(subject, charges, icon, look);
+                char_set_attack_info(subject, attack_delay, attack_range);
+        }
+
+        return 0;
+}
+
+
+static int
+op_create_item(env_t *env, int args_nr, val_t *args)
+{
+        struct item_data *item_data;
+        struct item item;
+        entity_t *entity = ARGENTITY(0);
+        character_t *subject;
+        int must_add_sequentially;
+        int count = ARGINT(2);
+        if (count <= 0)
+                return 0;
+
+        if (entity->type == BL_PC)
+                subject = (character_t *) entity;
+        else
+                return 0;
+
+        if (TY(1) == TY_INT)
+                item_data = itemdb_exists(ARGINT(1));
+        else if (TY(1) == TY_STRING)
+                item_data = itemdb_searchname(ARGSTR(1));
+        else
+                return 1;
+
+        if (!item_data)
+                return 0;
+
+        must_add_sequentially = (item_data->type == 4
+                                 || item_data->type == 5
+                                 || item_data->type == 7
+                                 || item_data->type == 8); /* Very elegant. */
+
+        memset(&item, 0, sizeof(struct item));
+        item.nameid = item_data->nameid;
+        item.identify = 1;
+
+        if (must_add_sequentially)
+                while (count--)
+                        pc_additem(subject, &item, 1);
+        else
+                pc_additem(subject, &item, count);
+
+        return 0;
+}
+
+
+#define AGGRAVATION_MODE_ATTACKS_CASTER(n) 	((n) == 0 || (n) == 2)
+#define AGGRAVATION_MODE_MAKES_AGGRESSIVE(n)	((n) > 0)
+
+static int
+op_aggravate(env_t *env, int args_nr, val_t *args)
+{
+        entity_t *victim = ARGENTITY(2);
+        int mode = ARGINT(1);
+        entity_t *target = ARGENTITY(0);
+        struct mob_data *other;
+
+        if (target->type == BL_MOB)
+                other = (struct mob_data *) target;
+        else
+                return 0;
+
+        mob_target(other, victim, battle_get_range(victim));
+
+        if (AGGRAVATION_MODE_MAKES_AGGRESSIVE(mode))
+                other->mode = 0x85 | (other->mode & MOB_SENSIBLE_MASK); /* war */
+
+        if (AGGRAVATION_MODE_ATTACKS_CASTER(mode)) {
+                other->target_id = victim->id;
+                other->attacked_id = victim->id;
+        }
+
+        return 0;
+}
+
+#define MONSTER_ATTITUDE_HOSTILE	0
+#define MONSTER_ATTITUDE_FRIENDLY	1
+#define MONSTER_ATTITUDE_SERVANT	2
+
+static int
+op_spawn(env_t *env, int args_nr, val_t *args)
+{
+        area_t *area = ARGAREA(0);
+        entity_t *owner_e = ARGENTITY(1);
+        int monster_id = ARGINT(2);
+        int monster_attitude = ARGINT(3);
+        int monster_count = ARGINT(4);
+        int monster_lifetime = ARGINT(5);
+        int i;
+
+        character_t *owner = (monster_attitude == MONSTER_ATTITUDE_SERVANT && owner_e->type == BL_PC)
+                           ? (character_t *) owner_e
+                           : NULL;
+
+        for (i = 0; i < monster_count; i++) {
+                location_t loc;
+                magic_random_location(&loc, area);
+
+                int mob_id;
+                struct mob_data *mob;
+
+                mob_id = mob_once_spawn(owner, map[loc.m].name, loc.x, loc.y, "--ja--", // Is that needed?
+                                        monster_id, 1, "");
+
+                mob = (struct mob_data *)map_id2bl(mob_id);
+
+                if (mob) {
+                        mob->mode = mob_db[monster_id].mode;
+
+                        switch (monster_attitude) {
+
+                        case MONSTER_ATTITUDE_SERVANT:
+                                mob->state.special_mob_ai = 1;
+                                mob->mode |= 0x04;
+                                break;
+
+                        case MONSTER_ATTITUDE_FRIENDLY:
+                                mob->mode = 0x81;
+                                break;
+
+                        case MONSTER_ATTITUDE_HOSTILE:
+                                mob->mode = 0x85;
+                                if (owner) {
+                                        mob->target_id = owner->bl.id;
+                                        mob->attacked_id = owner->bl.id;
+                                }
+                                break;
+                        }
+
+                        mob->mode |= MOB_MODE_SUMMONED | MOB_MODE_TURNS_AGAINST_BAD_MASTER;
+
+                        mob->deletetimer = add_timer(gettick() + monster_lifetime,
+                                                     mob_timer_delete,
+                                                     mob_id, 0);
+
+                        if (owner) {
+                                mob->master_id = owner->bl.id;
+                                mob->master_dist = 6;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+
+static int
+op_injure(env_t *env, int args_nr, val_t *args)
+{
+        entity_t *caster = ARGENTITY(0);
+        entity_t *target = ARGENTITY(1);
+        int damage_caused = ARGINT(2);
+        int mp_damage = ARGINT(3);
+        int target_hp = battle_get_hp(target);
+        int mdef = battle_get_mdef(target);
+
+        if (target->type == BL_PC
+            && !map[target->m].flag.pvp)
+                return 0; /* Cannot damage other players outside of pvp */
+
+        if (target != caster) {
+                /* Not protected against own spells */
+                damage_caused = (damage_caused * (100 - mdef)) / 100;
+                mp_damage = (mp_damage * (100 - mdef)) / 100;
+        }
+
+        damage_caused = (damage_caused > target_hp) ? target_hp : damage_caused;
+
+        if (damage_caused < 0)
+                damage_caused = 0;
+
+        if (damage_caused || mp_damage) {
+                battle_damage(caster, target, damage_caused, mp_damage);
+                clif_damage(caster, target, gettick(),
+                            0, 0, damage_caused, 0, 0, 0);
+        }
+
+        return 0;
+}
+
+static int
+op_emote(env_t *env, int args_nr, val_t *args)
+{
+        entity_t *victim = ARGENTITY(0);
+        int emotion = ARGINT(1);
+        clif_emotion(victim, emotion);
+
+        return 0;
+}
+
+static int
+op_set_script_variable(env_t *env, int args_nr, val_t *args)
+{
+        character_t *c = (ETY(0) == BL_PC)? ARGPC(0) : NULL;
+
+        if (!c)
+                return 1;
+
+        pc_setglobalreg(c, ARGSTR(1), ARGINT(2));
+
+        return 0;
+}
+
+
+static op_t operations[] =
+{
+        { "sfx", ".ii", op_sfx },
+        { "instaheal", "eii", op_instaheal },
+        { "itemheal", "eii", op_itemheal },
+        { "shroud", "ei", op_shroud },
+        { "unshroud", "e", op_reveal },
+        { "message", "es", op_message },
+        { "messenger_npc", "lissi", op_messenger_npc },
+        { "move", "ed", op_move },
+        { "warp", "el", op_warp },
+        { "banish", "e", op_banish },
+        { "status_change", "eiiiiii", op_status_change },
+        { "override_attack", "eiiiii", op_override_attack },
+        { "create_item", "e.i", op_create_item },
+        { "aggravate", "eie", op_aggravate },
+        { "spawn", "aeiiii", op_spawn },
+        { "injure", "eeii", op_injure },
+        { "emote", "ei", op_emote },
+        { "set_script_variable", "esi", op_set_script_variable },
+        { NULL, NULL, NULL }
+};
+
+static int operations_sorted = 0;
+static int operation_count;
+
+
+int
+compare_operations(const void *lhs, const void *rhs)
+{
+        return strcmp(((op_t *)lhs)->name, ((op_t *)rhs)->name);
+}
+
+
+op_t *
+magic_get_op(char *name, int *index)
+{
+        op_t key;
+
+        if (!operations_sorted) {
+                op_t *opc = operations;
+
+                while (opc->name)
+                        ++opc;
+
+                operation_count = opc - operations;
+
+                qsort(operations, operation_count, sizeof(op_t), compare_operations);
+                operations_sorted = 1;
+        }
+
+        key.name = name;
+        op_t *op = bsearch(&key, operations, operation_count, sizeof(op_t), compare_operations);
+
+        if (op && index)
+                *index = op - operations;
+
+        return op;
+}
+
+
+void
+spell_effect_report_termination(int invocation_id, int bl_id, int sc_id, int supplanted)
+{
+        int i;
+        int index = -1;
+        invocation_t *invocation = (invocation_t *) map_id2bl(invocation_id);
+
+        if (!invocation)
+                return;
+
+        for (i = 0; i < invocation->status_change_refs_nr; i++) {
+                status_change_ref_t *cr = &invocation->status_change_refs[i];
+                if (cr->sc_type == sc_id && cr->bl_id == bl_id) {
+                        index = i;
+                        break;
+                }
+        }
+
+        if (index == -1) {
+                fprintf(stderr, "[magic] INTERNAL ERROR: spell-effect-report-termination:  tried to terminate on unexpected bl %d, sc %d\n", bl_id, sc_id);
+                return;
+        }
+
+        if (index == invocation->status_change_refs_nr -1)
+                invocation->status_change_refs_nr--;
+        else /* Copy last change ref to the one we are deleting */
+                invocation->status_change_refs[index] = invocation->status_change_refs[--invocation->status_change_refs_nr];
+
+        try_to_finish_invocation(invocation);
+}
+
+static effect_t *
+return_to_stack(invocation_t *invocation)
+{
+        if (!invocation->stack_size)
+                return NULL;
+        else {
+                cont_activation_record_t *ar = invocation->stack + (invocation->stack_size - 1);
+                switch (ar->ty) {
+
+                case CONT_STACK_PROC: {
+                        effect_t *ret = ar->return_location;
+                        int i;
+
+                        for (i = 0; i < ar->c.c_proc.args_nr; i++) {
+                                val_t *var = &invocation->env->vars[ar->c.c_proc.formals[i]];
+                                magic_clear_var(var);
+                                *var = ar->c.c_proc.old_actuals[i];
+                        }
+
+                        clear_activation_record(ar);
+                        --invocation->stack_size;
+
+                        return ret;
+                }
+
+                case CONT_STACK_FOREACH: {
+                        int entity_id;
+                        val_t *var = &invocation->env->vars[ar->c.c_foreach.id];
+
+                        do {
+                                if (ar->c.c_foreach.index >= ar->c.c_foreach.entities_nr) {
+                                        effect_t *ret = ar->return_location;
+                                        clear_activation_record(ar);
+                                        --invocation->stack_size;
+                                        return ret;
+                                }
+
+                                entity_id = ar->c.c_foreach.entities[ar->c.c_foreach.index++];
+                        } while (!entity_id || !map_id2bl(entity_id));
+
+                        magic_clear_var(var);
+                        var->ty = TY_ENTITY;
+                        var->v.v_int = entity_id;
+
+                        return ar->c.c_foreach.body;
+                }
+
+                case CONT_STACK_FOR:
+                        if (ar->c.c_for.current > ar->c.c_for.stop) {
+                                effect_t *ret = ar->return_location;
+                                clear_activation_record(ar);
+                                --invocation->stack_size;
+                                return ret;
+                        }
+
+                        magic_clear_var(&invocation->env->vars[ar->c.c_for.id]);
+                        invocation->env->vars[ar->c.c_for.id].ty = TY_INT;
+                        invocation->env->vars[ar->c.c_for.id].v.v_int = ar->c.c_for.current++;
+
+                        return ar->c.c_for.body;
+
+                default:
+                        fprintf(stderr, "[magic] INTERNAL ERROR: While executing spell `%s':  stack corruption\n", invocation->spell->name);
+                        return NULL;
+                }
+        }
+}
+
+static cont_activation_record_t *
+add_stack_entry(invocation_t *invocation, int ty, effect_t *return_location)
+{
+        cont_activation_record_t *ar = invocation->stack + invocation->stack_size++;
+        if (invocation->stack_size >= MAX_STACK_SIZE) {
+                fprintf(stderr, "[magic] Execution stack size exceeded in spell `%s'; truncating effect\n", invocation->spell->name);
+                invocation->stack_size--;
+                return NULL;
+        }
+
+        ar->ty = ty;
+        ar->return_location = return_location;
+        return ar;
+}
+
+static int
+find_entities_in_area_c(entity_t *target, va_list va)
+{
+        int *entities_allocd_p = va_arg(va, int *);
+        int *entities_nr_p = va_arg(va, int *);
+        int **entities_p = va_arg(va, int **);
+        int filter = va_arg(va, int);
+
+        switch (target->type) {
+
+        case BL_PC:
+                if (filter == FOREACH_FILTER_PC
+                    || filter == FOREACH_FILTER_ENTITY
+                    || (filter == FOREACH_FILTER_TARGET
+                        && map[target->m].flag.pvp))
+                        break;
+                else
+                        return 0;
+
+        case BL_MOB:
+                if (filter == FOREACH_FILTER_MOB
+                    || filter == FOREACH_FILTER_ENTITY
+                    || filter == FOREACH_FILTER_TARGET)
+                        break;
+                else
+                        return 0;
+
+        default:
+                return 0;
+        }
+
+        if (*entities_nr_p == *entities_allocd_p) {
+                /* Need more space */
+                (*entities_allocd_p) += 32;
+                *entities_p = realloc(*entities_p, sizeof(int) * (*entities_allocd_p));
+        }
+
+        (*entities_p)[(*entities_nr_p)++] = target->id;
+
+        return 0;
+}
+
+static void
+find_entities_in_area(area_t *area, int *entities_allocd_p, int *entities_nr_p, int **entities_p, int filter)
+{
+        switch (area->ty) {
+        case AREA_UNION:
+                find_entities_in_area(area->a.a_union[0], entities_allocd_p, entities_nr_p, entities_p, filter);
+                find_entities_in_area(area->a.a_union[1], entities_allocd_p, entities_nr_p, entities_p, filter);
+                break;
+
+        default: {
+                int m, x, y, width, height;
+                magic_area_rect(&m, &x, &y, &width, &height, area);
+                map_foreachinarea(find_entities_in_area_c,
+                                  m, x, y, x+width, y+height,
+                                  0 /* filter elsewhere */,
+                                  entities_allocd_p, entities_nr_p, entities_p, filter);
+        }
+        }
+}
+
+static effect_t *
+run_foreach(invocation_t *invocation, effect_t *foreach, effect_t *return_location)
+{
+        val_t area;
+        int filter = foreach->e.e_foreach.filter;
+        int id = foreach->e.e_foreach.id;
+        effect_t *body = foreach->e.e_foreach.body;
+
+        magic_eval(invocation->env, &area, foreach->e.e_foreach.area);
+
+        if (area.ty != TY_AREA) {
+                magic_clear_var(&area);
+                fprintf(stderr, "[magic] Error in spell `%s':  FOREACH loop over non-area\n", invocation->spell->name);
+                return return_location;
+        } else {
+                cont_activation_record_t *ar = add_stack_entry(invocation, CONT_STACK_FOREACH, return_location);
+                int entities_allocd = 64;
+                int *entities_collect = malloc(entities_allocd * sizeof(int));
+                int *entities;
+                int *shuffle_board;
+                int entities_nr = 0;
+                int i;
+
+                if (!ar)
+                        return return_location;
+
+                find_entities_in_area(area.v.v_area, &entities_allocd, &entities_nr, &entities_collect, filter);
+
+                /* Now shuffle */
+                shuffle_board = malloc((sizeof(int) * (1 + entities_nr))); // +1: to avoid spurious warnings in memory profilers
+                entities = malloc((sizeof(int) * (1 + entities_nr))); // +1: to avoid spurious warnings in memory profilers
+                for (i = 0; i < entities_nr; i++)
+                        shuffle_board[i] = i;
+
+                for (i = entities_nr - 1 ; i >= 0; i--) {
+                        int random_index = rand() % (i + 1);
+                        entities[i] = entities_collect[shuffle_board[random_index]];
+                        shuffle_board[random_index] = shuffle_board[i]; // thus, we are guaranteed only to use unused indices
+                }
+
+                free(entities_collect);
+                free(shuffle_board);
+                /* Done shuffling */
+
+                ar->c.c_foreach.id = id;
+                ar->c.c_foreach.body = body;
+                ar->c.c_foreach.index = 0;
+                ar->c.c_foreach.entities_nr = entities_nr;
+                ar->c.c_foreach.entities = entities;
+
+                magic_clear_var(&area);
+
+                return return_to_stack(invocation);
+        }
+}
+
+static effect_t *
+run_for(invocation_t *invocation, effect_t *for_, effect_t *return_location)
+{
+        cont_activation_record_t *ar;
+        int id = for_->e.e_for.id;
+        val_t start;
+        val_t stop;
+
+        magic_eval(invocation->env, &start, for_->e.e_for.start);
+        magic_eval(invocation->env, &stop, for_->e.e_for.stop);
+
+        if (start.ty != TY_INT || stop.ty != TY_INT) {
+                magic_clear_var(&start);
+                magic_clear_var(&stop);
+                fprintf(stderr, "[magic] Error in spell `%s':  FOR loop start or stop point is not an integer\n", invocation->spell->name);
+                return return_location;
+        }
+
+        ar = add_stack_entry(invocation, CONT_STACK_FOR, return_location);
+
+        if (!ar)
+                return return_location;
+
+        ar->c.c_for.id = id;
+        ar->c.c_for.current = start.v.v_int;
+        ar->c.c_for.stop = stop.v.v_int;
+        ar->c.c_for.body = for_->e.e_for.body;
+
+        return return_to_stack(invocation);
+}
+
+static effect_t *
+run_call(invocation_t *invocation, effect_t *return_location)
+{
+        effect_t *current = invocation->current_effect;
+        cont_activation_record_t *ar;
+        int args_nr = current->e.e_call.args_nr;
+        int *formals = current->e.e_call.formals;
+        val_t *old_actuals = aCalloc(sizeof(val_t), args_nr);
+        int i;
+
+        ar = add_stack_entry(invocation, CONT_STACK_PROC, return_location);
+        ar->c.c_proc.args_nr = args_nr;
+        ar->c.c_proc.formals = formals;
+        ar->c.c_proc.old_actuals = old_actuals;
+        for (i = 0; i < args_nr; i++) {
+                val_t *env_val = &invocation->env->vars[formals[i]];
+                val_t result;
+                magic_copy_var(&old_actuals[i], env_val);
+                magic_eval(invocation->env, &result, current->e.e_call.actuals[i]);
+                *env_val = result;
+        }
+
+        return current->e.e_call.body;
+}
+
+static void
+print_cfg(int i, effect_t *e)
+{
+        int j;
+        for (j = 0; j < i; j++)
+                printf("    ");
+
+        printf("%p: ", e);
+
+        if (!e) {
+                puts(" -- end --");
+                return;
+        }
+
+        switch (e->ty) {
+        case EFFECT_SKIP:
+                puts("SKIP"); break;
+        case EFFECT_END:
+                puts("END"); break;
+        case EFFECT_ABORT:
+                puts("ABORT"); break;
+        case EFFECT_ASSIGN:
+                puts("ASSIGN"); break;
+        case EFFECT_FOREACH:
+                puts("FOREACH");
+                print_cfg(i+1, e->e.e_foreach.body);
+                break;
+        case EFFECT_FOR:
+                puts("FOR");
+                print_cfg(i+1, e->e.e_for.body);
+                break;
+        case EFFECT_IF:
+                puts("IF");
+                for (j = 0; j < i; j++)
+                        printf("    ");
+                puts("THEN");
+                print_cfg(i+1, e->e.e_if.true_branch);
+                for (j = 0; j < i; j++)
+                        printf("    ");
+                puts("ELSE");
+                print_cfg(i+1, e->e.e_if.false_branch);
+                break;
+        case EFFECT_SLEEP:
+                puts("SLEEP"); break;
+        case EFFECT_SCRIPT:
+                puts("SCRIPT"); break;
+        case EFFECT_BREAK:
+                puts("BREAK"); break;
+        case EFFECT_OP:
+                puts("OP"); break;
+        }
+        print_cfg(i, e->next);
+}
+
+
+/**
+ * Execute a spell invocation until we abort, finish, or hit the next `sleep'.
+ *
+ * Use spell_execute() to automate handling of timers
+ *
+ * Returns: 0 if finished (all memory is freed implicitly)
+ *          >1 if we hit `sleep'; the result is the number of ticks we should sleep for.
+ *          -1 if we paused to wait for a user action (via script interaction)
+ */
+static int
+spell_run(invocation_t *invocation, int allow_delete)
+{
+#ifdef DEBUG
+        fprintf(stderr, "Resuming execution:  invocation of `%s'\n", invocation->spell->name);
+        print_cfg(1, invocation->current_effect);
+#endif        
+        while (invocation->current_effect) {
+                effect_t *e = invocation->current_effect;
+                effect_t *next = e->next;
+                int i;
+
+#ifdef DEBUG
+                fprintf(stderr, "Next step of type %d\n", e->ty);
+                dump_env(invocation->env);
+#endif        
+
+                switch (e->ty) {
+                case EFFECT_SKIP:
+                        break;
+
+                case EFFECT_ABORT:
+                        invocation->flags |= INVOCATION_FLAG_ABORTED;
+                        invocation->end_effect = NULL;
+                case EFFECT_END:
+                        clear_stack(invocation);
+                        next = NULL;
+                        break;
+
+                case EFFECT_ASSIGN:
+                        magic_eval(invocation->env, &invocation->env->vars[e->e.e_assign.id], e->e.e_assign.expr);
+                        break;
+
+                case EFFECT_FOREACH:
+                        next = run_foreach(invocation, e, next);
+                        break;
+
+                case EFFECT_FOR:
+                        next = run_for(invocation, e, next);
+                        break;
+
+                case EFFECT_IF:
+                        if (magic_eval_int(invocation->env, e->e.e_if.cond))
+                                next = e->e.e_if.true_branch;
+                        else
+                                next = e->e.e_if.false_branch;
+                        break;
+
+                case EFFECT_SLEEP: {
+                        int sleeptime = magic_eval_int(invocation->env, e->e.e_sleep);
+                        invocation->current_effect = next;
+                        if (sleeptime > 0)
+                                return sleeptime;
+                        break;
+                }
+
+                case EFFECT_SCRIPT: {
+                        character_t *caster = (character_t *) map_id2bl(invocation->caster);
+                        if (caster) {
+                                env_t *env = invocation->env;
+                                character_t *caster = (character_t *)map_id2bl(invocation->caster);
+                                argrec_t arg[] = { {"@target", .v.i = VAR(VAR_TARGET).ty == TY_ENTITY ? 0 : VAR(VAR_TARGET).v.v_int },
+                                                   {"@caster", .v.i = invocation->caster },
+                                                   {"@caster_name$", .v.s = caster ? caster->status.name : "" }};
+                                int message_recipient = VAR(VAR_SCRIPTTARGET).ty == TY_ENTITY
+                                                        ? VAR(VAR_SCRIPTTARGET).v.v_int
+                                                        : invocation->caster;
+                                character_t *recipient = (character_t *) map_id2bl(message_recipient);
+
+                                if (recipient->npc_id && recipient->npc_id != invocation->bl.id)
+                                        break; /* Don't send multiple message boxes at once */
+
+                                if (!invocation->script_pos) // first time running this script?
+                                        clif_spawn_fake_npc_for_player(recipient,
+                                                                       invocation->bl.id);
+                                // We have to do this or otherwise the client won't think that it's
+                                // dealing with an NPC
+
+                                int newpos = run_script_l(e->e.e_script,
+                                                          invocation->script_pos,
+                                                          message_recipient,
+                                                          invocation->bl.id,
+                                                          3, arg);
+                                /* Returns the new script position, or -1 once the script is finished */
+                                if (newpos != -1) {
+                                        /* Must set up for continuation */
+                                        recipient->npc_id = invocation->bl.id;
+                                        recipient->npc_pos = invocation->script_pos = newpos;
+                                        return -1; /* Signal `wait for script' */
+                                } else
+                                        invocation->script_pos = 0;
+                                clif_clearchar_id(invocation->bl.id, 1, caster->fd);
+                        }
+                        break;
+                }
+
+                case EFFECT_BREAK:
+                        next = return_to_stack(invocation);
+                        break;
+
+                case EFFECT_OP: {
+                        op_t *op = &operations[e->e.e_op.id];
+                        val_t args[MAX_ARGS];
+
+                        for (i = 0; i < e->e.e_op.args_nr; i++)
+                                magic_eval(invocation->env, &args[i], e->e.e_op.args[i]);
+
+                        if (!magic_signature_check("effect", op->name, op->signature,
+                                                   e->e.e_op.args_nr, args,
+                                                   e->e.e_op.line_nr, e->e.e_op.column))
+                                op->op(invocation->env, e->e.e_op.args_nr, args);
+
+                        for (i = 0; i < e->e.e_op.args_nr; i++)
+                                magic_clear_var(&args[i]);
+                        break;
+                }
+
+                case EFFECT_CALL:
+                        next = run_call(invocation, next);
+                        break;
+
+                default:
+                        fprintf(stderr, "[magic] INTERNAL ERROR: Unknown effect %d\n", e->ty);
+                }
+
+
+                if (!next)
+                        next = return_to_stack(invocation);
+
+                invocation->current_effect = next;
+        }
+
+        if (allow_delete)
+                try_to_finish_invocation(invocation);
+        return 0;
+}
+
+
+extern void
+spell_update_location(invocation_t *invocation);
+
+void
+spell_execute_d(invocation_t *invocation, int allow_deletion)
+{
+        int delta;
+
+        spell_update_location(invocation);
+        delta = spell_run(invocation, allow_deletion);
+
+        if (delta > 0)
+                invocation->timer = add_timer(gettick() + delta,
+                                              &invocation_timer_callback,
+                                              invocation->bl.id, 0);
+
+        /* If 0, the script cleaned itself.  If -1 (wait-for-script), we must wait for the user. */
+}
+
+void
+spell_execute(invocation_t *invocation)
+{
+        spell_execute_d(invocation, 1);
+}
+
+int
+spell_attack(int caster_id, int target_id)
+{
+        character_t *caster = (character_t *)map_id2bl(caster_id);
+        invocation_t *invocation = (invocation_t *)map_id2bl(caster->attack_spell_override);
+
+        if (invocation
+            && caster->attack_spell_charges > 0) {
+                magic_clear_var(&invocation->env->vars[VAR_TARGET]);
+                invocation->env->vars[VAR_TARGET].ty = TY_ENTITY;
+                invocation->env->vars[VAR_TARGET].v.v_int = target_id;
+
+                invocation->current_effect = invocation->trigger_effect;
+                invocation->flags &= ~INVOCATION_FLAG_ABORTED;
+                spell_execute_d(invocation, 0 /* don't delete the invocation if done */);
+
+                if (!(invocation->flags & INVOCATION_FLAG_ABORTED)) // If we didn't abort:
+                        caster->attack_spell_charges--;
+        }
+
+        if (invocation
+            && caster->attack_spell_override != invocation->bl.id) {
+                /* Attack spell changed / was refreshed */
+                free_invocation(invocation);
+        } else if (!invocation
+                   || caster->attack_spell_charges <= 0) {
+                caster->attack_spell_override = 0;
+                char_set_weapon_icon(caster, 0, 0, 0);
+                char_set_attack_info(caster, 0, 0);
+
+                if (invocation)
+                        free_invocation(invocation);
+        }
+
+        return 1;
+}
diff --git a/src/map/magic.c b/src/map/magic.c
new file mode 100644
index 0000000..114f74d
--- /dev/null
+++ b/src/map/magic.c
@@ -0,0 +1,116 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "magic-interpreter.h"
+
+#undef DEBUG
+
+static char *
+magic_preprocess_message(character_t *character, char *start, char *end)
+{
+        if (character->state.shroud_active
+            && character->state.shroud_disappears_on_talk)
+                magic_unshroud(character);
+
+        if (character->state.shroud_active
+            && character->state.shroud_hides_name_talking) {
+                int len = strlen(end);
+                strcpy(start, "? ");
+                memmove(start + 2, end, len + 1);
+                return start + 4;
+        } else
+                return end + 2; /* step past blank */
+}
+
+#define ISBLANK(c) ((c) == ' ')
+
+/* Returns a dynamically allocated copy of `src'.
+ * `*parameter' may point within that copy or be NULL. */
+static char *
+magic_tokenise(char *src, char **parameter)
+{
+        char *retval = strdup(src);
+        char *seeker = retval;
+
+        while (*seeker && !ISBLANK(*seeker))
+                ++seeker;
+
+        if (!*seeker)
+                *parameter = NULL;
+        else {
+            *seeker = 0; /* Terminate invocation */
+            ++seeker;
+
+            while (ISBLANK (*seeker))
+                    ++seeker;
+
+            *parameter = seeker;
+        }
+
+        return retval;
+}
+
+int
+magic_message(character_t *caster,
+              char *spell_, size_t spell_len)
+{
+        int power = caster->status.base_level + caster->status.int_;
+        char *invocation_base = spell_ + 8;
+        char *source_invocation = strchr(invocation_base, ':');
+        spell_t *spell;
+        char *parameter;
+        char *spell_invocation;
+
+        if (!source_invocation)
+                return 0;
+
+        /* Pre-message filter in case some spell alters output */
+        source_invocation = magic_preprocess_message(caster, invocation_base, source_invocation);
+
+        spell_invocation = magic_tokenise(source_invocation, &parameter);
+        parameter = parameter ? strdup(parameter) : strdup("");
+
+        spell = magic_find_spell(spell_invocation);
+        free(spell_invocation);
+
+        if (spell) {
+                env_t *env = spell_create_env(&magic_conf, spell, caster, power, parameter);
+                effect_set_t *effects = spell_trigger(spell, caster, env);
+
+#ifdef DEBUG
+                fprintf(stderr, "Found spell `%s', triggered = %d\n", spell_, effects != NULL);
+#endif
+
+                if (effects) {
+                        invocation_t *invocation = spell_instantiate(effects, env);
+
+                        /* We have a proper spell effect-- obscure the invocation! */
+                        while (*source_invocation) {
+                                if (((rand() * 100.0) / (RAND_MAX * 1.0)) < magic_conf.obscure_chance)
+                                        *source_invocation = '*';
+                                ++source_invocation;
+                        }
+
+                        spell_bind(caster, invocation);
+                        spell_execute(invocation);
+
+                        return (spell->flags & SPELL_FLAG_SILENT)? -1 : 1;
+                } else {
+                        magic_free_env(env);
+                }
+                return 0;
+        }
+
+        return 0; /* Not a spell */
+}
+
+int
+magic_init(char *conffile); // must be called after itemdb initialisation
+
+void
+do_init_magic()
+{
+        magic_init(MAGIC_CONFIG_FILE);
+}
diff --git a/src/map/magic.h b/src/map/magic.h
new file mode 100644
index 0000000..9ca47bb
--- /dev/null
+++ b/src/map/magic.h
@@ -0,0 +1,95 @@
+#ifndef MAGIC_H_
+#define MAGIC_H_
+
+#include "clif.h"
+#include "intif.h"
+
+#define MAGIC_CONFIG_FILE "conf/magic.conf"
+
+
+typedef struct map_session_data character_t;
+typedef struct block_list entity_t;
+
+struct invocation; /* Spell invocation */
+
+
+/**
+ * Try to cast magic.
+ *
+ * As an intended side effect, the magic message may be distorted (text only).
+ *
+ * \param caster Player attempting to cast magic
+ * \param spell The prospective incantation
+ * \param spell_len Number of characters in the incantation
+ * \return 1 or -1 if the input message was magic and was handled by this function, 0 otherwise.  -1 is returned when the
+ *         message should not be repeated.
+ */
+int
+magic_message(character_t *caster,
+              char *spell, size_t spell_len);
+
+/**
+ * Removes the shroud from a character
+ *
+ * \param character The character to remove the shroud from
+ */
+void
+magic_unshroud(character_t *character);
+
+/**
+ * Notifies a running spell that a status_change timer triggered by the spell has expired
+ *
+ * \param invocation The invocation to notify
+ * \param bl_id ID of the PC for whom this happened
+ * \param type sc_id ID of the status change entry that finished
+ * \param supplanted Whether the status_change finished normally (0) or was supplanted by a new status_change (1)
+ */
+void
+spell_effect_report_termination(int invocation, int bl_id, int sc_id, int supplanted);
+
+
+/**
+ * Initialise all spells, read config data
+ */
+void
+do_init_magic();
+
+/**
+ * Identifies the invocation used to trigger a spell
+ *
+ * Returns NULL if not found
+ */
+char *
+magic_find_invocation(char *spellame);
+
+/**
+ * Identifies the invocation used to denote a teleport location
+ *
+ * Returns NULL if not found
+ */
+char *
+magic_find_anchor_invocation(char *teleport_location);
+
+
+/**
+ * Execute a spell invocation and sets up timers to finish
+ */
+void
+spell_execute(struct invocation *invocation);
+
+/**
+ * Stops all magic bound to the specified character
+ *
+ */
+void
+magic_stop_completely(character_t *c);
+
+/**
+ * Attacks with a magical spell charged to the character
+ *
+ * Returns 0 if there is no charged spell or the spell is depleted.
+ */
+int
+spell_attack(int caster, int target);
+
+#endif /* !defined(MAGIC_H_) */
diff --git a/src/map/map.c b/src/map/map.c
index 040e180..079da90 100644
--- a/src/map/map.c
+++ b/src/map/map.c
@@ -35,6 +35,7 @@
 #include "atcommand.h"
 #include "nullpo.h"
 #include "socket.h"
+#include "magic.h"
 
 #ifdef MEMWATCH
 #include "memwatch.h"
@@ -284,6 +285,7 @@ int map_delblock(struct block_list *bl)
 
 	if(bl->type==BL_PC)
 		map[bl->m].users--;
+
 	if(bl->next) bl->next->prev = bl->prev;
 	if(bl->prev==&bl_head){
 		// リストの頭なので、map[]のblock_listを更新する
@@ -655,7 +657,10 @@ int map_delobject(int id) {
 	if(obj==NULL)
 		return 0;
 
-	map_delobjectnofree(id);	
+	map_delobjectnofree(id);
+        if (obj->type == BL_PC) // [Fate] Not sure where else to put this... I'm not sure where delobject for PCs is called from
+                pc_cleanup((struct map_session_data *)obj);
+
 	map_freeblock(obj);
 
 	return 0;
@@ -1077,7 +1082,7 @@ struct map_session_data * map_nick2sd(char *nick) {
     nicklen = strlen(nick);
 
 	for (i = 0; i < fd_max; i++) {
-		if (session[i] && (pl_sd = session[i]->session_data) && pl_sd->state.auth)
+                if (session[i] && (pl_sd = session[i]->session_data) && pl_sd->state.auth) {
 			// Without case sensitive check (increase the number of similar character names found)
 			if (strnicmp(pl_sd->status.name, nick, nicklen) == 0) {
 				// Strict comparison (if found, we finish the function immediatly with correct value)
@@ -1086,6 +1091,7 @@ struct map_session_data * map_nick2sd(char *nick) {
 				quantity++;
 				sd = pl_sd;
 			}
+                }
 	}
 	// Here, the exact character name is not found
 	// We return the found index of a similar account ONLY if there is 1 similar character
@@ -1991,6 +1997,7 @@ int do_init(int argc, char *argv[]) {
 	do_init_storage();
 	do_init_skill();
 	do_init_pet();
+        do_init_magic();
 
 #ifndef TXT_ONLY /* mail system [Valaris] */
 	if(battle_config.mail_system)	
@@ -2007,3 +2014,20 @@ int do_init(int argc, char *argv[]) {
 	return 0;
 }
 
+int
+map_scriptcont(struct map_session_data *sd, int id)
+{
+        struct block_list *bl = map_id2bl(id);
+
+        if (!bl)
+                return 0;
+
+        switch (bl->type) {
+        case BL_NPC: return npc_scriptcont(sd, id);
+        case BL_SPELL:
+            spell_execute((struct invocation *) bl);
+            break;
+        }
+
+        return 0;
+}
diff --git a/src/map/map.h b/src/map/map.h
index 3c7e2de..28d6758 100644
--- a/src/map/map.h
+++ b/src/map/map.h
@@ -5,6 +5,13 @@
 #include <stdarg.h>
 #include "mmo.h"
 
+#ifndef MAX
+#  define MAX(x,y) (((x)>(y)) ? (x) : (y))
+#endif
+#ifndef MIN
+#  define MIN(x,y) (((x)<(y)) ? (x) : (y))
+#endif
+
 #define MAX_PC_CLASS (1+6+6+1+6+1+1+1+1+4023)
 #define PC_CLASS_BASE 0
 #define PC_CLASS_BASE2 (PC_CLASS_BASE + 4001)
@@ -36,8 +43,8 @@
 
 #define OPTION_HIDE 0x40
 
-enum { BL_NUL, BL_PC, BL_NPC, BL_MOB, BL_ITEM, BL_CHAT, BL_SKILL , BL_PET };
-enum { WARP, SHOP, SCRIPT, MONS };
+enum { BL_NUL, BL_PC, BL_NPC, BL_MOB, BL_ITEM, BL_CHAT, BL_SKILL, BL_PET, BL_SPELL };
+enum { WARP, SHOP, SCRIPT, MONS, MESSAGE };
 struct block_list {
 	struct block_list *next,*prev;
 	int id;
@@ -61,6 +68,7 @@ struct script_regstr {
 struct status_change {
 	int timer;
 	int val1,val2,val3,val4;
+        int spell_invocation; /* [Fate] If triggered by a spell, record here */
 };
 struct vending {
 	short index;
@@ -68,6 +76,8 @@ struct vending {
 	int value;
 };
 
+struct invocation;
+
 struct skill_unit_group;
 struct skill_unit {
 	struct block_list bl;
@@ -115,26 +125,36 @@ struct pet_db;
 struct item_data;
 struct square;
 
+struct quick_regeneration { // [Fate]
+        int amount; // Amount of HP/SP left to regenerate
+        unsigned char speed; // less is faster (number of half-second ticks to wait between updates)
+        unsigned char tickdelay; // number of ticks to next update
+};
+
 struct map_session_data {
 	struct block_list bl;
 	struct {
-		unsigned auth : 1;
-		unsigned change_walk_target : 1;
-		unsigned attack_continue : 1;
-		unsigned menu_or_input : 1;
-		unsigned dead_sit : 2;
-		unsigned skillcastcancel : 1;
-		unsigned waitingdisconnect : 1;
-		unsigned lr_flag : 2;
-		unsigned connect_new : 1;
-		unsigned arrow_atk : 1;
-		unsigned attack_type : 3;
-		unsigned skill_flag : 1;
-		unsigned gangsterparadise : 1;
-		unsigned produce_flag : 1;
-		unsigned make_arrow_flag : 1;
-		unsigned potionpitcher_flag : 1;
-		unsigned storage_flag : 1;
+            unsigned auth : 1;
+            unsigned change_walk_target : 1;
+            unsigned attack_continue : 1;
+            unsigned menu_or_input : 1;
+            unsigned dead_sit : 2;
+            unsigned skillcastcancel : 1;
+            unsigned waitingdisconnect : 1;
+            unsigned lr_flag : 2;
+            unsigned connect_new : 1;
+            unsigned arrow_atk : 1;
+            unsigned attack_type : 3;
+            unsigned skill_flag : 1;
+            unsigned gangsterparadise : 1;
+            unsigned produce_flag : 1;
+            unsigned make_arrow_flag : 1;
+            unsigned potionpitcher_flag : 1;
+            unsigned storage_flag : 1;
+            unsigned shroud_active : 1;
+            unsigned shroud_hides_name_talking : 1;
+            unsigned shroud_disappears_on_pickup : 1;
+            unsigned shroud_disappears_on_talk : 1;
 	} state;
 	struct {
 		unsigned killer : 1;
@@ -185,6 +205,16 @@ struct map_session_data {
         int followtimer; // [MouseJstr]
         int followtarget;
 
+        int cast_tick; // [Fate] Next tick at which spellcasting is allowed
+        struct invocation *active_spells; // [Fate] Singly-linked list of active spells linked to this PC
+        int attack_spell_override; // [Fate] When an attack spell is active for this player, they trigger it
+                                   // like a weapon.  Check pc_attack_timer() for details.
+        short attack_spell_icon_override; // Weapon equipment slot (slot 4) item override
+        short attack_spell_look_override; // Weapon `look' (attack animation) override
+        short attack_spell_charges; // [Fate] Remaining number of charges for the attack spell
+        short attack_spell_delay;   // [Fate] ms delay after spell attack
+        short attack_spell_range;   // [Fate] spell range
+
 	short attackrange,attackrange_;
 	int skilltimer;
 	int skilltarget;
@@ -199,6 +229,9 @@ struct map_session_data {
 	int cloneskill_id,cloneskill_lv;
 	int potion_hp,potion_sp,potion_per_hp,potion_per_sp;
 
+        // [Fate] Used for gradual healing; amount of enqueued regeneration
+        struct quick_regeneration quick_regeneration_hp, quick_regeneration_sp;
+
 	int invincible_timer;
 	unsigned int canact_tick;
 	unsigned int canmove_tick;
@@ -358,6 +391,7 @@ struct npc_data {
 			short x,y;
 			char name[16];
 		} warp;
+                char *message; // for MESSAGE: only send this message
 	} u;
 	// ここにメンバを追加してはならない(shop_itemが可変長の為)
 
@@ -365,6 +399,12 @@ struct npc_data {
 	int eventtimer[MAX_EVENTTIMER];
 	short arenaflag;
 };
+
+#define MOB_MODE_SUMMONED			0x1000
+#define MOB_MODE_TURNS_AGAINST_BAD_MASTER	0x2000
+
+#define MOB_SENSIBLE_MASK 0xf000	// fate: mob mode flags that I actually understand
+
 struct mob_data {
 	struct block_list bl;
 	short n;
@@ -650,6 +690,7 @@ void map_addiddb(struct block_list *);
 void map_deliddb(struct block_list *bl);
 int map_foreachiddb(int (*)(void*,void*,va_list),...);
 void map_addnickdb(struct map_session_data *);
+int map_scriptcont(struct map_session_data *sd,int id); /* Continues a script either on a spell or on an NPC */
 struct map_session_data * map_nick2sd(char*);
 
 // gat関連
diff --git a/src/map/mob.c b/src/map/mob.c
index 1304a41..d53cbfe 100644
--- a/src/map/mob.c
+++ b/src/map/mob.c
@@ -1881,7 +1881,7 @@ static int mob_delay_item_drop(int tid,unsigned int tick,int id,int data)
 
 	if(battle_config.item_auto_get==1){
 		if(ditem->first_sd && (flag = pc_additem(ditem->first_sd,&temp_item,ditem->amount))){
-			clif_additem(ditem->first_sd,0,0,flag);
+                        clif_additem(ditem->first_sd,0,0,flag);
 			map_addflooritem(&temp_item,1,ditem->m,ditem->x,ditem->y,ditem->first_sd,ditem->second_sd,ditem->third_sd,0);
 		}
 		free(ditem);
@@ -2021,6 +2021,15 @@ int mob_damage(struct block_list *src,struct mob_data *md,int damage,int type)
 
 	nullpo_retr(0, md); //srcはNULLで呼ばれる場合もあるので、他でチェック
 
+        if (src->id == md->master_id
+            && md->mode & MOB_MODE_TURNS_AGAINST_BAD_MASTER) {
+            /* If the master hits a monster, have the monster turn against him */
+            md->master_id = 0;
+            md->mode = 0x85; /* Regular war mode */
+            md->target_id = src->id;
+            md->attacked_id = src->id;
+        }
+
 	max_hp = battle_get_max_hp(&md->bl);
 
 	if(src && src->type == BL_PC) {
diff --git a/src/map/npc.c b/src/map/npc.c
index cdc0fe5..a82fe12 100644
--- a/src/map/npc.c
+++ b/src/map/npc.c
@@ -717,7 +717,7 @@ int npc_event(struct map_session_data *sd,const char *eventname,int mob_kill)
 		npc_event_dequeue(sd);
 		return 0;
 	}
-	
+
 	sd->npc_id=nd->bl.id;
 	sd->npc_pos=run_script(nd->u.scr.script,ev->pos,sd->bl.id,nd->bl.id);
 	return 0;
@@ -773,6 +773,7 @@ int npc_touch_areanpc(struct map_session_data *sd,int m,int x,int y)
 			xs=map[m].npc[i]->u.warp.xs;
 			ys=map[m].npc[i]->u.warp.ys;
 			break;
+		case MESSAGE:
 		case SCRIPT:
 			xs=map[m].npc[i]->u.scr.xs;
 			ys=map[m].npc[i]->u.scr.ys;
@@ -796,6 +797,7 @@ int npc_touch_areanpc(struct map_session_data *sd,int m,int x,int y)
 		skill_stop_dancing(&sd->bl,0);
 		pc_setpos(sd,map[m].npc[i]->u.warp.name,map[m].npc[i]->u.warp.x,map[m].npc[i]->u.warp.y,0);
 		break;
+	case MESSAGE:
 	case SCRIPT:
 		{
 			char *name=(char *)aCalloc(50,sizeof(char));
@@ -875,6 +877,10 @@ int npc_click(struct map_session_data *sd,int id)
 	case SCRIPT:
 		sd->npc_pos=run_script(nd->u.scr.script,0,sd->bl.id,id);
 		break;
+        case MESSAGE:
+                if (nd->u.message)
+                    clif_scriptmes(sd, id, nd->u.message);
+                break;
 	}
 
 	return 0;
@@ -897,6 +903,12 @@ int npc_scriptcont(struct map_session_data *sd,int id)
 
 	nd=(struct npc_data *)map_id2bl(id);
 
+        if (!nd /* NPC was disposed? */ || nd->bl.subtype == MESSAGE) {
+            clif_scriptclose(sd, id);
+            npc_event_dequeue(sd);
+            return 0;
+        }
+
 	sd->npc_pos=run_script(nd->u.scr.script,sd->npc_pos,sd->bl.id,id);
 
 	return 0;
@@ -1591,7 +1603,6 @@ static int npc_parse_script(char *w1,char *w2,char *w3,char *w4,char *first_line
 	nd->u.scr.nexttimer=-1;
 	nd->u.scr.timerid=-1;
 
-	
 	return 0;
 }
 
@@ -1889,6 +1900,88 @@ static int npcname_db_final(void *key,void *data,va_list ap)
 {
 	return 0;
 }
+
+struct npc_data *
+npc_spawn_text(int m, int x, int y,
+               int class,
+               char *name,
+               char *message)
+{
+    struct npc_data *retval = (struct npc_data *)aCalloc(1, sizeof(struct npc_data));
+    retval->bl.id = npc_get_new_npc_id();
+    retval->bl.x = x;
+    retval->bl.y = y;
+    retval->bl.m = m;
+    retval->bl.type = BL_NPC;
+    retval->bl.subtype = MESSAGE;
+
+    strncpy(retval->name, name, 23);
+    strncpy(retval->exname, name, 23);
+    retval->name[15] = 0;
+    retval->exname[15] = 0;
+    retval->u.message = message? strdup(message) : NULL;
+
+    retval->class = class;
+    retval->speed = 200;
+
+    clif_spawnnpc(retval);
+    map_addblock(&retval->bl);
+    map_addiddb(&retval->bl);
+    if (retval->name && retval->name[0])
+        strdb_insert(npcname_db, retval->name, retval);
+
+    return retval;
+}
+
+static void
+npc_free_internal(struct npc_data *nd)
+{
+    struct chat_data *cd;
+
+    if(nd->chat_id && (cd=(struct chat_data*)map_id2bl(nd->chat_id))) {
+        free(cd);
+        cd = NULL;
+    }
+    if(nd->bl.subtype == SCRIPT) {
+        if(nd->u.scr.timer_event)
+            free(nd->u.scr.timer_event);
+        if(nd->u.scr.src_id==0){
+            if(nd->u.scr.script){
+                free(nd->u.scr.script);
+                nd->u.scr.script=NULL;
+            }
+            if(nd->u.scr.label_list){
+                free(nd->u.scr.label_list);
+                nd->u.scr.label_list = NULL;
+            }
+        }
+    } else if (nd->bl.subtype == MESSAGE
+               && nd->u.message) {
+        free(nd->u.message);
+    }
+    free(nd);
+}
+
+void
+npc_propagate_update(struct npc_data *nd)
+{
+    map_foreachinarea(npc_enable_sub,
+                      nd->bl.m,
+                      nd->bl.x - nd->u.scr.xs, nd->bl.y - nd->u.scr.ys,
+                      nd->bl.x + nd->u.scr.xs, nd->bl.y + nd->u.scr.ys,
+                      BL_PC, nd);
+}
+
+void
+npc_free(struct npc_data *nd)
+{
+    clif_clearchar(&nd->bl, 0);
+    npc_propagate_update(nd);
+    map_deliddb(&nd->bl);
+    map_delblock(&nd->bl);
+    npc_free_internal(nd);
+}
+
 /*==========================================
  * 終了
  *------------------------------------------
@@ -1899,7 +1992,6 @@ int do_final_npc(void)
 	struct block_list *bl;
 	struct npc_data *nd;
 	struct mob_data *md;
-	struct chat_data *cd;
 	struct pet_data *pd;
 
 	if(ev_db)
@@ -1909,28 +2001,9 @@ int do_final_npc(void)
 
 	for(i=START_NPC_NUM;i<npc_id;i++){
 		if((bl=map_id2bl(i))){
-			if(bl->type == BL_NPC && (nd = (struct npc_data *)bl)){
-				if(nd->chat_id && (cd=(struct chat_data*)map_id2bl(nd->chat_id))){
-					free(cd);
-					cd = NULL;
-				}
-				if(nd->bl.subtype == SCRIPT){
-					if(nd->u.scr.timer_event)
-						free(nd->u.scr.timer_event);
-				 	if(nd->u.scr.src_id==0){
-						if(nd->u.scr.script){
-							free(nd->u.scr.script);
-							nd->u.scr.script=NULL;
-						}
-						if(nd->u.scr.label_list){
-							free(nd->u.scr.label_list);
-							nd->u.scr.label_list = NULL;
-						}
-					}
-				}
-				free(nd);
-				nd = NULL;
-			}else if(bl->type == BL_MOB && (md = (struct mob_data *)bl)){
+			if(bl->type == BL_NPC && (nd = (struct npc_data *)bl))
+                            npc_free_internal(nd);
+                        else if(bl->type == BL_MOB && (md = (struct mob_data *)bl)){
 				if(md->lootitem){
 					free(md->lootitem);
 					md->lootitem = NULL;
diff --git a/src/map/npc.h b/src/map/npc.h
index 63d7765..c843b56 100644
--- a/src/map/npc.h
+++ b/src/map/npc.h
@@ -28,6 +28,21 @@ struct npc_data* npc_name2id(const char *name);
 
 int npc_get_new_npc_id(void);
 
+/**
+ * Spawns and installs a talk-only NPC
+ *
+ * \param message The message to speak.  If message is NULL, the NPC will not do anything at all.
+ */
+struct npc_data *npc_spawn_text(int m, int x, int y,
+                                int class,
+                                char *name,
+                                char *message); // message is strdup'd within
+
+/**
+ * Uninstalls and frees an NPC
+ */
+void npc_free(struct npc_data *npc);
+
 void npc_addsrcfile(char *);
 void npc_delsrcfile(char *);
 int do_final_npc(void);
diff --git a/src/map/pc.c b/src/map/pc.c
index e3b9357..435e053 100644
--- a/src/map/pc.c
+++ b/src/map/pc.c
@@ -701,11 +701,14 @@ int pc_authok(int id, int login_id2, time_t connect_until_time, struct mmo_chars
 	sd->inchealsptick = 0;
 	sd->hp_sub = 0;
 	sd->sp_sub = 0;
+        sd->quick_regeneration_hp.amount = 0;
+        sd->quick_regeneration_sp.amount = 0;
 	sd->inchealspirithptick = 0;
 	sd->inchealspiritsptick = 0;
 	sd->canact_tick = tick;
 	sd->canmove_tick = tick;
 	sd->attackabletime = tick;
+        sd->cast_tick = tick;
 
 	sd->doridori_counter = 0;
 
@@ -994,7 +997,8 @@ int pc_calc_skilltree(struct map_session_data *sd)
 		}
 	}
 
-	for(i=0;i<MAX_SKILL;i++){
+	for(i=0;i<MAX_SKILL;i++)
+            if (i < TMW_MAGIC || i > TMW_MAGIC_END){ // [Fate] This hack gets TMW magic working and persisted without bothering about the skill tree.
 		if (sd->status.skill[i].flag != 13) sd->status.skill[i].id=0;
 		if (sd->status.skill[i].flag && sd->status.skill[i].flag != 13){	// cardスキルなら、
 			sd->status.skill[i].lv=(sd->status.skill[i].flag==1)?0:sd->status.skill[i].flag-2;	// 本当のlvに
@@ -1014,6 +1018,7 @@ int pc_calc_skilltree(struct map_session_data *sd)
 		for(i=355;i<MAX_SKILL;i++)
 			sd->status.skill[i].id=i;
 		}
+
 	}else{
 		// 通常の計算
 		do{
@@ -1049,7 +1054,9 @@ int pc_checkweighticon(struct map_session_data *sd)
 
 	nullpo_retr(0, sd);
 
-	if(sd->weight*2 >= sd->max_weight)
+
+	if(sd->weight*2 >= sd->max_weight
+            && sd->sc_data[SC_FLYING_BACKPACK].timer == -1)
 		flag=1;
 	if(sd->weight*10 >= sd->max_weight*9)
 		flag=2;
@@ -1069,6 +1076,16 @@ int pc_checkweighticon(struct map_session_data *sd)
 	return 0;
 }
 
+
+void
+pc_set_weapon_look(struct map_session_data* sd)
+{
+        if (sd->attack_spell_override)
+                clif_changelook(&sd->bl, LOOK_WEAPON, sd->attack_spell_look_override);
+        else
+                clif_changelook(&sd->bl, LOOK_WEAPON, sd->status.weapon);
+}
+
 /*==========================================
  * パラメータ計算
  * first==0の時、計算対象のパラメータが呼び出し前から
@@ -1248,7 +1265,7 @@ int pc_calcstatus(struct map_session_data* sd,int first)
 
 	if(!sd->disguiseflag && sd->disguise) {
 		sd->disguise=0;
-		clif_changelook(&sd->bl,LOOK_WEAPON,sd->status.weapon);
+                pc_set_weapon_look(sd);
 		clif_changelook(&sd->bl,LOOK_SHIELD,sd->status.shield);
 		clif_changelook(&sd->bl,LOOK_HEAD_BOTTOM,sd->status.head_bottom);
 		clif_changelook(&sd->bl,LOOK_HEAD_TOP,sd->status.head_top);
@@ -1776,6 +1793,15 @@ int pc_calcstatus(struct map_session_data* sd,int first)
 			sd->sc_data[i=SC_SPEEDPOTION0].timer!=-1)	// 増 速ポーション
 			aspd_rate -= sd->sc_data[i].val2;
 
+                if (sd->sc_data[SC_HASTE].timer != -1)
+                    aspd_rate -= sd->sc_data[SC_HASTE].val1;
+
+
+                /* Slow down if protected */
+
+                if (sd->sc_data[SC_PHYS_SHIELD].timer != -1)
+                    aspd_rate += sd->sc_data[SC_PHYS_SHIELD].val1;
+
 		// HIT/FLEE変化系
 		if(sd->sc_data[SC_WHISTLE].timer!=-1){  // 口笛
 			sd->flee += sd->flee * (sd->sc_data[SC_WHISTLE].val1
@@ -1890,6 +1916,10 @@ int pc_calcstatus(struct map_session_data* sd,int first)
 		sd->aspd = sd->aspd*aspd_rate/100;
 	if(pc_isriding(sd))							// 騎兵修練
 		sd->aspd = sd->aspd*(100 + 10*(5 - pc_checkskill(sd,KN_CAVALIERMASTERY)))/ 100;
+
+        if (sd->attack_spell_override)
+                sd->aspd = sd->attack_spell_delay;
+
 	if(sd->aspd < battle_config.max_aspd) sd->aspd = battle_config.max_aspd;
 	sd->amotion = sd->aspd;
 	sd->dmotion = 800-sd->paramc[1]*4;
@@ -1921,7 +1951,7 @@ int pc_calcstatus(struct map_session_data* sd,int first)
 	if(b_class != sd->view_class) {
 		clif_changelook(&sd->bl,LOOK_BASE,sd->view_class);
 #if PACKETVER < 4
-		clif_changelook(&sd->bl,LOOK_WEAPON,sd->status.weapon);
+                pc_set_weapon_look(sd);
 		clif_changelook(&sd->bl,LOOK_SHIELD,sd->status.shield);
 #else
 		clif_changelook(&sd->bl,LOOK_WEAPON,0);
@@ -2826,6 +2856,47 @@ int pc_search_inventory(struct map_session_data *sd,int item_id)
 	return -1;
 }
 
+int
+pc_count_all_items(struct map_session_data *player, int item_id)
+{
+    int i;
+    int count = 0;
+
+    nullpo_retr(0, player);
+
+    for (i = 0; i < MAX_INVENTORY; i++) {
+        if (player->status.inventory[i].nameid == item_id)
+            count += player->status.inventory[i].amount;
+    }
+
+    return count;
+}
+
+int
+pc_remove_items(struct map_session_data *player, int item_id, int count)
+{
+    int i;
+
+    nullpo_retr(0, player);
+
+    for (i = 0; i < MAX_INVENTORY && count; i++) {
+        if (player->status.inventory[i].nameid == item_id) {
+            int to_delete = count;
+            /* only delete as much as we have */
+            if (to_delete > player->status.inventory[i].amount)
+                to_delete = player->status.inventory[i].amount;
+
+            count -= to_delete;
+
+            pc_delitem(player, i, to_delete, 0 /* means `really delete and update status' */);
+
+            if (!count)
+                return 0;
+        }
+    }
+    return 0;
+}
+
 /*==========================================
  * アイテム追加。個数のみitem構造体の数字を無視
  *------------------------------------------
@@ -3830,6 +3901,15 @@ int pc_stop_walking(struct map_session_data *sd,int type)
 	return 0;
 }
 
+void
+pc_touch_all_relevant_npcs(struct map_session_data *sd)
+{
+	if(map_getcell(sd->bl.m,sd->bl.x,sd->bl.y)&0x80)
+		npc_touch_areanpc(sd,sd->bl.m,sd->bl.x,sd->bl.y);
+	else
+		sd->areanpc_id=0;
+}
+
 /*==========================================
  *
  *------------------------------------------
@@ -3878,10 +3958,7 @@ int pc_movepos(struct map_session_data *sd,int dst_x,int dst_y)
 
 	skill_unit_move(&sd->bl,gettick(),dist+7);	// スキルユニットの検査
 
-	if(map_getcell(sd->bl.m,sd->bl.x,sd->bl.y)&0x80)
-		npc_touch_areanpc(sd,sd->bl.m,sd->bl.x,sd->bl.y);
-	else
-		sd->areanpc_id=0;
+        pc_touch_all_relevant_npcs(sd);
 	return 0;
 }
 
@@ -4035,6 +4112,7 @@ int pc_attack_timer(int tid,unsigned int tick,int id,int data)
 	short *opt;
 	int dist,skill,range;
 
+
 	sd=map_id2sd(id);
 	if(sd == NULL)
 		return 0;
@@ -4084,54 +4162,61 @@ int pc_attack_timer(int tid,unsigned int tick,int id,int data)
 		}
 	}
 
-	dist = distance(sd->bl.x,sd->bl.y,bl->x,bl->y);
-	range = sd->attackrange;
-	if(sd->status.weapon != 11) range++;
-	if( dist > range ){	// 届 かないので移動
-		//if(pc_can_reach(sd,bl->x,bl->y))
-			//clif_movetoattack(sd,bl);
-		return 0;
-	}
-
 	if (sd->attackabletime > tick)
 		return 0; // cannot attack yet
 
-	if(dist <= range && !battle_check_range(&sd->bl,bl,range) ) {
-		if(pc_can_reach(sd,bl->x,bl->y) && sd->canmove_tick < tick && (sd->sc_data[SC_ANKLE].timer == -1 || sd->sc_data[SC_SPIDERWEB].timer == -1))
-			// TMW client doesn't support this
-			//pc_walktoxy(sd,bl->x,bl->y);
-			clif_movetoattack(sd, bl);
-		sd->attackabletime = tick + (sd->aspd<<1);
-	}
-	else {
-		if(battle_config.pc_attack_direction_change)
-			sd->dir=sd->head_dir=map_calc_dir(&sd->bl, bl->x,bl->y );	// 向き設定
-
-		if(sd->walktimer != -1)
-			pc_stop_walking(sd,1);
+        if (sd->attack_spell_override // [Fate] If we have an active attack spell, use that
+            && spell_attack(id, sd->attacktarget)) {
+                // Return if the spell succeeded.  If the spell had disspiated, spell_attack() may fail.
+                sd->attackabletime = tick + sd->attack_spell_delay;
+
+        } else {
+                dist = distance(sd->bl.x,sd->bl.y,bl->x,bl->y);
+                range = sd->attackrange;
+                if(sd->status.weapon != 11) range++;
+                if( dist > range ){	// 届 かないので移動
+                        //if(pc_can_reach(sd,bl->x,bl->y))
+			//clif_movetoattack(sd,bl);
+                        return 0;
+                }
 
-		if(sd->sc_data[SC_COMBO].timer == -1) {
-			map_freeblock_lock();
-			pc_stop_walking(sd,0);
-			sd->attacktarget_lv = battle_weapon_attack(&sd->bl,bl,tick,0);
-			if(!(battle_config.pc_cloak_check_type&2) && sd->sc_data[SC_CLOAKING].timer != -1)
-				skill_status_change_end(&sd->bl,SC_CLOAKING,-1);
-			if(sd->status.pet_id > 0 && sd->pd && sd->petDB && battle_config.pet_attack_support)
-				pet_target_check(sd,bl,0);
-			map_freeblock_unlock();
-			if(sd->skilltimer != -1 && (skill = pc_checkskill(sd,SA_FREECAST)) > 0 ) // フリーキャスト
-				sd->attackabletime = tick + ((sd->aspd<<1)*(150 - skill*5)/100);
-			else
-				sd->attackabletime = tick + (sd->aspd<<1);
-		}
-		else if(sd->attackabletime <= tick) {
-			if(sd->skilltimer != -1 && (skill = pc_checkskill(sd,SA_FREECAST)) > 0 ) // フリーキャスト
-				sd->attackabletime = tick + ((sd->aspd<<1)*(150 - skill*5)/100);
-			else
-				sd->attackabletime = tick + (sd->aspd<<1);
-		}
-		if(sd->attackabletime <= tick) sd->attackabletime = tick + (battle_config.max_aspd<<1);
-	}
+                if(dist <= range && !battle_check_range(&sd->bl,bl,range) ) {
+                        if(pc_can_reach(sd,bl->x,bl->y) && sd->canmove_tick < tick && (sd->sc_data[SC_ANKLE].timer == -1 || sd->sc_data[SC_SPIDERWEB].timer == -1))
+                                // TMW client doesn't support this
+                                //pc_walktoxy(sd,bl->x,bl->y);
+                                clif_movetoattack(sd, bl);
+                        sd->attackabletime = tick + (sd->aspd<<1);
+                }
+                else {
+                        if(battle_config.pc_attack_direction_change)
+                                sd->dir=sd->head_dir=map_calc_dir(&sd->bl, bl->x,bl->y );	// 向き設定
+
+                        if(sd->walktimer != -1)
+                                pc_stop_walking(sd,1);
+
+                        if(sd->sc_data[SC_COMBO].timer == -1) {
+                                map_freeblock_lock();
+                                pc_stop_walking(sd,0);
+                                sd->attacktarget_lv = battle_weapon_attack(&sd->bl,bl,tick,0);
+                                if(!(battle_config.pc_cloak_check_type&2) && sd->sc_data[SC_CLOAKING].timer != -1)
+                                        skill_status_change_end(&sd->bl,SC_CLOAKING,-1);
+                                if(sd->status.pet_id > 0 && sd->pd && sd->petDB && battle_config.pet_attack_support)
+                                        pet_target_check(sd,bl,0);
+                                map_freeblock_unlock();
+                                if(sd->skilltimer != -1 && (skill = pc_checkskill(sd,SA_FREECAST)) > 0 ) // フリーキャスト
+                                        sd->attackabletime = tick + ((sd->aspd<<1)*(150 - skill*5)/100);
+                                else
+                                        sd->attackabletime = tick + (sd->aspd<<1);
+                        }
+                        else if(sd->attackabletime <= tick) {
+                                if(sd->skilltimer != -1 && (skill = pc_checkskill(sd,SA_FREECAST)) > 0 ) // フリーキャスト
+                                        sd->attackabletime = tick + ((sd->aspd<<1)*(150 - skill*5)/100);
+                                else
+                                        sd->attackabletime = tick + (sd->aspd<<1);
+                        }
+                        if(sd->attackabletime <= tick) sd->attackabletime = tick + (battle_config.max_aspd<<1);
+                }
+        }
 
 	if(sd->state.attack_continue) {
 		sd->attacktimer=add_timer(sd->attackabletime,pc_attack_timer,sd->bl.id,0);
@@ -4658,7 +4743,8 @@ int pc_skillup(struct map_session_data *sd,int skill_num)
 
 	if( sd->status.skill_point>0 &&
 		sd->status.skill[skill_num].id!=0 &&
-		sd->status.skill[skill_num].lv < skill_get_max(skill_num) )
+		sd->status.skill[skill_num].lv < skill_get_max(skill_num)
+            && (skill_num < TMW_MAGIC || skill_num > TMW_MAGIC_END)) // [Fate] Hack: Prevent exploit for raising magic levels
 	{
 		sd->status.skill[skill_num].lv++;
 		sd->status.skill_point--;
@@ -4967,6 +5053,9 @@ int pc_damage(struct block_list *src,struct map_session_data *sd,int damage)
 	skill_status_change_clear(&sd->bl,0);	// ステータス異常を解除する
 	clif_updatestatus(sd,SP_HP);
 	pc_calcstatus(sd,0);
+        // [Fate] Reset magic
+        sd->cast_tick = gettick();
+        magic_stop_completely(sd);
 
 	for(i=0;i<5;i++)
 		if(sd->dev.val1[i]){
@@ -5365,8 +5454,72 @@ int pc_heal(struct map_session_data *sd,int hp,int sp)
  * HP/SP回復
  *------------------------------------------
  */
+static int pc_itemheal_effect(struct map_session_data *sd,int hp,int sp);
+
+static int // Compute how quickly we regenerate (less is faster) for that amount
+pc_heal_quick_speed(int amount)
+{
+        if (amount >= 200) {
+                if (amount >= 500)
+                        return 0;
+                if (amount >= 350)
+                        return 1;
+                return 2;
+        } else { // < 200
+                if (amount >= 100)
+                        return 3;
+                if (amount >= 50)
+                        return 4;
+                return 5;
+        }
+}
+
+static void
+pc_heal_quick_accumulate(int new_amount, struct quick_regeneration *quick_regen, int max)
+{
+        int current_amount = quick_regen->amount;
+        int current_speed = quick_regen->speed;
+        int new_speed = pc_heal_quick_speed(new_amount);
+
+        int average_speed = ((new_speed * new_amount) + (current_speed * current_amount)) / (current_amount + new_amount); // new_amount > 0, current_amount >= 0
+
+        quick_regen->speed = average_speed;
+        quick_regen->amount = MIN(current_amount + new_amount, max);
+
+        quick_regen->tickdelay = MIN(quick_regen->speed, quick_regen->tickdelay);
+}
+
 int pc_itemheal(struct map_session_data *sd,int hp,int sp)
 {
+        /* defer healing */
+        if (hp > 0) {
+                pc_heal_quick_accumulate(hp,
+                                         &sd->quick_regeneration_hp,
+                                         sd->status.max_hp - sd->status.hp);
+                        
+                hp = 0;
+        }
+        if (sp > 0) {
+                pc_heal_quick_accumulate(sp,
+                                         &sd->quick_regeneration_sp,
+                                         sd->status.max_sp - sd->status.sp);
+
+                sp = 0;
+        }
+
+        /* Hurt right away, if necessary */
+        if (hp < 0 || sp < 0)
+                pc_itemheal_effect(sd, hp, sp);
+
+        return 0;
+}
+
+
+/* pc_itemheal_effect is invoked once every 0.5s whenever the pc
+ * has health recovery queued up (cf. pc_natural_heal_sub).
+ */
+static int pc_itemheal_effect(struct map_session_data *sd,int hp,int sp)
+{
 	int bonus;
 //	if(battle_config.battle_log)
 //		printf("heal %d %d\n",hp,sp);
@@ -5578,7 +5731,7 @@ int pc_equiplookall(struct map_session_data *sd)
 	nullpo_retr(0, sd);
 
 #if PACKETVER < 4
-	clif_changelook(&sd->bl,LOOK_WEAPON,sd->status.weapon);
+        pc_set_weapon_look(sd);
 	clif_changelook(&sd->bl,LOOK_SHIELD,sd->status.shield);
 #else
 	clif_changelook(&sd->bl,LOOK_WEAPON,0);
@@ -6191,8 +6344,11 @@ int pc_equipitem(struct map_session_data *sd,int n,int pos)
 		clif_arrowequip(sd,n);
 		clif_arrow_fail(sd,3);	// 3=矢が装備できました
 	}
-	else
-		clif_equipitemack(sd,n,pos,1);
+	else {
+                /* Don't update re-equipping if we're using a spell */
+                if (!(pos == 4 && sd->attack_spell_override))
+                        clif_equipitemack(sd,n,pos,1);
+        }
 
 	for(i=0;i<11;i++) {
 		if(pos & equip_pos[i])
@@ -6206,7 +6362,7 @@ int pc_equipitem(struct map_session_data *sd,int n,int pos)
 		else
 			sd->weapontype1 = 0;
 		pc_calcweapontype(sd);
-		clif_changelook(&sd->bl,LOOK_WEAPON,sd->status.weapon);
+                pc_set_weapon_look(sd);
 	}
 	if(sd->status.inventory[n].equip & 0x0020) {
 		if(sd->inventory_data[n]) {
@@ -6302,7 +6458,7 @@ int pc_unequipitem(struct map_session_data *sd,int n,int type)
 			sd->weapontype1 = 0;
 			sd->status.weapon = sd->weapontype2;
 			pc_calcweapontype(sd);
-			clif_changelook(&sd->bl,LOOK_WEAPON,sd->status.weapon);
+                        pc_set_weapon_look(sd);
 		}
 		if(sd->status.inventory[n].equip & 0x0020) {
 			sd->status.shield = sd->weapontype2 = 0;
@@ -6821,6 +6977,7 @@ static int pc_natural_heal_sp(struct map_session_data *sd)
 static int pc_spirit_heal_hp(struct map_session_data *sd,int level)
 {
 	int bonus_hp,interval = battle_config.natural_heal_skill_interval;
+	struct status_change *sc_data = battle_get_sc_data(&sd->bl);
 
 	nullpo_retr(0, sd);
 
@@ -6831,7 +6988,8 @@ static int pc_spirit_heal_hp(struct map_session_data *sd,int level)
 
 	sd->inchealspirithptick += natural_heal_diff_tick;
 
-	if(sd->weight*100/sd->max_weight >= battle_config.natural_heal_weight_rate)
+	if(sd->weight*100/sd->max_weight >= battle_config.natural_heal_weight_rate
+           && sc_data[SC_FLYING_BACKPACK].timer == -1)
 		interval += interval;
 
 	if(sd->inchealspirithptick >= interval) {
@@ -6872,7 +7030,7 @@ static int pc_spirit_heal_sp(struct map_session_data *sd,int level)
 	sd->inchealspiritsptick += natural_heal_diff_tick;
 
 	if(sd->weight*100/sd->max_weight >= battle_config.natural_heal_weight_rate)
-		interval += interval;
+            interval += interval;
 
 	if(sd->inchealspiritsptick >= interval) {
 		bonus_sp = sd->nsshealsp;
@@ -6903,17 +7061,49 @@ static int pc_spirit_heal_sp(struct map_session_data *sd,int level)
  * HP/SP 自然回復 各クライアント
  *------------------------------------------
  */
+static int pc_itemheal_effect(struct map_session_data *sd, int hp, int sp);
+
+static int
+pc_quickregenerate_effect(struct quick_regeneration *quick_regen, int heal_speed)
+{
+        if (!(quick_regen->tickdelay--)) {
+                int bonus = MIN(heal_speed * battle_config.itemheal_regeneration_factor,
+                                quick_regen->amount);
+
+                quick_regen->amount -= bonus;
+
+                quick_regen->tickdelay = quick_regen->speed;
+
+                return bonus;
+        }
+
+        return 0;
+}
 
 static int pc_natural_heal_sub(struct map_session_data *sd,va_list ap) {
 	int skill;
 
 	nullpo_retr(0, sd);
 
+        if (sd->sc_data[SC_HALT_REGENERATE].timer != -1)
+            return 0;
+
+        if (sd->quick_regeneration_hp.amount || sd->quick_regeneration_sp.amount) {
+                int hp_bonus = pc_quickregenerate_effect(&sd->quick_regeneration_hp, sd->nhealhp);
+                int sp_bonus = pc_quickregenerate_effect(&sd->quick_regeneration_sp, sd->nhealsp);
+
+                pc_itemheal_effect(sd,
+                                   hp_bonus,
+                                   sp_bonus);
+        }
+
 // -- moonsoul (if conditions below altered to disallow natural healing if under berserk status)
-	if ((battle_config.natural_heal_weight_rate > 100 || sd->weight*100/sd->max_weight < battle_config.natural_heal_weight_rate) &&
-		!pc_isdead(sd) && 
-		!pc_ishiding(sd) && 
-		sd->sc_data[SC_POISON].timer == -1
+	if ((sd->sc_data[SC_FLYING_BACKPACK].timer != -1
+             || battle_config.natural_heal_weight_rate > 100
+             || sd->weight*100/sd->max_weight < battle_config.natural_heal_weight_rate) &&
+            !pc_isdead(sd) && 
+            !pc_ishiding(sd) && 
+            sd->sc_data[SC_POISON].timer == -1
 	  ) {
 		pc_natural_heal_hp(sd);
 		if( sd->sc_data && sd->sc_data[SC_EXTREMITYFIST].timer == -1 &&	//阿修羅状態ではSPが回復しない
@@ -7514,3 +7704,9 @@ int do_init_pc(void) {
 
 	return 0;
 }
+
+void
+pc_cleanup(struct map_session_data *sd)
+{
+        magic_stop_completely(sd);
+}
diff --git a/src/map/pc.h b/src/map/pc.h
index 1919007..f424d57 100644
--- a/src/map/pc.h
+++ b/src/map/pc.h
@@ -23,6 +23,9 @@
 #define pc_is50overweight(sd) (sd->weight*2 >= sd->max_weight) 
 #define pc_is90overweight(sd) (sd->weight*10 >= sd->max_weight*9)
 
+void pc_touch_all_relevant_npcs(struct map_session_data *sd); /* Checks all npcs/warps at the same location to see whether they
+                                                              ** should do something with the specified player. */
+
 int pc_isGM(struct map_session_data *sd);
 int pc_iskiller(struct map_session_data *src, struct map_session_data *target); // [MouseJstr]
 int pc_getrefinebonus(int lv,int type);
@@ -64,6 +67,8 @@ int pc_additem(struct map_session_data*,struct item*,int);
 int pc_getzeny(struct map_session_data*,int);
 int pc_delitem(struct map_session_data*,int,int,int);
 int pc_checkitem(struct map_session_data*);
+int pc_count_all_items(struct map_session_data* player, int item_id);
+int pc_remove_items(struct map_session_data* player, int item_id, int count);
 
 int pc_cart_additem(struct map_session_data *sd,struct item *item_data,int amount);
 int pc_cart_delitem(struct map_session_data *sd,int n,int amount,int type);
@@ -156,7 +161,7 @@ int pc_divorce(struct map_session_data *sd);
 struct map_session_data *pc_get_partner(struct map_session_data *sd);
 int pc_set_gm_level(int account_id, int level);
 void pc_setstand(struct map_session_data *sd);
-
+void pc_cleanup(struct map_session_data *sd); // [Fate] Clean up after a logged-out PC
 
 struct pc_base_job{
 	int job; //職業、ただし転生職や養子職の場合は元の職業を返す(廃プリ→プリ)
diff --git a/src/map/pet.c b/src/map/pet.c
index 6026b1e..22d2af7 100644
--- a/src/map/pet.c
+++ b/src/map/pet.c
@@ -629,7 +629,7 @@ int pet_return_egg(struct map_session_data *sd)
 		*((long *)(&tmp_item.card[1])) = sd->pet.pet_id;
 		tmp_item.card[3] = sd->pet.rename_flag;
 		if((flag = pc_additem(sd,&tmp_item,1))) {
-			clif_additem(sd,0,0,flag);
+                        clif_additem(sd,0,0,flag);
 			map_addflooritem(&tmp_item,1,sd->bl.m,sd->bl.x,sd->bl.y,NULL,NULL,NULL,0);
 		}
 		if(battle_config.pet_status_support && sd->pet.intimate > 0) {
diff --git a/src/map/script.c b/src/map/script.c
index a9a171b..251ce01 100644
--- a/src/map/script.c
+++ b/src/map/script.c
@@ -249,6 +249,8 @@ int buildin_marriage(struct script_state *st);
 int buildin_wedding_effect(struct script_state *st);
 int buildin_divorce(struct script_state *st);
 int buildin_getitemname(struct script_state *st);
+int buildin_getspellinvocation(struct script_state *st); // [Fate]
+int buildin_getanchorinvocation(struct script_state *st); // [Fate]
 int buildin_makepet(struct script_state *st);
 int buildin_getexp(struct script_state *st);
 int buildin_getinventorylist(struct script_state *st);
@@ -283,6 +285,7 @@ int buildin_npctalk(struct script_state *st); // [Valaris]
 int buildin_hasitems(struct script_state *st); // [Valaris]
 int buildin_getlook(struct script_state *st);	//Lorky [Lupus]
 int buildin_getsavepoint(struct script_state *st);	//Lorky [Lupus]
+int buildin_getpartnerid(struct script_state *st); // [Fate]
 
 
 void push_val(struct script_stack *stack,int type,int val);
@@ -455,6 +458,9 @@ struct {
 	{buildin_wedding_effect,"wedding",""},
 	{buildin_divorce,"divorce",""},
 	{buildin_getitemname,"getitemname","i"},
+	{buildin_getspellinvocation,"getspellinvocation","s"},
+	{buildin_getanchorinvocation,"getanchorinvocation","s"},
+	{buildin_getpartnerid,"getpartnerid2","i"},
 	{buildin_makepet,"makepet","i"},
 	{buildin_getexp,"getexp","ii"},
 	{buildin_getinventorylist,"getinventorylist",""},
@@ -2301,7 +2307,7 @@ int buildin_getitem(struct script_state *st)
 		if(sd == NULL) //アイテムを渡す相手がいなかったらお帰り
 			return 0;
 		if((flag = pc_additem(sd,&item_tmp,amount))) {
-			clif_additem(sd,0,0,flag);
+                        clif_additem(sd,0,0,flag);
 			map_addflooritem(&item_tmp,amount,sd->bl.m,sd->bl.x,sd->bl.y,NULL,NULL,NULL,0);
 		}
 	}
@@ -5257,6 +5263,8 @@ int buildin_marriage(struct script_state *st)
 	struct map_session_data *sd=script_rid2sd(st);
 	struct map_session_data *p_sd=map_nick2sd(partner);
 
+        fprintf(stderr, "0=%p (%d,%d), 1=%p (%d,%d)\n", sd, sd->bl.id, sd->status.partner_id,
+                p_sd, p_sd->bl.id, p_sd->status.partner_id);
 	if(sd==NULL || p_sd==NULL || pc_marriage(sd,p_sd) < 0){
 		push_val(st->stack,C_INT,0);
 		return 0;
@@ -5391,6 +5399,46 @@ int buildin_getitemname(struct script_state *st)
 	return 0;
 }
 
+
+int buildin_getspellinvocation(struct script_state *st)
+{
+        char *name;
+	char *invocation;
+
+	name = conv_str(st,& (st->stack->stack_data[st->start+2]));
+
+        invocation = magic_find_invocation(name);
+        if (!invocation)
+                invocation = "...";
+
+	push_str(st->stack, C_STR, strdup(invocation));
+	return 0;
+}
+
+int buildin_getanchorinvocation(struct script_state *st)
+{
+        char *name;
+	char *invocation;
+
+	name = conv_str(st,& (st->stack->stack_data[st->start+2]));
+
+        invocation = magic_find_anchor_invocation(name);
+        if (!invocation)
+                invocation = "...";
+
+	push_str(st->stack, C_STR, strdup(invocation));
+	return 0;
+}
+
+int buildin_getpartnerid(struct script_state *st)
+{
+	struct map_session_data *sd=script_rid2sd(st);
+
+	push_val(st->stack, C_INT, sd->status.partner_id);
+	return 0;
+}
+
+
 /*==========================================
  * petskillbonus [Valaris]
  *------------------------------------------
@@ -6414,10 +6462,16 @@ int run_script_main(unsigned char *script,int pos,int rid,int oid,struct script_
  */
 int run_script(unsigned char *script,int pos,int rid,int oid)
 {
+        run_script_l(script, pos, rid, oid, 0, NULL);
+}
+
+int run_script_l(unsigned char *script,int pos,int rid,int oid, int args_nr, argrec_t *args)
+{
 	struct script_stack stack;
 	struct script_state st;
 	struct map_session_data *sd=map_id2sd(rid);
 	unsigned char *rootscript=script;
+        int i;
 
 	if(script==NULL || pos<0)
 		return -1;
@@ -6441,6 +6495,12 @@ int run_script(unsigned char *script,int pos,int rid,int oid)
 	st.pos=pos;
 	st.rid=rid;
 	st.oid=oid;
+        for (i = 0; i < args_nr; i++) {
+                if (args[i].name[strlen(args[i].name) - 1] == '$')
+                        pc_setregstr(sd, add_str(args[i].name), args[i].v.s);
+                else
+                        pc_setreg(sd, add_str(args[i].name), args[i].v.i);
+        }
 	run_script_main(script,pos,rid,oid,&st,rootscript);
 
 	free(stack.stack_data);
diff --git a/src/map/script.h b/src/map/script.h
index b50c466..3391643 100644
--- a/src/map/script.h
+++ b/src/map/script.h
@@ -24,6 +24,14 @@ struct script_state {
 };
 
 unsigned char * parse_script(unsigned char *,int);
+typedef struct {
+        char *name;
+        union {
+                int i;
+                char * s;
+        } v;
+} argrec_t;
+int run_script_l(unsigned char *,int,int,int,int,argrec_t *args);
 int run_script(unsigned char *,int,int,int);
 
 struct dbt* script_get_label_db();
diff --git a/src/map/skill.c b/src/map/skill.c
index 1e92b3f..cff56ba 100644
--- a/src/map/skill.c
+++ b/src/map/skill.c
@@ -9,6 +9,7 @@
 #include "timer.h"
 #include "nullpo.h"
 #include "malloc.h"
+#include "magic.h"
 
 #include "skill.h"
 #include "map.h"
@@ -3519,7 +3520,7 @@ int skill_castend_nodamage_id( struct block_list *src, struct block_list *bl,int
 			}
 			eflag = pc_additem(sd,&item_tmp,1);
 			if(eflag) {
-				clif_additem(sd,0,0,eflag);
+                                clif_additem(sd,0,0,eflag);
 				map_addflooritem(&item_tmp,1,sd->bl.m,sd->bl.x,sd->bl.y,NULL,NULL,NULL,0);
 			}
 		}
@@ -7708,6 +7709,8 @@ int skill_status_change_end(struct block_list* bl, int type, int tid)
 			case SC_MATKPOT:		/* magic attack potion [Valaris] */
 			case SC_WEDDING:	//結婚用(結婚衣裳になって歩くのが遅いとか)
 			case SC_MELTDOWN:		/* メルトダウン */
+                        case SC_PHYS_SHIELD:
+                        case SC_HASTE:
 				calc_flag = 1;
 				break;
 			case SC_BERSERK:			/* バーサーク */
@@ -7913,6 +7916,11 @@ int skill_status_change_timer(int tid, unsigned int tick, int id, int data)
 			printf("skill_status_change_timer %d != %d\n",tid,sc_data[type].timer);
 	}
 
+        if (sc_data[type].spell_invocation) { // Must report termination
+                spell_effect_report_termination(sc_data[type].spell_invocation, bl->id, type, 0);
+                sc_data[type].spell_invocation = 0;
+        }
+
 	switch(type){	/* 特殊な処理になる場合 */
 	case SC_MAXIMIZEPOWER:	/* マキシマイズパワー */
 	case SC_CLOAKING:		/* クローキング */
@@ -8229,6 +8237,11 @@ int skill_status_change_timer(int tid, unsigned int tick, int id, int data)
 				return 0;
 		}
 		break;
+
+        case SC_FLYING_BACKPACK:
+            clif_updatestatus(sd, SP_WEIGHT);
+            break;
+
 	}
 
 	return skill_status_change_end( bl,type,tid );
@@ -8266,6 +8279,12 @@ int skill_encchant_eremental_end(struct block_list *bl,int type)
  */
 int skill_status_change_start(struct block_list *bl, int type, int val1, int val2, int val3, int val4, int tick, int flag) 
 {
+        skill_status_effect(bl, type, val1, val2, val3, val4, tick, flag, 0);
+}
+
+
+int skill_status_effect(struct block_list *bl, int type, int val1, int val2, int val3, int val4, int tick, int flag, int spell_invocation) 
+{
 	struct map_session_data *sd = NULL;
 	struct status_change* sc_data;
 	short *sc_count, *option, *opt1, *opt2, *opt3;
@@ -8663,7 +8682,7 @@ int skill_status_change_start(struct block_list *bl, int type, int val1, int val
 		case SC_SPEEDPOTION2:
 			calc_flag = 1;
 			tick = 1000 * tick;
-			val2 = 5*(2+type-SC_SPEEDPOTION0);
+//			val2 = 5*(2+type-SC_SPEEDPOTION0);
 			break;
 
 		/* atk & matk potions [Valaris] */
@@ -8921,8 +8940,16 @@ int skill_status_change_start(struct block_list *bl, int type, int val1, int val
 					val4 = (int)sg;
 			}
 			break;
+                case SC_HASTE:
+                        calc_flag = 1;
 		case SC_SPLASHER:		/* ベナムスプラッシャー */
+                case SC_PHYS_SHIELD:
+                case SC_MBARRIER:
+                case SC_HALT_REGENERATE:
 			break;
+                case SC_FLYING_BACKPACK:
+                        updateflag = SP_WEIGHT;
+                        break;
 		default:
 			if(battle_config.error_log)
 				printf("UnknownStatusChange [%d]\n", type);
@@ -9000,7 +9027,13 @@ int skill_status_change_start(struct block_list *bl, int type, int val1, int val
 	sc_data[type].val2 = val2;
 	sc_data[type].val3 = val3;
 	sc_data[type].val4 = val4;
+        if (sc_data[type].spell_invocation) // Supplant by newer spell
+                spell_effect_report_termination(sc_data[type].spell_invocation, bl->id, type, 1);
+
+        sc_data[type].spell_invocation = spell_invocation;
+
 	/* タイマー設定 */
+
 	sc_data[type].timer = add_timer(
 		gettick() + tick, skill_status_change_timer, bl->id, type);
 
diff --git a/src/map/skill.h b/src/map/skill.h
index 6cb3d88..b3e3f59 100644
--- a/src/map/skill.h
+++ b/src/map/skill.h
@@ -3,6 +3,7 @@
 #define _SKILL_H_
 
 #include "map.h"
+#include "magic.h"
 
 #define MAX_SKILL_DB			450
 #define MAX_SKILL_PRODUCE_DB	 150
@@ -145,6 +146,7 @@ int skill_check_cloaking(struct block_list *bl);
 int skill_is_danceskill(int id);
 
 // ステータス異常
+int skill_status_effect(struct block_list *bl,int type,int val1,int val2,int val3,int val4,int tick,int flag, int spell_invocation);
 int skill_status_change_start(struct block_list *bl,int type,int val1,int val2,int val3,int val4,int tick,int flag);
 int skill_status_change_timer(int tid, unsigned int tick, int id, int data);
 int skill_encchant_eremental_end(struct block_list *bl, int type);
@@ -330,6 +332,13 @@ enum {	// struct map_session_data の status_changeの番号テーブル
 	SC_MINDBREAKER		=191,
 	SC_SPELLBREAKER		=192,
 
+// Added for Fate's spells
+        SC_HALT_REGENERATE	= 195, // Suspend regeneration
+        SC_FLYING_BACKPACK	= 196, // Flying backpack
+        SC_MBARRIER		= 197, // Magical barrier, magic resistance (val1 : power (%))
+        SC_HASTE		= 198, // `Haste' spell (val1 : power)
+        SC_PHYS_SHIELD		= 199, // `Protect' spell, reduce damage (val1: power)
+
 // -- testing various SC effects
 //	SC_AURABLADE			=81,
 //	SC_CONCENTRATION		=83,
@@ -705,13 +714,22 @@ enum {
 	DC_FORTUNEKISS,
 	DC_SERVICEFORYOU,
 
+	NPC_SELFDESTRUCTION2 = 331,
+
 	WE_MALE = 334,
 	WE_FEMALE,
 	WE_CALLPARTNER,
 
-	NPC_SELFDESTRUCTION2 = 331,
 	NPC_DARKCROSS = 338,
 
+        TMW_MAGIC = 340,
+        TMW_MAGIC_LIFE,
+        TMW_MAGIC_WAR,
+        TMW_MAGIC_TRANSMUTE,
+        TMW_MAGIC_NATURE,
+        TMW_MAGIC_ETHER,
+        TMW_MAGIC_END,
+
 	LK_AURABLADE = 355,
 	LK_PARRYING,
 	LK_CONCENTRATION,
diff --git a/src/map/storage.c b/src/map/storage.c
index 696a74e..ca7fa8b 100644
--- a/src/map/storage.c
+++ b/src/map/storage.c
@@ -234,7 +234,7 @@ int storage_storageget(struct map_session_data *sd,int index,int amount)
 				if((flag = pc_additem(sd,&stor->storage[index],amount)) == 0)
 					storage_delitem(sd,stor,index,amount);
 				else
-					clif_additem(sd,0,0,flag);
+                                        clif_additem(sd,0,0,flag);
 			} // valid amount
 		}// valid index
 	}// storage open
diff --git a/src/map/trade.c b/src/map/trade.c
index 8bf2cb2..397654e 100644
--- a/src/map/trade.c
+++ b/src/map/trade.c
@@ -169,7 +169,7 @@ void trade_tradecancel(struct map_session_data *sd)
 	if((target_sd = map_id2sd(sd->trade_partner)) != NULL){
 		for(trade_i=0; trade_i<10;trade_i++) { //give items back (only virtual)
 			if(sd->deal_item_amount[trade_i] != 0) {
-				clif_additem(sd,sd->deal_item_index[trade_i]-2,sd->deal_item_amount[trade_i],0);
+                                clif_additem(sd,sd->deal_item_index[trade_i]-2,sd->deal_item_amount[trade_i],0);
 				sd->deal_item_index[trade_i] =0;
 				sd->deal_item_amount[trade_i]=0;
 			}