Processing config file: D:\leidian\fluffos-master\fy2005\config.fluffos
living hash table size: invalid new value, resetting to default.
New Debug log location: "log/debug.log".
Execution root: D:\\leidian\\fluffos-master\\fy2005\\work
Initializing internal stuff ....
Event backend in use: win32
WARNING: Platform doesn't support eval limit!
Loading simul_efun file : /adm/obj/simul_efun
Loading master file: /adm/obj/master
*Warning: unable to open stat file domain_stats for reading.
*Warning: unable to open stat file author_stats for reading.

Loading preload files ...
/adm/daemons/securityd...
/adm/daemons/eventd...
/adm/daemons/virtuald...
/adm/daemons/cmd_d...
/adm/daemons/chinesed...
/adm/daemons/emoted...
/adm/daemons/aliasd...
/adm/daemons/fingerd...
/adm/daemons/channeld...
/adm/daemons/natured...
/adm/daemons/taskd...
/adm/daemons/coord...
/adm/daemons/whod...
/adm/daemons/logind...
/adm/daemons/voted...
/adm/daemons/itemd...
/adm/daemons/sceneryd...
/adm/daemons/moneyd...
/adm/daemons/annied...
/adm/daemons/pkd...
/std/char/npc_bas...
/std/char/npc_mid...
/std/char/npc_adv...
/adm/daemons/smartd...
/adm/daemons/spawnd...
/adm/daemons/brd...
/obj/void...
/adm/daemons/suifeng_d...
NAME: /p/residence/userroom/nerd1566785571.lpc
INHERITS:
      name                    fio    vio
      ----------------        ---    ---
	std/room/xroom.lpc        0      0
FUNCTIONS:
      name                      offset  mods   flags   fio  vio # locals  # args # def args
      ------------------------- ------  ----  -------  ---  --- --------  ------ ----------
   0: _query                         0   +m-  i-s----    0   0
   1: _delete                        0   +m-  i-s----    1   0
   2: _set                           0   +m-  i-s----    2   0
   3: query                          0   +--  i-s---v    3   0
   4: set_temp                       0   +--  i-s----    4   0
   5: query_default_object           0   +--  i-s----    5   0
   6: set_default_object             0   +--  i-s----    6   0
   7: query_with_slash               0   +--  i-s---v    7   0
   8: query_entire_dbase             0   +--  i-s----    8   0
   9: query_entire_temp_dbase        0   +--  i-s----    9   0
  10: add                            0   +--  i-s----   10   0
  11: set                            0   +--  i-s----   11   0
  12: set_with_slash                 0   +--  i-s----   12   0
  13: delete                         0   +--  i-s----   13   0
  14: query_temp                     0   +--  i-s---v   14   0
  15: delete_temp                    0   +--  i-s----   15   0
  16: add_temp                       0   +--  i-s----   16   0
  17: clean_up                       0   +--  i-s----   17   0
  18: create                         0   +--  --s-a--                   0       0          0 
  19: reset                          0   +--  i-s-a--   67   0
  20: setup                          0   +--  i-s----   20   0
  21: set_vector                     0   +--  i-spa--   38   0
  22: set_temp_vector                0   +--  i-spa--   39   0
  23: make_inventory                 0   +--  i-s----   23   0
  24: usr_in                         0   +--  i-s----   24   0
  25: long                           0   +--  i-s----   25   0
  26: valid_leave                    0   +--  i-s----   26   0
  27: query_max_encumbrance          0   +--  i-s----   27   0
  28: query                          0   +--  i-s-a-v    3   0
  29: set_temp                       0   +--  i-s-a--    4   0
  30: query_entire_dbase             0   +--  i-s-a--    8   0
  31: query_entire_temp_dbase        0   +--  i-s-a--    9   0
  32: add                            0   +--  i-s-a--   10   0
  33: set                            0   +--  i-s-a--   11   0
  34: delete                         0   +--  i-s-a--   13   0
  35: query_temp                     0   +--  i-s-a-v   14   0
  36: delete_temp                    0   +--  i-s-a--   15   0
  37: add_temp                       0   +--  i-s-a--   16   0
  38: set_vector                     0   +--  i-sp---   38   0
  39: set_temp_vector                0   +--  i-sp---   39   0
  40: get_highest_skill_level        0   +--  i-s----   40   0
  41: check_legitimate_state         0   +--  i-s----   41   0
  42: annie_attcp                    0   +--  i-s----   42   0
  43: clear_items                    0   +--  i-s----   43   0
  44: ngstr_chcol                    0   +--  i-s----   44   0
  45: mutant                         0   +--  i-s----   45   0
  46: annie_mimic                    0   +--  i-s----   46   0
  47: block_account                  0   +--  i-s----   47   0
  48: annie_abilitycp                0   +--  i-s----   48   0
  49: add_qitems                     0   +--  i-s----   49   0
  50: nrstr                          0   +--  i-s----   50   0
  51: mapping_copy                   0   +--  i-s----   51   0
  52: query_qitems                   0   +--  i-s----   52   0
  53: set_items                      0   +--  i-s----   53   0
  54: ngstr_fit                      0   +--  i-s----   54   0
  55: team_check                     0   +--  i-s----   55   0
  56: ngstr_uncolor                  0   +--  i-s----   56   0
  57: ngstr                          0   +--  i-s----   57   0
  58: tell_team                      0   +--  i-s----   58   0
  59: ngstr_pad                      0   +--  i-s----   59   0
  60: annie_skillcp                  0   +--  i-s----   60   0
  61: ngstr_cols                     0   +--  i-s----   61   0
  62: annie_itemmimic                0   +--  i-s----   62   0
  63: input_description              0   +--  i-s----   63   0
  64: save                           0   +--  i-s----   64   0
  65: restore                        0   +--  i-s----   65   0
  66: query_save_file                0   +--  i-s----   66   0
  67: reset                          0   +--  i-s----   67   0
  68: init                           0   +--  i-s----   68   0
  69: pay_time                       0   +--  i-s----   69   0
  70: is_owner                       0   +--  i-s----   70   0
  71: restore_item                   0   +--  i-s----   71   0
  72: do_help                        0   +--  i-s----   72   0
  73: do_invite                      0   +--  i-s----   73   0
  74: do_share                       0   +--  i-s----   74   0
  75: do_here                        0   +--  i-s----   75   0
  76: do_payoff                      0   +--  i-s----   76   0
  77: do_remodel                     0   +--  i-s----   77   0
  78: do_destroy                     0   +--  i-s----   78   0
  79: do_exercise                    0   +--  i-s----   79   0
  80: query_tax                      0   +--  i-s----   80   0
  81: query_stax                     0   +--  i-s----   81   0
  82: reset_pay_time                 0   +--  i-s----   82   0
  83: balance_g                      0   +--  i-s----   83   0
  84: balance_s                      0   +--  i-s----   84   0
  85: valid_enter                    0   +--  i-s----   85   0
  86: do_setowner                    0   +--  i-s----   86   0
  87: set_back                       0   +--  i-s----   87   0
  88: enter_desc                     0   +--  i-s----   88   0
  89: check_legal_long               0   +--  i-s----   89   0
  90: create                         0   +--  --s----                   0       0          0 
  91: #global_init#                  1   h--  --s----                   0       0          0 

;;; p/residence/userroom/nerd1566785571.lpc

Globals:
   0: dbase
   1: tmp_dbase
   2: default_ob
   3: items
VARIABLES defined:
STRINGS:
   0: p/residence/userroom/nerd1566785
   1: include/globals.h
   2: include/path.h
   3: include/ansi.h
   4: short
   5: 储藏室
   6: long
   7: \n　　　　玉盘银冷桂花
   8: exits
   9: out
  10: /p/residence/smile1.lpc
  11: objects
  12: coor/x
  13: coor/y
  14: coor/z
  15: room_flag
  16: owner
  17: nerd
  18: class
  19: annie
  20: timestamp
  21: 1
  22: timestamp2
  23: 1566785571
  24: free_space
  25: basic_tax
  26: basic_score_tax
  27: tree
  28: total_gold
  29: total_score
DISASSEMBLY:

;; Function: public void create()
0000:  02 02 04 05               F_PUSH                             ; push string 4, string 5
0004:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0008:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:24
0009:  02 02 06 07               F_PUSH                             ; push string 6, string 7
000d:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0011:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:30
0012:  02 03 08 09 0A            F_PUSH                             ; push string 8, string 9, string 10
0017:  12 02 00                  aggregate_assoc                    ; 2
001a:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
001e:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:33
001f:  0E 0B                     short_string                       ; "objects"
0021:  12 00 00                  aggregate_assoc                    ; 0
0024:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0028:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:35
0029:  0E 0C                     short_string                       ; "coor/x"
002b:  0C 14                     -byte                              ; -20
002d:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0031:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:36
0032:  0E 0D                     short_string                       ; "coor/y"
0034:  0C 1E                     -byte                              ; -30
0036:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
003a:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:37
003b:  02 02 0E 68               F_PUSH                             ; push string 14, number 40
003f:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0043:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:38
0044:  02 02 0F 61               F_PUSH                             ; push string 15, number 33
0048:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
004c:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:39
004d:  02 02 10 11               F_PUSH                             ; push string 16, string 17
0051:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0055:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:40
0056:  02 02 12 13               F_PUSH                             ; push string 18, string 19
005a:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
005e:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:41
005f:  02 02 14 15               F_PUSH                             ; push string 20, string 21
0063:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0067:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:42
0068:  02 02 16 17               F_PUSH                             ; push string 22, string 23
006c:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0070:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:43
0071:  02 02 18 44               F_PUSH                             ; push string 24, number 4
0075:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0079:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:44
007a:  0E 19                     short_string                       ; "basic_tax"
007c:  08 60 04                  F_SHORT_INT                        ; short 1120
007f:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0083:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:45
0084:  0E 1A                     short_string                       ; "basic_score_tax"
0086:  08 90 01                  F_SHORT_INT                        ; short 400
0089:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
008d:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:46
008e:  02 02 1B 41               F_PUSH                             ; push string 27, number 1
0092:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0096:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:47
0097:  0E 1C                     short_string                       ; "total_gold"
0099:  08 B0 04                  F_SHORT_INT                        ; short 1200
009c:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
00a0:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:48
00a1:  0E 1D                     short_string                       ; "total_score"
00a3:  08 30 02                  F_SHORT_INT                        ; short 560
00a6:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
00aa:  01                        pop                                ; 
; p/residence/userroom/nerd1566785571.lpc:49
00ab:  2D 14 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; setup, pushed_args:0
00af:  01                        pop                                ; 
00b0:  30                        return_zero                        ; 
; p/residence/userroom/nerd1566785571.lpc:50

;; Function: hidden void #global_init#()
00b1:  2E 00 5A 00 00            call_inherited                     ;             std/room/xroom.lpc::#global_init#    90
00b6:  01                        pop                                ; 
00b7:  30                        return_zero                        ; 
; p/residence/userroom/nerd1566785571.lpc:20

;;;  *** Line Number Info ***

absolute line -> (file, line) table:
0 lines from 1 [p/residence/userroom/nerd1566785571.lpc]
15 lines from 2 [include/globals.h]
65 lines from 3 [include/path.h]
181 lines from 2 [include/globals.h]
18 lines from 1 [p/residence/userroom/nerd1566785571.lpc]
77 lines from 4 [include/ansi.h]
35 lines from 1 [p/residence/userroom/nerd1566785571.lpc]

address -> absolute line table:
0000-0008: 362
0009-0011: 368
0012-001e: 371
001f-0028: 373
0029-0031: 374
0032-003a: 375
003b-0043: 376
0044-004c: 377
004d-0055: 378
0056-005e: 379
005f-0067: 380
0068-0070: 381
0071-0079: 382
007a-0083: 383
0084-008d: 384
008e-0096: 385
0097-00a0: 386
00a1-00aa: 387
00ab-00b0: 388
00b1-00b7: 358

;;; std/room/xroom.lpc

Globals:
   0: dbase
   1: tmp_dbase
   2: default_ob
   3: items
