#include "game/armem.h"
#include "game/disp.h"
#include "game/gamework_data.h"
#include "game/hsfman.h"
#include "game/object.h"
#include "game/objsub.h"
#include "game/pad.h"
#include "game/process.h"
#include "game/sprite.h"
#include "game/window.h"
#include "game/wipe.h"

#include "game/minigame_seq.h"

#include "math.h"

#include "stdarg.h"
#include "version.h"

#undef abs

#define ABS(x) (((x) < 0) ? -(x) : (x))

extern s16 HuSysVWaitGet(s16 param);

typedef struct seq_info {
    SeqInitFunc init;
    SeqUpdateFunc update;
    float x;
    float y;
    float scale_x;
    float scale_y;
    s32 time_max;
} SeqInfo;

OverlayID mgSeqOvlPrev = OVL_INVALID;

static SeqInfo seqInfoTbl[] = {
    { NULL, NULL, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 60 },
    { MGSeqInitTimer, MGSeqUpdateTimer, HU_DISP_CENTERX + 4, 64.0f, 1.0f, 1.0f, 60 },
    { MGSeqInitType2, MGSeqUpdateType2, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 0.5f, 0.5f, 60 },
    { MGSeqInitMGBasic, MGSeqUpdateMGBasic, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
    { MGSeqInitMGCommon, MGSeqUpdateMG1vs3, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
    { MGSeqInitWin, MGSeqUpdateWin, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
    { MGSeqInitMGCommon, MGSeqUpdateMGBattle, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
    { MGSeqInitMGCommon, MGSeqUpdateMGStory, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
    { MGSeqInitMGBasic, MGSeqUpdateMGBasic, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
    { MGSeqInitMGCommon, MGSeqUpdateMG2vs2, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
    { MGSeqInitFlip, MGSeqUpdateFlip, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
    { MGSeqInitMGCommon, MGSeqUpdateMGBowser, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
    { MGSeqInitWin, MGSeqUpdateWin, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
    { MGSeqInitDraw, MGSeqUpdateDraw, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 60 },
    { MGSeqInitRecord, MGSeqUpdateRecord, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 180 },
    { NULL, NULL, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 60 },
    { NULL, NULL, HU_DISP_CENTERX + 4, HU_DISP_CENTERY, 1.0f, 1.0f, 60 },
};

static s32 seqType2SprTbl[6] = { 0, 0, 0, 0, 0, 0 };

static s16 mgSeqTypeTbl[9] = {
    MG_SEQ_TYPE_4P,
    MG_SEQ_TYPE_1VS3,
    MG_SEQ_TYPE_2VS2,
    MG_SEQ_TYPE_BOWSER,
    MG_SEQ_TYPE_BATTLE,
    MG_SEQ_TYPE_PINBALL,
    MG_SEQ_TYPE_STORY,
    MG_SEQ_TYPE_BOWSER,
    MG_SEQ_TYPE_STORY,
};

static char lbl_8012F336[] = {
    "ｱｲｳｴｵｶｷｸ"
    "ｹｺｻｼｽｾｿﾀ"
    "ﾁﾂﾃﾄﾅﾆﾇﾈ"
    "ﾉﾊﾋﾌﾍﾎﾏﾐ"
    "ﾑﾒﾓﾔﾕﾖﾗﾘ"
    "ﾙﾚﾛﾜｦﾝｧｨ"
    "ｩｪｫｬｭｮｯｶ"
    "ｷｸｺｻｼｽｾｿ"
    "ﾀﾁﾂﾃﾄﾊﾋﾌ"
    "ﾍﾎﾊﾋﾌﾍﾎ"
    "!?ｰ",
};

static char lbl_8012F389[] = "x first\n";
static char lbl_8012F392[] = "y first\n";

static SeqWork seqWorkData[8];

static s16 seqTimer;
static u8 seqDoneF;
u8 lbl_801D3D94;
static s16 seqSpeed;
static s16 seqPauseF;
static int seqRecordVal;
static s32 pauseWaitF;
static s32 pauseExitF;
static s32 pauseActiveF;
static Process *pauseProcess;
static s32 seqLanguage;

void fn_80036BC8(void);

void MGSeqInit(void)
{
    s32 i;
    SeqWork *work;
    work = &seqWorkData[0];
    for (i = 8; i != 0; i--, work++) {
        work->seq_no = 0;
        work->data = NULL;
    }
    seqPauseF = 0;
    seqDoneF = 0;
    lbl_801D3D94 = 0;
    seqTimer = 30;
    HuAR_DVDtoARAM(DATADIR_GAMEMES);
    HuAR_DVDtoARAM(DATADIR_MGCONST);
    while (HuARDMACheck())
        ;
    fn_80036BC8();
    mgSeqOvlPrev = -1;
    seqLanguage = GWLanguageGet();
}

void MGSeqMain(void)
{
    SeqInfo *info;
    s32 i;
    s32 j;
    s32 alive_flag;
    u8 stat;
    SeqWork *work;

    seqSpeed = HuSysVWaitGet(seqSpeed);
    if (Hu3DPauseF) {
        return;
    }
    alive_flag = 0;
    stat = 0;
    work = &seqWorkData[0];
    for (i = 0; i < 8; i++, work++) {
        if (work->stat == 0) {
            continue;
        }
        if (work->update) {
            alive_flag = work->update(work);
        }
        else {
            info = &seqInfoTbl[work->seq_no];
            if (work->seq_no != 0 && NULL != info->update) {
                alive_flag = info->update(work);
            }
        }
        if (!alive_flag) {
            work->stat = 0;
            if (!lbl_801D3D94) {
                for (j = 0; j < 8; j++) {
                    if (seqWorkData[j].stat) {
                        break;
                    }
                }
            }
            if (!work->data) {
                HuMemDirectFree(work->data);
                work->data = NULL;
            }
        }
        stat |= work->stat;
    }
    if (!stat || stat & 0x4) {
        if (seqTimer > 0) {
            seqTimer -= seqSpeed;
        }
    }
}

static s16 CreateSeq(s16 seq_no, va_list params)
{
    SeqWork *work;
    SeqInfo *info;
    s32 i;
    s32 temp;
    work = seqWorkData;
    info = &seqInfoTbl[(u8)seq_no];
    for (i = 0; i < 8; i++, work++) {
        if (work->stat == 0) {
            break;
        }
    }
    if (i >= 8) {
        return -1;
    }
    work->stat |= 0x1;
    if (work->data) {
        HuMemDirectFree(work->data);
    }
    work->data = NULL;
    work->seq_no = (u8)seq_no;
    work->time = 0;
    work->x = info->x;
    work->y = info->y;
    work->scale_x = info->scale_x;
    work->scale_y = info->scale_y;
    work->unk_18 = 0.0f;
    work->unk_7D = 255;
    work->time_max = info->time_max;
    work->timer_val = work->state = work->alt_word_len = work->word_len = 0;
    work->angle = work->win_scale = 0.0f;
    work->param[0] = work->param[1] = 0;
    for (temp = 0; temp < 16; temp++) {
        work->sprite[temp] = work->spr_grp[temp] = -1;
    }
    if (NULL != info->init) {
        temp = info->init(work, params);
        if (temp == 0) {
            work->stat = 0;
            return -1;
        }
    }
    seqTimer = 30;
    return i;
}

s16 MGSeqCreate(s16 type, ...)
{
    s16 ret;
    va_list params;
    va_start(params, type);
    if (type == MG_SEQ_TYPE_AUTO) {
        if (GWSystem.mg_next == 0xFFFF) {
            type = MG_SEQ_TYPE_4P;
        }
        else {
            type = mgSeqTypeTbl[mgInfoTbl[GWSystem.mg_next].type];
        }
    }
    ret = CreateSeq(type, params);
    va_end(params);
    return ret;
}

u8 MGSeqStatGet(s16 id)
{
    SeqWork *work;
    u8 ret = 0;
    if (id < 0) {
        s32 i;
        work = seqWorkData;
        for (i = 8; i != 0; i--, work++) {
            ret |= work->stat;
        }
    }
    else {
        if (id < 8) {
            ret = seqWorkData[id].stat;
        }
    }
    return ret;
}

void MGSeqPosSet(s16 id, float x, float y)
{
    if (id >= 0 && id < 8) {
        seqWorkData[id].x = x;
        seqWorkData[id].y = y;
    }
}

void MGSeqParamSet(s16 id, s16 param1, s16 param2)
{
    if (id >= 0 && id < 8) {
        seqWorkData[id].param[0] = param1;
        seqWorkData[id].param[1] = param2;
    }
}

void MGSeqKill(s16 id)
{
    if (id >= 0 && id < 8) {
        if (seqWorkData[id].stat != 0) {
            seqWorkData[id].stat = 8;
        }
    }
}

void MGSeqKillAll(void)
{
    seqDoneF = 1;
    MGSeqMain();
    seqDoneF = 0;
    MGSeqStub();
    lbl_801D3D94 = 0;
}

s32 MGSeqDoneCheck(void)
{
    u8 stat = MGSeqStatGet(-1);
    if (stat == 0 || (stat & 0xC)) {
        if (seqTimer <= 0 || (stat & 0x8)) {
            return 1;
        }
    }
    return 0;
}

void MGSeqStub(void) { }

void MGSeqSprKill(SeqWork *work)
{
    s32 i;
    for (i = 0; i < 16; i++) {
        if (work->spr_grp[i] >= 0) {
            HuSprGrpKill(work->spr_grp[i]);
        }
        if (work->sprite[i] >= 0) {
            HuSprKill(work->sprite[i]);
        }
    }
}

static void *SeqReadFile(s32 file)
{
    return HuAR_ARAMtoMRAMFileRead(file, MEMORY_DEFAULT_NUM, HEAP_DATA);
}

s32 MGSeqInitTimer(SeqWork *work, va_list params)
{
    AnimData *spr_anim;
    s16 sprite;
    s16 spr_grp;
    int duration, x, y;
    s16 i;

    duration = va_arg(params, int);
    x = va_arg(params, int);
    y = va_arg(params, int);
    if (duration <= 0 && duration > 99) {
        duration = 99;
    }
    work->timer_val = duration;
    if (x >= 0) {
        work->x = x;
    }
    if (y >= 0) {
        work->y = y;
    }
    work->alt_word_len = 0;
    work->state = 2;
    work->angle = 0;
    work->spr_grp[0] = spr_grp = HuSprGrpCreate(4);
    HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
    spr_anim = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 2)));
    x = 12;
    for (i = 0; i < 2; i++) {
        sprite = HuSprCreate(spr_anim, 5, 0);
        HuSprGrpMemberSet(spr_grp, i, sprite);
        HuSprSpeedSet(spr_grp, i, 0);
        HuSprPosSet(spr_grp, i, x, 0);
        HuSprColorSet(spr_grp, i, 112, 233, 255);
        x -= 24;
        (void)i; // Hack for Matching
    }
    spr_anim = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 1)));
    sprite = HuSprCreate(spr_anim, 7, 0);
    HuSprGrpMemberSet(spr_grp, 2, sprite);
    HuSprPosSet(spr_grp, 2, 0, 0);
    HuSprTPLvlSet(spr_grp, 2, 0.5f);
    HuSprColorSet(spr_grp, 2, 0, 0, 0);
    spr_anim = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 0)));
    sprite = HuSprCreate(spr_anim, 6, 0);
    HuSprGrpMemberSet(spr_grp, 3, sprite);
    HuSprPosSet(spr_grp, 3, 0, 0);
    if (seqPauseF) {
        work->state = 1;
        for (i = 0; i < 2; i++) {
            HuSprAttrSet(spr_grp, i, HUSPR_ATTR_DISPOFF);
#if VERSION_NTSC
            //(void)i; //Hack for Matching
#endif
        }
    }
#if VERSION_PAL
    HuSprGrpPosSet(spr_grp, -1000.0f, 0.0f);
#endif
    return 1;
}

s32 MGSeqUpdateTimer(SeqWork *work)
{
    float scale;
    float tp_lvl;
    u8 digits[2];
    s16 i;
    s16 spr_grp = work->spr_grp[0];
    if (work->param[0] != 0 && work->state != -1) {
        switch (work->param[0]) {
            case 2:
                switch (work->param[1]) {
                    case -1:
                        work->stat |= 0x4;
                        work->state = -1;
                        work->angle = 0.0f;
                        break;

                    case 0:
                        work->state = 2;
                        work->angle = 0.0f;
                        break;

                    case 1:
                        work->state = 3;
                        work->angle = 0.0f;
                        break;

                    default:
                        break;
                }
                work->param[0] = 0;
                break;

            case 1:
                if (work->param[1] < 0 && !(work->stat & 0x4)) {
                    work->stat |= 0x4;
                    work->state = -1;
                    work->angle = 0.0f;
                }
                else {
                    if (work->param[1] > 99) {
                        work->timer_val = 99;
                    }
                    else {
                        if (work->timer_val != work->param[1]) {
                            work->timer_val = work->param[1];
                            if (work->param[1] <= 5) {
                                HuAudFXPlay(6);
                                work->state = 3;
                                work->angle = 0.0f;
                                HuSprColorSet(spr_grp, 0, 255, 112, 160);
                                HuSprColorSet(spr_grp, 1, 255, 112, 160);
                            }
                            else {
                                HuSprColorSet(spr_grp, 0, 112, 233, 255);
                                HuSprColorSet(spr_grp, 1, 112, 233, 255);
                            }
                        }
                    }
                }
                work->param[0] = 0;
                break;

            case 3:
                for (i = 0; i < 2; i++) {
                    HuSprAttrReset(spr_grp, i, HUSPR_ATTR_DISPOFF);
                }
                work->state = 3;
                work->param[0] = 0;
                break;

            default:
                work->param[0] = 0;
                break;
        }
    }
    if (work->state == 1) {
        return 1;
    }
    if (work->timer_val > 99) {
        digits[0] = digits[1] = 9;
    }
    else {
        s32 value;
        value = work->timer_val / 10;
        digits[1] = value;
        digits[0] = work->timer_val - (value * 10);
    }
    HuSprGrpPosSet(spr_grp, work->x, work->y);
    HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
    for (i = 0; i < 2; i++) {
        HuSprBankSet(spr_grp, i, digits[i]);
    }
    if (work->state != 0) {
        switch (work->state) {
            case 2: {
                float scale_x, scale_y;
                scale = fabs(((sin((work->angle * M_PI) / 180) * 5.0f) + 1.0f) - (sin((130 * M_PI) / 180) * 5.0f));
                scale_x = work->scale_x * scale;
                scale_y = work->scale_y * scale;
                work->angle += seqSpeed * 5.0f;
                if (work->angle > 130.0f) {
                    work->state = 0;
                    break;
                }
                HuSprGrpScaleSet(spr_grp, scale_x, scale_y);
            } break;

            case 3: {
                scale = sin((work->angle * M_PI) / 180) + 1.0;
                tp_lvl = 1.0 - (sin((work->angle * M_PI) / 180) * 0.5);
                work->angle += seqSpeed * 18.0f;
                if (work->angle > 180.0f) {
                    work->state = 0;
                    scale = 1.0f;
                    tp_lvl = 1.0f;
                }
                for (i = 0; i < 2; i++) {
                    HuSprScaleSet(spr_grp, i, scale, scale);
                    HuSprTPLvlSet(spr_grp, i, tp_lvl);
                }
            } break;

            case -1:
                HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
                for (i = 0; i < 2; i++) {
                    HuSprScaleSet(spr_grp, i, 1.0f, 1.0f);
                }
                work->angle += 1.0f;
                if (work->angle < 60.0f) {
                    break;
                }
                tp_lvl = 1.0 - ((work->angle - 60.0f) / 20.0f);
                if (tp_lvl <= 0.0f) {
                    tp_lvl = 0.0f;
                    work->state = 0;
                    work->stat |= 0x8;
                }

                for (i = 0; i < 4; i++) {
                    HuSprTPLvlSet(spr_grp, i, tp_lvl);
                }
                break;

            default:
                break;
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    else {
        return 1;
    }
}

s32 MGSeqInitType2(SeqWork *work, va_list params)
{
    s16 spr_idx;
    s16 spr_grp;
    AnimData *anim_tbl[6];
    s32 i;
    s16 len;
    char *str;
    char c;
    int time_max;
    int x, y;
    work->data = va_arg(params, void *);
    time_max = va_arg(params, int);
    x = va_arg(params, int);
    y = va_arg(params, int);
    if (time_max < 0) {
        time_max = -1;
    }
    work->time_max = time_max;
    if (x >= 0) {
        work->x = x;
    }
    if (y >= 0) {
        work->y = y;
    }
    work->state = 0;
    work->angle = 0.0f;
    x = 0;
    len = 0;
    str = work->data;
    while (c = *str++) {
        if (c >= '0' && c <= '9') {
            x |= 1;
            len++;
        }
        else if (c >= 'A' && c <= 'Z') {
            x |= 2;
            len++;
        }
        else if (c >= 'a' && c <= 'z') {
            x |= 4;
            len++;
        }
        else if (c == '!' || c == '?') {
            x |= 8;
            len++;
        }
    }
    work->word_len = len;
    for (i = 0; i < 6; i++) {
        if (x & (1 << i)) {
            anim_tbl[i] = HuSprAnimRead(SeqReadFile(seqType2SprTbl[i]));
        }
        else {
            anim_tbl[i] = NULL;
        }
    }
    work->spr_grp[0] = spr_grp = HuSprGrpCreate(len);
    x = 0;
    spr_idx = 0;
    str = work->data;
    while (c = *str++) {
        i = -2;
        if (c >= '0' && c <= '9') {
            c -= '0';
            i = 0;
        }
        else if (c >= 'A' && c <= 'Z') {
            c -= 'A';
            i = 1;
        }
        else if (c >= 'a' && c <= 'z') {
            c -= 'a';
            i = 2;
        }
        else if (c == '!' || c == '?') {
            if (c == '!') {
                c = 0;
            }
            else {
                c = 1;
            }
            i = 3;
        }
        else if (c == ' ') {
            i = -1;
        }
        work->alt_word_len = x;
        if (i == -1) {
            x += 32;
        }
        else if (i >= 0) {
            s16 sprite = HuSprCreate(anim_tbl[i], 5, c);
            HuSprGrpMemberSet(spr_grp, spr_idx, sprite);
            HuSprSpeedSet(spr_grp, spr_idx, 0.0f);
            HuSprPosSet(spr_grp, spr_idx, x, 0.0f);
            spr_idx++;
            x += 64;
        }
    }
    if (seqPauseF) {
        work->state = 1;
        for (i = 0; i < work->word_len; i++) {
            HuSprAttrSet(spr_grp, i, HUSPR_ATTR_DISPOFF);
        }
    }
    return 1;
}

s32 MGSeqUpdateType2(SeqWork *work)
{
    float tp_lvl;
    s16 spr_grp;
    spr_grp = work->spr_grp[0];
    HuSprGrpPosSet(spr_grp, work->x - ((0.5f * work->scale_x) * work->alt_word_len), work->y);
    HuSprGrpScaleSet(spr_grp, work->scale_x, work->scale_y);
    if (work->param[0] != 0 && work->state != -1) {
        switch (work->param[0]) {
            case 2:
                if (work->param[1] != -1) {
                    (void)work; // HACK: to introduce extra branch
                }
                else {
                    work->state = -1;
                    work->angle = 0.0f;
                }
                work->param[0] = 0;
                break;

            case 1:
                work->time_max = work->param[1];
                work->param[0] = 0;
                break;

            case 3: {
                s32 i;
                for (i = 0; i < work->word_len; i++) {
                    HuSprAttrReset(spr_grp, i, HUSPR_ATTR_DISPOFF);
                    (void)i;
                }
                work->state = 0;
                work->param[0] = 0;
            } break;

            default:
                work->param[0] = 0;
                break;
        }
    }
    if (work->state == 1) {
        return 1;
    }
    work->time += seqSpeed;
    if (work->time >= work->time_max && work->state != -1) {
        work->stat |= 0x4;
        work->state = -1;
        work->angle = 0.0f;
    }
    if (work->state != 0) {
        if (work->state != -1) {
            (void)work; // HACK: to introduce extra branch
        }
        else {
            s16 i;
            work->angle += seqSpeed * 0.1f;
            tp_lvl = 1.0f - work->angle;
            if (tp_lvl <= 0.0f) {
                tp_lvl = 0.0f;
                work->state = 0;
                work->stat |= 0x8;
            }
            for (i = 0; i < work->word_len; i++) {
                HuSprTPLvlSet(spr_grp, i, tp_lvl);
                (void)i;
            }
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    else {
        return 1;
    }
}

static char seqFontAlphaTbl[] = { "ABCDEFGH"
                                  "IJKLMNOP"
                                  "QRSTUVWX"
                                  "YZabcdef"
                                  "ghijklmn"
                                  "opqrstuv"
                                  "wxyz" };

static char seqFontKanaTbl[] = { "ｱｲｳｴｵｶｷｸ"
                                 "ｹｺｻｼｽｾｿﾀ"
                                 "ﾁﾂﾃﾄﾅﾆﾇﾈ"
                                 "ﾉﾊﾋﾌﾍﾎﾏﾐ"
                                 "ﾑﾒﾓﾔﾕﾖﾗﾘ"
                                 "ﾙﾚﾛﾜｦﾝｧｨ"
                                 "ｩｪｫｬｭｮｯｶ"
                                 "ｷｸｹｺｻｼｽｾ"
                                 "ｿﾀﾁﾂﾃﾄﾊﾋ"
                                 "ﾌﾍﾎﾊﾋﾌﾍﾎ"
                                 "ｰ" };

static char seqFontNumTbl[] = "0123456789";

static s32 *letterBufTbl[5] = {};

static char wordStartE[] = "START!";

static char seqPunctTbl[] = "!?";

static char wordStartJ[] = "ｽﾀｰﾄ!";

static char wordFinishJ[] = "ﾌｨﾆｯｼｭ!";

static char wordDrawJ[] = "ﾋｷﾜｹ!";

static char wordFinishE[] = "FINISH!";
static char wordDrawE[] = "DRAW!";

static char *wordMgTbl[6] = {
    wordStartJ,
    wordFinishJ,
    wordDrawJ,
    wordStartE,
    wordFinishE,
    wordDrawE,
};

void fn_80036BC8(void)
{
    if (!letterBufTbl[0]) {
        letterBufTbl[0] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32) * strlen(seqFontAlphaTbl));
        memset(letterBufTbl[0], 0, sizeof(s32) * strlen(seqFontAlphaTbl));
    }
    if (!letterBufTbl[1]) {
        letterBufTbl[1] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32) * strlen(seqFontKanaTbl));
        memset(letterBufTbl[1], 0, sizeof(s32) * strlen(seqFontKanaTbl));
    }
    if (!letterBufTbl[2]) {
        letterBufTbl[2] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32) * strlen(seqFontKanaTbl));
        memset(letterBufTbl[2], 0, sizeof(s32) * strlen(seqFontKanaTbl));
    }
    if (!letterBufTbl[3]) {
        letterBufTbl[3] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32) * strlen(seqFontNumTbl));
        memset(letterBufTbl[3], 0, sizeof(s32) * strlen(seqFontNumTbl));
    }
    if (!letterBufTbl[4]) {
        letterBufTbl[4] = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s32) * strlen(seqPunctTbl));
        memset(letterBufTbl[4], 0, sizeof(s32) * strlen(seqPunctTbl));
    }
}

