//プログラム全体で使われる定数とメタ関数

//実行ファイルのバージョン
def {
    CHECK_EXE_VERSION = sys.version >> 31
}

//単位
def {
    UNIT_FPS = 60//フレーム数/秒
    UNIT_SECOND = 1000//衝突時間
    UNIT_NORMAL = 1000//法線
    UNIT_REFLECTION = 1000//反射係数
}

//解像度
def {
    WINDOW_WIDTH  = 320
    WINDOW_HEIGHT = 240
}

//マップタイルのサイズ
def {
    MAPTILE_SIZE = 16
}

//共用ピクチャ
def {
    PIC_ACHIEVEMENT_TEXT = 300
    PIC_ACHIEVEMENT_EFFECT
}

//ミニゲーム用の一時変数
def {
    TV_MINIGAME = 400
    TS_MINIGAME = 64

    TV_PINBALL = 430//エターナルバトルが24個の変数を使う為、その分ずらす
    TS_PINBALL = 64
}

//一時変数
def {
    TV_NUMBER = 32
    TV_RETURN = 1 + TV_NUMBER * 0//返り値専用プール
    TV_MEV_1  = 1 + TV_NUMBER * 1
    TV_MEV_2  = 1 + TV_NUMBER * 2
    TV_CEV_1  = 1 + TV_NUMBER * 3
    TV_CEV_2  = 1 + TV_NUMBER * 4
    TV_CEV_3  = 1 + TV_NUMBER * 5
    TV_CEV_4  = 1 + TV_NUMBER * 6
    //1-224
}

//一時文字列
def {
    TS_NUMBER = 8
    TS_RETURN = 1 + TS_NUMBER * 0
    TS_MEV_1  = 1 + TS_NUMBER * 1
    TS_MEV_2  = 1 + TS_NUMBER * 2
    TS_CEV_1  = 1 + TS_NUMBER * 3
    TS_CEV_2  = 1 + TS_NUMBER * 4
    TS_CEV_3  = 1 + TS_NUMBER * 5
    TS_CEV_4  = 1 + TS_NUMBER * 6
    //1-57
}

//文字列定数
def {
    NEWLINE = "
"
}

//ブーリアン値
def {
    TRUE = 1
    FALSE = 0
}

//ブロック
def {
    EMPTY_BLOCK = bl {}
    ABORT_BLOCK = bl { @ev.abort }
    CONTINUE_BLOCK = bl { @continue }
    BREAK_BLOCK = bl { @break }
}

//画面表示、消去に使用する
//@scr.show, @scr.hide
def {
    FADE_NORMAL = 0
    FADE_BLOCK_EVENLY
    FADE_BLOCK_UP
    FADE_BLOCK_DOWN
    FADE_BLIND
    FADE_STRIPE_VERTICAL
    FADE_STRIPE_HORIZONTAL
    FADE_OUTSIDE_TO_CENTER
    FADE_CENTER_TO_OUTSIDE
    FADE_SCROLL_UP
    FADE_SCROLL_DOWN
    FADE_SCROLL_LEFT
    FADE_SCROLL_RIGHT
    FADE_SPLIT_VERTICAL
    FADE_SPLIT_HORIZONTAL
    FADE_SPLIT_CROSS
    FADE_ZOOM
    FADE_MOSAIC
    FADE_RASTERSCROLL
    FADE_FLASH
    FADE_NONE
}

//イベントの移動速度
def {
    SPEED_EIGHTH = 1
    SPEED_QUARTER
    SPEED_HALF
    SPEED_NORMAL
    SPEED_DOUBLE
    SPEED_QUADRUPLE
}
def {
    SPEED_ACT_EIGHTH    = -3
    SPEED_ACT_QUARTER   = -2
    SPEED_ACT_HALF      = -1
    SPEED_ACT_NORMAL    = 0
    SPEED_ACT_DOUBLE    = 1
    SPEED_ACT_QUADRUPLE = 2
}

//向き
def {
    DIR_FACE_UP = 0
    DIR_FACE_RIGHT
    DIR_FACE_DOWN
    DIR_FACE_LEFT
}