VARIABLES defined:
STRINGS:
   0: std/room/xroom.lpc
   1: include/globals.h
   2: include/path.h
   3: include/ansi.h
   4: temp_owner
   5: owner
   6: couple
   7: marry
   8: query
   9: 出走
  10: room_flag
  11: valid_startroom
  12: NONPC
  13: no_fight
  14: no_magic
  15: outdoors
  16: residence
  17: open_area
  18: already_loaded
  19: perma_exist
  20: do_help
  21: roomhelp
  22: do_invite
  23: invite
  24: do_share
  25: share
  26: do_here
  27: here
  28: do_payoff
  29: payoff
  30: do_remodel
  31: remodel
  32: do_destroy
  33: destroy_room
  34: input_description
  35: renovate
  36: do_exercise
  37: fight_switch
  38: /adm/daemons/brd
  39: 在此房间里可执行的命
  40: total_gold
  41: last_pay_time
  42: timestamp2
  43: already_pay
  44: total_score
  45: already_spay
  46: id
  47: 这么大的事儿，要主人
  48: 改变房屋打斗属性每小
  49: ）\n
  50: 1
  51: [1;31m该房间设定为可打
  52: [1;31m该房间设定为可使
  53: 0
  54: [1;32m该房间设定为不可
  55: [1;32m该房间设定为不可
  56: 参数只能是１（允许打
  57: 想替别人付钱啊？\n
  58: basic_tax
  59: 你的屋子已经交清存款
  60: payoff contract
  61: 为防止误操作，请先去
  62: deposit
  63: 你在南宫家没有存够
  64: 两银子。\n
  65: score
  66: 你的评价不足
  67: 点！\n
  68: add
  69: 你付出了
  70: 两白银，
  71: 点评价。\n
  72: charged
  73: annie_log_buildroom
  74: Payoff: [%s] %s(%s)的自建房
  75: name
  76: short
  77: 恭喜，你的屋子已经付
  78: 这事儿只有主人才能做
  79: 先把这间屋子的贷款交
  80: remodel contract
  81: 为防止误操作，请先去
  82: 你的屋子已经具有最大
  83: %d
  84: 格式：remodel 数字，数字
  85: Remodel后的数字必须比你
  86: ）大，比６小。\n
  87: 房屋更新失败，请立即
  88: 两金子。\n
  89: Payoff: [%s] %s(%s)的自建房
  90: set
  91: free_space
  92: save
  93: 两黄金，
  94: 房屋改建成功！！改建
  95: \n╭═════════
  96: 　　　　　　　　　　
  97: 
  98: [2;37;0m(
  99: [36m室外
 100: [36m室内
 101: [2;37;0m)
 102: [2;37;0m
 103: ║
 104: ║\n
 105: 　建造於[33m
 106: /cmds/usr/uptime
 107: 
 108: chinese_time
 109: ║ ═════════
 110:  ◆主人：[36m
 111: [2;37;0m ◆主人：
 112: [36m
 113: 无
 114: [2;37;0m ◆借用者：
 115: [36m特性关闭
 116: ║╭────────
 117: ║│　　　　　　　　
 118: 可用空间：[36m
 119: ║│
 120: │║\n
 121: 银两征收：[36m
 122: /adm/daemons/chinesed
 123: chinese_number
 124: 两
 125: [2;37;0m/周 评价征收：
 126: 点
 127: [2;37;0m/周
 128: 上次缴纳：[36m
 129: 下次缴纳：[36m
 130: [1;31m（已欠款
 131: expired
 132: 期）
 133: 累计已交：[36m
 134: [2;37;0m银子
 135: [36m 
 136: [2;37;0m评价　　可用空间
 137: ║╰────────
 138: ║ ◆房产总额：[36m
 139: [2;37;0m两黄金
 140: /
 141: [2;37;0m点评价
 142: 风云２００５  ║\n
 143: ╰═════════
 144: invite/
 145: [37m你在
 146: 周内未交维持费用。\n
 147: [37m系统一次最多只征收
 148: （你在南宫家没有存够
 149: 两银子。）\n
 150: （你的评价不足
 151: 点！）\n
 152: [33m你补交了所欠的维持
 153: 两银子、
 154: 点评价）。\n
 155: [1;31m恭喜，你的屋子已
 156: 该房屋欠款未请，暂时
 157: 你把
 158: 从客人名单上删去了。\n
 159: 你邀请
 160: 来你的房间。\n
 161: [37m	　　邀请名单：\n[2;
 162: [1;31m[30m──────
 163: 没有邀请任何人。\n
 164: \n
 165: 你将房间的主人暂时设
 166: 。\n
 167: set_back
 168: 你只能与你的另一半分
 169: 设置指令为：share <id>。\n
 170: 将自己设置为第二个主
 171: 你只能设置一次房间的
 172: 第二主人必须在其在线
 173: 你添加了房间的第二主
 174: 将你设置为
 175: 房间的第二主人。\n
 176: /data/user/%c/%s/%s
 177: .room
 178: timestamp
 179: .o
 180: query_save_file
 181: item_list
 182: item_list/
 183: move
 184: no_reset
 185: restore_item
 186: item_type
 187: reset_item_list
 188: 对不起，中文描述必须
 189: 对不起，中文描述不能
 190: 对不起，描述必需是中
 191: 你的银行存款不够，至
 192: long
 193: renovation
 194: renovation_time
 195: 房屋描述修改成功！！
 196: 装修屋子的间隔时间不
 197: edit
DISASSEMBLY:

;; Function: public int is_owner(string)
0000:  02 02 C0 04               F_PUSH                             ; push local 0, string 4
0004:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0008:  13 04 00                  branch_ne                          ; 0004 (000d)
; std/room/xroom.lpc:16
000b:  10                        const1                             ; 
000c:  2F                        return                             ; 
; std/room/xroom.lpc:17
000d:  02 02 C0 05               F_PUSH                             ; push local 0, string 5
0011:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0015:  13 04 00                  branch_ne                          ; 0004 (001a)
; std/room/xroom.lpc:18
0018:  10                        const1                             ; 
0019:  2F                        return                             ; 
; std/room/xroom.lpc:19
001a:  02 02 C0 06               F_PUSH                             ; push local 0, string 6
001e:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0022:  13 2D 00                  branch_ne                          ; 002d (0050)
; std/room/xroom.lpc:23
0025:  40 00                     local                              ; LV0
0027:  04 C7 00                  F_EFUN1                            ; EFUN: find_player(199)
002a:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:24
002c:  40 01                     local                              ; LV1
002e:  18 03 00                  branch_when_non_zero               ; 0003 (0032)
0031:  30                        return_zero                        ; 
; std/room/xroom.lpc:25
0032:  02 03 C1 08 07            F_PUSH                             ; push local 1, string 8, string 7
0037:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
003b:  0E 05                     short_string                       ; "owner"
003d:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0041:  16 0C 00                  branch_eq                          ; 000c (004e)
; std/room/xroom.lpc:26
0044:  02 02 06 09               F_PUSH                             ; push string 6, string 9
0048:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
004c:  01                        pop                                ; 
; std/room/xroom.lpc:27
004d:  30                        return_zero                        ; 
; std/room/xroom.lpc:28
004e:  10                        const1                             ; 
004f:  2F                        return                             ; 
; std/room/xroom.lpc:30
0050:  30                        return_zero                        ; 
0051:  30                        return_zero                        ; 
; std/room/xroom.lpc:32

;; Function: public void init()
0052:  0E 0A                     short_string                       ; "room_flag"
0054:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0058:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:38
005a:  02 02 C0 41               F_PUSH                             ; push local 0, number 1
005e:  74                        &                                  ; 
005f:  17 0B 00                  branch_when_zero                   ; 000b (006b)
0062:  02 02 0B 41               F_PUSH                             ; push string 11, number 1
0066:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
006a:  01                        pop                                ; 
; std/room/xroom.lpc:39
006b:  02 02 C0 42               F_PUSH                             ; push local 0, number 2
006f:  74                        &                                  ; 
0070:  17 0B 00                  branch_when_zero                   ; 000b (007c)
0073:  02 02 0C 41               F_PUSH                             ; push string 12, number 1
0077:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
007b:  01                        pop                                ; 
; std/room/xroom.lpc:40
007c:  02 02 C0 44               F_PUSH                             ; push local 0, number 4
0080:  74                        &                                  ; 
0081:  17 0B 00                  branch_when_zero                   ; 000b (008d)
0084:  02 02 0D 41               F_PUSH                             ; push string 13, number 1
0088:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
008c:  01                        pop                                ; 
; std/room/xroom.lpc:41
008d:  02 02 C0 48               F_PUSH                             ; push local 0, number 8
0091:  74                        &                                  ; 
0092:  17 0B 00                  branch_when_zero                   ; 000b (009e)
0095:  02 02 0E 41               F_PUSH                             ; push string 14, number 1
0099:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
009d:  01                        pop                                ; 
; std/room/xroom.lpc:42
009e:  02 02 C0 50               F_PUSH                             ; push local 0, number 16
00a2:  74                        &                                  ; 
00a3:  17 0B 00                  branch_when_zero                   ; 000b (00af)
00a6:  02 02 0F 10               F_PUSH                             ; push string 15, string 16
00aa:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
00ae:  01                        pop                                ; 
; std/room/xroom.lpc:43
00af:  3D 00                     transfer_local                     ; LV0
00b1:  0B 20                     byte                               ; 32
00b3:  74                        &                                  ; 
00b4:  17 0B 00                  branch_when_zero                   ; 000b (00c0)
00b7:  02 02 11 41               F_PUSH                             ; push string 17, number 1
00bb:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
00bf:  01                        pop                                ; 
; std/room/xroom.lpc:44
00c0:  0E 12                     short_string                       ; "already_loaded"
00c2:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
00c6:  18 1E 00                  branch_when_non_zero               ; 001e (00e5)
; std/room/xroom.lpc:46
00c9:  2D 41 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; restore, pushed_args:0
00cd:  01                        pop                                ; 
; std/room/xroom.lpc:47
00ce:  2D 47 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; restore_item, pushed_args:0
00d2:  01                        pop                                ; 
; std/room/xroom.lpc:48
00d3:  02 02 12 41               F_PUSH                             ; push string 18, number 1
00d7:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
00db:  01                        pop                                ; 
; std/room/xroom.lpc:49
00dc:  02 02 13 41               F_PUSH                             ; push string 19, number 1
00e0:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
00e4:  01                        pop                                ; 
; std/room/xroom.lpc:50
00e5:  02 02 14 15               F_PUSH                             ; push string 20, string 21
00e9:  05 BC 00                  F_EFUN2                            ; EFUN: add_action(188)
; std/room/xroom.lpc:53
00ec:  02 02 16 17               F_PUSH                             ; push string 22, string 23
00f0:  05 BC 00                  F_EFUN2                            ; EFUN: add_action(188)
; std/room/xroom.lpc:54
00f3:  02 02 18 19               F_PUSH                             ; push string 24, string 25
00f7:  05 BC 00                  F_EFUN2                            ; EFUN: add_action(188)
; std/room/xroom.lpc:56
00fa:  02 02 1A 1B               F_PUSH                             ; push string 26, string 27
00fe:  05 BC 00                  F_EFUN2                            ; EFUN: add_action(188)
; std/room/xroom.lpc:57
0101:  02 02 1C 1D               F_PUSH                             ; push string 28, string 29
0105:  05 BC 00                  F_EFUN2                            ; EFUN: add_action(188)
; std/room/xroom.lpc:59
0108:  02 02 1E 1F               F_PUSH                             ; push string 30, string 31
010c:  05 BC 00                  F_EFUN2                            ; EFUN: add_action(188)
; std/room/xroom.lpc:60
010f:  02 02 20 21               F_PUSH                             ; push string 32, string 33
0113:  05 BC 00                  F_EFUN2                            ; EFUN: add_action(188)
; std/room/xroom.lpc:61
0116:  02 02 22 23               F_PUSH                             ; push string 34, string 35
011a:  05 BC 00                  F_EFUN2                            ; EFUN: add_action(188)
; std/room/xroom.lpc:62
011d:  02 02 24 25               F_PUSH                             ; push string 36, string 37
0121:  05 BC 00                  F_EFUN2                            ; EFUN: add_action(188)
0124:  30                        return_zero                        ; 
; std/room/xroom.lpc:63

;; Function: public int do_destroy()
0125:  0F                        const0                             ; 
0126:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
0129:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:70
012b:  40 00                     local                              ; LV0
012d:  04 34 01                  F_EFUN1                            ; EFUN: wizardp(308)
0130:  79                        !                                  ; 
0131:  25 0B 00                  ||                                 ; 000b (013d)
0134:  40 00                     local                              ; LV0
0136:  7E 15 00 01               simul_efun                         ; "wiz_level" args: 1
013a:  0B 04                     byte                               ; 4
013c:  34                        <                                  ; 
013d:  17 03 00                  branch_when_zero                   ; 0003 (0141)
; std/room/xroom.lpc:72
0140:  30                        return_zero                        ; 
; std/room/xroom.lpc:73
0141:  02 02 26 21               F_PUSH                             ; push string 38, string 33
0145:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0149:  01                        pop                                ; 
; std/room/xroom.lpc:76
014a:  10                        const1                             ; 
014b:  2F                        return                             ; 
014c:  30                        return_zero                        ; 
; std/room/xroom.lpc:77

;; Function: public int do_help()
014d:  0E 27                     short_string                       ; "在此房间里可执行的"
014f:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0153:  01                        pop                                ; 
; std/room/xroom.lpc:114
0154:  10                        const1                             ; 
0155:  2F                        return                             ; 
; std/room/xroom.lpc:115

;; Function: public int query_tax()
0156:  0E 28                     short_string                       ; "total_gold"
0158:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
015c:  0B 0E                     byte                               ; 14
015e:  71                        *                                  ; 
015f:  0B 0F                     byte                               ; 15
0161:  72                        /                                  ; 
0162:  2F                        return                             ; 
; std/room/xroom.lpc:120

;; Function: public int query_stax()
0163:  0E 28                     short_string                       ; "total_gold"
0165:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0169:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:126
016b:  3D 00                     transfer_local                     ; LV0
016d: switch
      type: f2 table: 019a-01cc deflt: 0197
0175:  10                        const1                             ; 
0176:  6B 01                     (void)assign_local                 ; LV1
0178:  19 53 00                  branch                             ; 0053 (01cc)
; std/room/xroom.lpc:129
017b:  0B 02                     byte                               ; 2
017d:  6B 01                     (void)assign_local                 ; LV1
017f:  19 4C 00                  branch                             ; 004c (01cc)
; std/room/xroom.lpc:130
0182:  0B 03                     byte                               ; 3
0184:  6B 01                     (void)assign_local                 ; LV1
0186:  19 45 00                  branch                             ; 0045 (01cc)
; std/room/xroom.lpc:131
0189:  0B 04                     byte                               ; 4
018b:  6B 01                     (void)assign_local                 ; LV1
018d:  19 3E 00                  branch                             ; 003e (01cc)
; std/room/xroom.lpc:132
0190:  0B 05                     byte                               ; 5
0192:  6B 01                     (void)assign_local                 ; LV1
0194:  19 37 00                  branch                             ; 0037 (01cc)
0197:  19 34 00                  branch                             ; 0034 (01cc)
; std/room/xroom.lpc:133
      switch table (for 016d)
	96  	0175
	12c 	017b
	258 	0182
	4b0 	0189
	960 	0190
; std/room/xroom.lpc:128
01cc:  3D 01                     transfer_local                     ; LV1
01ce:  0B 64                     byte                               ; 100
01d0:  71                        *                                  ; 
01d1:  2F                        return                             ; 
01d2:  30                        return_zero                        ; 
; std/room/xroom.lpc:136

;; Function: public int pay_time()
01d3:  0E 29                     short_string                       ; "last_pay_time"
01d5:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
01d9:  17 0C 00                  branch_when_zero                   ; 000c (01e6)
; std/room/xroom.lpc:141
01dc:  0E 29                     short_string                       ; "last_pay_time"
01de:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
01e2:  2F                        return                             ; 
01e3:  19 0D 00                  branch                             ; 000d (01f1)
; std/room/xroom.lpc:142
01e6:  0E 2A                     short_string                       ; "timestamp2"
01e8:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
01ec:  7E 00 00 01               simul_efun                         ; "atoi" args: 1
01f0:  2F                        return                             ; 
01f1:  30                        return_zero                        ; 
; std/room/xroom.lpc:144

;; Function: public int reset_pay_time()
01f2:  03 04 01                  F_EFUN0                            ; EFUN: time(260)
01f5:  2D 45 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; pay_time, pushed_args:0
01f9:  70                        subtract                           ; 
01fa:  09 80 51 01 00 00 00 00 00  number                             ; 86400
0203:  72                        /                                  ; 
0204:  0B 07                     byte                               ; 7
0206:  72                        /                                  ; 
0207:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:150
0209:  0E 29                     short_string                       ; "last_pay_time"
020b:  2D 45 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; pay_time, pushed_args:0
020f:  3D 00                     transfer_local                     ; LV0
0211:  09 80 51 01 00 00 00 00 00  number                             ; 86400
021a:  71                        *                                  ; 
021b:  0B 07                     byte                               ; 7
021d:  71                        *                                  ; 
021e:  6F                        +                                  ; 
021f:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0223:  01                        pop                                ; 
; std/room/xroom.lpc:151
0224:  0E 29                     short_string                       ; "last_pay_time"
0226:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
022a:  2F                        return                             ; 
022b:  30                        return_zero                        ; 
; std/room/xroom.lpc:152

;; Function: public int balance_g()
022c:  0E 28                     short_string                       ; "total_gold"
022e:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0232:  0B 64                     byte                               ; 100
0234:  71                        *                                  ; 
0235:  0E 2B                     short_string                       ; "already_pay"
0237:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
023b:  70                        subtract                           ; 
023c:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:158
023e:  02 02 C0 40               F_PUSH                             ; push local 0, number 0
0242:  33                        <=                                 ; 
0243:  17 06 00                  branch_when_zero                   ; 0006 (024a)
; std/room/xroom.lpc:160
0246:  30                        return_zero                        ; 
0247:  19 05 00                  branch                             ; 0005 (024d)
; std/room/xroom.lpc:161
024a:  40 00                     local                              ; LV0
024c:  2F                        return                             ; 
024d:  30                        return_zero                        ; 
; std/room/xroom.lpc:163

;; Function: public int balance_s()
024e:  0E 2C                     short_string                       ; "total_score"
0250:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0254:  0E 2D                     short_string                       ; "already_spay"
0256:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
025a:  70                        subtract                           ; 
025b:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:170
025d:  02 02 C0 40               F_PUSH                             ; push local 0, number 0
0261:  33                        <=                                 ; 
0262:  17 06 00                  branch_when_zero                   ; 0006 (0269)
; std/room/xroom.lpc:172
0265:  30                        return_zero                        ; 
0266:  19 05 00                  branch                             ; 0005 (026c)
; std/room/xroom.lpc:173
0269:  40 00                     local                              ; LV0
026b:  2F                        return                             ; 
026c:  30                        return_zero                        ; 
; std/room/xroom.lpc:175

;; Function: public int do_exercise(string)
026d:  0F                        const0                             ; 
026e:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
0271:  6B 02                     (void)assign_local                 ; LV2
; std/room/xroom.lpc:231
0273:  02 03 C2 08 2E            F_PUSH                             ; push local 2, string 8, string 46
0278:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
027c:  2D 46 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; is_owner, pushed_args:1
0280:  18 09 00                  branch_when_non_zero               ; 0009 (028a)
; std/room/xroom.lpc:233
0283:  0E 2F                     short_string                       ; "这么大的事儿，要主"
0285:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0288:  0F                        const0                             ; 
0289:  2F                        return                             ; 
; std/room/xroom.lpc:234
028a:  0E 25                     short_string                       ; "fight_switch"
028c:  2D 0E 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query_temp, pushed_args:1
0290:  08 10 0E                  F_SHORT_INT                        ; short 3600
0293:  6F                        +                                  ; 
0294:  03 04 01                  F_EFUN0                            ; EFUN: time(260)
0297:  70                        subtract                           ; 
0298:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:236
029a:  02 02 C1 40               F_PUSH                             ; push local 1, number 0
029e:  15 11 00                  branch_le                          ; 0011 (02b0)
; std/room/xroom.lpc:237
02a1:  02 03 30 C1 7C            F_PUSH                             ; push string 48, local 1, number 60
02a6:  72                        /                                  ; 
02a7:  6F                        +                                  ; 
02a8:  0E 31                     short_string                       ; "）\n"
02aa:  6F                        +                                  ; 
02ab:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
02ae:  0F                        const0                             ; 
02af:  2F                        return                             ; 
; std/room/xroom.lpc:238
02b0:  02 02 C0 32               F_PUSH                             ; push local 0, string 50
02b4:  13 32 00                  branch_ne                          ; 0032 (02e7)
; std/room/xroom.lpc:240
02b7:  02 02 0D 40               F_PUSH                             ; push string 13, number 0
02bb:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
02bf:  01                        pop                                ; 
; std/room/xroom.lpc:241
02c0:  02 02 0E 40               F_PUSH                             ; push string 14, number 0
02c4:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
02c8:  01                        pop                                ; 
; std/room/xroom.lpc:242
02c9:  02 02 33 C2               F_PUSH                             ; push string 51, local 2
02cd:  7E 17 00 02               simul_efun                         ; "message_vision" args: 2
02d1:  01                        pop                                ; 
; std/room/xroom.lpc:243
02d2:  02 02 34 C2               F_PUSH                             ; push string 52, local 2
02d6:  7E 17 00 02               simul_efun                         ; "message_vision" args: 2
02da:  01                        pop                                ; 
; std/room/xroom.lpc:244
02db:  0E 25                     short_string                       ; "fight_switch"
02dd:  03 04 01                  F_EFUN0                            ; EFUN: time(260)
02e0:  2D 04 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
02e4:  01                        pop                                ; 
; std/room/xroom.lpc:245
02e5:  10                        const1                             ; 
02e6:  2F                        return                             ; 
; std/room/xroom.lpc:246
02e7:  3D 00                     transfer_local                     ; LV0
02e9:  0E 35                     short_string                       ; "0"
02eb:  13 32 00                  branch_ne                          ; 0032 (031e)
; std/room/xroom.lpc:249
02ee:  02 02 0D 41               F_PUSH                             ; push string 13, number 1
02f2:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
02f6:  01                        pop                                ; 
; std/room/xroom.lpc:250
02f7:  02 02 0E 41               F_PUSH                             ; push string 14, number 1
02fb:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
02ff:  01                        pop                                ; 
; std/room/xroom.lpc:251
0300:  02 02 36 C2               F_PUSH                             ; push string 54, local 2
0304:  7E 17 00 02               simul_efun                         ; "message_vision" args: 2
0308:  01                        pop                                ; 
; std/room/xroom.lpc:252
0309:  02 02 37 C2               F_PUSH                             ; push string 55, local 2
030d:  7E 17 00 02               simul_efun                         ; "message_vision" args: 2
0311:  01                        pop                                ; 
; std/room/xroom.lpc:253
0312:  0E 25                     short_string                       ; "fight_switch"
0314:  03 04 01                  F_EFUN0                            ; EFUN: time(260)
0317:  2D 04 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
031b:  01                        pop                                ; 
; std/room/xroom.lpc:254
031c:  10                        const1                             ; 
031d:  2F                        return                             ; 
; std/room/xroom.lpc:255
031e:  0E 38                     short_string                       ; "参数只能是１（允许"
0320:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0323:  0F                        const0                             ; 
0324:  2F                        return                             ; 
0325:  30                        return_zero                        ; 
; std/room/xroom.lpc:258

;; Function: public int do_payoff()
0326:  0F                        const0                             ; 
0327:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
032a:  6B 03                     (void)assign_local                 ; LV3
; std/room/xroom.lpc:264
032c:  02 03 C3 08 2E            F_PUSH                             ; push local 3, string 8, string 46
0331:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0335:  2D 46 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; is_owner, pushed_args:1
0339:  18 09 00                  branch_when_non_zero               ; 0009 (0343)
; std/room/xroom.lpc:267
033c:  0E 39                     short_string                       ; "想替别人付钱啊？\n"
033e:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0341:  0F                        const0                             ; 
0342:  2F                        return                             ; 
; std/room/xroom.lpc:268
0343:  2D 50 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; query_tax, pushed_args:0
0347:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:270
0349:  2D 51 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; query_stax, pushed_args:0
034d:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:271
034f:  0E 3A                     short_string                       ; "basic_tax"
0351:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0355:  0C 01                     -byte                              ; -1
0357:  13 09 00                  branch_ne                          ; 0009 (0361)
; std/room/xroom.lpc:273
035a:  0E 3B                     short_string                       ; "你的屋子已经交清存"
035c:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
035f:  0F                        const0                             ; 
0360:  2F                        return                             ; 
; std/room/xroom.lpc:274
0361:  02 02 3C C3               F_PUSH                             ; push string 60, local 3
0365:  05 BA 00                  F_EFUN2                            ; EFUN: present(186)
0368:  6C 04                     assign_local                       ; LV4
036a:  04 E7 00                  F_EFUN1                            ; EFUN: objectp(231)
036d:  18 09 00                  branch_when_non_zero               ; 0009 (0377)
; std/room/xroom.lpc:276
0370:  0E 3D                     short_string                       ; "为防止误操作，请先"
0372:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0375:  0F                        const0                             ; 
0376:  2F                        return                             ; 
; std/room/xroom.lpc:277
0377:  2D 53 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; balance_g, pushed_args:0
037b:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:279
037d:  2D 54 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; balance_s, pushed_args:0
0381:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:280
0383:  40 00                     local                              ; LV0
0385:  79                        !                                  ; 
0386:  26 05 00                  &&                                 ; 0005 (038c)
0389:  40 01                     local                              ; LV1
038b:  79                        !                                  ; 
038c:  17 09 00                  branch_when_zero                   ; 0009 (0396)
; std/room/xroom.lpc:282
038f:  0E 3B                     short_string                       ; "你的屋子已经交清存"
0391:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0394:  0F                        const0                             ; 
0395:  2F                        return                             ; 
; std/room/xroom.lpc:283
0396:  0F                        const0                             ; 
0397:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
039a:  02 02 08 3E               F_PUSH                             ; push string 8, string 62
039e:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
03a2:  0B 64                     byte                               ; 100
03a4:  72                        /                                  ; 
03a5:  6B 02                     (void)assign_local                 ; LV2
; std/room/xroom.lpc:285
03a7:  3D 02                     transfer_local                     ; LV2
03a9:  40 00                     local                              ; LV0
03ab:  14 13 00                  branch_ge                          ; 0013 (03bf)
; std/room/xroom.lpc:286
03ae:  02 02 3F C0               F_PUSH                             ; push string 63, local 0
03b2:  7E 02 00 01               simul_efun                         ; "chinese_number" args: 1
03b6:  6F                        +                                  ; 
03b7:  0E 40                     short_string                       ; "两银子。\n"
03b9:  6F                        +                                  ; 
03ba:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
03bd:  0F                        const0                             ; 
03be:  2F                        return                             ; 
; std/room/xroom.lpc:287
03bf:  02 02 C3 08               F_PUSH                             ; push local 3, string 8
03c3:  0E 41                     short_string                       ; "score"
03c5:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
03c9:  40 01                     local                              ; LV1
03cb:  14 13 00                  branch_ge                          ; 0013 (03df)
; std/room/xroom.lpc:289
03ce:  0E 42                     short_string                       ; "你的评价不足"
03d0:  40 01                     local                              ; LV1
03d2:  7E 02 00 01               simul_efun                         ; "chinese_number" args: 1
03d6:  6F                        +                                  ; 
03d7:  0E 43                     short_string                       ; "点！\n"
03d9:  6F                        +                                  ; 
03da:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
03dd:  0F                        const0                             ; 
03de:  2F                        return                             ; 
; std/room/xroom.lpc:290
03df:  40 03                     local                              ; LV3
03e1:  0E 44                     short_string                       ; "add"
03e3:  02 02 3E C0               F_PUSH                             ; push string 62, local 0
03e7:  7A                        -                                  ; 
03e8:  0B 64                     byte                               ; 100
03ea:  71                        *                                  ; 
03eb:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
03ef:  01                        pop                                ; 
; std/room/xroom.lpc:292
03f0:  40 03                     local                              ; LV3
03f2:  0E 44                     short_string                       ; "add"
03f4:  0E 41                     short_string                       ; "score"
03f6:  40 01                     local                              ; LV1
03f8:  7A                        -                                  ; 
03f9:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
03fd:  01                        pop                                ; 
; std/room/xroom.lpc:293
03fe:  40 03                     local                              ; LV3
0400:  0E 45                     short_string                       ; "你付出了"
0402:  40 00                     local                              ; LV0
0404:  6F                        +                                  ; 
0405:  0E 46                     short_string                       ; "两白银，"
0407:  6F                        +                                  ; 
0408:  40 01                     local                              ; LV1
040a:  6F                        +                                  ; 
040b:  0E 47                     short_string                       ; "点评价。\n"
040d:  6F                        +                                  ; 
040e:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0412:  01                        pop                                ; 
; std/room/xroom.lpc:295
0413:  0E 2B                     short_string                       ; "already_pay"
0415:  3D 00                     transfer_local                     ; LV0
0417:  2D 0A 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; add, pushed_args:2
041b:  01                        pop                                ; 
; std/room/xroom.lpc:297
041c:  0E 2D                     short_string                       ; "already_spay"
041e:  3D 01                     transfer_local                     ; LV1
0420:  2D 0A 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; add, pushed_args:2
0424:  01                        pop                                ; 
; std/room/xroom.lpc:298
0425:  0E 48                     short_string                       ; "charged"
0427:  10                        const1                             ; 
0428:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
042c:  01                        pop                                ; 
; std/room/xroom.lpc:299
042d:  2D 54 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; balance_s, pushed_args:0
0431:  79                        !                                  ; 
0432:  26 07 00                  &&                                 ; 0007 (043a)
0435:  2D 53 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; balance_g, pushed_args:0
0439:  79                        !                                  ; 
043a:  17 4E 00                  branch_when_zero                   ; 004e (0489)
; std/room/xroom.lpc:301
043d:  0E 3A                     short_string                       ; "basic_tax"
043f:  0C 01                     -byte                              ; -1
0441:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0445:  01                        pop                                ; 
; std/room/xroom.lpc:302
0446:  0E 49                     short_string                       ; "annie_log_buildroom"
0448:  0E 4A                     short_string                       ; "Payoff: [%s] %s(%s)的自建"
; std/room/xroom.lpc:309
044a:  03 04 01                  F_EFUN0                            ; EFUN: time(260)
044d:  04 07 01                  F_EFUN1                            ; EFUN: ctime(263)
; std/room/xroom.lpc:305
0450:  02 02 C3 08               F_PUSH                             ; push local 3, string 8
0454:  0E 4B                     short_string                       ; "name"
0456:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
; std/room/xroom.lpc:306
045a:  02 03 C3 08 2E            F_PUSH                             ; push local 3, string 8, string 46
045f:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
; std/room/xroom.lpc:307
0463:  0E 4C                     short_string                       ; "short"
0465:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
; std/room/xroom.lpc:308
0469:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
046c:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
0470:  07 23 01 06               F_EFUNV                            ; EFUN: sprintf(291)
0474:  7E 07 00 02               simul_efun                         ; "log_file" args: 2
0478:  01                        pop                                ; 
; std/room/xroom.lpc:309
0479:  40 04                     local                              ; LV4
047b:  7E 10 00 01               simul_efun                         ; "destruct" args: 1
047f:  01                        pop                                ; 
; std/room/xroom.lpc:310
0480:  40 03                     local                              ; LV3
0482:  0E 4D                     short_string                       ; "恭喜，你的屋子已经"
0484:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0488:  01                        pop                                ; 
; std/room/xroom.lpc:311
0489:  2D 40 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; save, pushed_args:0
048d:  01                        pop                                ; 
; std/room/xroom.lpc:314
048e:  10                        const1                             ; 
048f:  2F                        return                             ; 
0490:  30                        return_zero                        ; 
; std/room/xroom.lpc:315

;; Function: public int do_remodel(string)
0491:  0F                        const0                             ; 
0492:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
0495:  6B 0C                     (void)assign_local                 ; LV12
; std/room/xroom.lpc:325
0497:  0E 28                     short_string                       ; "total_gold"
0499:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
049d:  6B 05                     (void)assign_local                 ; LV5
; std/room/xroom.lpc:327
049f:  0E 2C                     short_string                       ; "total_score"
04a1:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
04a5:  6B 07                     (void)assign_local                 ; LV7
; std/room/xroom.lpc:328
04a7:  40 05                     local                              ; LV5
04a9: switch
      type: f2 table: 04d6-0508 deflt: 04d3
04b1:  10                        const1                             ; 
04b2:  6B 01                     (void)assign_local                 ; LV1
04b4:  19 53 00                  branch                             ; 0053 (0508)
; std/room/xroom.lpc:331
04b7:  0B 02                     byte                               ; 2
04b9:  6B 01                     (void)assign_local                 ; LV1
04bb:  19 4C 00                  branch                             ; 004c (0508)
; std/room/xroom.lpc:332
04be:  0B 03                     byte                               ; 3
04c0:  6B 01                     (void)assign_local                 ; LV1
04c2:  19 45 00                  branch                             ; 0045 (0508)
; std/room/xroom.lpc:333
04c5:  0B 04                     byte                               ; 4
04c7:  6B 01                     (void)assign_local                 ; LV1
04c9:  19 3E 00                  branch                             ; 003e (0508)
; std/room/xroom.lpc:334
04cc:  0B 05                     byte                               ; 5
04ce:  6B 01                     (void)assign_local                 ; LV1
04d0:  19 37 00                  branch                             ; 0037 (0508)
04d3:  19 34 00                  branch                             ; 0034 (0508)
; std/room/xroom.lpc:335
      switch table (for 04a9)
	96  	04b1
	12c 	04b7
	258 	04be
	4b0 	04c5
	960 	04cc
; std/room/xroom.lpc:330
0508:  02 03 CC 08 2E            F_PUSH                             ; push local 12, string 8, string 46
050d:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0511:  2D 46 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; is_owner, pushed_args:1
0515:  18 09 00                  branch_when_non_zero               ; 0009 (051f)
; std/room/xroom.lpc:338
0518:  0E 4E                     short_string                       ; "这事儿只有主人才能"
051a:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
051d:  0F                        const0                             ; 
051e:  2F                        return                             ; 
; std/room/xroom.lpc:339
051f:  0E 3A                     short_string                       ; "basic_tax"
0521:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0525:  0C 01                     -byte                              ; -1
0527:  16 09 00                  branch_eq                          ; 0009 (0531)
; std/room/xroom.lpc:341
052a:  0E 4F                     short_string                       ; "先把这间屋子的贷款"
052c:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
052f:  0F                        const0                             ; 
0530:  2F                        return                             ; 
; std/room/xroom.lpc:342
0531:  0E 50                     short_string                       ; "remodel contract"
0533:  40 0C                     local                              ; LV12
0535:  05 BA 00                  F_EFUN2                            ; EFUN: present(186)
0538:  6C 0B                     assign_local                       ; LV11
053a:  04 E7 00                  F_EFUN1                            ; EFUN: objectp(231)
053d:  18 09 00                  branch_when_non_zero               ; 0009 (0547)
; std/room/xroom.lpc:344
0540:  0E 51                     short_string                       ; "为防止误操作，请先"
0542:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0545:  0F                        const0                             ; 
0546:  2F                        return                             ; 
; std/room/xroom.lpc:345
0547:  02 02 C1 45               F_PUSH                             ; push local 1, number 5
054b:  35                        >=                                 ; 
054c:  17 09 00                  branch_when_zero                   ; 0009 (0556)
; std/room/xroom.lpc:347
054f:  0E 52                     short_string                       ; "你的屋子已经具有最"
0551:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0554:  0F                        const0                             ; 
0555:  2F                        return                             ; 
; std/room/xroom.lpc:348
0556:  40 00                     local                              ; LV0
0558:  79                        !                                  ; 
0559:  25 0D 00                  ||                                 ; 000d (0567)
055c:  40 00                     local                              ; LV0
055e:  0E 53                     short_string                       ; "%d"
0560:  7F 01                     sscanf                             ; 1
0562:  41 02                     local_lvalue                       ; LV2
0564:  6A                        (void)assign                       ; 
0565:  10                        const1                             ; 
0566:  32                        !=                                 ; 
0567:  17 09 00                  branch_when_zero                   ; 0009 (0571)
; std/room/xroom.lpc:350
056a:  0E 54                     short_string                       ; "格式：remodel 数字，数"
056c:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
056f:  0F                        const0                             ; 
0570:  2F                        return                             ; 
; std/room/xroom.lpc:351
0571:  02 02 C2 C1               F_PUSH                             ; push local 2, local 1
0575:  33                        <=                                 ; 
0576:  25 07 00                  ||                                 ; 0007 (057e)
0579:  02 02 C2 45               F_PUSH                             ; push local 2, number 5
057d:  36                        >                                  ; 
057e:  17 0F 00                  branch_when_zero                   ; 000f (058e)
; std/room/xroom.lpc:353
0581:  0E 55                     short_string                       ; "Remodel后的数字必须比"
0583:  40 01                     local                              ; LV1
0585:  6F                        +                                  ; 
0586:  0E 56                     short_string                       ; "）大，比６小。\n"
0588:  6F                        +                                  ; 
0589:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
058c:  0F                        const0                             ; 
058d:  2F                        return                             ; 
; std/room/xroom.lpc:354
058e:  40 02                     local                              ; LV2
0590: switch
      type: fe table: 05e4-05f6 deflt: 05d6
0598:  0B 96                     byte                               ; 150
059a:  6B 06                     (void)assign_local                 ; LV6
059c:  0B 78                     byte                               ; 120
059e:  6B 08                     (void)assign_local                 ; LV8
05a0:  19 55 00                  branch                             ; 0055 (05f6)
; std/room/xroom.lpc:357
05a3:  08 2C 01                  F_SHORT_INT                        ; short 300
05a6:  6B 06                     (void)assign_local                 ; LV6
05a8:  0B F0                     byte                               ; 240
05aa:  6B 08                     (void)assign_local                 ; LV8
05ac:  19 49 00                  branch                             ; 0049 (05f6)
; std/room/xroom.lpc:358
05af:  08 58 02                  F_SHORT_INT                        ; short 600
05b2:  6B 06                     (void)assign_local                 ; LV6
05b4:  08 7C 01                  F_SHORT_INT                        ; short 380
05b7:  6B 08                     (void)assign_local                 ; LV8
05b9:  19 3C 00                  branch                             ; 003c (05f6)
; std/room/xroom.lpc:359
05bc:  08 B0 04                  F_SHORT_INT                        ; short 1200
05bf:  6B 06                     (void)assign_local                 ; LV6
05c1:  08 30 02                  F_SHORT_INT                        ; short 560
05c4:  6B 08                     (void)assign_local                 ; LV8
05c6:  19 2F 00                  branch                             ; 002f (05f6)
; std/room/xroom.lpc:360
05c9:  08 60 09                  F_SHORT_INT                        ; short 2400
05cc:  6B 06                     (void)assign_local                 ; LV6
05ce:  08 34 03                  F_SHORT_INT                        ; short 820
05d1:  6B 08                     (void)assign_local                 ; LV8
05d3:  19 22 00                  branch                             ; 0022 (05f6)
; std/room/xroom.lpc:361
05d6:  40 0C                     local                              ; LV12
05d8:  0E 57                     short_string                       ; "房屋更新失败，请立"
05da:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
05de:  01                        pop                                ; 
05df:  10                        const1                             ; 
05e0:  2F                        return                             ; 
05e1:  19 14 00                  branch                             ; 0014 (05f6)
; std/room/xroom.lpc:362
      switch table (for 0590)
	 0: 0598
	 1: 05a3
	 2: 05af
	 3: 05bc
	 4: 05c9
	minval = 1
; std/room/xroom.lpc:356
05f6:  40 06                     local                              ; LV6
05f8:  3D 05                     transfer_local                     ; LV5
05fa:  70                        subtract                           ; 
05fb:  6B 03                     (void)assign_local                 ; LV3
; std/room/xroom.lpc:365
05fd:  40 08                     local                              ; LV8
05ff:  3D 07                     transfer_local                     ; LV7
0601:  70                        subtract                           ; 
0602:  6B 04                     (void)assign_local                 ; LV4
; std/room/xroom.lpc:366
0604:  0F                        const0                             ; 
0605:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
0608:  02 02 08 3E               F_PUSH                             ; push string 8, string 62
060c:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0610:  08 10 27                  F_SHORT_INT                        ; short 10000
0613:  72                        /                                  ; 
0614:  6B 09                     (void)assign_local                 ; LV9
; std/room/xroom.lpc:370
0616:  3D 09                     transfer_local                     ; LV9
0618:  40 03                     local                              ; LV3
061a:  14 13 00                  branch_ge                          ; 0013 (062e)
; std/room/xroom.lpc:371
061d:  02 02 3F C3               F_PUSH                             ; push string 63, local 3
0621:  7E 02 00 01               simul_efun                         ; "chinese_number" args: 1
0625:  6F                        +                                  ; 
0626:  0E 58                     short_string                       ; "两金子。\n"
0628:  6F                        +                                  ; 
0629:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
062c:  0F                        const0                             ; 
062d:  2F                        return                             ; 
; std/room/xroom.lpc:372
062e:  02 02 CC 08               F_PUSH                             ; push local 12, string 8
0632:  0E 41                     short_string                       ; "score"
0634:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0638:  40 04                     local                              ; LV4
063a:  14 13 00                  branch_ge                          ; 0013 (064e)
; std/room/xroom.lpc:374
063d:  0E 42                     short_string                       ; "你的评价不足"
063f:  40 04                     local                              ; LV4
0641:  7E 02 00 01               simul_efun                         ; "chinese_number" args: 1
0645:  6F                        +                                  ; 
0646:  0E 43                     short_string                       ; "点！\n"
0648:  6F                        +                                  ; 
0649:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
064c:  0F                        const0                             ; 
064d:  2F                        return                             ; 
; std/room/xroom.lpc:375
064e:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0651:  6B 0A                     (void)assign_local                 ; LV10
; std/room/xroom.lpc:377
0653:  0E 49                     short_string                       ; "annie_log_buildroom"
0655:  0E 59                     short_string                       ; "Payoff: [%s] %s(%s)的自建"
; std/room/xroom.lpc:386
0657:  03 04 01                  F_EFUN0                            ; EFUN: time(260)
065a:  04 07 01                  F_EFUN1                            ; EFUN: ctime(263)
; std/room/xroom.lpc:380
065d:  02 02 CC 08               F_PUSH                             ; push local 12, string 8
0661:  0E 4B                     short_string                       ; "name"
0663:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
; std/room/xroom.lpc:381
0667:  02 03 CC 08 2E            F_PUSH                             ; push local 12, string 8, string 46
066c:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
; std/room/xroom.lpc:382
0670:  02 02 CA 08               F_PUSH                             ; push local 10, string 8
0674:  0E 4C                     short_string                       ; "short"
0676:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
; std/room/xroom.lpc:383
067a:  02 03 C1 C2 CA            F_PUSH                             ; push local 1, local 2, local 10
; std/room/xroom.lpc:384
067f:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
0683:  07 23 01 08               F_EFUNV                            ; EFUN: sprintf(291)
0687:  7E 07 00 02               simul_efun                         ; "log_file" args: 2
068b:  01                        pop                                ; 
; std/room/xroom.lpc:386
068c:  40 0A                     local                              ; LV10
068e:  0E 5A                     short_string                       ; "set"
0690:  0E 28                     short_string                       ; "total_gold"
0692:  3D 06                     transfer_local                     ; LV6
0694:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0698:  01                        pop                                ; 
; std/room/xroom.lpc:388
0699:  40 0A                     local                              ; LV10
069b:  0E 5A                     short_string                       ; "set"
069d:  0E 2C                     short_string                       ; "total_score"
069f:  3D 08                     transfer_local                     ; LV8
06a1:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
06a5:  01                        pop                                ; 
; std/room/xroom.lpc:389
06a6:  40 0A                     local                              ; LV10
06a8:  0E 5A                     short_string                       ; "set"
06aa:  0E 5B                     short_string                       ; "free_space"
06ac:  3D 02                     transfer_local                     ; LV2
06ae:  3D 01                     transfer_local                     ; LV1
06b0:  02 02 CA 08               F_PUSH                             ; push local 10, string 8
06b4:  0E 5B                     short_string                       ; "free_space"
06b6:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
06ba:  70                        subtract                           ; 
06bb:  70                        subtract                           ; 
06bc:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
06c0:  01                        pop                                ; 
; std/room/xroom.lpc:390
06c1:  3D 0A                     transfer_local                     ; LV10
06c3:  0E 5C                     short_string                       ; "save"
06c5:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
06c9:  01                        pop                                ; 
; std/room/xroom.lpc:391
06ca:  40 0C                     local                              ; LV12
06cc:  0E 44                     short_string                       ; "add"
06ce:  02 02 3E C3               F_PUSH                             ; push string 62, local 3
06d2:  7A                        -                                  ; 
06d3:  08 10 27                  F_SHORT_INT                        ; short 10000
06d6:  71                        *                                  ; 
06d7:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
06db:  01                        pop                                ; 
; std/room/xroom.lpc:393
06dc:  40 0C                     local                              ; LV12
06de:  0E 44                     short_string                       ; "add"
06e0:  0E 41                     short_string                       ; "score"
06e2:  40 04                     local                              ; LV4
06e4:  7A                        -                                  ; 
06e5:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
06e9:  01                        pop                                ; 
; std/room/xroom.lpc:394
06ea:  40 0C                     local                              ; LV12
06ec:  0E 45                     short_string                       ; "你付出了"
06ee:  3D 03                     transfer_local                     ; LV3
06f0:  6F                        +                                  ; 
06f1:  0E 5D                     short_string                       ; "两黄金，"
06f3:  6F                        +                                  ; 
06f4:  3D 04                     transfer_local                     ; LV4
06f6:  6F                        +                                  ; 
06f7:  0E 47                     short_string                       ; "点评价。\n"
06f9:  6F                        +                                  ; 
06fa:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
06fe:  01                        pop                                ; 
; std/room/xroom.lpc:395
06ff:  3D 0C                     transfer_local                     ; LV12
0701:  0E 5C                     short_string                       ; "save"
0703:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0707:  01                        pop                                ; 
; std/room/xroom.lpc:396
0708:  3D 0B                     transfer_local                     ; LV11
070a:  7E 10 00 01               simul_efun                         ; "destruct" args: 1
070e:  01                        pop                                ; 
; std/room/xroom.lpc:397
070f:  0E 5E                     short_string                       ; "房屋改建成功！！改"
0711:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0715:  01                        pop                                ; 
; std/room/xroom.lpc:398
0716:  10                        const1                             ; 
0717:  2F                        return                             ; 
0718:  30                        return_zero                        ; 
; std/room/xroom.lpc:399

;; Function: public int do_here(string)
0719:  0E 5F                     short_string                       ; "\n╭════════"
071b:  7E 1B 00 01               simul_efun                         ; "write" args: 1
071f:  01                        pop                                ; 
; std/room/xroom.lpc:423
0720:  0E 60                     short_string                       ; "　　　　　　　　　"
0722:  0E 4C                     short_string                       ; "short"
0724:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0728:  6F                        +                                  ; 
0729:  0E 61                     short_string                       ; ""
072b:  6F                        +                                  ; 
072c:  0E 62                     short_string                       ; "[2;37;0m("
072e:  6F                        +                                  ; 
072f:  0E 0F                     short_string                       ; "outdoors"
0731:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0735:  17 07 00                  branch_when_zero                   ; 0007 (073d)
0738:  0E 63                     short_string                       ; "[36m室外"
073a:  19 04 00                  branch                             ; 0004 (073f)
073d:  0E 64                     short_string                       ; "[36m室内"
073f:  6F                        +                                  ; 
0740:  0E 61                     short_string                       ; ""
0742:  6F                        +                                  ; 
0743:  0E 65                     short_string                       ; "[2;37;0m)"
0745:  6F                        +                                  ; 
0746:  6C 01                     assign_local                       ; LV1
0748:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:424
074a:  3D 01                     transfer_local                     ; LV1
074c:  0E 61                     short_string                       ; ""
074e:  6F                        +                                  ; 
074f:  0E 66                     short_string                       ; "[2;37;0m"
0751:  6F                        +                                  ; 
0752:  0B 38                     byte                               ; 56
0754:  2D 39 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr, pushed_args:2
0758:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:425
075a:  0E 67                     short_string                       ; "║"
075c:  3D 01                     transfer_local                     ; LV1
075e:  6F                        +                                  ; 
075f:  0E 68                     short_string                       ; "║\n"
0761:  6F                        +                                  ; 
0762:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0766:  01                        pop                                ; 
; std/room/xroom.lpc:426
0767:  0E 69                     short_string                       ; "　建造於[33m"
0769:  0E 6A                     short_string                       ; "/cmds/usr/uptime"
076b:  0E 6C                     short_string                       ; "chinese_time"
076d:  0B 07                     byte                               ; 7
076f:  0E 6B                     short_string                       ; ""
0771:  0E 2A                     short_string                       ; "timestamp2"
0773:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0777:  6F                        +                                  ; 
0778:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
077c:  6F                        +                                  ; 
077d:  0E 61                     short_string                       ; ""
077f:  6F                        +                                  ; 
0780:  0E 66                     short_string                       ; "[2;37;0m"
0782:  6F                        +                                  ; 
0783:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:427
0785:  3D 01                     transfer_local                     ; LV1
0787:  0E 61                     short_string                       ; ""
0789:  6F                        +                                  ; 
078a:  0E 66                     short_string                       ; "[2;37;0m"
078c:  6F                        +                                  ; 
078d:  0B 38                     byte                               ; 56
078f:  2D 39 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr, pushed_args:2
0793:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:428
0795:  0E 67                     short_string                       ; "║"
0797:  3D 01                     transfer_local                     ; LV1
0799:  6F                        +                                  ; 
079a:  0E 68                     short_string                       ; "║\n"
079c:  6F                        +                                  ; 
079d:  7E 1B 00 01               simul_efun                         ; "write" args: 1
07a1:  01                        pop                                ; 
; std/room/xroom.lpc:429
07a2:  0E 6D                     short_string                       ; "║ ════════"
07a4:  7E 1B 00 01               simul_efun                         ; "write" args: 1
07a8:  01                        pop                                ; 
; std/room/xroom.lpc:430
07a9:  0E 6E                     short_string                       ; " ◆主人：[36m"
07ab:  0E 05                     short_string                       ; "owner"
07ad:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
07b1:  6F                        +                                  ; 
07b2:  0E 61                     short_string                       ; ""
07b4:  6F                        +                                  ; 
07b5:  0E 6F                     short_string                       ; "[2;37;0m ◆主人："
07b7:  6F                        +                                  ; 
07b8:  0E 70                     short_string                       ; "[36m"
07ba:  6F                        +                                  ; 
07bb:  0E 06                     short_string                       ; "couple"
07bd:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
07c1:  17 0B 00                  branch_when_zero                   ; 000b (07cd)
07c4:  0E 06                     short_string                       ; "couple"
07c6:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
07ca:  19 04 00                  branch                             ; 0004 (07cf)
07cd:  0E 71                     short_string                       ; "无"
07cf:  6F                        +                                  ; 
07d0:  0E 61                     short_string                       ; ""
07d2:  6F                        +                                  ; 
07d3:  0E 72                     short_string                       ; "[2;37;0m ◆借用者："
07d5:  6F                        +                                  ; 
07d6:  0E 73                     short_string                       ; "[36m特性关闭"
07d8:  6F                        +                                  ; 
07d9:  0E 66                     short_string                       ; "[2;37;0m"
07db:  6F                        +                                  ; 
07dc:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:431
07de:  3D 01                     transfer_local                     ; LV1
07e0:  0E 61                     short_string                       ; ""
07e2:  6F                        +                                  ; 
07e3:  0E 66                     short_string                       ; "[2;37;0m"
07e5:  6F                        +                                  ; 
07e6:  0B 38                     byte                               ; 56
07e8:  2D 39 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr, pushed_args:2
07ec:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:432
07ee:  0E 67                     short_string                       ; "║"
07f0:  40 01                     local                              ; LV1
07f2:  6F                        +                                  ; 
07f3:  0E 68                     short_string                       ; "║\n"
07f5:  6F                        +                                  ; 
07f6:  7E 1B 00 01               simul_efun                         ; "write" args: 1
07fa:  01                        pop                                ; 
; std/room/xroom.lpc:433
07fb:  0E 74                     short_string                       ; "║╭───────"
07fd:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0801:  01                        pop                                ; 
; std/room/xroom.lpc:434
0802:  0E 3A                     short_string                       ; "basic_tax"
0804:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0808:  0C 01                     -byte                              ; -1
080a:  13 49 00                  branch_ne                          ; 0049 (0854)
; std/room/xroom.lpc:435
080d:  0E 75                     short_string                       ; "║│　　　　　　　"
080f:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0813:  01                        pop                                ; 
; std/room/xroom.lpc:436
0814:  0E 75                     short_string                       ; "║│　　　　　　　"
0816:  7E 1B 00 01               simul_efun                         ; "write" args: 1
081a:  01                        pop                                ; 
; std/room/xroom.lpc:437
081b:  0E 75                     short_string                       ; "║│　　　　　　　"
081d:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0821:  01                        pop                                ; 
; std/room/xroom.lpc:438
0822:  0E 75                     short_string                       ; "║│　　　　　　　"
0824:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0828:  01                        pop                                ; 
; std/room/xroom.lpc:439
0829:  0E 76                     short_string                       ; "可用空间：[36m"
082b:  0E 5B                     short_string                       ; "free_space"
082d:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0831:  6F                        +                                  ; 
0832:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:440
0834:  40 01                     local                              ; LV1
0836:  0E 61                     short_string                       ; ""
0838:  6F                        +                                  ; 
0839:  0E 66                     short_string                       ; "[2;37;0m"
083b:  6F                        +                                  ; 
083c:  0B 34                     byte                               ; 52
083e:  2D 39 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr, pushed_args:2
0842:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:441
0844:  0E 77                     short_string                       ; "║│"
0846:  40 01                     local                              ; LV1
0848:  6F                        +                                  ; 
0849:  0E 78                     short_string                       ; "│║\n"
084b:  6F                        +                                  ; 
084c:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0850:  01                        pop                                ; 
0851:  19 44 01                  branch                             ; 0144 (0996)
; std/room/xroom.lpc:442
0854:  0E 79                     short_string                       ; "银两征收：[36m"
0856:  0E 7A                     short_string                       ; "/adm/daemons/chinesed"
0858:  0E 7B                     short_string                       ; "chinese_number"
085a:  2D 50 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; query_tax, pushed_args:0
085e:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0862:  6F                        +                                  ; 
0863:  0E 7C                     short_string                       ; "两"
0865:  6F                        +                                  ; 
0866:  0E 7D                     short_string                       ; "[2;37;0m/周 评价征收："
0868:  6F                        +                                  ; 
0869:  0E 70                     short_string                       ; "[36m"
086b:  6F                        +                                  ; 
086c:  0E 7A                     short_string                       ; "/adm/daemons/chinesed"
086e:  0E 7B                     short_string                       ; "chinese_number"
0870:  2D 51 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; query_stax, pushed_args:0
0874:  0B 64                     byte                               ; 100
0876:  72                        /                                  ; 
0877:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
087b:  6F                        +                                  ; 
087c:  0E 7E                     short_string                       ; "点"
087e:  6F                        +                                  ; 
087f:  0E 7F                     short_string                       ; "[2;37;0m/周"
0881:  6F                        +                                  ; 
0882:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:444
0884:  40 01                     local                              ; LV1
0886:  0E 61                     short_string                       ; ""
0888:  6F                        +                                  ; 
0889:  0E 66                     short_string                       ; "[2;37;0m"
088b:  6F                        +                                  ; 
088c:  0B 34                     byte                               ; 52
088e:  2D 39 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr, pushed_args:2
0892:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:445
0894:  0E 77                     short_string                       ; "║│"
0896:  40 01                     local                              ; LV1
0898:  6F                        +                                  ; 
0899:  0E 78                     short_string                       ; "│║\n"
089b:  6F                        +                                  ; 
089c:  7E 1B 00 01               simul_efun                         ; "write" args: 1
08a0:  01                        pop                                ; 
; std/room/xroom.lpc:446
08a1:  0E 75                     short_string                       ; "║│　　　　　　　"
08a3:  7E 1B 00 01               simul_efun                         ; "write" args: 1
08a7:  01                        pop                                ; 
; std/room/xroom.lpc:447
08a8:  0E 80                     short_string                       ; "上次缴纳：[36m"
08aa:  0E 6A                     short_string                       ; "/cmds/usr/uptime"
08ac:  0E 6C                     short_string                       ; "chinese_time"
08ae:  0B 07                     byte                               ; 7
08b0:  0E 6B                     short_string                       ; ""
08b2:  2D 45 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; pay_time, pushed_args:0
08b6:  6F                        +                                  ; 
08b7:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
08bb:  6F                        +                                  ; 
08bc:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:449
08be:  40 01                     local                              ; LV1
08c0:  0E 61                     short_string                       ; ""
08c2:  6F                        +                                  ; 
08c3:  0E 66                     short_string                       ; "[2;37;0m"
08c5:  6F                        +                                  ; 
08c6:  0B 34                     byte                               ; 52
08c8:  2D 39 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr, pushed_args:2
08cc:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:450
08ce:  0E 77                     short_string                       ; "║│"
08d0:  40 01                     local                              ; LV1
08d2:  6F                        +                                  ; 
08d3:  0E 78                     short_string                       ; "│║\n"
08d5:  6F                        +                                  ; 
08d6:  7E 1B 00 01               simul_efun                         ; "write" args: 1
08da:  01                        pop                                ; 
; std/room/xroom.lpc:451
08db:  0E 81                     short_string                       ; "下次缴纳：[36m"
08dd:  0E 6A                     short_string                       ; "/cmds/usr/uptime"
08df:  0E 6C                     short_string                       ; "chinese_time"
08e1:  0B 07                     byte                               ; 7
08e3:  0E 6B                     short_string                       ; ""
08e5:  2D 45 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; pay_time, pushed_args:0
08e9:  09 80 3A 09 00 00 00 00 00  number                             ; 604800
08f2:  6F                        +                                  ; 
08f3:  6F                        +                                  ; 
08f4:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
08f8:  6F                        +                                  ; 
08f9:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:453
08fb:  03 04 01                  F_EFUN0                            ; EFUN: time(260)
08fe:  2D 45 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; pay_time, pushed_args:0
0902:  09 80 3A 09 00 00 00 00 00  number                             ; 604800
090b:  6F                        +                                  ; 
090c:  15 1D 00                  branch_le                          ; 001d (092a)
; std/room/xroom.lpc:454
090f:  0E 82                     short_string                       ; "[1;31m（已欠款"
0911:  0E 83                     short_string                       ; "expired"
0913:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0917:  0B 07                     byte                               ; 7
0919:  72                        /                                  ; 
091a:  10                        const1                             ; 
091b:  6F                        +                                  ; 
091c:  7E 02 00 01               simul_efun                         ; "chinese_number" args: 1
0920:  6F                        +                                  ; 
0921:  0E 84                     short_string                       ; "期）"
0923:  6F                        +                                  ; 
0924:  0E 66                     short_string                       ; "[2;37;0m"
0926:  6F                        +                                  ; 
0927:  41 01                     local_lvalue                       ; LV1
0929:  69                        (void)+=                           ; 
; std/room/xroom.lpc:455
092a:  40 01                     local                              ; LV1
092c:  0E 61                     short_string                       ; ""
092e:  6F                        +                                  ; 
092f:  0E 66                     short_string                       ; "[2;37;0m"
0931:  6F                        +                                  ; 
0932:  0B 34                     byte                               ; 52
0934:  2D 39 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr, pushed_args:2
0938:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:457
093a:  0E 77                     short_string                       ; "║│"
093c:  40 01                     local                              ; LV1
093e:  6F                        +                                  ; 
093f:  0E 78                     short_string                       ; "│║\n"
0941:  6F                        +                                  ; 
0942:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0946:  01                        pop                                ; 
; std/room/xroom.lpc:458
0947:  0E 75                     short_string                       ; "║│　　　　　　　"
0949:  7E 1B 00 01               simul_efun                         ; "write" args: 1
094d:  01                        pop                                ; 
; std/room/xroom.lpc:460
094e:  0E 85                     short_string                       ; "累计已交：[36m"
0950:  0E 2B                     short_string                       ; "already_pay"
0952:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0956:  6F                        +                                  ; 
0957:  0E 7C                     short_string                       ; "两"
0959:  6F                        +                                  ; 
095a:  0E 86                     short_string                       ; "[2;37;0m银子"
095c:  6F                        +                                  ; 
095d:  0E 87                     short_string                       ; "[36m "
095f:  6F                        +                                  ; 
0960:  0E 2D                     short_string                       ; "already_spay"
0962:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0966:  6F                        +                                  ; 
0967:  0E 7E                     short_string                       ; "点"
0969:  6F                        +                                  ; 
096a:  0E 88                     short_string                       ; "[2;37;0m评价　　可用空"
096c:  6F                        +                                  ; 
096d:  0E 70                     short_string                       ; "[36m"
096f:  6F                        +                                  ; 
0970:  0E 5B                     short_string                       ; "free_space"
0972:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0976:  6F                        +                                  ; 
0977:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:461
0979:  40 01                     local                              ; LV1
097b:  0E 61                     short_string                       ; ""
097d:  6F                        +                                  ; 
097e:  0E 66                     short_string                       ; "[2;37;0m"
0980:  6F                        +                                  ; 
0981:  0B 34                     byte                               ; 52
0983:  2D 39 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr, pushed_args:2
0987:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:462
0989:  0E 77                     short_string                       ; "║│"
098b:  40 01                     local                              ; LV1
098d:  6F                        +                                  ; 
098e:  0E 78                     short_string                       ; "│║\n"
0990:  6F                        +                                  ; 
0991:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0995:  01                        pop                                ; 
; std/room/xroom.lpc:463
0996:  0E 89                     short_string                       ; "║╰───────"
0998:  7E 1B 00 01               simul_efun                         ; "write" args: 1
099c:  01                        pop                                ; 
; std/room/xroom.lpc:465
099d:  0E 8A                     short_string                       ; "║ ◆房产总额：[36m"
099f:  0E 28                     short_string                       ; "total_gold"
09a1:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
09a5:  6F                        +                                  ; 
09a6:  0E 61                     short_string                       ; ""
09a8:  6F                        +                                  ; 
09a9:  0E 8B                     short_string                       ; "[2;37;0m两黄金"
09ab:  6F                        +                                  ; 
09ac:  0E 8C                     short_string                       ; "/"
09ae:  6F                        +                                  ; 
09af:  0E 70                     short_string                       ; "[36m"
09b1:  6F                        +                                  ; 
09b2:  0E 2C                     short_string                       ; "total_score"
09b4:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
09b8:  6F                        +                                  ; 
09b9:  0E 61                     short_string                       ; ""
09bb:  6F                        +                                  ; 
09bc:  0E 8D                     short_string                       ; "[2;37;0m点评价"
09be:  6F                        +                                  ; 
09bf:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:467
09c1:  3D 01                     transfer_local                     ; LV1
09c3:  0E 61                     short_string                       ; ""
09c5:  6F                        +                                  ; 
09c6:  0E 66                     short_string                       ; "[2;37;0m"
09c8:  6F                        +                                  ; 
09c9:  0B 2C                     byte                               ; 44
09cb:  2D 39 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr, pushed_args:2
09cf:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:468
09d1:  3D 01                     transfer_local                     ; LV1
09d3:  0E 8E                     short_string                       ; "风云２００５  ║\n"
09d5:  6F                        +                                  ; 
09d6:  7E 1B 00 01               simul_efun                         ; "write" args: 1
09da:  01                        pop                                ; 
; std/room/xroom.lpc:469
09db:  0E 8F                     short_string                       ; "╰════════"
09dd:  7E 1B 00 01               simul_efun                         ; "write" args: 1
09e1:  01                        pop                                ; 
; std/room/xroom.lpc:473
09e2:  10                        const1                             ; 
09e3:  2F                        return                             ; 
09e4:  30                        return_zero                        ; 
; std/room/xroom.lpc:475

;; Function: public int valid_enter(object)
09e5:  0F                        const0                             ; 
09e6:  6B 06                     (void)assign_local                 ; LV6
; std/room/xroom.lpc:485
09e8:  0E 0A                     short_string                       ; "room_flag"
09ea:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
09ee:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:486
09f0:  02 03 C0 08 2E            F_PUSH                             ; push local 0, string 8, string 46
09f5:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
09f9:  2D 46 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; is_owner, pushed_args:1
09fd:  17 05 00                  branch_when_zero                   ; 0005 (0a03)
; std/room/xroom.lpc:488
0a00:  10                        const1                             ; 
0a01:  6B 06                     (void)assign_local                 ; LV6
; std/room/xroom.lpc:489
0a03:  3D 01                     transfer_local                     ; LV1
0a05:  0B 20                     byte                               ; 32
0a07:  74                        &                                  ; 
0a08:  17 05 00                  branch_when_zero                   ; 0005 (0a0e)
; std/room/xroom.lpc:492
0a0b:  10                        const1                             ; 
0a0c:  6B 06                     (void)assign_local                 ; LV6
; std/room/xroom.lpc:493
0a0e:  0E 90                     short_string                       ; "invite/"
0a10:  02 03 C0 08 2E            F_PUSH                             ; push local 0, string 8, string 46
0a15:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0a19:  6F                        +                                  ; 
0a1a:  2D 0E 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query_temp, pushed_args:1
0a1e:  17 05 00                  branch_when_zero                   ; 0005 (0a24)
; std/room/xroom.lpc:494
0a21:  10                        const1                             ; 
0a22:  6B 06                     (void)assign_local                 ; LV6
; std/room/xroom.lpc:495
0a24:  0E 83                     short_string                       ; "expired"
0a26:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0a2a:  26 0B 00                  &&                                 ; 000b (0a36)
0a2d:  0E 3A                     short_string                       ; "basic_tax"
0a2f:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0a33:  0C 01                     -byte                              ; -1
0a35:  32                        !=                                 ; 
0a36:  17 89 01                  branch_when_zero                   ; 0189 (0bc0)
; std/room/xroom.lpc:499
0a39:  0F                        const0                             ; 
0a3a:  6B 06                     (void)assign_local                 ; LV6
; std/room/xroom.lpc:501
0a3c:  02 03 C0 08 2E            F_PUSH                             ; push local 0, string 8, string 46
0a41:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0a45:  2D 46 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; is_owner, pushed_args:1
0a49:  17 76 01                  branch_when_zero                   ; 0176 (0bc0)
; std/room/xroom.lpc:502
0a4c:  0E 83                     short_string                       ; "expired"
0a4e:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0a52:  0B 07                     byte                               ; 7
0a54:  72                        /                                  ; 
0a55:  10                        const1                             ; 
0a56:  6F                        +                                  ; 
0a57:  6B 02                     (void)assign_local                 ; LV2
; std/room/xroom.lpc:503
0a59:  2D 50 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; query_tax, pushed_args:0
0a5d:  40 02                     local                              ; LV2
0a5f:  71                        *                                  ; 
0a60:  6B 03                     (void)assign_local                 ; LV3
; std/room/xroom.lpc:504
0a62:  2D 51 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; query_stax, pushed_args:0
0a66:  40 02                     local                              ; LV2
0a68:  71                        *                                  ; 
0a69:  6B 04                     (void)assign_local                 ; LV4
; std/room/xroom.lpc:505
0a6b:  40 00                     local                              ; LV0
0a6d:  0E 91                     short_string                       ; "[37m你在"
0a6f:  40 02                     local                              ; LV2
0a71:  7E 02 00 01               simul_efun                         ; "chinese_number" args: 1
0a75:  6F                        +                                  ; 
0a76:  0E 92                     short_string                       ; "周内未交维持费用。\n"
0a78:  6F                        +                                  ; 
0a79:  0E 66                     short_string                       ; "[2;37;0m"
0a7b:  6F                        +                                  ; 
0a7c:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0a80:  01                        pop                                ; 
; std/room/xroom.lpc:506
0a81:  0E 83                     short_string                       ; "expired"
0a83:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0a87:  0B 07                     byte                               ; 7
0a89:  15 1D 00                  branch_le                          ; 001d (0aa7)
; std/room/xroom.lpc:508
0a8c:  40 00                     local                              ; LV0
0a8e:  0E 93                     short_string                       ; "[37m系统一次最多只征"
0a90:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0a94:  01                        pop                                ; 
; std/room/xroom.lpc:509
0a95:  2D 50 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; query_tax, pushed_args:0
0a99:  0B 02                     byte                               ; 2
0a9b:  71                        *                                  ; 
0a9c:  6B 03                     (void)assign_local                 ; LV3
; std/room/xroom.lpc:510
0a9e:  2D 51 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; query_stax, pushed_args:0
0aa2:  0B 02                     byte                               ; 2
0aa4:  71                        *                                  ; 
0aa5:  6B 04                     (void)assign_local                 ; LV4
; std/room/xroom.lpc:511
0aa7:  0F                        const0                             ; 
0aa8:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
0aab:  02 02 08 3E               F_PUSH                             ; push string 8, string 62
0aaf:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0ab3:  0B 64                     byte                               ; 100
0ab5:  72                        /                                  ; 
0ab6:  6B 05                     (void)assign_local                 ; LV5
; std/room/xroom.lpc:514
0ab8:  02 02 C5 C3               F_PUSH                             ; push local 5, local 3
0abc:  14 16 00                  branch_ge                          ; 0016 (0ad3)
; std/room/xroom.lpc:515
0abf:  40 00                     local                              ; LV0
0ac1:  0E 94                     short_string                       ; "（你在南宫家没有存"
0ac3:  40 03                     local                              ; LV3
0ac5:  7E 02 00 01               simul_efun                         ; "chinese_number" args: 1
0ac9:  6F                        +                                  ; 
0aca:  0E 95                     short_string                       ; "两银子。）\n"
0acc:  6F                        +                                  ; 
0acd:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0ad1:  01                        pop                                ; 
; std/room/xroom.lpc:516
0ad2:  30                        return_zero                        ; 
; std/room/xroom.lpc:517
0ad3:  02 02 C0 08               F_PUSH                             ; push local 0, string 8
0ad7:  0E 41                     short_string                       ; "score"
0ad9:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0add:  40 04                     local                              ; LV4
0adf:  0B 64                     byte                               ; 100
0ae1:  72                        /                                  ; 
0ae2:  14 19 00                  branch_ge                          ; 0019 (0afc)
; std/room/xroom.lpc:520
0ae5:  40 00                     local                              ; LV0
0ae7:  0E 96                     short_string                       ; "（你的评价不足"
0ae9:  40 04                     local                              ; LV4
0aeb:  0B 64                     byte                               ; 100
0aed:  72                        /                                  ; 
0aee:  7E 02 00 01               simul_efun                         ; "chinese_number" args: 1
0af2:  6F                        +                                  ; 
0af3:  0E 97                     short_string                       ; "点！）\n"
0af5:  6F                        +                                  ; 
0af6:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0afa:  01                        pop                                ; 
; std/room/xroom.lpc:521
0afb:  30                        return_zero                        ; 
; std/room/xroom.lpc:522
0afc:  40 00                     local                              ; LV0
0afe:  0E 44                     short_string                       ; "add"
0b00:  02 02 3E C3               F_PUSH                             ; push string 62, local 3
0b04:  7A                        -                                  ; 
0b05:  0B 64                     byte                               ; 100
0b07:  71                        *                                  ; 
0b08:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0b0c:  01                        pop                                ; 
; std/room/xroom.lpc:524
0b0d:  40 00                     local                              ; LV0
0b0f:  0E 44                     short_string                       ; "add"
0b11:  0E 41                     short_string                       ; "score"
0b13:  40 04                     local                              ; LV4
0b15:  7A                        -                                  ; 
0b16:  0B 64                     byte                               ; 100
0b18:  72                        /                                  ; 
0b19:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0b1d:  01                        pop                                ; 
; std/room/xroom.lpc:525
0b1e:  40 00                     local                              ; LV0
0b20:  0E 98                     short_string                       ; "[33m你补交了所欠的维"
0b22:  40 03                     local                              ; LV3
0b24:  6F                        +                                  ; 
0b25:  0E 99                     short_string                       ; "两银子、"
0b27:  6F                        +                                  ; 
0b28:  40 04                     local                              ; LV4
0b2a:  0B 64                     byte                               ; 100
0b2c:  72                        /                                  ; 
0b2d:  6F                        +                                  ; 
0b2e:  0E 9A                     short_string                       ; "点评价）。\n"
0b30:  6F                        +                                  ; 
0b31:  0E 66                     short_string                       ; "[2;37;0m"
0b33:  6F                        +                                  ; 
0b34:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0b38:  01                        pop                                ; 
; std/room/xroom.lpc:526
0b39:  02 02 2B C3               F_PUSH                             ; push string 43, local 3
0b3d:  2D 0A 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; add, pushed_args:2
0b41:  01                        pop                                ; 
; std/room/xroom.lpc:527
0b42:  02 02 2D C4               F_PUSH                             ; push string 45, local 4
0b46:  0B 64                     byte                               ; 100
0b48:  72                        /                                  ; 
0b49:  2D 0A 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; add, pushed_args:2
0b4d:  01                        pop                                ; 
; std/room/xroom.lpc:528
0b4e:  0E 83                     short_string                       ; "expired"
0b50:  0F                        const0                             ; 
0b51:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0b55:  01                        pop                                ; 
; std/room/xroom.lpc:529
0b56:  0E 48                     short_string                       ; "charged"
0b58:  10                        const1                             ; 
0b59:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0b5d:  01                        pop                                ; 
; std/room/xroom.lpc:530
0b5e:  2D 52 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; reset_pay_time, pushed_args:0
0b62:  01                        pop                                ; 
; std/room/xroom.lpc:531
0b63:  2D 54 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; balance_s, pushed_args:0
0b67:  79                        !                                  ; 
0b68:  26 07 00                  &&                                 ; 0007 (0b70)
0b6b:  2D 53 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; balance_g, pushed_args:0
0b6f:  79                        !                                  ; 
0b70:  17 47 00                  branch_when_zero                   ; 0047 (0bb8)
; std/room/xroom.lpc:533
0b73:  0E 3A                     short_string                       ; "basic_tax"
0b75:  0C 01                     -byte                              ; -1
0b77:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0b7b:  01                        pop                                ; 
; std/room/xroom.lpc:534
0b7c:  0E 49                     short_string                       ; "annie_log_buildroom"
0b7e:  0E 4A                     short_string                       ; "Payoff: [%s] %s(%s)的自建"
; std/room/xroom.lpc:541
0b80:  03 04 01                  F_EFUN0                            ; EFUN: time(260)
0b83:  04 07 01                  F_EFUN1                            ; EFUN: ctime(263)
; std/room/xroom.lpc:537
0b86:  02 02 C0 08               F_PUSH                             ; push local 0, string 8
0b8a:  0E 4B                     short_string                       ; "name"
0b8c:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
; std/room/xroom.lpc:538
0b90:  02 03 C0 08 2E            F_PUSH                             ; push local 0, string 8, string 46
0b95:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
; std/room/xroom.lpc:539
0b99:  0E 4C                     short_string                       ; "short"
0b9b:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
; std/room/xroom.lpc:540
0b9f:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0ba2:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
0ba6:  07 23 01 06               F_EFUNV                            ; EFUN: sprintf(291)
0baa:  7E 07 00 02               simul_efun                         ; "log_file" args: 2
0bae:  01                        pop                                ; 
; std/room/xroom.lpc:541
0baf:  40 00                     local                              ; LV0
0bb1:  0E 9B                     short_string                       ; "[1;31m恭喜，你的屋子"
0bb3:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0bb7:  01                        pop                                ; 
; std/room/xroom.lpc:542
0bb8:  2D 40 00 00               F_CALL_FUNCTION_BY_ADDRESS         ; save, pushed_args:0
0bbc:  01                        pop                                ; 
; std/room/xroom.lpc:545
0bbd:  10                        const1                             ; 
0bbe:  6B 06                     (void)assign_local                 ; LV6
; std/room/xroom.lpc:546
0bc0:  40 06                     local                              ; LV6
0bc2:  79                        !                                  ; 
0bc3:  26 14 00                  &&                                 ; 0014 (0bd8)
0bc6:  0E 83                     short_string                       ; "expired"
0bc8:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0bcc:  26 0B 00                  &&                                 ; 000b (0bd8)
0bcf:  0E 3A                     short_string                       ; "basic_tax"
0bd1:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0bd5:  0C 01                     -byte                              ; -1
0bd7:  32                        !=                                 ; 
0bd8:  17 0B 00                  branch_when_zero                   ; 000b (0be4)
; std/room/xroom.lpc:550
0bdb:  40 00                     local                              ; LV0
0bdd:  0E 9C                     short_string                       ; "该房屋欠款未请，暂"
0bdf:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0be3:  01                        pop                                ; 
; std/room/xroom.lpc:551
0be4:  3D 06                     transfer_local                     ; LV6
0be6:  2F                        return                             ; 
0be7:  30                        return_zero                        ; 
; std/room/xroom.lpc:553

;; Function: public int do_invite(string)
0be8:  0F                        const0                             ; 
0be9:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
0bec:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:561
0bee:  3D 01                     transfer_local                     ; LV1
0bf0:  02 02 08 2E               F_PUSH                             ; push string 8, string 46
0bf4:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0bf8:  2D 46 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; is_owner, pushed_args:1
0bfc:  18 03 00                  branch_when_non_zero               ; 0003 (0c00)
; std/room/xroom.lpc:562
0bff:  30                        return_zero                        ; 
; std/room/xroom.lpc:563
0c00:  0E 17                     short_string                       ; "invite"
0c02:  2D 0E 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query_temp, pushed_args:1
0c06:  6B 02                     (void)assign_local                 ; LV2
; std/room/xroom.lpc:565
0c08:  40 00                     local                              ; LV0
0c0a:  17 5D 00                  branch_when_zero                   ; 005d (0c68)
; std/room/xroom.lpc:567
0c0d:  40 02                     local                              ; LV2
0c0f:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0c12:  17 09 00                  branch_when_zero                   ; 0009 (0c1c)
; std/room/xroom.lpc:568
0c15:  40 02                     local                              ; LV2
0c17:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
0c1a:  6B 04                     (void)assign_local                 ; LV4
; std/room/xroom.lpc:569
0c1c:  40 04                     local                              ; LV4
0c1e:  26 07 00                  &&                                 ; 0007 (0c26)
0c21:  40 04                     local                              ; LV4
0c23:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0c26:  17 27 00                  branch_when_zero                   ; 0027 (0c4e)
; std/room/xroom.lpc:570
0c29:  02 02 C0 C4               F_PUSH                             ; push local 0, local 4
0c2d:  05 AE 00                  F_EFUN2                            ; EFUN: member_array(174)
0c30:  0C 01                     -byte                              ; -1
0c32:  16 1B 00                  branch_eq                          ; 001b (0c4e)
; std/room/xroom.lpc:571
0c35:  0E 90                     short_string                       ; "invite/"
0c37:  40 00                     local                              ; LV0
0c39:  6F                        +                                  ; 
0c3a:  2D 0F 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; delete_temp, pushed_args:1
0c3e:  01                        pop                                ; 
; std/room/xroom.lpc:572
0c3f:  0E 9D                     short_string                       ; "你把"
0c41:  40 00                     local                              ; LV0
0c43:  6F                        +                                  ; 
0c44:  0E 9E                     short_string                       ; "从客人名单上删去了"
0c46:  6F                        +                                  ; 
0c47:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0c4b:  01                        pop                                ; 
; std/room/xroom.lpc:573
0c4c:  10                        const1                             ; 
0c4d:  2F                        return                             ; 
; std/room/xroom.lpc:574
0c4e:  0E 90                     short_string                       ; "invite/"
0c50:  40 00                     local                              ; LV0
0c52:  6F                        +                                  ; 
0c53:  10                        const1                             ; 
0c54:  2D 04 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
0c58:  01                        pop                                ; 
; std/room/xroom.lpc:576
0c59:  0E 9F                     short_string                       ; "你邀请"
0c5b:  40 00                     local                              ; LV0
0c5d:  6F                        +                                  ; 
0c5e:  0E A0                     short_string                       ; "来你的房间。\n"
0c60:  6F                        +                                  ; 
0c61:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0c65:  01                        pop                                ; 
; std/room/xroom.lpc:577
0c66:  10                        const1                             ; 
0c67:  2F                        return                             ; 
; std/room/xroom.lpc:578
0c68:  0E 17                     short_string                       ; "invite"
0c6a:  2D 0E 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query_temp, pushed_args:1
0c6e:  6B 02                     (void)assign_local                 ; LV2
; std/room/xroom.lpc:581
0c70:  0E A1                     short_string                       ; "[37m	　　邀请名单：\n"
0c72:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0c76:  01                        pop                                ; 
; std/room/xroom.lpc:583
0c77:  0E A2                     short_string                       ; "[1;31m[30m─────"
0c79:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0c7d:  01                        pop                                ; 
; std/room/xroom.lpc:584
0c7e:  40 02                     local                              ; LV2
0c80:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0c83:  79                        !                                  ; 
0c84:  25 08 00                  ||                                 ; 0008 (0c8d)
0c87:  40 02                     local                              ; LV2
0c89:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0c8c:  79                        !                                  ; 
0c8d:  17 12 00                  branch_when_zero                   ; 0012 (0ca0)
; std/room/xroom.lpc:585
0c90:  0E A3                     short_string                       ; "没有邀请任何人。\n"
0c92:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0c96:  01                        pop                                ; 
; std/room/xroom.lpc:586
0c97:  0E A2                     short_string                       ; "[1;31m[30m─────"
0c99:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0c9d:  01                        pop                                ; 
; std/room/xroom.lpc:587
0c9e:  10                        const1                             ; 
0c9f:  2F                        return                             ; 
; std/room/xroom.lpc:588
0ca0:  3D 02                     transfer_local                     ; LV2
0ca2:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
0ca5:  6B 04                     (void)assign_local                 ; LV4
; std/room/xroom.lpc:590
0ca7:  0F                        const0                             ; 
0ca8:  6B 03                     (void)assign_local                 ; LV3
0caa:  19 11 00                  branch                             ; 0011 (0cbc)
; std/room/xroom.lpc:591
0cad:  02 02 C3 C4               F_PUSH                             ; push local 3, local 4
0cb1:  4C                        index                              ; 
0cb2:  0E A4                     short_string                       ; "\n"
0cb4:  6F                        +                                  ; 
0cb5:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0cb9:  01                        pop                                ; 
0cba:  23 03                     loop_incr                          ; LV3
; std/room/xroom.lpc:592
0cbc:  02 02 C3 C4               F_PUSH                             ; push local 3, local 4
0cc0:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0cc3:  1D 17 00                  bbranch_lt                         ; 0017 (0cad)
; std/room/xroom.lpc:591
0cc6:  0E A2                     short_string                       ; "[1;31m[30m─────"
0cc8:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0ccc:  01                        pop                                ; 
; std/room/xroom.lpc:593
0ccd:  10                        const1                             ; 
0cce:  2F                        return                             ; 
0ccf:  30                        return_zero                        ; 
; std/room/xroom.lpc:594

;; Function: public int do_setowner(string)
0cd0:  0F                        const0                             ; 
0cd1:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
0cd4:  04 34 01                  F_EFUN1                            ; EFUN: wizardp(308)
0cd7:  79                        !                                  ; 
0cd8:  26 13 00                  &&                                 ; 0013 (0cec)
0cdb:  0F                        const0                             ; 
0cdc:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
0cdf:  02 02 08 2E               F_PUSH                             ; push string 8, string 46
0ce3:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0ce7:  2D 46 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; is_owner, pushed_args:1
0ceb:  79                        !                                  ; 
0cec:  17 03 00                  branch_when_zero                   ; 0003 (0cf0)
; std/room/xroom.lpc:599
0cef:  30                        return_zero                        ; 
; std/room/xroom.lpc:600
0cf0:  0E 04                     short_string                       ; "temp_owner"
0cf2:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0cf6:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:601
0cf8:  02 02 04 C0               F_PUSH                             ; push string 4, local 0
0cfc:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0d00:  01                        pop                                ; 
; std/room/xroom.lpc:602
0d01:  0E A5                     short_string                       ; "你将房间的主人暂时"
0d03:  3D 00                     transfer_local                     ; LV0
0d05:  6F                        +                                  ; 
0d06:  0E A6                     short_string                       ; "。\n"
0d08:  6F                        +                                  ; 
0d09:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0d0d:  01                        pop                                ; 
; std/room/xroom.lpc:603
0d0e:  0E A7                     short_string                       ; "set_back"
0d10:  0B 3C                     byte                               ; 60
0d12:  3D 01                     transfer_local                     ; LV1
0d14:  07 A9 00 03               F_EFUNV                            ; EFUN: call_out(169)
0d18:  01                        pop                                ; 
; std/room/xroom.lpc:604
0d19:  10                        const1                             ; 
0d1a:  2F                        return                             ; 
0d1b:  30                        return_zero                        ; 
; std/room/xroom.lpc:605

;; Function: public int do_share(string)
0d1c:  0F                        const0                             ; 
0d1d:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
0d20:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:611
0d22:  02 03 C1 08 2E            F_PUSH                             ; push local 1, string 8, string 46
0d27:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0d2b:  0E 05                     short_string                       ; "owner"
0d2d:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0d31:  16 03 00                  branch_eq                          ; 0003 (0d35)
; std/room/xroom.lpc:612
0d34:  30                        return_zero                        ; 
; std/room/xroom.lpc:613
0d35:  02 03 C1 08 07            F_PUSH                             ; push local 1, string 8, string 7
0d3a:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0d3e:  18 09 00                  branch_when_non_zero               ; 0009 (0d48)
; std/room/xroom.lpc:614
0d41:  0E A8                     short_string                       ; "你只能与你的另一半"
0d43:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0d46:  0F                        const0                             ; 
0d47:  2F                        return                             ; 
; std/room/xroom.lpc:615
0d48:  40 00                     local                              ; LV0
0d4a:  18 09 00                  branch_when_non_zero               ; 0009 (0d54)
; std/room/xroom.lpc:616
0d4d:  0E A9                     short_string                       ; "设置指令为：share <id>"
0d4f:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0d52:  0F                        const0                             ; 
0d53:  2F                        return                             ; 
; std/room/xroom.lpc:617
0d54:  02 04 C0 C1 08 07         F_PUSH                             ; push local 0, local 1, string 8, string 7
0d5a:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0d5e:  16 09 00                  branch_eq                          ; 0009 (0d68)
; std/room/xroom.lpc:618
0d61:  0E A8                     short_string                       ; "你只能与你的另一半"
0d63:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0d66:  0F                        const0                             ; 
0d67:  2F                        return                             ; 
; std/room/xroom.lpc:619
0d68:  02 02 C0 05               F_PUSH                             ; push local 0, string 5
0d6c:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0d70:  13 09 00                  branch_ne                          ; 0009 (0d7a)
; std/room/xroom.lpc:620
0d73:  0E AA                     short_string                       ; "将自己设置为第二个"
0d75:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0d78:  0F                        const0                             ; 
0d79:  2F                        return                             ; 
; std/room/xroom.lpc:621
0d7a:  0E 06                     short_string                       ; "couple"
0d7c:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0d80:  17 09 00                  branch_when_zero                   ; 0009 (0d8a)
; std/room/xroom.lpc:622
0d83:  0E AB                     short_string                       ; "你只能设置一次房间"
0d85:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0d88:  0F                        const0                             ; 
0d89:  2F                        return                             ; 
; std/room/xroom.lpc:623
0d8a:  40 00                     local                              ; LV0
0d8c:  04 C7 00                  F_EFUN1                            ; EFUN: find_player(199)
0d8f:  18 09 00                  branch_when_non_zero               ; 0009 (0d99)
; std/room/xroom.lpc:624
0d92:  0E AC                     short_string                       ; "第二主人必须在其在"
0d94:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0d97:  0F                        const0                             ; 
0d98:  2F                        return                             ; 
; std/room/xroom.lpc:625
0d99:  02 02 06 C0               F_PUSH                             ; push string 6, local 0
0d9d:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0da1:  01                        pop                                ; 
; std/room/xroom.lpc:626
0da2:  0E AD                     short_string                       ; "你添加了房间的第二"
0da4:  40 00                     local                              ; LV0
0da6:  6F                        +                                  ; 
0da7:  0E A6                     short_string                       ; "。\n"
0da9:  6F                        +                                  ; 
0daa:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0dae:  01                        pop                                ; 
; std/room/xroom.lpc:627
0daf:  3D 00                     transfer_local                     ; LV0
0db1:  04 C7 00                  F_EFUN1                            ; EFUN: find_player(199)
0db4:  3D 01                     transfer_local                     ; LV1
0db6:  0E 08                     short_string                       ; "query"
0db8:  0E 4B                     short_string                       ; "name"
0dba:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0dbe:  0E AE                     short_string                       ; "将你设置为"
0dc0:  6F                        +                                  ; 
0dc1:  0E 4C                     short_string                       ; "short"
0dc3:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0dc7:  6F                        +                                  ; 
0dc8:  0E AF                     short_string                       ; "房间的第二主人。\n"
0dca:  6F                        +                                  ; 
0dcb:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0dcf:  01                        pop                                ; 
; std/room/xroom.lpc:628
0dd0:  10                        const1                             ; 
0dd1:  2F                        return                             ; 
0dd2:  30                        return_zero                        ; 
; std/room/xroom.lpc:629

;; Function: public int set_back(string)
0dd3:  0E 04                     short_string                       ; "temp_owner"
0dd5:  3D 00                     transfer_local                     ; LV0
0dd7:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0ddb:  01                        pop                                ; 
; std/room/xroom.lpc:633
0ddc:  10                        const1                             ; 
0ddd:  2F                        return                             ; 
; std/room/xroom.lpc:634

;; Function: public string query_save_file()
0dde:  0E 05                     short_string                       ; "owner"
0de0:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0de4:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:641
0de6:  40 00                     local                              ; LV0
0de8:  04 E3 00                  F_EFUN1                            ; EFUN: stringp(227)
0deb:  18 03 00                  branch_when_non_zero               ; 0003 (0def)
0dee:  30                        return_zero                        ; 
; std/room/xroom.lpc:642
0def:  0E B0                     short_string                       ; "/data/user/%c/%s/%s"
0df1:  02 02 40 C0               F_PUSH                             ; push number 0, local 0
0df5:  4C                        index                              ; 
0df6:  40 00                     local                              ; LV0
0df8:  3D 00                     transfer_local                     ; LV0
0dfa:  0E B1                     short_string                       ; ".room"
0dfc:  6F                        +                                  ; 
0dfd:  0E B2                     short_string                       ; "timestamp"
0dff:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0e03:  6F                        +                                  ; 
0e04:  0E B3                     short_string                       ; ".o"
0e06:  6F                        +                                  ; 
0e07:  07 23 01 04               F_EFUNV                            ; EFUN: sprintf(291)
0e0b:  2F                        return                             ; 
0e0c:  30                        return_zero                        ; 
; std/room/xroom.lpc:643

;; Function: public int save()
0e0d:  0E 05                     short_string                       ; "owner"
0e0f:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0e13:  04 01 02                  F_EFUN1                            ; EFUN: seteuid(513)
0e16:  01                        pop                                ; 
; std/room/xroom.lpc:649
0e17:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0e1a:  0E B4                     short_string                       ; "query_save_file"
0e1c:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0e20:  6C 00                     assign_local                       ; LV0
0e22:  04 E3 00                  F_EFUN1                            ; EFUN: stringp(227)
0e25:  17 18 00                  branch_when_zero                   ; 0018 (0e3e)
; std/room/xroom.lpc:650
0e28:  40 00                     local                              ; LV0
0e2a:  0E B3                     short_string                       ; ".o"
0e2c:  6F                        +                                  ; 
0e2d:  7E 06 00 01               simul_efun                         ; "assure_file" args: 1
0e31:  01                        pop                                ; 
; std/room/xroom.lpc:651
0e32:  02 02 C0 41               F_PUSH                             ; push local 0, number 1
0e36:  05 CC 00                  F_EFUN2                            ; EFUN: save_object(204)
0e39:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:652
0e3b:  40 01                     local                              ; LV1
0e3d:  2F                        return                             ; 
; std/room/xroom.lpc:653
0e3e:  30                        return_zero                        ; 
0e3f:  30                        return_zero                        ; 
; std/room/xroom.lpc:655

;; Function: public int restore()
0e40:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0e43:  0E B4                     short_string                       ; "query_save_file"
0e45:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0e49:  6C 00                     assign_local                       ; LV0
0e4b:  04 E3 00                  F_EFUN1                            ; EFUN: stringp(227)
0e4e:  17 0C 00                  branch_when_zero                   ; 000c (0e5b)
; std/room/xroom.lpc:661
0e51:  40 00                     local                              ; LV0
0e53:  04 CB 00                  F_EFUN1                            ; EFUN: restore_object(203)
0e56:  17 04 00                  branch_when_zero                   ; 0004 (0e5b)
; std/room/xroom.lpc:662
0e59:  10                        const1                             ; 
0e5a:  2F                        return                             ; 
; std/room/xroom.lpc:663
0e5b:  30                        return_zero                        ; 
; std/room/xroom.lpc:664

;; Function: public int restore_item()
0e5c:  0E B5                     short_string                       ; "item_list"
0e5e:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0e62:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:693
0e64:  40 01                     local                              ; LV1
0e66:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0e69:  79                        !                                  ; 
0e6a:  25 08 00                  ||                                 ; 0008 (0e73)
0e6d:  40 01                     local                              ; LV1
0e6f:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0e72:  79                        !                                  ; 
0e73:  17 04 00                  branch_when_zero                   ; 0004 (0e78)
; std/room/xroom.lpc:694
0e76:  10                        const1                             ; 
0e77:  2F                        return                             ; 
; std/room/xroom.lpc:695
0e78:  3D 01                     transfer_local                     ; LV1
0e7a:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
0e7d:  6B 02                     (void)assign_local                 ; LV2
; std/room/xroom.lpc:698
0e7f:  0F                        const0                             ; 
0e80:  6B 04                     (void)assign_local                 ; LV4
0e82:  19 4D 00                  branch                             ; 004d (0ed0)
; std/room/xroom.lpc:699
0e85:  02 02 C4 C2               F_PUSH                             ; push local 4, local 2
0e89:  4C                        index                              ; 
0e8a:  0E 53                     short_string                       ; "%d"
0e8c:  7F 01                     sscanf                             ; 1
0e8e:  41 05                     local_lvalue                       ; LV5
0e90:  6A                        (void)assign                       ; 
0e91:  18 05 00                  branch_when_non_zero               ; 0005 (0e97)
0e94:  19 39 00                  branch                             ; 0039 (0ece)
; std/room/xroom.lpc:700
0e97:  0E B6                     short_string                       ; "item_list/"
0e99:  02 02 C4 C2               F_PUSH                             ; push local 4, local 2
0e9d:  4C                        index                              ; 
0e9e:  6F                        +                                  ; 
0e9f:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0ea3:  6B 03                     (void)assign_local                 ; LV3
; std/room/xroom.lpc:701
0ea5:  40 03                     local                              ; LV3
0ea7:  07 9D 00 01               F_EFUNV                            ; EFUN: new(157)
0eab:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:702
0ead:  40 00                     local                              ; LV0
0eaf:  0E B7                     short_string                       ; "move"
0eb1:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0eb4:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0eb8:  01                        pop                                ; 
; std/room/xroom.lpc:703
0eb9:  40 00                     local                              ; LV0
0ebb:  0E 5A                     short_string                       ; "set"
0ebd:  0E B8                     short_string                       ; "no_reset"
0ebf:  10                        const1                             ; 
0ec0:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0ec4:  01                        pop                                ; 
; std/room/xroom.lpc:704
0ec5:  40 00                     local                              ; LV0
0ec7:  0E B9                     short_string                       ; "restore_item"
0ec9:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0ecd:  01                        pop                                ; 
; std/room/xroom.lpc:705
0ece:  23 04                     loop_incr                          ; LV4
; std/room/xroom.lpc:706
0ed0:  02 02 C4 C2               F_PUSH                             ; push local 4, local 2
0ed4:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0ed7:  1D 53 00                  bbranch_lt                         ; 0053 (0e85)
; std/room/xroom.lpc:699
0eda:  10                        const1                             ; 
0edb:  2F                        return                             ; 
0edc:  30                        return_zero                        ; 
; std/room/xroom.lpc:707

;; Function: public void reset()
0edd:  2E 00 13 00 00            call_inherited                     ;                   std/room.lpc::reset           19
0ee2:  01                        pop                                ; 
; std/room/xroom.lpc:713
0ee3:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0ee6:  04 B4 00                  F_EFUN1                            ; EFUN: all_inventory(180)
0ee9:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:715
0eeb:  0F                        const0                             ; 
0eec:  6B 01                     (void)assign_local                 ; LV1
0eee:  19 28 00                  branch                             ; 0028 (0f17)
; std/room/xroom.lpc:716
0ef1:  02 02 C1 C0               F_PUSH                             ; push local 1, local 0
0ef5:  4C                        index                              ; 
0ef6:  0E 08                     short_string                       ; "query"
0ef8:  0E BA                     short_string                       ; "item_type"
0efa:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0efe:  18 05 00                  branch_when_non_zero               ; 0005 (0f04)
0f01:  19 13 00                  branch                             ; 0013 (0f15)
; std/room/xroom.lpc:717
0f04:  02 02 C1 C0               F_PUSH                             ; push local 1, local 0
0f08:  4C                        index                              ; 
0f09:  0E BB                     short_string                       ; "reset_item_list"
0f0b:  02 02 C1 C0               F_PUSH                             ; push local 1, local 0
0f0f:  4C                        index                              ; 
0f10:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0f14:  01                        pop                                ; 
; std/room/xroom.lpc:718
0f15:  23 01                     loop_incr                          ; LV1
; std/room/xroom.lpc:719
0f17:  02 02 C1 C0               F_PUSH                             ; push local 1, local 0
0f1b:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0f1e:  1D 2E 00                  bbranch_lt                         ; 002e (0ef1)
; std/room/xroom.lpc:716
0f21:  30                        return_zero                        ; 
0f22:  30                        return_zero                        ; 
; std/room/xroom.lpc:720

;; Function: public int check_legal_long(string)
0f23:  40 00                     local                              ; LV0
0f25:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0f28:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:726
0f2a:  40 00                     local                              ; LV0
0f2c:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0f2f:  0B 78                     byte                               ; 120
0f31:  34                        <                                  ; 
0f32:  25 0B 00                  ||                                 ; 000b (0f3e)
0f35:  40 00                     local                              ; LV0
0f37:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0f3a:  08 58 02                  F_SHORT_INT                        ; short 600
0f3d:  36                        >                                  ; 
0f3e:  17 13 00                  branch_when_zero                   ; 0013 (0f52)
; std/room/xroom.lpc:727
0f41:  0E BC                     short_string                       ; "对不起，中文描述必"
0f43:  40 00                     local                              ; LV0
0f45:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0f48:  6F                        +                                  ; 
0f49:  0E A4                     short_string                       ; "\n"
0f4b:  6F                        +                                  ; 
0f4c:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0f50:  01                        pop                                ; 
; std/room/xroom.lpc:728
0f51:  30                        return_zero                        ; 
0f52:  19 4B 00                  branch                             ; 004b (0f9e)
; std/room/xroom.lpc:729
0f55:  02 02 C1 C0               F_PUSH                             ; push local 1, local 0
0f59:  4C                        index                              ; 
0f5a:  0B 20                     byte                               ; 32
0f5c:  31                        ==                                 ; 
0f5d:  25 0A 00                  ||                                 ; 000a (0f68)
0f60:  02 02 C1 C0               F_PUSH                             ; push local 1, local 0
0f64:  4C                        index                              ; 
0f65:  0B 0A                     byte                               ; 10
0f67:  31                        ==                                 ; 
0f68:  17 05 00                  branch_when_zero                   ; 0005 (0f6e)
0f6b:  19 32 00                  branch                             ; 0032 (0f9e)
; std/room/xroom.lpc:732
0f6e:  02 02 C1 C0               F_PUSH                             ; push local 1, local 0
0f72:  4C                        index                              ; 
0f73:  0B 20                     byte                               ; 32
0f75:  14 0A 00                  branch_ge                          ; 000a (0f80)
; std/room/xroom.lpc:733
0f78:  0E BD                     short_string                       ; "对不起，中文描述不"
0f7a:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0f7e:  01                        pop                                ; 
; std/room/xroom.lpc:734
0f7f:  30                        return_zero                        ; 
; std/room/xroom.lpc:735
0f80:  02 02 C1 42               F_PUSH                             ; push local 1, number 2
0f84:  73                        %                                  ; 
0f85:  79                        !                                  ; 
0f86:  26 0C 00                  &&                                 ; 000c (0f93)
0f89:  02 02 C1 C0               F_PUSH                             ; push local 1, local 0
0f8d:  58                        ne_range                           ; 
0f8e:  7E 04 00 01               simul_efun                         ; "is_chinese" args: 1
0f92:  79                        !                                  ; 
0f93:  17 0A 00                  branch_when_zero                   ; 000a (0f9e)
; std/room/xroom.lpc:737
0f96:  0E BE                     short_string                       ; "对不起，描述必需是"
0f98:  7E 1B 00 01               simul_efun                         ; "write" args: 1
0f9c:  01                        pop                                ; 
; std/room/xroom.lpc:738
0f9d:  30                        return_zero                        ; 
; std/room/xroom.lpc:739
0f9e:  24 01 4B 00               while_dec                          ; LV1--, branch 004b (0f54)
; std/room/xroom.lpc:741
0fa2:  10                        const1                             ; 
0fa3:  2F                        return                             ; 
0fa4:  30                        return_zero                        ; 
; std/room/xroom.lpc:742

;; Function: public int enter_desc(object,object,string)
0fa5:  40 02                     local                              ; LV2
0fa7:  2D 59 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; check_legal_long, pushed_args:1
0fab:  18 04 00                  branch_when_non_zero               ; 0004 (0fb0)
0fae:  10                        const1                             ; 
0faf:  2F                        return                             ; 
; std/room/xroom.lpc:747
0fb0:  02 03 C0 08 3E            F_PUSH                             ; push local 0, string 8, string 62
0fb5:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0fb9:  09 50 C3 00 00 00 00 00 00  number                             ; 50000
0fc2:  14 0D 00                  branch_ge                          ; 000d (0fd0)
; std/room/xroom.lpc:749
0fc5:  40 00                     local                              ; LV0
0fc7:  0E BF                     short_string                       ; "你的银行存款不够，"
0fc9:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0fcd:  01                        pop                                ; 
; std/room/xroom.lpc:750
0fce:  10                        const1                             ; 
0fcf:  2F                        return                             ; 
; std/room/xroom.lpc:751
0fd0:  40 00                     local                              ; LV0
0fd2:  0E 44                     short_string                       ; "add"
0fd4:  0E 3E                     short_string                       ; "deposit"
0fd6:  09 B0 3C FF FF FF FF FF FF  number                             ; -50000
0fdf:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0fe3:  01                        pop                                ; 
; std/room/xroom.lpc:753
0fe4:  40 01                     local                              ; LV1
0fe6:  0E 5A                     short_string                       ; "set"
0fe8:  0E C0                     short_string                       ; "long"
0fea:  3D 02                     transfer_local                     ; LV2
0fec:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0ff0:  01                        pop                                ; 
; std/room/xroom.lpc:755
0ff1:  40 01                     local                              ; LV1
0ff3:  0E 44                     short_string                       ; "add"
0ff5:  0E C1                     short_string                       ; "renovation"
0ff7:  10                        const1                             ; 
0ff8:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0ffc:  01                        pop                                ; 
; std/room/xroom.lpc:756
0ffd:  40 01                     local                              ; LV1
0fff:  0E 5A                     short_string                       ; "set"
1001:  0E C2                     short_string                       ; "renovation_time"
1003:  03 04 01                  F_EFUN0                            ; EFUN: time(260)
1006:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
100a:  01                        pop                                ; 
; std/room/xroom.lpc:757
100b:  3D 01                     transfer_local                     ; LV1
100d:  0E 5C                     short_string                       ; "save"
100f:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
1013:  01                        pop                                ; 
; std/room/xroom.lpc:758
1014:  3D 00                     transfer_local                     ; LV0
1016:  0E 5C                     short_string                       ; "save"
1018:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
101c:  01                        pop                                ; 
; std/room/xroom.lpc:759
101d:  0E C3                     short_string                       ; "房屋描述修改成功！"
101f:  7E 1B 00 01               simul_efun                         ; "write" args: 1
1023:  01                        pop                                ; 
; std/room/xroom.lpc:760
1024:  10                        const1                             ; 
1025:  2F                        return                             ; 
1026:  30                        return_zero                        ; 
; std/room/xroom.lpc:761

;; Function: public int input_description()
1027:  0F                        const0                             ; 
1028:  04 9F 00                  F_EFUN1                            ; EFUN: this_player(159)
102b:  6B 00                     (void)assign_local                 ; LV0
; std/room/xroom.lpc:767
102d:  02 03 C0 08 2E            F_PUSH                             ; push local 0, string 8, string 46
1032:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
1036:  2D 46 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; is_owner, pushed_args:1
103a:  18 09 00                  branch_when_non_zero               ; 0009 (1044)
; std/room/xroom.lpc:769
103d:  0E 4E                     short_string                       ; "这事儿只有主人才能"
103f:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
1042:  0F                        const0                             ; 
1043:  2F                        return                             ; 
; std/room/xroom.lpc:770
1044:  40 00                     local                              ; LV0
1046:  04 B3 00                  F_EFUN1                            ; EFUN: environment(179)
1049:  6B 01                     (void)assign_local                 ; LV1
; std/room/xroom.lpc:772
104b:  02 02 C1 08               F_PUSH                             ; push local 1, string 8
104f:  0E C2                     short_string                       ; "renovation_time"
1051:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
1055:  08 58 02                  F_SHORT_INT                        ; short 600
1058:  6F                        +                                  ; 
1059:  03 04 01                  F_EFUN0                            ; EFUN: time(260)
105c:  15 09 00                  branch_le                          ; 0009 (1066)
; std/room/xroom.lpc:773
105f:  0E C4                     short_string                       ; "装修屋子的间隔时间"
1061:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
1064:  0F                        const0                             ; 
1065:  2F                        return                             ; 
; std/room/xroom.lpc:774
1066:  02 03 C0 08 3E            F_PUSH                             ; push local 0, string 8, string 62
106b:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
106f:  09 50 C3 00 00 00 00 00 00  number                             ; 50000
1078:  14 09 00                  branch_ge                          ; 0009 (1082)
; std/room/xroom.lpc:776
107b:  0E BF                     short_string                       ; "你的银行存款不够，"
107d:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
1080:  0F                        const0                             ; 
1081:  2F                        return                             ; 
; std/room/xroom.lpc:777
1082:  40 00                     local                              ; LV0
1084:  0E C5                     short_string                       ; "edit"
1086:  3D 00                     transfer_local                     ; LV0
1088:  3D 01                     transfer_local                     ; LV1
108a:  11 02 00                  aggregate                          ; 2
108d:  7D 02 58 00               (::)                               ; <local_fun> enter_desc
1091:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
1095:  01                        pop                                ; 
; std/room/xroom.lpc:779
1096:  10                        const1                             ; 
1097:  2F                        return                             ; 
1098:  30                        return_zero                        ; 
; std/room/xroom.lpc:780

;; Function: hidden void #global_init#()
1099:  2E 01 23 00 00            call_inherited                     ;              feature/annie.lpc::#global_init#    35
109e:  01                        pop                                ; 
109f:  30                        return_zero                        ; 
; std/room/xroom.lpc:5

;;;  *** Line Number Info ***

absolute line -> (file, line) table:
0 lines from 1 [std/room/xroom.lpc]
15 lines from 2 [include/globals.h]
65 lines from 3 [include/path.h]
181 lines from 2 [include/globals.h]
3 lines from 1 [std/room/xroom.lpc]
77 lines from 4 [include/ansi.h]
790 lines from 1 [std/room/xroom.lpc]

address -> absolute line table:
0000-000a: 354
000b-000c: 355
000d-0017: 356
0018-0019: 357
001a-0024: 361
0025-002b: 362
002c-0031: 363
0032-0043: 364
0044-004c: 365
004d-004d: 366
004e-004f: 368
0050-0051: 370
0052-0059: 376
005a-006a: 377
006b-007b: 378
007c-008c: 379
008d-009d: 380
009e-00ae: 381
00af-00bf: 382
00c0-00c8: 384
00c9-00cd: 385
00ce-00d2: 386
00d3-00db: 387
00dc-00e4: 388
00e5-00eb: 391
00ec-00f2: 392
00f3-00f9: 394
00fa-0100: 395
0101-0107: 397
0108-010e: 398
010f-0115: 399
0116-011c: 400
011d-0124: 401
0125-012a: 408
012b-013f: 410
0140-0140: 411
0141-0149: 414
014a-014c: 415
014d-0153: 452
0154-0155: 453
0156-0162: 458
0163-016a: 464
016b-0174: 466
0175-017a: 467
017b-0181: 468
0182-0188: 469
0189-018f: 470
0190-01cb: 471
01cc-01d2: 474
01d3-01db: 479
01dc-01e5: 480
01e6-01f1: 482
01f2-0208: 488
0209-0223: 489
0224-022b: 490
022c-023d: 496
023e-0245: 498
0246-0249: 499
024a-024d: 501
024e-025c: 508
025d-0264: 510
0265-0268: 511
0269-026c: 513
026d-0272: 569
0273-0282: 571
0283-0289: 572
028a-0299: 574
029a-02a0: 575
02a1-02af: 576
02b0-02b6: 578
02b7-02bf: 579
02c0-02c8: 580
02c9-02d1: 581
02d2-02da: 582
02db-02e4: 583
02e5-02e6: 584
02e7-02ed: 587
02ee-02f6: 588
02f7-02ff: 589
0300-0308: 590
0309-0311: 591
0312-031b: 592
031c-031d: 593
031e-0325: 596
0326-032b: 602
032c-033b: 605
033c-0342: 606
0343-0348: 608
0349-034e: 609
034f-0359: 611
035a-0360: 612
0361-036f: 614
0370-0376: 615
0377-037c: 617
037d-0382: 618
0383-038e: 620
038f-0395: 621
0396-03a6: 623
03a7-03ad: 624
03ae-03be: 625
03bf-03cd: 627
03ce-03de: 628
03df-03ef: 630
03f0-03fd: 631
03fe-0412: 633
0413-041b: 635
041c-0424: 636
0425-042c: 637
042d-043c: 639
043d-0445: 640
0446-0449: 647
044a-044f: 643
0450-0459: 644
045a-0462: 645
0463-0468: 646
0469-0478: 647
0479-047f: 648
0480-0488: 649
0489-048d: 652
048e-0490: 653
0491-0496: 663
0497-049e: 665
049f-04a6: 666
04a7-04b0: 668
04b1-04b6: 669
04b7-04bd: 670
04be-04c4: 671
04c5-04cb: 672
04cc-0507: 673
0508-0517: 676
0518-051e: 677
051f-0529: 679
052a-0530: 680
0531-053f: 682
0540-0546: 683
0547-054e: 685
054f-0555: 686
0556-0569: 688
056a-0570: 689
0571-0580: 691
0581-058d: 692
058e-0597: 694
0598-05a2: 695
05a3-05ae: 696
05af-05bb: 697
05bc-05c8: 698
05c9-05d5: 699
05d6-05f5: 700
05f6-05fc: 703
05fd-0603: 704
0604-0615: 708
0616-061c: 709
061d-062d: 710
062e-063c: 712
063d-064d: 713
064e-0652: 715
0653-0656: 724
0657-065c: 718
065d-0666: 719
0667-066f: 720
0670-0679: 721
067a-067b: 722
067c-067d: 723
067e-068b: 724
068c-0698: 726
0699-06a5: 727
06a6-06c0: 728
06c1-06c9: 729
06ca-06db: 731
06dc-06e9: 732
06ea-06fe: 733
06ff-0707: 734
0708-070e: 735
070f-0715: 736
0716-0718: 737
0719-071f: 761
0720-0749: 762
074a-0759: 763
075a-0766: 764
0767-0784: 765
0785-0794: 766
0795-07a1: 767
07a2-07a8: 768
07a9-07dd: 769
07de-07ed: 770
07ee-07fa: 771
07fb-0801: 772
0802-080c: 773
080d-0813: 774
0814-081a: 775
081b-0821: 776
0822-0828: 777
0829-0833: 778
0834-0843: 779
0844-0853: 780
0854-0883: 782
0884-0893: 783
0894-08a0: 784
08a1-08a7: 785
08a8-08bd: 787
08be-08cd: 788
08ce-08da: 789
08db-08fa: 791
08fb-090e: 792
090f-0929: 793
092a-0939: 795
093a-0946: 796
0947-094d: 798
094e-0978: 799
0979-0988: 800
0989-0995: 801
0996-099c: 803
099d-09c0: 805
09c1-09d0: 806
09d1-09da: 807
09db-09e1: 811
09e2-09e4: 813
09e5-09e7: 823
09e8-09ef: 824
09f0-09ff: 826
0a00-0a02: 827
0a03-0a0a: 830
0a0b-0a0d: 831
0a0e-0a20: 832
0a21-0a23: 833
0a24-0a38: 837
0a39-0a3b: 839
0a3c-0a4b: 840
0a4c-0a58: 841
0a59-0a61: 842
0a62-0a6a: 843
0a6b-0a80: 844
0a81-0a8b: 846
0a8c-0a94: 847
0a95-0a9d: 848
0a9e-0aa6: 849
0aa7-0ab7: 852
0ab8-0abe: 853
0abf-0ad1: 854
0ad2-0ad2: 855
0ad3-0ae4: 858
0ae5-0afa: 859
0afb-0afb: 860
0afc-0b0c: 862
0b0d-0b1d: 863
0b1e-0b38: 864
0b39-0b41: 865
0b42-0b4d: 866
0b4e-0b55: 867
0b56-0b5d: 868
0b5e-0b62: 869
0b63-0b72: 871
0b73-0b7b: 872
0b7c-0b7f: 879
0b80-0b85: 875
0b86-0b8f: 876
0b90-0b98: 877
0b99-0b9e: 878
0b9f-0bae: 879
0baf-0bb7: 880
0bb8-0bbc: 883
0bbd-0bbf: 884
0bc0-0bda: 888
0bdb-0be3: 889
0be4-0be7: 891
0be8-0bed: 899
0bee-0bfe: 900
0bff-0bff: 901
0c00-0c07: 903
0c08-0c0c: 905
0c0d-0c14: 906
0c15-0c1b: 907
0c1c-0c28: 908
0c29-0c34: 909
0c35-0c3e: 910
0c3f-0c4b: 911
0c4c-0c4d: 912
0c4e-0c58: 914
0c59-0c65: 915
0c66-0c67: 916
0c68-0c6f: 919
0c70-0c76: 921
0c77-0c7d: 922
0c7e-0c8f: 923
0c90-0c96: 924
0c97-0c9d: 925
0c9e-0c9f: 926
0ca0-0ca6: 928
0ca7-0cac: 929
0cad-0cbb: 930
0cbc-0cc5: 929
0cc6-0ccc: 931
0ccd-0ccf: 932
0cd0-0cee: 937
0cef-0cef: 938
0cf0-0cf7: 939
0cf8-0d00: 940
0d01-0d0d: 941
0d0e-0d18: 942
0d19-0d1b: 943
0d1c-0d21: 949
0d22-0d33: 950
0d34-0d34: 951
0d35-0d40: 952
0d41-0d47: 953
0d48-0d4c: 954
0d4d-0d53: 955
0d54-0d60: 956
0d61-0d67: 957
0d68-0d72: 958
0d73-0d79: 959
0d7a-0d82: 960
0d83-0d89: 961
0d8a-0d91: 962
0d92-0d98: 963
0d99-0da1: 964
0da2-0dae: 965
0daf-0dcf: 966
0dd0-0dd2: 967
0dd3-0ddb: 971
0ddc-0ddd: 972
0dde-0de5: 979
0de6-0dee: 980
0def-0e0c: 981
0e0d-0e16: 987
0e17-0e27: 988
0e28-0e31: 989
0e32-0e3a: 990
0e3b-0e3d: 991
0e3e-0e3f: 993
0e40-0e50: 999
0e51-0e58: 1000
0e59-0e5a: 1001
0e5b-0e5b: 1002
0e5c-0e63: 1031
0e64-0e75: 1032
0e76-0e77: 1033
0e78-0e7e: 1036
0e7f-0e84: 1037
0e85-0e96: 1038
0e97-0ea4: 1039
0ea5-0eac: 1040
0ead-0eb8: 1041
0eb9-0ec4: 1042
0ec5-0ecd: 1043
0ece-0ecf: 1044
0ed0-0ed9: 1037
0eda-0edc: 1045
0edd-0ee2: 1051
0ee3-0eea: 1053
0eeb-0ef0: 1054
0ef1-0f03: 1055
0f04-0f14: 1056
0f15-0f16: 1057
0f17-0f20: 1054
0f21-0f22: 1058
0f23-0f29: 1064
0f2a-0f40: 1065
0f41-0f50: 1066
0f51-0f54: 1067
0f55-0f6d: 1070
0f6e-0f77: 1071
0f78-0f7e: 1072
0f7f-0f7f: 1073
0f80-0f95: 1075
0f96-0f9c: 1076
0f9d-0f9d: 1077
0f9e-0fa1: 1079
0fa2-0fa4: 1080
0fa5-0faf: 1085
0fb0-0fc4: 1087
0fc5-0fcd: 1088
0fce-0fcf: 1089
0fd0-0fe3: 1091
0fe4-0ff0: 1093
0ff1-0ffc: 1094
0ffd-100a: 1095
100b-1013: 1096
1014-101c: 1097
101d-1023: 1098
1024-1026: 1099
1027-102c: 1105
102d-103c: 1107
103d-1043: 1108
1044-104a: 1110
104b-105e: 1111
105f-1065: 1112
1066-107a: 1114
107b-1081: 1115
1082-1095: 1117
1096-1098: 1118
1099-109f: 343

;;; std/room.lpc

Globals:
   0: dbase
   1: tmp_dbase
   2: default_ob
VARIABLES defined:
STRINGS:
   0: std/room.lpc
   1: include/globals.h
   2: include/path.h
   3: include/dbase.h
   4: CAN NOT CLONE STARNDARD OBJECT!\n
   5: move
   6: startroom
   7: set
   8: is_character
   9: query
  10: no_reset
  11: no_clean_up
  12: objects
  13: reset
  14: /adm/daemons/natured
  15: is_day_time
  16: long_day
  17: long_night
  18: long
  19: short
  20: 。\n
DISASSEMBLY:

;; Function: public void create()
0000:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0003:  04 DF 00                  F_EFUN1                            ; EFUN: clonep(223)
0006:  17 11 00                  branch_when_zero                   ; 0011 (0018)
; std/room.lpc:22
0009:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
000c:  7E 10 00 01               simul_efun                         ; "destruct" args: 1
0010:  01                        pop                                ; 
; std/room.lpc:23
0011:  0E 04                     short_string                       ; "CAN NOT CLONE STARNDARD OBJEC"
0013:  04 C8 00                  F_EFUN1                            ; EFUN: notify_fail(200)
0016:  0F                        const0                             ; 
0017:  2F                        return                             ; 
0018:  30                        return_zero                        ; 
; std/room.lpc:24

;; Function: public int query_max_encumbrance()
0019:  09 00 E8 76 48 17 00 00 00  number                             ; 100000000000
0022:  2F                        return                             ; 
; std/room.lpc:29

;; Function: public object make_inventory(string)
0023:  3D 00                     transfer_local                     ; LV0
0025:  07 9D 00 01               F_EFUNV                            ; EFUN: new(157)
0029:  6B 01                     (void)assign_local                 ; LV1
; std/room.lpc:35
002b:  40 01                     local                              ; LV1
002d:  04 E7 00                  F_EFUN1                            ; EFUN: objectp(231)
0030:  17 1F 00                  branch_when_zero                   ; 001f (0050)
; std/room.lpc:36
0033:  02 02 C1 05               F_PUSH                             ; push local 1, string 5
0037:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
003a:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
003e:  01                        pop                                ; 
; std/room.lpc:37
003f:  02 03 C1 07 06            F_PUSH                             ; push local 1, string 7, string 6
0044:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0047:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
004b:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
004f:  01                        pop                                ; 
; std/room.lpc:38
0050:  3D 01                     transfer_local                     ; LV1
0052:  2F                        return                             ; 
0053:  30                        return_zero                        ; 
; std/room.lpc:40

;; Function: public void reset()
0054:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0057:  04 B4 00                  F_EFUN1                            ; EFUN: all_inventory(180)
005a:  6B 05                     (void)assign_local                 ; LV5
; std/room.lpc:51
005c:  40 05                     local                              ; LV5
005e:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0061:  10                        const1                             ; 
0062:  70                        subtract                           ; 
0063:  6B 03                     (void)assign_local                 ; LV3
0065:  19 47 00                  branch                             ; 0047 (00ad)
; std/room.lpc:52
0068:  02 02 C3 C5               F_PUSH                             ; push local 3, local 5
006c:  4C                        index                              ; 
006d:  0E 08                     short_string                       ; "is_character"
006f:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0073:  79                        !                                  ; 
0074:  26 28 00                  &&                                 ; 0028 (009d)
; std/room.lpc:53
0077:  02 02 C3 C5               F_PUSH                             ; push local 3, local 5
007b:  4C                        index                              ; 
007c:  02 02 09 06               F_PUSH                             ; push string 9, string 6
0080:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0084:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0087:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
008b:  32                        !=                                 ; 
008c:  26 10 00                  &&                                 ; 0010 (009d)
; std/room.lpc:54
008f:  02 02 C3 C5               F_PUSH                             ; push local 3, local 5
0093:  4C                        index                              ; 
0094:  02 02 09 0A               F_PUSH                             ; push string 9, string 10
0098:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
009c:  79                        !                                  ; 
009d:  17 0C 00                  branch_when_zero                   ; 000c (00aa)
; std/room.lpc:55
00a0:  02 02 C3 C5               F_PUSH                             ; push local 3, local 5
00a4:  4C                        index                              ; 
00a5:  7E 10 00 01               simul_efun                         ; "destruct" args: 1
00a9:  01                        pop                                ; 
; std/room.lpc:56
00aa:  41 03                     local_lvalue                       ; LV3
00ac:  38                        dec(x)                             ; 
00ad:  02 02 C3 40               F_PUSH                             ; push local 3, number 0
00b1:  35                        >=                                 ; 
00b2:  1B 4B 00                  bbranch_when_non_zero              ; 004b (0068)
; std/room.lpc:52
00b5:  02 02 0B 40               F_PUSH                             ; push string 11, number 0
00b9:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
00bd:  01                        pop                                ; 
; std/room.lpc:67
00be:  0E 0C                     short_string                       ; "objects"
00c0:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
00c4:  6B 00                     (void)assign_local                 ; LV0
; std/room.lpc:68
00c6:  40 00                     local                              ; LV0
00c8:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
00cb:  18 03 00                  branch_when_non_zero               ; 0003 (00cf)
; std/room.lpc:69
00ce:  30                        return_zero                        ; 
; std/room.lpc:70
00cf:  0E 0C                     short_string                       ; "objects"
00d1:  2D 0E 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query_temp, pushed_args:1
00d5:  6C 01                     assign_local                       ; LV1
00d7:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
00da:  18 0C 00                  branch_when_non_zero               ; 000c (00e7)
; std/room.lpc:72
00dd:  40 00                     local                              ; LV0
00df:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
00e2:  04 DA 00                  F_EFUN1                            ; EFUN: allocate_mapping(218)
00e5:  6B 01                     (void)assign_local                 ; LV1
; std/room.lpc:73
00e7:  40 00                     local                              ; LV0
00e9:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
00ec:  6B 02                     (void)assign_local                 ; LV2
; std/room.lpc:76
00ee:  0F                        const0                             ; 
00ef:  6B 03                     (void)assign_local                 ; LV3
00f1:  19 BF 00                  branch                             ; 00bf (01b1)
; std/room.lpc:77
00f4:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
00f8:  4C                        index                              ; 
00f9:  40 01                     local                              ; LV1
00fb:  4C                        index                              ; 
00fc:  04 E1 00                  F_EFUN1                            ; EFUN: undefinedp(225)
00ff:  26 1A 00                  &&                                 ; 001a (011a)
0102:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0106:  4C                        index                              ; 
0107:  40 00                     local                              ; LV0
0109:  4C                        index                              ; 
010a:  04 E0 00                  F_EFUN1                            ; EFUN: intp(224)
010d:  26 0C 00                  &&                                 ; 000c (011a)
0110:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0114:  4C                        index                              ; 
0115:  40 00                     local                              ; LV0
0117:  4C                        index                              ; 
0118:  10                        const1                             ; 
0119:  36                        >                                  ; 
011a:  17 16 00                  branch_when_zero                   ; 0016 (0131)
; std/room.lpc:79
011d:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0121:  4C                        index                              ; 
0122:  40 00                     local                              ; LV0
0124:  4C                        index                              ; 
0125:  04 F0 00                  F_EFUN1                            ; EFUN: allocate(240)
0128:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
012c:  4C                        index                              ; 
012d:  41 01                     local_lvalue                       ; LV1
012f:  4D                        index_lvalue                       ; 
0130:  6A                        (void)assign                       ; 
; std/room.lpc:80
0131:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0135:  4C                        index                              ; 
0136:  40 00                     local                              ; LV0
0138:  4C                        index                              ; 
0139: switch
      type: fe table: 01a5-01af deflt: 0164
0141:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0145:  4C                        index                              ; 
0146:  40 01                     local                              ; LV1
0148:  4C                        index                              ; 
0149:  18 17 00                  branch_when_non_zero               ; 0017 (0161)
; std/room.lpc:85
014c:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0150:  4C                        index                              ; 
0151:  2D 17 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; make_inventory, pushed_args:1
0155:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0159:  4C                        index                              ; 
015a:  41 01                     local_lvalue                       ; LV1
015c:  4D                        index_lvalue                       ; 
015d:  6A                        (void)assign                       ; 
015e:  19 50 00                  branch                             ; 0050 (01af)
0161:  19 4D 00                  branch                             ; 004d (01af)
; std/room.lpc:86
0164:  0F                        const0                             ; 
0165:  6B 04                     (void)assign_local                 ; LV4
0167:  19 2B 00                  branch                             ; 002b (0193)
; std/room.lpc:108
016a:  02 03 C4 C3 C2            F_PUSH                             ; push local 4, local 3, local 2
016f:  4C                        index                              ; 
0170:  40 01                     local                              ; LV1
0172:  4C                        index                              ; 
0173:  4C                        index                              ; 
0174:  04 E7 00                  F_EFUN1                            ; EFUN: objectp(231)
0177:  18 19 00                  branch_when_non_zero               ; 0019 (0191)
; std/room.lpc:110
017a:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
017e:  4C                        index                              ; 
017f:  2D 17 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; make_inventory, pushed_args:1
0183:  02 03 C4 C3 C2            F_PUSH                             ; push local 4, local 3, local 2
0188:  4C                        index                              ; 
0189:  41 01                     local_lvalue                       ; LV1
018b:  4D                        index_lvalue                       ; 
018c:  4D                        index_lvalue                       ; 
018d:  6A                        (void)assign                       ; 
018e:  19 02 00                  branch                             ; 0002 (0191)
; std/room.lpc:111
0191:  23 04                     loop_incr                          ; LV4
; std/room.lpc:127
0193:  02 03 C4 C3 C2            F_PUSH                             ; push local 4, local 3, local 2
0198:  4C                        index                              ; 
0199:  40 00                     local                              ; LV0
019b:  4C                        index                              ; 
019c:  1D 33 00                  bbranch_lt                         ; 0033 (016a)
019f:  19 0F 00                  branch                             ; 000f (01af)
01a2:  19 0C 00                  branch                             ; 000c (01af)
; std/room.lpc:108
      switch table (for 0139)
	 0: 0141
	minval = 1
; std/room.lpc:82
01af:  23 03                     loop_incr                          ; LV3
; std/room.lpc:130
01b1:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
01b5:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
01b8:  1D C5 00                  bbranch_lt                         ; 00c5 (00f4)
; std/room.lpc:77
01bb:  0E 0C                     short_string                       ; "objects"
01bd:  3D 01                     transfer_local                     ; LV1
01bf:  2D 04 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
01c3:  01                        pop                                ; 
01c4:  30                        return_zero                        ; 
; std/room.lpc:131

;; Function: public int usr_in()
01c5:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
01c8:  04 B5 00                  F_EFUN1                            ; EFUN: deep_inventory(181)
01cb:  6B 00                     (void)assign_local                 ; LV0
; std/room.lpc:139
01cd:  40 00                     local                              ; LV0
01cf:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
01d2:  6B 01                     (void)assign_local                 ; LV1
01d4:  19 0F 00                  branch                             ; 000f (01e4)
; std/room.lpc:140
01d7:  02 02 C1 C0               F_PUSH                             ; push local 1, local 0
01db:  4C                        index                              ; 
01dc:  04 31 01                  F_EFUN1                            ; EFUN: userp(305)
01df:  17 04 00                  branch_when_zero                   ; 0004 (01e4)
01e2:  10                        const1                             ; 
01e3:  2F                        return                             ; 
; std/room.lpc:143
01e4:  24 01 0F 00               while_dec                          ; LV1--, branch 000f (01d6)
; std/room.lpc:144
01e8:  30                        return_zero                        ; 
01e9:  30                        return_zero                        ; 
; std/room.lpc:145

;; Function: public void setup()
01ea:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
01ed:  04 00 02                  F_EFUN1                            ; EFUN: getuid(512)
01f0:  04 01 02                  F_EFUN1                            ; EFUN: seteuid(513)
01f3:  01                        pop                                ; 
; std/room.lpc:149
01f4:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
01f7:  0E 0D                     short_string                       ; "reset"
01f9:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
01fd:  01                        pop                                ; 
01fe:  30                        return_zero                        ; 
; std/room.lpc:150

;; Function: public string long()
01ff:  02 02 0E 0F               F_PUSH                             ; push string 14, string 15
0203:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0207:  17 0D 00                  branch_when_zero                   ; 000d (0215)
; std/room.lpc:155
020a:  0E 10                     short_string                       ; "long_day"
020c:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0210:  6B 00                     (void)assign_local                 ; LV0
0212:  19 0A 00                  branch                             ; 000a (021d)
; std/room.lpc:156
0215:  0E 11                     short_string                       ; "long_night"
0217:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
021b:  6B 00                     (void)assign_local                 ; LV0
; std/room.lpc:158
021d:  40 00                     local                              ; LV0
021f:  04 E3 00                  F_EFUN1                            ; EFUN: stringp(227)
0222:  18 1D 00                  branch_when_non_zero               ; 001d (0240)
; std/room.lpc:160
0225:  0E 12                     short_string                       ; "long"
0227:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
022b:  6B 00                     (void)assign_local                 ; LV0
; std/room.lpc:161
022d:  40 00                     local                              ; LV0
022f:  04 E3 00                  F_EFUN1                            ; EFUN: stringp(227)
0232:  18 0D 00                  branch_when_non_zero               ; 000d (0240)
; std/room.lpc:162
0235:  0E 13                     short_string                       ; "short"
0237:  2D 03 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
023b:  0E 14                     short_string                       ; "。\n"
023d:  6F                        +                                  ; 
023e:  6B 00                     (void)assign_local                 ; LV0
; std/room.lpc:163
0240:  3D 00                     transfer_local                     ; LV0
0242:  2F                        return                             ; 
0243:  30                        return_zero                        ; 
; std/room.lpc:167

;; Function: public int valid_leave(object,string)
0244:  10                        const1                             ; 
0245:  2F                        return                             ; 
; std/room.lpc:171

;;;  *** Line Number Info ***

absolute line -> (file, line) table:
0 lines from 1 [std/room.lpc]
15 lines from 2 [include/globals.h]
65 lines from 3 [include/path.h]
181 lines from 2 [include/globals.h]
16 lines from 1 [std/room.lpc]
23 lines from 4 [include/dbase.h]
157 lines from 1 [std/room.lpc]

address -> absolute line table:
0000-0008: 306
0009-0010: 307
0011-0018: 308
0019-0022: 313
0023-002a: 319
002b-0032: 320
0033-003e: 321
003f-004f: 322
0050-0053: 324
0054-005b: 335
005c-0067: 336
0068-0076: 337
0077-008e: 338
008f-009f: 339
00a0-00a9: 340
00aa-00b4: 336
00b5-00bd: 351
00be-00c5: 352
00c6-00cd: 353
00ce-00ce: 354
00cf-00dc: 356
00dd-00e6: 357
00e7-00ed: 360
00ee-00f3: 361
00f4-011c: 363
011d-0130: 364
0131-0140: 366
0141-014b: 369
014c-0163: 370
0164-0169: 392
016a-0179: 394
017a-0190: 395
0191-0192: 411
0193-01ae: 392
01af-01b0: 414
01b1-01ba: 361
01bb-01c4: 415
01c5-01cc: 423
01cd-01d6: 424
01d7-01e3: 427
01e4-01e7: 428
01e8-01e9: 429
01ea-01f3: 433
01f4-01fe: 434
01ff-0209: 439
020a-0214: 440
0215-021c: 442
021d-0224: 444
0225-022c: 445
022d-0234: 446
0235-023f: 447
0240-0243: 451
0244-0245: 455

;;; feature/dbase.lpc

Globals:
   0: dbase
   1: tmp_dbase
   2: default_ob
VARIABLES defined:
   0: public mapping dbase
   1: public nosave mapping tmp_dbase
   2: public nosave mixed default_ob
STRINGS:
   0: feature/dbase.lpc
   1: include/globals.h
   2: include/path.h
   3: no_clean_up
   4: add
   5: /
   6: .
   7: query
   8: dbase: add() - called on a funct
   9: dbase: add_temp() - called on a 
DISASSEMBLY:

;; Function: public mixed query_default_object()
0000:  44 02 00                  global                             ; default_ob(2)
0003:  2F                        return                             ; 
; feature/dbase.lpc:10

;; Function: public void set_default_object(mixed)
0004:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0007:  04 FF 01                  F_EFUN1                            ; EFUN: geteuid(511)
000a:  18 0C 00                  branch_when_non_zero               ; 000c (0017)
000d:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0010:  04 00 02                  F_EFUN1                            ; EFUN: getuid(512)
0013:  04 01 02                  F_EFUN1                            ; EFUN: seteuid(513)
0016:  01                        pop                                ; 
; feature/dbase.lpc:15
0017:  40 00                     local                              ; LV0
0019:  6E 02 00                  (void)assign_global                ; default_ob(2)
; feature/dbase.lpc:16
001c:  3D 00                     transfer_local                     ; LV0
001e:  02 03 04 03 41            F_PUSH                             ; push string 4, string 3, number 1
0023:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0027:  01                        pop                                ; 
0028:  30                        return_zero                        ; 
; feature/dbase.lpc:17

;; Function: public mixed set(string,mixed)
0029:  44 00 00                  global                             ; dbase(0)
002c:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
002f:  18 08 00                  branch_when_non_zero               ; 0008 (0038)
0032:  12 00 00                  aggregate_assoc                    ; 0
0035:  6E 00 00                  (void)assign_global                ; dbase(0)
; feature/dbase.lpc:21
0038:  02 03 C0 6F 40            F_PUSH                             ; push local 0, number 47, number 0
003d:  06 D1 00                  F_EFUN3                            ; EFUN: strsrch(209)
0040:  0C 01                     -byte                              ; -1
0042:  16 11 00                  branch_eq                          ; 0011 (0054)
; feature/dbase.lpc:23
0045:  02 03 80 C0 05            F_PUSH                             ; push global 0, local 0, string 5
004a:  05 A6 00                  F_EFUN2                            ; EFUN: explode(166)
004d:  40 01                     local                              ; LV1
004f:  2D 02 00 03               F_CALL_FUNCTION_BY_ADDRESS         ; _set, pushed_args:3
0053:  2F                        return                             ; 
; feature/dbase.lpc:24
0054:  3D 01                     transfer_local                     ; LV1
0056:  3D 00                     transfer_local                     ; LV0
0058:  45 00 00                  global_lvalue                      ; dbase(0)
005b:  4D                        index_lvalue                       ; 
005c:  64                        assign                             ; 
005d:  2F                        return                             ; 
005e:  30                        return_zero                        ; 
; feature/dbase.lpc:25

;; Function: public mixed set_with_slash(string,mixed)
005f:  44 00 00                  global                             ; dbase(0)
0062:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0065:  18 08 00                  branch_when_non_zero               ; 0008 (006e)
0068:  12 00 00                  aggregate_assoc                    ; 0
006b:  6E 00 00                  (void)assign_global                ; dbase(0)
; feature/dbase.lpc:28
006e:  02 03 C0 6E 40            F_PUSH                             ; push local 0, number 46, number 0
0073:  06 D1 00                  F_EFUN3                            ; EFUN: strsrch(209)
0076:  0C 01                     -byte                              ; -1
0078:  16 11 00                  branch_eq                          ; 0011 (008a)
; feature/dbase.lpc:30
007b:  02 03 80 C0 06            F_PUSH                             ; push global 0, local 0, string 6
0080:  05 A6 00                  F_EFUN2                            ; EFUN: explode(166)
0083:  40 01                     local                              ; LV1
0085:  2D 02 00 03               F_CALL_FUNCTION_BY_ADDRESS         ; _set, pushed_args:3
0089:  2F                        return                             ; 
; feature/dbase.lpc:31
008a:  3D 01                     transfer_local                     ; LV1
008c:  3D 00                     transfer_local                     ; LV0
008e:  45 00 00                  global_lvalue                      ; dbase(0)
0091:  4D                        index_lvalue                       ; 
0092:  64                        assign                             ; 
0093:  2F                        return                             ; 
0094:  30                        return_zero                        ; 
; feature/dbase.lpc:33

;; Function: public varargs mixed query_with_slash(string,int)
0095:  44 00 00                  global                             ; dbase(0)
0098:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
009b:  18 03 00                  branch_when_non_zero               ; 0003 (009f)
009e:  30                        return_zero                        ; 
; feature/dbase.lpc:38
009f:  02 02 C0 80               F_PUSH                             ; push local 0, global 0
00a3:  4C                        index                              ; 
00a4:  04 E1 00                  F_EFUN1                            ; EFUN: undefinedp(225)
00a7:  26 0D 00                  &&                                 ; 000d (00b5)
00aa:  02 03 C0 6E 40            F_PUSH                             ; push local 0, number 46, number 0
00af:  06 D1 00                  F_EFUN3                            ; EFUN: strsrch(209)
00b2:  0C 01                     -byte                              ; -1
00b4:  32                        !=                                 ; 
00b5:  17 13 00                  branch_when_zero                   ; 0013 (00c9)
; feature/dbase.lpc:40
00b8:  02 03 80 C0 06            F_PUSH                             ; push global 0, local 0, string 6
00bd:  05 A6 00                  F_EFUN2                            ; EFUN: explode(166)
00c0:  2D 00 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; _query, pushed_args:2
00c4:  6B 02                     (void)assign_local                 ; LV2
00c6:  19 09 00                  branch                             ; 0009 (00d0)
; feature/dbase.lpc:41
00c9:  02 02 C0 80               F_PUSH                             ; push local 0, global 0
00cd:  4C                        index                              ; 
00ce:  6B 02                     (void)assign_local                 ; LV2
; feature/dbase.lpc:43
00d0:  40 02                     local                              ; LV2
00d2:  04 E1 00                  F_EFUN1                            ; EFUN: undefinedp(225)
00d5:  26 05 00                  &&                                 ; 0005 (00db)
00d8:  44 02 00                  global                             ; default_ob(2)
00db:  17 0E 00                  branch_when_zero                   ; 000e (00ea)
; feature/dbase.lpc:45
00de:  02 04 82 07 C0 41         F_PUSH                             ; push global 2, string 7, local 0, number 1
00e4:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
00e8:  6B 02                     (void)assign_local                 ; LV2
; feature/dbase.lpc:46
00ea:  3D 01                     transfer_local                     ; LV1
00ec:  17 05 00                  branch_when_zero                   ; 0005 (00f2)
00ef:  40 02                     local                              ; LV2
00f1:  2F                        return                             ; 
; feature/dbase.lpc:48
00f2:  3D 02                     transfer_local                     ; LV2
00f4:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
00f7:  07 98 00 02               F_EFUNV                            ; EFUN: evaluate(152)
00fb:  2F                        return                             ; 
00fc:  30                        return_zero                        ; 
; feature/dbase.lpc:50

;; Function: public varargs mixed query(string,int)
00fd:  44 00 00                  global                             ; dbase(0)
0100:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0103:  18 03 00                  branch_when_non_zero               ; 0003 (0107)
; feature/dbase.lpc:56
0106:  30                        return_zero                        ; 
; feature/dbase.lpc:57
0107:  02 02 C0 80               F_PUSH                             ; push local 0, global 0
010b:  4C                        index                              ; 
010c:  04 E1 00                  F_EFUN1                            ; EFUN: undefinedp(225)
010f:  26 0D 00                  &&                                 ; 000d (011d)
0112:  02 03 C0 6F 40            F_PUSH                             ; push local 0, number 47, number 0
0117:  06 D1 00                  F_EFUN3                            ; EFUN: strsrch(209)
011a:  0C 01                     -byte                              ; -1
011c:  32                        !=                                 ; 
011d:  17 13 00                  branch_when_zero                   ; 0013 (0131)
; feature/dbase.lpc:60
0120:  02 03 80 C0 05            F_PUSH                             ; push global 0, local 0, string 5
0125:  05 A6 00                  F_EFUN2                            ; EFUN: explode(166)
0128:  2D 00 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; _query, pushed_args:2
012c:  6B 02                     (void)assign_local                 ; LV2
012e:  19 09 00                  branch                             ; 0009 (0138)
; feature/dbase.lpc:61
0131:  02 02 C0 80               F_PUSH                             ; push local 0, global 0
0135:  4C                        index                              ; 
0136:  6B 02                     (void)assign_local                 ; LV2
; feature/dbase.lpc:63
0138:  44 02 00                  global                             ; default_ob(2)
013b:  17 3C 00                  branch_when_zero                   ; 003c (0178)
; feature/dbase.lpc:66
013e:  40 02                     local                              ; LV2
0140:  04 E1 00                  F_EFUN1                            ; EFUN: undefinedp(225)
0143:  17 11 00                  branch_when_zero                   ; 0011 (0155)
; feature/dbase.lpc:67
0146:  02 04 82 07 C0 41         F_PUSH                             ; push global 2, string 7, local 0, number 1
014c:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0150:  6B 02                     (void)assign_local                 ; LV2
0152:  19 25 00                  branch                             ; 0025 (0178)
; feature/dbase.lpc:68
0155:  40 02                     local                              ; LV2
0157:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
015a:  17 1D 00                  branch_when_zero                   ; 001d (0178)
; feature/dbase.lpc:69
015d:  02 04 82 07 C0 41         F_PUSH                             ; push global 2, string 7, local 0, number 1
0163:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0167:  6B 03                     (void)assign_local                 ; LV3
; feature/dbase.lpc:70
0169:  40 03                     local                              ; LV3
016b:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
016e:  17 09 00                  branch_when_zero                   ; 0009 (0178)
; feature/dbase.lpc:71
0171:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0175:  6F                        +                                  ; 
0176:  6B 02                     (void)assign_local                 ; LV2
; feature/dbase.lpc:72
0178:  3D 01                     transfer_local                     ; LV1
017a:  17 05 00                  branch_when_zero                   ; 0005 (0180)
; feature/dbase.lpc:77
017d:  40 02                     local                              ; LV2
017f:  2F                        return                             ; 
; feature/dbase.lpc:78
0180:  3D 02                     transfer_local                     ; LV2
0182:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0185:  07 98 00 02               F_EFUNV                            ; EFUN: evaluate(152)
0189:  2F                        return                             ; 
018a:  30                        return_zero                        ; 
; feature/dbase.lpc:81

;; Function: public int delete(string)
018b:  44 00 00                  global                             ; dbase(0)
018e:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0191:  18 03 00                  branch_when_non_zero               ; 0003 (0195)
0194:  30                        return_zero                        ; 
; feature/dbase.lpc:85
0195:  02 03 C0 6F 40            F_PUSH                             ; push local 0, number 47, number 0
019a:  06 D1 00                  F_EFUN3                            ; EFUN: strsrch(209)
019d:  0C 01                     -byte                              ; -1
019f:  16 12 00                  branch_eq                          ; 0012 (01b2)
; feature/dbase.lpc:87
01a2:  02 03 80 C0 05            F_PUSH                             ; push global 0, local 0, string 5
01a7:  05 A6 00                  F_EFUN2                            ; EFUN: explode(166)
01aa:  2D 01 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; _delete, pushed_args:2
01ae:  2F                        return                             ; 
01af:  19 0B 00                  branch                             ; 000b (01bb)
; feature/dbase.lpc:88
01b2:  02 02 80 C0               F_PUSH                             ; push global 0, local 0
01b6:  05 DD 00                  F_EFUN2                            ; EFUN: map_delete(221)
; feature/dbase.lpc:90
01b9:  10                        const1                             ; 
01ba:  2F                        return                             ; 
01bb:  30                        return_zero                        ; 
; feature/dbase.lpc:91

;; Function: public mixed add(string,mixed)
01bc:  44 00 00                  global                             ; dbase(0)
01bf:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
01c2:  79                        !                                  ; 
01c3:  25 0D 00                  ||                                 ; 000d (01d1)
01c6:  02 02 C0 41               F_PUSH                             ; push local 0, number 1
01ca:  2D 03 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:2
01ce:  6C 02                     assign_local                       ; LV2
01d0:  79                        !                                  ; 
01d1:  17 0B 00                  branch_when_zero                   ; 000b (01dd)
; feature/dbase.lpc:98
01d4:  02 02 C0 C1               F_PUSH                             ; push local 0, local 1
01d8:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
01dc:  2F                        return                             ; 
; feature/dbase.lpc:99
01dd:  40 02                     local                              ; LV2
01df:  04 E5 00                  F_EFUN1                            ; EFUN: functionp(229)
01e2:  17 07 00                  branch_when_zero                   ; 0007 (01ea)
; feature/dbase.lpc:101
01e5:  0E 08                     short_string                       ; "dbase: add() - called on a fu"
01e7:  04 3F 01                  F_EFUN1                            ; EFUN: error(319)
; feature/dbase.lpc:102
01ea:  3D 00                     transfer_local                     ; LV0
01ec:  3D 02                     transfer_local                     ; LV2
01ee:  3D 01                     transfer_local                     ; LV1
01f0:  6F                        +                                  ; 
01f1:  2D 0B 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
01f5:  2F                        return                             ; 
01f6:  30                        return_zero                        ; 
; feature/dbase.lpc:104

;; Function: public mapping query_entire_dbase()
01f7:  44 00 00                  global                             ; dbase(0)
01fa:  2F                        return                             ; 
; feature/dbase.lpc:112

;; Function: public mixed set_temp(string,mixed)
01fb:  44 01 00                  global                             ; tmp_dbase(1)
01fe:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0201:  18 08 00                  branch_when_non_zero               ; 0008 (020a)
0204:  12 00 00                  aggregate_assoc                    ; 0
0207:  6E 01 00                  (void)assign_global                ; tmp_dbase(1)
; feature/dbase.lpc:116
020a:  02 03 C0 6F 40            F_PUSH                             ; push local 0, number 47, number 0
020f:  06 D1 00                  F_EFUN3                            ; EFUN: strsrch(209)
0212:  0C 01                     -byte                              ; -1
0214:  16 11 00                  branch_eq                          ; 0011 (0226)
; feature/dbase.lpc:118
0217:  02 03 81 C0 05            F_PUSH                             ; push global 1, local 0, string 5
021c:  05 A6 00                  F_EFUN2                            ; EFUN: explode(166)
021f:  40 01                     local                              ; LV1
0221:  2D 02 00 03               F_CALL_FUNCTION_BY_ADDRESS         ; _set, pushed_args:3
0225:  2F                        return                             ; 
; feature/dbase.lpc:119
0226:  3D 01                     transfer_local                     ; LV1
0228:  3D 00                     transfer_local                     ; LV0
022a:  45 01 00                  global_lvalue                      ; tmp_dbase(1)
022d:  4D                        index_lvalue                       ; 
022e:  64                        assign                             ; 
022f:  2F                        return                             ; 
0230:  30                        return_zero                        ; 
; feature/dbase.lpc:121

;; Function: public varargs mixed query_temp(string,int)
0231:  44 01 00                  global                             ; tmp_dbase(1)
0234:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0237:  18 03 00                  branch_when_non_zero               ; 0003 (023b)
023a:  30                        return_zero                        ; 
; feature/dbase.lpc:127
023b:  02 03 C0 6F 40            F_PUSH                             ; push local 0, number 47, number 0
0240:  06 D1 00                  F_EFUN3                            ; EFUN: strsrch(209)
0243:  0C 01                     -byte                              ; -1
0245:  16 13 00                  branch_eq                          ; 0013 (0259)
; feature/dbase.lpc:129
0248:  02 03 81 C0 05            F_PUSH                             ; push global 1, local 0, string 5
024d:  05 A6 00                  F_EFUN2                            ; EFUN: explode(166)
0250:  2D 00 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; _query, pushed_args:2
0254:  6B 02                     (void)assign_local                 ; LV2
0256:  19 09 00                  branch                             ; 0009 (0260)
; feature/dbase.lpc:130
0259:  02 02 C0 81               F_PUSH                             ; push local 0, global 1
025d:  4C                        index                              ; 
025e:  6B 02                     (void)assign_local                 ; LV2
; feature/dbase.lpc:132
0260:  40 02                     local                              ; LV2
0262:  04 E5 00                  F_EFUN1                            ; EFUN: functionp(229)
0265:  26 05 00                  &&                                 ; 0005 (026b)
0268:  40 01                     local                              ; LV1
026a:  79                        !                                  ; 
026b:  17 0F 00                  branch_when_zero                   ; 000f (027b)
; feature/dbase.lpc:134
026e:  40 02                     local                              ; LV2
0270:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0273:  07 98 00 02               F_EFUNV                            ; EFUN: evaluate(152)
0277:  2F                        return                             ; 
0278:  19 05 00                  branch                             ; 0005 (027e)
; feature/dbase.lpc:135
027b:  40 02                     local                              ; LV2
027d:  2F                        return                             ; 
027e:  30                        return_zero                        ; 
; feature/dbase.lpc:137

;; Function: public int delete_temp(string)
027f:  44 01 00                  global                             ; tmp_dbase(1)
0282:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0285:  18 03 00                  branch_when_non_zero               ; 0003 (0289)
0288:  30                        return_zero                        ; 
; feature/dbase.lpc:141
0289:  02 03 C0 6F 40            F_PUSH                             ; push local 0, number 47, number 0
028e:  06 D1 00                  F_EFUN3                            ; EFUN: strsrch(209)
0291:  0C 01                     -byte                              ; -1
0293:  16 12 00                  branch_eq                          ; 0012 (02a6)
; feature/dbase.lpc:143
0296:  02 03 81 C0 05            F_PUSH                             ; push global 1, local 0, string 5
029b:  05 A6 00                  F_EFUN2                            ; EFUN: explode(166)
029e:  2D 01 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; _delete, pushed_args:2
02a2:  2F                        return                             ; 
02a3:  19 0B 00                  branch                             ; 000b (02af)
; feature/dbase.lpc:144
02a6:  02 02 81 C0               F_PUSH                             ; push global 1, local 0
02aa:  05 DD 00                  F_EFUN2                            ; EFUN: map_delete(221)
; feature/dbase.lpc:146
02ad:  10                        const1                             ; 
02ae:  2F                        return                             ; 
02af:  30                        return_zero                        ; 
; feature/dbase.lpc:147

;; Function: public mixed add_temp(string,mixed)
02b0:  44 01 00                  global                             ; tmp_dbase(1)
02b3:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
02b6:  79                        !                                  ; 
02b7:  25 0D 00                  ||                                 ; 000d (02c5)
02ba:  02 02 C0 41               F_PUSH                             ; push local 0, number 1
02be:  2D 0E 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; query_temp, pushed_args:2
02c2:  6C 02                     assign_local                       ; LV2
02c4:  79                        !                                  ; 
02c5:  17 0B 00                  branch_when_zero                   ; 000b (02d1)
; feature/dbase.lpc:154
02c8:  02 02 C0 C1               F_PUSH                             ; push local 0, local 1
02cc:  2D 04 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
02d0:  2F                        return                             ; 
; feature/dbase.lpc:155
02d1:  40 02                     local                              ; LV2
02d3:  04 E5 00                  F_EFUN1                            ; EFUN: functionp(229)
02d6:  17 07 00                  branch_when_zero                   ; 0007 (02de)
; feature/dbase.lpc:157
02d9:  0E 09                     short_string                       ; "dbase: add_temp() - called on"
02db:  04 3F 01                  F_EFUN1                            ; EFUN: error(319)
; feature/dbase.lpc:158
02de:  3D 00                     transfer_local                     ; LV0
02e0:  3D 02                     transfer_local                     ; LV2
02e2:  3D 01                     transfer_local                     ; LV1
02e4:  6F                        +                                  ; 
02e5:  2D 04 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
02e9:  2F                        return                             ; 
02ea:  30                        return_zero                        ; 
; feature/dbase.lpc:160

;; Function: public mapping query_entire_temp_dbase()
02eb:  44 01 00                  global                             ; tmp_dbase(1)
02ee:  2F                        return                             ; 
; feature/dbase.lpc:168

;;;  *** Line Number Info ***

absolute line -> (file, line) table:
0 lines from 1 [feature/dbase.lpc]
15 lines from 2 [include/globals.h]
65 lines from 3 [include/path.h]
181 lines from 2 [include/globals.h]
170 lines from 1 [feature/dbase.lpc]

address -> absolute line table:
0000-0003: 271
0004-0016: 276
0017-001b: 277
001c-0028: 278
0029-0037: 282
0038-0044: 284
0045-0053: 285
0054-005e: 286
005f-006d: 289
006e-007a: 291
007b-0089: 292
008a-0094: 294
0095-009e: 299
009f-00b7: 301
00b8-00c8: 302
00c9-00cf: 304
00d0-00dd: 306
00de-00e9: 307
00ea-00f1: 309
00f2-00fc: 311
00fd-0105: 317
0106-0106: 318
0107-011f: 321
0120-0130: 322
0131-0137: 324
0138-013d: 327
013e-0145: 328
0146-0154: 329
0155-015c: 330
015d-0168: 331
0169-0170: 332
0171-0177: 333
0178-017c: 338
017d-017f: 339
0180-018a: 342
018b-0194: 346
0195-01a1: 348
01a2-01b1: 349
01b2-01b8: 351
01b9-01bb: 352
01bc-01d3: 359
01d4-01dc: 360
01dd-01e4: 362
01e5-01e9: 363
01ea-01f6: 365
01f7-01fa: 373
01fb-0209: 377
020a-0216: 379
0217-0225: 380
0226-0230: 382
0231-023a: 388
023b-0247: 390
0248-0258: 391
0259-025f: 393
0260-026d: 395
026e-027a: 396
027b-027e: 398
027f-0288: 402
0289-0295: 404
0296-02a5: 405
02a6-02ac: 407
02ad-02af: 408
02b0-02c7: 415
02c8-02d0: 416
02d1-02d8: 418
02d9-02dd: 419
02de-02ea: 421
02eb-02ee: 429

;;; feature/treemap.lpc

Globals:
VARIABLES defined:
STRINGS:
   0: feature/treemap.lpc
   1: include/globals.h
   2: include/path.h
DISASSEMBLY:

;; Function: public nomask mixed _query(mapping,string *)
0000:  3D 00                     transfer_local                     ; LV0
0002:  6B 02                     (void)assign_local                 ; LV2
; feature/treemap.lpc:16
0004:  40 01                     local                              ; LV1
0006:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0009:  6B 04                     (void)assign_local                 ; LV4
; feature/treemap.lpc:17
000b:  0F                        const0                             ; 
000c:  6B 03                     (void)assign_local                 ; LV3
000e:  19 22 00                  branch                             ; 0022 (0031)
; feature/treemap.lpc:18
0011:  02 02 C3 C1               F_PUSH                             ; push local 3, local 1
0015:  4C                        index                              ; 
0016:  40 02                     local                              ; LV2
0018:  4C                        index                              ; 
0019:  6C 02                     assign_local                       ; LV2
001b:  04 E1 00                  F_EFUN1                            ; EFUN: undefinedp(225)
001e:  17 05 00                  branch_when_zero                   ; 0005 (0024)
0021:  19 14 00                  branch                             ; 0014 (0036)
; feature/treemap.lpc:19
0024:  40 02                     local                              ; LV2
0026:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0029:  18 05 00                  branch_when_non_zero               ; 0005 (002f)
002c:  19 09 00                  branch                             ; 0009 (0036)
; feature/treemap.lpc:21
002f:  23 03                     loop_incr                          ; LV3
0031:  21 03 04 23 00            loop_cond_local                    ; LV3 < LV4 bbranch_when_non_zero 0023 (0011)
; feature/treemap.lpc:23
0036:  3D 02                     transfer_local                     ; LV2
0038:  2F                        return                             ; 
0039:  30                        return_zero                        ; 
; feature/treemap.lpc:24

;; Function: public nomask int _delete(mapping,string *)
003a:  40 01                     local                              ; LV1
003c:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
003f:  10                        const1                             ; 
0040:  13 0D 00                  branch_ne                          ; 000d (004e)
; feature/treemap.lpc:28
0043:  02 03 C0 40 C1            F_PUSH                             ; push local 0, number 0, local 1
0048:  4C                        index                              ; 
0049:  05 DD 00                  F_EFUN2                            ; EFUN: map_delete(221)
; feature/treemap.lpc:29
004c:  10                        const1                             ; 
004d:  2F                        return                             ; 
; feature/treemap.lpc:30
004e:  02 02 40 C1               F_PUSH                             ; push number 0, local 1
0052:  4C                        index                              ; 
0053:  40 00                     local                              ; LV0
0055:  4C                        index                              ; 
0056:  79                        !                                  ; 
0057:  25 0E 00                  ||                                 ; 000e (0066)
005a:  02 02 40 C1               F_PUSH                             ; push number 0, local 1
005e:  4C                        index                              ; 
005f:  40 00                     local                              ; LV0
0061:  4C                        index                              ; 
0062:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0065:  79                        !                                  ; 
0066:  17 03 00                  branch_when_zero                   ; 0003 (006a)
; feature/treemap.lpc:32
0069:  30                        return_zero                        ; 
; feature/treemap.lpc:33
006a:  02 02 40 C1               F_PUSH                             ; push number 0, local 1
006e:  4C                        index                              ; 
006f:  3D 00                     transfer_local                     ; LV0
0071:  4C                        index                              ; 
0072:  02 02 41 C1               F_PUSH                             ; push number 1, local 1
0076:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0079:  10                        const1                             ; 
007a:  70                        subtract                           ; 
007b:  3D 01                     transfer_local                     ; LV1
007d:  50                        nn_range                           ; 
007e:  2D 01 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; _delete, pushed_args:2
0082:  2F                        return                             ; 
0083:  30                        return_zero                        ; 
; feature/treemap.lpc:34

;; Function: public nomask mixed _set(mapping,string *,mixed)
0084:  40 01                     local                              ; LV1
0086:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0089:  10                        const1                             ; 
008a:  13 0D 00                  branch_ne                          ; 000d (0098)
; feature/treemap.lpc:38
008d:  02 03 C2 40 C1            F_PUSH                             ; push local 2, number 0, local 1
0092:  4C                        index                              ; 
0093:  41 00                     local_lvalue                       ; LV0
0095:  4D                        index_lvalue                       ; 
0096:  64                        assign                             ; 
0097:  2F                        return                             ; 
; feature/treemap.lpc:39
0098:  02 02 40 C1               F_PUSH                             ; push number 0, local 1
009c:  4C                        index                              ; 
009d:  40 00                     local                              ; LV0
009f:  4C                        index                              ; 
00a0:  79                        !                                  ; 
00a1:  25 0E 00                  ||                                 ; 000e (00b0)
00a4:  02 02 40 C1               F_PUSH                             ; push number 0, local 1
00a8:  4C                        index                              ; 
00a9:  40 00                     local                              ; LV0
00ab:  4C                        index                              ; 
00ac:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
00af:  79                        !                                  ; 
00b0:  17 14 00                  branch_when_zero                   ; 0014 (00c5)
; feature/treemap.lpc:41
00b3:  02 02 41 C1               F_PUSH                             ; push number 1, local 1
00b7:  4C                        index                              ; 
00b8:  0F                        const0                             ; 
00b9:  12 02 00                  aggregate_assoc                    ; 2
00bc:  02 02 40 C1               F_PUSH                             ; push number 0, local 1
00c0:  4C                        index                              ; 
00c1:  41 00                     local_lvalue                       ; LV0
00c3:  4D                        index_lvalue                       ; 
00c4:  6A                        (void)assign                       ; 
; feature/treemap.lpc:42
00c5:  02 02 40 C1               F_PUSH                             ; push number 0, local 1
00c9:  4C                        index                              ; 
00ca:  3D 00                     transfer_local                     ; LV0
00cc:  4C                        index                              ; 
00cd:  02 02 41 C1               F_PUSH                             ; push number 1, local 1
00d1:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
00d4:  10                        const1                             ; 
00d5:  70                        subtract                           ; 
00d6:  3D 01                     transfer_local                     ; LV1
00d8:  50                        nn_range                           ; 
00d9:  3D 02                     transfer_local                     ; LV2
00db:  2D 02 00 03               F_CALL_FUNCTION_BY_ADDRESS         ; _set, pushed_args:3
00df:  2F                        return                             ; 
00e0:  30                        return_zero                        ; 
; feature/treemap.lpc:44

;;;  *** Line Number Info ***

absolute line -> (file, line) table:
0 lines from 1 [feature/treemap.lpc]
15 lines from 2 [include/globals.h]
65 lines from 3 [include/path.h]
181 lines from 2 [include/globals.h]
46 lines from 1 [feature/treemap.lpc]

address -> absolute line table:
0000-0003: 277
0004-000a: 278
000b-0010: 279
0011-0023: 280
0024-002e: 282
002f-0035: 284
0036-0039: 285
003a-0042: 289
0043-004b: 290
004c-004d: 291
004e-0068: 293
0069-0069: 294
006a-0083: 295
0084-008c: 299
008d-0097: 300
0098-00b2: 302
00b3-00c4: 303
00c5-00e0: 305

;;; feature/clean_up.lpc

Globals:
VARIABLES defined:
STRINGS:
   0: feature/clean_up.lpc
   1: include/globals.h
   2: include/path.h
   3: no_clean_up
   4: query
   5: perma_exist
DISASSEMBLY:

;; Function: public int clean_up()
0000:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0003:  02 02 04 03               F_PUSH                             ; push string 4, string 3
0007:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
000b:  17 04 00                  branch_when_zero                   ; 0004 (0010)
000e:  10                        const1                             ; 
000f:  2F                        return                             ; 
; feature/clean_up.lpc:10
0010:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0013:  04 26 01                  F_EFUN1                            ; EFUN: interactive(294)
0016:  17 04 00                  branch_when_zero                   ; 0004 (001b)
0019:  10                        const1                             ; 
001a:  2F                        return                             ; 
; feature/clean_up.lpc:12
001b:  03 B3 00                  F_EFUN0                            ; EFUN: environment(179)
001e:  17 04 00                  branch_when_zero                   ; 0004 (0023)
0021:  10                        const1                             ; 
0022:  2F                        return                             ; 
; feature/clean_up.lpc:17
0023:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0026:  02 02 04 05               F_PUSH                             ; push string 4, string 5
002a:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
002e:  17 04 00                  branch_when_zero                   ; 0004 (0033)
0031:  10                        const1                             ; 
0032:  2F                        return                             ; 
; feature/clean_up.lpc:19
0033:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0036:  04 B4 00                  F_EFUN1                            ; EFUN: all_inventory(180)
0039:  6B 00                     (void)assign_local                 ; LV0
; feature/clean_up.lpc:21
003b:  40 00                     local                              ; LV0
003d:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0040:  10                        const1                             ; 
0041:  70                        subtract                           ; 
0042:  6B 01                     (void)assign_local                 ; LV1
0044:  19 12 00                  branch                             ; 0012 (0057)
; feature/clean_up.lpc:22
0047:  02 02 C1 C0               F_PUSH                             ; push local 1, local 0
004b:  4C                        index                              ; 
004c:  04 26 01                  F_EFUN1                            ; EFUN: interactive(294)
004f:  17 04 00                  branch_when_zero                   ; 0004 (0054)
0052:  10                        const1                             ; 
0053:  2F                        return                             ; 
; feature/clean_up.lpc:23
0054:  41 01                     local_lvalue                       ; LV1
0056:  38                        dec(x)                             ; 
0057:  02 02 C1 40               F_PUSH                             ; push local 1, number 0
005b:  35                        >=                                 ; 
005c:  1B 16 00                  bbranch_when_non_zero              ; 0016 (0047)
; feature/clean_up.lpc:22
005f:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0062:  7E 10 00 01               simul_efun                         ; "destruct" args: 1
0066:  01                        pop                                ; 
; feature/clean_up.lpc:27
0067:  30                        return_zero                        ; 
0068:  30                        return_zero                        ; 
; feature/clean_up.lpc:28

;;;  *** Line Number Info ***

absolute line -> (file, line) table:
0 lines from 1 [feature/clean_up.lpc]
15 lines from 2 [include/globals.h]
65 lines from 3 [include/path.h]
181 lines from 2 [include/globals.h]
30 lines from 1 [feature/clean_up.lpc]

address -> absolute line table:
0000-000f: 271
0010-001a: 273
001b-0022: 278
0023-0032: 280
0033-003a: 282
003b-0046: 283
0047-0053: 284
0054-005e: 283
005f-0066: 288
0067-0068: 289

;;; feature/annie.lpc

Globals:
   0: items
VARIABLES defined:
   0: public mapping items
STRINGS:
   0: feature/annie.lpc
   1: include/globals.h
   2: include/path.h
   3: include/ansi.h
   4: include/dbase.h
   5: include/login.h
   6: 
   7: abcdefghijklmnopqrstuvwxyzABCDEF
   8: 
   9: \n
  10: 

  11: 	
  12: 　
  13:  
  14: query_entire_dbase
  15: query_entire_temp_dbase
  16: Cpstat：复制源没有任何
  17: sort_keys
  18: [1;37m物件：
  19: [2;37;0m\n
  20: set
  21: \n[1;37m
  22:  个储存的资料已复制到 
  23: [2;37;0m\n\n
  24: set_temp
  25:  个暂存的资料已复制到 
  26: query_skills
  27: query_skill_map
  28: set_skill
  29: [1;37m
  30:  个技能已复制到 
  31: query_skill_mapped
  32: map_skill
  33: [1;37m原来源的[2;37;0m
  34: name
  35: [1;37m没有任何可用的技
  36: [2;37;0m
  37: str
  38: cor
  39: dur
  40: agi
  41: spi
  42: con
  43: per
  44: int
  45: kar
  46: cps
  47: fle
  48: tol
  49: max_kee
  50: max_gin
  51: max_sen
  52: kee
  53: gin
  54: sen
  55: eff_kee
  56: eff_gin
  57: eff_sen
  58: max_force
  59: max_atman
  60: max_mana
  61: force
  62: atman
  63: mana
  64: combat_exp
  65: query
  66: [1;37m的基本属性已经复
  67: [1;37m中。\n
  68: [37m
  69: 没有ABILITY\n
  70: ability
  71: delete
  72: ability/
  73:  个ABILITY已复制到 
  74: ability2
  75: ability2/
  76: Add_mana/ability
  77: Add_force/ability
  78: Add_atman/ability
  79: mutant_rate
  80: mutant
  81: mutant_name
  82: [1;34m
  83: resistance/kee
  84: resistance/sen
  85: resistance/gin
  86: shield_force/type
  87: shield_force/ratio
  88: shield_force/msg
  89: [35m$N[35m招式甫及$n[35m
  90: immune_busy
  91: force_factor
  92: damage_shield/type
  93: damage_shield/amount
  94: damage_shield/msg
  95: [1;37m$n一触$N衣衫，忽然
  96: query_team
  97: visible
  98: [1;37m你的帐号数据异常
  99: /cmds/adm/block
 100: id
 101: main
 102: env/debug
DISASSEMBLY:

;; Function: public mapping query_qitems()
0000:  44 00 00                  global                             ; items(0)
0003:  2F                        return                             ; 
; feature/annie.lpc:29

;; Function: public int add_qitems(string,int)
0004:  44 00 00                  global                             ; items(0)
0007:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
000a:  18 12 00                  branch_when_non_zero               ; 0012 (001d)
; feature/annie.lpc:36
000d:  02 02 C0 C1               F_PUSH                             ; push local 0, local 1
0011:  12 02 00                  aggregate_assoc                    ; 2
0014:  6E 00 00                  (void)assign_global                ; items(0)
; feature/annie.lpc:37
0017:  40 01                     local                              ; LV1
0019:  2F                        return                             ; 
001a:  19 56 00                  branch                             ; 0056 (0071)
; feature/annie.lpc:38
001d:  44 00 00                  global                             ; items(0)
0020:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
0023:  6B 02                     (void)assign_local                 ; LV2
; feature/annie.lpc:40
0025:  02 02 C0 C2               F_PUSH                             ; push local 0, local 2
0029:  05 AE 00                  F_EFUN2                            ; EFUN: member_array(174)
002c:  6B 03                     (void)assign_local                 ; LV3
; feature/annie.lpc:41
002e:  40 03                     local                              ; LV3
0030:  0C 01                     -byte                              ; -1
0032:  16 35 00                  branch_eq                          ; 0035 (0068)
; feature/annie.lpc:42
0035:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0039:  4C                        index                              ; 
003a:  44 00 00                  global                             ; items(0)
003d:  4C                        index                              ; 
003e:  40 01                     local                              ; LV1
0040:  6F                        +                                  ; 
0041:  0F                        const0                             ; 
0042:  33                        <=                                 ; 
0043:  17 0C 00                  branch_when_zero                   ; 000c (0050)
; feature/annie.lpc:44
0046:  02 03 80 C3 C2            F_PUSH                             ; push global 0, local 3, local 2
004b:  4C                        index                              ; 
004c:  05 DD 00                  F_EFUN2                            ; EFUN: map_delete(221)
; feature/annie.lpc:45
004f:  30                        return_zero                        ; 
; feature/annie.lpc:46
0050:  02 03 C1 C3 C2            F_PUSH                             ; push local 1, local 3, local 2
0055:  4C                        index                              ; 
0056:  45 00 00                  global_lvalue                      ; items(0)
0059:  4D                        index_lvalue                       ; 
005a:  69                        (void)+=                           ; 
; feature/annie.lpc:48
005b:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
005f:  4C                        index                              ; 
0060:  44 00 00                  global                             ; items(0)
0063:  4C                        index                              ; 
0064:  2F                        return                             ; 
0065:  19 0B 00                  branch                             ; 000b (0071)
; feature/annie.lpc:49
0068:  02 02 C1 C0               F_PUSH                             ; push local 1, local 0
006c:  45 00 00                  global_lvalue                      ; items(0)
006f:  4D                        index_lvalue                       ; 
0070:  6A                        (void)assign                       ; 
0071:  30                        return_zero                        ; 
; feature/annie.lpc:51

;; Function: public void clear_items()
0072:  12 00 00                  aggregate_assoc                    ; 0
0075:  6E 00 00                  (void)assign_global                ; items(0)
0078:  30                        return_zero                        ; 
; feature/annie.lpc:55

;; Function: public void set_items(mapping)
0079:  3D 00                     transfer_local                     ; LV0
007b:  6E 00 00                  (void)assign_global                ; items(0)
007e:  30                        return_zero                        ; 
; feature/annie.lpc:59

;; Function: public string ngstr_uncolor(string)
007f:  40 00                     local                              ; LV0
0081:  04 E3 00                  F_EFUN1                            ; EFUN: stringp(227)
0084:  18 05 00                  branch_when_non_zero               ; 0005 (008a)
0087:  0E 06                     short_string                       ; ""
0089:  2F                        return                             ; 
; feature/annie.lpc:76
008a:  0E 06                     short_string                       ; ""
008c:  6B 01                     (void)assign_local                 ; LV1
; feature/annie.lpc:77
008e:  0F                        const0                             ; 
008f:  6B 05                     (void)assign_local                 ; LV5
; feature/annie.lpc:78
0091:  0F                        const0                             ; 
0092:  6B 06                     (void)assign_local                 ; LV6
; feature/annie.lpc:79
0094:  40 00                     local                              ; LV0
0096:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0099:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:80
009b:  0F                        const0                             ; 
009c:  6B 03                     (void)assign_local                 ; LV3
009e:  19 45 00                  branch                             ; 0045 (00e4)
; feature/annie.lpc:81
00a1:  02 03 C3 C3 C0            F_PUSH                             ; push local 3, local 3, local 0
00a6:  50                        nn_range                           ; 
00a7:  6B 02                     (void)assign_local                 ; LV2
; feature/annie.lpc:82
00a9:  40 05                     local                              ; LV5
00ab:  17 21 00                  branch_when_zero                   ; 0021 (00cd)
; feature/annie.lpc:83
00ae:  41 06                     local_lvalue                       ; LV6
00b0:  37                        inc(x)                             ; 
; feature/annie.lpc:84
00b1:  02 03 07 C2 40            F_PUSH                             ; push string 7, local 2, number 0
00b6:  06 D1 00                  F_EFUN3                            ; EFUN: strsrch(209)
00b9:  0C 01                     -byte                              ; -1
00bb:  32                        !=                                 ; 
00bc:  25 07 00                  ||                                 ; 0007 (00c4)
00bf:  02 02 C6 50               F_PUSH                             ; push local 6, number 16
00c3:  36                        >                                  ; 
00c4:  17 05 00                  branch_when_zero                   ; 0005 (00ca)
; feature/annie.lpc:86
00c7:  0F                        const0                             ; 
00c8:  6B 05                     (void)assign_local                 ; LV5
00ca:  19 17 00                  branch                             ; 0017 (00e2)
; feature/annie.lpc:87
00cd:  02 02 C2 08               F_PUSH                             ; push local 2, string 8
00d1:  13 0B 00                  branch_ne                          ; 000b (00dd)
; feature/annie.lpc:90
00d4:  10                        const1                             ; 
00d5:  6B 05                     (void)assign_local                 ; LV5
; feature/annie.lpc:91
00d7:  0F                        const0                             ; 
00d8:  6B 06                     (void)assign_local                 ; LV6
00da:  19 07 00                  branch                             ; 0007 (00e2)
; feature/annie.lpc:92
00dd:  40 02                     local                              ; LV2
00df:  41 01                     local_lvalue                       ; LV1
00e1:  69                        (void)+=                           ; 
; feature/annie.lpc:95
00e2:  23 03                     loop_incr                          ; LV3
00e4:  21 03 04 46 00            loop_cond_local                    ; LV3 < LV4 bbranch_when_non_zero 0046 (00a1)
; feature/annie.lpc:96
00e9:  3D 01                     transfer_local                     ; LV1
00eb:  2F                        return                             ; 
00ec:  30                        return_zero                        ; 
; feature/annie.lpc:97

;; Function: public int ngstr_chcol(string)
00ed:  40 00                     local                              ; LV0
00ef:  04 E3 00                  F_EFUN1                            ; EFUN: stringp(227)
00f2:  79                        !                                  ; 
00f3:  25 07 00                  ||                                 ; 0007 (00fb)
00f6:  02 02 C0 06               F_PUSH                             ; push local 0, string 6
00fa:  31                        ==                                 ; 
00fb:  17 03 00                  branch_when_zero                   ; 0003 (00ff)
00fe:  30                        return_zero                        ; 
; feature/annie.lpc:102
00ff:  02 02 C0 09               F_PUSH                             ; push local 0, string 9
0103:  31                        ==                                 ; 
0104:  25 0F 00                  ||                                 ; 000f (0114)
0107:  02 02 C0 0A               F_PUSH                             ; push local 0, string 10
010b:  31                        ==                                 ; 
010c:  25 07 00                  ||                                 ; 0007 (0114)
010f:  02 02 C0 0B               F_PUSH                             ; push local 0, string 11
0113:  31                        ==                                 ; 
0114:  17 03 00                  branch_when_zero                   ; 0003 (0118)
0117:  30                        return_zero                        ; 
; feature/annie.lpc:103
0118:  0F                        const0                             ; 
0119:  3D 00                     transfer_local                     ; LV0
011b:  4C                        index                              ; 
011c:  0B 80                     byte                               ; 128
011e:  14 04 00                  branch_ge                          ; 0004 (0123)
0121:  10                        const1                             ; 
0122:  2F                        return                             ; 
; feature/annie.lpc:104
0123:  0B 02                     byte                               ; 2
0125:  2F                        return                             ; 
0126:  30                        return_zero                        ; 
; feature/annie.lpc:105

;; Function: public int ngstr_cols(string)
0127:  40 00                     local                              ; LV0
0129:  04 E3 00                  F_EFUN1                            ; EFUN: stringp(227)
012c:  18 03 00                  branch_when_non_zero               ; 0003 (0130)
012f:  30                        return_zero                        ; 
; feature/annie.lpc:112
0130:  3D 00                     transfer_local                     ; LV0
0132:  2D 1C 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr_uncolor, pushed_args:1
0136:  6B 00                     (void)assign_local                 ; LV0
; feature/annie.lpc:113
0138:  0F                        const0                             ; 
0139:  6B 03                     (void)assign_local                 ; LV3
; feature/annie.lpc:114
013b:  40 00                     local                              ; LV0
013d:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0140:  6B 02                     (void)assign_local                 ; LV2
; feature/annie.lpc:115
0142:  0F                        const0                             ; 
0143:  6B 01                     (void)assign_local                 ; LV1
0145:  19 11 00                  branch                             ; 0011 (0157)
0148:  02 03 C1 C1 C0            F_PUSH                             ; push local 1, local 1, local 0
014d:  50                        nn_range                           ; 
014e:  2D 10 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr_chcol, pushed_args:1
0152:  41 03                     local_lvalue                       ; LV3
0154:  69                        (void)+=                           ; 
0155:  23 01                     loop_incr                          ; LV1
0157:  21 01 02 12 00            loop_cond_local                    ; LV1 < LV2 bbranch_when_non_zero 0012 (0148)
; feature/annie.lpc:116
015c:  3D 03                     transfer_local                     ; LV3
015e:  2F                        return                             ; 
015f:  30                        return_zero                        ; 
; feature/annie.lpc:117

;; Function: public string ngstr_pad(string,int)
0160:  40 00                     local                              ; LV0
0162:  04 E3 00                  F_EFUN1                            ; EFUN: stringp(227)
0165:  18 06 00                  branch_when_non_zero               ; 0006 (016c)
0168:  0E 06                     short_string                       ; ""
016a:  6B 00                     (void)assign_local                 ; LV0
; feature/annie.lpc:124
016c:  3D 01                     transfer_local                     ; LV1
016e:  40 00                     local                              ; LV0
0170:  2D 21 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr_cols, pushed_args:1
0174:  70                        subtract                           ; 
0175:  6B 02                     (void)assign_local                 ; LV2
0177:  19 0D 00                  branch                             ; 000d (0185)
; feature/annie.lpc:125
017a:  0E 0C                     short_string                       ; "　"
017c:  41 00                     local_lvalue                       ; LV0
017e:  69                        (void)+=                           ; 
; feature/annie.lpc:127
017f:  0B 02                     byte                               ; 2
0181:  41 02                     local_lvalue                       ; LV2
0183:  5B                        -=                                 ; 
0184:  01                        pop                                ; 
; feature/annie.lpc:128
0185:  02 02 C2 42               F_PUSH                             ; push local 2, number 2
0189:  35                        >=                                 ; 
018a:  1B 11 00                  bbranch_when_non_zero              ; 0011 (017a)
; feature/annie.lpc:126
018d:  3D 02                     transfer_local                     ; LV2
018f:  10                        const1                             ; 
0190:  13 07 00                  branch_ne                          ; 0007 (0198)
0193:  0E 0D                     short_string                       ; " "
0195:  41 00                     local_lvalue                       ; LV0
0197:  69                        (void)+=                           ; 
; feature/annie.lpc:130
0198:  3D 00                     transfer_local                     ; LV0
019a:  2F                        return                             ; 
019b:  30                        return_zero                        ; 
; feature/annie.lpc:131

;; Function: public int ngstr_fit(string,int)
019c:  40 00                     local                              ; LV0
019e:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
01a1:  6B 03                     (void)assign_local                 ; LV3
; feature/annie.lpc:139
01a3:  0F                        const0                             ; 
01a4:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:140
01a6:  0F                        const0                             ; 
01a7:  6B 05                     (void)assign_local                 ; LV5
; feature/annie.lpc:141
01a9:  0F                        const0                             ; 
01aa:  6B 06                     (void)assign_local                 ; LV6
; feature/annie.lpc:142
01ac:  0F                        const0                             ; 
01ad:  6B 02                     (void)assign_local                 ; LV2
01af:  19 4D 00                  branch                             ; 004d (01fd)
; feature/annie.lpc:143
01b2:  02 03 C2 C2 C0            F_PUSH                             ; push local 2, local 2, local 0
01b7:  50                        nn_range                           ; 
01b8:  6B 07                     (void)assign_local                 ; LV7
; feature/annie.lpc:144
01ba:  40 06                     local                              ; LV6
01bc:  17 18 00                  branch_when_zero                   ; 0018 (01d5)
; feature/annie.lpc:145
01bf:  02 03 07 C7 40            F_PUSH                             ; push string 7, local 7, number 0
01c4:  06 D1 00                  F_EFUN3                            ; EFUN: strsrch(209)
01c7:  0C 01                     -byte                              ; -1
01c9:  16 05 00                  branch_eq                          ; 0005 (01cf)
; feature/annie.lpc:146
01cc:  0F                        const0                             ; 
01cd:  6B 06                     (void)assign_local                 ; LV6
; feature/annie.lpc:147
01cf:  41 04                     local_lvalue                       ; LV4
01d1:  37                        inc(x)                             ; 
01d2:  19 28 00                  branch                             ; 0028 (01fb)
; feature/annie.lpc:148
01d5:  02 02 C7 08               F_PUSH                             ; push local 7, string 8
01d9:  13 0B 00                  branch_ne                          ; 000b (01e5)
; feature/annie.lpc:151
01dc:  10                        const1                             ; 
01dd:  6B 06                     (void)assign_local                 ; LV6
; feature/annie.lpc:152
01df:  41 04                     local_lvalue                       ; LV4
01e1:  37                        inc(x)                             ; 
01e2:  19 18 00                  branch                             ; 0018 (01fb)
; feature/annie.lpc:153
01e5:  40 07                     local                              ; LV7
01e7:  2D 10 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr_chcol, pushed_args:1
01eb:  41 05                     local_lvalue                       ; LV5
01ed:  69                        (void)+=                           ; 
; feature/annie.lpc:156
01ee:  02 02 C5 C1               F_PUSH                             ; push local 5, local 1
01f2:  15 05 00                  branch_le                          ; 0005 (01f8)
01f5:  19 0C 00                  branch                             ; 000c (0202)
; feature/annie.lpc:157
01f8:  41 04                     local_lvalue                       ; LV4
01fa:  37                        inc(x)                             ; 
; feature/annie.lpc:158
01fb:  23 02                     loop_incr                          ; LV2
01fd:  21 02 03 4E 00            loop_cond_local                    ; LV2 < LV3 bbranch_when_non_zero 004e (01b2)
; feature/annie.lpc:159
0202:  02 02 C4 41               F_PUSH                             ; push local 4, number 1
0206:  14 05 00                  branch_ge                          ; 0005 (020c)
0209:  10                        const1                             ; 
020a:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:160
020c:  3D 04                     transfer_local                     ; LV4
020e:  2F                        return                             ; 
020f:  30                        return_zero                        ; 
; feature/annie.lpc:161

;; Function: public string ngstr(string,int)
0210:  3D 00                     transfer_local                     ; LV0
0212:  3D 01                     transfer_local                     ; LV1
0214:  2D 1F 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr_pad, pushed_args:2
0218:  2F                        return                             ; 
; feature/annie.lpc:166

;; Function: public string nrstr(string,int,string,string,int)
0219:  40 00                     local                              ; LV0
021b:  04 E3 00                  F_EFUN1                            ; EFUN: stringp(227)
021e:  79                        !                                  ; 
021f:  25 09 00                  ||                                 ; 0009 (0229)
0222:  40 00                     local                              ; LV0
0224:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0227:  10                        const1                             ; 
0228:  34                        <                                  ; 
0229:  17 08 00                  branch_when_zero                   ; 0008 (0232)
022c:  02 02 C2 C3               F_PUSH                             ; push local 2, local 3
0230:  6F                        +                                  ; 
0231:  2F                        return                             ; 
; feature/annie.lpc:175
0232:  3D 01                     transfer_local                     ; LV1
0234:  40 02                     local                              ; LV2
0236:  2D 21 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr_cols, pushed_args:1
023a:  70                        subtract                           ; 
023b:  40 03                     local                              ; LV3
023d:  2D 21 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr_cols, pushed_args:1
0241:  70                        subtract                           ; 
0242:  6B 08                     (void)assign_local                 ; LV8
; feature/annie.lpc:177
0244:  02 02 C8 41               F_PUSH                             ; push local 8, number 1
0248:  14 05 00                  branch_ge                          ; 0005 (024e)
024b:  10                        const1                             ; 
024c:  6B 08                     (void)assign_local                 ; LV8
; feature/annie.lpc:178
024e:  0E 06                     short_string                       ; ""
0250:  6B 05                     (void)assign_local                 ; LV5
; feature/annie.lpc:180
0252:  3D 04                     transfer_local                     ; LV4
0254:  18 5F 00                  branch_when_non_zero               ; 005f (02b4)
; feature/annie.lpc:181
0257:  02 03 C0 09 06            F_PUSH                             ; push local 0, string 9, string 6
025c:  07 CA 00 03               F_EFUNV                            ; EFUN: replace_string(202)
0260:  6B 06                     (void)assign_local                 ; LV6
0262:  19 44 00                  branch                             ; 0044 (02a7)
; feature/annie.lpc:182
0265:  02 02 C6 C8               F_PUSH                             ; push local 6, local 8
0269:  2D 1A 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr_fit, pushed_args:2
026d:  6B 0B                     (void)assign_local                 ; LV11
; feature/annie.lpc:184
026f:  02 03 40 CB 41            F_PUSH                             ; push number 0, local 11, number 1
0274:  70                        subtract                           ; 
0275:  40 06                     local                              ; LV6
0277:  50                        nn_range                           ; 
0278:  6B 07                     (void)assign_local                 ; LV7
; feature/annie.lpc:185
027a:  40 06                     local                              ; LV6
027c:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
027f:  6B 0A                     (void)assign_local                 ; LV10
; feature/annie.lpc:186
0281:  02 02 CB CA               F_PUSH                             ; push local 11, local 10
0285:  35                        >=                                 ; 
0286:  17 09 00                  branch_when_zero                   ; 0009 (0290)
0289:  0E 06                     short_string                       ; ""
028b:  6B 06                     (void)assign_local                 ; LV6
028d:  19 09 00                  branch                             ; 0009 (0297)
; feature/annie.lpc:187
0290:  02 02 CB C6               F_PUSH                             ; push local 11, local 6
0294:  58                        ne_range                           ; 
0295:  6B 06                     (void)assign_local                 ; LV6
; feature/annie.lpc:188
0297:  02 03 C2 C7 C8            F_PUSH                             ; push local 2, local 7, local 8
029c:  2D 1F 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr_pad, pushed_args:2
02a0:  6F                        +                                  ; 
02a1:  40 03                     local                              ; LV3
02a3:  6F                        +                                  ; 
02a4:  41 05                     local_lvalue                       ; LV5
02a6:  69                        (void)+=                           ; 
; feature/annie.lpc:189
02a7:  40 06                     local                              ; LV6
02a9:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
02ac:  0F                        const0                             ; 
02ad:  36                        >                                  ; 
02ae:  1B 4A 00                  bbranch_when_non_zero              ; 004a (0265)
02b1:  19 9E 00                  branch                             ; 009e (0350)
; feature/annie.lpc:183
02b4:  40 00                     local                              ; LV0
02b6:  6B 06                     (void)assign_local                 ; LV6
02b8:  19 8D 00                  branch                             ; 008d (0346)
; feature/annie.lpc:192
02bb:  02 03 C6 09 40            F_PUSH                             ; push local 6, string 9, number 0
02c0:  06 D1 00                  F_EFUN3                            ; EFUN: strsrch(209)
02c3:  6B 09                     (void)assign_local                 ; LV9
; feature/annie.lpc:194
02c5:  02 02 C9 40               F_PUSH                             ; push local 9, number 0
02c9:  14 0D 00                  branch_ge                          ; 000d (02d7)
; feature/annie.lpc:195
02cc:  40 06                     local                              ; LV6
02ce:  6B 07                     (void)assign_local                 ; LV7
; feature/annie.lpc:196
02d0:  0E 06                     short_string                       ; ""
02d2:  6B 06                     (void)assign_local                 ; LV6
02d4:  19 43 00                  branch                             ; 0043 (0318)
; feature/annie.lpc:197
02d7:  40 09                     local                              ; LV9
02d9:  18 10 00                  branch_when_non_zero               ; 0010 (02ea)
; feature/annie.lpc:198
02dc:  0E 06                     short_string                       ; ""
02de:  6B 07                     (void)assign_local                 ; LV7
; feature/annie.lpc:199
02e0:  02 02 41 C6               F_PUSH                             ; push number 1, local 6
02e4:  58                        ne_range                           ; 
02e5:  6B 06                     (void)assign_local                 ; LV6
02e7:  19 30 00                  branch                             ; 0030 (0318)
; feature/annie.lpc:200
02ea:  02 03 40 C9 41            F_PUSH                             ; push number 0, local 9, number 1
02ef:  70                        subtract                           ; 
02f0:  40 06                     local                              ; LV6
02f2:  50                        nn_range                           ; 
02f3:  6B 07                     (void)assign_local                 ; LV7
; feature/annie.lpc:202
02f5:  40 06                     local                              ; LV6
02f7:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
02fa:  6B 0A                     (void)assign_local                 ; LV10
; feature/annie.lpc:203
02fc:  02 02 C9 41               F_PUSH                             ; push local 9, number 1
0300:  6F                        +                                  ; 
0301:  40 0A                     local                              ; LV10
0303:  35                        >=                                 ; 
0304:  17 09 00                  branch_when_zero                   ; 0009 (030e)
0307:  0E 06                     short_string                       ; ""
0309:  6B 06                     (void)assign_local                 ; LV6
030b:  19 0C 00                  branch                             ; 000c (0318)
; feature/annie.lpc:204
030e:  02 02 C9 41               F_PUSH                             ; push local 9, number 1
0312:  6F                        +                                  ; 
0313:  40 06                     local                              ; LV6
0315:  58                        ne_range                           ; 
0316:  6B 06                     (void)assign_local                 ; LV6
; feature/annie.lpc:205
0318:  40 07                     local                              ; LV7
031a:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
031d:  0F                        const0                             ; 
031e:  15 17 00                  branch_le                          ; 0017 (0336)
; feature/annie.lpc:207
0321:  02 02 C7 C8               F_PUSH                             ; push local 7, local 8
0325:  2D 1A 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr_fit, pushed_args:2
0329:  6B 0B                     (void)assign_local                 ; LV11
; feature/annie.lpc:208
032b:  02 03 40 CB 41            F_PUSH                             ; push number 0, local 11, number 1
0330:  70                        subtract                           ; 
0331:  40 07                     local                              ; LV7
0333:  50                        nn_range                           ; 
0334:  6B 07                     (void)assign_local                 ; LV7
; feature/annie.lpc:209
0336:  02 03 C2 C7 C8            F_PUSH                             ; push local 2, local 7, local 8
033b:  2D 1F 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; ngstr_pad, pushed_args:2
033f:  6F                        +                                  ; 
0340:  40 03                     local                              ; LV3
0342:  6F                        +                                  ; 
0343:  41 05                     local_lvalue                       ; LV5
0345:  69                        (void)+=                           ; 
; feature/annie.lpc:211
0346:  40 06                     local                              ; LV6
0348:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
034b:  0F                        const0                             ; 
034c:  36                        >                                  ; 
034d:  1B 93 00                  bbranch_when_non_zero              ; 0093 (02bb)
; feature/annie.lpc:193
0350:  3D 05                     transfer_local                     ; LV5
0352:  2F                        return                             ; 
0353:  30                        return_zero                        ; 
; feature/annie.lpc:214

;; Function: public string annie_mimic(object,object)
0354:  0F                        const0                             ; 
0355:  6B 08                     (void)assign_local                 ; LV8
; feature/annie.lpc:228
0357:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
035a:  04 FF 01                  F_EFUN1                            ; EFUN: geteuid(511)
035d:  04 01 02                  F_EFUN1                            ; EFUN: seteuid(513)
0360:  01                        pop                                ; 
; feature/annie.lpc:230
0361:  02 02 C0 0E               F_PUSH                             ; push local 0, string 14
0365:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0369:  6B 02                     (void)assign_local                 ; LV2
; feature/annie.lpc:232
036b:  02 02 C0 0F               F_PUSH                             ; push local 0, string 15
036f:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0373:  6B 03                     (void)assign_local                 ; LV3
; feature/annie.lpc:233
0375:  40 02                     local                              ; LV2
0377:  79                        !                                  ; 
0378:  25 08 00                  ||                                 ; 0008 (0381)
037b:  40 02                     local                              ; LV2
037d:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0380:  79                        !                                  ; 
0381:  26 0E 00                  &&                                 ; 000e (0390)
0384:  40 03                     local                              ; LV3
0386:  79                        !                                  ; 
0387:  25 08 00                  ||                                 ; 0008 (0390)
038a:  40 03                     local                              ; LV3
038c:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
038f:  79                        !                                  ; 
0390:  17 05 00                  branch_when_zero                   ; 0005 (0396)
; feature/annie.lpc:234
0393:  0E 10                     short_string                       ; "Cpstat：复制源没有任"
0395:  2F                        return                             ; 
; feature/annie.lpc:235
0396:  40 02                     local                              ; LV2
0398:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
039b:  17 16 00                  branch_when_zero                   ; 0016 (03b2)
; feature/annie.lpc:237
039e:  40 02                     local                              ; LV2
03a0:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
03a3:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:238
03a5:  02 02 C4 11               F_PUSH                             ; push local 4, string 17
03a9:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
03ac:  07 1B 01 03               F_EFUNV                            ; EFUN: sort_array(283)
03b0:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:239
03b2:  40 03                     local                              ; LV3
03b4:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
03b7:  17 16 00                  branch_when_zero                   ; 0016 (03ce)
; feature/annie.lpc:242
03ba:  40 03                     local                              ; LV3
03bc:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
03bf:  6B 05                     (void)assign_local                 ; LV5
; feature/annie.lpc:243
03c1:  02 02 C5 11               F_PUSH                             ; push local 5, string 17
03c5:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
03c8:  07 1B 01 03               F_EFUNV                            ; EFUN: sort_array(283)
03cc:  6B 05                     (void)assign_local                 ; LV5
; feature/annie.lpc:244
03ce:  40 04                     local                              ; LV4
03d0:  79                        !                                  ; 
03d1:  25 08 00                  ||                                 ; 0008 (03da)
03d4:  40 04                     local                              ; LV4
03d6:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
03d9:  79                        !                                  ; 
03da:  17 05 00                  branch_when_zero                   ; 0005 (03e0)
; feature/annie.lpc:247
03dd:  0E 10                     short_string                       ; "Cpstat：复制源没有任"
03df:  2F                        return                             ; 
; feature/annie.lpc:248
03e0:  02 02 12 C0               F_PUSH                             ; push string 18, local 0
03e4:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
03e8:  6F                        +                                  ; 
03e9:  0E 08                     short_string                       ; ""
03eb:  6F                        +                                  ; 
03ec:  0E 13                     short_string                       ; "[2;37;0m\n"
03ee:  6F                        +                                  ; 
03ef:  6B 06                     (void)assign_local                 ; LV6
; feature/annie.lpc:250
03f1:  0F                        const0                             ; 
03f2:  6B 07                     (void)assign_local                 ; LV7
03f4:  19 18 00                  branch                             ; 0018 (040d)
; feature/annie.lpc:251
03f7:  02 04 C1 14 C7 C4         F_PUSH                             ; push local 1, string 20, local 7, local 4
03fd:  4C                        index                              ; 
03fe:  02 02 C7 C4               F_PUSH                             ; push local 7, local 4
0402:  4C                        index                              ; 
0403:  40 02                     local                              ; LV2
0405:  4C                        index                              ; 
0406:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
040a:  01                        pop                                ; 
040b:  23 07                     loop_incr                          ; LV7
; feature/annie.lpc:252
040d:  02 02 C7 C4               F_PUSH                             ; push local 7, local 4
0411:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0414:  1D 1E 00                  bbranch_lt                         ; 001e (03f7)
; feature/annie.lpc:251
0417:  0E 15                     short_string                       ; "\n[1;37m"
0419:  3D 04                     transfer_local                     ; LV4
041b:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
041e:  6F                        +                                  ; 
041f:  0E 16                     short_string                       ; " 个储存的资料已复制"
0421:  6F                        +                                  ; 
0422:  40 01                     local                              ; LV1
0424:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
0428:  6F                        +                                  ; 
0429:  0E 08                     short_string                       ; ""
042b:  6F                        +                                  ; 
042c:  0E 17                     short_string                       ; "[2;37;0m\n\n"
042e:  6F                        +                                  ; 
042f:  41 06                     local_lvalue                       ; LV6
0431:  69                        (void)+=                           ; 
; feature/annie.lpc:253
0432:  3D 08                     transfer_local                     ; LV8
0434:  17 55 00                  branch_when_zero                   ; 0055 (048a)
; feature/annie.lpc:255
0437:  02 02 12 C0               F_PUSH                             ; push string 18, local 0
043b:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
043f:  6F                        +                                  ; 
0440:  0E 08                     short_string                       ; ""
0442:  6F                        +                                  ; 
0443:  0E 13                     short_string                       ; "[2;37;0m\n"
0445:  6F                        +                                  ; 
0446:  41 06                     local_lvalue                       ; LV6
0448:  69                        (void)+=                           ; 
; feature/annie.lpc:256
0449:  0F                        const0                             ; 
044a:  6B 07                     (void)assign_local                 ; LV7
044c:  19 18 00                  branch                             ; 0018 (0465)
; feature/annie.lpc:257
044f:  02 04 C1 18 C7 C5         F_PUSH                             ; push local 1, string 24, local 7, local 5
0455:  4C                        index                              ; 
0456:  02 02 C7 C5               F_PUSH                             ; push local 7, local 5
045a:  4C                        index                              ; 
045b:  40 03                     local                              ; LV3
045d:  4C                        index                              ; 
045e:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0462:  01                        pop                                ; 
0463:  23 07                     loop_incr                          ; LV7
; feature/annie.lpc:258
0465:  02 02 C7 C5               F_PUSH                             ; push local 7, local 5
0469:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
046c:  1D 1E 00                  bbranch_lt                         ; 001e (044f)
; feature/annie.lpc:257
046f:  02 02 15 C5               F_PUSH                             ; push string 21, local 5
0473:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0476:  6F                        +                                  ; 
0477:  0E 19                     short_string                       ; " 个暂存的资料已复制"
0479:  6F                        +                                  ; 
047a:  40 01                     local                              ; LV1
047c:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
0480:  6F                        +                                  ; 
0481:  0E 08                     short_string                       ; ""
0483:  6F                        +                                  ; 
0484:  0E 17                     short_string                       ; "[2;37;0m\n\n"
0486:  6F                        +                                  ; 
0487:  41 06                     local_lvalue                       ; LV6
0489:  69                        (void)+=                           ; 
; feature/annie.lpc:259
048a:  02 02 C0 1A               F_PUSH                             ; push local 0, string 26
048e:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0492:  6B 09                     (void)assign_local                 ; LV9
; feature/annie.lpc:262
0494:  40 09                     local                              ; LV9
0496:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0499:  17 AD 00                  branch_when_zero                   ; 00ad (0547)
; feature/annie.lpc:263
049c:  40 09                     local                              ; LV9
049e:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
04a1:  0F                        const0                             ; 
04a2:  7D 03 41 01               (::)                               ; <efun> strcmp
04a6:  07 1B 01 02               F_EFUNV                            ; EFUN: sort_array(283)
04aa:  6B 0B                     (void)assign_local                 ; LV11
; feature/annie.lpc:265
04ac:  02 02 C0 1B               F_PUSH                             ; push local 0, string 27
04b0:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
04b4:  6B 0A                     (void)assign_local                 ; LV10
; feature/annie.lpc:267
04b6:  40 0A                     local                              ; LV10
04b8:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
04bb:  17 09 00                  branch_when_zero                   ; 0009 (04c5)
04be:  40 0A                     local                              ; LV10
04c0:  04 DB 00                  F_EFUN1                            ; EFUN: values(219)
04c3:  6B 0C                     (void)assign_local                 ; LV12
; feature/annie.lpc:268
04c5:  40 0C                     local                              ; LV12
04c7:  18 07 00                  branch_when_non_zero               ; 0007 (04cf)
04ca:  11 00 00                  aggregate                          ; 0
04cd:  6B 0C                     (void)assign_local                 ; LV12
; feature/annie.lpc:269
04cf:  0F                        const0                             ; 
04d0:  6B 07                     (void)assign_local                 ; LV7
04d2:  19 18 00                  branch                             ; 0018 (04eb)
; feature/annie.lpc:271
04d5:  02 04 C1 1C C7 CB         F_PUSH                             ; push local 1, string 28, local 7, local 11
04db:  4C                        index                              ; 
04dc:  02 02 C7 CB               F_PUSH                             ; push local 7, local 11
04e0:  4C                        index                              ; 
04e1:  40 09                     local                              ; LV9
04e3:  4C                        index                              ; 
04e4:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
04e8:  01                        pop                                ; 
04e9:  23 07                     loop_incr                          ; LV7
; feature/annie.lpc:272
04eb:  02 02 C7 C9               F_PUSH                             ; push local 7, local 9
04ef:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
04f2:  1D 1E 00                  bbranch_lt                         ; 001e (04d5)
; feature/annie.lpc:271
04f5:  02 02 1D C9               F_PUSH                             ; push string 29, local 9
04f9:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
04fc:  6F                        +                                  ; 
04fd:  0E 1E                     short_string                       ; " 个技能已复制到 "
04ff:  6F                        +                                  ; 
0500:  40 01                     local                              ; LV1
0502:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
0506:  6F                        +                                  ; 
0507:  0E 08                     short_string                       ; ""
0509:  6F                        +                                  ; 
050a:  0E 17                     short_string                       ; "[2;37;0m\n\n"
050c:  6F                        +                                  ; 
050d:  41 06                     local_lvalue                       ; LV6
050f:  69                        (void)+=                           ; 
; feature/annie.lpc:274
0510:  0F                        const0                             ; 
0511:  6B 07                     (void)assign_local                 ; LV7
0513:  19 29 00                  branch                             ; 0029 (053d)
; feature/annie.lpc:276
0516:  02 04 C0 1F C7 CB         F_PUSH                             ; push local 0, string 31, local 7, local 11
051c:  4C                        index                              ; 
051d:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0521:  17 19 00                  branch_when_zero                   ; 0019 (053b)
; feature/annie.lpc:277
0524:  02 04 C1 20 C7 CB         F_PUSH                             ; push local 1, string 32, local 7, local 11
052a:  4C                        index                              ; 
052b:  02 04 C0 1F C7 CB         F_PUSH                             ; push local 0, string 31, local 7, local 11
0531:  4C                        index                              ; 
0532:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0536:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
053a:  01                        pop                                ; 
; feature/annie.lpc:278
053b:  23 07                     loop_incr                          ; LV7
; feature/annie.lpc:279
053d:  02 02 C7 C9               F_PUSH                             ; push local 7, local 9
0541:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0544:  1D 2F 00                  bbranch_lt                         ; 002f (0516)
; feature/annie.lpc:276
0547:  3D 06                     transfer_local                     ; LV6
0549:  2F                        return                             ; 
054a:  30                        return_zero                        ; 
; feature/annie.lpc:284

;; Function: public string annie_itemmimic(object,mapping,mapping)
054b:  10                        const1                             ; 
054c:  6B 07                     (void)assign_local                 ; LV7
; feature/annie.lpc:295
054e:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0551:  04 FF 01                  F_EFUN1                            ; EFUN: geteuid(511)
0554:  04 01 02                  F_EFUN1                            ; EFUN: seteuid(513)
0557:  01                        pop                                ; 
; feature/annie.lpc:297
0558:  40 01                     local                              ; LV1
055a:  79                        !                                  ; 
055b:  25 08 00                  ||                                 ; 0008 (0564)
055e:  40 01                     local                              ; LV1
0560:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0563:  79                        !                                  ; 
0564:  26 0E 00                  &&                                 ; 000e (0573)
0567:  40 02                     local                              ; LV2
0569:  79                        !                                  ; 
056a:  25 08 00                  ||                                 ; 0008 (0573)
056d:  40 02                     local                              ; LV2
056f:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0572:  79                        !                                  ; 
0573:  17 05 00                  branch_when_zero                   ; 0005 (0579)
; feature/annie.lpc:299
0576:  0E 10                     short_string                       ; "Cpstat：复制源没有任"
0578:  2F                        return                             ; 
; feature/annie.lpc:300
0579:  40 01                     local                              ; LV1
057b:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
057e:  17 16 00                  branch_when_zero                   ; 0016 (0595)
; feature/annie.lpc:302
0581:  40 01                     local                              ; LV1
0583:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
0586:  6B 03                     (void)assign_local                 ; LV3
; feature/annie.lpc:303
0588:  02 02 C3 11               F_PUSH                             ; push local 3, string 17
058c:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
058f:  07 1B 01 03               F_EFUNV                            ; EFUN: sort_array(283)
0593:  6B 03                     (void)assign_local                 ; LV3
; feature/annie.lpc:304
0595:  40 02                     local                              ; LV2
0597:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
059a:  17 16 00                  branch_when_zero                   ; 0016 (05b1)
; feature/annie.lpc:307
059d:  40 02                     local                              ; LV2
059f:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
05a2:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:308
05a4:  02 02 C4 11               F_PUSH                             ; push local 4, string 17
05a8:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
05ab:  07 1B 01 03               F_EFUNV                            ; EFUN: sort_array(283)
05af:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:309
05b1:  40 03                     local                              ; LV3
05b3:  79                        !                                  ; 
05b4:  25 08 00                  ||                                 ; 0008 (05bd)
05b7:  40 03                     local                              ; LV3
05b9:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
05bc:  79                        !                                  ; 
05bd:  17 05 00                  branch_when_zero                   ; 0005 (05c3)
; feature/annie.lpc:312
05c0:  0E 10                     short_string                       ; "Cpstat：复制源没有任"
05c2:  2F                        return                             ; 
; feature/annie.lpc:313
05c3:  0E 21                     short_string                       ; "[1;37m原来源的[2;37;0m"
05c5:  6B 05                     (void)assign_local                 ; LV5
; feature/annie.lpc:315
05c7:  0F                        const0                             ; 
05c8:  6B 06                     (void)assign_local                 ; LV6
05ca:  19 18 00                  branch                             ; 0018 (05e3)
; feature/annie.lpc:316
05cd:  02 04 C0 14 C6 C3         F_PUSH                             ; push local 0, string 20, local 6, local 3
05d3:  4C                        index                              ; 
05d4:  02 02 C6 C3               F_PUSH                             ; push local 6, local 3
05d8:  4C                        index                              ; 
05d9:  40 01                     local                              ; LV1
05db:  4C                        index                              ; 
05dc:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
05e0:  01                        pop                                ; 
05e1:  23 06                     loop_incr                          ; LV6
; feature/annie.lpc:317
05e3:  02 02 C6 C3               F_PUSH                             ; push local 6, local 3
05e7:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
05ea:  1D 1E 00                  bbranch_lt                         ; 001e (05cd)
; feature/annie.lpc:316
05ed:  0E 1D                     short_string                       ; "[1;37m"
05ef:  3D 03                     transfer_local                     ; LV3
05f1:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
05f4:  6F                        +                                  ; 
05f5:  0E 16                     short_string                       ; " 个储存的资料已复制"
05f7:  6F                        +                                  ; 
05f8:  40 00                     local                              ; LV0
05fa:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
05fe:  6F                        +                                  ; 
05ff:  0E 08                     short_string                       ; ""
0601:  6F                        +                                  ; 
0602:  0E 17                     short_string                       ; "[2;37;0m\n\n"
0604:  6F                        +                                  ; 
0605:  41 05                     local_lvalue                       ; LV5
0607:  69                        (void)+=                           ; 
; feature/annie.lpc:318
0608:  3D 07                     transfer_local                     ; LV7
060a:  17 48 00                  branch_when_zero                   ; 0048 (0653)
; feature/annie.lpc:320
060d:  0E 21                     short_string                       ; "[1;37m原来源的[2;37;0m"
060f:  41 05                     local_lvalue                       ; LV5
0611:  69                        (void)+=                           ; 
; feature/annie.lpc:321
0612:  0F                        const0                             ; 
0613:  6B 06                     (void)assign_local                 ; LV6
0615:  19 18 00                  branch                             ; 0018 (062e)
; feature/annie.lpc:322
0618:  02 04 C0 18 C6 C4         F_PUSH                             ; push local 0, string 24, local 6, local 4
061e:  4C                        index                              ; 
061f:  02 02 C6 C4               F_PUSH                             ; push local 6, local 4
0623:  4C                        index                              ; 
0624:  40 02                     local                              ; LV2
0626:  4C                        index                              ; 
0627:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
062b:  01                        pop                                ; 
062c:  23 06                     loop_incr                          ; LV6
; feature/annie.lpc:323
062e:  02 02 C6 C4               F_PUSH                             ; push local 6, local 4
0632:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0635:  1D 1E 00                  bbranch_lt                         ; 001e (0618)
; feature/annie.lpc:322
0638:  02 02 1D C4               F_PUSH                             ; push string 29, local 4
063c:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
063f:  6F                        +                                  ; 
0640:  0E 19                     short_string                       ; " 个暂存的资料已复制"
0642:  6F                        +                                  ; 
0643:  40 00                     local                              ; LV0
0645:  7E 08 00 01               simul_efun                         ; "base_name" args: 1
0649:  6F                        +                                  ; 
064a:  0E 08                     short_string                       ; ""
064c:  6F                        +                                  ; 
064d:  0E 17                     short_string                       ; "[2;37;0m\n\n"
064f:  6F                        +                                  ; 
0650:  41 05                     local_lvalue                       ; LV5
0652:  69                        (void)+=                           ; 
; feature/annie.lpc:324
0653:  3D 05                     transfer_local                     ; LV5
0655:  2F                        return                             ; 
0656:  30                        return_zero                        ; 
; feature/annie.lpc:328

;; Function: public string annie_skillcp(object,object)
0657:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
065a:  04 FF 01                  F_EFUN1                            ; EFUN: geteuid(511)
065d:  04 01 02                  F_EFUN1                            ; EFUN: seteuid(513)
0660:  01                        pop                                ; 
; feature/annie.lpc:337
0661:  02 02 C0 1A               F_PUSH                             ; push local 0, string 26
0665:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0669:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:339
066b:  40 04                     local                              ; LV4
066d:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0670:  17 B1 00                  branch_when_zero                   ; 00b1 (0722)
; feature/annie.lpc:340
0673:  40 04                     local                              ; LV4
0675:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
0678:  0F                        const0                             ; 
0679:  7D 03 41 01               (::)                               ; <efun> strcmp
067d:  07 1B 01 02               F_EFUNV                            ; EFUN: sort_array(283)
0681:  6B 06                     (void)assign_local                 ; LV6
; feature/annie.lpc:342
0683:  02 02 C0 1B               F_PUSH                             ; push local 0, string 27
0687:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
068b:  6B 05                     (void)assign_local                 ; LV5
; feature/annie.lpc:344
068d:  40 05                     local                              ; LV5
068f:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0692:  17 09 00                  branch_when_zero                   ; 0009 (069c)
0695:  40 05                     local                              ; LV5
0697:  04 DB 00                  F_EFUN1                            ; EFUN: values(219)
069a:  6B 07                     (void)assign_local                 ; LV7
; feature/annie.lpc:345
069c:  40 07                     local                              ; LV7
069e:  18 07 00                  branch_when_non_zero               ; 0007 (06a6)
06a1:  11 00 00                  aggregate                          ; 0
06a4:  6B 07                     (void)assign_local                 ; LV7
; feature/annie.lpc:346
06a6:  0F                        const0                             ; 
06a7:  6B 03                     (void)assign_local                 ; LV3
06a9:  19 18 00                  branch                             ; 0018 (06c2)
; feature/annie.lpc:348
06ac:  02 04 C1 1C C3 C6         F_PUSH                             ; push local 1, string 28, local 3, local 6
06b2:  4C                        index                              ; 
06b3:  02 02 C3 C6               F_PUSH                             ; push local 3, local 6
06b7:  4C                        index                              ; 
06b8:  40 04                     local                              ; LV4
06ba:  4C                        index                              ; 
06bb:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
06bf:  01                        pop                                ; 
06c0:  23 03                     loop_incr                          ; LV3
; feature/annie.lpc:349
06c2:  02 02 C3 C4               F_PUSH                             ; push local 3, local 4
06c6:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
06c9:  1D 1E 00                  bbranch_lt                         ; 001e (06ac)
; feature/annie.lpc:348
06cc:  02 02 1D C4               F_PUSH                             ; push string 29, local 4
06d0:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
06d3:  6F                        +                                  ; 
06d4:  0E 1E                     short_string                       ; " 个技能已复制到 "
06d6:  6F                        +                                  ; 
06d7:  02 02 C1 22               F_PUSH                             ; push local 1, string 34
06db:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
06df:  6F                        +                                  ; 
06e0:  0E 08                     short_string                       ; ""
06e2:  6F                        +                                  ; 
06e3:  0E 17                     short_string                       ; "[2;37;0m\n\n"
06e5:  6F                        +                                  ; 
06e6:  6B 02                     (void)assign_local                 ; LV2
; feature/annie.lpc:351
06e8:  0F                        const0                             ; 
06e9:  6B 03                     (void)assign_local                 ; LV3
06eb:  19 29 00                  branch                             ; 0029 (0715)
; feature/annie.lpc:353
06ee:  02 04 C0 1F C3 C6         F_PUSH                             ; push local 0, string 31, local 3, local 6
06f4:  4C                        index                              ; 
06f5:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
06f9:  17 19 00                  branch_when_zero                   ; 0019 (0713)
; feature/annie.lpc:354
06fc:  02 04 C1 20 C3 C6         F_PUSH                             ; push local 1, string 32, local 3, local 6
0702:  4C                        index                              ; 
0703:  02 04 C0 1F C3 C6         F_PUSH                             ; push local 0, string 31, local 3, local 6
0709:  4C                        index                              ; 
070a:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
070e:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0712:  01                        pop                                ; 
; feature/annie.lpc:355
0713:  23 03                     loop_incr                          ; LV3
; feature/annie.lpc:356
0715:  02 02 C3 C4               F_PUSH                             ; push local 3, local 4
0719:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
071c:  1D 2F 00                  bbranch_lt                         ; 002f (06ee)
071f:  19 17 00                  branch                             ; 0017 (0737)
; feature/annie.lpc:353
0722:  02 03 1D C0 22            F_PUSH                             ; push string 29, local 0, string 34
0727:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
072b:  6F                        +                                  ; 
072c:  0E 08                     short_string                       ; ""
072e:  6F                        +                                  ; 
072f:  0E 23                     short_string                       ; "[1;37m没有任何可用的"
0731:  6F                        +                                  ; 
0732:  0E 24                     short_string                       ; "[2;37;0m"
0734:  6F                        +                                  ; 
0735:  6B 02                     (void)assign_local                 ; LV2
; feature/annie.lpc:357
0737:  3D 02                     transfer_local                     ; LV2
0739:  2F                        return                             ; 
073a:  30                        return_zero                        ; 
; feature/annie.lpc:359

;; Function: public string annie_attcp(object,object)
073b:  02 1B 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 37 38 39 3A 3B 3C 3D 3E 3F  F_PUSH                             ; push string 37, string 38, string 39, string 40, string 41, string 42, string 43, string 44, string 45, string 46, string 47, string 48, string 49, string 50, string 51, string 52, string 53, string 54, string 55, string 56, string 57, string 58, string 59, string 60, string 61, string 62, string 63
0758:  0E 40                     short_string                       ; "combat_exp"
075a:  11 1C 00                  aggregate                          ; 28
075d:  6B 02                     (void)assign_local                 ; LV2
; feature/annie.lpc:366
075f:  0F                        const0                             ; 
0760:  6B 03                     (void)assign_local                 ; LV3
0762:  19 1D 00                  branch                             ; 001d (0780)
; feature/annie.lpc:370
0765:  02 04 C1 14 C3 C2         F_PUSH                             ; push local 1, string 20, local 3, local 2
076b:  4C                        index                              ; 
076c:  40 00                     local                              ; LV0
076e:  0E 41                     short_string                       ; "query"
0770:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0774:  4C                        index                              ; 
0775:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0779:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
077d:  01                        pop                                ; 
077e:  23 03                     loop_incr                          ; LV3
; feature/annie.lpc:371
0780:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0784:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0787:  1D 23 00                  bbranch_lt                         ; 0023 (0765)
; feature/annie.lpc:370
078a:  0E 1D                     short_string                       ; "[1;37m"
078c:  3D 00                     transfer_local                     ; LV0
078e:  0E 22                     short_string                       ; "name"
0790:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0794:  6F                        +                                  ; 
0795:  0E 08                     short_string                       ; ""
0797:  6F                        +                                  ; 
0798:  0E 42                     short_string                       ; "[1;37m的基本属性已经"
079a:  6F                        +                                  ; 
079b:  3D 01                     transfer_local                     ; LV1
079d:  0E 22                     short_string                       ; "name"
079f:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
07a3:  6F                        +                                  ; 
07a4:  0E 08                     short_string                       ; ""
07a6:  6F                        +                                  ; 
07a7:  0E 43                     short_string                       ; "[1;37m中。\n"
07a9:  6F                        +                                  ; 
07aa:  0E 24                     short_string                       ; "[2;37;0m"
07ac:  6F                        +                                  ; 
07ad:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:373
07af:  3D 04                     transfer_local                     ; LV4
07b1:  2F                        return                             ; 
07b2:  30                        return_zero                        ; 
; feature/annie.lpc:374

;; Function: public string annie_abilitycp(object,object)
07b3:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
07b6:  04 FF 01                  F_EFUN1                            ; EFUN: geteuid(511)
07b9:  04 01 02                  F_EFUN1                            ; EFUN: seteuid(513)
07bc:  01                        pop                                ; 
; feature/annie.lpc:382
07bd:  0E 44                     short_string                       ; "[37m"
07bf:  02 02 C0 22               F_PUSH                             ; push local 0, string 34
07c3:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
07c7:  6F                        +                                  ; 
07c8:  0E 45                     short_string                       ; "没有ABILITY\n"
07ca:  6F                        +                                  ; 
07cb:  0E 24                     short_string                       ; "[2;37;0m"
07cd:  6F                        +                                  ; 
07ce:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:384
07d0:  40 01                     local                              ; LV1
07d2:  0E 47                     short_string                       ; "delete"
07d4:  0E 46                     short_string                       ; "ability"
07d6:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
07da:  01                        pop                                ; 
; feature/annie.lpc:386
07db:  40 00                     local                              ; LV0
07dd:  0E 41                     short_string                       ; "query"
07df:  0E 46                     short_string                       ; "ability"
07e1:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
07e5:  6B 02                     (void)assign_local                 ; LV2
; feature/annie.lpc:387
07e7:  40 02                     local                              ; LV2
07e9:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
07ec:  17 59 00                  branch_when_zero                   ; 0059 (0846)
; feature/annie.lpc:388
07ef:  40 02                     local                              ; LV2
07f1:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
07f4:  0F                        const0                             ; 
07f5:  7D 03 41 01               (::)                               ; <efun> strcmp
07f9:  07 1B 01 02               F_EFUNV                            ; EFUN: sort_array(283)
07fd:  6B 03                     (void)assign_local                 ; LV3
; feature/annie.lpc:389
07ff:  0F                        const0                             ; 
0800:  6B 05                     (void)assign_local                 ; LV5
0802:  19 1D 00                  branch                             ; 001d (0820)
; feature/annie.lpc:390
0805:  02 02 C1 14               F_PUSH                             ; push local 1, string 20
0809:  0E 48                     short_string                       ; "ability/"
080b:  02 02 C5 C3               F_PUSH                             ; push local 5, local 3
080f:  4C                        index                              ; 
0810:  6F                        +                                  ; 
0811:  02 02 C5 C3               F_PUSH                             ; push local 5, local 3
0815:  4C                        index                              ; 
0816:  40 02                     local                              ; LV2
0818:  4C                        index                              ; 
0819:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
081d:  01                        pop                                ; 
081e:  23 05                     loop_incr                          ; LV5
; feature/annie.lpc:391
0820:  02 02 C5 C2               F_PUSH                             ; push local 5, local 2
0824:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0827:  1D 23 00                  bbranch_lt                         ; 0023 (0805)
; feature/annie.lpc:390
082a:  02 02 1D C2               F_PUSH                             ; push string 29, local 2
082e:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0831:  6F                        +                                  ; 
0832:  0E 49                     short_string                       ; " 个ABILITY已复制到 "
0834:  6F                        +                                  ; 
0835:  02 02 C1 22               F_PUSH                             ; push local 1, string 34
0839:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
083d:  6F                        +                                  ; 
083e:  0E 08                     short_string                       ; ""
0840:  6F                        +                                  ; 
0841:  0E 13                     short_string                       ; "[2;37;0m\n"
0843:  6F                        +                                  ; 
0844:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:392
0846:  40 01                     local                              ; LV1
0848:  0E 47                     short_string                       ; "delete"
084a:  0E 4A                     short_string                       ; "ability2"
084c:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0850:  01                        pop                                ; 
; feature/annie.lpc:395
0851:  40 00                     local                              ; LV0
0853:  0E 41                     short_string                       ; "query"
0855:  0E 4A                     short_string                       ; "ability2"
0857:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
085b:  6B 02                     (void)assign_local                 ; LV2
; feature/annie.lpc:396
085d:  40 02                     local                              ; LV2
085f:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0862:  17 5A 00                  branch_when_zero                   ; 005a (08bd)
; feature/annie.lpc:397
0865:  40 02                     local                              ; LV2
0867:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
086a:  0F                        const0                             ; 
086b:  7D 03 41 01               (::)                               ; <efun> strcmp
086f:  07 1B 01 02               F_EFUNV                            ; EFUN: sort_array(283)
0873:  6B 03                     (void)assign_local                 ; LV3
; feature/annie.lpc:398
0875:  0F                        const0                             ; 
0876:  6B 05                     (void)assign_local                 ; LV5
0878:  19 1D 00                  branch                             ; 001d (0896)
; feature/annie.lpc:399
087b:  02 02 C1 14               F_PUSH                             ; push local 1, string 20
087f:  0E 4B                     short_string                       ; "ability2/"
0881:  02 02 C5 C3               F_PUSH                             ; push local 5, local 3
0885:  4C                        index                              ; 
0886:  6F                        +                                  ; 
0887:  02 02 C5 C3               F_PUSH                             ; push local 5, local 3
088b:  4C                        index                              ; 
088c:  40 02                     local                              ; LV2
088e:  4C                        index                              ; 
088f:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0893:  01                        pop                                ; 
0894:  23 05                     loop_incr                          ; LV5
; feature/annie.lpc:400
0896:  02 02 C5 C2               F_PUSH                             ; push local 5, local 2
089a:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
089d:  1D 23 00                  bbranch_lt                         ; 0023 (087b)
; feature/annie.lpc:399
08a0:  02 02 1D C2               F_PUSH                             ; push string 29, local 2
08a4:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
08a7:  6F                        +                                  ; 
08a8:  0E 49                     short_string                       ; " 个ABILITY已复制到 "
08aa:  6F                        +                                  ; 
08ab:  02 02 C1 22               F_PUSH                             ; push local 1, string 34
08af:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
08b3:  6F                        +                                  ; 
08b4:  0E 08                     short_string                       ; ""
08b6:  6F                        +                                  ; 
08b7:  0E 17                     short_string                       ; "[2;37;0m\n\n"
08b9:  6F                        +                                  ; 
08ba:  41 04                     local_lvalue                       ; LV4
08bc:  69                        (void)+=                           ; 
; feature/annie.lpc:401
08bd:  02 02 C1 14               F_PUSH                             ; push local 1, string 20
08c1:  0E 4C                     short_string                       ; "Add_mana/ability"
08c3:  40 00                     local                              ; LV0
08c5:  0E 41                     short_string                       ; "query"
08c7:  0E 4C                     short_string                       ; "Add_mana/ability"
08c9:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
08cd:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
08d1:  01                        pop                                ; 
; feature/annie.lpc:404
08d2:  02 02 C1 14               F_PUSH                             ; push local 1, string 20
08d6:  0E 4D                     short_string                       ; "Add_force/ability"
08d8:  40 00                     local                              ; LV0
08da:  0E 41                     short_string                       ; "query"
08dc:  0E 4D                     short_string                       ; "Add_force/ability"
08de:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
08e2:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
08e6:  01                        pop                                ; 
; feature/annie.lpc:405
08e7:  3D 01                     transfer_local                     ; LV1
08e9:  0E 14                     short_string                       ; "set"
08eb:  0E 4E                     short_string                       ; "Add_atman/ability"
08ed:  3D 00                     transfer_local                     ; LV0
08ef:  0E 41                     short_string                       ; "query"
08f1:  0E 4E                     short_string                       ; "Add_atman/ability"
08f3:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
08f7:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
08fb:  01                        pop                                ; 
; feature/annie.lpc:406
08fc:  3D 04                     transfer_local                     ; LV4
08fe:  2F                        return                             ; 
08ff:  30                        return_zero                        ; 
; feature/annie.lpc:408

;; Function: public int mutant()
0900:  0B 07                     byte                               ; 7
0902:  04 B0 00                  F_EFUN1                            ; EFUN: random(176)
0905:  10                        const1                             ; 
0906:  6F                        +                                  ; 
0907:  6B 01                     (void)assign_local                 ; LV1
; feature/annie.lpc:415
0909:  0E 4F                     short_string                       ; "mutant_rate"
090b:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
090f:  6B 00                     (void)assign_local                 ; LV0
; feature/annie.lpc:417
0911:  0B 64                     byte                               ; 100
0913:  04 B0 00                  F_EFUN1                            ; EFUN: random(176)
0916:  3D 00                     transfer_local                     ; LV0
0918:  15 03 00                  branch_le                          ; 0003 (091c)
; feature/annie.lpc:419
091b:  30                        return_zero                        ; 
; feature/annie.lpc:420
091c:  0E 50                     short_string                       ; "mutant"
091e:  40 01                     local                              ; LV1
0920:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0924:  01                        pop                                ; 
; feature/annie.lpc:422
0925:  0E 51                     short_string                       ; "mutant_name"
0927:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
092b:  17 18 00                  branch_when_zero                   ; 0018 (0944)
; feature/annie.lpc:424
092e:  0E 22                     short_string                       ; "name"
0930:  0E 52                     short_string                       ; "[1;34m"
0932:  0E 22                     short_string                       ; "name"
0934:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0938:  6F                        +                                  ; 
0939:  0E 08                     short_string                       ; ""
093b:  6F                        +                                  ; 
093c:  0E 24                     short_string                       ; "[2;37;0m"
093e:  6F                        +                                  ; 
093f:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0943:  01                        pop                                ; 
; feature/annie.lpc:425
0944:  3D 01                     transfer_local                     ; LV1
0946: switch
      type: fe table: 0acb-0ae1 deflt: 0ac8
094e:  02 02 31 31               F_PUSH                             ; push string 49, string 49
0952:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0956:  0B 14                     byte                               ; 20
0958:  71                        *                                  ; 
0959:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
095d:  01                        pop                                ; 
; feature/annie.lpc:429
095e:  02 02 37 31               F_PUSH                             ; push string 55, string 49
0962:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0966:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
096a:  01                        pop                                ; 
; feature/annie.lpc:430
096b:  02 02 34 31               F_PUSH                             ; push string 52, string 49
096f:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0973:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0977:  01                        pop                                ; 
; feature/annie.lpc:431
0978:  02 02 33 33               F_PUSH                             ; push string 51, string 51
097c:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0980:  0B 14                     byte                               ; 20
0982:  71                        *                                  ; 
0983:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0987:  01                        pop                                ; 
; feature/annie.lpc:432
0988:  02 02 39 33               F_PUSH                             ; push string 57, string 51
098c:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0990:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0994:  01                        pop                                ; 
; feature/annie.lpc:433
0995:  02 02 36 33               F_PUSH                             ; push string 54, string 51
0999:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
099d:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
09a1:  01                        pop                                ; 
; feature/annie.lpc:434
09a2:  02 02 32 32               F_PUSH                             ; push string 50, string 50
09a6:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
09aa:  0B 14                     byte                               ; 20
09ac:  71                        *                                  ; 
09ad:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
09b1:  01                        pop                                ; 
; feature/annie.lpc:435
09b2:  02 02 38 32               F_PUSH                             ; push string 56, string 50
09b6:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
09ba:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
09be:  01                        pop                                ; 
; feature/annie.lpc:436
09bf:  02 02 35 32               F_PUSH                             ; push string 53, string 50
09c3:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
09c7:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
09cb:  01                        pop                                ; 
; feature/annie.lpc:437
09cc:  10                        const1                             ; 
09cd:  2F                        return                             ; 
09ce:  19 12 01                  branch                             ; 0112 (0ae1)
; feature/annie.lpc:438
09d1:  0E 53                     short_string                       ; "resistance/kee"
09d3:  0B 64                     byte                               ; 100
09d5:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
09d9:  01                        pop                                ; 
; feature/annie.lpc:441
09da:  10                        const1                             ; 
09db:  2F                        return                             ; 
09dc:  19 04 01                  branch                             ; 0104 (0ae1)
; feature/annie.lpc:442
09df:  0E 54                     short_string                       ; "resistance/sen"
09e1:  0B 64                     byte                               ; 100
09e3:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
09e7:  01                        pop                                ; 
; feature/annie.lpc:445
09e8:  0E 55                     short_string                       ; "resistance/gin"
09ea:  0B 64                     byte                               ; 100
09ec:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
09f0:  01                        pop                                ; 
; feature/annie.lpc:446
09f1:  0E 3C                     short_string                       ; "max_mana"
09f3:  08 20 4E                  F_SHORT_INT                        ; short 20000
09f6:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
09fa:  01                        pop                                ; 
; feature/annie.lpc:447
09fb:  0E 3F                     short_string                       ; "mana"
09fd:  08 20 4E                  F_SHORT_INT                        ; short 20000
0a00:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0a04:  01                        pop                                ; 
; feature/annie.lpc:448
0a05:  0E 56                     short_string                       ; "shield_force/type"
0a07:  0E 3F                     short_string                       ; "mana"
0a09:  2D 01 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
0a0d:  01                        pop                                ; 
; feature/annie.lpc:449
0a0e:  0E 57                     short_string                       ; "shield_force/ratio"
0a10:  08 10 27                  F_SHORT_INT                        ; short 10000
0a13:  2D 01 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
0a17:  01                        pop                                ; 
; feature/annie.lpc:450
0a18:  0E 58                     short_string                       ; "shield_force/msg"
0a1a:  0E 59                     short_string                       ; "[35m$N[35m招式甫及$n[3"
0a1c:  2D 01 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
0a20:  01                        pop                                ; 
; feature/annie.lpc:452
0a21:  10                        const1                             ; 
0a22:  2F                        return                             ; 
0a23:  19 BD 00                  branch                             ; 00bd (0ae1)
; feature/annie.lpc:453
0a26:  0E 5A                     short_string                       ; "immune_busy"
0a28:  0B 04                     byte                               ; 4
0a2a:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0a2e:  01                        pop                                ; 
; feature/annie.lpc:457
0a2f:  10                        const1                             ; 
0a30:  2F                        return                             ; 
0a31:  19 AF 00                  branch                             ; 00af (0ae1)
; feature/annie.lpc:458
0a34:  02 02 25 25               F_PUSH                             ; push string 37, string 37
0a38:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0a3c:  0B 64                     byte                               ; 100
0a3e:  04 B0 00                  F_EFUN1                            ; EFUN: random(176)
0a41:  0B 96                     byte                               ; 150
0a43:  6F                        +                                  ; 
0a44:  71                        *                                  ; 
0a45:  0B 64                     byte                               ; 100
0a47:  72                        /                                  ; 
0a48:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0a4c:  01                        pop                                ; 
; feature/annie.lpc:461
0a4d:  0E 5B                     short_string                       ; "force_factor"
0a4f:  0E 5B                     short_string                       ; "force_factor"
0a51:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0a55:  0B 64                     byte                               ; 100
0a57:  04 B0 00                  F_EFUN1                            ; EFUN: random(176)
0a5a:  0B 96                     byte                               ; 150
0a5c:  6F                        +                                  ; 
0a5d:  71                        *                                  ; 
0a5e:  0B 64                     byte                               ; 100
0a60:  72                        /                                  ; 
0a61:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0a65:  01                        pop                                ; 
; feature/annie.lpc:462
0a66:  10                        const1                             ; 
0a67:  2F                        return                             ; 
0a68:  19 78 00                  branch                             ; 0078 (0ae1)
; feature/annie.lpc:463
0a6b:  0E 40                     short_string                       ; "combat_exp"
0a6d:  0E 40                     short_string                       ; "combat_exp"
0a6f:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0a73:  0B 96                     byte                               ; 150
0a75:  72                        /                                  ; 
0a76:  0B 64                     byte                               ; 100
0a78:  04 B0 00                  F_EFUN1                            ; EFUN: random(176)
0a7b:  0B 64                     byte                               ; 100
0a7d:  6F                        +                                  ; 
0a7e:  71                        *                                  ; 
0a7f:  2D 05 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set, pushed_args:2
0a83:  01                        pop                                ; 
; feature/annie.lpc:466
0a84:  10                        const1                             ; 
0a85:  2F                        return                             ; 
0a86:  19 5A 00                  branch                             ; 005a (0ae1)
; feature/annie.lpc:467
0a89:  0E 5C                     short_string                       ; "damage_shield/type"
0a8b:  0E 34                     short_string                       ; "kee"
0a8d:  2D 01 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
0a91:  01                        pop                                ; 
; feature/annie.lpc:470
0a92:  0E 5D                     short_string                       ; "damage_shield/amount"
; feature/annie.lpc:474
0a94:  0E 25                     short_string                       ; "str"
0a96:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0a9a:  0E 25                     short_string                       ; "str"
0a9c:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0aa0:  71                        *                                  ; 
0aa1:  0E 25                     short_string                       ; "str"
0aa3:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0aa7:  71                        *                                  ; 
0aa8:  0B 64                     byte                               ; 100
0aaa:  72                        /                                  ; 
0aab:  0E 25                     short_string                       ; "str"
0aad:  2D 00 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; query, pushed_args:1
0ab1:  71                        *                                  ; 
0ab2:  0B 20                     byte                               ; 32
0ab4:  72                        /                                  ; 
0ab5:  2D 01 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
0ab9:  01                        pop                                ; 
; feature/annie.lpc:473
0aba:  0E 5E                     short_string                       ; "damage_shield/msg"
0abc:  0E 5F                     short_string                       ; "[1;37m$n一触$N衣衫，忽"
0abe:  2D 01 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; set_temp, pushed_args:2
0ac2:  01                        pop                                ; 
; feature/annie.lpc:475
0ac3:  10                        const1                             ; 
0ac4:  2F                        return                             ; 
0ac5:  19 1B 00                  branch                             ; 001b (0ae1)
0ac8:  19 18 00                  branch                             ; 0018 (0ae1)
; feature/annie.lpc:476
      switch table (for 0946)
	 0: 094e
	 1: 09d1
	 2: 09df
	 3: 0a26
	 4: 0a34
	 5: 0a6b
	 6: 0a89
	minval = 1
; feature/annie.lpc:427
0ae1:  10                        const1                             ; 
0ae2:  2F                        return                             ; 
0ae3:  30                        return_zero                        ; 
; feature/annie.lpc:480

;; Function: public void tell_team(object,string)
0ae4:  40 00                     local                              ; LV0
0ae6:  0E 60                     short_string                       ; "query_team"
0ae8:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0aec:  04 E6 00                  F_EFUN1                            ; EFUN: pointerp(230)
0aef:  17 0D 00                  branch_when_zero                   ; 000d (0afd)
0af2:  40 00                     local                              ; LV0
0af4:  0E 60                     short_string                       ; "query_team"
0af6:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0afa:  19 07 00                  branch                             ; 0007 (0b02)
0afd:  40 00                     local                              ; LV0
0aff:  11 01 00                  aggregate                          ; 1
0b02:  6B 02                     (void)assign_local                 ; LV2
; feature/annie.lpc:486
0b04:  40 02                     local                              ; LV2
0b06:  17 2B 00                  branch_when_zero                   ; 002b (0b32)
; feature/annie.lpc:487
0b09:  0F                        const0                             ; 
0b0a:  6B 03                     (void)assign_local                 ; LV3
0b0c:  19 1B 00                  branch                             ; 001b (0b28)
; feature/annie.lpc:488
0b0f:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0b13:  4C                        index                              ; 
0b14:  18 05 00                  branch_when_non_zero               ; 0005 (0b1a)
0b17:  19 0E 00                  branch                             ; 000e (0b26)
; feature/annie.lpc:489
0b1a:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0b1e:  4C                        index                              ; 
0b1f:  40 01                     local                              ; LV1
0b21:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0b25:  01                        pop                                ; 
; feature/annie.lpc:490
0b26:  23 03                     loop_incr                          ; LV3
; feature/annie.lpc:491
0b28:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0b2c:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0b2f:  1D 21 00                  bbranch_lt                         ; 0021 (0b0f)
; feature/annie.lpc:488
0b32:  30                        return_zero                        ; 
0b33:  30                        return_zero                        ; 
; feature/annie.lpc:493

;; Function: public object team_check(object,string,int,mixed)
0b34:  40 00                     local                              ; LV0
0b36:  6B 06                     (void)assign_local                 ; LV6
; feature/annie.lpc:500
0b38:  40 00                     local                              ; LV0
0b3a:  0E 60                     short_string                       ; "query_team"
0b3c:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0b40:  04 E6 00                  F_EFUN1                            ; EFUN: pointerp(230)
0b43:  17 0D 00                  branch_when_zero                   ; 000d (0b51)
0b46:  40 00                     local                              ; LV0
0b48:  0E 60                     short_string                       ; "query_team"
0b4a:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0b4e:  19 07 00                  branch                             ; 0007 (0b56)
0b51:  40 00                     local                              ; LV0
0b53:  11 01 00                  aggregate                          ; 1
0b56:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:506
0b58:  40 04                     local                              ; LV4
0b5a:  17 80 00                  branch_when_zero                   ; 0080 (0bdb)
; feature/annie.lpc:507
0b5d:  0F                        const0                             ; 
0b5e:  6B 05                     (void)assign_local                 ; LV5
0b60:  19 70 00                  branch                             ; 0070 (0bd1)
; feature/annie.lpc:508
0b63:  02 02 C5 C4               F_PUSH                             ; push local 5, local 4
0b67:  4C                        index                              ; 
0b68:  18 05 00                  branch_when_non_zero               ; 0005 (0b6e)
0b6b:  19 63 00                  branch                             ; 0063 (0bcf)
; feature/annie.lpc:509
0b6e:  02 02 C5 C4               F_PUSH                             ; push local 5, local 4
0b72:  4C                        index                              ; 
0b73:  40 06                     local                              ; LV6
0b75:  31                        ==                                 ; 
0b76:  26 07 00                  &&                                 ; 0007 (0b7e)
0b79:  02 02 C2 42               F_PUSH                             ; push local 2, number 2
0b7d:  35                        >=                                 ; 
0b7e:  17 05 00                  branch_when_zero                   ; 0005 (0b84)
0b81:  19 4D 00                  branch                             ; 004d (0bcf)
; feature/annie.lpc:510
0b84:  40 02                     local                              ; LV2
0b86:  79                        !                                  ; 
0b87:  25 07 00                  ||                                 ; 0007 (0b8f)
0b8a:  02 02 C2 42               F_PUSH                             ; push local 2, number 2
0b8e:  31                        ==                                 ; 
0b8f:  26 21 00                  &&                                 ; 0021 (0bb1)
; feature/annie.lpc:511
0b92:  02 02 C5 C4               F_PUSH                             ; push local 5, local 4
0b96:  4C                        index                              ; 
0b97:  04 B3 00                  F_EFUN1                            ; EFUN: environment(179)
0b9a:  40 06                     local                              ; LV6
0b9c:  04 B3 00                  F_EFUN1                            ; EFUN: environment(179)
0b9f:  32                        !=                                 ; 
0ba0:  25 10 00                  ||                                 ; 0010 (0bb1)
0ba3:  40 06                     local                              ; LV6
0ba5:  0E 61                     short_string                       ; "visible"
0ba7:  02 02 C5 C4               F_PUSH                             ; push local 5, local 4
0bab:  4C                        index                              ; 
0bac:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0bb0:  79                        !                                  ; 
0bb1:  17 05 00                  branch_when_zero                   ; 0005 (0bb7)
0bb4:  19 1A 00                  branch                             ; 001a (0bcf)
; feature/annie.lpc:512
0bb7:  02 02 C5 C4               F_PUSH                             ; push local 5, local 4
0bbb:  4C                        index                              ; 
0bbc:  0E 41                     short_string                       ; "query"
0bbe:  40 01                     local                              ; LV1
0bc0:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0bc4:  40 03                     local                              ; LV3
0bc6:  13 08 00                  branch_ne                          ; 0008 (0bcf)
; feature/annie.lpc:517
0bc9:  02 02 C5 C4               F_PUSH                             ; push local 5, local 4
0bcd:  4C                        index                              ; 
0bce:  2F                        return                             ; 
; feature/annie.lpc:518
0bcf:  23 05                     loop_incr                          ; LV5
; feature/annie.lpc:519
0bd1:  02 02 C5 C4               F_PUSH                             ; push local 5, local 4
0bd5:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0bd8:  1D 76 00                  bbranch_lt                         ; 0076 (0b63)
; feature/annie.lpc:508
0bdb:  30                        return_zero                        ; 
0bdc:  30                        return_zero                        ; 
; feature/annie.lpc:521

;; Function: public mapping mapping_copy(mapping)
0bdd:  12 00 00                  aggregate_assoc                    ; 0
0be0:  6B 01                     (void)assign_local                 ; LV1
; feature/annie.lpc:525
0be2:  40 00                     local                              ; LV0
0be4:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0be7:  17 0C 00                  branch_when_zero                   ; 000c (0bf4)
; feature/annie.lpc:528
0bea:  40 00                     local                              ; LV0
0bec:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
0bef:  6B 02                     (void)assign_local                 ; LV2
0bf1:  19 03 00                  branch                             ; 0003 (0bf5)
; feature/annie.lpc:529
0bf4:  30                        return_zero                        ; 
; feature/annie.lpc:531
0bf5:  40 02                     local                              ; LV2
0bf7:  79                        !                                  ; 
0bf8:  25 08 00                  ||                                 ; 0008 (0c01)
0bfb:  40 02                     local                              ; LV2
0bfd:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0c00:  79                        !                                  ; 
0c01:  17 03 00                  branch_when_zero                   ; 0003 (0c05)
; feature/annie.lpc:533
0c04:  30                        return_zero                        ; 
; feature/annie.lpc:534
0c05:  0F                        const0                             ; 
0c06:  6B 03                     (void)assign_local                 ; LV3
0c08:  19 15 00                  branch                             ; 0015 (0c1e)
; feature/annie.lpc:536
0c0b:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0c0f:  4C                        index                              ; 
0c10:  40 00                     local                              ; LV0
0c12:  4C                        index                              ; 
0c13:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0c17:  4C                        index                              ; 
0c18:  41 01                     local_lvalue                       ; LV1
0c1a:  4D                        index_lvalue                       ; 
0c1b:  6A                        (void)assign                       ; 
0c1c:  23 03                     loop_incr                          ; LV3
; feature/annie.lpc:537
0c1e:  02 02 C3 C2               F_PUSH                             ; push local 3, local 2
0c22:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0c25:  1D 1B 00                  bbranch_lt                         ; 001b (0c0b)
; feature/annie.lpc:536
0c28:  3D 01                     transfer_local                     ; LV1
0c2a:  2F                        return                             ; 
0c2b:  30                        return_zero                        ; 
; feature/annie.lpc:539

;; Function: public int get_highest_skill_level(object,int)
0c2c:  0F                        const0                             ; 
0c2d:  6B 03                     (void)assign_local                 ; LV3
; feature/annie.lpc:544
0c2f:  02 02 C0 1A               F_PUSH                             ; push local 0, string 26
0c33:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0c37:  6B 04                     (void)assign_local                 ; LV4
; feature/annie.lpc:548
0c39:  40 04                     local                              ; LV4
0c3b:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0c3e:  17 5E 00                  branch_when_zero                   ; 005e (0c9d)
; feature/annie.lpc:549
0c41:  40 04                     local                              ; LV4
0c43:  04 DC 00                  F_EFUN1                            ; EFUN: keys(220)
0c46:  0F                        const0                             ; 
0c47:  7D 03 41 01               (::)                               ; <efun> strcmp
0c4b:  07 1B 01 02               F_EFUNV                            ; EFUN: sort_array(283)
0c4f:  6B 06                     (void)assign_local                 ; LV6
; feature/annie.lpc:550
0c51:  02 02 C0 1B               F_PUSH                             ; push local 0, string 27
0c55:  07 97 00 02               F_EFUNV                            ; EFUN: call_other(151)
0c59:  6B 05                     (void)assign_local                 ; LV5
; feature/annie.lpc:552
0c5b:  40 05                     local                              ; LV5
0c5d:  04 24 01                  F_EFUN1                            ; EFUN: mapp(292)
0c60:  17 09 00                  branch_when_zero                   ; 0009 (0c6a)
0c63:  40 05                     local                              ; LV5
0c65:  04 DB 00                  F_EFUN1                            ; EFUN: values(219)
0c68:  6B 07                     (void)assign_local                 ; LV7
; feature/annie.lpc:553
0c6a:  40 07                     local                              ; LV7
0c6c:  18 07 00                  branch_when_non_zero               ; 0007 (0c74)
0c6f:  11 00 00                  aggregate                          ; 0
0c72:  6B 07                     (void)assign_local                 ; LV7
; feature/annie.lpc:554
0c74:  0F                        const0                             ; 
0c75:  6B 02                     (void)assign_local                 ; LV2
0c77:  19 1B 00                  branch                             ; 001b (0c93)
; feature/annie.lpc:556
0c7a:  02 02 C2 C6               F_PUSH                             ; push local 2, local 6
0c7e:  4C                        index                              ; 
0c7f:  40 04                     local                              ; LV4
0c81:  4C                        index                              ; 
0c82:  40 03                     local                              ; LV3
0c84:  15 0C 00                  branch_le                          ; 000c (0c91)
; feature/annie.lpc:557
0c87:  02 02 C2 C6               F_PUSH                             ; push local 2, local 6
0c8b:  4C                        index                              ; 
0c8c:  40 04                     local                              ; LV4
0c8e:  4C                        index                              ; 
0c8f:  6B 03                     (void)assign_local                 ; LV3
; feature/annie.lpc:558
0c91:  23 02                     loop_incr                          ; LV2
; feature/annie.lpc:559
0c93:  02 02 C2 C4               F_PUSH                             ; push local 2, local 4
0c97:  04 A2 00                  F_EFUN1                            ; EFUN: sizeof(162)
0c9a:  1D 21 00                  bbranch_lt                         ; 0021 (0c7a)
; feature/annie.lpc:556
0c9d:  3D 03                     transfer_local                     ; LV3
0c9f:  2F                        return                             ; 
0ca0:  30                        return_zero                        ; 
; feature/annie.lpc:560

;; Function: public int block_account(object)
0ca1:  40 00                     local                              ; LV0
0ca3:  0E 62                     short_string                       ; "[1;37m你的帐号数据异"
0ca5:  7E 18 00 02               simul_efun                         ; "tell_object" args: 2
0ca9:  01                        pop                                ; 
; feature/annie.lpc:564
0caa:  0E 63                     short_string                       ; "/cmds/adm/block"
0cac:  0E 65                     short_string                       ; "main"
0cae:  03 99 00                  F_EFUN0                            ; EFUN: this_object(153)
0cb1:  3D 00                     transfer_local                     ; LV0
0cb3:  0E 41                     short_string                       ; "query"
0cb5:  0E 64                     short_string                       ; "id"
0cb7:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0cbb:  07 97 00 04               F_EFUNV                            ; EFUN: call_other(151)
0cbf:  01                        pop                                ; 
; feature/annie.lpc:565
0cc0:  10                        const1                             ; 
0cc1:  2F                        return                             ; 
0cc2:  30                        return_zero                        ; 
; feature/annie.lpc:567

;; Function: public int check_legitimate_state(object)
0cc3:  40 00                     local                              ; LV0
0cc5:  04 34 01                  F_EFUN1                            ; EFUN: wizardp(308)
0cc8:  26 0C 00                  &&                                 ; 000c (0cd5)
0ccb:  40 00                     local                              ; LV0
0ccd:  0E 41                     short_string                       ; "query"
0ccf:  0E 66                     short_string                       ; "env/debug"
0cd1:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0cd5:  17 04 00                  branch_when_zero                   ; 0004 (0cda)
; feature/annie.lpc:574
0cd8:  10                        const1                             ; 
0cd9:  2F                        return                             ; 
; feature/annie.lpc:575
0cda:  40 00                     local                              ; LV0
0cdc:  0E 41                     short_string                       ; "query"
0cde:  0E 25                     short_string                       ; "str"
0ce0:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0ce4:  0B 5A                     byte                               ; 90
0ce6:  35                        >=                                 ; 
0ce7:  17 0A 00                  branch_when_zero                   ; 000a (0cf2)
; feature/annie.lpc:578
0cea:  40 00                     local                              ; LV0
0cec:  2D 13 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; block_account, pushed_args:1
0cf0:  01                        pop                                ; 
; feature/annie.lpc:580
0cf1:  30                        return_zero                        ; 
; feature/annie.lpc:581
0cf2:  40 00                     local                              ; LV0
0cf4:  0E 41                     short_string                       ; "query"
0cf6:  0E 2C                     short_string                       ; "int"
0cf8:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0cfc:  0B 50                     byte                               ; 80
0cfe:  15 0A 00                  branch_le                          ; 000a (0d09)
; feature/annie.lpc:584
0d01:  40 00                     local                              ; LV0
0d03:  2D 13 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; block_account, pushed_args:1
0d07:  01                        pop                                ; 
; feature/annie.lpc:586
0d08:  30                        return_zero                        ; 
; feature/annie.lpc:587
0d09:  40 00                     local                              ; LV0
0d0b:  0E 41                     short_string                       ; "query"
0d0d:  0E 28                     short_string                       ; "agi"
0d0f:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0d13:  0B 55                     byte                               ; 85
0d15:  36                        >                                  ; 
0d16:  25 2F 00                  ||                                 ; 002f (0d46)
0d19:  40 00                     local                              ; LV0
0d1b:  0E 41                     short_string                       ; "query"
0d1d:  0E 2A                     short_string                       ; "con"
0d1f:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0d23:  0B 55                     byte                               ; 85
0d25:  36                        >                                  ; 
0d26:  25 1F 00                  ||                                 ; 001f (0d46)
; feature/annie.lpc:590
0d29:  40 00                     local                              ; LV0
0d2b:  0E 41                     short_string                       ; "query"
0d2d:  0E 2E                     short_string                       ; "cps"
0d2f:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0d33:  0B 55                     byte                               ; 85
0d35:  36                        >                                  ; 
0d36:  25 0F 00                  ||                                 ; 000f (0d46)
0d39:  40 00                     local                              ; LV0
0d3b:  0E 41                     short_string                       ; "query"
0d3d:  0E 2D                     short_string                       ; "kar"
0d3f:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0d43:  0B 55                     byte                               ; 85
0d45:  36                        >                                  ; 
0d46:  17 0A 00                  branch_when_zero                   ; 000a (0d51)
; feature/annie.lpc:591
0d49:  40 00                     local                              ; LV0
0d4b:  2D 13 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; block_account, pushed_args:1
0d4f:  01                        pop                                ; 
; feature/annie.lpc:593
0d50:  30                        return_zero                        ; 
; feature/annie.lpc:594
0d51:  40 00                     local                              ; LV0
0d53:  0E 41                     short_string                       ; "query"
0d55:  0E 5B                     short_string                       ; "force_factor"
0d57:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0d5b:  0B 96                     byte                               ; 150
0d5d:  15 0A 00                  branch_le                          ; 000a (0d68)
; feature/annie.lpc:597
0d60:  40 00                     local                              ; LV0
0d62:  2D 13 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; block_account, pushed_args:1
0d66:  01                        pop                                ; 
; feature/annie.lpc:598
0d67:  30                        return_zero                        ; 
; feature/annie.lpc:599
0d68:  40 00                     local                              ; LV0
0d6a:  0E 41                     short_string                       ; "query"
0d6c:  0E 40                     short_string                       ; "combat_exp"
0d6e:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0d72:  09 00 1B B7 00 00 00 00 00  number                             ; 12000000
0d7b:  15 0A 00                  branch_le                          ; 000a (0d86)
; feature/annie.lpc:603
0d7e:  40 00                     local                              ; LV0
0d80:  2D 13 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; block_account, pushed_args:1
0d84:  01                        pop                                ; 
; feature/annie.lpc:604
0d85:  30                        return_zero                        ; 
; feature/annie.lpc:605
0d86:  02 02 C0 40               F_PUSH                             ; push local 0, number 0
0d8a:  2D 0C 00 02               F_CALL_FUNCTION_BY_ADDRESS         ; get_highest_skill_level, pushed_args:2
0d8e:  08 C2 01                  F_SHORT_INT                        ; short 450
0d91:  15 0A 00                  branch_le                          ; 000a (0d9c)
; feature/annie.lpc:609
0d94:  40 00                     local                              ; LV0
0d96:  2D 13 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; block_account, pushed_args:1
0d9a:  01                        pop                                ; 
; feature/annie.lpc:610
0d9b:  30                        return_zero                        ; 
; feature/annie.lpc:611
0d9c:  40 00                     local                              ; LV0
0d9e:  0E 41                     short_string                       ; "query"
0da0:  0E 32                     short_string                       ; "max_gin"
0da2:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0da6:  08 30 75                  F_SHORT_INT                        ; short 30000
0da9:  36                        >                                  ; 
0daa:  25 27 00                  ||                                 ; 0027 (0dd2)
; feature/annie.lpc:615
0dad:  40 00                     local                              ; LV0
0daf:  0E 41                     short_string                       ; "query"
0db1:  0E 31                     short_string                       ; "max_kee"
0db3:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0db7:  09 40 9C 00 00 00 00 00 00  number                             ; 40000
0dc0:  36                        >                                  ; 
0dc1:  25 10 00                  ||                                 ; 0010 (0dd2)
; feature/annie.lpc:616
0dc4:  40 00                     local                              ; LV0
0dc6:  0E 41                     short_string                       ; "query"
0dc8:  0E 33                     short_string                       ; "max_sen"
0dca:  07 97 00 03               F_EFUNV                            ; EFUN: call_other(151)
0dce:  08 30 75                  F_SHORT_INT                        ; short 30000
0dd1:  36                        >                                  ; 
0dd2:  17 0A 00                  branch_when_zero                   ; 000a (0ddd)
; feature/annie.lpc:617
0dd5:  40 00                     local                              ; LV0
0dd7:  2D 13 00 01               F_CALL_FUNCTION_BY_ADDRESS         ; block_account, pushed_args:1
0ddb:  01                        pop                                ; 
; feature/annie.lpc:618
0ddc:  30                        return_zero                        ; 
; feature/annie.lpc:619
0ddd:  10                        const1                             ; 
0dde:  2F                        return                             ; 
0ddf:  30                        return_zero                        ; 
; feature/annie.lpc:622

;; Function: hidden void #global_init#()
0de0:  12 00 00                  aggregate_assoc                    ; 0
0de3:  6E 00 00                  (void)assign_global                ; items(0)
0de6:  30                        return_zero                        ; 
; feature/annie.lpc:22

;;;  *** Line Number Info ***

absolute line -> (file, line) table:
0 lines from 1 [feature/annie.lpc]
15 lines from 2 [include/globals.h]
65 lines from 3 [include/path.h]
181 lines from 2 [include/globals.h]
9 lines from 1 [feature/annie.lpc]
77 lines from 4 [include/ansi.h]
1 lines from 1 [feature/annie.lpc]
23 lines from 5 [include/dbase.h]
1 lines from 1 [feature/annie.lpc]
39 lines from 6 [include/login.h]
613 lines from 1 [feature/annie.lpc]

address -> absolute line table:
0000-0003: 429
0004-000c: 436
000d-0016: 437
0017-001c: 438
001d-0024: 440
0025-002d: 441
002e-0034: 442
0035-0045: 444
0046-004e: 445
004f-004f: 446
0050-005a: 448
005b-0067: 449
0068-0071: 451
0072-0078: 455
0079-007e: 459
007f-0089: 476
008a-008d: 477
008e-0090: 478
0091-0093: 479
0094-009a: 480
009b-00a0: 481
00a1-00a8: 482
00a9-00ad: 483
00ae-00b0: 484
00b1-00c6: 486
00c7-00cc: 487
00cd-00d3: 490
00d4-00d6: 491
00d7-00dc: 492
00dd-00e1: 495
00e2-00e8: 496
00e9-00ec: 497
00ed-00fe: 502
00ff-0117: 503
0118-0122: 504
0123-0126: 505
0127-012f: 512
0130-0137: 513
0138-013a: 514
013b-0141: 515
0142-015b: 516
015c-015f: 517
0160-016b: 524
016c-0179: 525
017a-017e: 527
017f-0184: 528
0185-018c: 526
018d-0197: 530
0198-019b: 531
019c-01a2: 539
01a3-01a5: 540
01a6-01a8: 541
01a9-01ab: 542
01ac-01b1: 543
01b2-01b9: 544
01ba-01be: 545
01bf-01cb: 546
01cc-01ce: 547
01cf-01d4: 548
01d5-01db: 551
01dc-01de: 552
01df-01e4: 553
01e5-01ed: 556
01ee-01f7: 557
01f8-01fa: 558
01fb-0201: 559
0202-020b: 560
020c-020f: 561
0210-0218: 566
0219-0231: 575
0232-0243: 577
0244-024d: 578
024e-0251: 580
0252-0256: 581
0257-0264: 582
0265-026e: 584
026f-0279: 585
027a-0280: 586
0281-028f: 587
0290-0296: 588
0297-02a6: 589
02a7-02b3: 583
02b4-02ba: 592
02bb-02c4: 594
02c5-02cb: 595
02cc-02cf: 596
02d0-02d6: 597
02d7-02db: 598
02dc-02df: 599
02e0-02e9: 600
02ea-02f4: 602
02f5-02fb: 603
02fc-030d: 604
030e-0317: 605
0318-0320: 607
0321-032a: 608
032b-0335: 609
0336-0345: 611
0346-034f: 593
0350-0353: 614
0354-0356: 628
0357-0360: 630
0361-036a: 632
036b-0374: 633
0375-0392: 634
0393-0395: 635
0396-039d: 637
039e-03a4: 638
03a5-03b1: 639
03b2-03b9: 642
03ba-03c0: 643
03c1-03cd: 644
03ce-03dc: 647
03dd-03df: 648
03e0-03f0: 650
03f1-03f6: 651
03f7-040c: 652
040d-0416: 651
0417-0431: 653
0432-0436: 655
0437-0448: 656
0449-044e: 657
044f-0464: 658
0465-046e: 657
046f-0489: 659
048a-0493: 662
0494-049b: 663
049c-04ab: 665
04ac-04b5: 667
04b6-04c4: 668
04c5-04ce: 669
04cf-04d4: 671
04d5-04ea: 672
04eb-04f4: 671
04f5-050f: 674
0510-0515: 676
0516-0523: 677
0524-053a: 678
053b-053c: 679
053d-0546: 676
0547-054a: 684
054b-054d: 695
054e-0557: 697
0558-0575: 699
0576-0578: 700
0579-0580: 702
0581-0587: 703
0588-0594: 704
0595-059c: 707
059d-05a3: 708
05a4-05b0: 709
05b1-05bf: 712
05c0-05c2: 713
05c3-05c6: 715
05c7-05cc: 716
05cd-05e2: 717
05e3-05ec: 716
05ed-0607: 718
0608-060c: 720
060d-0611: 721
0612-0617: 722
0618-062d: 723
062e-0637: 722
0638-0652: 724
0653-0656: 728
0657-0660: 737
0661-066a: 739
066b-0672: 740
0673-0682: 742
0683-068c: 744
068d-069b: 745
069c-06a5: 746
06a6-06ab: 748
06ac-06c1: 749
06c2-06cb: 748
06cc-06e7: 751
06e8-06ed: 753
06ee-06fb: 754
06fc-0712: 755
0713-0714: 756
0715-0721: 753
0722-0736: 757
0737-073a: 759
073b-075e: 766
075f-0764: 770
0765-077f: 771
0780-0789: 770
078a-07ae: 773
07af-07b2: 774
07b3-07bc: 782
07bd-07cf: 784
07d0-07da: 786
07db-07e6: 787
07e7-07ee: 788
07ef-07fe: 789
07ff-0804: 790
0805-081f: 791
0820-0829: 790
082a-0845: 792
0846-0850: 795
0851-085c: 796
085d-0864: 797
0865-0874: 798
0875-087a: 799
087b-0895: 800
0896-089f: 799
08a0-08bc: 801
08bd-08d1: 804
08d2-08e6: 805
08e7-08fb: 806
08fc-08ff: 808
0900-0908: 815
0909-0910: 817
0911-091a: 819
091b-091b: 820
091c-0924: 822
0925-092d: 824
092e-0943: 825
0944-094d: 827
094e-095d: 829
095e-096a: 830
096b-0977: 831
0978-0987: 832
0988-0994: 833
0995-09a1: 834
09a2-09b1: 835
09b2-09be: 836
09bf-09cb: 837
09cc-09d0: 838
09d1-09d9: 841
09da-09de: 842
09df-09e7: 845
09e8-09f0: 846
09f1-09fa: 847
09fb-0a04: 848
0a05-0a0d: 849
0a0e-0a17: 850
0a18-0a20: 852
0a21-0a25: 853
0a26-0a2e: 857
0a2f-0a33: 858
0a34-0a4c: 861
0a4d-0a65: 862
0a66-0a6a: 863
0a6b-0a83: 866
0a84-0a88: 867
0a89-0a91: 870
0a92-0a93: 874
0a94-0ab9: 873
0aba-0ac2: 875
0ac3-0ae0: 876
0ae1-0ae3: 880
0ae4-0b03: 886
0b04-0b08: 887
0b09-0b0e: 888
0b0f-0b19: 889
0b1a-0b25: 890
0b26-0b27: 891
0b28-0b31: 888
0b32-0b33: 893
0b34-0b37: 900
0b38-0b57: 906
0b58-0b5c: 907
0b5d-0b62: 908
0b63-0b6d: 909
0b6e-0b83: 910
0b84-0b91: 911
0b92-0bb6: 912
0bb7-0bc8: 917
0bc9-0bce: 918
0bcf-0bd0: 919
0bd1-0bda: 908
0bdb-0bdc: 921
0bdd-0be1: 925
0be2-0be9: 928
0bea-0bf3: 929
0bf4-0bf4: 931
0bf5-0c03: 933
0c04-0c04: 934
0c05-0c0a: 936
0c0b-0c1d: 937
0c1e-0c27: 936
0c28-0c2b: 939
0c2c-0c2e: 944
0c2f-0c38: 948
0c39-0c40: 949
0c41-0c50: 950
0c51-0c5a: 952
0c5b-0c69: 953
0c6a-0c73: 954
0c74-0c79: 956
0c7a-0c86: 957
0c87-0c90: 958
0c91-0c92: 959
0c93-0c9c: 956
0c9d-0ca0: 960
0ca1-0ca9: 964
0caa-0cbf: 965
0cc0-0cc2: 967
0cc3-0cd7: 974
0cd8-0cd9: 975
0cda-0ce9: 978
0cea-0cf0: 980
0cf1-0cf1: 981
0cf2-0d00: 984
0d01-0d07: 986
0d08-0d08: 987
0d09-0d18: 990
0d19-0d28: 990
0d29-0d48: 991
0d49-0d4f: 993
0d50-0d50: 994
0d51-0d5f: 997
0d60-0d66: 998
0d67-0d67: 999
0d68-0d7d: 1003
0d7e-0d84: 1004
0d85-0d85: 1005
0d86-0d93: 1009
0d94-0d9a: 1010
0d9b-0d9b: 1011
0d9c-0dac: 1015
0dad-0dc3: 1016
0dc4-0dd4: 1017
0dd5-0ddb: 1018
0ddc-0ddc: 1019
0ddd-0ddf: 1022
0de0-0de6: 422
Trace duration: 247951.000000 us, dumping 12346 events to trace_lpcc.json in separate thread.
[thread 3d]: Dump trace successfully to file trace_lpcc.json, cost 29 ms.