static AnimData *SeqLoadFontChar(char *str, s16 flags);

static s32 SeqMakeWord(SeqWork *work, char *str, s16 flags)
{
    s16 len;
    s16 x;
    s16 i;
    s16 grp_idx;
#if VERSION_JPN
    char *str_ptr;
    AnimData **char_anim;
    s16 *char_pos;
#else
    AnimData **char_anim;
    s16 *char_pos;
    char *str_ptr;
#endif
    s16 spr_grp;
    for (grp_idx = 0; grp_idx < 16; grp_idx++) {
        if (work->spr_grp[grp_idx] == -1) {
            break;
        }
    }
    if (grp_idx == 16) {
        return -1;
    }
    char_anim = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(AnimData *) * 100);
    char_pos = HuMemDirectMalloc(HEAP_SYSTEM, sizeof(s16) * 100);
    str_ptr = str;
    x = 0;
    len = 0;
    while (*str_ptr != '\0') {
#if VERSION_JPN
        if (*str_ptr == ' ') {
            x += 56;
        }
        else {
            char_anim[len] = SeqLoadFontChar(str_ptr, flags);
            if (char_anim[len]) {
                char_pos[len] = x;
                x += 56;
                len++;
            }
        }
#else
        char_anim[len] = SeqLoadFontChar(str_ptr, flags);
        if (char_anim[len]) {
            char_pos[len] = x;
            x += 56;
            len++;
        }
#endif
        str_ptr++;
    }
    work->spr_grp[grp_idx] = spr_grp = HuSprGrpCreate(len);
    x = (x / 2) - 28;
    for (i = 0; i < len; i++) {
        s16 sprite = HuSprCreate(char_anim[i], 5, 0);
        HuSprGrpMemberSet(spr_grp, i, sprite);
        HuSprPosSet(spr_grp, i, char_pos[i] - x, 0.0f);
    }
    work->word_len = len;
    HuMemDirectFree(char_anim);
    HuMemDirectFree(char_pos);
    return grp_idx;
}

static AnimData *SeqLoadFontChar(char *str, s16 flags)
{
    s32 data_num;
    s16 id;
    char *list;
    char c = *str;
    if (c == 222 || c == 223) {
        return NULL;
    }
#if !VERSION_JPN
    if (c == 32) {
        return HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 10)));
    }
#endif
    for (id = 0, list = seqFontAlphaTbl; *list != 0; id++, list++) {
        if (*list == c) {
            data_num = DATA_MAKE_NUM(DATADIR_GAMEMES, id + (VERSION_JPN ? 20 : 21));
            return HuSprAnimRead(SeqReadFile(data_num));
        }
    }
    for (id = 0, list = seqFontNumTbl; *list != 0; id++, list++) {
        if (*list == c) {
            data_num = DATA_MAKE_NUM(DATADIR_GAMEMES, id + (VERSION_JPN ? 10 : 11));
            return HuSprAnimRead(SeqReadFile(data_num));
        }
    }
    for (id = 0, list = seqPunctTbl; *list != 0; id++, list++) {
        if (*list == c) {
            data_num = DATA_MAKE_NUM(DATADIR_GAMEMES, id + (VERSION_JPN ? 153 : 154));
            return HuSprAnimRead(SeqReadFile(data_num));
        }
    }
    if (str[1] == 222) { // ゛
        list = seqFontKanaTbl;
        list += 55;
        id = 55;
    }
    else if (str[1] == 223) { // ゜
        list = seqFontKanaTbl;
        list += 75;
        id = 75;
    }
    else {
        list = seqFontKanaTbl;
        id = 0;
    }
    while (*list != 0) {
        if (*list == c) {
            if (flags & 0x1) {
                data_num = DATA_MAKE_NUM(DATADIR_GAMEMES, id + (VERSION_JPN ? 155 : 156));
            }
            else {
                data_num = DATA_MAKE_NUM(DATADIR_GAMEMES, id + (VERSION_JPN ? 72 : 73));
            }
            return HuSprAnimRead(SeqReadFile(data_num));
        }
        id++;
        list++;
    }
    return NULL;
}

static float ForceDefine480()
{
    return 480.0f;
}

static void SeqPlayStartFX(void);

s32 MGSeqInitMGBasic(SeqWork *work, va_list params)
{
    s16 i;
    s16 word_grp;

    work->state = va_arg(params, int);
    if (work->state == 2) {
        return MGSeqInitDraw(work, params);
    }
    work->type = 0;
    work->angle = 0;

    {
        s32 word_katakana;
        s32 word_flag;
        s32 word_ofs;
        word_katakana = 0;
        if (work->state == 2 && seqLanguage == 0) {
            word_katakana = 1;
        }
        if (word_katakana) {
            word_flag = 1;
        }
        else {
            word_flag = 0;
        }
        if (seqLanguage == 0) {
            word_ofs = 0;
        }
        else {
            word_ofs = 3;
        }
        word_grp = SeqMakeWord(work, wordMgTbl[work->state + word_ofs], word_flag);
    }
    HuSprGrpPosSet(work->spr_grp[word_grp], 0.0f, 0.0f);

    for (i = 0; i < work->word_len; i++) {
        HuSprTPLvlSet(work->spr_grp[word_grp], i, 1.0f);
        HuSprPosSet(work->spr_grp[word_grp], i, -100.0f, HU_DISP_CENTERY);
    }
    if (seqPauseF) {
        work->type = 2;
        HuSprAttrSet(word_grp, 0, HUSPR_ATTR_DISPOFF);
    }
    else {
        work->param[0] = 3;
    }
    return 1;
}