//イベントの方向
def {
    DIR_EV_UP = 0
    DIR_EV_RIGHT
    DIR_EV_DOWN
    DIR_EV_LEFT
    DIR_EV_UPRIGHT
    DIR_EV_DOWNRIGHT
    DIR_EV_DOWNLEFT
    DIR_EV_UPLEFT
}


//キー入力
def {
    KEY_NONE = 0
    KEY_DOWN
    KEY_LEFT
    KEY_RIGHT
    KEY_UP
    KEY_DECISION
    KEY_CANCEL
    KEY_SHIFT
    KEY_EMPTY_8
    KEY_EMPTY_9
    KEY_NUMBER_0
    KEY_NUMBER_1
    KEY_NUMBER_2
    KEY_NUMBER_3
    KEY_NUMBER_4
}

//キー入力
def {
    KEY_REPEAT_STOP = 16
    KEY_REPEAT_INTERVAL = 4//REPEAT_STOPの約数を指定する
}

//音階
def {
    F_C5 = 100//ド(0)
    F_C5S= 106//ド#
    F_D5 = 112//レ
    F_D5S= 119//レ#
    F_E5 = 126//ミ
    F_F5 = 133//ファ
    F_F5S= 141//ファ#
    F_G5 = 150//ソ
    F_G5S= 159//ソ#
    F_A5 = 168//ラ
    F_A5S= 178//ラ#
    F_B5 = 189//シ
    F_C6 = 200//ド(7)
    F_C6S= 212//ド#
    F_D6 = 225//レ(8)
} 

//------------------------------------------------
//分岐処理

//疑似的なスイッチ文
//ループ文を使っている
__fn pseudoSwitchState $value $array $default {
    $case = 0
    @loop 1 bl {
        __loop $array $elem $index bl {
            __if $index % 2 == 0 bl {
                //強引にメタ変数を書き換える
                $case *= 0 
                $case += $elem
            } .else bl {
                @if $value == $case bl {
                    $elem
                    @break
                }
            }
        }
        
        $default
        @break
    }
}

//トリガー文
__fn triggerSwitchState $dvValue $array {
    $bit = 0
    @if `$dvValue bl {
        __loop $array $elem $index bl {
            __if $index % 2 == 0 bl {
                $bit *= 0 
                $bit += $elem
            } .else bl {
                @if `$dvValue & $bit bl {
                    v[__id($dvValue)] &= (-1) ^ ($bit)
                    $elem
                }
            }
        }
    }
}

//------------------------------------------------
//変数処理
//イベント用の変数と文字列変数を全て初期化する
__fn initialTempValues bl {
    //変数を初期化する
    v[1..260] = 0
    //文字列変数を初期化する
    t[1..63].asg("")
}

//宣言された変数を使って範囲を指定し、値を一括代入する
__fn assignVarUsingDeclared $dvHead $dvFoot $var bl {
    v[__id($dvHead)..__id($dvFoot)] = $var
}

//宣言された文字列変数を使って範囲を指定し、値を一括代入する
__fn assignStrUsingDeclared $dvHead $dvFoot $var bl {
    t[__id($dvHead)..__id($dvFoot)] .asg($var)
}

//配列を初期化する
__fn initArray $dvArr $size $var bl {
    v[__id($dvArr)..__id($dvArr) + ($size) - 1] = $var
}

//配列の値を配列で代入する
//初期化と全く同じ内容だが、一応分けておく
__fn copyToArray $dvDstArr $size $srcArr bl {
    v[__id($dvDstArr)..__id($dvDstArr) + ($size) - 1] = $srcArr
}

//配列から値を取得する
__fn readFromArray $dvDst $dvArr $idx bl {
    v[__id($dvDst)] = v[__id($dvArr) + ($idx)]
}

//配列に値を代入する
__fn writeToArray $src $dvArr $idx bl {
    v[__id($dvArr) + $idx] = $src
}

//ビットフラグを立てる
__fn bitOn $dvDst $t bl {
    v[__id($dvDst)] |= ($t)
}

//ビットフラグを落とす
__fn bitOff $dvDst $t bl {
    v[__id($dvDst)] &= (-1) ^ ($t)
}

//ビットを反転させる
__fn bitFlip $dvDst $t bl {
    v[__id($dvDst)] = (-1) - ($t)
}