s32 MGSeqUpdateMGBasic(SeqWork *work)
{
    s16 idx;
    float scale;
    if (work->param[0] != 0 && work->type != -1) {
        switch (work->param[0]) {
            case 2:
                if (work->param[1] != -1) {
                    (void)work; // HACK: to introduce extra branch
                }
                else {
                    work->type = -1;
                    work->angle = 0.0f;
                }
                work->param[0] = 0;
                break;

            case 1:
                work->time_max = work->param[1];
                work->param[0] = 0;
                break;

            case 3:
                work->type = 1;
                work->param[0] = 0;
                break;

            default:
                work->param[0] = 0;
                break;
        }
    }
    if (work->type == 2) {
        return 1;
    }
    work->time += seqSpeed;
    if (work->time >= work->time_max && work->type != -1) {
        work->type = -1;
        work->angle = 0.0f;
    }
    if (work->type) {
        switch (work->type) {
            case 1: {
                float pos_x;
                float time;
                s16 i;
                if (work->state == 0) {
                    if (work->time <= 40) {
                        for (i = 0; i < work->word_len; i++) {
                            time = work->time - ((20 / work->word_len) * (work->word_len - i - 1));
                            if (time < 0 || time > 20.0f) {
                                continue;
                            }
                            pos_x = (work->x - (0.5f * (work->word_len * 56))) + 28.0f + (i * 56);
                            if (time == 20.0f) {
                                HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
                                HuSprZRotSet(work->spr_grp[0], i, 0.0f);
                            }
                            else {
                                HuSprPosSet(work->spr_grp[0], i, pos_x - (((1.0 - sin(((time * 4.5f) * M_PI) / 180.0)) * (work->word_len * 56 * 2))),
                                    work->y);
                                HuSprZRotSet(work->spr_grp[0], i, (time / 20.0f) * 390.0f);
                            }
                        }
                    }
                    else {
                        time = work->time - 40;
                        scale = work->scale_x + (0.5 * sin(((time * 9.0f) * M_PI) / 180.0));
                        for (i = 0; i < work->word_len; i++) {
                            pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 56))))) + (scale * (i * 56));
                            HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
                            HuSprScaleSet(work->spr_grp[0], i, scale, work->scale_y + sin(((time * 9.0f) * M_PI) / 180.0));
                        }
                    }
                    if (work->time == 40) {
                        idx = HuAudFXPlay(36);
                        work->stat |= 0x10;
                    }
                    if (work->time == 60) {
                        SeqPlayStartFX();
                        work->stat |= 0x4;
                    }
                    if (work->time >= 60) {
                        work->type = 0;
                    }
                }
                else {
                    if (work->time == 1) {
                        if (work->state == 1) {
                            HuAudFXPlay(37);
                        }
                        else {
                            HuAudFXPlay(40);
                        }
                        MGSeqPauseEnableCtrl(0);
                        work->stat |= 0x10;
                    }
                    if (work->time <= 20) {
                        time = work->time;
                        scale = work->scale_x + (0.5 * sin(((time * 9.0f) * M_PI) / 180.0));
                        for (i = 0; i < work->word_len; i++) {
                            HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
                            pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 56))))) + (scale * (i * 56));
                            HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
                            HuSprScaleSet(work->spr_grp[0], i, work->scale_x + sin(((time * 9.0f) * M_PI) / 180.0),
                                work->scale_y + sin(((time * 9.0f) * M_PI) / 180.0));
                        }
                        if (time == 20.0f) {
                            for (i = 0; i < work->word_len; i++) {
                                HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
                            }
                        }
                    }
                    else {
                        if (work->time > 80) {
                            for (i = 0; i < work->word_len; i++) {
                                time = (work->time - 80) - ((20 / work->word_len) * (work->word_len - i - 1));
                                if (time < 0.0f || time > 20.0f) {
                                    continue;
                                }
                                pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (i * 56);
                                if (time == 20.0f) {
                                    HuSprAttrSet(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
                                }
                                else {
                                    HuSprPosSet(work->spr_grp[0], i,
                                        pos_x + ((1.0 - cos(((time * 4.5f) * M_PI) / 180.0f)) * (work->word_len * 56 * 2)), work->y);
                                    HuSprZRotSet(work->spr_grp[0], i, (time / 20.0f) * 390.0f);
                                }
                            }
                        }
                    }
                    if (work->time == 110) {
                        work->stat |= 0x4;
                    }
                    if (work->time >= 110) {
                        work->type = 0;
                        work->stat |= 8;
                    }
                }
            } break;

            case -1: {
                work->angle += seqSpeed * 0.1f;
                scale = 1.0f - work->angle;
                if (scale <= 0.0f) {
                    scale = 0.0f;
                    work->type = 0;
                    work->stat |= 0x8;
                    if (work->state == 0) {
                        MGSeqPauseEnableCtrl(1);
                    }
                }
                for (idx = 0; idx < work->word_len; idx++) {
                    HuSprTPLvlSet(work->spr_grp[0], idx, scale);
                }
            } break;

            default:
                break;
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    return 1;
}

s32 MGSeqInitMGCommon(SeqWork *work, va_list params)
{
    s16 i;
    float tp_lvl;
    s16 j;
    s16 word_grp;

    work->state = va_arg(params, int);
    if (work->state == 2) {
        return MGSeqInitDraw(work, params);
    }
    work->type = 0;
    work->angle = 0;
    tp_lvl = 1.0f;
    for (i = 0; i < 4; i++) {
        if (i == 0) {
            s32 word_katakana;
            s32 word_flag;
            s32 word_ofs;
            word_katakana = 0;
            if (work->state == 2 && seqLanguage == 0) {
                word_katakana = 1;
            }
            if (word_katakana) {
                word_flag = 1;
            }
            else {
                word_flag = 0;
            }
            if (seqLanguage == 0) {
                word_ofs = 0;
            }
            else {
                word_ofs = 3;
            }
            word_grp = SeqMakeWord(work, wordMgTbl[work->state + word_ofs], word_flag);
        }
        else {
            s16 grp_idx;
            s32 new_grp;
            for (grp_idx = 0; grp_idx < 16; grp_idx++) {
                if (work->spr_grp[grp_idx] == -1) {
                    break;
                }
            }
            if (grp_idx == 16) {
                new_grp = -1;
            }
            else {
                work->spr_grp[grp_idx] = HuSprGrpCopy(work->spr_grp[word_grp]);
                new_grp = grp_idx;
            }
            (void)new_grp;
            word_grp = new_grp;
        }
        HuSprGrpPosSet(work->spr_grp[word_grp], 0.0f, 0.0f);
        for (j = 0; j < work->word_len; j++) {
            HuSprTPLvlSet(work->spr_grp[word_grp], j, tp_lvl);
            HuSprPosSet(work->spr_grp[word_grp], j, -100.0f, HU_DISP_CENTERY);
            HuSprPriSet(work->spr_grp[word_grp], j, i + 5);
            HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
        }
        if (i == 0) {
            tp_lvl -= 0.5;
        }
        else {
            tp_lvl -= 0.1f;
        }
    }
    if (seqPauseF) {
        work->type = 2;
        HuSprAttrSet(word_grp, 0, HUSPR_ATTR_DISPOFF);
    }
    else {
        work->param[0] = 3;
    }
    return 1;
}

s32 MGSeqUpdateMGBattle(SeqWork *work)
{
    s16 idx;
    float scale;
    if (work->param[0] != 0 && work->type != -1) {
        switch (work->param[0]) {
            case 2:
                if (work->param[1] != -1) {
                    (void)work; // HACK: to introduce extra branch
                }
                else {
                    work->type = -1;
                    work->angle = 0.0f;
                }
                work->param[0] = 0;
                break;

            case 1:
                work->time_max = work->param[1];
                work->param[0] = 0;
                break;

            case 3:
                work->type = 1;
                work->param[0] = 0;
                break;

            default:
                work->param[0] = 0;
                break;
        }
    }
    if (work->type == 2) {
        return 1;
    }
    work->time += seqSpeed;
    if (work->time >= work->time_max && work->type != -1) {
        work->stat |= 0x4;
        work->type = -1;
        work->angle = 0.0f;
    }
    if (work->type) {
        switch (work->type) {
            case 1: {
                s16 i, j;
                float time;
                float pos_x;
                if (work->state == 0) {
                    if (work->time < 45) {
                        if (work->time > 10 && work->time <= 40) {
                            time = work->time - 10;
                            scale = 10.0f * (1.0f - (time / 30.0f));
                            pos_x = (work->x - (0.5f * (work->word_len * 56))) + 28.0f;
                            HuSprPosSet(work->spr_grp[0], 0, pos_x, work->y);
                            HuSprScaleSet(work->spr_grp[0], 0, work->scale_x + scale, work->scale_y + scale);
                            scale = time / 30.0f;
                            HuSprTPLvlSet(work->spr_grp[0], 0, scale);
                        }
                        for (i = 0; i < 4; i++) {
                            time = work->time - i;
                            if (time < 0 || time > 40) {
                                continue;
                            }
                            for (j = 1; j < work->word_len; j++) {
                                pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (j * 56);
                                if (time == 40.0f) {
                                    HuSprPosSet(work->spr_grp[i], j, pos_x, work->y);
                                    HuSprZRotSet(work->spr_grp[i], j, 0.0f);
                                    HuSprScaleSet(work->spr_grp[i], j, work->scale_x, work->scale_y);
                                    if (i != 0) {
                                        HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
                                    }
                                }
                                else {
                                    s16 discard_cnt;
                                    static float letterOfs[] = { 30, 20, 20, 3, -4, 20, -30, 20, 20, 20, -30, 20, -10, 40, 10, -40 };
                                    float x, y;
                                    float ofs_x, ofs_y;
                                    float zrot, scale_ang;
                                    x = pos_x;
                                    y = work->y;
                                    ofs_x = letterOfs[((j - 1) & 0x7) * 2];
                                    ofs_y = letterOfs[(((j - 1) & 0x7) * 2) + 1];
                                    zrot = 0.0f;
                                    discard_cnt = 0;
                                    scale_ang = 0.0f;
                                    for (idx = 0; idx < 40.0f - time; idx++) {
                                        if (x + ofs_x > HU_DISP_WIDTH || x + ofs_x < 0) {
                                            ofs_x = -ofs_x;
                                            discard_cnt++;
                                        }
                                        if (y + ofs_y > HU_DISP_HEIGHT || y + ofs_y < 0) {
                                            ofs_y = -ofs_y;
                                            discard_cnt++;
                                        }
                                        if (discard_cnt) {
                                            zrot += 20.0f;
                                            scale_ang = 0.0f;
                                        }
                                        x += ofs_x;
                                        y += ofs_y;
                                    }
                                    HuSprPosSet(work->spr_grp[i], j, x, y);
                                    HuSprScaleSet(work->spr_grp[i], j, work->scale_x * cos((M_PI * scale_ang) / 180.0), work->scale_y);
                                    HuSprZRotSet(work->spr_grp[i], j, zrot);
                                }
                            }
                        }
                    }
                    else {
                        if (work->time > 60) {
                            time = work->time - 60;
                            scale = 0.5 * sin((M_PI * (time * 9.0f)) / 180.0);
                            for (j = 0; j < work->word_len; j++) {
                                pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
                                    + ((j * 56) * (scale + work->scale_x));
                                HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
                                HuSprScaleSet(work->spr_grp[0], j, work->scale_x + scale, work->scale_y + scale);
                            }
                        }
                    }
                    if (work->time == 60) {
                        HuAudFXPlay(36);
                        work->stat |= 0x10;
                    }
                    if (work->time == 80) {
                        work->stat |= 0x4;
                        SeqPlayStartFX();
                    }
                    if (work->time >= 80) {
                        work->type = 0;
                    }
                }
                else {
                    if (work->time == 1) {
                        if (work->state == 1) {
                            HuAudFXPlay(37);
                        }
                        else {
                            HuAudFXPlay(40);
                        }
                        MGSeqPauseEnableCtrl(0);
                        work->stat |= 0x10;
                    }
                    if (work->time <= 20) {
                        for (i = 1; i < 4; i++) {
                            for (j = 0; j < work->word_len; j++) {
                                HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
                            }
                        }
                        time = work->time;
                        scale = work->scale_x + (0.5 * sin((M_PI * (time * 9.0f)) / 180.0));
                        for (j = 0; j < work->word_len; j++) {
                            HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
                            pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 56))))) + (scale * (j * 56));
                            HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
                            HuSprScaleSet(work->spr_grp[0], j, work->scale_x + (sin((M_PI * (time * 9.0f)) / 180.0)),
                                work->scale_y + (sin((M_PI * (time * 9.0f)) / 180.0)));
                        }
                        if (time == 20.0f) {
                            for (j = 0; j < work->word_len; j++) {
                                HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
                            }
                        }
                    }
                    else {
                        if (work->time > 80 && work->time <= 95) {
                            time = work->time - 80;
                            for (j = 0; j < work->word_len; j++) {
                                pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (j * 56);
                                HuSprPosSet(
                                    work->spr_grp[0], j, pos_x + ((HU_DISP_CENTERX - pos_x) * (1.0 - cos((M_PI * (time * 6.0)) / 180.0))), work->y);
                            }
                            if (time == 15.0f) {
                                for (j = 0; j < work->word_len; j++) {
                                    HuSprAttrReset(work->spr_grp[1], j, HUSPR_ATTR_DISPOFF);
                                    HuSprPosSet(work->spr_grp[1], j, HU_DISP_CENTERX, work->y);
                                    HuSprTPLvlSet(work->spr_grp[1], j, 1.0f);
                                }
                            }
                        }
                        else {
                            if (work->time > 105) {
                                for (j = 0; j < work->word_len; j++) {
                                    time = work->time - 105;
                                    time -= j * 3;
                                    if (time < 0) {
                                        continue;
                                    }
                                    scale = 1.0f - (time / 15.0f);
                                    if (scale < 0.0f) {
                                        scale = 0.0f;
                                    }
                                    HuSprPosSet(work->spr_grp[0], j, HU_DISP_CENTERX, work->y + ((-100.0f - work->y) * (time / 20.0f)));
                                    HuSprTPLvlSet(work->spr_grp[0], j, scale);
                                    HuSprPosSet(work->spr_grp[1], j, HU_DISP_CENTERX, work->y + ((580.0f - work->y) * (time / 20.0f)));
                                    HuSprTPLvlSet(work->spr_grp[1], j, scale);
                                }
                            }
                        }
                    }
                    if (work->time == 130) {
                        work->stat |= 0x4;
                    }
                    if (work->time >= 130) {
                        work->type = 0;
                        work->stat |= 0x8;
                    }
                }

            } break;

            case -1: {
                work->angle += seqSpeed * 0.1f;
                scale = 1.0f - work->angle;
                if (scale <= 0.0f) {
                    scale = 0.0f;
                    work->type = 0;
                    work->stat |= 0x8;
                    if (work->state == 0) {
                        MGSeqPauseEnableCtrl(1);
                    }
                }
                for (idx = 0; idx < work->word_len; idx++) {
                    HuSprTPLvlSet(work->spr_grp[0], idx, scale);
                }
            } break;

            default:
                break;
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    return 1;
}

s32 MGSeqUpdateMG1vs3(SeqWork *work)
{
    s16 idx;
    float scale;
    if (work->param[0] != 0 && work->type != -1) {
        switch (work->param[0]) {
            case 2:
                if (work->param[1] != -1) {
                    (void)work; // HACK: to introduce extra branch
                }
                else {
                    work->type = -1;
                    work->angle = 0.0f;
                }
                work->param[0] = 0;
                break;

            case 1:
                work->time_max = work->param[1];
                work->param[0] = 0;
                break;

            case 3:
                work->type = 1;
                work->param[0] = 0;
                break;

            default:
                work->param[0] = 0;
                break;
        }
    }
    if (work->type == 2) {
        return 1;
    }
    work->time += seqSpeed;
    if (work->time >= work->time_max && work->type != -1) {
        work->stat |= 0x4;
        work->type = -1;
        work->angle = 0.0f;
    }
    if (work->type) {
        switch (work->type) {
            case 1: {
                float time;
                float scale_x, scale_y;
                float pos_x, pos_y;
                s16 i;
                s16 j;
                if (work->state == 0) {
                    if (work->time <= 10) {
                        scale = work->time / 10.0f;
                        time = work->time;
                        for (idx = 0; idx < work->word_len; idx++) {
                            scale_x = 0.3 * work->scale_x;
                            scale_y = 0.3 * work->scale_y;
                            pos_x = ((28.0f * scale_x) + (work->x - (0.5f * (scale_x * (work->word_len * 56))))) + (scale_x * (idx * 56));
                            pos_y = work->y - (150.0 * sin((M_PI * (((16.0f / 3.0f) * time) + 20.0f)) / 180.0));
                            HuSprPosSet(work->spr_grp[0], idx, pos_x, pos_y);
                            HuSprScaleSet(work->spr_grp[0], idx, scale_x, scale_y * cos(M_PI * (12.0f * time) / 180.0));
                            HuSprTPLvlSet(work->spr_grp[0], idx, scale);
                        }
                    }
                    else {
                        if (work->time <= 60) {
                            for (i = 0; i < 4; i++) {
                                for (idx = 0; idx < work->word_len; idx++) {
                                    time = (work->time - 10) - (idx * 3) - i;
                                    if (time < 0.0f) {
                                        time = 0.0f;
                                    }
                                    else {
                                        if (time > 30.0f) {
                                            continue;
                                        }
                                    }
                                    scale = 0.3 + (0.7 * (1.0 - cos((M_PI * (time * 3.0f)) / 180.0)));
                                    scale_x = work->scale_x * scale;
                                    scale_y = work->scale_y * scale;
                                    pos_x = ((28.0f * scale_x) + (work->x - (0.5f * (scale_x * (work->word_len * 56))))) + (scale_x * (idx * 56));
                                    pos_y = work->y - (150.0 * sin((M_PI * (((16.0f / 3.0f) * time) + 20.0f)) / 180.0));
                                    HuSprPosSet(work->spr_grp[i], idx, pos_x, pos_y);
                                    HuSprScaleSet(work->spr_grp[i], idx, scale_x, scale_y * cos(M_PI * (12.0f * time) / 180.0));
                                }
                            }
                            if (work->time == 60) {
                                for (i = 1; i < 4; i++) {
                                    for (j = 0; j < work->word_len; j++) {
                                        HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
                                    }
                                }
                            }
                        }
                        else {
                            if (work->time > 70) {
                                time = work->time - 70;
                                scale = 0.5 * sin((M_PI * (time * 9.0f)) / 180.0);
                                for (j = 0; j < work->word_len; j++) {
                                    pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
                                        + ((j * 56) * (scale + work->scale_x));
                                    HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
                                    HuSprScaleSet(work->spr_grp[0], j, work->scale_x + scale, work->scale_y + scale);
                                }
                            }
                        }
                    }
                    if (work->time == 70) {
                        HuAudFXPlay(36);
                        work->stat |= 0x10;
                    }
                    if (work->time == 90) {
                        work->stat |= 0x4;
                        SeqPlayStartFX();
                    }
                    if (work->time >= 90) {
                        work->type = 0;
                    }
                }
                else {
                    if (work->time == 1) {
                        if (work->state == 1) {
                            HuAudFXPlay(37);
                        }
                        else {
                            HuAudFXPlay(40);
                        }
                        MGSeqPauseEnableCtrl(0);
                        work->stat |= 0x10;
                    }
                    if (work->time <= 20) {
                        for (i = 1; i < 4; i++) {
                            for (j = 0; j < work->word_len; j++) {
                                HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
                            }
                        }
                        time = work->time;
                        scale = work->scale_x + (0.5 * sin((M_PI * (time * 9.0f)) / 180.0));
                        for (j = 0; j < work->word_len; j++) {
                            HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
                            pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 56))))) + (scale * (j * 56));
                            HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
                            HuSprScaleSet(work->spr_grp[0], j, work->scale_x + (sin((M_PI * (time * 9.0f)) / 180.0)),
                                work->scale_y + (sin((M_PI * (time * 9.0f)) / 180.0)));
                        }
                        if (time == 20.0f) {
                            for (i = 1; i < 4; i++) {
                                for (j = 0; j < work->word_len; j++) {
                                    HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
                                }
                            }
                        }
                    }
                    else {
                        if (work->time > 80 || work->time < 140) {
                            for (i = 0; i < 4; i++) {
                                for (j = 0; j < work->word_len; j++) {
                                    time = (work->time - 80) - i - j;
                                    if (time < 0 || time > 40) {
                                        continue;
                                    }
                                    if (time <= 20) {
                                        float pos_base = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (j * 56);
                                        pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + ((work->word_len - j - 1) * 56);
                                        HuSprPosSet(work->spr_grp[i], j, pos_base + ((time / 20.0f) * (pos_x - pos_base)),
                                            work->y + (((HU_DISP_HEIGHT - 40) - work->y) * (time / 20.0f)));
                                    }
                                    else {
                                        time -= 20.0f;
                                        pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + ((work->word_len - j - 1) * 56);
                                        pos_y = HU_DISP_HEIGHT - 40;
                                        HuSprPosSet(work->spr_grp[i], j, pos_x, pos_y + ((-40.0f - pos_y) * (time / 20.0f)));
                                    }
                                }
                            }
                        }
                    }
                    if (work->time == 140) {
                        work->stat |= 0x4;
                    }
                    if (work->time >= 140) {
                        work->type = 0;
                        work->stat |= 0x8;
                    }
                }
            } break;

            case -1: {
                work->angle += seqSpeed * 0.1f;
                scale = 1.0f - work->angle;
                if (scale <= 0.0f) {
                    scale = 0.0f;
                    work->type = 0;
                    work->stat |= 0x8;
                    if (work->state == 0) {
                        MGSeqPauseEnableCtrl(1);
                    }
                }
                for (idx = 0; idx < work->word_len; idx++) {
                    HuSprTPLvlSet(work->spr_grp[0], idx, scale);
                }
            } break;

            default:
                break;
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    return 1;
}

s32 MGSeqUpdateMGStory(SeqWork *work)
{
    s16 idx;
    float scale;
    if (work->param[0] != 0 && work->type != -1) {
        switch (work->param[0]) {
            case 2:
                if (work->param[1] != -1) {
                    (void)work; // HACK: to introduce extra branch
                }
                else {
                    work->type = -1;
                    work->angle = 0.0f;
                }
                work->param[0] = 0;
                break;

            case 1:
                work->time_max = work->param[1];
                work->param[0] = 0;
                break;

            case 3:
                work->type = 1;
                work->param[0] = 0;
                break;

            default:
                work->param[0] = 0;
                break;
        }
    }
    if (work->type == 2) {
        return 1;
    }
    work->time += seqSpeed;
    if (work->time >= work->time_max && work->type != -1) {
        work->stat |= 0x4;
        work->type = -1;
        work->angle = 0.0f;
    }
    if (work->type) {
        switch (work->type) {
            case 1: {
                float pos_x, pos_y;
                float time;
                s16 i;
                s16 j;
                if (work->state == 0) {
                    if (work->time <= 30) {
                        for (idx = 0; idx < work->word_len; idx++) {
                            time = (work->time - (idx * 2));
                            if (time < 0.0f || time > 15.0f) {
                                continue;
                            }
                            pos_x = -50.0f;
                            HuSprPosSet(work->spr_grp[0], idx, pos_x + ((HU_DISP_CENTERX - pos_x) * (time / 15.0f)), work->y);
                            HuSprTPLvlSet(work->spr_grp[0], idx, 1.0f);
                            HuSprZRotSet(work->spr_grp[0], idx, (1.0 - (time / 15.0f)) * 180.0);
                            pos_x = HU_DISP_WIDTH + 50;
                            HuSprPosSet(work->spr_grp[1], idx, pos_x + ((HU_DISP_CENTERX - pos_x) * (time / 15.0f)), work->y);
                            HuSprTPLvlSet(work->spr_grp[1], idx, 1.0f);
                            HuSprZRotSet(work->spr_grp[1], idx, (1.0 - (time / 15.0f)) * -180.0);
                        }
                        if (work->time == 30) {
                            for (j = 0; j < work->word_len; j++) {
                                HuSprAttrSet(work->spr_grp[1], j, HUSPR_ATTR_DISPOFF);
                            }
                        }
                    }
                    else {
                        if (work->time > 35 && work->time <= 45) {
                            time = work->time - 35;
                            for (idx = 0; idx < work->word_len; idx++) {
                                pos_x = (work->x - (0.5f * (work->word_len * 56))) + 28.0f + (idx * 56);
                                HuSprPosSet(work->spr_grp[0], idx, HU_DISP_CENTERX + ((pos_x - HU_DISP_CENTERX) * (time / 10.0f)), work->y);
                            }
                        }
                        else {
                            if (work->time > 55) {
                                time = work->time - 55;
                                scale = 0.5 * sin(M_PI * (9.0f * time) / 180.0);
                                for (j = 0; j < work->word_len; j++) {
                                    pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
                                        + ((j * 56) * (scale + work->scale_x));
                                    HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
                                    HuSprScaleSet(work->spr_grp[0], j, work->scale_x + scale, work->scale_y + scale);
                                }
                            }
                        }
                    }
                    if (work->time == 55) {
                        HuAudFXPlay(36);
                        work->stat |= 0x10;
                    }
                    if (work->time == 75) {
                        SeqPlayStartFX();
                        work->stat |= 0x4;
                    }
                    if (work->time >= 75) {
                        work->type = 0;
                    }
                }
                else {
                    if (work->time == 1) {
                        if (work->state == 1) {
                            HuAudFXPlay(37);
                        }
                        else {
                            HuAudFXPlay(40);
                        }
                        MGSeqPauseEnableCtrl(0);
                        work->stat |= 0x10;
                    }
                    if (work->time <= 20) {
                        for (i = 1; i < 4; i++) {
                            for (j = 0; j < work->word_len; j++) {
                                HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
                            }
                        }
                        time = work->time;
                        scale = work->scale_x + (0.5 * sin((M_PI * (time * 9.0f)) / 180.0));
                        for (j = 0; j < work->word_len; j++) {
                            HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
                            pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 56))))) + (scale * (j * 56));
                            HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
                            HuSprScaleSet(work->spr_grp[0], j, work->scale_x + (sin((M_PI * (time * 9.0f)) / 180.0)),
                                work->scale_y + (sin((M_PI * (time * 9.0f)) / 180.0)));
                        }
                        if (time == 20.0f) {
                            for (i = 1; i < 4; i++) {
                                for (j = 0; j < work->word_len; j++) {
                                    HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
                                }
                            }
                        }
                    }
                    else if (work->time > 80 && work->time < 160) {
                        for (i = 0; i < 4; i++) {
                            for (j = 0; j < work->word_len; j++) {
                                s16 initF;
                                float dx, dy;
                                time = (work->time - 80) - i;
                                if (time < 0 || time > 60) {
                                    continue;
                                }
                                pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (j * 56);
                                dx = 28.0f + (work->x - (0.5f * (work->word_len * 56)));
                                pos_y = work->y;
                                for (idx = initF = 0; idx < time; idx++) {
                                    if (!initF) {
                                        pos_x -= 20.0f;
                                        if (pos_x <= dx) {
                                            pos_x = 28.0f + (work->x - (0.5f * (work->word_len * 56)));
                                            initF = 1;
                                            dy = 25.0f;
                                            dx = 10.0f;
                                        }
                                    }
                                    else {
                                        pos_x += dx;
                                        pos_y += dy;
                                        dx += 0.1;
                                        dy -= 2.0f;
                                        if (pos_y < 0.0f) {
                                            break;
                                        }
                                    }
                                }

                                HuSprPosSet(work->spr_grp[i], j, pos_x, pos_y);
                            }
                        }
                    }
                    if (work->time == 160) {
                        work->stat |= 0x4;
                    }
                    if (work->time >= 160) {
                        work->type = 0;
                        work->stat |= 0x8;
                    }
                }
            } break;

            case -1: {
                work->angle += seqSpeed * 0.1f;
                scale = 1.0f - work->angle;
                if (scale <= 0.0f) {
                    scale = 0.0f;
                    work->type = 0;
                    work->stat |= 0x8;
                    if (work->state == 0) {
                        MGSeqPauseEnableCtrl(1);
                    }
                }
                for (idx = 0; idx < work->word_len; idx++) {
                    HuSprTPLvlSet(work->spr_grp[0], idx, scale);
                }
            } break;

            default:
                break;
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    return 1;
}