//立っているビットの数を数える
//32を超えると次の変数を参照する
__fn countNumberOfBit $dvDst $loop $tag {
    v[__id($dvDst)] = 0
    localB = $loop
    @loop localB .dst(localA) bl {
        @if `(v[__id($tag) + localA / 32] & (0x01 << (localA % 32))) != 0x00 bl {
            v[__id($dvDst)] += 1
        }
    }
}

//変数の符号を返す
__fn getSgn $dvDst $s bl {
    v[__id($dvDst)] = ($s) > 0 ? 1 : (($s) < 0 ? -1 : 0)
}

//距離を詰めるように速度を更新する
//放物線の高さ h = 1 / 2 * g * t ^ 2
//停止に掛かる時間 t = v0 / g
//速度 v = d - v ^ 2 / (g * 2) * sgn(v) - v
__fn updateSpeedToApproach $dvDst $dis $vel $lim bl {
    v[__id($dvDst)] += clamp((($dis) - ($vel) * ($vel) / (($lim) * 2) * (($vel > 0) ? 1 : -1)) - ($vel), -($lim), ($lim))
}

//イージング関数
//y = x^2 / (2(x^2^-x) + 1) (0<=x<=1)
//y = (h * x^2) / (2 * x^2 - 2x * w + w^2)
//h: scale y  w: scale x
__fn easingInOut $dst $x $h $w {
    $sqX = pow($x, 2)
    $sqW = pow($w, 2)
    v[__id($dst)] = muldiv($h, $sqX, 2 * $sqX - 2 * $x * $w + $sqW)
}

//座標が画面内にあるか
__fn isInWindow $dvDst $x $y bl {
    v[__id($dvDst)] = 0 < ($x) && ($x) < WINDOW_WIDTH && 0 < ($y) && ($y) < WINDOW_HEIGHT ? TRUE : FALSE
}

//簡易アニメーション
__fn easyAnimation $dvIdx $loop $start $end $frame $interval bl {
    __if $loop == TRUE bl {
        __if $start < $end bl {
            v[__id($dvIdx)] = $start + (($frame) / ($interval)) % ($end - $start + 1)
        } .else bl {
            v[__id($dvIdx)] = $start - (($frame) / ($interval)) % ($start - $end + 1)
        }
    } .else bl {
        __if $start < $end bl {
            v[__id($dvIdx)] = $start + min(($frame) / ($interval), $end - $start) 
        } .else bl {
            v[__id($dvIdx)] = $start - min(($frame) / ($interval), $start - $end)
        }
    }
}

//範囲内の変数に乱数を割り当てて、異常な動作がないかを確かめる
__fn debug_setRandomNumber $num $dvHeader bl {
    @loop $num .dst($dvHeader) bl {
        v[__id($dvHeader)] = rnd(1, 100)

    }

}

//変数やピクチャIDの範囲をコメントで表示する
__fn commentRangeOfVariables $dvFoot $head $numVar $numStr $numPic bl {
    $num = __id($dvFoot)
    $num -= $head
    $num += 1
    @comment __str("Range of variables : ", $head, " to ", __id($dvFoot), ", num : ", $num )
    @comment __str("variable : ", $numVar, "  string : ", $numStr, "  picture : ", $numPic)
}

//------------------------------------------------
//グラフィック

//システムグラフィックをデフォルトのものに設定する
__fn setDefaultSystemGraphic {
    @sys.skin "SystemDef" .stretch .gothic
}

//色調を使って画面を表示する
__fn fastFadeIn $time {
    @scr.tint .rgbs(0, 0, 0, 100) .time(0)
    @scr.show(FADE_FLASH)
    @scr.tint .rgbs(100, 100, 100, 100) .time($time)
}

//色調を使って画面を消去する
__fn fastFadeOut $time {
    @scr.tint .rgbs(0, 0, 0, 100) .time($time) .wait
    @scr.hide(FADE_FLASH)
    @scr.tint .rgbs(100, 100, 100, 100) .time(0)
}

//色調を使って場面転換を演出する
__fn fastFadeInTintOnly $time bl {
    @scr.tint .rgbs(0, 0, 0, 100) .time(0)
    @scr.tint .rgbs(100, 100, 100, 100) .time($time)

}

//------------------------------------------------
//ピクチャ

//ピクチャの存在をチェックする
__fn pictureExists $dvDst $i {
    @pic[$i].getInfo .baseRect(unusedV, unusedV, localA, unusedV) .xywh//ピクチャが存在していないと幅が0になる
    v[__id($dvDst)] = localA > 0 ? TRUE : FALSE
}

//複数のピクチャを削除する
__fn erasePictures $head $end bl {
    @pic.erase [$head..$end]
}

//ピクチャを隠す
__fn hidePicture $id {
    @pic.move[$id] {
        .topLeft
        .pos(-320, -320) 
        .scale(100)
        .trans(100)
    }
}

//配列で指定してピクチャを隠す
__fn hidePicturesForEach $arr {
    @foreach $arr .dst(localA) {
        @pic.move[localA] {
            .topLeft
            .pos(-320, -320) 
            .scale(100)
            .trans(100)
        }
    }
}
//デバグ用のピクチャを表示する
__fn db_log $str bl {
    @pic[1].strpic {
        $str
        .pos(0, 0) .topLeft
        .size(0, 0) .chromakey(1)
        .scale(100)
        .trans(50)
        .rgbs(100, 100, 100, 100)
        .font("", 12)
        .spacing(0, 4)
        .skin("") .stretch
        .mapLayer(7)
        .eraseWhenTransfer
        .affectedByFlash
        .affectedByShake
    }

}

//デバグ用のピクチャを表示する
//変数を三つ表示する
__fn db_log_v3 $v1 $v2 $v3 bl {
    @pic[1].strpic {
        __str("v: \",$v1, ", \",$v2, ", \",$v3)
        .pos(0, 0) .topLeft
        .size(0, 0) .chromakey(1)
        .scale(100)
        .trans(50)
        .rgbs(100, 100, 100, 100)
        .font("", 12)
        .spacing(0, 4)
        .skin("") .stretch
        .mapLayer(7)
        .eraseWhenTransfer
        .affectedByFlash
        .affectedByShake
    }

}

//------------------------------------------------
//入力

//方向キーの入力を取得する
__fn V2_getInput $dvDest bl {
    v[0 + __id($dvDest)..1 + __id($dvDest)] = 0
    @key.input .dst(localA) .right
    v[0 + __id($dvDest)] += localA != 0 ? 1 : 0
    @key.input .dst(localA) .left
    v[0 + __id($dvDest)] -= localA != 0 ? 1 : 0
    @key.input .dst(localA) .down
    v[1 + __id($dvDest)] += localA != 0 ? 1 : 0
    @key.input .dst(localA) .up
    v[1 + __id($dvDest)] -= localA != 0 ? 1 : 0

}

//何かの入力を待つ
__fn getAnyKey $dvDest $wait bl {
    __if $wait == TRUE bl {
        @key.input .dst($dvDest) .wait {
            .up
            .down
            .left
            .right
            .decision
            .cancel
            .shift
        }
    } .else bl {
        @key.input .dst($dvDest) {
            .up
            .down
            .left
            .right
            .decision
            .cancel
            .shift
        }
    }
}

//ポーズの共通処理
//キャンセルを押すと続ける
__fn pauseProcces $type $var $label {
    $block = bl {
        @se.play "Cancel2" .opt(100, 100, 50)
        //選択肢にメタ変数は使えない
        @msg.choice bl {
            .cancel(0)
            .case "\>つづける" bl {
                @wait(3)
            }
            .case "\>やめる" bl {
                @label.jump $label
            }
        }
    }

    //キャンセルキーを押すと選択肢が出る
    __if $type == TRUE bl {
        @key.input .dst($var) .cancel
        @if $var != 0 bl {
            $block
            v[__id($var)] = 0
        }
    } .else bl {
        @if `$var == KEY_CANCEL bl {
            $block
        }
    }
}