s32 MGSeqUpdateMG2vs2(SeqWork *work)
{
    s16 idx;
    float scale;
    if (work->param[0] != 0 && work->type != -1) {
        switch (work->param[0]) {
            case 2:
                if (work->param[1] != -1) {
                    (void)work; // HACK: to introduce extra branch
                }
                else {
                    work->type = -1;
                    work->angle = 0.0f;
                }
                work->param[0] = 0;
                break;

            case 1:
                work->time_max = work->param[1];
                work->param[0] = 0;
                break;

            case 3:
                work->type = 1;
                work->param[0] = 0;
                break;

            default:
                work->param[0] = 0;
                break;
        }
    }
    if (work->type == 2) {
        return 1;
    }
    work->time += seqSpeed;
    if (work->time >= work->time_max && work->type != -1) {
        work->stat |= 0x4;
        work->type = -1;
        work->angle = 0.0f;
    }
    if (work->type) {
        switch (work->type) {
            case 1: {
                static s16 letterOfs[] = { -10, -50, 0, -30, 5, -60, -10, 60, 8, -40, 5, 50, -10, 20 };

                float pos_x;
                float time;
                s16 i;
                s16 j;
                if (work->state == 0) {
                    if (work->time <= 30) {
                        time = work->time;
                        for (idx = 0; idx < work->word_len; idx++) {
                            pos_x = (28.0f + (work->x - (0.5f * (work->scale_x * (work->word_len * 56))))) + (idx * 56);
                            HuSprPosSet(work->spr_grp[0], idx, pos_x + ((1.0f - (time / 30.0f)) * letterOfs[(idx * 2)]),
                                work->y + ((1.0f - (time / 30.0f)) * letterOfs[(idx * 2) + 1]));
                            HuSprTPLvlSet(work->spr_grp[0], idx, time / 30.0f);
                        }
                    }
                    else {
                        if (work->time > 40 && work->time <= 60) {
                            time = work->time - 40;
                            scale = 0.5 * sin(((time * 9.0f) * M_PI) / 180.0);
                            for (j = 0; j < work->word_len; j++) {
                                pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
                                    + ((j * 56) * (scale + work->scale_x));
                                HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
                                HuSprScaleSet(work->spr_grp[0], j, work->scale_x + scale, work->scale_y + scale);
                            }
                        }
                    }
                    if (work->time == 40) {
                        HuAudFXPlay(36);
                        work->stat |= 0x10;
                    }
                    if (work->time == 60) {
                        work->stat |= 0x4;
                        SeqPlayStartFX();
                    }
                    if (work->time >= 60) {
                        work->type = 0;
                    }
                }
                else {
                    if (work->time == 1) {
                        if (work->state == 1) {
                            HuAudFXPlay(37);
                        }
                        else {
                            HuAudFXPlay(40);
                        }
                        MGSeqPauseEnableCtrl(0);
                        work->stat |= 0x10;
                    }
                    if (work->time <= 20) {
                        for (i = 1; i < 4; i++) {
                            for (j = 0; j < work->word_len; j++) {
                                HuSprAttrSet(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
                            }
                        }
                        time = work->time;
                        scale = work->scale_x + (0.5 * sin((M_PI * (time * 9.0f)) / 180.0));
                        for (j = 0; j < work->word_len; j++) {
                            HuSprAttrReset(work->spr_grp[0], j, HUSPR_ATTR_DISPOFF);
                            pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 56))))) + (scale * (j * 56));
                            HuSprPosSet(work->spr_grp[0], j, pos_x, work->y);
                            HuSprScaleSet(work->spr_grp[0], j, work->scale_x + (sin((M_PI * (time * 9.0f)) / 180.0)),
                                work->scale_y + (sin((M_PI * (time * 9.0f)) / 180.0)));
                        }
                        if (time == 20.0f) {
                            for (i = 1; i < 4; i++) {
                                for (j = 0; j < work->word_len; j++) {
                                    HuSprAttrReset(work->spr_grp[i], j, HUSPR_ATTR_DISPOFF);
                                }
                            }
                        }
                    }
                    else {
                        if (work->time > 80 && work->time < 140) {
                            time = work->time - 80;
                            for (idx = 0; idx < work->word_len; idx++) {
                                float radius = (idx * 56) - (((work->word_len - 1) * 56) / 2);
                                float angle = (1.0f + (1.0f - (ABS(radius) / 320.0f))) * 720.0f;
                                float new_scale;
                                radius *= 1.0 - (time / 60.0f);
                                HuSprPosSet(work->spr_grp[0], idx, (radius * sin(M_PI * (((time / 60.0f) * angle) + 90.0f) / 180.0)) + work->x,
                                    (radius * cos(M_PI * (((time / 60.0f) * angle) + 90.0f) / 180.0)) + work->y);
                                HuSprZRotSet(work->spr_grp[0], idx, -(time / 60.0f) * 720.0f);
                                new_scale = 0.5 + (0.5 * (1.0f - (time / 60.0f)));
                                HuSprScaleSet(work->spr_grp[0], idx, new_scale, new_scale);
                                HuSprTPLvlSet(work->spr_grp[0], idx, 1.0f - (time / 60.0f));
                            }
                        }
                    }
                    if (work->time == 140) {
                        work->stat |= 0x4;
                    }
                    if (work->time >= 150) {
                        work->type = 0;
                        work->stat |= 0x8;
                    }
                }
            } break;

            case -1: {
                work->angle += seqSpeed * 0.1f;
                scale = 1.0f - work->angle;
                if (scale <= 0.0f) {
                    scale = 0.0f;
                    work->type = 0;
                    work->stat |= 0x8;
                    if (work->state == 0) {
                        MGSeqPauseEnableCtrl(1);
                    }
                }
                for (idx = 0; idx < work->word_len; idx++) {
                    HuSprTPLvlSet(work->spr_grp[0], idx, scale);
                }
            } break;

            default:

                break;
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    return 1;
}

s32 MGSeqInitFlip(SeqWork *work, va_list params)
{
    s16 i;
    s16 word_grp;
    s16 word_ofs;
    work->state = va_arg(params, int);
    if (work->state == 2) {
        return MGSeqInitDraw(work, params);
    }
    work->type = 0;
    work->angle = 0;
    {
        s32 word_ofs_temp;
        s32 word_katakana;
        s32 word_flag;

        if (seqLanguage == 0) {
            word_ofs_temp = 3;
        }
        else {
            word_ofs_temp = 0;
        }
        word_ofs = word_ofs_temp;
        word_katakana = 0;
        if (work->state == 2 && word_ofs == 0) {
            word_katakana = 1;
        }
        if (word_katakana) {
            word_flag = 1;
        }
        else {
            word_flag = 0;
        }

        word_grp = SeqMakeWord(work, wordMgTbl[work->state + word_ofs], word_flag);
    }
    HuSprGrpPosSet(work->spr_grp[word_grp], 0.0f, 0.0f);
    for (i = 0; i < work->word_len; i++) {
        HuSprTPLvlSet(work->spr_grp[word_grp], i, 0.0f);
        HuSprPosSet(work->spr_grp[word_grp], i, (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (i * 56), work->y);
        HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
        HuSprAttrReset(work->spr_grp[word_grp], i, HUSPR_ATTR_DISPOFF);
    }
    work->alt_word_len = work->word_len;
    {
        s32 word_ofs_temp;
        s32 word_katakana;
        s32 word_flag;

        if (seqLanguage == 0) {
            word_ofs_temp = 0;
        }
        else {
            word_ofs_temp = 3;
        }
        word_ofs = word_ofs_temp;
        word_katakana = 0;
        if (work->state == 2 && word_ofs == 0) {
            word_katakana = 1;
        }
        if (word_katakana) {
            word_flag = 1;
        }
        else {
            word_flag = 0;
        }

        word_grp = SeqMakeWord(work, wordMgTbl[work->state + word_ofs], word_flag);
    }
    HuSprGrpPosSet(work->spr_grp[word_grp], 0.0f, 0.0f);
    for (i = 0; i < work->word_len; i++) {
        HuSprTPLvlSet(work->spr_grp[word_grp], i, 0.0f);
        HuSprPosSet(work->spr_grp[word_grp], i, (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (i * 56), work->y);
        HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
        HuSprAttrReset(work->spr_grp[word_grp], i, HUSPR_ATTR_DISPOFF);
    }
    if (seqPauseF) {
        work->type = 2;
        HuSprAttrSet(word_grp, 0, HUSPR_ATTR_DISPOFF);
    }
    else {
        work->param[0] = 3;
    }
    return 1;
}

s32 MGSeqUpdateFlip(SeqWork *work)
{
    s16 idx;
    float scale;
    if (work->param[0] != 0 && work->type != -1) {
        switch (work->param[0]) {
            case 2:
                if (work->param[1] != -1) {
                    (void)work; // HACK: to introduce extra branch
                }
                else {
                    work->type = -1;
                    work->angle = 0.0f;
                }
                work->param[0] = 0;
                break;

            case 1:
                work->time_max = work->param[1];
                work->param[0] = 0;
                break;

            case 3:
                work->type = 1;
                work->param[0] = 0;
                break;

            default:
                work->param[0] = 0;
                break;
        }
    }
    if (work->type == 2) {
        return 1;
    }
    work->time += seqSpeed;
    if (work->time >= work->time_max && work->type != -1) {
        work->stat |= 0x4;
        work->type = -1;
        work->angle = 0.0f;
    }
    if (work->type) {
        switch (work->type) {
            case 1: {
                float time;
                float pos_x;
                s16 i;
                if (work->state == 0) {
                    if (work->time <= 10) {
                        for (idx = 0; idx < work->alt_word_len; idx++) {
                            HuSprTPLvlSet(work->spr_grp[0], idx, work->time / 10.0f);
                        }
                    }
                    else {
                        if (work->time <= 30) {
                            time = work->time - 10;
                            if (time <= 10) {
                                for (idx = 0; idx < work->alt_word_len; idx++) {
                                    HuSprScaleSet(work->spr_grp[0], idx, cos(M_PI * ((time / 10.0f) * 90.0f) / 180.0), 1.0f);
                                }
                            }
                            else {
                                time -= 10.0f;
                                for (idx = 0; idx < work->word_len; idx++) {
                                    HuSprTPLvlSet(work->spr_grp[1], idx, 1.0f);
                                    HuSprScaleSet(work->spr_grp[1], idx, sin(M_PI * ((time / 10.0f) * 90.0f) / 180.0), 1.0f);
                                }
                            }
                        }
                        else {
                            if (work->time > 35 && work->time <= 55) {
                                time = work->time - 35;
                                scale = 0.5 * sin(((time * 9.0f) * M_PI) / 180.0);
                                for (i = 0; i < work->word_len; i++) {
                                    pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
                                        + ((i * 56) * (scale + work->scale_x));
                                    HuSprPosSet(work->spr_grp[1], i, pos_x, work->y);
                                    HuSprScaleSet(work->spr_grp[1], i, work->scale_x + scale, work->scale_y + scale);
                                }
                            }
                        }
                    }
                    if (work->time == 35) {
                        HuAudFXPlay(36);
                        work->stat |= 0x10;
                    }
                    if (work->time == 55) {
                        work->stat |= 0x4;
                        SeqPlayStartFX();
                    }
                    if (work->time >= 75) {
                        work->type = 0;
                    }
                }
                else {
                    if (work->time == 1) {
                        if (work->state == 1) {
                            HuAudFXPlay(37);
                        }
                        else {
                            HuAudFXPlay(40);
                        }
                        MGSeqPauseEnableCtrl(0);
                        work->stat |= 0x10;
                    }
                    if (work->time <= 20) {
                        time = work->time;
                        scale = 0.5 * sin(M_PI * (9.0f * time) / 180.0);
                        for (i = 0; i < work->word_len; i++) {
                            HuSprTPLvlSet(work->spr_grp[1], i, 1.0f);
                            pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
                                + ((i * 56) * (scale + work->scale_x));
                            HuSprPosSet(work->spr_grp[1], i, pos_x, work->y);
                            HuSprScaleSet(work->spr_grp[1], i, work->scale_x + scale, work->scale_y + scale);
                        }
                    }
                    else {
                        if (work->time > 80 && work->time <= 160) {
                            time = work->time - 80;
                            for (idx = 0; idx < work->word_len; idx++) {
                                scale = time - (idx * 2);
                                if (scale < 0 || scale > 15.0f) {
                                    continue;
                                }
                                HuSprScaleSet(work->spr_grp[1], idx, cos(M_PI * ((scale / 15.0f) * 90.0f) / 180.0), 1.0f);
                            }
                            for (idx = 0; idx < work->alt_word_len; idx++) {
                                scale = (time - 15.0f) - (idx * 2);
                                if (scale < 0 || scale > 30.0f) {
                                    continue;
                                }
                                HuSprTPLvlSet(work->spr_grp[0], idx, 1.0f);
                                HuSprScaleSet(work->spr_grp[0], idx, sin(M_PI * ((scale / 30.0f) * 180.0f) / 180.0), 1.0f);
                            }
                        }
                    }
                    if (work->time == 160) {
                        work->stat |= 0x4;
                    }
                    if (work->time >= 160) {
                        work->type = 0;
                        work->stat |= 0x8;
                    }
                }
            } break;

            case -1: {
                work->angle += seqSpeed * 0.1f;
                scale = 1.0f - work->angle;
                if (scale <= 0.0f) {
                    scale = 0.0f;
                    work->type = 0;
                    work->stat |= 0x8;
                    if (work->state == 0) {
                        MGSeqPauseEnableCtrl(1);
                    }
                }
                for (idx = 0; idx < work->word_len; idx++) {
                    HuSprTPLvlSet(work->spr_grp[1], idx, scale);
                }
            } break;

            default:
                break;
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    return 1;
}

s32 MGSeqUpdateMGBowser(SeqWork *work)
{
    s16 idx;
    float scale;
    if (work->param[0] != 0 && work->type != -1) {
        switch (work->param[0]) {
            case 2:
                if (work->param[1] != -1) {
                    (void)work; // HACK: to introduce extra branch
                }
                else {
                    work->type = -1;
                    work->angle = 0.0f;
                }
                work->param[0] = 0;
                break;

            case 1:
                work->time_max = work->param[1];
                work->param[0] = 0;
                break;

            case 3:
                work->type = 1;
                work->param[0] = 0;
                break;

            default:
                work->param[0] = 0;
                break;
        }
    }
    if (work->type == 2) {
        return 1;
    }
    work->time += seqSpeed;
    if (work->time >= work->time_max && work->type != -1) {
        work->stat |= 0x4;
        work->type = -1;
        work->angle = 0.0f;
    }
    if (work->type) {
        switch (work->type) {
            case 1: {
                s16 i;
                s16 j;
                float angle;
                float time_angle;
                float time;
                float pos_x, pos_y;

                float temp_f25;
                float center_x;
                s16 spr_idx[16];
                float scale_arr[16];

                if (work->state == 0) {
                    if (work->time <= 60) {
                        center_x = (0.5 * (work->word_len * 56)) + 20.0;
                        for (idx = 0; idx < work->word_len; idx++) {
                            time = work->time - idx;
                            if (time < 0) {
                                scale_arr[idx] = 0.0f;
                                spr_idx[idx] = idx;
                            }
                            else {
                                if (time > 50.0f) {
                                    time = 50.0f;
                                }
                                time_angle = 540.0 * (1.0f - (time / 50.0f));
                                pos_x = (28.0f + (0.5f * -(work->word_len * 56))) + (idx * 56);
                                angle = 180.0 * (atan2(pos_x, center_x) / M_PI);
                                pos_x = work->x + (center_x * sin(M_PI * (angle + time_angle) / 180.0));
                                pos_y = work->y - (HU_DISP_CENTERY * (1.0 - (time / 50.0f)));
                                HuSprPosSet(work->spr_grp[0], idx, pos_x, pos_y);
                                temp_f25 = 0.9 + (0.1 * cos(M_PI * (angle + time_angle) / 180.0));
                                HuSprScaleSet(work->spr_grp[0], idx, temp_f25 * cos(M_PI * (angle + time_angle) / 180.0), temp_f25);
                                scale_arr[idx] = cos(M_PI * (angle + time_angle) / 180.0);
                                spr_idx[idx] = idx;
                            }
                        }
                        for (i = 1; i < work->word_len; i++) {
                            for (idx = 0; idx < work->word_len - i; idx++) {
                                if (scale_arr[idx] > scale_arr[idx + 1]) {
                                    j = spr_idx[idx];
                                    spr_idx[idx] = spr_idx[idx + 1];
                                    spr_idx[idx + 1] = j;
                                    angle = scale_arr[idx];
                                    scale_arr[idx] = scale_arr[idx + 1];
                                    scale_arr[idx + 1] = angle;
                                }
                            }
                        }
                        for (idx = 0; idx < work->word_len; idx++) {
                            HuSprPriSet(work->spr_grp[0], spr_idx[idx], idx + 5);
                        }
                    }
                    else {
                        if (work->time > 60 && work->time <= 80) {
                            time = work->time - 60;
                            scale = 0.5 * sin(((time * 9.0f) * M_PI) / 180.0);
                            for (i = 0; i < work->word_len; i++) {
                                pos_x = (28.0f * (scale + work->scale_x)) + (work->x - (0.5f * ((work->word_len * 56) * (scale + work->scale_x))))
                                    + ((i * 56) * (scale + work->scale_x));
                                HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
                                HuSprScaleSet(work->spr_grp[0], i, work->scale_x + scale, work->scale_y + scale);
                            }
                        }
                    }
                    if (work->time == 60) {
                        HuAudFXPlay(36);
                        work->stat |= 0x10;
                    }
                    if (work->time == 80) {
                        work->stat |= 0x4;
                        SeqPlayStartFX();
                    }
                    if (work->time >= 100) {
                        work->type = 0;
                    }
                }
                else {
                    if (work->time == 1) {
                        if (work->state == 1) {
                            HuAudFXPlay(37);
                        }
                        else {
                            HuAudFXPlay(40);
                        }
                        MGSeqPauseEnableCtrl(0);
                        work->stat |= 0x10;
                    }
                    if (work->time <= 20) {
                        for (j = 1; j < 4; j++) {
                            for (i = 0; i < work->word_len; i++) {
                                HuSprAttrSet(work->spr_grp[j], i, HUSPR_ATTR_DISPOFF);
                            }
                        }
                        time = work->time;
                        scale = work->scale_x + (0.5 * sin(((time * 9.0f) * M_PI) / 180.0));
                        for (i = 0; i < work->word_len; i++) {
                            HuSprAttrReset(work->spr_grp[0], i, HUSPR_ATTR_DISPOFF);
                            pos_x = ((28.0f * scale) + (work->x - (0.5f * (scale * (work->word_len * 56))))) + (scale * (i * 56));
                            HuSprPosSet(work->spr_grp[0], i, pos_x, work->y);
                            HuSprScaleSet(work->spr_grp[0], i, work->scale_x + (sin((M_PI * (time * 9.0f)) / 180.0)),
                                work->scale_y + (sin((M_PI * (time * 9.0f)) / 180.0)));
                        }
                        if (time == 20.0f) {
                            for (j = 1; j < 4; j++) {
                                for (i = 0; i < work->word_len; i++) {
                                    HuSprAttrReset(work->spr_grp[j], i, HUSPR_ATTR_DISPOFF);
                                }
                            }
                        }
                    }
                    else {
                        if (work->time > 80 && work->time <= 125) {
                            static float letterOfs[] = {
                                -30,
                                -30,
                                HU_DISP_WIDTH + 30,
                                -30,
                                HU_DISP_CENTERX + 52,
                                HU_DISP_HEIGHT + 30,
                                HU_DISP_WIDTH + 30,
                                HU_DISP_HEIGHT + 30,
                                -30,
                                HU_DISP_HEIGHT - 30,
                                HU_DISP_WIDTH + 30,
                                120,
                                HU_DISP_CENTERX + 162,
                                -30,
                            };
                            for (i = 0; i < 4; i++) {
                                time = work->time - 80 - i;
                                if (time < 0.0f || time > 15.0f) {
                                    continue;
                                }
                                for (idx = 0; idx < work->word_len; idx++) {
                                    pos_x = (28.0f + (work->x - (0.5f * (work->word_len * 56)))) + (idx * 56);
                                    pos_x += (time / 15.0f) * (letterOfs[(idx * 2)] - pos_x);
                                    pos_y = work->y + ((time / 15.0f) * (letterOfs[(idx * 2) + 1] - work->y));
                                    HuSprPosSet(work->spr_grp[i], idx, pos_x, pos_y);
                                }
                            }
                        }
                    }
                    if (work->time == 125) {
                        work->stat |= 0x4;
                    }
                    if (work->time >= 135) {
                        work->type = 0;
                        work->stat |= 0x8;
                    }
                }
            } break;

            case -1: {
                work->angle += seqSpeed * 0.1f;
                scale = 1.0f - work->angle;
                if (scale <= 0.0f) {
                    scale = 0.0f;
                    work->type = 0;
                    work->stat |= 0x8;
                    if (work->state == 0) {
                        MGSeqPauseEnableCtrl(1);
                    }
                }
                for (idx = 0; idx < work->word_len; idx++) {
                    HuSprTPLvlSet(work->spr_grp[0], idx, scale);
                }
            } break;

            default:
                break;
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    return 1;
}

s32 MGSeqInitDraw(SeqWork *work, va_list params)
{
    s16 word_grp;
    work->state = 2;
    work->seq_no = 13;
    work->type = 0;
    work->angle = 0.0f;
    {
        s32 word_flag;
        s32 word_ofs;

        if (seqLanguage == 0) {
            word_flag = 1;
        }
        else {
            word_flag = 0;
        }
        if (seqLanguage == 0) {
            word_ofs = 0;
        }
        else {
            word_ofs = 3;
        }

        word_grp = SeqMakeWord(work, wordMgTbl[2 + word_ofs], word_flag);
    }
    HuSprGrpPosSet(work->spr_grp[word_grp], HU_DISP_CENTERX, HU_DISP_CENTERY);
    work->param[0] = 3;
    return 1;
}

s32 MGSeqUpdateDraw(SeqWork *work)
{
    s16 idx;
    float scale;
    s16 group = work->spr_grp[0];
    if (work->param[0] != 0 && work->type != -1) {
        switch (work->param[0]) {
            case 2:
                if (work->param[1] != -1) {
                    (void)work; // HACK: to introduce extra branch
                }
                else {
                    work->type = -1;
                    work->angle = 0.0f;
                }
                work->param[0] = 0;
                break;

            case 1:
                work->time_max = work->param[1];
                work->param[0] = 0;
                break;

            case 3:
                work->type = 1;
                work->param[0] = 0;
                break;

            default:
                work->param[0] = 0;
                break;
        }
    }
    work->time += seqSpeed;
    if (work->time >= work->time_max && work->type != -1) {
        work->stat |= 0x4;
        work->type = -1;
        work->angle = 0.0f;
    }
    if (work->type) {
        switch (work->type) {
            case 1: {
                float time;
                float scale;
                float zrot;
                if (work->time <= 20) {
                    time = work->time;
                    zrot = 365.0f * (time / 20.0f);
                    scale = 1.3f * sin(M_PI * (90.0f * (time / 20.0f)) / 180.0);
                    HuSprGrpScaleSet(group, scale, scale);
                    HuSprGrpZRotSet(group, zrot);
                }
                if (work->time > 20 && work->time <= 25) {
                    HuSprGrpZRotSet(group, 0.0f);
                    time = work->time - 20;
                    scale = 1.0 + (0.3 * cos(M_PI * (90.0f * (time / 5.0f)) / 180.0));
                    HuSprGrpScaleSet(group, scale, scale);
                }
                if (work->time == 5) {
                    HuAudFXPlay(40);
                }
                if (work->time == 60) {
                    work->type = 0;
                }
            } break;

            case -1: {
                float tp_lvl;
                work->angle += seqSpeed * 0.1f;
                tp_lvl = 1.0f - work->angle;
                if (tp_lvl <= 0.0f) {
                    tp_lvl = 0.0f;
                    work->state = 0;
                    work->stat |= 0x8;
                }
                HuSprGrpTPLvlSet(group, tp_lvl);
            } break;

            default:
                break;
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    return 1;
}

static char *winCharNameTbl[] = {
    "ﾏﾘｵ",
    "MARIO",
    "ﾙｲｰｼﾞ",
    "LUIGI",
    "ﾋﾟｰﾁ",
    "PEACH",
    "ﾖｯｼｰ",
    "YOSHI",
    "ﾜﾘｵ",
    "WARIO",
    "ﾄﾞﾝｷｰ",
    VERSION_JPN ? "DK" : " DK ",
    "ﾃﾞｲｼﾞｰ",
    "DAISY",
    "ﾜﾙｲｰｼﾞ",
    "WALUIGI",
    "ｸｯﾊﾟ",
    "BOWSER",
    "ｷﾉﾋﾟｵ",
    "TOAD",
    "ﾍｲﾎｰ",
    VERSION_JPN ? "HEHOH" : "SHY GUY",
    "ﾃﾚｻ",
    VERSION_JPN ? "TERETHA" : "BOO",
    "ﾉｺﾉｺ",
    VERSION_JPN ? "NOKONOKO" : "KOOPA",
    "ﾐﾆｸｯﾊﾟ",
    VERSION_NTSC ? (VERSION_ENG ? "KOOPA KID" : "BABYBOWSER") : "MINI BOWSER",
    "ｸﾘﾎﾞｰ",
    VERSION_JPN ? "KURIBO" : "GOOMBA",
};

static char *winWordTbl[] = { "ｶﾁ", "WON!", "ﾊｲﾎﾞｸ", "LOSE", "ﾕｳｼｮｳ!", "CHAMPION!" };

static s16 winPosOfs[][5][2] = {
    { { VERSION_JPN ? 144 : 114, 0 }, { -144, 0 }, { 0, 0 }, { 0, 0 }, { 0, 0 } },
    { { 0, 35 }, { -144, -35 }, { 144, -35 }, { 0, 0 }, { 0, 0 } },
    { { 0, 105 }, { 0, -105 }, { -144, 0 }, { 144, 0 }, { 0, 0 } },
    { { 0, 105 }, { -144, -105 }, { 144, -105 }, { -144, 0 }, { 144, 0 } },
};

static s16 winnerNameW[8];

#define GET_LANG_IDX() ((seqLanguage == 0) ? 0 : 1)
#define GET_WIN_KANAF() ((seqLanguage == 0) ? 1 : 0)

s32 MGSeqInitWin(SeqWork *work, va_list params)
{
    int win_type = va_arg(params, int);
    s16 word_idx;
    s16 word_grp;
    s32 i;
    s32 j;
    s32 num_winners;
    float word_w;
    float word_x;
    if (win_type < 0 && win_type >= 6) {
        return 0;
    }
    if (win_type == 3) {
        word_idx = GET_LANG_IDX();
    }
    else {
        if (win_type == 4) {
            word_idx = GET_LANG_IDX() + 2;
        }
        else {
            word_idx = GET_LANG_IDX() + 4;
        }
    }
    word_grp = SeqMakeWord(work, winWordTbl[word_idx], GET_WIN_KANAF());
    winnerNameW[0] = work->word_len * (VERSION_JPN ? 56 : 50);
#if !VERSION_JPN
    for (i = 0; i < work->word_len; i++) {
        HuSprPosSet(work->spr_grp[word_grp], i, 25.0f + ((i * 50) - (0.5f * (work->word_len * 50))), 0.0f);
        HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
    }
#endif
    num_winners = 0;
#if !VERSION_JPN
    work->win_scale = 1.0f;
#endif
    for (j = 0; j < 4; j++) {
        int winner = va_arg(params, int);
        (void)winner; // to match PAL
        if (winner < 0) {
            continue;
        }
        word_grp = SeqMakeWord(work, winCharNameTbl[(winner * 2) + GET_LANG_IDX()], 0);
#if VERSION_ENG
        if (seqLanguage != 0) {
            char *name = winCharNameTbl[(winner * 2) + GET_LANG_IDX()];
            word_w = 0.0f;
            for (i = word_w; i < work->word_len; i++, name++) {
                if (*name == ' ') {
                    word_w += 30.0f;
                }
                else {
                    word_w += 50.0f;
                }
            }
            name = winCharNameTbl[(winner * 2) + GET_LANG_IDX()];
            word_x = 0.0f;
            for (i = word_x; i < work->word_len; i++, name++) {
                HuSprPosSet(work->spr_grp[word_grp], i, 25.0 + (word_x - (0.5 * word_w)), 0.0f);
                HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
                if (*name == ' ') {
                    word_x += 30.0f;
                }
                else {
                    word_x += 50.0f;
                }
            }
            if (work->win_scale == 0.6f || winner == 7 || winner == 13 || winner == 10) {
                work->win_scale = 0.6f;
            }
            else {
                work->win_scale = 0.75f;
            }
            winnerNameW[num_winners + 1] = word_w;
        }
        else if (winner == 7 || winner == 13) {
            for (i = 0; i < work->word_len; i++) {
                HuSprPosSet(work->spr_grp[word_grp], i, 26.0f + ((i * 52) - (0.5f * (work->word_len * 52))), 0.0f);
                HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
            }
            work->win_scale = 0.8f;
            winnerNameW[num_winners + 1] = work->word_len * 52;
        }
        else {
            work->win_scale = 1.0f;
            winnerNameW[num_winners + 1] = work->word_len * 56;
        }
#elif VERSION_PAL
        for (i = 0; i < work->word_len; i++) {
            HuSprPosSet(work->spr_grp[word_grp], i, 25.0f + ((i * 50) - (0.5f * (work->word_len * 50))), 0.0f);
            HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
        }
        if ((work->win_scale == 0.5f) || (winner == 13)) {
            work->win_scale = 0.5f;
        }
        else if ((work->win_scale == 0.6f) || (winner == 7) || (winner == 10)) {
            work->win_scale = 0.6f;
        }
        else {
            work->win_scale = 0.75f;
        }
        winnerNameW[num_winners + 1] = work->word_len * 50;
#else
        if (seqLanguage != 0) {
            for (i = 0; i < work->word_len; i++) {
                HuSprPosSet(work->spr_grp[word_grp], i, 25.0f + (i * 50 - (0.5f * (work->word_len * 50))), 0.0f);
                HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
            }
            work->win_scale = 0.75f;
            winnerNameW[num_winners + 1] = work->word_len * 50;
        }
        else if (winner == 7 || winner == 13) {
            for (i = 0; i < work->word_len; i++) {
                HuSprPosSet(work->spr_grp[word_grp], i, 26.0f + ((i * 52) - (0.5f * (work->word_len * 52))), 0.0f);
                HuSprAttrSet(work->spr_grp[word_grp], i, HUSPR_ATTR_LINEAR);
            }
            work->win_scale = 0.8f;
            winnerNameW[num_winners + 1] = work->word_len * 52;
        }
        else {
            work->win_scale = 1.0f;
            winnerNameW[num_winners + 1] = work->word_len * 56;
        }
#endif
        num_winners++;
    }
    if (num_winners == 0) {
        return 0;
    }
    work->state = 0;
    work->word_len = num_winners + 1;
    work->angle = 0.0f;
    work->type = 0;
    for (j = 0; j < num_winners + 1; j++) {
        if (num_winners == 1) {
#if VERSION_JPN
            word_x = 32 + (winnerNameW[1] + winnerNameW[0]);
#else
            word_x = 32.0f + ((float)winnerNameW[0] + (winnerNameW[1] * work->win_scale));
#endif
            if (j == 0) {
                word_x = (((HU_DISP_WIDTH - word_x) / 2.0f) + (word_x - (winnerNameW[0] / 2))) - HU_DISP_CENTERX;
            }
            else {
                word_x = (((HU_DISP_WIDTH - word_x) / 2.0f) + (winnerNameW[1] / 2)) - HU_DISP_CENTERX;
            }
        }
        else {
            if (abs(winPosOfs[num_winners - 1][j][0]) == 144.0f) {
#if VERSION_ENG
                if (winnerNameW[j] + 32 < HU_DISP_CENTERX) {
                    word_x = 176.0f;
                }
                else {
                    word_x = 32.0f + ((winnerNameW[j] * work->win_scale) / 2.0f);
                }
                if (winPosOfs[num_winners - 1][j][0] < 0) {
                    word_x = -(HU_DISP_CENTERX - word_x);
                }
                else {
                    word_x = (HU_DISP_WIDTH - word_x) - HU_DISP_CENTERX;
                }
#elif VERSION_PAL
                if (32.0f + (work->win_scale * winnerNameW[j]) < HU_DISP_CENTERX) {
                    word_x = 32.0f + ((winnerNameW[j] * work->win_scale) / 2.0f);
                }
                else {
                    word_x = 120.0f;
                }
                if (winPosOfs[num_winners - 1][j][0] < 0) {
                    word_x = -word_x;
                }
#else
                if (32 + winnerNameW[j] < HU_DISP_CENTERX) {
                    word_x = 32 + winnerNameW[j] / 2;
                }
                else {
                    word_x = 120.0f;
                }
                if (winPosOfs[num_winners - 1][j][0] < 0) {
                    word_x = -word_x;
                }
#endif
            }
            else {
                word_x = winPosOfs[num_winners - 1][j][0];
            }
        }
        HuSprGrpPosSet(work->spr_grp[j], HU_DISP_CENTERX + word_x, HU_DISP_CENTERY + winPosOfs[num_winners - 1][j][1]);
    }
    if (seqPauseF) {
        work->type = 1;
        num_winners++;
        for (j = 0; j < num_winners; j++) {
            HuSprAttrSet(work->spr_grp[j], 0, HUSPR_ATTR_DISPOFF);
        }
    }
    else {
        work->param[0] = 3;
    }
    return 1;
}

s32 MGSeqUpdateWin(SeqWork *work)
{
    s32 idx;
    float tp_lvl;
    s16 group = work->spr_grp[0];
    if (work->param[0] != 0 && work->type != -1) {
        switch (work->param[0]) {
            case 2:
                if (work->param[1] != -1) {
                    (void)work; // HACK: to introduce extra branch
                }
                else {
                    work->type = -1;
                    work->angle = 0.0f;
                }
                work->param[0] = 0;
                break;

            case 1:
                work->time_max = work->param[1];
                work->param[0] = 0;
                break;

            case 3:
                work->type = 1;
                work->param[0] = 0;
                break;

            default:
                work->param[0] = 0;
                break;
        }
    }
    work->time += seqSpeed;
    if (work->time >= work->time_max && work->type != -1) {
        work->stat |= 0x4;
        work->type = -1;
        work->angle = 0.0f;
    }
    if (work->type) {
        switch (work->type) {
            case 1: {
                float time;
                float scale;
                float zrot;
                if (work->time <= 20) {
                    time = work->time;
                    zrot = 365.0f * (time / 20.0f);
                    scale = sin(M_PI * (90.0f * (time / 20.0f)) / 180.0);
                    HuSprGrpScaleSet(work->spr_grp[0], scale, scale);
                    HuSprGrpZRotSet(work->spr_grp[0], zrot);
                    scale = 1.0 + (5.0 * cos(M_PI * (90.0f * (time / 20.0f)) / 180.0));
                    tp_lvl = time / 20.0f;
                    for (idx = 1; idx < work->word_len; idx++) {
                        HuSprGrpTPLvlSet(work->spr_grp[idx], tp_lvl);
                        HuSprGrpScaleSet(work->spr_grp[idx], scale * work->win_scale, scale);
                    }
                }
                if (work->time > 20 && work->time <= 22) {
                    HuSprGrpZRotSet(work->spr_grp[0], 0.0f);
                    for (idx = 1; idx < work->word_len; idx++) {
                        float pos_x;
                        float ofs[2];
                        if (work->time == 21) {
                            ofs[0] = ((idx & 0x1) * 2) - 1;
                            ofs[1] = (idx & 0x2) ? 2 : -1;
                        }
                        else {
                            ofs[0] = ofs[1] = 0.0f;
                        }
                        if (work->word_len == 2) {
                            pos_x = winnerNameW[1] + winnerNameW[0] + 32;
                            pos_x = (((HU_DISP_WIDTH - pos_x) / 2.0f) + (winnerNameW[1] / 2)) - HU_DISP_CENTERX;
                        }
                        else {
                            if (abs(winPosOfs[work->word_len - 2][idx][0]) == 144.0f) {
                                if (winnerNameW[idx] + 32 < HU_DISP_CENTERX) {
                                    pos_x = VERSION_ENG ? 176.0f : winnerNameW[idx] / 2 + 32;
                                }
                                else {
                                    pos_x = VERSION_ENG ? 32.0f + ((winnerNameW[idx] * work->win_scale) / 2.0f) : 128.0f;
                                }
                                if (winPosOfs[work->word_len - 2][idx][0] < 0) {
                                    pos_x = VERSION_ENG ? -(HU_DISP_CENTERX - pos_x) : -pos_x;
                                }
#if VERSION_ENG
                                else {
                                    pos_x = (HU_DISP_WIDTH - pos_x) - HU_DISP_CENTERX;
                                }
#endif
                            }
                            else {
                                pos_x = winPosOfs[work->word_len - 2][idx][0];
                            }
                        }
                        HuSprGrpPosSet(work->spr_grp[idx], (HU_DISP_CENTERX + pos_x) + ofs[0],
                            ofs[1] + (HU_DISP_CENTERY + winPosOfs[work->word_len - 2][idx][1]));
                    }
                }
                if (work->time == 125) {
                    work->type = 0;
                }
            } break;

            case -1: {
                work->angle += seqSpeed * 0.1f;
                tp_lvl = 1.0f - work->angle;
                if (tp_lvl <= 0.0f) {
                    tp_lvl = 0.0f;
                    work->state = 0;
                    work->stat |= 0x8;
                }
                for (idx = 0; idx < work->word_len; idx++) {
                    HuSprGrpTPLvlSet(work->spr_grp[idx], tp_lvl);
                }
            } break;

            default:
                break;
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    return 1;
}

s32 MGSeqInitRecord(SeqWork *work, va_list params)
{
    AnimData *spr_data;
    s16 spr_grp;
    s16 time_pos[2];
    s16 i;
    s16 sprite;
    s16 digit_idx;
    s32 digit;
    seqRecordVal = va_arg(params, int);
    work->type = 0;
    work->angle = 0.0f;
    work->spr_grp[0] = spr_grp = HuSprGrpCreate(10);
    spr_data = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 9)));
    sprite = HuSprCreate(spr_data, 0, 0);
    HuSprGrpMemberSet(spr_grp, 0, sprite);
    HuSprPosSet(spr_grp, 0, 0.0f, -32.0f);
    spr_data = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 8)));
    sprite = HuSprCreate(spr_data, 0, 0);
    HuSprGrpMemberSet(spr_grp, 1, sprite);
    spr_data = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 7)));
    for (i = 0; i < 8; i++) {
        sprite = HuSprCreate(spr_data, 0, 0);
        HuSprGrpMemberSet(spr_grp, i + 2, sprite);
    }
    if (omcurovl == OVL_M407 || omcurovl == OVL_M453 || omcurovl == OVL_M459 || omcurovl == OVL_M460 || omcurovl == OVL_M462
        || omcurovl == OVL_M442) {
        digit_idx = 0;
        if (seqRecordVal > 9999) {
            seqRecordVal = 9999;
        }
        digit = seqRecordVal / 1000;
        if (digit != 0) {
            HuSprBankSet(spr_grp, digit_idx + 2, digit);
            seqRecordVal -= digit * 1000;
            digit_idx++;
        }

        digit = seqRecordVal / 100;
        if (digit != 0 || digit_idx != 0) {
            HuSprBankSet(spr_grp, digit_idx + 2, digit);
            seqRecordVal -= digit * 100;
            digit_idx++;
        }
        digit = seqRecordVal / 10;
        if (digit != 0 || digit_idx != 0) {
            HuSprBankSet(spr_grp, digit_idx + 2, digit);
            seqRecordVal -= digit * 10;
            digit_idx++;
        }
        HuSprBankSet(spr_grp, digit_idx + 2, seqRecordVal);
        digit_idx++;
        for (i = digit_idx; i < 8; i++) {
            HuSprAttrSet(spr_grp, i + 2, HUSPR_ATTR_DISPOFF);
        }
        HuSprPosSet(spr_grp, 1, (-((digit_idx * 44) + 48) / 2) + 24, 32.0f);
        for (i = 0; i < digit_idx; i++) {
            HuSprPosSet(spr_grp, i + 2, (-((digit_idx * 44) + 48) / 2) + 70 + (i * 44), 32.0f);
        }
    }
    else {
        s16 x;
        digit_idx = 0;
        digit = seqRecordVal / (600 * REFRESH_RATE);
        if (digit != 0) {
            HuSprBankSet(spr_grp, digit_idx + 2, digit);
            seqRecordVal -= digit * (600 * REFRESH_RATE);
            digit_idx++;
        }
        digit = seqRecordVal / (60 * REFRESH_RATE);
        HuSprBankSet(spr_grp, digit_idx + 2, digit);
        seqRecordVal -= digit * (60 * REFRESH_RATE);
        digit_idx++;
        HuSprBankSet(spr_grp, digit_idx + 2, 10);
        time_pos[0] = digit_idx;
        digit_idx++;
        digit = seqRecordVal / (10 * REFRESH_RATE);
        HuSprBankSet(spr_grp, digit_idx + 2, digit);
        seqRecordVal -= digit * (10 * REFRESH_RATE);
        digit_idx++;
        digit = seqRecordVal / REFRESH_RATE;
        HuSprBankSet(spr_grp, digit_idx + 2, digit);
        seqRecordVal -= digit * REFRESH_RATE;
        digit_idx++;
        HuSprBankSet(spr_grp, digit_idx + 2, 11);
        time_pos[1] = digit_idx;
        digit_idx++;
        if (omcurovl == OVL_M405 || omcurovl == OVL_M432 || omcurovl == OVL_M461) {
            seqRecordVal = (float)seqRecordVal * (101.5 / REFRESH_RATE);
        }
        else {
            seqRecordVal = (float)seqRecordVal * (100.0 / REFRESH_RATE);
        }
        digit = seqRecordVal / 10;
        HuSprBankSet(spr_grp, digit_idx + 2, digit);
        seqRecordVal -= digit * 10;
        digit_idx++;
        HuSprBankSet(spr_grp, digit_idx + 2, seqRecordVal);
        digit_idx++;
        for (i = digit_idx; i < 8; i++) {
            HuSprAttrSet(spr_grp, i + 2, HUSPR_ATTR_DISPOFF);
        }
        HuSprPosSet(spr_grp, 1, (-((digit_idx * 44) + 4) / 2) + 24, 32.0f);
        x = (-((digit_idx * 44) + 4) / 2) + 70;
        for (i = 0; i < digit_idx; i++) {
            HuSprPosSet(spr_grp, i + 2, x, 32.0f);
            if (time_pos[0] == i || time_pos[1] == i) {
                x += 22;
            }
            else {
                x += 44;
            }
        }
    }
    HuSprGrpPosSet(spr_grp, HU_DISP_CENTERX, HU_DISP_CENTERY);
    work->param[0] = 3;
    return 1;
}

s32 MGSeqUpdateRecord(SeqWork *work)
{
    s16 group;
    if (_CheckFlag(FLAG_ID_MAKE(1, 12))) {
        work->state = 0;
        work->stat |= 0xC;
    }
    else {
        group = work->spr_grp[0];
        if (work->param[0] != 0 && work->type != -1) {
            switch (work->param[0]) {
                case 2:
                    if (work->param[1] != -1) {
                        (void)work; // HACK: to introduce extra branch
                    }
                    else {
                        work->type = -1;
                        work->angle = 0.0f;
                    }
                    work->param[0] = 0;
                    break;

                case 1:
                    work->time_max = work->param[1];
                    work->param[0] = 0;
                    break;

                case 3:
                    work->type = 1;
                    work->param[0] = 0;
                    break;

                default:
                    work->param[0] = 0;
                    break;
            }
        }
        work->time += seqSpeed;
        if (work->time >= work->time_max && work->type != -1) {
            work->stat |= 0x4;
            work->type = -1;
            work->angle = 0.0f;
        }
        if (work->type) {
            switch (work->type) {
                case 1: {
                    if (work->time <= 10) {
                        HuSprGrpTPLvlSet(group, work->time / 10.0);
                    }
                    if (work->time == 5) {
                        HuAudFXPlay(38);
                    }
                    if (work->time == 30) {
                        work->type = 0;
                    }
                } break;

                case -1: {
                    float tp_lvl;
                    work->angle += seqSpeed * 0.1f;
                    tp_lvl = 1.0f - work->angle;
                    if (tp_lvl <= 0.0f) {
                        tp_lvl = 0.0f;
                        work->state = 0;
                        work->stat |= 0x8;
                    }
                    HuSprGrpTPLvlSet(group, tp_lvl);
                } break;

                default:
                    break;
            }
        }
    }
    if (seqDoneF || (work->stat & 0x8)) {
        MGSeqSprKill(work);
        return 0;
    }
    return 1;
}

static void PauseProc(void);

void MGSeqPauseInit(void)
{
    MGSeqPauseEnableCtrl(0);
    HuWinInit(1);
    pauseProcess = HuPrcCreate(PauseProc, 100, 4096, 0);
    HuPrcSetStat(pauseProcess, PROCESS_STAT_PAUSE_EN | PROCESS_STAT_UPAUSE_EN);
    pauseActiveF = 1;
    pauseExitF = 0;
    pauseWaitF = 0;
}

#define PAUSE_WIN_X (HU_DISP_CENTERX - 206)
#define PAUSE_WIN_DIST (HU_DISP_CENTERX + 112)
#define PAUSE_EXIT_Y (HU_DISP_HEIGHT - 80)

static void PauseProc(void)
{
    s16 mg;
    s16 i;
    s16 j;

    s16 char_mess_map[4];
    s16 char_mess[4][4];
    s16 window[3] = { -1, -1, -1 };

    SeqWork work;
    static char *pauseStr[] = { "ﾎﾟｰｽﾞ", "PAUSE" };
    float ratio;

    HuAudFXPlay(5);
    for (i = 0; i < 16; i++) {
        work.sprite[i] = work.spr_grp[i] = -1;
    }
    SeqMakeWord(&work, pauseStr[GET_LANG_IDX()], 0);
    for (i = 0; i < work.word_len; i++) {
        HuSprPriSet(work.spr_grp[0], i, 0);
    }
    for (i = 0; i < 4; i++) {
        char_mess_map[i] = 0;
    }
    for (i = 0; i < 4; i++) {
        char_mess[GWPlayerCfg[i].group][char_mess_map[GWPlayerCfg[i].group]] = GWPlayerCfg[i].character;
        char_mess_map[GWPlayerCfg[i].group]++;
    }
    mg = omMgIndexGet(omcurovl);
    if (mgInfoTbl[mg].inst_mess[1] == 0 && mgInfoTbl[mg].inst_mess[2] == 0) {
        for (i = 1; i <= 20; i++) {
            ratio = sin(M_PI * (i * 4.5f) / 180.0);
            HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 290) - 50.0f);
            HuPrcVSleep();
        }
    }
    else {
        if (mgPracticeEnableF && !_CheckFlag(FLAG_ID_MAKE(1, 12))) {
            window[2] = HuWinExCreateStyled(-10000.0f, PAUSE_EXIT_Y, 412, 42, -1, 0);
            HuWinPriSet(window[2], 0);
            HuWinDispOn(window[2]);
            HuWinMesSpeedSet(window[2], 0);
            HuWinAttrSet(window[2], 0x800);
            HuWinMesSet(window[2], MAKE_MESSID(0x33, 0xA1));
        }
        if (mgInfoTbl[mg].inst_mess[2]) {
            s16 insert_idx;
            window[0] = HuWinExCreateStyled(-10000.0f, HU_DISP_CENTERY - 100, 412, 120, -1, 0);
            HuWinPriSet(window[0], 0);
            HuWinDispOn(window[0]);
            HuWinMesSpeedSet(window[0], 0);
            HuWinMesSet(window[0], mgInfoTbl[mg].inst_mess[1]);
            window[1] = HuWinExCreateStyled(-10000.0f, HU_DISP_CENTERY + 36, 412, 120, -1, 0);
            HuWinPriSet(window[1], 0);
            HuWinDispOn(window[1]);
            HuWinMesSpeedSet(window[1], 0);
            HuWinMesSet(window[1], mgInfoTbl[mg].inst_mess[2]);
            for (i = insert_idx = 0; i < 4; i++) {
                for (j = 0; j < char_mess_map[i]; j++) {
                    HuWinInsertMesSet(window[0], char_mess[i][j], (s16)insert_idx);
                    HuWinInsertMesSet(window[1], char_mess[i][j], (s16)insert_idx);
                    insert_idx++;
                }
            }
            for (i = 1; i <= 20; i++) {
                ratio = sin(M_PI * (i * 4.5f) / 180.0);
                HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 150) - 50.0f);
                HuWinPosSet(window[0], (PAUSE_WIN_DIST + PAUSE_WIN_X) * ratio - PAUSE_WIN_DIST, HU_DISP_CENTERY - 100);
                HuWinPosSet(window[1], -(PAUSE_WIN_DIST - PAUSE_WIN_X) * ratio + PAUSE_WIN_DIST, HU_DISP_CENTERY + 32);
                if (window[2] != -1) {
                    HuWinPosSet(window[2], PAUSE_WIN_X, (PAUSE_EXIT_Y + 4) + (100 * (1.0 - ratio)));
                }
                HuPrcVSleep();
            }
        }
        else {
            window[0] = HuWinExCreateStyled(-10000.0f, HU_DISP_CENTERY - 70, 412, 120, -1, 0);
            HuWinPriSet(window[0], 0);
            HuWinDispOn(window[0]);
            HuWinMesSpeedSet(window[0], 0);
            HuWinMesSet(window[0], mgInfoTbl[mg].inst_mess[1]);
            for (i = 1; i <= 20; i++) {
                ratio = sin(M_PI * (i * 4.5f) / 180.0);
                HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 150) - 50.0f);
                HuWinPosSet(window[0], (PAUSE_WIN_DIST + PAUSE_WIN_X) * ratio - PAUSE_WIN_DIST, HU_DISP_CENTERY - 70);
                if (window[2] != -1) {
                    HuWinPosSet(window[2], -(PAUSE_WIN_DIST - PAUSE_WIN_X) * ratio + PAUSE_WIN_DIST, PAUSE_EXIT_Y + 4);
                }
                HuPrcVSleep();
            }
        }
    }
    MGSeqPauseEnableCtrl(1);
    pauseWaitF = 1;
    while (!pauseExitF) {
        HuPrcVSleep();
    }
    pauseWaitF = 0;
    if (window[0] == -1 && window[1] == -1) {
        for (i = 1; i <= 10; i++) {
            ratio = cos(M_PI * (i * 9.0f) / 180.0);
            HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 290) - 50.0f);
            HuPrcVSleep();
        }
    }
    else {
        if (window[1] != -1) {
            for (i = 1; i <= 10; i++) {
                ratio = cos(M_PI * (i * 9.0f) / 180.0);
                HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 150) - 50.0f);
                HuWinPosSet(window[0], (PAUSE_WIN_DIST + PAUSE_WIN_X) * ratio - PAUSE_WIN_DIST, HU_DISP_CENTERY - 100);
                HuWinPosSet(window[1], -(PAUSE_WIN_DIST - PAUSE_WIN_X) * ratio + PAUSE_WIN_DIST, HU_DISP_CENTERY + 32);
                if (window[2] != -1) {
                    HuWinPosSet(window[2], PAUSE_WIN_X, (PAUSE_EXIT_Y + 4) + (100 * (1.0 - ratio)));
                }
                HuPrcVSleep();
            }
        }
        else {
            for (i = 1; i <= 10; i++) {
                ratio = cos(M_PI * (i * 9.0f) / 180.0);
                HuSprGrpPosSet(work.spr_grp[0], HU_DISP_CENTERX, (ratio * 150) - 50.0f);
                HuWinPosSet(window[0], (PAUSE_WIN_DIST + PAUSE_WIN_X) * ratio - PAUSE_WIN_DIST, HU_DISP_CENTERY - 70);
                if (window[2] != -1) {
                    HuWinPosSet(window[2], -(PAUSE_WIN_DIST - PAUSE_WIN_X) * ratio + PAUSE_WIN_DIST, PAUSE_EXIT_Y + 4);
                }
                HuPrcVSleep();
            }
        }
    }
    omSysPauseCtrl(0);
    if (window[0] != -1) {
        HuWinKill(window[0]);
    }
    if (window[1] != -1) {
        HuWinKill(window[1]);
    }
    if (window[2] != -1) {
        HuWinKill(window[2]);
    }
    HuSprGrpKill(work.spr_grp[0]);
    pauseProcess = NULL;
    pauseActiveF = 0;
    HuPrcEnd();
    do {
        HuPrcVSleep();
    } while (1);
}