//再開の共通処理
//キャンセルを押すと終了する
__fn replayProcess $replayLabel $endLabel bl {
    @msg.choice bl {
        .cancel(1)
        .case "\>もういちど" bl {
            @label.jump $replayLabel
        }
        .case "\>やめる" bl {
            @label.jump $endLabel
        }
    }
}

//------------------------------------------------
//メッセージ

//メッセージのデフォルト設定
__fn msgDefault {
    @msg.opt {
        .opaq
        .varyPos
        .allowEventMove
        .size 0, 0
        .font "", 0
    }
    @msg.face("", 0, .left)
}

//下に置く
__fn msgBottom bl {
    @msg.opt .opaq .bottom .size(0, 0) .font("", 0)
    @msg.face("", 0, .left)
}

//------------------------------------------------
//音声

//BGMを記録して止める
__fn storeAndStopBGM bl {
    @if enableDedicatedBGM.isOn bl {
        @bgm.store
        @bgm.stop
    }
}

//BGMを記録する
__fn storeBGM bl {
    @if enableDedicatedBGM.isOn bl {
        @bgm.store
    }
}

//記録したBGMを再生する
__fn restoreBGM bl {
    @if enableDedicatedBGM.isOn bl {
        @bgm.restore
    }
}

//BGMを再生する
__fn startBGM $path $restart $fadeIn $volume $temo $balance bl {
    @if enableDedicatedBGM.isOn bl {
        __if $restart == TRUE bl {
            @bgm.stop
        }
        @bgm.play $path .opt($fadeIn, $volume, $temo, $balance)
    }
}