void MGSeqPauseKill(void)
{
    pauseExitF = 1;
}

void MGSeqPauseEnableCtrl(s32 flag)
{
    if (!_CheckFlag(FLAG_ID_MAKE(1, 8))) {
        omSysPauseEnable(flag);
    }
}

static void PracticeProc(void);

static s16 practiceTbl[][2] = {
    OVL_M401,
    1,
    OVL_M402,
    1,
    OVL_M403,
    1,
    OVL_M405,
    1,
    OVL_M406,
    0,
    OVL_M407,
    1,
    OVL_M408,
    0,
    OVL_M409,
    0,
    OVL_M410,
    1,
    OVL_M411,
    2,
    OVL_M412,
    1,
    OVL_M413,
    0,
    OVL_M414,
    2,
    OVL_M415,
    1,
    OVL_M443,
    2,
    OVL_M416,
    1,
    OVL_M417,
    1,
    OVL_M418,
    1,
    OVL_M419,
    1,
    OVL_M420,
    1,
    OVL_M421,
    1,
    OVL_M422,
    1,
    OVL_M423,
    1,
    OVL_M424,
    1,
    OVL_M425,
    1,
    OVL_M426,
    1,
    OVL_M427,
    0,
    OVL_M428,
    0,
    OVL_M429,
    2,
    OVL_M430,
    1,
    OVL_M431,
    1,
    OVL_M432,
    1,
    OVL_M433,
    0,
    OVL_M434,
    1,
    OVL_M404,
    0,
    OVL_M438,
    1,
    OVL_M439,
    2,
    OVL_M440,
    1,
    OVL_M441,
    1,
    OVL_M442,
    1,
    OVL_M455,
    0,
    OVL_M456,
    0,
    OVL_INVALID,
    0,
};