//BGMを止める
__fn stopBGM $fadeOut bl {
    @if enableDedicatedBGM.isOn bl {
        __if $fadeOut > 0 bl {
            @bgm.fadeout($fadeOut)
        } .else bl {
            @bgm.stop
        }
    }
}

//------------------------------------------------
//イベント

//マップイベントを呼び出す
__fn callMapEvent $ev $page {
    v[__id(localA)..__id(localB)] = [$ev, $page]
    @ev.call .mev(localA, localB)
}

//コモンイベントを呼び出す
__fn callCommonEvent $ev {
    @ev.call .cev($ev)
}

//イベントの中心座標を代入する
__fn V2_setEventCenter $dvDst $ev {
    v[__id($dvDst)+0] = ev[$ev].scrx + 0 + cameraX
    v[__id($dvDst)+1] = ev[$ev].scry - MAPTILE_SIZE / 2 + cameraY
}

//イベントの中心座標を加える
__fn V2_addEventCenter $dvDst $ev {
    v[__id($dvDst)+0] += ev[$ev].scrx + 0 + cameraX
    v[__id($dvDst)+1] += ev[$ev].scry - MAPTILE_SIZE / 2 + cameraY
}

//イベントの位置を再配置する
//ゼロを指定すると呼び出し元を対象とする
__fn resetEventPosition $ev {
    __if $ev == 0 {
        @ev[10005].swap .self
    } .else {
        @ev[$ev].swap($ev)
    }
}

//変数を使って指定する
__fn resetEventPositionByVar $ev {
    localA = ev[$ev].x
    localB = ev[$ev].y
    @ev[$ev].setPos .pos(localA, localB) 
}

//------------------------------------------------
//ミニゲーム用のピクチャ、変数、文字列変数を初期化する
__fn initPicturesAndVariables $picHead $picNum $varHead $varNum $strHead $strNum {
    __if $picNum > 0 bl {
        @pic.erase [$picHead..$picHead + $picNum - 1]
    }
    __if $varNum > 0 bl {
        v[$varHead..$varHead + $varNum - 1] = 0
    }
    __if $strNum > 0 bl {
        t[$strHead..$strHead + $strNum - 1] .asg("")
    }
}