void MGSeqPracticeInit(void)
{
    Process *process;
    s16 i;
    process = HuPrcCurrentGet();
    if (!_CheckFlag(FLAG_ID_MAKE(1, 12))) {
        return;
    }
    wipeFadeInF = 0;
    for (i = 0; practiceTbl[i][0] != OVL_INVALID; i++) {
        if (omcurovl == practiceTbl[i][0]) {
            break;
        }
    }
    if (practiceTbl[i][0] != -1) {
        HuPrcChildCreate(PracticeProc, 10, 8192, 0, process);
    }
}

static void PracticeProc(void)
{

    s16 group;
    s16 sprite;
    AnimData *anim;
    s16 i;
    s16 *practice;
    float time;
    static float yPosTbl[] = { 53, HU_DISP_HEIGHT - 56, HU_DISP_CENTERY };
    time = 0.0f;
    for (i = 0; practiceTbl[i][0] != OVL_INVALID; i++) {
        if (omcurovl == practiceTbl[i][0]) {
            break;
        }
    }
    practice = &practiceTbl[i][0];
    group = HuSprGrpCreate(1);
    HuSprGrpPosSet(group, 0, 0);
    anim = HuSprAnimRead(SeqReadFile(DATA_MAKE_NUM(DATADIR_GAMEMES, 5)));
    sprite = HuSprCreate(anim, 1, 0);
    HuSprGrpMemberSet(group, 0, sprite);
    HuSprPosSet(group, 0, HU_DISP_CENTERX, yPosTbl[practice[1]]);
    do {
        if (!wipeFadeInF || WipeStatGet()) {
            HuSprAttrSet(group, 0, HUSPR_ATTR_DISPOFF);
            HuPrcVSleep();
            continue;
        }
        HuSprAttrReset(group, 0, HUSPR_ATTR_DISPOFF);
        for (i = 0; i < 4; i++) {
            if (!(HuPadBtnDown[GWPlayerCfg[i].pad_idx] & PAD_TRIGGER_Z)) {
                continue;
                ;
            }
            if (!GWPlayerCfg[i].iscom) {
                break;
            }
        }
        if (i != 4) {
            break;
        }
        HuSprTPLvlSet(group, 0, fabs(sin(M_PI * time / 180.0)));
        time += 2.0f;
        HuPrcVSleep();
    } while (1);
    omSysExitReq = 1;
    HuPrcEnd();
    do {
        HuPrcVSleep();
    } while (1);
}

static s16 seqStartFXTbl[][2]
    = { OVL_M401, 17, OVL_M402, 16, OVL_M403, 12, OVL_M404, 12, OVL_M405, 17, OVL_M406, 12, OVL_M407, 16, OVL_M408, 12, OVL_M409, 16, OVL_M410, 12,
          OVL_M411, 16, OVL_M412, 12, OVL_M413, 16, OVL_M414, 16, OVL_M415, 16, OVL_M416, 16, OVL_M417, 17, OVL_M418, 16, OVL_M419, 16, OVL_M420, 16,
          OVL_M421, 16, OVL_M422, 12, OVL_M423, 12, OVL_M424, 16, OVL_M425, 16, OVL_M426, 16, OVL_M427, 12, OVL_M428, 12, OVL_M429, 16, OVL_M430, 12,
          OVL_M431, 16, OVL_M432, 12, OVL_M433, 12, OVL_M434, 16, OVL_M435, 12, OVL_M436, 16, OVL_M437, 12, OVL_M438, 16, OVL_M439, 12, OVL_M440, 16,
          OVL_M441, 16, OVL_M442, 16, OVL_M443, -1, OVL_M444, -1, OVL_M445, 12, OVL_M446, -1, OVL_M447, 12, OVL_M448, -1, OVL_M449, 16, OVL_M450, 12,
          OVL_M455, 17, OVL_M456, 17, OVL_M457, 12, OVL_M458, 12, OVL_M459, 17, OVL_M460, 12, OVL_M461, 12, OVL_M462, 12, OVL_INVALID, 0 };

static void SeqPlayStartFX(void)
{
    s16 i;
    for (i = 0; seqStartFXTbl[i][0] != OVL_INVALID; i++) {
        if (omcurovl == seqStartFXTbl[i][0]) {
            break;
        }
    }
    if (seqStartFXTbl[i][0] == OVL_INVALID || seqStartFXTbl[i][1] == -1) {
        return;
    }
    HuAudFXPlay(seqStartFXTbl[i][1]);
}

void MGSeqPracticeExitCheck(omObjData *object)
{
    s16 input;
    s16 i;
    mgQuitExtraF = 0;
    if (object->work[0] == 0) {
        if (omMgIndexGet(omcurovl) == -1) {
            omDelObjEx(HuPrcCurrentGet(), object);
            return;
        }
        object->work[0]++;
    }
    if (!omPauseChk() || _CheckFlag(FLAG_ID_MAKE(1, 12)) || !pauseWaitF) {
        return;
    }
    for (i = input = 0; i < 4; i++) {
        input |= HuPadBtnDown[i];
    }
    if (input & PAD_TRIGGER_Z) {
        HuAudFXPlay(3);
        pauseExitF = 1;
        omSysPauseCtrl(0);
        omSysExitReq = 1;
        mgQuitExtraF = 1;
        omDelObjEx(HuPrcCurrentGet(), object);
    }
}