//実績を達成しているかチェックする
__fn checkSetAchievement $dvSwitch $if bl {
    @if s[__id($dvSwitch)].isOff bl {
        @if `$if bl {
            $id = __id($dvSwitch)
            $id += 0
            setAchievement($id)
        }
    }
}

//------------------------------------------------
//コモンイベントに引数と返り値のやりとりを追加する

//無効な変数
defv unusedV = 0
defs unusedS = 0
deft unusedT = 0

//引数を入力する
//if文を増やせば、対応できる引数の数も増える
__fn sendArgmuentValue $h $n $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 {
    __if $n == 0 {
    } .elif $n ==  1 { v[$h] = $1
    } .elif $n ==  2 { v[$h..$h+ 1] = [$1, $2]
    } .elif $n ==  3 { v[$h..$h+ 2] = [$1, $2, $3]
    } .elif $n ==  4 { v[$h..$h+ 3] = [$1, $2, $3, $4]
    } .elif $n ==  5 { v[$h..$h+ 4] = [$1, $2, $3, $4, $5]
    } .elif $n ==  6 { v[$h..$h+ 5] = [$1, $2, $3, $4, $5, $6]
    } .elif $n ==  7 { v[$h..$h+ 6] = [$1, $2, $3, $4, $5, $6, $7]
    } .elif $n ==  8 { v[$h..$h+ 7] = [$1, $2, $3, $4, $5, $6, $7, $8]
    } .elif $n ==  9 { v[$h..$h+ 8] = [$1, $2, $3, $4, $5, $6, $7, $8, $9]
    } .elif $n == 10 { v[$h..$h+ 9] = [$1, $2, $3, $4, $5, $6, $7, $8, $9, $10]
    } .elif $n == 11 { v[$h..$h+10] = [$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11]
    } .elif $n == 12 { v[$h..$h+11] = [$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12]
    } .elif $n == 13 { v[$h..$h+12] = [$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13]
    } .elif $n == 14 { v[$h..$h+13] = [$1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14]
    }
}

//文字列引数
__fn sendArgmuentString $h $n $1 $2 $3 $4 {
    __if $n >=  1 { t[$h].asg($1, .extract) }
    __if $n >=  2 { t[$h].asg($2, .extract) }
    __if $n >=  3 { t[$h].asg($3, .extract) }
    __if $n >=  4 { t[$h].asg($4, .extract) }
}

//返り値を指定した変数へ代入する
__fn receiveReturnValue $n $1 $2 $3 $4 $5 $6 $7 $8 $9 $10 $11 $12 $13 $14 {
    __if $n >=  1 { __if __id($1)  != __id(unusedV) { v[__id($1) ] = v[TV_RETURN +  0] } }
    __if $n >=  2 { __if __id($2)  != __id(unusedV) { v[__id($2) ] = v[TV_RETURN +  1] } }
    __if $n >=  3 { __if __id($3)  != __id(unusedV) { v[__id($3) ] = v[TV_RETURN +  2] } }
    __if $n >=  4 { __if __id($4)  != __id(unusedV) { v[__id($4) ] = v[TV_RETURN +  3] } }
    __if $n >=  5 { __if __id($5)  != __id(unusedV) { v[__id($5) ] = v[TV_RETURN +  4] } }
    __if $n >=  6 { __if __id($6)  != __id(unusedV) { v[__id($6) ] = v[TV_RETURN +  5] } }
    __if $n >=  7 { __if __id($7)  != __id(unusedV) { v[__id($7) ] = v[TV_RETURN +  6] } }
    __if $n >=  8 { __if __id($8)  != __id(unusedV) { v[__id($8) ] = v[TV_RETURN +  7] } }
    __if $n >=  9 { __if __id($9)  != __id(unusedV) { v[__id($9) ] = v[TV_RETURN +  8] } }
    __if $n >= 10 { __if __id($10) != __id(unusedV) { v[__id($10)] = v[TV_RETURN +  9] } }
    __if $n >= 11 { __if __id($11) != __id(unusedV) { v[__id($11)] = v[TV_RETURN + 10] } }
    __if $n >= 12 { __if __id($12) != __id(unusedV) { v[__id($12)] = v[TV_RETURN + 11] } }
    __if $n >= 13 { __if __id($13) != __id(unusedV) { v[__id($13)] = v[TV_RETURN + 12] } }
    __if $n >= 14 { __if __id($14) != __id(unusedV) { v[__id($14)] = v[TV_RETURN + 13] } }
}

//文字列返り値
__fn receiveReturnString $n $1 $2 $3 $4 {
    __if $n >= 1 { __if __id($1) != __id(unusedT) { t[__id($1)].asg(t[TS_RETURN + 0]) } }
    __if $n >= 2 { __if __id($2) != __id(unusedT) { t[__id($2)].asg(t[TS_RETURN + 1]) } }
    __if $n >= 3 { __if __id($3) != __id(unusedT) { t[__id($3)].asg(t[TS_RETURN + 2]) } }
    __if $n >= 4 { __if __id($4) != __id(unusedT) { t[__id($4)].asg(t[TS_RETURN + 3]) } }
}