Merge branch 'master' of https://github.com/pret/pokeemerald into battle_refactor

29 files changed, 6253 insertions, 81 deletions

diff --git a/src/battle_message.c b/src/battle_message.c
index a08378058..7ab6fcef3 100644
--- a/src/battle_message.c
+++ b/src/battle_message.c
@@ -1324,6 +1324,8 @@ const u8 gText_BattleRecordedOnPass[] = _("{B_PLAYER_NAME}’s battle result was
 const u8 gText_LinkTrainerWantsToBattlePause[] = _("{B_20}\nwants to battle!{PAUSE 49}");
 const u8 gText_TwoLinkTrainersWantToBattlePause[] = _("{B_20} and {B_21}\nwant to battle!{PAUSE 49}");
 
+// This is four lists of moves which use a different attack string in Japanese
+// to the default. See the documentation for sub_814F950 for more detail.
 static const u16 sUnknownMoveTable[] =
 {
     MOVE_SWORDS_DANCE, MOVE_STRENGTH, MOVE_GROWTH,
@@ -1338,16 +1340,16 @@ static const u16 sUnknownMoveTable[] =
     MOVE_TRICK, MOVE_ASSIST, MOVE_INGRAIN, MOVE_KNOCK_OFF,
     MOVE_CAMOUFLAGE, MOVE_ASTONISH, MOVE_ODOR_SLEUTH,
     MOVE_GRASS_WHISTLE, MOVE_SHEER_COLD, MOVE_MUDDY_WATER,
-    MOVE_IRON_DEFENSE, MOVE_BOUNCE, MOVE_NONE,
+    MOVE_IRON_DEFENSE, MOVE_BOUNCE, 0,
 
     MOVE_TELEPORT, MOVE_RECOVER, MOVE_BIDE, MOVE_AMNESIA,
-    MOVE_FLAIL, MOVE_TAUNT, MOVE_BULK_UP, MOVE_NONE,
+    MOVE_FLAIL, MOVE_TAUNT, MOVE_BULK_UP, 0,
 
     MOVE_MEDITATE, MOVE_AGILITY, MOVE_MIMIC, MOVE_DOUBLE_TEAM,
     MOVE_BARRAGE, MOVE_TRANSFORM, MOVE_STRUGGLE, MOVE_SCARY_FACE,
     MOVE_CHARGE, MOVE_WISH, MOVE_BRICK_BREAK, MOVE_YAWN,
     MOVE_FEATHER_DANCE, MOVE_TEETER_DANCE, MOVE_MUD_SPORT,
-    MOVE_FAKE_TEARS, MOVE_WATER_SPORT, MOVE_CALM_MIND, MOVE_NONE,
+    MOVE_FAKE_TEARS, MOVE_WATER_SPORT, MOVE_CALM_MIND, 0,
 
     MOVE_POUND, MOVE_SCRATCH, MOVE_VICE_GRIP,
     MOVE_WING_ATTACK, MOVE_FLY, MOVE_BIND, MOVE_SLAM,
@@ -1361,7 +1363,7 @@ static const u16 sUnknownMoveTable[] =
     MOVE_FORESIGHT, MOVE_CHARM, MOVE_ATTRACT, MOVE_ROCK_SMASH,
     MOVE_UPROAR, MOVE_SPIT_UP, MOVE_SWALLOW, MOVE_TORMENT,
     MOVE_FLATTER, MOVE_ROLE_PLAY, MOVE_ENDEAVOR, MOVE_TICKLE,
-    MOVE_COVET, MOVE_NONE
+    MOVE_COVET, 0
 };
 
 static const u8 sDummyWeirdStatusString[] = {EOS, EOS, EOS, EOS, EOS, EOS, EOS, EOS, 0, 0};
@@ -2330,6 +2332,10 @@ static void ExpandBattleTextBuffPlaceholders(const u8 *src, u8 *dst)
     }
 }
 
+// Loads one of two text strings into the provided buffer. This is functionally
+// unused, since the value loaded into the buffer is not read; it loaded one of
+// two particles (either "は" or "の") which works in tandem with sub_814F950
+// below to effect changes in the meaning of the line.
 static void sub_814F8F8(u8* textBuff)
 {
     s32 counter = 0;
@@ -2337,7 +2343,7 @@ static void sub_814F8F8(u8* textBuff)
 
     while (counter != 4)
     {
-        if (sUnknownMoveTable[i] == MOVE_NONE)
+        if (sUnknownMoveTable[i] == 0)
             counter++;
         if (sUnknownMoveTable[i++] == gStringInfo->currentMove)
             break;
@@ -2352,6 +2358,24 @@ static void sub_814F8F8(u8* textBuff)
     }
 }
 
+// Appends "!" to the text buffer `dst`. In the original Japanese this looked
+// into the table of moves at sUnknownMoveTable and varied the line accordingly.
+// 
+// gText_ExclamationMark was a plain "!", used for any attack not on the list.
+// It resulted in the translation "<NAME>'s <ATTACK>!".
+// 
+// gText_ExclamationMark2 was "を つかった！". This resulted in the translation
+// "<NAME> used <ATTACK>!", which was used for all attacks in English.
+// 
+// gText_ExclamationMark3 was "した！". This was used for those moves whose
+// names were verbs, such as Recover, and resulted in translations like "<NAME>
+// recovered itself!".
+// 
+// gText_ExclamationMark4 was "を した！" This resulted in a translation of
+// "<NAME> did an <ATTACK>!".
+// 
+// gText_ExclamationMark5 was " こうげき！" This resulted in a translation of
+// "<NAME>'s <ATTACK> attack!".
 static void sub_814F950(u8* dst)
 {
     s32 counter = 0;
diff --git a/src/battle_transition.c b/src/battle_transition.c
new file mode 100644
index 000000000..e003e0fce
--- /dev/null
+++ b/src/battle_transition.c
@@ -0,0 +1,4350 @@
+#include "global.h"
+#include "battle_transition.h"
+#include "unk_transition.h"
+#include "main.h"
+#include "overworld.h"
+#include "task.h"
+#include "palette.h"
+#include "trig.h"
+#include "field_effect.h"
+#include "field_camera.h"
+#include "random.h"
+#include "sprite.h"
+#include "sound.h"
+#include "constants/songs.h"
+#include "constants/trainers.h"
+#include "field_camera.h"
+#include "unknown_task.h"
+#include "malloc.h"
+#include "gpu_regs.h"
+#include "decompress.h"
+#include "bg.h"
+#include "blend_palette.h"
+
+struct TransitionData
+{
+    vu8 VBlank_DMA;
+    u16 WININ;
+    u16 WINOUT;
+    u16 WIN0H;
+    u16 WIN0V;
+    u16 field_A; // unused
+    u16 field_C; // unused
+    u16 BLDCNT;
+    u16 BLDALPHA;
+    u16 BLDY;
+    s16 field_14;
+    s16 field_16;
+    s16 BG0HOFS_1;
+    s16 BG0HOFS_2;
+    s16 BG0VOFS; // used but not set
+    s16 field_1E; // unused
+    s16 field_20;
+    s16 field_22; // unused
+    s16 data[11];
+};
+
+struct StructRectangularSpiral
+{
+    u8 field_0;
+    s16 field_2;
+    u8 field_4;
+    s16 field_6;
+    u8 field_8;
+};
+
+typedef bool8 (*TransitionStateFunc)(struct Task *task);
+typedef bool8 (*TransitionSpriteCallback)(struct Sprite *sprite);
+
+extern u16 gUnknown_020393A8[];
+extern u16 gUnknown_02038C28[][0x3C0];
+extern u16 gBattle_BG0_X;
+extern u16 gBattle_BG0_Y;
+
+extern const struct OamData gFieldObjectBaseOam_32x32;
+
+extern void c2_exit_to_overworld_2_switch(void);
+extern void sub_80AC3D0(void);
+extern void dp12_8087EA4(void);
+
+// this file's functions
+static void LaunchBattleTransitionTask(u8 transitionId);
+static void Task_BattleTransitionMain(u8 taskId);
+static void Phase1Task_TransitionAll(u8 taskId);
+static void Phase2Task_Blur(u8 taskId);
+static void Phase2Task_Swirl(u8 taskId);
+static void Phase2Task_Shuffle(u8 taskId);
+static void Phase2Task_BigPokeball(u8 taskId);
+static void Phase2Task_PokeballsTrail(u8 taskId);
+static void Phase2Task_Clockwise_BlackFade(u8 taskId);
+static void Phase2Task_Ripple(u8 taskId);
+static void Phase2Task_Wave(u8 taskId);
+static void Phase2Task_Slice(u8 taskId);
+static void Phase2Task_WhiteFade(u8 taskId);
+static void Phase2Task_GridSquares(u8 taskId);
+static void Phase2Task_Shards(u8 taskId);
+static void Phase2Task_Sydney(u8 taskId);
+static void Phase2Task_Phoebe(u8 taskId);
+static void Phase2Task_Glacia(u8 taskId);
+static void Phase2Task_Drake(u8 taskId);
+static void Phase2Task_Champion(u8 taskId);
+static void Phase2Task_Aqua(u8 taskId);
+static void Phase2Task_Magma(u8 taskId);
+static void Phase2Task_Regice(u8 taskId);
+static void Phase2Task_Registeel(u8 taskId);
+static void Phase2Task_Regirock(u8 taskId);
+static void Phase2Task_Kyogre(u8 taskId);
+static void Phase2Task_Groudon(u8 taskId);
+static void Phase2Task_Rayquaza(u8 taskId);
+static void Phase2Task_ShredSplit(u8 taskId);
+static void Phase2Task_Blackhole1(u8 taskId);
+static void Phase2Task_Blackhole2(u8 taskId);
+static void Phase2Task_RectangularSpiral(u8 taskId);
+static void Phase2Task_29(u8 taskId);
+static void Phase2Task_30(u8 taskId);
+static void Phase2Task_31(u8 taskId);
+static void Phase2Task_32(u8 taskId);
+static void Phase2Task_33(u8 taskId);
+static void VBlankCB_BattleTransition(void);
+static void VBlankCB_Phase2_Swirl(void);
+static void HBlankCB_Phase2_Swirl(void);
+static void VBlankCB_Phase2_Shuffle(void);
+static void HBlankCB_Phase2_Shuffle(void);
+static void VBlankCB0_Phase2_BigPokeball(void);
+static void VBlankCB1_Phase2_BigPokeball(void);
+static void VBlankCB_Phase2_Clockwise_BlackFade(void);
+static void VBlankCB_Phase2_Ripple(void);
+static void HBlankCB_Phase2_Ripple(void);
+static void VBlankCB_Phase2_30(void);
+static void HBlankCB_Phase2_30(void);
+static void VBlankCB_Phase2_Wave(void);
+static void VBlankCB_Phase2_Slice(void);
+static void HBlankCB_Phase2_Slice(void);
+static void VBlankCB0_Phase2_WhiteFade(void);
+static void VBlankCB1_Phase2_WhiteFade(void);
+static void HBlankCB_Phase2_WhiteFade(void);
+static void VBlankCB_Phase2_Shards(void);
+static void VBlankCB_Phase2_Rayquaza(void);
+static bool8 Phase2_Blur_Func1(struct Task *task);
+static bool8 Phase2_Blur_Func2(struct Task *task);
+static bool8 Phase2_Blur_Func3(struct Task *task);
+static bool8 Phase2_Swirl_Func1(struct Task *task);
+static bool8 Phase2_Swirl_Func2(struct Task *task);
+static bool8 Phase2_Shuffle_Func1(struct Task *task);
+static bool8 Phase2_Shuffle_Func2(struct Task *task);
+static bool8 Phase2_Aqua_Func1(struct Task *task);
+static bool8 Phase2_Aqua_Func2(struct Task *task);
+static bool8 Phase2_Magma_Func1(struct Task *task);
+static bool8 Phase2_Magma_Func2(struct Task *task);
+static bool8 Phase2_FramesCountdown(struct Task *task);
+static bool8 Phase2_Regi_Func1(struct Task *task);
+static bool8 Phase2_Regice_Func2(struct Task *task);
+static bool8 Phase2_Registeel_Func2(struct Task *task);
+static bool8 Phase2_Regirock_Func2(struct Task *task);
+static bool8 Phase2_WeatherTrio_Func1(struct Task *task);
+static bool8 Phase2_WaitPaletteFade(struct Task *task);
+static bool8 Phase2_Kyogre_Func3(struct Task *task);
+static bool8 Phase2_Kyogre_Func4(struct Task *task);
+static bool8 Phase2_Kyogre_Func5(struct Task *task);
+static bool8 Phase2_Groudon_Func3(struct Task *task);
+static bool8 Phase2_Groudon_Func4(struct Task *task);
+static bool8 Phase2_Groudon_Func5(struct Task *task);
+static bool8 Phase2_WeatherDuo_Func6(struct Task *task);
+static bool8 Phase2_WeatherDuo_Func7(struct Task *task);
+static bool8 Phase2_BigPokeball_Func1(struct Task *task);
+static bool8 Phase2_BigPokeball_Func2(struct Task *task);
+static bool8 Phase2_BigPokeball_Func3(struct Task *task);
+static bool8 Phase2_BigPokeball_Func4(struct Task *task);
+static bool8 Phase2_BigPokeball_Func5(struct Task *task);
+static bool8 Phase2_BigPokeball_Func6(struct Task *task);
+static bool8 Phase2_PokeballsTrail_Func1(struct Task *task);
+static bool8 Phase2_PokeballsTrail_Func2(struct Task *task);
+static bool8 Phase2_PokeballsTrail_Func3(struct Task *task);
+static bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task);
+static bool8 Phase2_Clockwise_BlackFade_Func2(struct Task *task);
+static bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task);
+static bool8 Phase2_Clockwise_BlackFade_Func4(struct Task *task);
+static bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task);
+static bool8 Phase2_Clockwise_BlackFade_Func6(struct Task *task);
+static bool8 Phase2_Clockwise_BlackFade_Func7(struct Task *task);
+static bool8 Phase2_Ripple_Func1(struct Task *task);
+static bool8 Phase2_Ripple_Func2(struct Task *task);
+static bool8 Phase2_Wave_Func1(struct Task *task);
+static bool8 Phase2_Wave_Func2(struct Task *task);
+static bool8 Phase2_Wave_Func3(struct Task *task);
+static bool8 Phase2_Slice_Func1(struct Task *task);
+static bool8 Phase2_Slice_Func2(struct Task *task);
+static bool8 Phase2_Slice_Func3(struct Task *task);
+static bool8 Phase2_WhiteFade_Func1(struct Task *task);
+static bool8 Phase2_WhiteFade_Func2(struct Task *task);
+static bool8 Phase2_WhiteFade_Func3(struct Task *task);
+static bool8 Phase2_WhiteFade_Func4(struct Task *task);
+static bool8 Phase2_WhiteFade_Func5(struct Task *task);
+static bool8 Phase2_GridSquares_Func1(struct Task *task);
+static bool8 Phase2_GridSquares_Func2(struct Task *task);
+static bool8 Phase2_GridSquares_Func3(struct Task *task);
+static bool8 Phase2_Shards_Func1(struct Task *task);
+static bool8 Phase2_Shards_Func2(struct Task *task);
+static bool8 Phase2_Shards_Func3(struct Task *task);
+static bool8 Phase2_Shards_Func4(struct Task *task);
+static bool8 Phase2_Shards_Func5(struct Task *task);
+static bool8 Phase2_ShredSplit_Func1(struct Task *task);
+static bool8 Phase2_ShredSplit_Func2(struct Task *task);
+static bool8 Phase2_ShredSplit_Func3(struct Task *task);
+static bool8 Phase2_ShredSplit_Func4(struct Task *task);
+static bool8 Phase2_Blackhole_Func1(struct Task *task);
+static bool8 Phase2_Blackhole1_Func2(struct Task *task);
+static bool8 Phase2_Blackhole1_Func3(struct Task *task);
+static bool8 Phase2_Blackhole2_Func2(struct Task *task);
+static bool8 Phase2_RectangularSpiral_Func1(struct Task *task);
+static bool8 Phase2_RectangularSpiral_Func2(struct Task *task);
+static bool8 Phase2_RectangularSpiral_Func3(struct Task *task);
+static bool8 Phase2_29_Func1(struct Task *task);
+static bool8 Phase2_29_Func2(struct Task *task);
+static bool8 Phase2_30_Func1(struct Task *task);
+static bool8 Phase2_30_Func2(struct Task *task);
+static bool8 Phase2_30_Func3(struct Task *task);
+static bool8 Phase2_30_Func4(struct Task *task);
+static bool8 Phase2_Rayquaza_Func3(struct Task *task);
+static bool8 Phase2_Rayquaza_Func4(struct Task *task);
+static bool8 Phase2_Rayquaza_Func5(struct Task *task);
+static bool8 Phase2_Rayquaza_Func6(struct Task *task);
+static bool8 Phase2_Rayquaza_Func7(struct Task *task);
+static bool8 Phase2_Rayquaza_Func8(struct Task *task);
+static bool8 Phase2_Rayquaza_Func9(struct Task *task);
+static bool8 Phase2_31_Func1(struct Task *task);
+static bool8 Phase2_31_Func2(struct Task *task);
+static bool8 Phase2_31_Func3(struct Task *task);
+static bool8 Phase2_31_33_Func5(struct Task *task);
+static bool8 Phase2_33_Func1(struct Task *task);
+static bool8 Phase2_33_Func2(struct Task *task);
+static bool8 Phase2_33_Func3(struct Task *task);
+static bool8 Phase2_33_Func4(struct Task *task);
+static bool8 Phase2_32_Func1(struct Task *task);
+static bool8 Phase2_32_Func2(struct Task *task);
+static bool8 Phase2_32_Func3(struct Task *task);
+static bool8 Phase2_32_Func4(struct Task *task);
+static bool8 Phase2_32_Func5(struct Task *task);
+static bool8 Phase2_Mugshot_Func1(struct Task *task);
+static bool8 Phase2_Mugshot_Func2(struct Task *task);
+static bool8 Phase2_Mugshot_Func3(struct Task *task);
+static bool8 Phase2_Mugshot_Func4(struct Task *task);
+static bool8 Phase2_Mugshot_Func5(struct Task *task);
+static bool8 Phase2_Mugshot_Func6(struct Task *task);
+static bool8 Phase2_Mugshot_Func7(struct Task *task);
+static bool8 Phase2_Mugshot_Func8(struct Task *task);
+static bool8 Phase2_Mugshot_Func9(struct Task *task);
+static bool8 Phase2_Mugshot_Func10(struct Task *task);
+static void Phase2Task_MugShotTransition(u8 taskId);
+static void Mugshots_CreateOpponentPlayerSprites(struct Task *task);
+static void VBlankCB0_Phase2_Mugshots(void);
+static void VBlankCB1_Phase2_Mugshots(void);
+static void HBlankCB_Phase2_Mugshots(void);
+static bool8 Transition_Phase1(struct Task *task);
+static bool8 Transition_WaitForPhase1(struct Task *task);
+static bool8 Transition_Phase2(struct Task *task);
+static bool8 Transition_WaitForPhase2(struct Task *task);
+static void sub_8149F08(void);
+static void sub_8149F84(void);
+static void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4);
+static void sub_814A014(u16 *a0, s16 a1, s16 a2, s16 a3);
+static void sub_8149F98(s16 *array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize);
+static void sub_8149F40(u16 **a0);
+static void sub_814A1AC(s16 *a0, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6);
+static bool8 sub_814A228(s16 *a0, bool8 a1, bool8 a2);
+static void sub_8148484(s16 spriteId, s16 value);
+static void sub_814849C(s16 spriteId);
+static s16 sub_81484B8(s16 spriteId);
+static bool8 Phase1_TransitionAll_Func1(struct Task *task);
+static bool8 Phase1_TransitionAll_Func2(struct Task *task);
+static bool8 IsPhase1Done(void);
+static bool16 sub_8149048(const s16 * const *arg0, struct StructRectangularSpiral *arg1);
+static void sub_814713C(struct Sprite *sprite);
+static void sub_8148380(struct Sprite *sprite);
+static void sub_8149864(struct Sprite *sprite);
+static bool8 sub_81483A8(struct Sprite *sprite);
+static bool8 sub_81483AC(struct Sprite *sprite);
+static bool8 sub_81483F8(struct Sprite *sprite);
+static bool8 sub_814842C(struct Sprite *sprite);
+static bool8 sub_8148458(struct Sprite *sprite);
+
+// iwram bss vars
+IWRAM_DATA static s16 sUnusedRectangularSpiralVar;
+IWRAM_DATA static u8 sTestingTransitionId;
+IWRAM_DATA static u8 sTestingTransitionState;
+IWRAM_DATA static struct StructRectangularSpiral sRectangularSpiralTransition[4];
+
+// ewram vars
+EWRAM_DATA static struct TransitionData *sTransitionStructPtr = NULL;
+
+// const rom data
+static const u32 sBigPokeball_Tileset[] = INCBIN_U32("graphics/battle_transitions/big_pokeball.4bpp");
+static const u32 sPokeballTrail_Tileset[] = INCBIN_U32("graphics/battle_transitions/pokeball_trail.4bpp");
+static const u8 sSpriteImage_85B98F0[] = INCBIN_U8("graphics/battle_transitions/pokeball.4bpp");
+static const u32 sUnknown_085B9AF0[] = INCBIN_U32("graphics/battle_transitions/elite_four_bg.4bpp");
+static const u8 sSpriteImage_85B9CD0[] = INCBIN_U8("graphics/battle_transitions/unused_brendan.4bpp");
+static const u8 sSpriteImage_85BA4D0[] = INCBIN_U8("graphics/battle_transitions/unused_lass.4bpp");
+static const u32 sShrinkingBoxTileset[] = INCBIN_U32("graphics/battle_transitions/shrinking_box.4bpp");
+static const u32 sEvilTeam_Palette[] = INCBIN_U32("graphics/battle_transitions/evil_team.gbapal");
+static const u32 sTeamAqua_Tileset[] = INCBIN_U32("graphics/battle_transitions/team_aqua.4bpp.lz");
+static const u32 sTeamAqua_Tilemap[] = INCBIN_U32("graphics/battle_transitions/team_aqua.bin.lz");
+static const u32 sTeamMagma_Tileset[] = INCBIN_U32("graphics/battle_transitions/team_magma.4bpp.lz");
+static const u32 sTeamMagma_Tilemap[] = INCBIN_U32("graphics/battle_transitions/team_magma.bin.lz");
+static const u32 gUnknown_085BBC14[] = INCBIN_U32("graphics/battle_transitions/85BBC14.4bpp");
+static const u32 gUnknown_085BC2B4[] = INCBIN_U32("graphics/battle_transitions/85BC2B4.gbapal");
+static const u32 gUnknown_085BC2D4[] = INCBIN_U32("graphics/battle_transitions/85BC2D4.gbapal");
+static const u32 gUnknown_085BC2F4[] = INCBIN_U32("graphics/battle_transitions/85BC2F4.gbapal");
+static const u32 gUnknown_085BC314[] = INCBIN_U32("graphics/battle_transitions/85BC314.bin");
+static const u32 gUnknown_085BCB14[] = INCBIN_U32("graphics/battle_transitions/85BCB14.bin");
+static const u32 gUnknown_085BD314[] = INCBIN_U32("graphics/battle_transitions/85BD314.bin");
+static const u16 gUnknown_085BDB14[] = INCBIN_U16("graphics/battle_transitions/85BDB14.gbapal");
+static const u32 gUnknown_085BDB34[] = INCBIN_U32("graphics/battle_transitions/kyogre.4bpp.lz");
+static const u32 gUnknown_085BE1E8[] = INCBIN_U32("graphics/battle_transitions/kyogre.bin.lz");
+static const u32 gUnknown_085BE51C[] = INCBIN_U32("graphics/battle_transitions/groudon.4bpp.lz");
+static const u32 gUnknown_085BEA88[] = INCBIN_U32("graphics/battle_transitions/groudon.bin.lz");
+static const u16 gUnknown_085BEDA0[] = INCBIN_U16("graphics/battle_transitions/kyogre_pt1.gbapal");
+static const u16 gUnknown_085BEEE0[] = INCBIN_U16("graphics/battle_transitions/kyogre_pt2.gbapal");
+static const u16 gUnknown_085BF0A0[] = INCBIN_U16("graphics/battle_transitions/groudon_pt1.gbapal");
+static const u16 gUnknown_085BF2A0[] = INCBIN_U16("graphics/battle_transitions/groudon_pt2.gbapal");
+static const u16 gUnknown_085BF4A0[] = INCBIN_U16("graphics/battle_transitions/rayquaza.gbapal");
+static const u32 gUnknown_085BF6A0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.4bpp");
+static const u32 gUnknown_085C6BE0[] = INCBIN_U32("graphics/battle_transitions/rayquaza.bin");
+static const u32 gUnknown_085C7BE0[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.gbapal");
+static const u32 gUnknown_085C7C00[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.4bpp.lz");
+static const u32 gUnknown_085C828C[] = INCBIN_U32("graphics/battle_transitions/frontier_brain.bin.lz");
+static const u32 gUnknown_085C8578[] = INCBIN_U32("graphics/battle_transitions/frontier_squares_blanktiles.gbapal");
+static const u32 gUnknown_085C8598[] = INCBIN_U32("graphics/battle_transitions/frontier_square_1.4bpp.lz");
+static const u32 gUnknown_085C86F4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_2.4bpp.lz");
+static const u32 gUnknown_085C87F4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_3.4bpp.lz");
+static const u32 gUnknown_085C88A4[] = INCBIN_U32("graphics/battle_transitions/frontier_square_4.4bpp.lz");
+static const u32 gUnknown_085C8928[] = INCBIN_U32("graphics/battle_transitions/frontier_squares.bin");
+
+static const TaskFunc sPhase1_Tasks[B_TRANSITION_COUNT] =
+{
+    [0 ... B_TRANSITION_COUNT - 1] = &Phase1Task_TransitionAll
+};
+
+static const TaskFunc sPhase2_Tasks[B_TRANSITION_COUNT] =
+{
+    Phase2Task_Blur,                        // 0
+    Phase2Task_Swirl,                       // 1
+    Phase2Task_Shuffle,                     // 2
+    Phase2Task_BigPokeball,                 // 3
+    Phase2Task_PokeballsTrail,              // 4
+    Phase2Task_Clockwise_BlackFade,         // 5
+    Phase2Task_Ripple,                      // 6
+    Phase2Task_Wave,                        // 7
+    Phase2Task_Slice,                       // 8
+    Phase2Task_WhiteFade,                   // 9
+    Phase2Task_GridSquares,                 // 10
+    Phase2Task_Shards,                      // 11
+    Phase2Task_Sydney,                      // 12
+    Phase2Task_Phoebe,                      // 13
+    Phase2Task_Glacia,                      // 14
+    Phase2Task_Drake,                       // 15
+    Phase2Task_Champion,                    // 16
+    Phase2Task_Aqua,                        // 17
+    Phase2Task_Magma,                       // 18
+    Phase2Task_Regice,                      // 19
+    Phase2Task_Registeel,                   // 20
+    Phase2Task_Regirock,                    // 21
+    Phase2Task_Kyogre,                      // 22
+    Phase2Task_Groudon,                     // 23
+    Phase2Task_Rayquaza,                    // 24
+    Phase2Task_ShredSplit,                  // 25
+    Phase2Task_Blackhole1,                  // 26
+    Phase2Task_Blackhole2,                  // 27
+    Phase2Task_RectangularSpiral,           // 28
+    Phase2Task_29,                          // 29
+    Phase2Task_30,                          // 30
+    Phase2Task_31,                          // 31
+    Phase2Task_32,                          // 32
+    Phase2Task_33,                          // 33
+    Phase2Task_34,                          // 34
+    Phase2Task_35,                          // 35
+    Phase2Task_36,                          // 36
+    Phase2Task_37,                          // 37
+    Phase2Task_38,                          // 38
+    Phase2Task_39,                          // 39
+    Phase2Task_40,                          // 40
+    Phase2Task_41,                          // 41
+};
+
+static const TransitionStateFunc sMainTransitionPhases[] =
+{
+    &Transition_Phase1,
+    &Transition_WaitForPhase1,
+    &Transition_Phase2,
+    &Transition_WaitForPhase2
+};
+
+static const TransitionStateFunc sPhase2_Blur_Funcs[] =
+{
+    Phase2_Blur_Func1,
+    Phase2_Blur_Func2,
+    Phase2_Blur_Func3
+};
+
+static const TransitionStateFunc sPhase2_Swirl_Funcs[] =
+{
+    Phase2_Swirl_Func1,
+    Phase2_Swirl_Func2,
+};
+
+static const TransitionStateFunc sPhase2_Shuffle_Funcs[] =
+{
+    Phase2_Shuffle_Func1,
+    Phase2_Shuffle_Func2,
+};
+
+static const TransitionStateFunc sPhase2_Aqua_Funcs[] =
+{
+    Phase2_Aqua_Func1,
+    Phase2_Aqua_Func2,
+    Phase2_BigPokeball_Func3,
+    Phase2_BigPokeball_Func4,
+    Phase2_BigPokeball_Func5,
+    Phase2_FramesCountdown,
+    Phase2_BigPokeball_Func6
+};
+
+static const TransitionStateFunc sPhase2_Magma_Funcs[] =
+{
+    Phase2_Magma_Func1,
+    Phase2_Magma_Func2,
+    Phase2_BigPokeball_Func3,
+    Phase2_BigPokeball_Func4,
+    Phase2_BigPokeball_Func5,
+    Phase2_FramesCountdown,
+    Phase2_BigPokeball_Func6
+};
+
+static const TransitionStateFunc sPhase2_BigPokeball_Funcs[] =
+{
+    Phase2_BigPokeball_Func1,
+    Phase2_BigPokeball_Func2,
+    Phase2_BigPokeball_Func3,
+    Phase2_BigPokeball_Func4,
+    Phase2_BigPokeball_Func5,
+    Phase2_BigPokeball_Func6
+};
+
+static const TransitionStateFunc sPhase2_Regice_Funcs[] =
+{
+    Phase2_Regi_Func1,
+    Phase2_Regice_Func2,
+    Phase2_BigPokeball_Func3,
+    Phase2_BigPokeball_Func4,
+    Phase2_BigPokeball_Func5,
+    Phase2_BigPokeball_Func6
+};
+
+static const TransitionStateFunc sPhase2_Registeel_Funcs[] =
+{
+    Phase2_Regi_Func1,
+    Phase2_Registeel_Func2,
+    Phase2_BigPokeball_Func3,
+    Phase2_BigPokeball_Func4,
+    Phase2_BigPokeball_Func5,
+    Phase2_BigPokeball_Func6
+};
+
+static const TransitionStateFunc sPhase2_Regirock_Funcs[] =
+{
+    Phase2_Regi_Func1,
+    Phase2_Regirock_Func2,
+    Phase2_BigPokeball_Func3,
+    Phase2_BigPokeball_Func4,
+    Phase2_BigPokeball_Func5,
+    Phase2_BigPokeball_Func6
+};
+
+static const TransitionStateFunc sPhase2_Kyogre_Funcs[] =
+{
+    Phase2_WeatherTrio_Func1,
+    Phase2_WaitPaletteFade,
+    Phase2_Kyogre_Func3,
+    Phase2_Kyogre_Func4,
+    Phase2_Kyogre_Func5,
+    Phase2_FramesCountdown,
+    Phase2_WeatherDuo_Func6,
+    Phase2_WeatherDuo_Func7
+};
+
+static const TransitionStateFunc sPhase2_PokeballsTrail_Funcs[] =
+{
+    Phase2_PokeballsTrail_Func1,
+    Phase2_PokeballsTrail_Func2,
+    Phase2_PokeballsTrail_Func3
+};
+
+static const s16 sUnknown_085C8B88[2] = {-16, 256};
+static const s16 sUnknown_085C8B8C[5] = {0, 32, 64, 18, 48};
+static const s16 sUnknown_085C8B96[2] = {8, -8};
+
+static const TransitionStateFunc sPhase2_Clockwise_BlackFade_Funcs[] =
+{
+    Phase2_Clockwise_BlackFade_Func1,
+    Phase2_Clockwise_BlackFade_Func2,
+    Phase2_Clockwise_BlackFade_Func3,
+    Phase2_Clockwise_BlackFade_Func4,
+    Phase2_Clockwise_BlackFade_Func5,
+    Phase2_Clockwise_BlackFade_Func6,
+    Phase2_Clockwise_BlackFade_Func7
+};
+
+static const TransitionStateFunc sPhase2_Ripple_Funcs[] =
+{
+    Phase2_Ripple_Func1,
+    Phase2_Ripple_Func2
+};
+
+static const TransitionStateFunc sPhase2_Wave_Funcs[] =
+{
+    Phase2_Wave_Func1,
+    Phase2_Wave_Func2,
+    Phase2_Wave_Func3
+};
+
+static const TransitionStateFunc sPhase2_Mugshot_Funcs[] =
+{
+    Phase2_Mugshot_Func1,
+    Phase2_Mugshot_Func2,
+    Phase2_Mugshot_Func3,
+    Phase2_Mugshot_Func4,
+    Phase2_Mugshot_Func5,
+    Phase2_Mugshot_Func6,
+    Phase2_Mugshot_Func7,
+    Phase2_Mugshot_Func8,
+    Phase2_Mugshot_Func9,
+    Phase2_Mugshot_Func10
+};
+
+static const u8 sMugshotsTrainerPicIDsTable[MUGSHOTS_COUNT] =
+{
+    TRAINER_PIC_ELITE_FOUR_SIDNEY,
+    TRAINER_PIC_ELITE_FOUR_PHOEBE,
+    TRAINER_PIC_ELITE_FOUR_GLACIA,
+    TRAINER_PIC_ELITE_FOUR_DRAKE,
+    TRAINER_PIC_CHAMPION_WALLACE
+};
+static const s16 sMugshotsOpponentRotationScales[MUGSHOTS_COUNT][2] =
+{
+    {0x200, 0x200},
+    {0x200, 0x200},
+    {0x1B0, 0x1B0},
+    {0x1A0, 0x1A0},
+    {0x188, 0x188},
+};
+static const s16 sMugshotsOpponentCoords[MUGSHOTS_COUNT][2] =
+{
+    {0,     0},
+    {0,     0},
+    {-4,    4},
+    {0,     5},
+    {-8,    7},
+};
+
+static const TransitionSpriteCallback sUnknown_085C8C24[] =
+{
+    sub_81483A8,
+    sub_81483AC,
+    sub_81483F8,
+    sub_814842C,
+    sub_81483A8,
+    sub_8148458,
+    sub_81483A8
+};
+
+static const s16 sUnknown_085C8C40[2] = {12, -12};
+static const s16 sUnknown_085C8C44[2] = {-1, 1};
+
+static const TransitionStateFunc sPhase2_Slice_Funcs[] =
+{
+    Phase2_Slice_Func1,
+    Phase2_Slice_Func2,
+    Phase2_Slice_Func3
+};
+
+static const TransitionStateFunc sPhase2_ShredSplit_Funcs[] =
+{
+    Phase2_ShredSplit_Func1,
+    Phase2_ShredSplit_Func2,
+    Phase2_ShredSplit_Func3,
+    Phase2_ShredSplit_Func4
+};
+
+static const u8 gUnknown_085C8C64[] = {39, 119};
+static const s16 gUnknown_085C8C66[] = {1, -1};
+
+static const TransitionStateFunc sPhase2_Blackhole1_Funcs[] =
+{
+    Phase2_Blackhole_Func1,
+    Phase2_Blackhole1_Func2,
+    Phase2_Blackhole1_Func3
+};
+
+static const TransitionStateFunc sPhase2_Blackhole2_Funcs[] =
+{
+    Phase2_Blackhole_Func1,
+    Phase2_Blackhole2_Func2
+};
+
+static const s16 gUnknown_085C8C80[] = {-6, 4};
+
+static const TransitionStateFunc sPhase2_RectangularSpiral_Funcs[] =
+{
+    Phase2_RectangularSpiral_Func1,
+    Phase2_RectangularSpiral_Func2,
+    Phase2_RectangularSpiral_Func3
+};
+
+static const s16 gUnknown_085C8C90[] = {1, 27, 275, -1};
+static const s16 gUnknown_085C8C98[] = {2, 486, -1};
+static const s16 gUnknown_085C8C9E[] = {3, 262, -1};
+static const s16 gUnknown_085C8CA4[] = {4, 507, -2};
+static const s16 gUnknown_085C8CAA[] = {1, 213, -1};
+static const s16 gUnknown_085C8CB0[] = {2, 548, -2};
+static const s16 gUnknown_085C8CB6[] = {3, 196, -1};
+static const s16 gUnknown_085C8CBC[] = {4, 573, 309, -1};
+static const s16 gUnknown_085C8CC4[] = {1, 474, -1};
+static const s16 gUnknown_085C8CCA[] = {2, 295, 32, -1};
+static const s16 gUnknown_085C8CD2[] = {3, 58, -1};
+static const s16 gUnknown_085C8CD8[] = {4, 455, -1};
+static const s16 gUnknown_085C8CDE[] = {1, 540, -1};
+static const s16 gUnknown_085C8CE4[] = {2, 229, -1};
+static const s16 gUnknown_085C8CEA[] = {3, 244, 28, -1};
+static const s16 gUnknown_085C8CF2[] = {4, 517, -1};
+
+static const s16 *const gUnknown_085C8CF8[] =
+{
+	gUnknown_085C8C90,
+	gUnknown_085C8CA4,
+	gUnknown_085C8C98,
+	gUnknown_085C8C9E,
+	gUnknown_085C8CEA,
+	gUnknown_085C8CE4,
+	gUnknown_085C8CF2,
+	gUnknown_085C8CDE
+};
+
+static const s16 *const gUnknown_085C8D18[] =
+{
+	gUnknown_085C8CBC,
+	gUnknown_085C8CB0,
+	gUnknown_085C8CB6,
+	gUnknown_085C8CAA,
+	gUnknown_085C8CCA,
+	gUnknown_085C8CD8,
+	gUnknown_085C8CC4,
+	gUnknown_085C8CD2
+};
+
+static const s16 *const *const gUnknown_085C8D38[] =
+{
+	gUnknown_085C8CF8,
+	gUnknown_085C8D18
+};
+
+static const TransitionStateFunc sPhase2_Groudon_Funcs[] =
+{
+    Phase2_WeatherTrio_Func1,
+    Phase2_WaitPaletteFade,
+    Phase2_Groudon_Func3,
+    Phase2_Groudon_Func4,
+    Phase2_Groudon_Func5,
+    Phase2_FramesCountdown,
+    Phase2_WeatherDuo_Func6,
+    Phase2_WeatherDuo_Func7
+};
+
+static const TransitionStateFunc sPhase2_Rayquaza_Funcs[] =
+{
+    Phase2_WeatherTrio_Func1,
+    Phase2_WaitPaletteFade,
+    Phase2_Rayquaza_Func3,
+    Phase2_Rayquaza_Func4,
+    Phase2_Rayquaza_Func5,
+    Phase2_Rayquaza_Func6,
+    Phase2_Rayquaza_Func7,
+    Phase2_Rayquaza_Func8,
+    Phase2_Rayquaza_Func9,
+    Phase2_Blackhole1_Func2,
+    Phase2_Blackhole1_Func3
+};
+
+static const TransitionStateFunc sPhase2_WhiteFade_Funcs[] =
+{
+    Phase2_WhiteFade_Func1,
+    Phase2_WhiteFade_Func2,
+    Phase2_WhiteFade_Func3,
+    Phase2_WhiteFade_Func4,
+    Phase2_WhiteFade_Func5
+};
+
+static const s16 sUnknown_085C8DA0[] = {0, 20, 15, 40, 10, 25, 35, 5};
+
+static const TransitionStateFunc sPhase2_GridSquares_Funcs[] =
+{
+    Phase2_GridSquares_Func1,
+    Phase2_GridSquares_Func2,
+    Phase2_GridSquares_Func3
+};
+
+static const TransitionStateFunc sPhase2_Shards_Funcs[] =
+{
+    Phase2_Shards_Func1,
+    Phase2_Shards_Func2,
+    Phase2_Shards_Func3,
+    Phase2_Shards_Func4,
+    Phase2_Shards_Func5
+};
+
+static const s16 sUnknown_085C8DD0[][5] =
+{
+    {56,    0,      0,      160,    0},
+    {104,   160,    240,    88,     1},
+    {240,   72,     56,     0,      1},
+    {0,     32,     144,    160,    0},
+    {144,   160,    184,    0,      1},
+    {56,    0,      168,    160,    0},
+    {168,   160,    48,     0,      1},
+};
+
+static const s16 sUnknown_085C8E16[] = {8, 4, 2, 1, 1, 1, 0};
+
+static const TransitionStateFunc sPhase1_TransitionAll_Funcs[] =
+{
+    Phase1_TransitionAll_Func1,
+    Phase1_TransitionAll_Func2
+};
+
+static const struct SpriteFrameImage sSpriteImageTable_85C8E2C[] =
+{
+    sSpriteImage_85B98F0, 0x200
+};
+
+static const union AnimCmd sSpriteAnim_85C8E34[] =
+{
+    ANIMCMD_FRAME(0, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sSpriteAnimTable_85C8E3C[] =
+{
+    sSpriteAnim_85C8E34
+};
+
+static const union AffineAnimCmd sSpriteAffineAnim_85C8E40[] =
+{
+    AFFINEANIMCMD_FRAME(0, 0, -4, 1),
+    AFFINEANIMCMD_JUMP(0)
+};
+
+static const union AffineAnimCmd sSpriteAffineAnim_85C8E50[] =
+{
+    AFFINEANIMCMD_FRAME(0, 0, 4, 1),
+    AFFINEANIMCMD_JUMP(0)
+};
+
+static const union AffineAnimCmd *const sSpriteAffineAnimTable_85C8E60[] =
+{
+    sSpriteAffineAnim_85C8E40,
+    sSpriteAffineAnim_85C8E50
+};
+
+static const struct SpriteTemplate gUnknown_085C8E68 =
+{
+    .tileTag = 0xFFFF,
+    .paletteTag = 4105,
+    .oam = &gFieldObjectBaseOam_32x32,
+    .anims = sSpriteAnimTable_85C8E3C,
+    .images = sSpriteImageTable_85C8E2C,
+    .affineAnims = sSpriteAffineAnimTable_85C8E60,
+    .callback = sub_814713C
+};
+
+static const struct OamData gOamData_85C8E80 =
+{
+    .y = 0,
+    .affineMode = 0,
+    .objMode = 0,
+    .mosaic = 0,
+    .bpp = 0,
+    .shape = 0,
+    .x = 0,
+    .matrixNum = 0,
+    .size = 3,
+    .tileNum = 0,
+    .priority = 0,
+    .paletteNum = 0,
+    .affineParam = 0,
+};
+
+static const struct SpriteFrameImage sSpriteImageTable_85C8E88[] =
+{
+    sSpriteImage_85B9CD0, 0x800
+};
+
+static const struct SpriteFrameImage sSpriteImageTable_85C8E90[] =
+{
+    sSpriteImage_85BA4D0, 0x800
+};
+
+static const union AnimCmd sSpriteAnim_85C8E98[] =
+{
+    ANIMCMD_FRAME(0, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sSpriteAnimTable_85C8EA0[] =
+{
+    sSpriteAnim_85C8E98
+};
+
+static const struct SpriteTemplate sSpriteTemplate_85C8EA4 =
+{
+    .tileTag = 0xFFFF,
+    .paletteTag = 4106,
+    .oam = &gOamData_85C8E80,
+    .anims = sSpriteAnimTable_85C8EA0,
+    .images = sSpriteImageTable_85C8E88,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = sub_8148380
+};
+
+static const struct SpriteTemplate sSpriteTemplate_85C8EBC =
+{
+    .tileTag = 0xFFFF,
+    .paletteTag = 4106,
+    .oam = &gOamData_85C8E80,
+    .anims = sSpriteAnimTable_85C8EA0,
+    .images = sSpriteImageTable_85C8E90,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = sub_8148380
+};
+
+static const u16 gFieldEffectObjectPalette10[] = INCBIN_U16("graphics/map_objects/palettes/field_effect_object_palette_10.gbapal");
+
+const struct SpritePalette gFieldEffectObjectPaletteInfo10 =
+{
+    gFieldEffectObjectPalette10, 0x1009
+};
+
+static const u16 sMugshotPal_Sydney[] = INCBIN_U16("graphics/battle_transitions/sidney_bg.gbapal");
+static const u16 sMugshotPal_Phoebe[] = INCBIN_U16("graphics/battle_transitions/phoebe_bg.gbapal");
+static const u16 sMugshotPal_Glacia[] = INCBIN_U16("graphics/battle_transitions/glacia_bg.gbapal");
+static const u16 sMugshotPal_Drake[] = INCBIN_U16("graphics/battle_transitions/drake_bg.gbapal");
+static const u16 sMugshotPal_Champion[] = INCBIN_U16("graphics/battle_transitions/wallace_bg.gbapal");
+static const u16 sMugshotPal_Brendan[] = INCBIN_U16("graphics/battle_transitions/brendan_bg.gbapal");
+static const u16 sMugshotPal_May[] = INCBIN_U16("graphics/battle_transitions/may_bg.gbapal");
+
+static const u16 *const sOpponentMugshotsPals[MUGSHOTS_COUNT] =
+{
+    sMugshotPal_Sydney,
+    sMugshotPal_Phoebe,
+    sMugshotPal_Glacia,
+    sMugshotPal_Drake,
+    sMugshotPal_Champion
+};
+
+static const u16 *const sPlayerMugshotsPals[2] =
+{
+    sMugshotPal_Brendan,
+    sMugshotPal_May
+};
+
+static const u16 sUnusedTrainerPalette[] = INCBIN_U16("graphics/battle_transitions/unused_trainer.gbapal");
+static const struct SpritePalette sSpritePalette_UnusedTrainer =
+{
+    sUnusedTrainerPalette, 0x100A
+};
+
+static const u16 sBigPokeball_Tilemap[] = INCBIN_U16("graphics/battle_transitions/big_pokeball_map.bin");
+static const u16 sMugshotsTilemap[] = INCBIN_U16("graphics/battle_transitions/elite_four_bg_map.bin");
+
+static const TransitionStateFunc sPhase2_29_Funcs[] =
+{
+    Phase2_29_Func1,
+    Phase2_29_Func2,
+    Phase2_BigPokeball_Func3,
+    Phase2_BigPokeball_Func4,
+    Phase2_BigPokeball_Func5,
+    Phase2_BigPokeball_Func6
+};
+
+static const TransitionStateFunc sPhase2_30_Funcs[] =
+{
+    Phase2_30_Func1,
+    Phase2_30_Func2,
+    Phase2_30_Func3,
+    Phase2_30_Func4
+};
+
+static const TransitionStateFunc sPhase2_31_Funcs[] =
+{
+    Phase2_31_Func1,
+    Phase2_31_Func2,
+    Phase2_31_Func3,
+    Phase2_31_33_Func5
+};
+
+static const TransitionStateFunc sPhase2_33_Funcs[] =
+{
+    Phase2_33_Func1,
+    Phase2_33_Func2,
+    Phase2_33_Func3,
+    Phase2_33_Func4,
+    Phase2_31_33_Func5
+};
+
+static const TransitionStateFunc sPhase2_32_Funcs[] =
+{
+    Phase2_32_Func1,
+    Phase2_32_Func2,
+    Phase2_32_Func3,
+    Phase2_32_Func4,
+    Phase2_32_Func5
+};
+
+static const u8 gUnknown_085C9A30[] = {0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x1b, 0x14, 0x0d, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x07, 0x0e, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x13, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x0f, 0x10, 0x11, 0x12};
+static const u8 gUnknown_085C9A53[] = {0x00, 0x10, 0x29, 0x16, 0x2c, 0x02, 0x2b, 0x15, 0x2e, 0x1b, 0x09, 0x30, 0x26, 0x05, 0x39, 0x3b, 0x0c, 0x3f, 0x23, 0x1c, 0x0a, 0x35, 0x07, 0x31, 0x27, 0x17, 0x37, 0x01, 0x3e, 0x11, 0x3d, 0x1e, 0x06, 0x22, 0x0f, 0x33, 0x20, 0x3a, 0x0d, 0x2d, 0x25, 0x34, 0x0b, 0x18, 0x3c, 0x13, 0x38, 0x21, 0x1d, 0x32, 0x28, 0x36, 0x0e, 0x03, 0x2f, 0x14, 0x12, 0x19, 0x04, 0x24, 0x1a, 0x2a, 0x1f, 0x08, 0x00};
+
+// code
+static void CB2_TestBattleTransition(void)
+{
+    switch (sTestingTransitionState)
+    {
+    case 0:
+        LaunchBattleTransitionTask(sTestingTransitionId);
+        sTestingTransitionState++;
+        break;
+    case 1:
+        if (IsBattleTransitionDone())
+        {
+            sTestingTransitionState = 0;
+            SetMainCallback2(c2_exit_to_overworld_2_switch);
+        }
+        break;
+    }
+
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+void TestBattleTransition(u8 transitionId)
+{
+    sTestingTransitionId = transitionId;
+    SetMainCallback2(CB2_TestBattleTransition);
+}
+
+void BattleTransition_StartOnField(u8 transitionId)
+{
+    gMain.callback2 = CB2_OverworldBasic;
+    LaunchBattleTransitionTask(transitionId);
+}
+
+void BattleTransition_Start(u8 transitionId)
+{
+    LaunchBattleTransitionTask(transitionId);
+}
+
+// in all tasks data[0] is reserved for the state
+#define tState          data[0]
+
+// main task that launches sub-tasks for phase1 and phase2
+#define tTransitionId   data[1]
+#define tTransitionDone data[15]
+
+bool8 IsBattleTransitionDone(void)
+{
+    u8 taskId = FindTaskIdByFunc(Task_BattleTransitionMain);
+    if (gTasks[taskId].tTransitionDone)
+    {
+        DestroyTask(taskId);
+        FREE_AND_SET_NULL(sTransitionStructPtr);
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+
+static void LaunchBattleTransitionTask(u8 transitionId)
+{
+    u8 taskId = CreateTask(Task_BattleTransitionMain, 2);
+    gTasks[taskId].tTransitionId = transitionId;
+    sTransitionStructPtr = AllocZeroed(sizeof(*sTransitionStructPtr));
+}
+
+static void Task_BattleTransitionMain(u8 taskId)
+{
+    while (sMainTransitionPhases[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Transition_Phase1(struct Task *task)
+{
+    sub_80AC3D0();
+    CpuCopy32(gPlttBufferFaded, gPlttBufferUnfaded, 0x400);
+    if (sPhase1_Tasks[task->tTransitionId] != NULL)
+    {
+        CreateTask(sPhase1_Tasks[task->tTransitionId], 4);
+        task->tState++;
+        return FALSE;
+    }
+    else
+    {
+        task->tState = 2;
+        return TRUE;
+    }
+}
+
+static bool8 Transition_WaitForPhase1(struct Task *task)
+{
+    if (FindTaskIdByFunc(sPhase1_Tasks[task->tTransitionId]) == 0xFF)
+    {
+        task->tState++;
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+
+static bool8 Transition_Phase2(struct Task *task)
+{
+    CreateTask(sPhase2_Tasks[task->tTransitionId], 0);
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Transition_WaitForPhase2(struct Task *task)
+{
+    task->tTransitionDone = FALSE;
+    if (FindTaskIdByFunc(sPhase2_Tasks[task->tTransitionId]) == 0xFF)
+        task->tTransitionDone = TRUE;
+    return FALSE;
+}
+
+#undef tTransitionId
+#undef tTransitionDone
+
+static void Phase1Task_TransitionAll(u8 taskId)
+{
+    if (gTasks[taskId].tState == 0)
+    {
+        gTasks[taskId].tState++;
+        CreatePhase1Task(0, 0, 3, 2, 2); // creates a sub-task for this sub-task
+    }
+    else if (IsPhase1Done())
+    {
+        DestroyTask(taskId);
+    }
+}
+
+// sub-task for phase2
+#define tData1              data[1]
+#define tData2              data[2]
+#define tData3              data[3]
+#define tData4              data[4]
+#define tData5              data[5]
+#define tData6              data[6]
+#define tFuncState          data[7]
+#define tFrames             data[8]
+#define tOpponentSpriteId   data[13]
+#define tPlayerSpriteId     data[14]
+#define tMugshotId          data[15]
+
+static void Phase2Task_Blur(u8 taskId)
+{
+    while (sPhase2_Blur_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Blur_Func1(struct Task *task)
+{
+    SetGpuReg(REG_OFFSET_MOSAIC, 0);
+    SetGpuRegBits(REG_OFFSET_BG1CNT, BGCNT_MOSAIC);
+    SetGpuRegBits(REG_OFFSET_BG2CNT, BGCNT_MOSAIC);
+    SetGpuRegBits(REG_OFFSET_BG3CNT, BGCNT_MOSAIC);
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_Blur_Func2(struct Task *task)
+{
+    if (task->tData1 != 0)
+    {
+        task->tData1--;
+    }
+    else
+    {
+        task->tData1 = 4;
+        if (++task->tData2 == 10)
+            BeginNormalPaletteFade(-1, -1, 0, 0x10, 0);
+        SetGpuReg(REG_OFFSET_MOSAIC, (task->tData2 & 15) * 17);
+        if (task->tData2 > 14)
+            task->tState++;
+    }
+    return FALSE;
+}
+
+static bool8 Phase2_Blur_Func3(struct Task *task)
+{
+    if (!gPaletteFade.active)
+    {
+        u8 taskId = FindTaskIdByFunc(Phase2Task_Blur);
+        DestroyTask(taskId);
+    }
+    return FALSE;
+}
+
+static void Phase2Task_Swirl(u8 taskId)
+{
+    while (sPhase2_Swirl_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Swirl_Func1(struct Task *task)
+{
+    sub_8149F08();
+    dp12_8087EA4();
+    BeginNormalPaletteFade(-1, 4, 0, 0x10, 0);
+    sub_8149F98(gUnknown_020393A8, sTransitionStructPtr->field_14, 0, 2, 0, 160);
+
+    SetVBlankCallback(VBlankCB_Phase2_Swirl);
+    SetHBlankCallback(HBlankCB_Phase2_Swirl);
+
+    EnableInterrupts(INTR_FLAG_VBLANK | INTR_FLAG_HBLANK);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Swirl_Func2(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    task->tData1 += 4;
+    task->tData2 += 8;
+
+    sub_8149F98(gUnknown_02038C28[0], sTransitionStructPtr->field_14, task->tData1, 2, task->tData2, 160);
+
+    if (!gPaletteFade.active)
+    {
+        u8 taskId = FindTaskIdByFunc(Phase2Task_Swirl);
+        DestroyTask(taskId);
+    }
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static void VBlankCB_Phase2_Swirl(void)
+{
+    VBlankCB_BattleTransition();
+    if (sTransitionStructPtr->VBlank_DMA)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+}
+
+static void HBlankCB_Phase2_Swirl(void)
+{
+    u16 var = gUnknown_02038C28[1][REG_VCOUNT];
+    REG_BG1HOFS = var;
+    REG_BG2HOFS = var;
+    REG_BG3HOFS = var;
+}
+
+static void Phase2Task_Shuffle(u8 taskId)
+{
+    while (sPhase2_Shuffle_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Shuffle_Func1(struct Task *task)
+{
+    sub_8149F08();
+    dp12_8087EA4();
+
+    BeginNormalPaletteFade(-1, 4, 0, 0x10, 0);
+    memset(gUnknown_020393A8, sTransitionStructPtr->field_16, 0x140);
+
+    SetVBlankCallback(VBlankCB_Phase2_Shuffle);
+    SetHBlankCallback(HBlankCB_Phase2_Shuffle);
+
+    EnableInterrupts(INTR_FLAG_VBLANK | INTR_FLAG_HBLANK);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Shuffle_Func2(struct Task *task)
+{
+    u8 i;
+    u16 r3, r4;
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    r4 = task->tData1;
+    r3 = task->tData2 >> 8;
+    task->tData1 += 4224;
+    task->tData2 += 384;
+
+    for (i = 0; i < 160; i++, r4 += 4224)
+    {
+        u16 var = r4 / 256;
+        gUnknown_02038C28[0][i] = sTransitionStructPtr->field_16 + Sin(var, r3);
+    }
+
+    if (!gPaletteFade.active)
+        DestroyTask(FindTaskIdByFunc(Phase2Task_Shuffle));
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static void VBlankCB_Phase2_Shuffle(void)
+{
+    VBlankCB_BattleTransition();
+    if (sTransitionStructPtr->VBlank_DMA)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+}
+
+static void HBlankCB_Phase2_Shuffle(void)
+{
+    u16 var = gUnknown_02038C28[1][REG_VCOUNT];
+    REG_BG1VOFS = var;
+    REG_BG2VOFS = var;
+    REG_BG3VOFS = var;
+}
+
+static void Phase2Task_BigPokeball(u8 taskId)
+{
+    while (sPhase2_BigPokeball_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static void Phase2Task_Aqua(u8 taskId)
+{
+    while (sPhase2_Aqua_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static void Phase2Task_Magma(u8 taskId)
+{
+    while (sPhase2_Magma_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static void Phase2Task_Regice(u8 taskId)
+{
+    while (sPhase2_Regice_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static void Phase2Task_Registeel(u8 taskId)
+{
+    while (sPhase2_Registeel_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static void Phase2Task_Regirock(u8 taskId)
+{
+    while (sPhase2_Regirock_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static void Phase2Task_Kyogre(u8 taskId)
+{
+    while (sPhase2_Kyogre_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static void sub_814669C(struct Task *task)
+{
+    s32 i;
+
+    sub_8149F08();
+    dp12_8087EA4();
+
+    task->tData1 = 16;
+    task->tData2 = 0;
+    task->tData4 = 0;
+    task->tData5 = 0x4000;
+    sTransitionStructPtr->WININ = 63;
+    sTransitionStructPtr->WINOUT = 0;
+    sTransitionStructPtr->WIN0H = 240;
+    sTransitionStructPtr->WIN0V = 160;
+    sTransitionStructPtr->BLDCNT = 0x3F41;
+    sTransitionStructPtr->BLDALPHA = (task->tData1 << 8) | (task->tData2);
+
+    for (i = 0; i < 160; i++)
+    {
+        gUnknown_02038C28[1][i] = 240;
+    }
+
+    SetVBlankCallback(VBlankCB0_Phase2_BigPokeball);
+}
+
+static bool8 Phase2_Aqua_Func1(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    task->tFrames = 60;
+    sub_814669C(task);
+    sub_8149F58(&dst1, &dst2);
+    CpuFill16(0, dst1, 0x800);
+    LZ77UnCompVram(sTeamAqua_Tileset, dst2);
+    LoadPalette(sEvilTeam_Palette, 0xF0, 0x20);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Magma_Func1(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    task->tFrames = 60;
+    sub_814669C(task);
+    sub_8149F58(&dst1, &dst2);
+    CpuFill16(0, dst1, 0x800);
+    LZ77UnCompVram(sTeamMagma_Tileset, dst2);
+    LoadPalette(sEvilTeam_Palette, 0xF0, 0x20);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Regi_Func1(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    task->tFrames = 60;
+    sub_814669C(task);
+    sub_8149F58(&dst1, &dst2);
+    CpuFill16(0, dst1, 0x800);
+    CpuCopy16(gUnknown_085BBC14, dst2, 0x2000);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_BigPokeball_Func1(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_814669C(task);
+    sub_8149F58(&dst1, &dst2);
+    CpuFill16(0, dst1, 0x800);
+    CpuCopy16(sBigPokeball_Tileset, dst2, 0x580);
+    LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_BigPokeball_Func2(struct Task *task)
+{
+    s16 i, j;
+    u16 *dst1, *dst2;
+    const u16 *BigPokeballMap;
+
+    sub_8149F58(&dst1, &dst2);
+    BigPokeballMap = sBigPokeball_Tilemap;
+    for (i = 0; i < 20; i++)
+    {
+        for (j = 0; j < 30; j++, BigPokeballMap++)
+        {
+            dst1[i * 32 + j] = *BigPokeballMap | 0xF000;
+        }
+    }
+    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_Aqua_Func2(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    LZ77UnCompVram(sTeamAqua_Tilemap, dst1);
+    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Magma_Func2(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    LZ77UnCompVram(sTeamMagma_Tilemap, dst1);
+    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Regice_Func2(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    LoadPalette(gUnknown_085BC2B4, 0xF0, 0x20);
+    CpuCopy16(gUnknown_085BC314, dst1, 0x500);
+    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Registeel_Func2(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    LoadPalette(gUnknown_085BC2D4, 0xF0, 0x20);
+    CpuCopy16(gUnknown_085BCB14, dst1, 0x500);
+    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Regirock_Func2(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    LoadPalette(gUnknown_085BC2F4, 0xF0, 0x20);
+    CpuCopy16(gUnknown_085BD314, dst1, 0x500);
+    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5, 160);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Kyogre_Func3(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    CpuFill16(0, dst1, 0x800);
+    LZ77UnCompVram(gUnknown_085BDB34, dst2);
+    LZ77UnCompVram(gUnknown_085BE1E8, dst1);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Kyogre_Func4(struct Task *task)
+{
+    if (task->tData1 % 3 == 0)
+    {
+        u16 var = task->tData1 % 30;
+        var /= 3;
+        LoadPalette(gUnknown_085BEDA0 + (var * 16), 0xF0, 0x20);
+    }
+    if (++task->tData1 > 58)
+    {
+        task->tState++;
+        task->tData1 = 0;
+    }
+
+    return FALSE;
+}
+
+static bool8 Phase2_Kyogre_Func5(struct Task *task)
+{
+    if (task->tData1 % 5 == 0)
+    {
+        s16 var = task->tData1 / 5;
+        LoadPalette(gUnknown_085BEEE0 + (var * 16), 0xF0, 0x20);
+    }
+    if (++task->tData1 > 68)
+    {
+        task->tState++;
+        task->tData1 = 0;
+        task->tFrames = 30;
+    }
+
+    return FALSE;
+}
+
+static bool8 Phase2_WeatherDuo_Func6(struct Task *task)
+{
+    BeginNormalPaletteFade(0xFFFF8000, 1, 0, 0x10, 0);
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_WeatherDuo_Func7(struct Task *task)
+{
+    if (!gPaletteFade.active)
+    {
+        DmaStop(0);
+        sub_8149F84();
+        DestroyTask(FindTaskIdByFunc(task->func));
+    }
+    return FALSE;
+}
+
+static bool8 Phase2_BigPokeball_Func3(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    if (task->tData3 == 0 || --task->tData3 == 0)
+    {
+        task->tData2++;
+        task->tData3 = 2;
+    }
+    sTransitionStructPtr->BLDALPHA = (task->tData1 << 8) | task->tData2;
+    if (task->tData2 > 15)
+        task->tState++;
+    task->tData4 += 8;
+    task->tData5 -= 256;
+
+    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5 >> 8, 160);
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_BigPokeball_Func4(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    if (task->tData3 == 0 || --task->tData3 == 0)
+    {
+        task->tData1--;
+        task->tData3 = 2;
+    }
+    sTransitionStructPtr->BLDALPHA = (task->tData1 << 8) | task->tData2;
+    if (task->tData1 == 0)
+        task->tState++;
+    task->tData4 += 8;
+    task->tData5 -= 256;
+
+    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5 >> 8, 160);
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_BigPokeball_Func5(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    task->tData4 += 8;
+    task->tData5 -= 256;
+
+    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 132, task->tData5 >> 8, 160);
+
+    if (task->tData5 <= 0)
+    {
+        task->tState++;
+        task->tData1 = 160;
+        task->tData2 = 256;
+        task->tData3 = 0;
+    }
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_FramesCountdown(struct Task *task)
+{
+    if (--task->tFrames == 0)
+        task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_WeatherTrio_Func1(struct Task *task)
+{
+    BeginNormalPaletteFade(0x0000FFFF, 1, 0, 0x10, 0);
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_WaitPaletteFade(struct Task *task)
+{
+    if (!gPaletteFade.active)
+        task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_BigPokeball_Func6(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    if (task->tData2 < 1024)
+        task->tData2 += 128;
+    if (task->tData1 != 0)
+    {
+        task->tData1 -= (task->tData2 >> 8);
+        if (task->tData1 < 0)
+            task->tData1 = 0;
+    }
+    sub_814A014(gUnknown_02038C28[0], 120, 80, task->tData1);
+    if (task->tData1 == 0)
+    {
+        SetVBlankCallback(NULL);
+        DmaStop(0);
+        sub_8149F84();
+        DestroyTask(FindTaskIdByFunc(task->func));
+    }
+    else
+    {
+        if (task->tData3 == 0)
+        {
+            task->tData3++;
+            SetVBlankCallback(VBlankCB1_Phase2_BigPokeball);
+        }
+
+        sTransitionStructPtr->VBlank_DMA++;
+    }
+
+    return FALSE;
+}
+
+static void Transition_BigPokeball_Vblank(void)
+{
+    DmaStop(0);
+    VBlankCB_BattleTransition();
+    if (sTransitionStructPtr->VBlank_DMA)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+    REG_WININ = sTransitionStructPtr->WININ;
+    REG_WINOUT = sTransitionStructPtr->WINOUT;
+    REG_WIN0V = sTransitionStructPtr->WIN0V;
+    REG_BLDCNT = sTransitionStructPtr->BLDCNT;
+    REG_BLDALPHA = sTransitionStructPtr->BLDALPHA;
+}
+
+static void VBlankCB0_Phase2_BigPokeball(void)
+{
+    Transition_BigPokeball_Vblank();
+    DmaSet(0, gUnknown_020393A8, &REG_BG0HOFS, 0xA2400001);
+}
+
+static void VBlankCB1_Phase2_BigPokeball(void)
+{
+    Transition_BigPokeball_Vblank();
+    DmaSet(0, gUnknown_020393A8, &REG_WIN0H, 0xA2400001);
+}
+
+static void Phase2Task_PokeballsTrail(u8 taskId)
+{
+    while (sPhase2_PokeballsTrail_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_PokeballsTrail_Func1(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    CpuSet(sPokeballTrail_Tileset, dst2, 0x20);
+    CpuFill32(0, dst1, 0x800);
+    LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_PokeballsTrail_Func2(struct Task *task)
+{
+    s16 i;
+    s16 rand;
+    s16 arr0[ARRAY_COUNT(sUnknown_085C8B88)];
+    s16 arr1[ARRAY_COUNT(sUnknown_085C8B8C)];
+
+    memcpy(arr0, sUnknown_085C8B88, sizeof(sUnknown_085C8B88));
+    memcpy(arr1, sUnknown_085C8B8C, sizeof(sUnknown_085C8B8C));
+    rand = Random() & 1;
+    for (i = 0; i <= 4; i++, rand ^= 1)
+    {
+        gFieldEffectArguments[0] = arr0[rand];      // x
+        gFieldEffectArguments[1] = (i * 32) + 16;   // y
+        gFieldEffectArguments[2] = rand;
+        gFieldEffectArguments[3] = arr1[i];
+        FieldEffectStart(FLDEFF_POKEBALL);
+    }
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_PokeballsTrail_Func3(struct Task *task)
+{
+    if (!FieldEffectActiveListContains(FLDEFF_POKEBALL))
+    {
+        sub_8149F84();
+        DestroyTask(FindTaskIdByFunc(Phase2Task_PokeballsTrail));
+    }
+    return FALSE;
+}
+
+bool8 FldEff_Pokeball(void)
+{
+    u8 spriteId = CreateSpriteAtEnd(&gUnknown_085C8E68, gFieldEffectArguments[0], gFieldEffectArguments[1], 0);
+    gSprites[spriteId].oam.priority = 0;
+    gSprites[spriteId].oam.affineMode = 1;
+    gSprites[spriteId].data[0] = gFieldEffectArguments[2];
+    gSprites[spriteId].data[1] = gFieldEffectArguments[3];
+    gSprites[spriteId].data[2] = -1;
+    InitSpriteAffineAnim(&gSprites[spriteId]);
+    StartSpriteAffineAnim(&gSprites[spriteId], gFieldEffectArguments[2]);
+    return FALSE;
+}
+
+#define SOME_VRAM_STORE(ptr, posY, posX, toStore)                       \
+{                                                                       \
+    u32 index = (posY) * 32 + posX;                                     \
+    ptr[index] = toStore;                                               \
+}
+
+static void sub_814713C(struct Sprite *sprite)
+{
+    s16 arr0[ARRAY_COUNT(sUnknown_085C8B96)];
+
+    memcpy(arr0, sUnknown_085C8B96, sizeof(sUnknown_085C8B96));
+    if (sprite->data[1] != 0)
+    {
+        sprite->data[1]--;
+    }
+    else
+    {
+        if (sprite->pos1.x >= 0 && sprite->pos1.x <= 240)
+        {
+            s16 posX = sprite->pos1.x >> 3;
+            s16 posY = sprite->pos1.y >> 3;
+
+            if (posX != sprite->data[2])
+            {
+                u32 var;
+                u16 *ptr;
+
+                sprite->data[2] = posX;
+                var = (((REG_BG0CNT >> 8) & 0x1F) << 11);  // r2
+                ptr = (u16 *)(VRAM + var);
+
+                SOME_VRAM_STORE(ptr, posY - 2, posX, 0xF001);
+                SOME_VRAM_STORE(ptr, posY - 1, posX, 0xF001);
+                SOME_VRAM_STORE(ptr, posY - 0, posX, 0xF001);
+                SOME_VRAM_STORE(ptr, posY + 1, posX, 0xF001);
+            }
+        }
+        sprite->pos1.x += arr0[sprite->data[0]];
+        if (sprite->pos1.x < -15 || sprite->pos1.x > 255)
+            FieldEffectStop(sprite, FLDEFF_POKEBALL);
+    }
+}
+
+static void Phase2Task_Clockwise_BlackFade(u8 taskId)
+{
+    while (sPhase2_Clockwise_BlackFade_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Clockwise_BlackFade_Func1(struct Task *task)
+{
+    u16 i;
+
+    sub_8149F08();
+    dp12_8087EA4();
+
+    sTransitionStructPtr->WININ = 0;
+    sTransitionStructPtr->WINOUT = 63;
+    sTransitionStructPtr->WIN0H = -3855;
+    sTransitionStructPtr->WIN0V = 160;
+
+    for (i = 0; i < 160; i++)
+    {
+        gUnknown_020393A8[i] = 0xF3F4;
+    }
+
+    SetVBlankCallback(VBlankCB_Phase2_Clockwise_BlackFade);
+    sTransitionStructPtr->data[4] = 120;
+
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_Clockwise_BlackFade_Func2(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    sub_814A1AC(sTransitionStructPtr->data, 120, 80, sTransitionStructPtr->data[4], -1, 1, 1);
+    do
+    {
+        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (sTransitionStructPtr->data[2] + 1) | 0x7800;
+    } while (!sub_814A228(sTransitionStructPtr->data, 1, 1));
+
+    sTransitionStructPtr->data[4] += 16;
+    if (sTransitionStructPtr->data[4] >= 240)
+    {
+        sTransitionStructPtr->data[5] = 0;
+        task->tState++;
+    }
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Clockwise_BlackFade_Func3(struct Task *task)
+{
+    s16 r1, r3;
+    vu8 var = 0;
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    sub_814A1AC(sTransitionStructPtr->data, 120, 80, 240, sTransitionStructPtr->data[5], 1, 1);
+
+    while (1)
+    {
+        r1 = 120, r3 = sTransitionStructPtr->data[2] + 1;
+        if (sTransitionStructPtr->data[5] >= 80)
+            r1 = sTransitionStructPtr->data[2], r3 = 240;
+        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (r3) | (r1 << 8);
+        if (var != 0)
+            break;
+        var = sub_814A228(sTransitionStructPtr->data, 1, 1);
+    }
+
+    sTransitionStructPtr->data[5] += 8;
+    if (sTransitionStructPtr->data[5] >= 160)
+    {
+        sTransitionStructPtr->data[4] = 240;
+        task->tState++;
+    }
+    else
+    {
+        while (sTransitionStructPtr->data[3] < sTransitionStructPtr->data[5])
+        {
+            gUnknown_02038C28[0][++sTransitionStructPtr->data[3]] = (r3) | (r1 << 8);
+        }
+    }
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Clockwise_BlackFade_Func4(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    sub_814A1AC(sTransitionStructPtr->data, 120, 80, sTransitionStructPtr->data[4], 160, 1, 1);
+    do
+    {
+        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (sTransitionStructPtr->data[2] << 8) | 0xF0;
+    } while (!sub_814A228(sTransitionStructPtr->data, 1, 1));
+
+    sTransitionStructPtr->data[4] -= 16;
+    if (sTransitionStructPtr->data[4] <= 0)
+    {
+        sTransitionStructPtr->data[5] = 160;
+        task->tState++;
+    }
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Clockwise_BlackFade_Func5(struct Task *task)
+{
+    s16 r1, r2, var4;
+    vu8 var = 0;
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    sub_814A1AC(sTransitionStructPtr->data, 120, 80, 0, sTransitionStructPtr->data[5], 1, 1);
+
+    while (1)
+    {
+        r1 = (gUnknown_02038C28[0][sTransitionStructPtr->data[3]]) & 0xFF;
+        r2 = sTransitionStructPtr->data[2];
+        if (sTransitionStructPtr->data[5] <= 80)
+            r2 = 120, r1 = sTransitionStructPtr->data[2];
+        var4 = (r1) | (r2 << 8);
+        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = var4;
+        if (var != 0)
+            break;
+        var = sub_814A228(sTransitionStructPtr->data, 1, 1);
+    }
+
+    sTransitionStructPtr->data[5] -= 8;
+    if (sTransitionStructPtr->data[5] <= 0)
+    {
+        sTransitionStructPtr->data[4] = 0;
+        task->tState++;
+    }
+    else
+    {
+        while (sTransitionStructPtr->data[3] > sTransitionStructPtr->data[5])
+        {
+            gUnknown_02038C28[0][--sTransitionStructPtr->data[3]] = (r1) | (r2 << 8);
+        }
+    }
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Clockwise_BlackFade_Func6(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    sub_814A1AC(sTransitionStructPtr->data, 120, 80, sTransitionStructPtr->data[4], 0, 1, 1);
+    do
+    {
+        s16 r2, r3;
+
+        r2 = 120, r3 = sTransitionStructPtr->data[2];
+        if (sTransitionStructPtr->data[2] >= 120)
+            r2 = 0, r3 = 240;
+        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (r3) | (r2 << 8);
+
+    } while (!sub_814A228(sTransitionStructPtr->data, 1, 1));
+
+    sTransitionStructPtr->data[4] += 16;
+    if (sTransitionStructPtr->data[2] > 120)
+        task->tState++;
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Clockwise_BlackFade_Func7(struct Task *task)
+{
+    DmaStop(0);
+    sub_8149F84();
+    DestroyTask(FindTaskIdByFunc(Phase2Task_Clockwise_BlackFade));
+    return FALSE;
+}
+
+static void VBlankCB_Phase2_Clockwise_BlackFade(void)
+{
+    DmaStop(0);
+    VBlankCB_BattleTransition();
+    if (sTransitionStructPtr->VBlank_DMA != 0)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+    REG_WININ = sTransitionStructPtr->WININ;
+    REG_WINOUT = sTransitionStructPtr->WINOUT;
+    REG_WIN0V = sTransitionStructPtr->WIN0V;
+    REG_WIN0H = gUnknown_02038C28[1][0];
+    DmaSet(0, gUnknown_02038C28[1], &REG_WIN0H, 0xA2400001);
+}
+
+static void Phase2Task_Ripple(u8 taskId)
+{
+    while (sPhase2_Ripple_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Ripple_Func1(struct Task *task)
+{
+    u8 i;
+
+    sub_8149F08();
+    dp12_8087EA4();
+
+    for (i = 0; i < 160; i++)
+    {
+        gUnknown_020393A8[i] = sTransitionStructPtr->field_16;
+    }
+
+    SetVBlankCallback(VBlankCB_Phase2_Ripple);
+    SetHBlankCallback(HBlankCB_Phase2_Ripple);
+
+    EnableInterrupts(INTR_FLAG_HBLANK);
+
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_Ripple_Func2(struct Task *task)
+{
+    u8 i;
+    s16 r3;
+    u16 r4, r8;
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    r3 = task->tData2 >> 8;
+    r4 = task->tData1;
+    r8 = 384;
+    task->tData1 += 0x400;
+    if (task->tData2 <= 0x1FFF)
+        task->tData2 += 0x180;
+
+    for (i = 0; i < 160; i++, r4 += r8)
+    {
+        // todo: fix the asm
+        s16 var = r4 >> 8;
+        asm("");
+        gUnknown_02038C28[0][i] = sTransitionStructPtr->field_16 + Sin(var, r3);
+    }
+
+    if (++task->tData3 == 81)
+    {
+        task->tData4++;
+        BeginNormalPaletteFade(-1, -2, 0, 0x10, 0);
+    }
+
+    if (task->tData4 != 0 && !gPaletteFade.active)
+        DestroyTask(FindTaskIdByFunc(Phase2Task_Ripple));
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static void VBlankCB_Phase2_Ripple(void)
+{
+    VBlankCB_BattleTransition();
+    if (sTransitionStructPtr->VBlank_DMA)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+}
+
+static void HBlankCB_Phase2_Ripple(void)
+{
+    u16 var = gUnknown_02038C28[1][REG_VCOUNT];
+    REG_BG1VOFS = var;
+    REG_BG2VOFS = var;
+    REG_BG3VOFS = var;
+}
+
+static void Phase2Task_Wave(u8 taskId)
+{
+    while (sPhase2_Wave_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Wave_Func1(struct Task *task)
+{
+    u8 i;
+
+    sub_8149F08();
+    dp12_8087EA4();
+
+    sTransitionStructPtr->WININ = 63;
+    sTransitionStructPtr->WINOUT = 0;
+    sTransitionStructPtr->WIN0H = 240;
+    sTransitionStructPtr->WIN0V = 160;
+
+    for (i = 0; i < 160; i++)
+    {
+        gUnknown_02038C28[1][i] = 242;
+    }
+
+    SetVBlankCallback(VBlankCB_Phase2_Wave);
+
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_Wave_Func2(struct Task *task)
+{
+    u8 i, r5;
+    u16* toStore;
+    bool8 nextFunc;
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    toStore = gUnknown_02038C28[0];
+    r5 = task->tData2;
+    task->tData2 += 16;
+    task->tData1 += 8;
+
+    for (i = 0, nextFunc = TRUE; i < 160; i++, r5 += 4, toStore++)
+    {
+        s16 value = task->tData1 + Sin(r5, 40);
+        if (value < 0)
+            value = 0;
+        if (value > 240)
+            value = 240;
+        *toStore = (value << 8) | (0xF1);
+        if (value < 240)
+            nextFunc = FALSE;
+    }
+    if (nextFunc)
+        task->tState++;
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Wave_Func3(struct Task *task)
+{
+    DmaStop(0);
+    sub_8149F84();
+    DestroyTask(FindTaskIdByFunc(Phase2Task_Wave));
+    return FALSE;
+}
+
+static void VBlankCB_Phase2_Wave(void)
+{
+    DmaStop(0);
+    VBlankCB_BattleTransition();
+    if (sTransitionStructPtr->VBlank_DMA != 0)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+    REG_WININ = sTransitionStructPtr->WININ;
+    REG_WINOUT = sTransitionStructPtr->WINOUT;
+    REG_WIN0V = sTransitionStructPtr->WIN0V;
+    DmaSet(0, gUnknown_02038C28[1], &REG_WIN0H, 0xA2400001);
+}
+
+static void Phase2Task_Sydney(u8 taskId)
+{
+    gTasks[taskId].tMugshotId = MUGSHOT_SYDNEY;
+    Phase2Task_MugShotTransition(taskId);
+}
+
+static void Phase2Task_Phoebe(u8 taskId)
+{
+    gTasks[taskId].tMugshotId = MUGSHOT_PHOEBE;
+    Phase2Task_MugShotTransition(taskId);
+}
+
+static void Phase2Task_Glacia(u8 taskId)
+{
+    gTasks[taskId].tMugshotId = MUGSHOT_GLACIA;
+    Phase2Task_MugShotTransition(taskId);
+}
+
+static void Phase2Task_Drake(u8 taskId)
+{
+    gTasks[taskId].tMugshotId = MUGSHOT_DRAKE;
+    Phase2Task_MugShotTransition(taskId);
+}
+
+static void Phase2Task_Champion(u8 taskId)
+{
+    gTasks[taskId].tMugshotId = MUGSHOT_CHAMPION;
+    Phase2Task_MugShotTransition(taskId);
+}
+
+static void Phase2Task_MugShotTransition(u8 taskId)
+{
+    while (sPhase2_Mugshot_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Mugshot_Func1(struct Task *task)
+{
+    u8 i;
+
+    sub_8149F08();
+    dp12_8087EA4();
+    Mugshots_CreateOpponentPlayerSprites(task);
+
+    task->tData1 = 0;
+    task->tData2 = 1;
+    task->tData3 = 239;
+    sTransitionStructPtr->WININ = 63;
+    sTransitionStructPtr->WINOUT = 62;
+    sTransitionStructPtr->WIN0V = 160;
+
+    for (i = 0; i < 160; i++)
+    {
+        gUnknown_02038C28[1][i] = 0xF0F1;
+    }
+
+    SetVBlankCallback(VBlankCB0_Phase2_Mugshots);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Mugshot_Func2(struct Task *task)
+{
+    s16 i, j;
+    u16 *dst1, *dst2;
+    const u16 *MugshotsMap;
+
+    MugshotsMap = sMugshotsTilemap;
+    sub_8149F58(&dst1, &dst2);
+    CpuSet(sUnknown_085B9AF0, dst2, 0xF0);
+    LoadPalette(sOpponentMugshotsPals[task->tMugshotId], 0xF0, 0x20);
+    LoadPalette(sPlayerMugshotsPals[gSaveBlock2Ptr->playerGender], 0xFA, 0xC);
+
+    for (i = 0; i < 20; i++)
+    {
+        for (j = 0; j < 32; j++, MugshotsMap++)
+        {
+            dst1[i * 32 + j] = *MugshotsMap | 0xF000;
+        }
+    }
+
+    EnableInterrupts(INTR_FLAG_HBLANK);
+
+    SetHBlankCallback(HBlankCB_Phase2_Mugshots);
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Mugshot_Func3(struct Task *task)
+{
+    u8 i, r5;
+    u16* toStore;
+    s16 value;
+    s32 mergedValue;
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    toStore = gUnknown_02038C28[0];
+    r5 = task->tData1;
+    task->tData1 += 0x10;
+
+    for (i = 0; i < 80; i++, toStore++, r5 += 0x10)
+    {
+        value = task->tData2 + Sin(r5, 0x10);
+        if (value < 0)
+            value = 1;
+        if (value > 0xF0)
+            value = 0xF0;
+        *toStore = value;
+    }
+    for (; i < 160; i++, toStore++, r5 += 0x10)
+    {
+        value = task->tData3 - Sin(r5, 0x10);
+        if (value < 0)
+            value = 0;
+        if (value > 0xEF)
+            value = 0xEF;
+        *toStore = (value << 8) | (0xF0);
+    }
+
+    task->tData2 += 8;
+    task->tData3 -= 8;
+    if (task->tData2 > 0xF0)
+        task->tData2 = 0xF0;
+    if (task->tData3 < 0)
+        task->tData3 = 0;
+    mergedValue = *(s32*)(&task->tData2);
+    if (mergedValue == 0xF0)
+        task->tState++;
+
+    sTransitionStructPtr->BG0HOFS_1 -= 8;
+    sTransitionStructPtr->BG0HOFS_2 += 8;
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Mugshot_Func4(struct Task *task)
+{
+    u8 i;
+    u16* toStore;
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    for (i = 0, toStore = gUnknown_02038C28[0]; i < 160; i++, toStore++)
+    {
+        *toStore = 0xF0;
+    }
+
+    task->tState++;
+    task->tData1 = 0;
+    task->tData2 = 0;
+    task->tData3 = 0;
+    sTransitionStructPtr->BG0HOFS_1 -= 8;
+    sTransitionStructPtr->BG0HOFS_2 += 8;
+
+    sub_8148484(task->tOpponentSpriteId, 0);
+    sub_8148484(task->tPlayerSpriteId, 1);
+    sub_814849C(task->tOpponentSpriteId);
+
+    PlaySE(SE_BT_START);
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Mugshot_Func5(struct Task *task)
+{
+    sTransitionStructPtr->BG0HOFS_1 -= 8;
+    sTransitionStructPtr->BG0HOFS_2 += 8;
+    if (sub_81484B8(task->tOpponentSpriteId))
+    {
+        task->tState++;
+        sub_814849C(task->tPlayerSpriteId);
+    }
+    return FALSE;
+}
+
+static bool8 Phase2_Mugshot_Func6(struct Task *task)
+{
+    sTransitionStructPtr->BG0HOFS_1 -= 8;
+    sTransitionStructPtr->BG0HOFS_2 += 8;
+    if (sub_81484B8(task->tPlayerSpriteId))
+    {
+        sTransitionStructPtr->VBlank_DMA = FALSE;
+        SetVBlankCallback(NULL);
+        DmaStop(0);
+        memset(gUnknown_02038C28[0], 0, 0x140);
+        memset(gUnknown_02038C28[1], 0, 0x140);
+        SetGpuReg(REG_OFFSET_WIN0H, 0xF0);
+        SetGpuReg(REG_OFFSET_BLDY, 0);
+        task->tState++;
+        task->tData3 = 0;
+        task->tData4 = 0;
+        sTransitionStructPtr->BLDCNT = 0xBF;
+        SetVBlankCallback(VBlankCB1_Phase2_Mugshots);
+    }
+    return FALSE;
+}
+
+static bool8 Phase2_Mugshot_Func7(struct Task *task)
+{
+    bool32 r6;
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    r6 = TRUE;
+    sTransitionStructPtr->BG0HOFS_1 -= 8;
+    sTransitionStructPtr->BG0HOFS_2 += 8;
+
+    if (task->tData4 < 0x50)
+        task->tData4 += 2;
+    if (task->tData4 > 0x50)
+        task->tData4 = 0x50;
+
+    if (++task->tData3 & 1)
+    {
+        s16 i;
+        for (i = 0, r6 = FALSE; i <= task->tData4; i++)
+        {
+            s16 index1 = 0x50 - i;
+            s16 index2 = 0x50 + i;
+            if (gUnknown_02038C28[0][index1] <= 15)
+            {
+                r6 = TRUE;
+                gUnknown_02038C28[0][index1]++;
+            }
+            if (gUnknown_02038C28[0][index2] <= 15)
+            {
+                r6 = TRUE;
+                gUnknown_02038C28[0][index2]++;
+            }
+        }
+    }
+
+    if (task->tData4 == 0x50 && !r6)
+        task->tState++;
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Mugshot_Func8(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    BlendPalettes(-1, 0x10, 0x7FFF);
+    sTransitionStructPtr->BLDCNT = 0xFF;
+    task->tData3 = 0;
+
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_Mugshot_Func9(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    task->tData3++;
+    memset(gUnknown_02038C28[0], task->tData3, 0x140);
+    if (task->tData3 > 15)
+        task->tState++;
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Mugshot_Func10(struct Task *task)
+{
+    DmaStop(0);
+    sub_8149F84();
+    DestroyTask(FindTaskIdByFunc(task->func));
+    return FALSE;
+}
+
+static void VBlankCB0_Phase2_Mugshots(void)
+{
+    DmaStop(0);
+    VBlankCB_BattleTransition();
+    if (sTransitionStructPtr->VBlank_DMA != 0)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+    REG_BG0VOFS = sTransitionStructPtr->BG0VOFS;
+    REG_WININ = sTransitionStructPtr->WININ;
+    REG_WINOUT = sTransitionStructPtr->WINOUT;
+    REG_WIN0V = sTransitionStructPtr->WIN0V;
+    DmaSet(0, gUnknown_02038C28[1], &REG_WIN0H, 0xA2400001);
+}
+
+static void VBlankCB1_Phase2_Mugshots(void)
+{
+    DmaStop(0);
+    VBlankCB_BattleTransition();
+    if (sTransitionStructPtr->VBlank_DMA != 0)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+    REG_BLDCNT = sTransitionStructPtr->BLDCNT;
+    DmaSet(0, gUnknown_02038C28[1], &REG_BLDY, 0xA2400001);
+}
+
+static void HBlankCB_Phase2_Mugshots(void)
+{
+    if (REG_VCOUNT < 80)
+        REG_BG0HOFS = sTransitionStructPtr->BG0HOFS_1;
+    else
+        REG_BG0HOFS = sTransitionStructPtr->BG0HOFS_2;
+}
+
+static void Mugshots_CreateOpponentPlayerSprites(struct Task *task)
+{
+    struct Sprite *opponentSprite, *playerSprite;
+
+    s16 mugshotId = task->tMugshotId;
+    task->tOpponentSpriteId = CreateTrainerSprite(sMugshotsTrainerPicIDsTable[mugshotId],
+                                                     sMugshotsOpponentCoords[mugshotId][0] - 32,
+                                                     sMugshotsOpponentCoords[mugshotId][1] + 42,
+                                                     0, gDecompressionBuffer);
+    task->tPlayerSpriteId = CreateTrainerSprite(PlayerGenderToFrontTrainerPicId(gSaveBlock2Ptr->playerGender), 272, 106, 0, gDecompressionBuffer);
+
+    opponentSprite = &gSprites[task->tOpponentSpriteId];
+    playerSprite = &gSprites[task->tPlayerSpriteId];
+
+    opponentSprite->callback = sub_8148380;
+    playerSprite->callback = sub_8148380;
+
+    opponentSprite->oam.affineMode = 3;
+    playerSprite->oam.affineMode = 3;
+
+    opponentSprite->oam.matrixNum = AllocOamMatrix();
+    playerSprite->oam.matrixNum = AllocOamMatrix();
+
+    opponentSprite->oam.shape = 1;
+    playerSprite->oam.shape = 1;
+
+    opponentSprite->oam.size = 3;
+    playerSprite->oam.size = 3;
+
+    CalcCenterToCornerVec(opponentSprite, 1, 3, 3);
+    CalcCenterToCornerVec(playerSprite, 1, 3, 3);
+
+    SetOamMatrixRotationScaling(opponentSprite->oam.matrixNum, sMugshotsOpponentRotationScales[mugshotId][0], sMugshotsOpponentRotationScales[mugshotId][1], 0);
+    SetOamMatrixRotationScaling(playerSprite->oam.matrixNum, -512, 512, 0);
+}
+
+static void sub_8148380(struct Sprite *sprite)
+{
+    while (sUnknown_085C8C24[sprite->data[0]](sprite));
+}
+
+static bool8 sub_81483A8(struct Sprite *sprite)
+{
+    return FALSE;
+}
+
+static bool8 sub_81483AC(struct Sprite *sprite)
+{
+    s16 arr0[2];
+    s16 arr1[2];
+
+    memcpy(arr0, sUnknown_085C8C40, sizeof(sUnknown_085C8C40));
+    memcpy(arr1, sUnknown_085C8C44, sizeof(sUnknown_085C8C44));
+
+    sprite->data[0]++;
+    sprite->data[1] = arr0[sprite->data[7]];
+    sprite->data[2] = arr1[sprite->data[7]];
+    return TRUE;
+}
+
+static bool8 sub_81483F8(struct Sprite *sprite)
+{
+    sprite->pos1.x += sprite->data[1];
+    if (sprite->data[7] && sprite->pos1.x < 133)
+        sprite->data[0]++;
+    else if (!sprite->data[7] && sprite->pos1.x > 103)
+        sprite->data[0]++;
+    return FALSE;
+}
+
+static bool8 sub_814842C(struct Sprite *sprite)
+{
+    sprite->data[1] += sprite->data[2];
+    sprite->pos1.x += sprite->data[1];
+    if (sprite->data[1] == 0)
+    {
+        sprite->data[0]++;
+        sprite->data[2] = -sprite->data[2];
+        sprite->data[6] = 1;
+    }
+    return FALSE;
+}
+
+static bool8 sub_8148458(struct Sprite *sprite)
+{
+    sprite->data[1] += sprite->data[2];
+    sprite->pos1.x += sprite->data[1];
+    if (sprite->pos1.x < -31 || sprite->pos1.x > 271)
+        sprite->data[0]++;
+    return FALSE;
+}
+
+static void sub_8148484(s16 spriteId, s16 value)
+{
+    gSprites[spriteId].data[7] = value;
+}
+
+static void sub_814849C(s16 spriteId)
+{
+    gSprites[spriteId].data[0]++;
+}
+
+static s16 sub_81484B8(s16 spriteId)
+{
+    return gSprites[spriteId].data[6];
+}
+
+static void Phase2Task_Slice(u8 taskId)
+{
+    while (sPhase2_Slice_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Slice_Func1(struct Task *task)
+{
+    u16 i;
+
+    sub_8149F08();
+    dp12_8087EA4();
+
+    task->tData2 = 256;
+    task->tData3 = 1;
+    sTransitionStructPtr->WININ = 63;
+    sTransitionStructPtr->WINOUT = 0;
+    sTransitionStructPtr->WIN0V = 160;
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    for (i = 0; i < 160; i++)
+    {
+        gUnknown_02038C28[1][i] = sTransitionStructPtr->field_14;
+        gUnknown_02038C28[1][160 + i] = 0xF0;
+    }
+
+    EnableInterrupts(INTR_FLAG_HBLANK);
+    SetGpuRegBits(REG_OFFSET_DISPSTAT, DISPSTAT_HBLANK_INTR);
+
+    SetVBlankCallback(VBlankCB_Phase2_Slice);
+    SetHBlankCallback(HBlankCB_Phase2_Slice);
+
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_Slice_Func2(struct Task *task)
+{
+    u16 i;
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    task->tData1 += (task->tData2 >> 8);
+    if (task->tData1 > 0xF0)
+        task->tData1 = 0xF0;
+    if (task->tData2 <= 0xFFF)
+        task->tData2 += task->tData3;
+    if (task->tData3 < 128)
+        task->tData3 <<= 1; // multiplying by two
+
+    for (i = 0; i < 160; i++)
+    {
+        u16 *storeLoc1 = &gUnknown_02038C28[0][i];
+        u16 *storeLoc2 = &gUnknown_02038C28[0][i + 160];
+        if (i & 1)
+        {
+            *storeLoc1 = sTransitionStructPtr->field_14 + task->tData1;
+            *storeLoc2 = 0xF0 - task->tData1;
+        }
+        else
+        {
+            *storeLoc1 = sTransitionStructPtr->field_14 - task->tData1;
+            *storeLoc2 = (task->tData1 << 8) | (0xF1);
+        }
+    }
+
+    if (task->tData1 > 0xEF)
+        task->tState++;
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Slice_Func3(struct Task *task)
+{
+    DmaStop(0);
+    sub_8149F84();
+    DestroyTask(FindTaskIdByFunc(Phase2Task_Slice));
+    return FALSE;
+}
+
+static void VBlankCB_Phase2_Slice(void)
+{
+    DmaStop(0);
+    VBlankCB_BattleTransition();
+    REG_WININ = sTransitionStructPtr->WININ;
+    REG_WINOUT = sTransitionStructPtr->WINOUT;
+    REG_WIN0V = sTransitionStructPtr->WIN0V;
+    if (sTransitionStructPtr->VBlank_DMA)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 640);
+    DmaSet(0, &gUnknown_02038C28[1][160], &REG_WIN0H, 0xA2400001);
+}
+
+static void HBlankCB_Phase2_Slice(void)
+{
+    if (REG_VCOUNT < 160)
+    {
+        u16 var = gUnknown_02038C28[1][REG_VCOUNT];
+        REG_BG1HOFS = var;
+        REG_BG2HOFS = var;
+        REG_BG3HOFS = var;
+    }
+}
+
+static void Phase2Task_ShredSplit(u8 taskId)
+{
+    while (sPhase2_ShredSplit_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_ShredSplit_Func1(struct Task *task)
+{
+    u16 i;
+
+    sub_8149F08();
+    dp12_8087EA4();
+
+    sTransitionStructPtr->WININ = 63;
+    sTransitionStructPtr->WINOUT = 0;
+    sTransitionStructPtr->WIN0V = 160;
+
+    for (i = 0; i < 0xA0; i++)
+    {
+        gUnknown_02038C28[1][i] = sTransitionStructPtr->field_14;
+        gUnknown_02038C28[1][0xA0 + i] = 0xF0;
+        gUnknown_02038C28[0][i] = sTransitionStructPtr->field_14;
+        gUnknown_02038C28[0][0xA0 + i] = 0xF0;
+        gUnknown_02038C28[0][0x140 + i] = 0;
+        gUnknown_02038C28[0][0x1E0 + i] = 0x100;
+        gUnknown_02038C28[0][0x280 + i] = 1;
+    }
+
+    task->tData4 = 0;
+    task->tData5 = 0;
+    task->tData6 = 7;
+
+    EnableInterrupts(INTR_FLAG_HBLANK);
+
+    SetVBlankCallback(VBlankCB_Phase2_Slice);
+    SetHBlankCallback(HBlankCB_Phase2_Slice);
+
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_ShredSplit_Func2(struct Task *task)
+{
+    u16 i, j, k;
+    u8 arr1[ARRAY_COUNT(gUnknown_085C8C64)];
+    s16 arr2[ARRAY_COUNT(gUnknown_085C8C66)];
+    u8 var;
+    u16 *ptr4, *ptr3, *ptr1, *ptr2;
+    s16 unkVar;
+
+    memcpy(arr1, gUnknown_085C8C64, sizeof(arr1));
+    memcpy(arr2, gUnknown_085C8C66, sizeof(arr2));
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    var = 0;
+
+    for (i = 0; i <= task->tData5; i++)
+    {
+        for (j = 0; j < 2; j++)
+        {
+            for (k = 0; k < 2; k++)
+            {
+                unkVar = (arr1[j]) + (arr2[k] * -(i) * 2);
+                if (unkVar >= 0 && (unkVar != 79 || j != 1))
+                {
+                    ptr4 = &gUnknown_02038C28[0][unkVar + 320];
+                    ptr3 = &gUnknown_02038C28[0][unkVar + 480];
+                    ptr1 = &gUnknown_02038C28[0][unkVar + 640];
+                    if (*ptr4 > 0xEF)
+                    {
+                        *ptr4 = 0xF0;
+                        var++;
+                    }
+                    else
+                    {
+                        *ptr4 += (*ptr3 >> 8);
+                        if (*ptr1 <= 0x7F)
+                            *ptr1 *= 2;
+                        if (*ptr3 <= 0xFFF)
+                            *ptr3 += *ptr1;
+                    }
+                    ptr2 = &gUnknown_02038C28[0][unkVar];
+                    ptr3 = &gUnknown_02038C28[0][unkVar + 160];
+                    *ptr2 = sTransitionStructPtr->field_14 + *ptr4;
+                    *ptr3 = 0xF0 - *ptr4;
+
+                    if (i == 0)
+                        break;
+                }
+            }
+        }
+
+        for (j = 0; j < 2; j++)
+        {
+            for (k = 0; k < 2; k++)
+            {
+                unkVar = (arr1[j] + 1) + (arr2[k] * -(i) * 2);
+                if (unkVar <= 160 && (unkVar != 80 || j != 1))
+                {
+                    ptr4 = &gUnknown_02038C28[0][unkVar + 320];
+                    ptr3 = &gUnknown_02038C28[0][unkVar + 480];
+                    ptr1 = &gUnknown_02038C28[0][unkVar + 640];
+                    if (*ptr4 > 0xEF)
+                    {
+                        *ptr4 = 0xF0;
+                        var++;
+                    }
+                    else
+                    {
+                        *ptr4 += (*ptr3 >> 8);
+                        if (*ptr1 <= 0x7F)
+                            *ptr1 *= 2;
+                        if (*ptr3 <= 0xFFF)
+                            *ptr3 += *ptr1;
+                    }
+                    ptr2 = &gUnknown_02038C28[0][unkVar];
+                    ptr3 = &gUnknown_02038C28[0][unkVar + 160];
+                    *ptr2 = sTransitionStructPtr->field_14 - *ptr4;
+                    *ptr3 = (*ptr4 << 8) | (0xF1);
+
+                    if (i == 0)
+                        break;
+                }
+            }
+        }
+    }
+
+    if (--task->tData4 < 0)
+        task->tData4 = 0;
+    if (task->tData4 <= 0 && task->tData5 + 1 <= 20)
+        task->tData4 = task->tData6, task->tData5++;
+    if (var > 0x9F)
+        task->tState++;
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+// This function never increments the state counter, because the loop condition
+// is always false, resulting in the game being stuck in an infinite loop.
+// It's possible this transition is only partially 
+// done and the second part was left out.
+static bool8 Phase2_ShredSplit_Func3(struct Task *task)
+{
+    u16 i;
+    bool32 done = TRUE;
+    u16 checkVar2 = 0xFF10;
+
+    for (i = 0; i < 0xA0; i++)
+    {
+        if (gUnknown_02038C28[1][i] != 0xF0 && gUnknown_02038C28[1][i] != checkVar2)
+            done = FALSE; // a break statement should be put here
+    }
+
+    if (done == TRUE)
+        task->tState++;
+
+    return FALSE;
+}
+
+static bool8 Phase2_ShredSplit_Func4(struct Task *task)
+{
+    DmaStop(0);
+    sub_8149F84();
+    DestroyTask(FindTaskIdByFunc(Phase2Task_ShredSplit));
+    return FALSE;
+}
+
+static void Phase2Task_Blackhole1(u8 taskId)
+{
+    while (sPhase2_Blackhole1_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static void Phase2Task_Blackhole2(u8 taskId)
+{
+    while (sPhase2_Blackhole2_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Blackhole_Func1(struct Task *task)
+{
+    s32 i;
+
+    sub_8149F08();
+    dp12_8087EA4();
+
+    sTransitionStructPtr->WININ = 0;
+    sTransitionStructPtr->WINOUT = 63;
+    sTransitionStructPtr->WIN0H = 240;
+    sTransitionStructPtr->WIN0V = 160;
+
+    for (i = 0; i < 0xA0; i++)
+    {
+        gUnknown_02038C28[1][i] = 0;
+    }
+
+    SetVBlankCallback(VBlankCB1_Phase2_BigPokeball);
+
+    task->tState++;
+    task->tData1 = 1;
+    task->tData2 = 0x100;
+    task->tFuncState = 0;
+
+    return FALSE;
+}
+
+static bool8 Phase2_Blackhole1_Func3(struct Task *task)
+{
+    if (task->tFuncState == 1)
+    {
+        DmaStop(0);
+        SetVBlankCallback(NULL);
+        DestroyTask(FindTaskIdByFunc(task->func));
+    }
+    else
+    {
+        sTransitionStructPtr->VBlank_DMA = FALSE;
+        if (task->tData2 < 0x400)
+            task->tData2 += 0x80;
+        if (task->tData1 < 0xA0)
+            task->tData1 += (task->tData2 >> 8);
+        if (task->tData1 > 0xA0)
+            task->tData1 = 0xA0;
+        sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->tData1);
+        if (task->tData1 == 0xA0)
+        {
+            task->tFuncState = 1;
+            sub_8149F84();
+        }
+        else
+        {
+            sTransitionStructPtr->VBlank_DMA++;
+        }
+    }
+
+    return FALSE;
+}
+
+static bool8 Phase2_Blackhole1_Func2(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    if (task->tFuncState == 0)
+    {
+        task->tFuncState++;
+        task->tData1 = 0x30;
+        task->tData6 = 0;
+    }
+    task->tData1 += gUnknown_085C8C80[task->tData6];
+    task->tData6 = (task->tData6 + 1) % 2;
+    sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->tData1);
+    if (task->tData1 < 9)
+    {
+        task->tState++;
+        task->tFuncState = 0;
+    }
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Blackhole2_Func2(struct Task *task)
+{
+    u16 index; // should be s16 I think
+    s16 amplitude;
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+    if (task->tFuncState == 0)
+    {
+        task->tFuncState++;
+        task->tData5 = 2;
+        task->tData6 = 2;
+    }
+    if (task->tData1 > 0xA0)
+        task->tData1 = 0xA0;
+
+    sub_814A014(gUnknown_02038C28[0], 0x78, 0x50, task->tData1);
+    if (task->tData1 == 0xA0)
+    {
+        DmaStop(0);
+        sub_8149F84();
+        DestroyTask(FindTaskIdByFunc(task->func));
+    }
+
+    index = task->tData5;
+    if ((task->tData5 & 0xFF) <= 128)
+    {
+        amplitude = task->tData6;
+        task->tData5 += 8;
+    }
+    else
+    {
+        amplitude = task->tData6 - 1;
+        task->tData5 += 16;
+    }
+    task->tData1 += Sin(index & 0xFF, amplitude);
+
+    if (task->tData1 <= 0)
+        task->tData1 = 1;
+    if (task->tData5 > 0xFE)
+        task->tData5 >>= 8, task->tData6++;
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static void Phase2Task_RectangularSpiral(u8 taskId)
+{
+    while (sPhase2_RectangularSpiral_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_RectangularSpiral_Func1(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    CpuCopy16(sShrinkingBoxTileset, dst2, 0x20);
+    CpuCopy16(sShrinkingBoxTileset + 0x70, dst2 + 0x20, 0x20);
+    CpuFill16(0xF000, dst1, 0x800);
+    LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20);
+
+    task->tData3 = 1;
+    task->tState++;
+
+    sRectangularSpiralTransition[0].field_0 = 0;
+    sRectangularSpiralTransition[0].field_2 = -1;
+    sRectangularSpiralTransition[0].field_4 = 1;
+    sRectangularSpiralTransition[0].field_6 = 308;
+    sRectangularSpiralTransition[0].field_8 = 0;
+
+    sRectangularSpiralTransition[1].field_0 = 0;
+    sRectangularSpiralTransition[1].field_2 = -1;
+    sRectangularSpiralTransition[1].field_4 = 1;
+    sRectangularSpiralTransition[1].field_6 = 308;
+    sRectangularSpiralTransition[1].field_8 = 0;
+
+    sRectangularSpiralTransition[2].field_0 = 0;
+    sRectangularSpiralTransition[2].field_2 = -3;
+    sRectangularSpiralTransition[2].field_4 = 1;
+    sRectangularSpiralTransition[2].field_6 = 307;
+    sRectangularSpiralTransition[2].field_8 = 0;
+
+    sRectangularSpiralTransition[3].field_0 = 0;
+    sRectangularSpiralTransition[3].field_2 = -3;
+    sRectangularSpiralTransition[3].field_4 = 1;
+    sRectangularSpiralTransition[3].field_6 = 307;
+    sRectangularSpiralTransition[3].field_8 = 0;
+
+    return FALSE;
+}
+
+static bool8 Phase2_RectangularSpiral_Func2(struct Task *task)
+{
+    u16 *dst1, *dst2;
+    u8 i;
+    u16 j;
+    bool32 done = TRUE;
+
+    sub_8149F58(&dst1, &dst2);
+
+    for (i = 0; i < 2; i++)
+    {
+        for (j = 0; j < ARRAY_COUNT(sRectangularSpiralTransition); j++)
+        {
+            s16 var = 0, var2 = 0;
+            s32 var3 = 0;
+
+            if (sub_8149048(gUnknown_085C8D38[j / 2], &sRectangularSpiralTransition[j]))
+            {
+                u32 one;
+                done = FALSE;
+                var = sRectangularSpiralTransition[j].field_2;
+                one = 1;
+                if ((j & 1) == one)
+                    var = 0x27D - var;
+
+                var2 = var % 32;
+                var3 = var / 32 * 32;
+
+                dst1[var3 + var2] = 0xF002;
+            }
+        }
+    }
+
+    if (done == TRUE)
+        task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_RectangularSpiral_Func3(struct Task *task)
+{
+    DmaStop(0);
+    sub_8149F84();
+    DestroyTask(FindTaskIdByFunc(task->func));
+    return FALSE;
+}
+
+static bool16 sub_8149048(const s16 * const *arg0, struct StructRectangularSpiral *arg1)
+{
+    const s16 *array = arg0[arg1->field_0];
+    if (array[arg1->field_4] == -1)
+        return FALSE;
+
+    // ??
+    sUnusedRectangularSpiralVar = array[0];
+    sUnusedRectangularSpiralVar = array[1];
+    sUnusedRectangularSpiralVar = array[2];
+    sUnusedRectangularSpiralVar = array[3];
+
+    switch (array[0])
+    {
+    case 1:
+        arg1->field_2 += 0x1;
+        break;
+    case 2:
+        arg1->field_2 -= 0x1;
+        break;
+    case 3:
+        arg1->field_2 -= 0x20;
+        break;
+    case 4:
+        arg1->field_2 += 0x20;
+        break;
+    }
+
+    if (arg1->field_2 > 0x27F || array[arg1->field_4] == -1)
+        return FALSE;
+
+    if (arg1->field_8 == 0 && array[arg1->field_4] == -2)
+    {
+        arg1->field_8 = 1;
+        arg1->field_4 = 1;
+        arg1->field_2 = arg1->field_6;
+        arg1->field_0 = 4;
+    }
+
+    if (arg1->field_2 == array[arg1->field_4])
+    {
+        (arg1->field_0)++;
+        if (arg1->field_8 == 1)
+        {
+            if (arg1->field_0 > 7)
+            {
+                (arg1->field_4)++;
+                (arg1->field_0) = 4;
+            }
+        }
+        else
+        {
+            if (arg1->field_0 > 3)
+            {
+                (arg1->field_4)++;
+                (arg1->field_0) = 0;
+            }
+        }
+    }
+
+    return TRUE;
+}
+
+static void Phase2Task_Groudon(u8 taskId)
+{
+    while (sPhase2_Groudon_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Groudon_Func3(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    CpuFill16(0, dst1, 0x800);
+    LZ77UnCompVram(gUnknown_085BE51C, dst2);
+    LZ77UnCompVram(gUnknown_085BEA88, dst1);
+
+    task->tState++;
+    task->tData1 = 0;
+    return FALSE;
+}
+
+static bool8 Phase2_Groudon_Func4(struct Task *task)
+{
+    if (task->tData1 % 3 == 0)
+    {
+        u16 var = (task->tData1 % 30) / 3;
+        LoadPalette(gUnknown_085BF0A0 + (var * 16), 0xF0, 0x20);
+    }
+    if (++task->tData1 > 58)
+    {
+        task->tState++;
+        task->tData1 = 0;
+    }
+
+    return FALSE;
+}
+
+static bool8 Phase2_Groudon_Func5(struct Task *task)
+{
+    if (task->tData1 % 5 == 0)
+    {
+        s16 var = task->tData1 / 5;
+        LoadPalette(gUnknown_085BF2A0 + (var * 16), 0xF0, 0x20);
+    }
+    if (++task->tData1 > 68)
+    {
+        task->tState++;
+        task->tData1 = 0;
+        task->tFrames = 30;
+    }
+
+    return FALSE;
+}
+
+static void Phase2Task_Rayquaza(u8 taskId)
+{
+    while (sPhase2_Rayquaza_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Rayquaza_Func3(struct Task *task)
+{
+    u16 *dst1, *dst2;
+    u16 i;
+
+    sub_8149F08();
+    dp12_8087EA4();
+
+    SetGpuReg(REG_OFFSET_BG0CNT, 0x9A08);
+    sub_8149F58(&dst1, &dst2);
+    CpuFill16(0, dst1, 0x800);
+    CpuCopy16(gUnknown_085BF6A0, dst2, 0x2000);
+
+    sTransitionStructPtr->field_20 = 0;
+    task->tState++;
+    LoadPalette(gUnknown_085BF4A0 + 0x50, 0xF0, 0x20);
+
+    for (i = 0; i < 160; i++)
+    {
+        gUnknown_02038C28[0][i] = 0;
+        gUnknown_02038C28[1][i] = 0x100;
+    }
+
+    SetVBlankCallback(VBlankCB_Phase2_Rayquaza);
+    return FALSE;
+}
+
+static bool8 Phase2_Rayquaza_Func4(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    CpuCopy16(gUnknown_085C6BE0, dst1, 0x1000);
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Rayquaza_Func5(struct Task *task)
+{
+    if ((task->tData1 % 4) == 0)
+    {
+        u16 value = task->tData1 / 4;
+        const u16 *palPtr = &gUnknown_085BF4A0[(value + 5) * 16];
+        LoadPalette(palPtr, 0xF0, 0x20);
+    }
+    if (++task->tData1 > 40)
+    {
+        task->tState++;
+        task->tData1 = 0;
+    }
+
+    return FALSE;
+}
+
+static bool8 Phase2_Rayquaza_Func6(struct Task *task)
+{
+    if (++task->tData1 > 20)
+    {
+        task->tState++;
+        task->tData1 = 0;
+        BeginNormalPaletteFade(0xFFFF8000, 2, 0, 0x10, 0);
+    }
+
+    return FALSE;
+}
+
+static bool8 Phase2_Rayquaza_Func7(struct Task *task)
+{
+    if (!gPaletteFade.active)
+    {
+        sTransitionStructPtr->field_20 = 1;
+        task->tState++;
+    }
+
+    return FALSE;
+}
+
+static bool8 Phase2_Rayquaza_Func8(struct Task *task)
+{
+    BlendPalettes(0x00007FFF, 8, 0);
+    BlendPalettes(0xFFFF8000, 0, 0);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_Rayquaza_Func9(struct Task *task)
+{
+    if ((task->tData1 % 3) == 0)
+    {
+        u16 value = task->tData1 / 3;
+        const u16 *palPtr = &gUnknown_085BF4A0[(value + 0) * 16];
+        LoadPalette(palPtr, 0xF0, 0x20);
+    }
+    if (++task->tData1 >= 40)
+    {
+        u16 i;
+
+        sTransitionStructPtr->WININ = 0;
+        sTransitionStructPtr->WINOUT = 63;
+        sTransitionStructPtr->WIN0H = 240;
+        sTransitionStructPtr->WIN0V = 160;
+
+        for (i = 0; i < 160; i++)
+        {
+            gUnknown_02038C28[1][i] = 0;
+        }
+
+        SetVBlankCallback(VBlankCB1_Phase2_BigPokeball);
+        task->tState++;
+        task->tData2 = 0x100;
+        task->tFuncState = 0;
+        ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG0_ON);
+    }
+
+    return FALSE;
+}
+
+static void VBlankCB_Phase2_Rayquaza(void)
+{
+    void *dmaSrc;
+
+    DmaStop(0);
+    VBlankCB_BattleTransition();
+
+    if (sTransitionStructPtr->field_20 == 0)
+        dmaSrc = gUnknown_02038C28[0];
+    else if (sTransitionStructPtr->field_20 == 1)
+        dmaSrc = gUnknown_02038C28[1];
+    else
+        dmaSrc = gUnknown_02038C28[0];
+
+    DmaSet(0, dmaSrc, &REG_BG0VOFS, 0xA2400001);
+}
+
+static void Phase2Task_WhiteFade(u8 taskId)
+{
+    while (sPhase2_WhiteFade_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_WhiteFade_Func1(struct Task *task)
+{
+    u16 i;
+
+    sub_8149F08();
+    dp12_8087EA4();
+
+    sTransitionStructPtr->BLDCNT = 0xBF;
+    sTransitionStructPtr->BLDY = 0;
+    sTransitionStructPtr->WININ = 0x1E;
+    sTransitionStructPtr->WINOUT = 0x3F;
+    sTransitionStructPtr->WIN0V = 0xA0;
+
+    for (i = 0; i < 160; i++)
+    {
+        gUnknown_02038C28[1][i] = 0;
+        gUnknown_02038C28[1][i + 160] = 0xF0;
+    }
+
+    EnableInterrupts(INTR_FLAG_HBLANK);
+    SetHBlankCallback(HBlankCB_Phase2_WhiteFade);
+    SetVBlankCallback(VBlankCB0_Phase2_WhiteFade);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_WhiteFade_Func2(struct Task *task)
+{
+    s16 i, posY;
+    s16 arr1[ARRAY_COUNT(sUnknown_085C8DA0)];
+    struct Sprite *sprite;
+
+    memcpy(arr1, sUnknown_085C8DA0, sizeof(sUnknown_085C8DA0));
+    for (i = 0, posY = 0; i < 8; i++, posY += 0x14)
+    {
+        sprite = &gSprites[CreateInvisibleSprite(sub_8149864)];
+        sprite->pos1.x = 0xF0;
+        sprite->pos1.y = posY;
+        sprite->data[5] = arr1[i];
+    }
+    sprite->data[6]++;
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_WhiteFade_Func3(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = 0;
+    if (sTransitionStructPtr->field_20 > 7)
+    {
+        BlendPalettes(-1, 0x10, 0x7FFF);
+        task->tState++;
+    }
+    return FALSE;
+}
+
+static bool8 Phase2_WhiteFade_Func4(struct Task *task)
+{
+    sTransitionStructPtr->VBlank_DMA = 0;
+
+    DmaStop(0);
+    SetVBlankCallback(0);
+    SetHBlankCallback(0);
+
+    sTransitionStructPtr->WIN0H = 0xF0;
+    sTransitionStructPtr->BLDY = 0;
+    sTransitionStructPtr->BLDCNT = 0xFF;
+    sTransitionStructPtr->WININ = 0x3F;
+
+    SetVBlankCallback(VBlankCB1_Phase2_WhiteFade);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_WhiteFade_Func5(struct Task *task)
+{
+   if (++sTransitionStructPtr->BLDY > 16)
+   {
+       sub_8149F84();
+       DestroyTask(FindTaskIdByFunc(Phase2Task_WhiteFade));
+   }
+   return FALSE;
+}
+
+static void VBlankCB0_Phase2_WhiteFade(void)
+{
+    DmaStop(0);
+    VBlankCB_BattleTransition();
+    REG_BLDCNT = sTransitionStructPtr->BLDCNT;
+    REG_WININ = sTransitionStructPtr->WININ;
+    REG_WINOUT = sTransitionStructPtr->WINOUT;
+    REG_WIN0V = sTransitionStructPtr->WIN0V;
+    if (sTransitionStructPtr->VBlank_DMA)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 640);
+    DmaSet(0, &gUnknown_02038C28[1][160], &REG_WIN0H, 0xA2400001);
+}
+
+static void VBlankCB1_Phase2_WhiteFade(void)
+{
+    VBlankCB_BattleTransition();
+    REG_BLDY = sTransitionStructPtr->BLDY;
+    REG_BLDCNT = sTransitionStructPtr->BLDCNT;
+    REG_WININ = sTransitionStructPtr->WININ;
+    REG_WINOUT = sTransitionStructPtr->WINOUT;
+    REG_WIN0H = sTransitionStructPtr->WIN0H;
+    REG_WIN0V = sTransitionStructPtr->WIN0V;
+}
+
+static void HBlankCB_Phase2_WhiteFade(void)
+{
+    REG_BLDY = gUnknown_02038C28[1][REG_VCOUNT];
+}
+
+static void sub_8149864(struct Sprite *sprite)
+{
+    if (sprite->data[5])
+    {
+        sprite->data[5]--;
+        if (sprite->data[6])
+            sTransitionStructPtr->VBlank_DMA = 1;
+    }
+    else
+    {
+        u16 i;
+        u16* ptr1 = &gUnknown_02038C28[0][sprite->pos1.y];
+        u16* ptr2 = &gUnknown_02038C28[0][sprite->pos1.y + 160];
+        for (i = 0; i < 20; i++)
+        {
+            ptr1[i] = sprite->data[0] >> 8;
+            ptr2[i] = (u8)(sprite->pos1.x);
+        }
+        if (sprite->pos1.x == 0 && sprite->data[0] == 0x1000)
+            sprite->data[1] = 1;
+
+        sprite->pos1.x -= 16;
+        sprite->data[0] += 0x80;
+
+        if (sprite->pos1.x < 0)
+            sprite->pos1.x = 0;
+        if (sprite->data[0] > 0x1000)
+            sprite->data[0] = 0x1000;
+
+        if (sprite->data[6])
+            sTransitionStructPtr->VBlank_DMA = 1;
+
+        if (sprite->data[1])
+        {
+            if (sprite->data[6] == 0 || (sTransitionStructPtr->field_20 > 6 && sprite->data[2]++ > 7))
+            {
+                sTransitionStructPtr->field_20++;
+                DestroySprite(sprite);
+            }
+        }
+    }
+}
+
+static void Phase2Task_GridSquares(u8 taskId)
+{
+    while (sPhase2_GridSquares_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_GridSquares_Func1(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    CpuSet(sShrinkingBoxTileset, dst2, 0x10);
+    CpuFill16(0xF000, dst1, 0x800);
+    LoadPalette(gFieldEffectObjectPalette10, 0xF0, 0x20);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_GridSquares_Func2(struct Task *task)
+{
+    u16* dst1;
+
+    if (task->tData1 == 0)
+    {
+        sub_8149F40(&dst1);
+        task->tData1 = 3;
+        task->tData2++;
+        CpuSet(sShrinkingBoxTileset + (task->tData2 * 8), dst1, 0x10);
+        if (task->tData2 > 0xD)
+        {
+            task->tState++;
+            task->tData1 = 16;
+        }
+    }
+
+    task->tData1--;
+    return FALSE;
+}
+
+static bool8 Phase2_GridSquares_Func3(struct Task *task)
+{
+    if (--task->tData1 == 0)
+    {
+        sub_8149F84();
+        DestroyTask(FindTaskIdByFunc(Phase2Task_GridSquares));
+    }
+    return FALSE;
+}
+
+static void Phase2Task_Shards(u8 taskId)
+{
+    while (sPhase2_Shards_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_Shards_Func1(struct Task *task)
+{
+    u16 i;
+
+    sub_8149F08();
+    dp12_8087EA4();
+
+    sTransitionStructPtr->WININ = 0x3F;
+    sTransitionStructPtr->WINOUT = 0;
+    sTransitionStructPtr->WIN0V = 0xA0;
+
+    for (i = 0; i < 160; i++)
+    {
+        gUnknown_02038C28[0][i] = 0xF0;
+    }
+
+    CpuSet(gUnknown_02038C28[0], gUnknown_02038C28[1], 0xA0);
+    SetVBlankCallback(VBlankCB_Phase2_Shards);
+
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_Shards_Func2(struct Task *task)
+{
+    sub_814A1AC(sTransitionStructPtr->data,
+                sUnknown_085C8DD0[task->tData1][0],
+                sUnknown_085C8DD0[task->tData1][1],
+                sUnknown_085C8DD0[task->tData1][2],
+                sUnknown_085C8DD0[task->tData1][3],
+                1, 1);
+    task->tData2 = sUnknown_085C8DD0[task->tData1][4];
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_Shards_Func3(struct Task *task)
+{
+    s16 i;
+    bool8 nextFunc;
+
+    sTransitionStructPtr->VBlank_DMA = 0;
+
+    for (i = 0, nextFunc = FALSE; i < 16; i++)
+    {
+        s16 r3 = gUnknown_02038C28[0][sTransitionStructPtr->data[3]] >> 8;
+        s16 r4 = gUnknown_02038C28[0][sTransitionStructPtr->data[3]] & 0xFF;
+        if (task->tData2 == 0)
+        {
+            if (r3 < sTransitionStructPtr->data[2])
+                r3 = sTransitionStructPtr->data[2];
+            if (r3 > r4)
+                r3 = r4;
+        }
+        else
+        {
+            if (r4 > sTransitionStructPtr->data[2])
+                r4 = sTransitionStructPtr->data[2];
+            if (r4 <= r3)
+                r4 = r3;
+        }
+        gUnknown_02038C28[0][sTransitionStructPtr->data[3]] = (r4) | (r3 << 8);
+        if (nextFunc)
+        {
+            task->tState++;
+            break;
+        }
+        else
+            nextFunc = sub_814A228(sTransitionStructPtr->data, 1, 1);
+    }
+
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static bool8 Phase2_Shards_Func4(struct Task *task)
+{
+    if (++task->tData1 < 7)
+    {
+        task->tState++;
+        task->tData3 = sUnknown_085C8E16[task->tData1 - 1];
+        return TRUE;
+    }
+    else
+    {
+        DmaStop(0);
+        sub_8149F84();
+        DestroyTask(FindTaskIdByFunc(Phase2Task_Shards));
+        return FALSE;
+    }
+}
+
+static bool8 Phase2_Shards_Func5(struct Task *task)
+{
+    if (--task->tData3 == 0)
+    {
+        task->tState = 1;
+        return TRUE;
+    }
+    else
+        return FALSE;
+}
+
+static void VBlankCB_Phase2_Shards(void)
+{
+    DmaStop(0);
+    VBlankCB_BattleTransition();
+    if (sTransitionStructPtr->VBlank_DMA)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+    REG_WININ = sTransitionStructPtr->WININ;
+    REG_WINOUT = sTransitionStructPtr->WINOUT;
+    REG_WIN0V = sTransitionStructPtr->WIN0V;
+    REG_WIN0H = gUnknown_02038C28[1][0];
+    DmaSet(0, gUnknown_02038C28[1], &REG_WIN0H, 0xA2400001);
+}
+
+// sub-task for phase2
+#undef tData1
+#undef tData2
+#undef tData3
+#undef tData4
+#undef tData5
+#undef tData6
+#undef tFuncState
+#undef tFrames
+#undef tOpponentSpriteId
+#undef tPlayerSpriteId
+#undef tMugshotId
+
+// sub-task for sub-task phase
+#define tData1      data[1]
+#define tData2      data[2]
+#define tData3      data[3]
+#define tData4      data[4]
+#define tData5      data[5]
+#define tData6      data[6]
+#define tData7      data[7]
+
+static void CreatePhase1Task(s16 a0, s16 a1, s16 a2, s16 a3, s16 a4)
+{
+    u8 taskId = CreateTask(TransitionPhase1_Task_RunFuncs, 3);
+    gTasks[taskId].tData1 = a0;
+    gTasks[taskId].tData2 = a1;
+    gTasks[taskId].tData3 = a2;
+    gTasks[taskId].tData4 = a3;
+    gTasks[taskId].tData5 = a4;
+    gTasks[taskId].tData6 = a0;
+}
+
+static bool8 IsPhase1Done(void)
+{
+    if (FindTaskIdByFunc(TransitionPhase1_Task_RunFuncs) == 0xFF)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void TransitionPhase1_Task_RunFuncs(u8 taskId)
+{
+    while (sPhase1_TransitionAll_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase1_TransitionAll_Func1(struct Task *task)
+{
+    if (task->tData6 == 0 || --task->tData6 == 0)
+    {
+        task->tData6 = task->tData1;
+        task->tData7 += task->tData4;
+        if (task->tData7 > 16)
+            task->tData7 = 16;
+        BlendPalettes(-1, task->tData7, 0x2D6B);
+    }
+    if (task->tData7 > 15)
+    {
+        task->tState++;
+        task->tData6 = task->tData2;
+    }
+    return FALSE;
+}
+
+static bool8 Phase1_TransitionAll_Func2(struct Task *task)
+{
+    if (task->tData6 == 0 || --task->tData6 == 0)
+    {
+        task->tData6 = task->tData2;
+        task->tData7 -= task->tData5;
+        if (task->tData7 < 0)
+            task->tData7 = 0;
+        BlendPalettes(-1, task->tData7, 0x2D6B);
+    }
+    if (task->tData7 == 0)
+    {
+        if (--task->tData3 == 0)
+            DestroyTask(FindTaskIdByFunc(TransitionPhase1_Task_RunFuncs));
+        else
+        {
+            task->tData6 = task->tData1;
+            task->tState = 0;
+        }
+    }
+    return FALSE;
+}
+
+#undef tData1
+#undef tData2
+#undef tData3
+#undef tData4
+#undef tData5
+#undef tData6
+#undef tData7
+
+static void sub_8149F08(void)
+{
+    memset(sTransitionStructPtr, 0, sizeof(*sTransitionStructPtr));
+    sub_8089C08(&sTransitionStructPtr->field_14, &sTransitionStructPtr->field_16);
+}
+
+static void VBlankCB_BattleTransition(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+static void sub_8149F40(u16 **a0)
+{
+    u16 reg, *vram;
+
+    reg = REG_BG0CNT >> 2;
+    reg <<= 0xE;
+    vram = (u16*)(VRAM + reg);
+
+    *a0 = vram;
+}
+
+void sub_8149F58(u16 **a0, u16 **a1)
+{
+    u16 reg0, reg1, *vram0, *vram1;
+
+    reg0 = REG_BG0CNT >> 8;
+    reg1 = REG_BG0CNT >> 2;
+
+    reg0 <<= 0xB;
+    reg1 <<= 0xE;
+
+    vram0 = (u16*)(VRAM + reg0);
+    *a0 = vram0;
+
+    vram1 = (u16*)(VRAM + reg1);
+    *a1 = vram1;
+}
+
+static void sub_8149F84(void)
+{
+    BlendPalettes(-1, 0x10, 0);
+}
+
+static void sub_8149F98(s16 *array, s16 sinAdd, s16 index, s16 indexIncrementer, s16 amplitude, s16 arrSize)
+{
+    u8 i;
+    for (i = 0; arrSize > 0; arrSize--, i++, index += indexIncrementer)
+    {
+        array[i] = sinAdd + Sin(0xFF & index, amplitude);
+    }
+}
+
+static void sub_814A014(u16 *array, s16 a1, s16 a2, s16 a3)
+{
+    s16 i;
+
+    memset(array, 0xA, 160 * sizeof(s16));
+    for (i = 0; i < 64; i++)
+    {
+        s16 sinResult, cosResult;
+        s16 toStoreOrr, r2, r3, toStore, r7, r8;
+
+        sinResult = Sin(i, a3);
+        cosResult = Cos(i, a3);
+
+        toStoreOrr = a1 - sinResult;
+        toStore = a1 + sinResult;
+        r7 = a2 - cosResult;
+        r8 = a2 + cosResult;
+
+        if (toStoreOrr < 0)
+            toStoreOrr = 0;
+        if (toStore > 0xF0)
+            toStore = 0xF0;
+        if (r7 < 0)
+            r7 = 0;
+        if (r8 > 0x9F)
+            r8 = 0x9F;
+
+        toStore |= (toStoreOrr << 8);
+        array[r7] = toStore;
+        array[r8] = toStore;
+
+        cosResult = Cos(i + 1, a3);
+        r3 = a2 - cosResult;
+        r2 = a2 + cosResult;
+
+        if (r3 < 0)
+            r3 = 0;
+        if (r2 > 0x9F)
+            r2 = 0x9F;
+
+        while (r7 > r3)
+            array[--r7] = toStore;
+        while (r7 < r3)
+            array[++r7] = toStore;
+
+        while (r8 > r2)
+            array[--r8] = toStore;
+        while (r8 < r2)
+            array[++r8] = toStore;
+    }
+}
+
+static void sub_814A1AC(s16 *data, s16 a1, s16 a2, s16 a3, s16 a4, s16 a5, s16 a6)
+{
+    data[0] = a1;
+    data[1] = a2;
+    data[2] = a1;
+    data[3] = a2;
+    data[4] = a3;
+    data[5] = a4;
+    data[6] = a5;
+    data[7] = a6;
+    data[8] = a3 - a1;
+    if (data[8] < 0)
+    {
+        data[8] = -data[8];
+        data[6] = -a5;
+    }
+    data[9] = a4 - a2;
+    if (data[9] < 0)
+    {
+        data[9] = -data[9];
+        data[7] = -a6;
+    }
+    data[10] = 0;
+}
+
+static bool8 sub_814A228(s16 *data, bool8 a1, bool8 a2)
+{
+    u8 var;
+    if (data[8] > data[9])
+    {
+        data[2] += data[6];
+        data[10] += data[9];
+        if (data[10] > data[8])
+        {
+            data[3] += data[7];
+            data[10] -= data[8];
+        }
+    }
+    else
+    {
+        data[3] += data[7];
+        data[10] += data[8];
+        if (data[10] > data[9])
+        {
+            data[2] += data[6];
+            data[10] -= data[9];
+        }
+    }
+    var = 0;
+    if ((data[6] > 0 && data[2] >= data[4]) || (data[6] < 0 && data[2] <= data[4]))
+    {
+        var++;
+        if (a1)
+            data[2] = data[4];
+    }
+    if ((data[7] > 0 && data[3] >= data[5]) || (data[7] < 0 && data[3] <= data[5]))
+    {
+        var++;
+        if (a2)
+            data[3] = data[5];
+    }
+
+    if (var == 2)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+// sub-task for phase2 of a couple of new transitions
+#define tData1      data[1]
+#define tData2      data[2]
+#define tData3      data[3]
+#define tData4      data[4]
+#define tData5      data[5]
+#define tData6      data[6]
+#define tData7      data[7]
+
+static bool8 Phase2_29_Func1(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_814669C(task);
+    sub_8149F58(&dst1, &dst2);
+    CpuFill16(0, dst1, 0x800);
+    LZ77UnCompVram(gUnknown_085C7C00, dst2);
+    LoadPalette(gUnknown_085C7BE0, 0xF0, 0x20);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_29_Func2(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    LZ77UnCompVram(gUnknown_085C828C, dst1);
+    sub_8149F98(gUnknown_02038C28[0], 0, task->tData4, 0x84, task->tData5, 160);
+
+    task->tState++;
+    return TRUE;
+}
+
+static void Phase2Task_29(u8 taskId)
+{
+    while (sPhase2_29_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static void Phase2Task_30(u8 taskId)
+{
+    while (sPhase2_30_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_30_Func1(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F08();
+    dp12_8087EA4();
+    ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON | DISPCNT_WIN1_ON);
+    task->tData2 = 0x2000;
+    task->tData1 = 0x7FFF;
+    task->tData5 = 0;
+    task->tData6 = 16;
+    task->tData7 = 2560;
+    sTransitionStructPtr->BLDCNT = 0x3F41;
+    sTransitionStructPtr->BLDALPHA = (task->tData6 << 8) | (task->tData5);
+    REG_BLDCNT = sTransitionStructPtr->BLDCNT;
+    REG_BLDALPHA = sTransitionStructPtr->BLDALPHA;
+    sub_8149F58(&dst1, &dst2);
+    CpuFill16(0, dst1, 0x800);
+    LZ77UnCompVram(gUnknown_085C7C00, dst2);
+    LoadPalette(gUnknown_085C7BE0, 0xF0, 0x20);
+    sTransitionStructPtr->field_16 = 0;
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_30_Func2(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    LZ77UnCompVram(gUnknown_085C828C, dst1);
+
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_30_Func3(struct Task *task)
+{
+    u8 i;
+
+    for (i = 0; i < 160; i++)
+    {
+        gUnknown_02038C28[1][i] = sTransitionStructPtr->field_16;
+    }
+
+    SetVBlankCallback(VBlankCB_Phase2_30);
+    SetHBlankCallback(HBlankCB_Phase2_30);
+    EnableInterrupts(INTR_FLAG_HBLANK);
+
+    task->tState++;
+    return TRUE;
+}
+
+static bool8 Phase2_30_Func4(struct Task *task)
+{
+    u8 i;
+    u16 var6, amplitude, var8;
+
+    sTransitionStructPtr->VBlank_DMA = FALSE;
+
+    amplitude = task->tData2 >> 8;
+    var6 = task->tData1;
+    var8 = 384;
+
+    task->tData1 = var6 - task->tData7;
+
+    if (task->tData3 >= 70)
+    {
+        if (task->tData2 - 384 >= 0)
+            task->tData2 -= 384;
+        else
+            task->tData2 = 0;
+    }
+
+    if (task->tData3 >= 0 && task->tData3 % 3 == 0)
+    {
+        if (task->tData5 < 16)
+            task->tData5++;
+        else if (task->tData6 > 0)
+            task->tData6--;
+
+        sTransitionStructPtr->BLDALPHA = (task->tData6 << 8) | (task->tData5);
+    }
+
+    for (i = 0; i < 160; i++, var6 += var8)
+    {
+        s16 index = var6 / 256;
+        asm("");
+        gUnknown_02038C28[0][i] = sTransitionStructPtr->field_16 + Sin(index, amplitude);
+    }
+
+    if (++task->tData3 == 101)
+    {
+        task->tData4++;
+        BeginNormalPaletteFade(-1, 0, 0, 0x10, 0);
+    }
+
+    if (task->tData4 != 0 && !gPaletteFade.active)
+        DestroyTask(FindTaskIdByFunc(Phase2Task_30));
+
+    task->tData7 -= 17;
+    sTransitionStructPtr->VBlank_DMA++;
+    return FALSE;
+}
+
+static void VBlankCB_Phase2_30(void)
+{
+    VBlankCB_BattleTransition();
+    REG_BLDCNT = sTransitionStructPtr->BLDCNT;
+    REG_BLDALPHA = sTransitionStructPtr->BLDALPHA;
+
+    if (sTransitionStructPtr->VBlank_DMA)
+        DmaCopy16(3, gUnknown_02038C28[0], gUnknown_02038C28[1], 320);
+}
+
+static void HBlankCB_Phase2_30(void)
+{
+    u16 var = gUnknown_02038C28[1][REG_VCOUNT];
+    REG_BG0VOFS = var;
+}
+
+static void Phase2Task_31(u8 taskId)
+{
+    while (sPhase2_31_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static void Phase2Task_33(u8 taskId)
+{
+    while (sPhase2_33_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static void Phase2Task_32(u8 taskId)
+{
+    while (sPhase2_32_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 Phase2_31_Func1(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    LZ77UnCompVram(gUnknown_085C8598, dst2);
+
+    FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20);
+    FillBgTilemapBufferRect(0, 1, 0, 0, 1, 0x20, 0xF);
+    FillBgTilemapBufferRect(0, 1, 0x1D, 0, 1, 0x20, 0xF);
+    CopyBgTilemapBufferToVram(0);
+    LoadPalette(gUnknown_085C8578, 0xF0, 0x20);
+
+    task->tData2 = 1;
+    task->tData3 = 0;
+    task->tData4 = 0;
+    task->tData7 = 10;
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_31_Func2(struct Task *task)
+{
+    CopyRectToBgTilemapBufferRect(0, gUnknown_085C8928, 0, 0, 4, 4, task->tData2, task->tData3, 4, 4, 0xF, 0, 0);
+    CopyBgTilemapBufferToVram(0);
+
+    task->tData2 += 4;
+    if (++task->tData4 == 7)
+    {
+        task->tData2 = 1;
+        task->tData3 += 4;
+        task->tData4 = 0;
+        if (task->tData3 > 19)
+            task->tState++;
+    }
+
+    return FALSE;
+}
+
+static bool8 Phase2_31_Func3(struct Task *task)
+{
+    u8 i;
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    if (task->tData6++ >= task->tData7)
+    {
+        switch (task->tData5)
+        {
+        case 0:
+            for (i = 250; i < 255; i++)
+            {
+                gPlttBufferUnfaded[i] = 0;
+                gPlttBufferFaded[i] = 0;
+            }
+            break;
+        case 1:
+            BlendPalettes(0xFFFF7FFF, 0x10, 0);
+            LZ77UnCompVram(gUnknown_085C86F4, dst2);
+            break;
+        case 2:
+            LZ77UnCompVram(gUnknown_085C87F4, dst2);
+            break;
+        case 3:
+            LZ77UnCompVram(gUnknown_085C88A4, dst2);
+            break;
+        default:
+            FillBgTilemapBufferRect_Palette0(0, 1, 0, 0, 0x20, 0x20);
+            CopyBgTilemapBufferToVram(0);
+            task->tState++;
+            return FALSE;
+        }
+
+        task->tData6 = 0;
+        task->tData5++;
+    }
+
+    return FALSE;
+}
+
+static bool8 Phase2_33_Func1(struct Task *task)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    LZ77UnCompVram(gUnknown_085C8598, dst2);
+
+    FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20);
+    FillBgTilemapBufferRect(0, 1, 0, 0, 1, 0x20, 0xF);
+    FillBgTilemapBufferRect(0, 1, 0x1D, 0, 1, 0x20, 0xF);
+    CopyBgTilemapBufferToVram(0);
+    LoadPalette(gUnknown_085C8578, 0xE0, 0x20);
+    LoadPalette(gUnknown_085C8578, 0xF0, 0x20);
+    BlendPalette(0xE0, 0x10, 8, 0);
+
+    task->tData2 = 34;
+    task->tData3 = 0;
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_33_Func2(struct Task *task)
+{
+    u8 var = gUnknown_085C9A30[task->tData2];
+    u8 varMod = var % 7;
+    u8 varDiv = var / 7;
+    CopyRectToBgTilemapBufferRect(0, &gUnknown_085C8928, 0, 0, 4, 4, 4 * varMod + 1, 4 * varDiv, 4, 4, 0xF, 0, 0);
+    CopyBgTilemapBufferToVram(0);
+
+    if (--task->tData2 < 0)
+        task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_33_Func3(struct Task *task)
+{
+    BlendPalette(0xE0, 0x10, 3, 0);
+    BlendPalettes(0xFFFF3FFF, 0x10, 0);
+
+    task->tData2 = 0;
+    task->tData3 = 0;
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_33_Func4(struct Task *task)
+{
+    if ((task->tData3 ^= 1))
+    {
+        CopyRectToBgTilemapBufferRect(
+        0,
+        gUnknown_085C8928,
+        0,
+        0,
+        4,
+        4,
+        4 * (gUnknown_085C9A30[task->tData2] % 7) + 1,
+        4 * (gUnknown_085C9A30[task->tData2] / 7),
+        4,
+        4,
+        0xE,
+        0,
+        0);
+    }
+    else
+    {
+        if (task->tData2 > 0)
+        {
+            FillBgTilemapBufferRect(
+            0,
+            1,
+            4 * (gUnknown_085C9A30[task->tData2 - 1] % 7) + 1,
+            4 * (gUnknown_085C9A30[task->tData2 - 1] / 7),
+            4,
+            4,
+            0xF);
+        }
+
+        task->tData2++;
+    }
+
+    if (task->tData2 > 34)
+        task->tState++;
+
+    CopyBgTilemapBufferToVram(0);
+    return FALSE;
+}
+
+static bool8 Phase2_31_33_Func5(struct Task *task)
+{
+    FillBgTilemapBufferRect_Palette0(0, 1, 0, 0, 0x20, 0x20);
+    CopyBgTilemapBufferToVram(0);
+    BlendPalettes(0xFFFFFFFF, 0x10, 0);
+    DestroyTask(FindTaskIdByFunc(task->func));
+    return FALSE;
+}
+
+// sub task for phase2 32
+#define tSub32_X_delta  data[0]
+#define tSub32_Y_delta  data[1]
+#define tSub32_Bool     data[2]
+
+static void sub_814ABE4(u8 taskId)
+{
+    if (!(gTasks[taskId].tSub32_Bool ^= 1))
+    {
+        SetGpuReg(REG_OFFSET_BG0VOFS, gBattle_BG0_X);
+        SetGpuReg(REG_OFFSET_BG0HOFS, gBattle_BG0_Y);
+        gBattle_BG0_X += gTasks[taskId].tSub32_X_delta;
+        gBattle_BG0_Y += gTasks[taskId].tSub32_Y_delta;
+    }
+}
+
+static bool8 Phase2_32_Func1(struct Task *task)
+{
+    u8 taskId = 0;
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    LZ77UnCompVram(gUnknown_085C8598, dst2);
+    FillBgTilemapBufferRect_Palette0(0, 0, 0, 0, 0x20, 0x20);
+    CopyBgTilemapBufferToVram(0);
+    LoadPalette(gUnknown_085C8578, 0xF0, 0x20);
+
+    gBattle_BG0_X = 0;
+    gBattle_BG0_Y = 0;
+    SetGpuReg(REG_OFFSET_BG0VOFS, gBattle_BG0_X);
+    SetGpuReg(REG_OFFSET_BG0HOFS, gBattle_BG0_Y);
+
+    task->tData2 = 0;
+    taskId = CreateTask(sub_814ABE4, 1);
+    switch (Random() % 4)
+    {
+    case 0:
+        gTasks[taskId].tSub32_X_delta = 1;
+        gTasks[taskId].tSub32_Y_delta = 1;
+        break;
+    case 1:
+        gTasks[taskId].tSub32_X_delta = -1;
+        gTasks[taskId].tSub32_Y_delta = -1;
+        break;
+    case 2:
+        gTasks[taskId].tSub32_X_delta = 1;
+        gTasks[taskId].tSub32_Y_delta = -1;
+        break;
+    default:
+        gTasks[taskId].tSub32_X_delta = -1;
+        gTasks[taskId].tSub32_Y_delta = 1;
+        break;
+    }
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_32_Func2(struct Task *task)
+{
+    u8 var = gUnknown_085C9A53[task->tData2];
+    u8 varDiv = var / 8;
+    u8 varAnd = var & 7;
+
+    CopyRectToBgTilemapBufferRect(
+    0,
+    &gUnknown_085C8928,
+    0,
+    0,
+    4,
+    4,
+    4 * varDiv + 1,
+    4 * varAnd,
+    4,
+    4,
+    0xF,
+    0,
+    0);
+    CopyBgTilemapBufferToVram(0);
+
+    if (++task->tData2 > 63)
+        task->tState++;
+    return 0;
+}
+
+static bool8 Phase2_32_Func3(struct Task *task)
+{
+    BlendPalettes(0xFFFF7FFF, 0x10, 0);
+
+    task->tData2 = 0;
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 Phase2_32_Func4(struct Task *task)
+{
+    u8 var = gUnknown_085C9A53[task->tData2];
+    u8 varDiv = var / 8;
+    u8 varAnd = var & 7;
+
+    FillBgTilemapBufferRect(0, 1, 4 * varDiv + 1, 4 * varAnd, 4, 4, 0xF);
+    CopyBgTilemapBufferToVram(0);
+
+    if (++task->tData2 > 63)
+    {
+        DestroyTask(FindTaskIdByFunc(sub_814ABE4));
+        task->tState++;
+    }
+
+    return FALSE;
+}
+
+#undef tSub32_X_delta
+#undef tSub32_Y_delta
+#undef tSub32_Bool
+
+static bool8 Phase2_32_Func5(struct Task *task)
+{
+    gBattle_BG0_X = 0;
+    gBattle_BG0_Y = 0;
+    SetGpuReg(REG_OFFSET_BG0VOFS, 0);
+    SetGpuReg(REG_OFFSET_BG0HOFS, gBattle_BG0_Y);
+
+    FillBgTilemapBufferRect_Palette0(0, 1, 0, 0, 0x20, 0x20);
+    CopyBgTilemapBufferToVram(0);
+    BlendPalettes(0xFFFFFFFF, 0x10, 0);
+
+    DestroyTask(FindTaskIdByFunc(task->func));
+    task->tState++; // UB: changing value of a destroyed task
+    return FALSE;
+}
+
+#undef tData1
+#undef tData2
+#undef tData3
+#undef tData4
+#undef tData5
+#undef tData6
+#undef tData7
diff --git a/src/berry_fix_program.c b/src/berry_fix_program.c
index 3b2bfb5f7..f487489d4 100644
--- a/src/berry_fix_program.c
+++ b/src/berry_fix_program.c
@@ -141,7 +141,7 @@ void InitBerryFixProgram(void)
     SetVBlankCallback(NULL);
     ResetSpriteData();
     ResetTasks();
-    remove_some_task();
+    ScanlineEffect_Stop();
     SetGpuReg(REG_OFFSET_DISPCNT, 0x0000);
     berry_fix_mb_manager = AllocZeroed(0x50);
     berry_fix_mb_manager->state = 0;
diff --git a/src/bg.c b/src/bg.c
index 74e3ea830..b699a0b1f 100644
--- a/src/bg.c
+++ b/src/bg.c
@@ -1007,7 +1007,7 @@ void CopyToBgTilemapBufferRect_ChangePalette(u8 bg, void *src, u8 destX, u8 dest
 }
 // Skipping for now, it probably uses structs passed by value
 /*
-void CopyRectToBgTilemapBufferRect(u8 bg, void* src, u8 srcX, u8 srcY, u8 srcWidth, u8 srcHeight, u8 destX, u8 destY, u8 rectWidth, u8 rectHeight, u8 palette1, u16 tileOffset, u16 palette2)
+void CopyRectToBgTilemapBufferRect(u8 bg, const void* src, u8 srcX, u8 srcY, u8 srcWidth, u8 srcHeight, u8 destX, u8 destY, u8 rectWidth, u8 rectHeight, u8 palette1, u16 tileOffset, u16 palette2)
 {
     u16 attribute;
     u16 mode;
@@ -1049,7 +1049,7 @@ void CopyRectToBgTilemapBufferRect(u8 bg, void* src, u8 srcX, u8 srcY, u8 srcWid
     }
 }*/
 __attribute__((naked))
-void CopyRectToBgTilemapBufferRect(u8 bg, void* src, u8 srcX, u8 srcY, u8 srcWidth, u8 srcHeight, u8 destX, u8 destY, u8 rectWidth, u8 rectHeight, u8 palette1, u16 tileOffset, u16 palette2)
+void CopyRectToBgTilemapBufferRect(u8 bg, const void* src, u8 srcX, u8 srcY, u8 srcWidth, u8 srcHeight, u8 destX, u8 destY, u8 rectWidth, u8 rectHeight, u8 palette1, u16 tileOffset, u16 palette2)
 {
     asm("push {r4-r7,lr}\n\
     mov r7, r10\n\
diff --git a/src/braille_puzzles.c b/src/braille_puzzles.c
index d6924de9f..d6924de9f 100755..100644
--- a/src/braille_puzzles.c
+++ b/src/braille_puzzles.c
diff --git a/src/clear_save_data_screen.c b/src/clear_save_data_screen.c
index 6d6a1545b..6d6a1545b 100755..100644
--- a/src/clear_save_data_screen.c
+++ b/src/clear_save_data_screen.c
diff --git a/src/diploma.c b/src/diploma.c
index d4a269757..fedc10bd0 100755..100644
--- a/src/diploma.c
+++ b/src/diploma.c
@@ -72,7 +72,7 @@ void CB2_ShowDiploma(void)
     DmaFill16(3, 0, VRAM, VRAM_SIZE);
     DmaFill32(3, 0, OAM, OAM_SIZE);
     DmaFill16(3, 0, PLTT, PLTT_SIZE);
-    remove_some_task();
+    ScanlineEffect_Stop();
     ResetTasks();
     ResetSpriteData();
     ResetPaletteFade();
diff --git a/src/egg_hatch.c b/src/egg_hatch.c
index 1aff894b9..37f2b2e19 100644
--- a/src/egg_hatch.c
+++ b/src/egg_hatch.c
@@ -66,7 +66,7 @@ extern void overworld_free_bg_tilemaps(void);
 extern void sub_80AF168(void);
 extern void AllocateMonSpritesGfx(void);
 extern void FreeMonSpritesGfx(void);
-extern void remove_some_task(void);
+extern void ScanlineEffect_Stop(void);
 extern void reset_temp_tile_data_buffers(void);
 extern void c2_exit_to_overworld_2_switch(void);
 extern void play_some_sound(void);
@@ -512,7 +512,7 @@ static void CB2_EggHatch_0(void)
         FreeAllSpritePalettes();
         ResetSpriteData();
         ResetTasks();
-        remove_some_task();
+        ScanlineEffect_Stop();
         m4aSoundVSyncOn();
         gMain.state++;
         break;
diff --git a/src/evolution_scene.c b/src/evolution_scene.c
index 4b59147ff..5dfc36cb2 100644
--- a/src/evolution_scene.c
+++ b/src/evolution_scene.c
@@ -269,7 +269,7 @@ void EvolutionScene(struct Pokemon* mon, u16 speciesToEvolve, bool8 canStopEvo,
     sub_80356D0();
     LoadBattleTextboxAndBackground();
     ResetSpriteData();
-    remove_some_task();
+    ScanlineEffect_Stop();
     ResetTasks();
     FreeAllSpritePalettes();
 
diff --git a/src/field_map_obj.c b/src/field_map_obj.c
index df80494b3..df80494b3 100755..100644
--- a/src/field_map_obj.c
+++ b/src/field_map_obj.c
diff --git a/src/field_special_scene.c b/src/field_special_scene.c
index a704beaab..a704beaab 100755..100644
--- a/src/field_special_scene.c
+++ b/src/field_special_scene.c
diff --git a/src/hall_of_fame.c b/src/hall_of_fame.c
index 4465f65a3..3e70e22fa 100644
--- a/src/hall_of_fame.c
+++ b/src/hall_of_fame.c
@@ -1302,7 +1302,7 @@ static void ClearVramOamPltt_LoadHofPal(void)
 
 static void sub_8174F70(void)
 {
-    remove_some_task();
+    ScanlineEffect_Stop();
     ResetTasks();
     ResetSpriteData();
     reset_temp_tile_data_buffers();
diff --git a/src/hof_pc.c b/src/hof_pc.c
new file mode 100644
index 000000000..e772f04e8
--- /dev/null
+++ b/src/hof_pc.c
@@ -0,0 +1,46 @@
+#include "global.h"
+#include "hall_of_fame.h"
+#include "main.h"
+#include "palette.h"
+#include "overworld.h"
+#include "script.h"
+#include "script_menu.h"
+#include "task.h"
+
+extern void (*gFieldCallback)(void);
+extern void (*gUnknown_0300485C)(void);
+
+extern void Overworld_PlaySpecialMapMusic(void);
+extern bool16 ScrSpecial_CreatePCMenu(void);
+extern void ScriptMenu_DisplayPCStartupPrompt(void);
+
+static void ReshowPCMenuAfterHallOfFamePC(void);
+static void Task_WaitForPaletteFade(u8);
+
+void AccessHallOfFamePC(void)
+{
+    SetMainCallback2(CB2_DoHallOfFamePC);
+    ScriptContext2_Enable();
+}
+
+void ReturnFromHallOfFamePC(void)
+{
+    SetMainCallback2(c2_exit_to_overworld_2_switch);
+    gFieldCallback = ReshowPCMenuAfterHallOfFamePC;
+}
+
+static void ReshowPCMenuAfterHallOfFamePC(void)
+{
+    ScriptContext2_Enable();
+    Overworld_PlaySpecialMapMusic();
+    ScrSpecial_CreatePCMenu();
+    ScriptMenu_DisplayPCStartupPrompt();
+    BeginNormalPaletteFade(0xFFFFFFFF, 0, 0x10, 0, 0);
+    CreateTask(Task_WaitForPaletteFade, 10);
+}
+
+static void Task_WaitForPaletteFade(u8 taskId)
+{
+    if (!gPaletteFade.active)
+        DestroyTask(taskId);
+}
diff --git a/src/item.c b/src/item.c
index 931027e25..a17599db9 100644
--- a/src/item.c
+++ b/src/item.c
@@ -1,5 +1,6 @@
 #include "global.h"
 #include "item.h"
+#include "berry.h"
 #include "constants/items.h"
 #include "string_util.h"
 #include "text.h"
@@ -11,7 +12,6 @@ extern bool8 InBattlePyramid(void);
 extern const u8 gText_PokeBalls[];
 extern const u8 gText_Berries[];
 extern const u8 gText_Berry[];
-extern const u8 gUnknown_085897E4[][28]; // not sure what this one is
 
 bool8 CheckPyramidBagHasItem(u16 itemId, u16 count);
 bool8 CheckPyramidBagHasSpace(u16 itemId, u16 count);
@@ -96,8 +96,8 @@ void CopyItemNameHandlePlural(u16 itemId, u8 *string, u32 quantity)
     }
     else
     {
-        if (itemId >= 0x85 && itemId <= 0xAF)
-            GetBerryCountString(string, gUnknown_085897E4[itemId], quantity);
+        if (itemId >= ITEM_CHERI_BERRY && itemId <= ITEM_ENIGMA_BERRY)
+            GetBerryCountString(string, gBerries[itemId - ITEM_CHERI_BERRY].name, quantity);
         else
             StringCopy(string, ItemId_GetItem(itemId)->name);
     }
diff --git a/src/libisagbprn.c b/src/libisagbprn.c
index e0e979e95..e0e979e95 100755..100644
--- a/src/libisagbprn.c
+++ b/src/libisagbprn.c
diff --git a/src/mail.c b/src/mail.c
index 68a55e242..c3cbe4a3c 100644
--- a/src/mail.c
+++ b/src/mail.c
@@ -240,30 +240,6 @@ static const struct MailLayout sUnknown_0859F458[] = {
     { 0x05, 0x09, 0x60, 0x05, 0x1e, Unknown_0859F444 }
 };
 
-// What the heck are these meant to be? Call them u16 for now.
-
-static const u16 Unknown_0859F4E8[] = {
-    0x00, 0x4000, 0x00, 0x00
-};
-
-static const u16 Unknown_0859F4F0[] = {
-    0x00, 0x00, -1, 0x00
-};
-
-static const u16 Unknown_0859F4F8[] = {
-    0x04, 0x00, -1, 0x00
-};
-
-static const u16 Unknown_0859F500[] = {
-    0x00, 0x40, -1, 0x00
-};
-
-static const u16 *const sUnknown_0859F508[] = {
-    Unknown_0859F4F0,
-    Unknown_0859F4F8,
-    Unknown_0859F500
-};
-
 // .text
 
 void ReadMail(struct MailStruct *mail, void (*callback)(void), bool8 flag)
@@ -329,7 +305,7 @@ static bool8 MailReadBuildGraphics(void)
     {
         case 0:
             SetVBlankCallback(NULL);
-            remove_some_task();
+            ScanlineEffect_Stop();
             SetGpuReg(REG_OFFSET_DISPCNT, 0x0000);
             break;
         case 1:
diff --git a/src/main.c b/src/main.c
index 07b7d9147..d4601293b 100644
--- a/src/main.c
+++ b/src/main.c
@@ -29,7 +29,7 @@ extern void MapMusicMain(void);
 extern void EnableInterrupts(u16);
 extern void sub_8033648(void);
 extern u16 SetFlashTimerIntr(u8 timerNum, void (**intrFunc)(void));
-extern void remove_some_task(void);
+extern void ScanlineEffect_Stop(void);
 
 extern struct SoundInfo gSoundInfo;
 extern u32 gFlashMemoryPresent;
@@ -425,7 +425,7 @@ void DoSoftReset(void)
 {
     REG_IME = 0;
     m4aSoundVSyncOff();
-    remove_some_task();
+    ScanlineEffect_Stop();
     DmaStop(1);
     DmaStop(2);
     DmaStop(3);
diff --git a/src/mystery_event_msg.c b/src/mystery_event_msg.c
new file mode 100644
index 000000000..74261179b
--- /dev/null
+++ b/src/mystery_event_msg.c
@@ -0,0 +1,13 @@
+#include "global.h"
+
+const u8 gText_MysteryGiftBerry[] = _("Obtained a {STR_VAR_2} BERRY!\nDad has it at PETALBURG GYM.");
+const u8 gText_MysteryGiftBerryTransform[] = _("The {STR_VAR_1} BERRY transformed into\none {STR_VAR_2} BERRY.");
+const u8 gText_MysteryGiftBerryObtained[] = _("The {STR_VAR_1} BERRY has already been\nobtained.");
+const u8 gText_MysteryGiftSpecialRibbon[] = _("A special RIBBON was awarded to\nyour party POKéMON.");
+const u8 gText_MysteryGiftNationalDex[] = _("The POKéDEX has been upgraded\nwith the NATIONAL MODE.");
+const u8 gText_MysteryGiftRareWord[] = _("A rare word has been added.");
+const u8 gText_MysteryGiftSentOver[] = _("{STR_VAR_1} was sent over!");
+const u8 gText_MysteryGiftFullParty[] = _("Your party is full.\n{STR_VAR_1} could not be sent over.");
+const u8 gText_MysteryGiftNewTrainer[] = _("A new TRAINER has arrived in\nHOENN.");
+const u8 gText_MysteryGiftNewAdversaryInBattleTower[] = _("A new adversary has arrived in the\nBATTLE TOWER.");
+const u8 gText_MysteryGiftCantBeUsed[] = _("This data can’t be used in\nthis version.");
diff --git a/src/mystery_event_script.c b/src/mystery_event_script.c
new file mode 100644
index 000000000..8822cd05a
--- /dev/null
+++ b/src/mystery_event_script.c
@@ -0,0 +1,396 @@
+#include "global.h"
+#include "berry.h"
+#include "battle_tower.h"
+#include "easy_chat.h"
+#include "event_data.h"
+#include "mail.h"
+#include "mystery_event_script.h"
+#include "pokedex.h"
+#include "pokemon.h"
+#include "pokemon_size_record.h"
+#include "script.h"
+#include "constants/species.h"
+#include "strings.h"
+#include "string_util.h"
+#include "text.h"
+#include "util.h"
+#include "mystery_event_msg.h"
+#include "pokemon_storage_system.h"
+
+extern void sub_811EFC0(u8);
+extern void ValidateEReaderTrainer(void);
+
+extern ScrCmdFunc gMysteryEventScriptCmdTable[];
+extern ScrCmdFunc gMysteryEventScriptCmdTableEnd[];
+
+#define LANGUAGE_MASK 0x1
+#define VERSION_MASK 0x200
+
+EWRAM_DATA static struct ScriptContext sMysteryEventScriptContext = {0};
+
+static bool32 CheckCompatibility(u16 a1, u32 a2, u16 a3, u32 a4)
+{
+    if (!(a1 & LANGUAGE_MASK))
+        return FALSE;
+
+    if (!(a2 & LANGUAGE_MASK))
+        return FALSE;
+
+    if (!(a3 & 0x4))
+        return FALSE;
+
+    if (!(a4 & VERSION_MASK))
+        return FALSE;
+
+    return TRUE;
+}
+
+static void SetIncompatible(void)
+{
+    StringExpandPlaceholders(gStringVar4, gText_MysteryGiftCantBeUsed);
+    SetMysteryEventScriptStatus(3);
+}
+
+static void InitMysteryEventScript(struct ScriptContext *ctx, u8 *script)
+{
+    InitScriptContext(ctx, gMysteryEventScriptCmdTable, gMysteryEventScriptCmdTableEnd);
+    SetupBytecodeScript(ctx, script);
+    ctx->data[0] = (u32)script;
+    ctx->data[1] = 0;
+    ctx->data[2] = 0;
+    ctx->data[3] = 0;
+}
+
+static bool32 RunMysteryEventScriptCommand(struct ScriptContext *ctx)
+{
+    if (RunScriptCommand(ctx) && ctx->data[3])
+        return TRUE;
+    else
+        return FALSE;
+}
+
+void sub_8153870(u8 *script)
+{
+    InitMysteryEventScript(&sMysteryEventScriptContext, script);
+}
+
+bool32 sub_8153884(u32 *a0)
+{
+    bool32 ret = RunMysteryEventScriptCommand(&sMysteryEventScriptContext);
+    *a0 = sMysteryEventScriptContext.data[2];
+
+    return ret;
+}
+
+u32 RunMysteryEventScript(u8 *script)
+{
+    struct ScriptContext *ctx = &sMysteryEventScriptContext;
+    InitMysteryEventScript(ctx, script);
+    while (RunMysteryEventScriptCommand(ctx));
+
+    return ctx->data[2];
+}
+
+void SetMysteryEventScriptStatus(u32 val)
+{
+    sMysteryEventScriptContext.data[2] = val;
+}
+
+static int CalcRecordMixingGiftChecksum(void)
+{
+    unsigned int i;
+    int sum = 0;
+    u8 *data = (u8*)(&gSaveBlock1Ptr->recordMixingGift.data);
+
+    for (i = 0; i < sizeof(gSaveBlock1Ptr->recordMixingGift.data); i++)
+        sum += data[i];
+
+    return sum;
+}
+
+static bool32 IsRecordMixingGiftValid(void)
+{
+    struct RecordMixingGiftData *data = &gSaveBlock1Ptr->recordMixingGift.data;
+    int checksum = CalcRecordMixingGiftChecksum();
+
+    if (data->unk0 == 0
+        || data->quantity == 0
+        || data->itemId == 0
+        || checksum == 0
+        || checksum != gSaveBlock1Ptr->recordMixingGift.checksum)
+        return FALSE;
+    else
+        return TRUE;
+}
+
+static void ClearRecordMixingGift(void)
+{
+    CpuFill16(0, &gSaveBlock1Ptr->recordMixingGift, sizeof(gSaveBlock1Ptr->recordMixingGift));
+}
+
+static void SetRecordMixingGift(u8 unk, u8 quantity, u16 itemId)
+{
+    if (!unk || !quantity || !itemId)
+    {
+        ClearRecordMixingGift();
+    }
+    else
+    {
+        gSaveBlock1Ptr->recordMixingGift.data.unk0 = unk;
+        gSaveBlock1Ptr->recordMixingGift.data.quantity = quantity;
+        gSaveBlock1Ptr->recordMixingGift.data.itemId = itemId;
+        gSaveBlock1Ptr->recordMixingGift.checksum = CalcRecordMixingGiftChecksum();
+    }
+}
+
+u16 GetRecordMixingGift(void)
+{
+    struct RecordMixingGiftData *data = &gSaveBlock1Ptr->recordMixingGift.data;
+
+    if (!IsRecordMixingGiftValid())
+    {
+        ClearRecordMixingGift();
+        return 0;
+    }
+    else
+    {
+        u16 itemId = data->itemId;
+        data->quantity--;
+        if (data->quantity == 0)
+            ClearRecordMixingGift();
+        else
+            gSaveBlock1Ptr->recordMixingGift.checksum = CalcRecordMixingGiftChecksum();
+
+        return itemId;
+    }
+}
+
+bool8 MEScrCmd_end(struct ScriptContext *ctx)
+{
+    StopScript(ctx);
+    return TRUE;
+}
+
+bool8 MEScrCmd_checkcompat(struct ScriptContext *ctx)
+{
+    u16 v1;
+    u32 v2;
+    u16 v3;
+    u32 v4;
+
+    ctx->data[1] = ScriptReadWord(ctx);
+    v1 = ScriptReadHalfword(ctx);
+    v2 = ScriptReadWord(ctx);
+    v3 = ScriptReadHalfword(ctx);
+    v4 = ScriptReadWord(ctx);
+
+    if (CheckCompatibility(v1, v2, v3, v4) == TRUE)
+        ctx->data[3] = 1;
+    else
+        SetIncompatible();
+
+    return TRUE;
+}
+
+bool8 MEScrCmd_nop(struct ScriptContext *ctx)
+{
+    return FALSE;
+}
+
+bool8 MEScrCmd_setstatus(struct ScriptContext *ctx)
+{
+    u8 value = ScriptReadByte(ctx);
+    ctx->data[2] = value;
+    return FALSE;
+}
+
+bool8 MEScrCmd_setmsg(struct ScriptContext *ctx)
+{
+    u8 value = ScriptReadByte(ctx);
+    u8 *str = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]);
+    if (value == 0xFF || value == ctx->data[2])
+        StringExpandPlaceholders(gStringVar4, str);
+    return FALSE;
+}
+
+bool8 MEScrCmd_runscript(struct ScriptContext *ctx)
+{
+    u8 *script = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]);
+    ScriptContext2_RunNewScript(script);
+    return FALSE;
+}
+
+bool8 MEScrCmd_setenigmaberry(struct ScriptContext *ctx)
+{
+    u8 *str;
+    const u8 *message;
+    bool32 haveBerry = IsEnigmaBerryValid();
+    u8 *berry = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]);
+    StringCopyN(gStringVar1, gSaveBlock1Ptr->enigmaBerry.berry.name, BERRY_NAME_COUNT);
+    SetEnigmaBerry(berry);
+    StringCopyN(gStringVar2, gSaveBlock1Ptr->enigmaBerry.berry.name, BERRY_NAME_COUNT);
+
+    if (!haveBerry)
+    {
+        str = gStringVar4;
+        message = gText_MysteryGiftBerry;
+    }
+    else if (StringCompare(gStringVar1, gStringVar2))
+    {
+        str = gStringVar4;
+        message = gText_MysteryGiftBerryTransform;
+    }
+    else
+    {
+        str = gStringVar4;
+        message = gText_MysteryGiftBerryObtained;
+    }
+
+    StringExpandPlaceholders(str, message);
+
+    ctx->data[2] = 2;
+
+    if (IsEnigmaBerryValid() == TRUE)
+        VarSet(VAR_ENIGMA_BERRY_AVAILABLE, 1);
+    else
+        ctx->data[2] = 1;
+
+    return FALSE;
+}
+
+bool8 MEScrCmd_giveribbon(struct ScriptContext *ctx)
+{
+    u8 index = ScriptReadByte(ctx);
+    u8 ribbonId = ScriptReadByte(ctx);
+    GiveGiftRibbonToParty(index, ribbonId);
+    StringExpandPlaceholders(gStringVar4, gText_MysteryGiftSpecialRibbon);
+    ctx->data[2] = 2;
+    return FALSE;
+}
+
+bool8 MEScrCmd_initramscript(struct ScriptContext *ctx)
+{
+    u8 mapGroup = ScriptReadByte(ctx);
+    u8 mapNum = ScriptReadByte(ctx);
+    u8 objectId = ScriptReadByte(ctx);
+    u8 *script = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]);
+    u8 *scriptEnd = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]);
+    InitRamScript(script, scriptEnd - script, mapGroup, mapNum, objectId);
+    return FALSE;
+}
+
+bool8 MEScrCmd_givenationaldex(struct ScriptContext *ctx)
+{
+    EnableNationalPokedex();
+    StringExpandPlaceholders(gStringVar4, gText_MysteryGiftNationalDex);
+    ctx->data[2] = 2;
+    return FALSE;
+}
+
+bool8 MEScrCmd_addrareword(struct ScriptContext *ctx)
+{
+    sub_811EFC0(ScriptReadByte(ctx));
+    StringExpandPlaceholders(gStringVar4, gText_MysteryGiftRareWord);
+    ctx->data[2] = 2;
+    return FALSE;
+}
+
+bool8 MEScrCmd_setrecordmixinggift(struct ScriptContext *ctx)
+{
+    u8 unk = ScriptReadByte(ctx);
+    u8 quantity = ScriptReadByte(ctx);
+    u16 itemId = ScriptReadHalfword(ctx);
+    SetRecordMixingGift(unk, quantity, itemId);
+    return FALSE;
+}
+
+bool8 MEScrCmd_givepokemon(struct ScriptContext *ctx)
+{
+    struct MailStruct mail;
+    struct Pokemon pokemon;
+    u16 species;
+    u16 heldItem;
+    u32 data = ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0];
+    void *pokemonPtr = (void *)data;
+    void *mailPtr = (void *)(data + sizeof(struct Pokemon));
+
+    pokemon = *(struct Pokemon *)pokemonPtr;
+    species = GetMonData(&pokemon, MON_DATA_SPECIES2);
+
+    if (species == SPECIES_EGG)
+        StringCopyN(gStringVar1, gText_EggNickname, POKEMON_NAME_LENGTH + 1);
+    else
+        StringCopyN(gStringVar1, gText_Pokemon, POKEMON_NAME_LENGTH + 1);
+
+    if (gPlayerPartyCount == PARTY_SIZE)
+    {
+        StringExpandPlaceholders(gStringVar4, gText_MysteryGiftFullParty);
+        ctx->data[2] = 3;
+    }
+    else
+    {
+        memcpy(&gPlayerParty[5], pokemonPtr, sizeof(struct Pokemon));
+        memcpy(&mail, mailPtr, sizeof(struct MailStruct));
+
+        if (species != SPECIES_EGG)
+        {
+            u16 pokedexNum = SpeciesToNationalPokedexNum(species);
+            GetSetPokedexFlag(pokedexNum, FLAG_SET_SEEN);
+            GetSetPokedexFlag(pokedexNum, FLAG_SET_CAUGHT);
+        }
+
+        heldItem = GetMonData(&gPlayerParty[5], MON_DATA_HELD_ITEM);
+        if (ItemIsMail(heldItem))
+            GiveMailToMon2(&gPlayerParty[5], &mail);
+        CompactPartySlots();
+        CalculatePlayerPartyCount();
+        StringExpandPlaceholders(gStringVar4, gText_MysteryGiftSentOver);
+        ctx->data[2] = 2;
+    }
+
+    return FALSE;
+}
+
+bool8 MEScrCmd_addtrainer(struct ScriptContext *ctx)
+{
+    u32 data = ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0];
+    memcpy((void*)(gSaveBlock2Ptr) + 0xBEC, (void *)data, 0xBC);
+    ValidateEReaderTrainer();
+    StringExpandPlaceholders(gStringVar4, gText_MysteryGiftNewTrainer);
+    ctx->data[2] = 2;
+    return FALSE;
+}
+
+bool8 MEScrCmd_enableresetrtc(struct ScriptContext *ctx)
+{
+    EnableResetRTC();
+    StringExpandPlaceholders(gStringVar4, gText_InGameClockUsable);
+    ctx->data[2] = 2;
+    return FALSE;
+}
+
+bool8 MEScrCmd_checksum(struct ScriptContext *ctx)
+{
+    int checksum = ScriptReadWord(ctx);
+    u8 *data = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]);
+    u8 *dataEnd = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]);
+    if (checksum != CalcByteArraySum(data, dataEnd - data))
+    {
+        ctx->data[3] = 0;
+        ctx->data[2] = 1;
+    }
+    return TRUE;
+}
+
+bool8 MEScrCmd_crc(struct ScriptContext *ctx)
+{
+    int crc = ScriptReadWord(ctx);
+    u8 *data = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]);
+    u8 *dataEnd = (u8 *)(ScriptReadWord(ctx) - ctx->data[1] + ctx->data[0]);
+    if (crc != CalcCRC16(data, dataEnd - data))
+    {
+        ctx->data[3] = 0;
+        ctx->data[2] = 1;
+    }
+    return TRUE;
+}
diff --git a/src/option_menu.c b/src/option_menu.c
new file mode 100644
index 000000000..7f92756ab
--- /dev/null
+++ b/src/option_menu.c
@@ -0,0 +1,662 @@
+#include "global.h"
+#include "option_menu.h"
+#include "main.h"
+#include "menu.h"
+#include "unknown_task.h"
+#include "palette.h"
+#include "sprite.h"
+#include "task.h"
+#include "bg.h"
+#include "gpu_regs.h"
+#include "window.h"
+#include "text.h"
+#include "text_window.h"
+#include "international_string_util.h"
+#include "strings.h"
+
+extern void SetPokemonCryStereo(u32 val);
+
+// Task data
+enum
+{
+    TD_MENUSELECTION,
+    TD_TEXTSPEED,
+    TD_BATTLESCENE,
+    TD_BATTLESTYLE,
+    TD_SOUND,
+    TD_BUTTONMODE,
+    TD_FRAMETYPE,
+};
+
+// Menu items
+enum
+{
+    MENUITEM_TEXTSPEED,
+    MENUITEM_BATTLESCENE,
+    MENUITEM_BATTLESTYLE,
+    MENUITEM_SOUND,
+    MENUITEM_BUTTONMODE,
+    MENUITEM_FRAMETYPE,
+    MENUITEM_CANCEL,
+    MENUITEM_COUNT,
+};
+
+// Window Ids
+enum
+{
+    WIN_TEXT_OPTION,
+    WIN_OPTIONS
+};
+
+// this file's functions
+static void Task_OptionMenuFadeIn(u8 taskId);
+static void Task_OptionMenuProcessInput(u8 taskId);
+static void Task_OptionMenuSave(u8 taskId);
+static void Task_OptionMenuFadeOut(u8 taskId);
+static void HighlightOptionMenuItem(u8 selection);
+static u8   TextSpeed_ProcessInput(u8 selection);
+static void TextSpeed_DrawChoices(u8 selection);
+static u8   BattleScene_ProcessInput(u8 selection);
+static void BattleScene_DrawChoices(u8 selection);
+static u8   BattleStyle_ProcessInput(u8 selection);
+static void BattleStyle_DrawChoices(u8 selection);
+static u8   Sound_ProcessInput(u8 selection);
+static void Sound_DrawChoices(u8 selection);
+static u8   FrameType_ProcessInput(u8 selection);
+static void FrameType_DrawChoices(u8 selection);
+static u8   ButtonMode_ProcessInput(u8 selection);
+static void ButtonMode_DrawChoices(u8 selection);
+static void DrawTextOption(void);
+static void DrawOptionMenuTexts(void);
+static void sub_80BB154(void);
+
+// EWRAM vars
+EWRAM_DATA static bool8 sArrowPressed = FALSE;
+
+// const rom data
+static const u16 sUnknown_0855C604[] = INCBIN_U16("graphics/misc/option_menu_text.gbapal");
+// note: this is only used in the Japanese release
+static const u8 sEqualSignGfx[] = INCBIN_U8("graphics/misc/option_menu_equals_sign.4bpp");
+
+static const u8 *const sOptionMenuItemsNames[MENUITEM_COUNT] =
+{
+    gText_TextSpeed,
+    gText_BattleScene,
+    gText_BattleStyle,
+    gText_Sound,
+    gText_ButtonMode,
+    gText_Frame,
+    gText_OptionMenuCancel,
+};
+
+static const struct WindowTemplate sOptionMenuWinTemplates[] =
+{
+    {1, 2, 1, 0x1A, 2, 1, 2},
+    {0, 2, 5, 0x1A, 0xE, 1, 0x36},
+    DUMMY_WIN_TEMPLATE
+};
+
+static const struct BgTemplate sOptionMenuBgTemplates[] =
+{
+   {
+       .bg = 1,
+       .charBaseIndex = 1,
+       .mapBaseIndex = 30,
+       .screenSize = 0,
+       .paletteMode = 0,
+       .priority = 0,
+       .baseTile = 0
+   },
+   {
+       .bg = 0,
+       .charBaseIndex = 1,
+       .mapBaseIndex = 31,
+       .screenSize = 0,
+       .paletteMode = 0,
+       .priority = 1,
+       .baseTile = 0
+   }
+};
+
+static const u16 sUnknown_0855C6A0[] = {0x7E51};
+
+// code
+static void MainCB2(void)
+{
+    RunTasks();
+    AnimateSprites();
+    BuildOamBuffer();
+    UpdatePaletteFade();
+}
+
+static void VBlankCB(void)
+{
+    LoadOam();
+    ProcessSpriteCopyRequests();
+    TransferPlttBuffer();
+}
+
+void CB2_InitOptionMenu(void)
+{
+    switch (gMain.state)
+    {
+    default:
+    case 0:
+        SetVBlankCallback(NULL);
+        gMain.state++;
+        break;
+    case 1:
+    {
+        u8 *addr;
+        u32 size;
+
+        addr = (u8 *)VRAM;
+        size = 0x18000;
+        while (1)
+        {
+            DmaFill16(3, 0, addr, 0x1000);
+            addr += 0x1000;
+            size -= 0x1000;
+            if (size <= 0x1000)
+            {
+                DmaFill16(3, 0, addr, size);
+                break;
+            }
+        }
+        DmaClear32(3, OAM, OAM_SIZE);
+        DmaClear16(3, PLTT, PLTT_SIZE);
+        SetGpuReg(REG_OFFSET_DISPCNT, 0);
+        ResetBgsAndClearDma3BusyFlags(0);
+        InitBgsFromTemplates(0, sOptionMenuBgTemplates, ARRAY_COUNT(sOptionMenuBgTemplates));
+        ChangeBgX(0, 0, 0);
+        ChangeBgY(0, 0, 0);
+        ChangeBgX(1, 0, 0);
+        ChangeBgY(1, 0, 0);
+        ChangeBgX(2, 0, 0);
+        ChangeBgY(2, 0, 0);
+        ChangeBgX(3, 0, 0);
+        ChangeBgY(3, 0, 0);
+        InitWindows(sOptionMenuWinTemplates);
+        DeactivateAllTextPrinters();
+        SetGpuReg(REG_OFFSET_WIN0H, 0);
+        SetGpuReg(REG_OFFSET_WIN0V, 0);
+        SetGpuReg(REG_OFFSET_WININ, 1);
+        SetGpuReg(REG_OFFSET_WINOUT, 35);
+        SetGpuReg(REG_OFFSET_BLDCNT, 193);
+        SetGpuReg(REG_OFFSET_BLDALPHA, 0);
+        SetGpuReg(REG_OFFSET_BLDY, 4);
+        SetGpuReg(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON | DISPCNT_OBJ_ON | DISPCNT_OBJ_1D_MAP);
+        ShowBg(0);
+        ShowBg(1);
+        gMain.state++;
+    }
+        break;
+    case 2:
+        ResetPaletteFade();
+        ScanlineEffect_Stop();
+        ResetTasks();
+        ResetSpriteData();
+        gMain.state++;
+        break;
+    case 3:
+        LoadBgTiles(1, GetWindowFrameTilesPal(gSaveBlock2Ptr->optionsWindowFrameType)->tiles, 0x120, 0x1A2);
+        gMain.state++;
+        break;
+    case 4:
+        LoadPalette(sUnknown_0855C6A0, 0, sizeof(sUnknown_0855C6A0));
+        LoadPalette(GetWindowFrameTilesPal(gSaveBlock2Ptr->optionsWindowFrameType)->pal, 0x70, 0x20);
+        gMain.state++;
+        break;
+    case 5:
+        LoadPalette(sUnknown_0855C604, 0x10, sizeof(sUnknown_0855C604));
+        gMain.state++;
+        break;
+    case 6:
+        PutWindowTilemap(0);
+        DrawTextOption();
+        gMain.state++;
+        break;
+    case 7:
+        gMain.state++;
+        break;
+    case 8:
+        PutWindowTilemap(1);
+        DrawOptionMenuTexts();
+        gMain.state++;
+    case 9:
+        sub_80BB154();
+        gMain.state++;
+        break;
+    case 10:
+    {
+        u8 taskId = CreateTask(Task_OptionMenuFadeIn, 0);
+
+        gTasks[taskId].data[TD_MENUSELECTION] = 0;
+        gTasks[taskId].data[TD_TEXTSPEED] = gSaveBlock2Ptr->optionsTextSpeed;
+        gTasks[taskId].data[TD_BATTLESCENE] = gSaveBlock2Ptr->optionsBattleSceneOff;
+        gTasks[taskId].data[TD_BATTLESTYLE] = gSaveBlock2Ptr->optionsBattleStyle;
+        gTasks[taskId].data[TD_SOUND] = gSaveBlock2Ptr->optionsSound;
+        gTasks[taskId].data[TD_BUTTONMODE] = gSaveBlock2Ptr->optionsButtonMode;
+        gTasks[taskId].data[TD_FRAMETYPE] = gSaveBlock2Ptr->optionsWindowFrameType;
+
+        TextSpeed_DrawChoices(gTasks[taskId].data[TD_TEXTSPEED]);
+        BattleScene_DrawChoices(gTasks[taskId].data[TD_BATTLESCENE]);
+        BattleStyle_DrawChoices(gTasks[taskId].data[TD_BATTLESTYLE]);
+        Sound_DrawChoices(gTasks[taskId].data[TD_SOUND]);
+        ButtonMode_DrawChoices(gTasks[taskId].data[TD_BUTTONMODE]);
+        FrameType_DrawChoices(gTasks[taskId].data[TD_FRAMETYPE]);
+        HighlightOptionMenuItem(gTasks[taskId].data[TD_MENUSELECTION]);
+
+        CopyWindowToVram(WIN_OPTIONS, 3);
+        gMain.state++;
+        break;
+    }
+    case 11:
+        BeginNormalPaletteFade(-1, 0, 0x10, 0, 0);
+        SetVBlankCallback(VBlankCB);
+        SetMainCallback2(MainCB2);
+        return;
+    }
+}
+
+static void Task_OptionMenuFadeIn(u8 taskId)
+{
+    if (!gPaletteFade.active)
+        gTasks[taskId].func = Task_OptionMenuProcessInput;
+}
+
+static void Task_OptionMenuProcessInput(u8 taskId)
+{
+    if (gMain.newKeys & A_BUTTON)
+    {
+        if (gTasks[taskId].data[TD_MENUSELECTION] == MENUITEM_CANCEL)
+            gTasks[taskId].func = Task_OptionMenuSave;
+    }
+    else if (gMain.newKeys & B_BUTTON)
+    {
+        gTasks[taskId].func = Task_OptionMenuSave;
+    }
+    else if (gMain.newKeys & DPAD_UP)
+    {
+        if (gTasks[taskId].data[TD_MENUSELECTION] > 0)
+            gTasks[taskId].data[TD_MENUSELECTION]--;
+        else
+            gTasks[taskId].data[TD_MENUSELECTION] = 6;
+        HighlightOptionMenuItem(gTasks[taskId].data[TD_MENUSELECTION]);
+    }
+    else if (gMain.newKeys & DPAD_DOWN)
+    {
+        if (gTasks[taskId].data[TD_MENUSELECTION] <= 5)
+            gTasks[taskId].data[TD_MENUSELECTION]++;
+        else
+            gTasks[taskId].data[TD_MENUSELECTION] = 0;
+        HighlightOptionMenuItem(gTasks[taskId].data[TD_MENUSELECTION]);
+    }
+    else
+    {
+        u8 previousOption;
+
+        switch (gTasks[taskId].data[TD_MENUSELECTION])
+        {
+        case MENUITEM_TEXTSPEED:
+            previousOption = gTasks[taskId].data[TD_TEXTSPEED];
+            gTasks[taskId].data[TD_TEXTSPEED] = TextSpeed_ProcessInput(gTasks[taskId].data[TD_TEXTSPEED]);
+
+            if (previousOption != gTasks[taskId].data[TD_TEXTSPEED])
+                TextSpeed_DrawChoices(gTasks[taskId].data[TD_TEXTSPEED]);
+            break;
+        case MENUITEM_BATTLESCENE:
+            previousOption = gTasks[taskId].data[TD_BATTLESCENE];
+            gTasks[taskId].data[TD_BATTLESCENE] = BattleScene_ProcessInput(gTasks[taskId].data[TD_BATTLESCENE]);
+
+            if (previousOption != gTasks[taskId].data[TD_BATTLESCENE])
+                BattleScene_DrawChoices(gTasks[taskId].data[TD_BATTLESCENE]);
+            break;
+        case MENUITEM_BATTLESTYLE:
+            previousOption = gTasks[taskId].data[TD_BATTLESTYLE];
+            gTasks[taskId].data[TD_BATTLESTYLE] = BattleStyle_ProcessInput(gTasks[taskId].data[TD_BATTLESTYLE]);
+
+            if (previousOption != gTasks[taskId].data[TD_BATTLESTYLE])
+                BattleStyle_DrawChoices(gTasks[taskId].data[TD_BATTLESTYLE]);
+            break;
+        case MENUITEM_SOUND:
+            previousOption = gTasks[taskId].data[TD_SOUND];
+            gTasks[taskId].data[TD_SOUND] = Sound_ProcessInput(gTasks[taskId].data[TD_SOUND]);
+
+            if (previousOption != gTasks[taskId].data[TD_SOUND])
+                Sound_DrawChoices(gTasks[taskId].data[TD_SOUND]);
+            break;
+        case MENUITEM_BUTTONMODE:
+            previousOption = gTasks[taskId].data[TD_BUTTONMODE];
+            gTasks[taskId].data[TD_BUTTONMODE] = ButtonMode_ProcessInput(gTasks[taskId].data[TD_BUTTONMODE]);
+
+            if (previousOption != gTasks[taskId].data[TD_BUTTONMODE])
+                ButtonMode_DrawChoices(gTasks[taskId].data[TD_BUTTONMODE]);
+            break;
+        case MENUITEM_FRAMETYPE:
+            previousOption = gTasks[taskId].data[TD_FRAMETYPE];
+            gTasks[taskId].data[TD_FRAMETYPE] = FrameType_ProcessInput(gTasks[taskId].data[TD_FRAMETYPE]);
+
+            if (previousOption != gTasks[taskId].data[TD_FRAMETYPE])
+                FrameType_DrawChoices(gTasks[taskId].data[TD_FRAMETYPE]);
+            break;
+        default:
+            return;
+        }
+
+        if (sArrowPressed)
+        {
+            sArrowPressed = FALSE;
+            CopyWindowToVram(WIN_OPTIONS, 2);
+        }
+    }
+}
+
+static void Task_OptionMenuSave(u8 taskId)
+{
+    gSaveBlock2Ptr->optionsTextSpeed = gTasks[taskId].data[TD_TEXTSPEED];
+    gSaveBlock2Ptr->optionsBattleSceneOff = gTasks[taskId].data[TD_BATTLESCENE];
+    gSaveBlock2Ptr->optionsBattleStyle = gTasks[taskId].data[TD_BATTLESTYLE];
+    gSaveBlock2Ptr->optionsSound = gTasks[taskId].data[TD_SOUND];
+    gSaveBlock2Ptr->optionsButtonMode = gTasks[taskId].data[TD_BUTTONMODE];
+    gSaveBlock2Ptr->optionsWindowFrameType = gTasks[taskId].data[TD_FRAMETYPE];
+
+    BeginNormalPaletteFade(-1, 0, 0, 0x10, 0);
+    gTasks[taskId].func = Task_OptionMenuFadeOut;
+}
+
+static void Task_OptionMenuFadeOut(u8 taskId)
+{
+    if (!gPaletteFade.active)
+    {
+        DestroyTask(taskId);
+        FreeAllWindowBuffers();
+        SetMainCallback2(gMain.savedCallback);
+    }
+}
+
+static void HighlightOptionMenuItem(u8 index)
+{
+    SetGpuReg(REG_OFFSET_WIN0H, WIN_RANGE(16, 224));
+    SetGpuReg(REG_OFFSET_WIN0V, WIN_RANGE(index * 16 + 40, index * 16 + 56));
+}
+
+static void DrawOptionMenuChoice(const u8 *text, u8 x, u8 y, u8 style)
+{
+    u8 dst[16];
+    u16 i;
+
+    for (i = 0; *text != EOS && i <= 14; i++)
+        dst[i] = *(text++);
+
+    if (style != 0)
+    {
+        dst[2] = 4;
+        dst[5] = 5;
+    }
+
+    dst[i] = EOS;
+    PrintTextOnWindow(WIN_OPTIONS, 1, dst, x, y + 1, TEXT_SPEED_FF, NULL);
+}
+
+static u8 TextSpeed_ProcessInput(u8 selection)
+{
+    if (gMain.newKeys & DPAD_RIGHT)
+    {
+        if (selection <= 1)
+            selection++;
+        else
+            selection = 0;
+
+        sArrowPressed = TRUE;
+    }
+    if (gMain.newKeys & DPAD_LEFT)
+    {
+        if (selection != 0)
+            selection--;
+        else
+            selection = 2;
+
+        sArrowPressed = TRUE;
+    }
+    return selection;
+}
+
+static void TextSpeed_DrawChoices(u8 selection)
+{
+    u8 styles[3];
+    s32 widthSlow, widthMid, widthFast, xMid;
+
+    styles[0] = 0;
+    styles[1] = 0;
+    styles[2] = 0;
+    styles[selection] = 1;
+
+    DrawOptionMenuChoice(gText_TextSpeedSlow, 104, 0, styles[0]);
+
+    widthSlow = GetStringWidth(1, gText_TextSpeedSlow, 0);
+    widthMid = GetStringWidth(1, gText_TextSpeedMid, 0);
+    widthFast = GetStringWidth(1, gText_TextSpeedFast, 0);
+
+    widthMid -= 94;
+    xMid = (widthSlow - widthMid - widthFast) / 2 + 104;
+    DrawOptionMenuChoice(gText_TextSpeedMid, xMid, 0, styles[1]);
+
+    DrawOptionMenuChoice(gText_TextSpeedFast, GetStringRightAlignXOffset(1, gText_TextSpeedFast, 198), 0, styles[2]);
+}
+
+static u8 BattleScene_ProcessInput(u8 selection)
+{
+    if (gMain.newKeys & (DPAD_LEFT | DPAD_RIGHT))
+    {
+        selection ^= 1;
+        sArrowPressed = TRUE;
+    }
+
+    return selection;
+}
+
+static void BattleScene_DrawChoices(u8 selection)
+{
+    u8 styles[2];
+
+    styles[0] = 0;
+    styles[1] = 0;
+    styles[selection] = 1;
+
+    DrawOptionMenuChoice(gText_BattleSceneOn, 104, 16, styles[0]);
+    DrawOptionMenuChoice(gText_BattleSceneOff, GetStringRightAlignXOffset(1, gText_BattleSceneOff, 198), 16, styles[1]);
+}
+
+static u8 BattleStyle_ProcessInput(u8 selection)
+{
+    if (gMain.newKeys & (DPAD_LEFT | DPAD_RIGHT))
+    {
+        selection ^= 1;
+        sArrowPressed = TRUE;
+    }
+
+    return selection;
+}
+
+static void BattleStyle_DrawChoices(u8 selection)
+{
+    u8 styles[2];
+
+    styles[0] = 0;
+    styles[1] = 0;
+    styles[selection] = 1;
+
+    DrawOptionMenuChoice(gText_BattleStyleShift, 104, 32, styles[0]);
+    DrawOptionMenuChoice(gText_BattleStyleSet, GetStringRightAlignXOffset(1, gText_BattleStyleSet, 198), 32, styles[1]);
+}
+
+static u8 Sound_ProcessInput(u8 selection)
+{
+    if (gMain.newKeys & (DPAD_LEFT | DPAD_RIGHT))
+    {
+        selection ^= 1;
+        SetPokemonCryStereo(selection);
+        sArrowPressed = TRUE;
+    }
+
+    return selection;
+}
+
+static void Sound_DrawChoices(u8 selection)
+{
+    u8 styles[2];
+
+    styles[0] = 0;
+    styles[1] = 0;
+    styles[selection] = 1;
+
+    DrawOptionMenuChoice(gText_SoundMono, 104, 48, styles[0]);
+    DrawOptionMenuChoice(gText_SoundStereo, GetStringRightAlignXOffset(1, gText_SoundStereo, 198), 48, styles[1]);
+}
+
+static u8 FrameType_ProcessInput(u8 selection)
+{
+    if (gMain.newKeys & DPAD_RIGHT)
+    {
+        if (selection < WINDOW_FRAMES_COUNT - 1)
+            selection++;
+        else
+            selection = 0;
+
+        LoadBgTiles(1, GetWindowFrameTilesPal(selection)->tiles, 0x120, 0x1A2);
+        LoadPalette(GetWindowFrameTilesPal(selection)->pal, 0x70, 0x20);
+        sArrowPressed = TRUE;
+    }
+    if (gMain.newKeys & DPAD_LEFT)
+    {
+        if (selection != 0)
+            selection--;
+        else
+            selection = WINDOW_FRAMES_COUNT - 1;
+
+        LoadBgTiles(1, GetWindowFrameTilesPal(selection)->tiles, 0x120, 0x1A2);
+        LoadPalette(GetWindowFrameTilesPal(selection)->pal, 0x70, 0x20);
+        sArrowPressed = TRUE;
+    }
+    return selection;
+}
+
+static void FrameType_DrawChoices(u8 selection)
+{
+    u8 text[16];
+    u8 n = selection + 1;
+    u16 i;
+
+    for (i = 0; gText_FrameTypeNumber[i] != EOS && i <= 5; i++)
+        text[i] = gText_FrameTypeNumber[i];
+
+    // Convert a number to decimal string
+    if (n / 10 != 0)
+    {
+        text[i] = n / 10 + CHAR_0;
+        i++;
+        text[i] = n % 10 + CHAR_0;
+        i++;
+    }
+    else
+    {
+        text[i] = n % 10 + CHAR_0;
+        i++;
+        text[i] = 0x77;
+        i++;
+    }
+
+    text[i] = EOS;
+
+    DrawOptionMenuChoice(gText_FrameType, 104, 80, 0);
+    DrawOptionMenuChoice(text, 128, 80, 1);
+}
+
+static u8 ButtonMode_ProcessInput(u8 selection)
+{
+    if (gMain.newKeys & DPAD_RIGHT)
+    {
+        if (selection <= 1)
+            selection++;
+        else
+            selection = 0;
+
+        sArrowPressed = TRUE;
+    }
+    if (gMain.newKeys & DPAD_LEFT)
+    {
+        if (selection != 0)
+            selection--;
+        else
+            selection = 2;
+
+        sArrowPressed = TRUE;
+    }
+    return selection;
+}
+
+static void ButtonMode_DrawChoices(u8 selection)
+{
+    s32 widthNormal, widthLR, widthLA, xLR;
+    u8 styles[3];
+
+    styles[0] = 0;
+    styles[1] = 0;
+    styles[2] = 0;
+    styles[selection] = 1;
+
+    DrawOptionMenuChoice(gText_ButtonTypeNormal, 104, 64, styles[0]);
+
+    widthNormal = GetStringWidth(1, gText_ButtonTypeNormal, 0);
+    widthLR = GetStringWidth(1, gText_ButtonTypeLR, 0);
+    widthLA = GetStringWidth(1, gText_ButtonTypeLEqualsA, 0);
+
+    widthLR -= 94;
+    xLR = (widthNormal - widthLR - widthLA) / 2 + 104;
+    DrawOptionMenuChoice(gText_ButtonTypeLR, xLR, 64, styles[1]);
+
+    DrawOptionMenuChoice(gText_ButtonTypeLEqualsA, GetStringRightAlignXOffset(1, gText_ButtonTypeLEqualsA, 198), 64, styles[2]);
+}
+
+static void DrawTextOption(void)
+{
+    FillWindowPixelBuffer(WIN_TEXT_OPTION, 0x11);
+    PrintTextOnWindow(WIN_TEXT_OPTION, 1, gText_Option, 8, 1, TEXT_SPEED_FF, NULL);
+    CopyWindowToVram(WIN_TEXT_OPTION, 3);
+}
+
+static void DrawOptionMenuTexts(void)
+{
+    u8 i;
+
+    FillWindowPixelBuffer(WIN_OPTIONS, 0x11);
+    for (i = 0; i < MENUITEM_COUNT; i++)
+    {
+        PrintTextOnWindow(WIN_OPTIONS, 1, sOptionMenuItemsNames[i], 8, (i * 16) + 1, TEXT_SPEED_FF, NULL);
+    }
+    CopyWindowToVram(WIN_OPTIONS, 3);
+}
+
+static void sub_80BB154(void)
+{
+    //                   bg, tileNum, x,    y,    width, height,  pal
+    FillBgTilemapBufferRect(1, 0x1A2, 1,    0,      1,      1,      7);
+    FillBgTilemapBufferRect(1, 0x1A3, 2,    0,      0x1B,   1,      7);
+    FillBgTilemapBufferRect(1, 0x1A4, 28,   0,      1,      1,      7);
+    FillBgTilemapBufferRect(1, 0x1A5, 1,    1,      1,      2,      7);
+    FillBgTilemapBufferRect(1, 0x1A7, 28,   1,      1,      2,      7);
+    FillBgTilemapBufferRect(1, 0x1A8, 1,    3,      1,      1,      7);
+    FillBgTilemapBufferRect(1, 0x1A9, 2,    3,      0x1B,   1,      7);
+    FillBgTilemapBufferRect(1, 0x1AA, 28,   3,      1,      1,      7);
+    FillBgTilemapBufferRect(1, 0x1A2, 1,    4,      1,      1,      7);
+    FillBgTilemapBufferRect(1, 0x1A3, 2,    4,      0x1A,   1,      7);
+    FillBgTilemapBufferRect(1, 0x1A4, 28,   4,      1,      1,      7);
+    FillBgTilemapBufferRect(1, 0x1A5, 1,    5,      1,      0x12,   7);
+    FillBgTilemapBufferRect(1, 0x1A7, 28,   5,      1,      0x12,   7);
+    FillBgTilemapBufferRect(1, 0x1A8, 1,    19,     1,      1,      7);
+    FillBgTilemapBufferRect(1, 0x1A9, 2,    19,     0x1A,   1,      7);
+    FillBgTilemapBufferRect(1, 0x1AA, 28,   19,     1,      1,      7);
+
+    CopyBgTilemapBufferToVram(1);
+}
diff --git a/src/pokeblock.c b/src/pokeblock.c
index 737f2c6f3..573eed52b 100644
--- a/src/pokeblock.c
+++ b/src/pokeblock.c
@@ -419,7 +419,7 @@ static bool8 InitPokeblockMenu(void)
         gMain.state++;
         break;
     case 1:
-        remove_some_task();
+        ScanlineEffect_Stop();
         gMain.state++;
         break;
     case 2:
diff --git a/src/pokemon_summary_screen.c b/src/pokemon_summary_screen.c
index e56448d8b..a900badd1 100755..100644
--- a/src/pokemon_summary_screen.c
+++ b/src/pokemon_summary_screen.c
@@ -75,7 +75,7 @@ extern u8 sub_81221AC();
 extern void SetVBlankHBlankCallbacksToNull();
 extern void ResetVramOamAndBgCntRegs();
 extern void clear_scheduled_bg_copies_to_vram();
-extern void remove_some_task();
+extern void ScanlineEffect_Stop();
 extern void ResetBgsAndClearDma3BusyFlags(u32 leftoverFireRedLeafGreenVariable);
 extern void ShowBg(u8 a);
 extern void SetGpuReg(u8 regOffset, u16 value);
@@ -455,7 +455,7 @@ bool8 sub_81BFB10(void)
         gMain.state++;
         break;
     case 1:
-        remove_some_task();
+        ScanlineEffect_Stop();
         gMain.state++;
         break;
     case 2:
diff --git a/src/save_failed_screen.c b/src/save_failed_screen.c
index 218ef68d7..8764daa5f 100755..100644
--- a/src/save_failed_screen.c
+++ b/src/save_failed_screen.c
@@ -9,6 +9,7 @@
 #include "menu.h"
 #include "save.h"
 #include "gba/flash_internal.h"
+#include "text_window.h"
 
 #define MSG_WIN_TOP 12
 #define CLOCK_WIN_TOP (MSG_WIN_TOP - 4)
@@ -21,9 +22,7 @@ extern const u8 gBirchHelpGfx[];
 extern const u8 gBirchBagTilemap[];
 extern const u8 gBirchGrassTilemap[];
 extern const u16 gBirchBagGrassPal[];
-extern const u16 gUnknown_0850FEFC[];
 extern const u16 gUnknown_0860F074[];
-extern const u32 gUnknown_0850E87C[];
 extern struct SaveSection gSaveDataBuffer;
 
 extern u8 gText_SaveFailedCheckingBackup[];
@@ -226,7 +225,7 @@ static void CB2_SaveFailedScreen(void)
             InitBgsFromTemplates(0, gUnknown_085EFD88, 3);
             SetBgTilemapBuffer(0, (void *)&gDecompressionBuffer[0x2000]);
             CpuFill32(0, &gDecompressionBuffer[0x2000], 0x800);
-            LoadBgTiles(0, gUnknown_0850E87C, 0x120, 0x214);
+            LoadBgTiles(0, gTextWindowFrame1_Gfx, 0x120, 0x214);
             InitWindows(gUnknown_085EFD94);
             // AddWindowWithoutTileMap returns a u16/integer, but the info is clobbered into a u8 here resulting in lost info. Bug?
             gSaveFailedWindowIds[TEXT_WIN_ID] = AddWindowWithoutTileMap(gUnknown_085EFD9C);
@@ -239,7 +238,7 @@ static void CB2_SaveFailedScreen(void)
             ResetPaletteFade();
             LoadPalette(gBirchBagGrassPal, 0, 0x40);
             LoadPalette(sSaveFailedClockPal, 0x100, 0x20);
-            LoadPalette(gUnknown_0850FEFC, 0xE0, 0x20);
+            LoadPalette(gTextWindowFrame1_Pal, 0xE0, 0x20);
             LoadPalette(gUnknown_0860F074, 0xF0, 0x20);
             SetWindowBorderStyle(gSaveFailedWindowIds[TEXT_WIN_ID], FALSE, 0x214, 0xE);
             SetWindowBorderStyle(gSaveFailedWindowIds[CLOCK_WIN_ID], FALSE, 0x214, 0xE);
diff --git a/src/save_location.c b/src/save_location.c
index 262aaf40c..262aaf40c 100755..100644
--- a/src/save_location.c
+++ b/src/save_location.c
diff --git a/src/starter_choose.c b/src/starter_choose.c
index 2d78af8fb..83a7b8112 100644
--- a/src/starter_choose.c
+++ b/src/starter_choose.c
@@ -53,7 +53,7 @@ extern const u8 gUnknown_085B1E0C[];
 extern const u8 gUnknown_085B1E28[][2];
 
 extern void sub_809882C(u8, u16, u8);
-extern void remove_some_task(void);
+extern void ScanlineEffect_Stop(void);
 extern void clear_scheduled_bg_copies_to_vram(void);
 extern void dp13_810BB8C(void);
 extern void do_scheduled_bg_tilemap_copies_to_vram(void);
@@ -74,7 +74,7 @@ static void Task_MoveStarterChooseCursor(u8 taskId);
 static void sub_8134668(u8 taskId);
 static void CreateStarterPokemonLabel(u8 selection);
 static u8 CreatePokemonFrontSprite(u16 species, u8 x, u8 y);
-static void StarterPokemonSpriteCallback(struct Sprite *sprite);
+void StarterPokemonSpriteCallback(struct Sprite *sprite);
 
 static IWRAM_DATA u16 sStarterChooseWindowId;
 
@@ -134,7 +134,7 @@ void CB2_ChooseStarter(void)
     DeactivateAllTextPrinters();
     sub_809882C(0, 0x2A8, 0xD0);
     clear_scheduled_bg_copies_to_vram();
-    remove_some_task();
+    ScanlineEffect_Stop();
     ResetTasks();
     ResetSpriteData();
     ResetPaletteFade();
@@ -361,7 +361,7 @@ static u8 CreatePokemonFrontSprite(u16 species, u8 x, u8 y)
     return spriteId;
 }
 
-static void sub_81346DC(struct Sprite *sprite)
+void sub_81346DC(struct Sprite *sprite)
 {
     sprite->pos1.x = gUnknown_085B1E28[gTasks[sprite->data[0]].tStarterSelection][0];
     sprite->pos1.y = gUnknown_085B1E28[gTasks[sprite->data[0]].tStarterSelection][1];
@@ -369,7 +369,7 @@ static void sub_81346DC(struct Sprite *sprite)
     sprite->data[1] = (u8)(sprite->data[1]) + 4;
 }
 
-static void sub_813473C(struct Sprite *sprite)
+void sub_813473C(struct Sprite *sprite)
 {
     if (gTasks[sprite->data[0]].tStarterSelection == sprite->data[1])
         StartSpriteAnimIfDifferent(sprite, 1);
@@ -377,7 +377,7 @@ static void sub_813473C(struct Sprite *sprite)
         StartSpriteAnimIfDifferent(sprite, 0);
 }
 
-static void StarterPokemonSpriteCallback(struct Sprite *sprite)
+void StarterPokemonSpriteCallback(struct Sprite *sprite)
 {
     //Move sprite to upper center of screen
     if (sprite->pos1.x > STARTER_PKMN_POS_X)
diff --git a/src/text_window.c b/src/text_window.c
index 336536c04..33cd7cffe 100644
--- a/src/text_window.c
+++ b/src/text_window.c
@@ -3,26 +3,97 @@
 #include "text_window.h"
 #include "window.h"
 #include "palette.h"
-
-extern u8 LoadBgTiles(u8 bg, const void *src, u16 size, u16 destOffset);
-extern void FillBgTilemapBufferRect(u8 bg, u16 tileNum, u8 x, u8 y, u8 width, u8 height, u8 palette);
-
-extern const struct TilesPal gUnknown_0851021C[];
-extern const u32 gUnknown_08DDD748[];
-extern const u16 gUnknown_0851017C[];
-extern const u16 gUnknown_08DDD728[];
-
-const struct TilesPal* sub_8098758(u8 id)
+#include "bg.h"
+#include "graphics.h"
+
+// const rom data
+const u32 gTextWindowFrame1_Gfx[] = INCBIN_U32("graphics/text_window/1.4bpp");
+static const u32 sTextWindowFrame2_Gfx[] = INCBIN_U32("graphics/text_window/2.4bpp");
+static const u32 sTextWindowFrame3_Gfx[] = INCBIN_U32("graphics/text_window/3.4bpp");
+static const u32 sTextWindowFrame4_Gfx[] = INCBIN_U32("graphics/text_window/4.4bpp");
+static const u32 sTextWindowFrame5_Gfx[] = INCBIN_U32("graphics/text_window/5.4bpp");
+static const u32 sTextWindowFrame6_Gfx[] = INCBIN_U32("graphics/text_window/6.4bpp");
+static const u32 sTextWindowFrame7_Gfx[] = INCBIN_U32("graphics/text_window/7.4bpp");
+static const u32 sTextWindowFrame8_Gfx[] = INCBIN_U32("graphics/text_window/8.4bpp");
+static const u32 sTextWindowFrame9_Gfx[] = INCBIN_U32("graphics/text_window/9.4bpp");
+static const u32 sTextWindowFrame10_Gfx[] = INCBIN_U32("graphics/text_window/10.4bpp");
+static const u32 sTextWindowFrame11_Gfx[] = INCBIN_U32("graphics/text_window/11.4bpp");
+static const u32 sTextWindowFrame12_Gfx[] = INCBIN_U32("graphics/text_window/12.4bpp");
+static const u32 sTextWindowFrame13_Gfx[] = INCBIN_U32("graphics/text_window/13.4bpp");
+static const u32 sTextWindowFrame14_Gfx[] = INCBIN_U32("graphics/text_window/14.4bpp");
+static const u32 sTextWindowFrame15_Gfx[] = INCBIN_U32("graphics/text_window/15.4bpp");
+static const u32 sTextWindowFrame16_Gfx[] = INCBIN_U32("graphics/text_window/16.4bpp");
+static const u32 sTextWindowFrame17_Gfx[] = INCBIN_U32("graphics/text_window/17.4bpp");
+static const u32 sTextWindowFrame18_Gfx[] = INCBIN_U32("graphics/text_window/18.4bpp");
+static const u32 sTextWindowFrame19_Gfx[] = INCBIN_U32("graphics/text_window/19.4bpp");
+static const u32 sTextWindowFrame20_Gfx[] = INCBIN_U32("graphics/text_window/20.4bpp");
+
+const u16 gTextWindowFrame1_Pal[] = INCBIN_U16("graphics/text_window/1.gbapal");
+static const u16 sTextWindowFrame2_Pal[] = INCBIN_U16("graphics/text_window/2.gbapal");
+static const u16 sTextWindowFrame3_Pal[] = INCBIN_U16("graphics/text_window/3.gbapal");
+static const u16 sTextWindowFrame4_Pal[] = INCBIN_U16("graphics/text_window/4.gbapal");
+static const u16 sTextWindowFrame5_Pal[] = INCBIN_U16("graphics/text_window/5.gbapal");
+static const u16 sTextWindowFrame6_Pal[] = INCBIN_U16("graphics/text_window/6.gbapal");
+static const u16 sTextWindowFrame7_Pal[] = INCBIN_U16("graphics/text_window/7.gbapal");
+static const u16 sTextWindowFrame8_Pal[] = INCBIN_U16("graphics/text_window/8.gbapal");
+static const u16 sTextWindowFrame9_Pal[] = INCBIN_U16("graphics/text_window/9.gbapal");
+static const u16 sTextWindowFrame10_Pal[] = INCBIN_U16("graphics/text_window/10.gbapal");
+static const u16 sTextWindowFrame11_Pal[] = INCBIN_U16("graphics/text_window/11.gbapal");
+static const u16 sTextWindowFrame12_Pal[] = INCBIN_U16("graphics/text_window/12.gbapal");
+static const u16 sTextWindowFrame13_Pal[] = INCBIN_U16("graphics/text_window/13.gbapal");
+static const u16 sTextWindowFrame14_Pal[] = INCBIN_U16("graphics/text_window/14.gbapal");
+static const u16 sTextWindowFrame15_Pal[] = INCBIN_U16("graphics/text_window/15.gbapal");
+static const u16 sTextWindowFrame16_Pal[] = INCBIN_U16("graphics/text_window/16.gbapal");
+static const u16 sTextWindowFrame17_Pal[] = INCBIN_U16("graphics/text_window/17.gbapal");
+static const u16 sTextWindowFrame18_Pal[] = INCBIN_U16("graphics/text_window/18.gbapal");
+static const u16 sTextWindowFrame19_Pal[] = INCBIN_U16("graphics/text_window/19.gbapal");
+static const u16 sTextWindowFrame20_Pal[] = INCBIN_U16("graphics/text_window/20.gbapal");
+
+static const u16 sUnknown_0851017C[][16] =
 {
-    if (id > 19)
-        return &gUnknown_0851021C[0];
+    INCBIN_U16("graphics/text_window/message_box.gbapal"),
+    INCBIN_U16("graphics/text_window/text_pal1.gbapal"),
+    INCBIN_U16("graphics/text_window/text_pal2.gbapal"),
+    INCBIN_U16("graphics/text_window/text_pal3.gbapal"),
+    INCBIN_U16("graphics/text_window/text_pal4.gbapal")
+};
+
+static const struct TilesPal sWindowFrames[WINDOW_FRAMES_COUNT] =
+{
+    {gTextWindowFrame1_Gfx, gTextWindowFrame1_Pal},
+    {sTextWindowFrame2_Gfx, sTextWindowFrame2_Pal},
+    {sTextWindowFrame3_Gfx, sTextWindowFrame3_Pal},
+    {sTextWindowFrame4_Gfx, sTextWindowFrame4_Pal},
+    {sTextWindowFrame5_Gfx, sTextWindowFrame5_Pal},
+    {sTextWindowFrame6_Gfx, sTextWindowFrame6_Pal},
+    {sTextWindowFrame7_Gfx, sTextWindowFrame7_Pal},
+    {sTextWindowFrame8_Gfx, sTextWindowFrame8_Pal},
+    {sTextWindowFrame9_Gfx, sTextWindowFrame9_Pal},
+    {sTextWindowFrame10_Gfx, sTextWindowFrame10_Pal},
+    {sTextWindowFrame11_Gfx, sTextWindowFrame11_Pal},
+    {sTextWindowFrame12_Gfx, sTextWindowFrame12_Pal},
+    {sTextWindowFrame13_Gfx, sTextWindowFrame13_Pal},
+    {sTextWindowFrame14_Gfx, sTextWindowFrame14_Pal},
+    {sTextWindowFrame15_Gfx, sTextWindowFrame15_Pal},
+    {sTextWindowFrame16_Gfx, sTextWindowFrame16_Pal},
+    {sTextWindowFrame17_Gfx, sTextWindowFrame17_Pal},
+    {sTextWindowFrame18_Gfx, sTextWindowFrame18_Pal},
+    {sTextWindowFrame19_Gfx, sTextWindowFrame19_Pal},
+    {sTextWindowFrame20_Gfx, sTextWindowFrame20_Pal}
+};
+
+// code
+const struct TilesPal *GetWindowFrameTilesPal(u8 id)
+{
+    if (id >= WINDOW_FRAMES_COUNT)
+        return &sWindowFrames[0];
     else
-        return &gUnknown_0851021C[id];
+        return &sWindowFrames[id];
 }
 
 void copy_textbox_border_tile_patterns_to_vram(u8 windowId, u16 destOffset, u8 palOffset)
 {
-    LoadBgTiles(GetWindowAttribute(windowId, WINDOW_PRIORITY), gUnknown_08DDD748, 0x1C0, destOffset);
+    LoadBgTiles(GetWindowAttribute(windowId, WINDOW_PRIORITY), gMessageBox_Gfx, 0x1C0, destOffset);
     LoadPalette(GetOverworldTextboxPalettePtr(), palOffset, 0x20);
 }
 
@@ -33,8 +104,8 @@ void box_border_load_tiles_and_pal(u8 windowId, u16 destOffset, u8 palOffset)
 
 void sub_80987D4(u8 windowId, u8 frameId, u16 destOffset, u8 palOffset)
 {
-    LoadBgTiles(GetWindowAttribute(windowId, WINDOW_PRIORITY), gUnknown_0851021C[frameId].tiles, 0x120, destOffset);
-    LoadPalette(gUnknown_0851021C[frameId].pal, palOffset, 0x20);
+    LoadBgTiles(GetWindowAttribute(windowId, WINDOW_PRIORITY), sWindowFrames[frameId].tiles, 0x120, destOffset);
+    LoadPalette(sWindowFrames[frameId].pal, palOffset, 0x20);
 }
 
 void sub_809882C(u8 windowId, u16 destOffset, u8 palOffset)
@@ -89,7 +160,7 @@ void rbox_fill_rectangle(u8 windowId)
     FillBgTilemapBufferRect(bgLayer, 0, tilemapLeft - 1, tilemapTop - 1, width + 2, height + 2, 0x11);
 }
 
-const u16* stdpal_get(u8 id)
+const u16 *stdpal_get(u8 id)
 {
     switch (id)
     {
@@ -110,16 +181,17 @@ const u16* stdpal_get(u8 id)
         id = 0x40;
         break;
     }
-    return &gUnknown_0851017C[id];
+
+    return (const u16 *)(sUnknown_0851017C) + id;
 }
 
-const u16* GetOverworldTextboxPalettePtr(void)
+const u16 *GetOverworldTextboxPalettePtr(void)
 {
-    return gUnknown_08DDD728;
+    return gMessageBox_Pal;
 }
 
 void sub_8098C6C(u8 bg, u16 destOffset, u8 palOffset)
 {
-    LoadBgTiles(bg, gUnknown_0851021C[gSaveBlock2Ptr->optionsWindowFrameType].tiles, 0x120, destOffset);
-    LoadPalette(sub_8098758(gSaveBlock2Ptr->optionsWindowFrameType)->pal, palOffset, 0x20);
+    LoadBgTiles(bg, sWindowFrames[gSaveBlock2Ptr->optionsWindowFrameType].tiles, 0x120, destOffset);
+    LoadPalette(GetWindowFrameTilesPal(gSaveBlock2Ptr->optionsWindowFrameType)->pal, palOffset, 0x20);
 }
diff --git a/src/tileset_anims.c b/src/tileset_anims.c
index 4ad787e1c..f89cfdd2b 100644
--- a/src/tileset_anims.c
+++ b/src/tileset_anims.c
@@ -5,6 +5,7 @@
 #include "blend_palette.h"
 #include "battle_transition.h"
 #include "task.h"
+#include "battle_transition.h"
 
 // Static type declarations
 
@@ -1392,7 +1393,7 @@ static void sub_80A1818(u16 a1)
 {
     CpuCopy16(gTilesetAnims_BattleDomePals0[a1 & 0x3], gPlttBufferUnfaded + 0x80, 32);
     BlendPalette(0x80, 0x10, gPaletteFade.y, gPaletteFade.blendColor & 0x7FFF);
-    if ((u8)FindTaskIdByFunc(sub_8149DFC) != 0xFF )
+    if ((u8)FindTaskIdByFunc(TransitionPhase1_Task_RunFuncs) != 0xFF )
     {
         sSecondaryTilesetCB = sub_80A1670;
         sSecondaryTilesetCBBufferSize = 0x20;
@@ -1402,7 +1403,7 @@ static void sub_80A1818(u16 a1)
 static void sub_80A1884(u16 a1)
 {
     CpuCopy16(gTilesetAnims_BattleDomePals0[a1 & 0x3], gPlttBufferUnfaded + 0x80, 32);
-    if ((u8)FindTaskIdByFunc(sub_8149DFC) == 0xFF )
+    if ((u8)FindTaskIdByFunc(TransitionPhase1_Task_RunFuncs) == 0xFF )
     {
         BlendPalette(0x80, 0x10, gPaletteFade.y, gPaletteFade.blendColor & 0x7FFF);
         if (!--sSecondaryTilesetCBBufferSize)
diff --git a/src/unk_transition.c b/src/unk_transition.c
new file mode 100644
index 000000000..feaddc8ce
--- /dev/null
+++ b/src/unk_transition.c
@@ -0,0 +1,633 @@
+#include "global.h"
+#include "sprite.h"
+#include "decompress.h"
+#include "unk_transition.h"
+#include "battle_transition.h"
+#include "task.h"
+#include "palette.h"
+#include "trig.h"
+#include "bg.h"
+#include "gpu_regs.h"
+
+typedef bool8 (*TransitionStateFunc)(struct Task *task);
+
+// this file's functions
+static void sub_81DA848(struct Sprite *sprite);
+static void sub_81DA9BC(struct Sprite *sprite);
+static bool8 sub_81DAACC(struct Task *task);
+static bool8 sub_81DAC14(struct Task *task);
+static bool8 sub_81DABBC(struct Task *task);
+static bool8 sub_81DAB4C(struct Task *task);
+static bool8 sub_81DAC80(struct Task *task);
+static bool8 sub_81DACEC(struct Task *task);
+static bool8 sub_81DAD58(struct Task *task);
+static bool8 sub_81DADC4(struct Task *task);
+static bool8 sub_81DAE44(struct Task *task);
+static bool8 sub_81DAEB0(struct Task *task);
+static bool8 sub_81DAF34(struct Task *task);
+static bool8 sub_81DAFA0(struct Task *task);
+static bool8 sub_81DB02C(struct Task *task);
+static bool8 sub_81DB098(struct Task *task);
+static bool8 sub_81DB124(struct Task *task);
+static bool8 sub_81DB190(struct Task *task);
+static bool8 sub_81DB224(struct Task *task);
+static bool8 sub_81DB290(struct Task *task);
+static bool8 sub_81DB328(struct Task *task);
+
+// const rom data
+// TODO: move those from .s file to .c
+extern const u8 gUnknown_0862AD54[];
+extern const u8 gUnknown_0862AF30[];
+extern const u8 gUnknown_0862B0DC[];
+extern const u16 gUnknown_0862B53C[];
+
+static const struct OamData sOamData_862B71C =
+{
+    .y = 0,
+    .affineMode = 0,
+    .objMode = 0,
+    .mosaic = 0,
+    .bpp = 0,
+    .shape = 0,
+    .x = 0,
+    .matrixNum = 0,
+    .size = 3,
+    .tileNum = 0,
+    .priority = 1,
+    .paletteNum = 0,
+    .affineParam = 0
+};
+
+static const struct CompressedSpriteSheet sUnknown_0862B724 =
+{
+    gUnknown_0862B0DC, 0x1800, 11920
+};
+
+static const struct SpritePalette sUnknown_0862B72C =
+{
+    gUnknown_0862B53C, 11920
+};
+
+static const union AnimCmd sSpriteAnim_862B734[] =
+{
+    ANIMCMD_FRAME(0, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_862B73C[] =
+{
+    ANIMCMD_FRAME(64, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd sSpriteAnim_862B744[] =
+{
+    ANIMCMD_FRAME(128, 1),
+    ANIMCMD_END
+};
+
+static const union AnimCmd *const sSpriteAnimTable_862B74C[] =
+{
+    sSpriteAnim_862B734,
+    sSpriteAnim_862B73C,
+    sSpriteAnim_862B744
+};
+
+static const struct SpriteTemplate sUnknown_0862B758 =
+{
+    .tileTag = 11920,
+    .paletteTag = 11920,
+    .oam = &sOamData_862B71C,
+    .anims = sSpriteAnimTable_862B74C,
+    .images = NULL,
+    .affineAnims = gDummySpriteAffineAnimTable,
+    .callback = SpriteCallbackDummy,
+};
+
+static const TransitionStateFunc sPhase2_34_Funcs[] =
+{
+    sub_81DAACC,
+    sub_81DAC14,
+    sub_81DABBC,
+    sub_81DAB4C,
+    sub_81DAC80
+};
+
+static const TransitionStateFunc sPhase2_35_Funcs[] =
+{
+    sub_81DAACC,
+    sub_81DACEC,
+    sub_81DABBC,
+    sub_81DAB4C,
+    sub_81DAD58
+};
+
+static const TransitionStateFunc sPhase2_36_Funcs[] =
+{
+    sub_81DAACC,
+    sub_81DADC4,
+    sub_81DABBC,
+    sub_81DAB4C,
+    sub_81DAE44
+};
+
+static const TransitionStateFunc sPhase2_37_Funcs[] =
+{
+    sub_81DAACC,
+    sub_81DAEB0,
+    sub_81DABBC,
+    sub_81DAB4C,
+    sub_81DAF34
+};
+
+static const TransitionStateFunc sPhase2_38_Funcs[] =
+{
+    sub_81DAACC,
+    sub_81DAFA0,
+    sub_81DABBC,
+    sub_81DAB4C,
+    sub_81DB02C
+};
+
+static const TransitionStateFunc sPhase2_39_Funcs[] =
+{
+    sub_81DAACC,
+    sub_81DB098,
+    sub_81DABBC,
+    sub_81DAB4C,
+    sub_81DB124
+};
+
+static const TransitionStateFunc sPhase2_40_Funcs[] =
+{
+    sub_81DAACC,
+    sub_81DB190,
+    sub_81DABBC,
+    sub_81DAB4C,
+    sub_81DB224
+};
+
+static const TransitionStateFunc sPhase2_41_Funcs[] =
+{
+    sub_81DAACC,
+    sub_81DB290,
+    sub_81DABBC,
+    sub_81DAB4C,
+    sub_81DB328
+};
+
+// code
+static void sub_81DA700(void)
+{
+    u16 *dst1, *dst2;
+
+    sub_8149F58(&dst1, &dst2);
+    LZ77UnCompVram(gUnknown_0862AD54, dst2);
+    LZ77UnCompVram(gUnknown_0862AF30, dst1);
+    LoadPalette(gUnknown_0862B53C, 0xF0, 0x20);
+    LoadCompressedObjectPic(&sUnknown_0862B724);
+    LoadSpritePalette(&sUnknown_0862B72C);
+}
+
+static u8 sub_81DA74C(s16 x, s16 y, u8 arg2, u8 arg3, s8 arg4, s8 arg5, u8 spriteAnimNum)
+{
+    u8 spriteId = CreateSprite(&sUnknown_0862B758, x, y, 0);
+
+    switch (spriteAnimNum)
+    {
+    case 0:
+        gSprites[spriteId].data[0] = 120;
+        gSprites[spriteId].data[1] = 45;
+        break;
+    case 1:
+        gSprites[spriteId].data[0] = 89;
+        gSprites[spriteId].data[1] = 97;
+        break;
+    case 2:
+        gSprites[spriteId].data[0] = 151;
+        gSprites[spriteId].data[1] = 97;
+        break;
+    }
+
+    gSprites[spriteId].data[2] = arg4;
+    gSprites[spriteId].data[3] = arg5;
+    gSprites[spriteId].data[6] = arg2;
+    gSprites[spriteId].data[7] = arg3;
+    gSprites[spriteId].data[4] = 0;
+    gSprites[spriteId].data[5] = 0;
+
+    StartSpriteAnim(&gSprites[spriteId], spriteAnimNum);
+    gSprites[spriteId].callback = sub_81DA848;
+
+    return spriteId;
+}
+
+static void sub_81DA848(struct Sprite *sprite)
+{
+    s16 *data = sprite->data;
+
+    if (sprite->pos1.x == data[0] && sprite->pos1.y == data[1])
+    {
+        sprite->callback = SpriteCallbackDummy;
+    }
+    else
+    {
+        if (data[4] == data[6])
+        {
+            sprite->pos1.x += data[2];
+            data[4] = 0;
+        }
+        else
+        {
+            data[4]++;
+        }
+
+        if (data[5] == data[7])
+        {
+            sprite->pos1.y += data[3];
+            data[5] = 0;
+        }
+        else
+        {
+            data[5]++;
+        }
+    }
+}
+
+static u8 sub_81DA8BC(s16 x, s16 y, s16 arg2, s16 arg3, s16 arg4, s16 arg5, s16 arg6, u8 spriteAnimNum)
+{
+    u8 spriteId = CreateSprite(&sUnknown_0862B758, x, y, 0);
+
+    switch (spriteAnimNum)
+    {
+    case 0:
+        gSprites[spriteId].data[0] = 120;
+        gSprites[spriteId].data[1] = 45;
+        break;
+    case 1:
+        gSprites[spriteId].data[0] = 89;
+        gSprites[spriteId].data[1] = 97;
+        break;
+    case 2:
+        gSprites[spriteId].data[0] = 151;
+        gSprites[spriteId].data[1] = 97;
+        break;
+    }
+
+    gSprites[spriteId].data[2] = arg2;
+    gSprites[spriteId].data[3] = arg3;
+    gSprites[spriteId].data[4] = arg4;
+    gSprites[spriteId].data[5] = arg5;
+    gSprites[spriteId].data[6] = arg6;
+
+    StartSpriteAnim(&gSprites[spriteId], spriteAnimNum);
+    gSprites[spriteId].callback = sub_81DA9BC;
+
+    return spriteId;
+}
+
+static void sub_81DA9BC(struct Sprite *sprite)
+{
+    sprite->pos2.x = (Sin2(sprite->data[2]) * sprite->data[4]) >> 12; // div by 4096
+    sprite->pos2.y = (Cos2(sprite->data[2]) * sprite->data[4]) >> 12; // div by 4096
+
+    sprite->data[2] = (sprite->data[2] + sprite->data[3]) % 360;
+
+    if (sprite->data[4] != sprite->data[5])
+        sprite->data[4] += sprite->data[6];
+    else
+        sprite->callback = SpriteCallbackDummy;
+}
+
+#define tState          data[0]
+
+static void sub_81DAA20(struct Task *task)
+{
+    FreeSpriteTilesByTag(11920);
+    FreeSpritePaletteByTag(11920);
+
+    DestroySprite(&gSprites[task->data[4]]);
+    DestroySprite(&gSprites[task->data[5]]);
+    DestroySprite(&gSprites[task->data[6]]);
+}
+
+static bool8 sub_81DAA74(struct Task *task)
+{
+    if (gSprites[task->data[4]].callback == SpriteCallbackDummy
+        && gSprites[task->data[5]].callback == SpriteCallbackDummy
+        && gSprites[task->data[6]].callback == SpriteCallbackDummy)
+        return TRUE;
+    else
+        return FALSE;
+}
+
+static bool8 sub_81DAACC(struct Task *task)
+{
+    if (task->data[1] == 0)
+    {
+        ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN0_ON);
+        ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_WIN1_ON);
+        ClearGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG0_ON);
+
+        task->data[1]++;
+        return FALSE;
+    }
+    else
+    {
+        sub_81DA700();
+        SetGpuReg(REG_OFFSET_BLDCNT, 0x3F41);
+        SetGpuReg(REG_OFFSET_BLDALPHA, 0x1000);
+        ChangeBgX(0, 0, 0);
+        ChangeBgY(0, 0, 0);
+        ChangeBgY(0, 0x500, 2);
+
+        task->data[1] = 0;
+        task->tState++;
+        return TRUE;
+    }
+}
+
+static bool8 sub_81DAB4C(struct Task *task)
+{
+    if (task->data[2] == 0)
+        SetGpuRegBits(REG_OFFSET_DISPCNT, DISPCNT_BG0_ON);
+
+    if (task->data[2] == 16)
+    {
+        if (task->data[3] == 31)
+        {
+            BeginNormalPaletteFade(-1, -1, 0, 0x10, 0);
+            task->tState++;
+        }
+        else
+        {
+            task->data[3]++;
+        }
+    }
+    else
+    {
+        u16 var;
+
+        task->data[2]++;
+        var = task->data[2];
+        SetGpuReg(REG_OFFSET_BLDALPHA, (var) | ((16 - var) << 8));
+    }
+
+    return FALSE;
+}
+
+static bool8 sub_81DABBC(struct Task *task)
+{
+    if (sub_81DAA74(task) == TRUE)
+        task->tState++;
+
+    return FALSE;
+}
+
+void Phase2Task_34(u8 taskId)
+{
+    while (sPhase2_34_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 sub_81DAC14(struct Task *task)
+{
+    task->data[4] = sub_81DA74C(120, -51, 0, 0, 0,   2, 0);
+    task->data[5] = sub_81DA74C(-7,  193, 0, 0, 2,  -2, 1);
+    task->data[6] = sub_81DA74C(247, 193, 0, 0, -2, -2, 2);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 sub_81DAC80(struct Task *task)
+{
+    if (!gPaletteFade.active)
+    {
+        sub_81DAA20(task);
+        DestroyTask(FindTaskIdByFunc(Phase2Task_34));
+    }
+
+    return FALSE;
+}
+
+void Phase2Task_35(u8 taskId)
+{
+    while (sPhase2_35_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 sub_81DACEC(struct Task *task)
+{
+    task->data[4] = sub_81DA74C(120, 197, 0, 0, 0, -4, 0);
+    task->data[5] = sub_81DA74C(241, 59,  0, 1, -4, 2, 1);
+    task->data[6] = sub_81DA74C(-1,  59,  0, 1, 4,  2, 2);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 sub_81DAD58(struct Task *task)
+{
+    if (!gPaletteFade.active)
+    {
+        sub_81DAA20(task);
+        DestroyTask(FindTaskIdByFunc(Phase2Task_35));
+    }
+
+    return FALSE;
+}
+
+void Phase2Task_36(u8 taskId)
+{
+    while (sPhase2_36_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 sub_81DADC4(struct Task *task)
+{
+    task->data[4] = sub_81DA8BC(120, 45, 12,  4, 128, 0, -4, 0);
+    task->data[5] = sub_81DA8BC(89,  97, 252, 4, 128, 0, -4, 1);
+    task->data[6] = sub_81DA8BC(151, 97, 132, 4, 128, 0, -4, 2);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 sub_81DAE44(struct Task *task)
+{
+    if (!gPaletteFade.active)
+    {
+        sub_81DAA20(task);
+        DestroyTask(FindTaskIdByFunc(Phase2Task_36));
+    }
+
+    return FALSE;
+}
+
+void Phase2Task_37(u8 taskId)
+{
+    while (sPhase2_37_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 sub_81DAEB0(struct Task *task)
+{
+    task->data[4] = sub_81DA8BC(120, 80, 284, 8, 131, 35, -3, 0);
+    task->data[5] = sub_81DA8BC(120, 80, 44,  8, 131, 35, -3, 1);
+    task->data[6] = sub_81DA8BC(121, 80, 164, 8, 131, 35, -3, 2);
+
+    task->tState++;
+    return FALSE;
+}
+
+static bool8 sub_81DAF34(struct Task *task)
+{
+    if (!gPaletteFade.active)
+    {
+        sub_81DAA20(task);
+        DestroyTask(FindTaskIdByFunc(Phase2Task_37));
+    }
+
+    return FALSE;
+}
+
+void Phase2Task_38(u8 taskId)
+{
+    while (sPhase2_38_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 sub_81DAFA0(struct Task *task)
+{
+    if (task->data[1] == 0)
+    {
+        task->data[4] = sub_81DA74C(120, -51, 0, 0, 0, 4,  0);
+    }
+    else if (task->data[1] == 16)
+    {
+        task->data[5] = sub_81DA74C(-7,  193, 0, 0, 4, -4, 1);
+    }
+    else if (task->data[1] == 32)
+    {
+        task->data[6] = sub_81DA74C(247, 193, 0, 0, -4, -4, 2);
+        task->tState++;
+    }
+
+    task->data[1]++;
+    return FALSE;
+}
+
+static bool8 sub_81DB02C(struct Task *task)
+{
+    if (!gPaletteFade.active)
+    {
+        sub_81DAA20(task);
+        DestroyTask(FindTaskIdByFunc(Phase2Task_38));
+    }
+
+    return FALSE;
+}
+
+void Phase2Task_39(u8 taskId)
+{
+    while (sPhase2_39_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 sub_81DB098(struct Task *task)
+{
+    if (task->data[1] == 0)
+    {
+        task->data[4] = sub_81DA74C(120, 197, 0, 0, 0, -8,  0);
+    }
+    else if (task->data[1] == 16)
+    {
+        task->data[5] = sub_81DA74C(241, 78,  0, 0, -8, 1,  1);
+    }
+    else if (task->data[1] == 32)
+    {
+        task->data[6] = sub_81DA74C(-1,  78,  0, 0, 8,  1,  2);
+        task->tState++;
+    }
+
+    task->data[1]++;
+    return FALSE;
+}
+
+static bool8 sub_81DB124(struct Task *task)
+{
+    if (!gPaletteFade.active)
+    {
+        sub_81DAA20(task);
+        DestroyTask(FindTaskIdByFunc(Phase2Task_39));
+    }
+
+    return FALSE;
+}
+
+void Phase2Task_40(u8 taskId)
+{
+    while (sPhase2_40_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 sub_81DB190(struct Task *task)
+{
+    if (task->data[1] == 0)
+    {
+        task->data[4] = sub_81DA8BC(120, 45, 12,  4, 128, 0, -4, 0);
+    }
+    else if (task->data[1] == 16)
+    {
+        task->data[5] = sub_81DA8BC(89,  97, 252, 4, 128, 0, -4, 1);
+    }
+    else if (task->data[1] == 32)
+    {
+        task->data[6] = sub_81DA8BC(151, 97, 132, 4, 128, 0, -4, 2);
+        task->tState++;
+    }
+
+    task->data[1]++;
+    return FALSE;
+}
+
+static bool8 sub_81DB224(struct Task *task)
+{
+    if (!gPaletteFade.active)
+    {
+        sub_81DAA20(task);
+        DestroyTask(FindTaskIdByFunc(Phase2Task_40));
+    }
+
+    return FALSE;
+}
+
+void Phase2Task_41(u8 taskId)
+{
+    while (sPhase2_41_Funcs[gTasks[taskId].tState](&gTasks[taskId]));
+}
+
+static bool8 sub_81DB290(struct Task *task)
+{
+    if (task->data[1] == 0)
+    {
+        task->data[4] = sub_81DA8BC(120, 80, 284, 8, 131, 35, -3, 0);
+    }
+    else if (task->data[1] == 16)
+    {
+        task->data[5] = sub_81DA8BC(120, 80, 44,  8, 131, 35, -3, 1);
+    }
+    else if (task->data[1] == 32)
+    {
+        task->data[6] = sub_81DA8BC(121, 80, 164, 8, 131, 35, -3, 2);
+        task->tState++;
+    }
+
+    task->data[1]++;
+    return FALSE;
+}
+
+static bool8 sub_81DB328(struct Task *task)
+{
+    if (!gPaletteFade.active)
+    {
+        sub_81DAA20(task);
+        DestroyTask(FindTaskIdByFunc(Phase2Task_41));
+    }
+
+    return FALSE;
+}
diff --git a/src/wallclock.c b/src/wallclock.c
index ea6137c5d..dbea24b4c 100644
--- a/src/wallclock.c
+++ b/src/wallclock.c
@@ -578,7 +578,7 @@ static void LoadWallClockGraphics(void)
     DeactivateAllTextPrinters();
     sub_809882C(0, 0x250, 0xd0);
     clear_scheduled_bg_copies_to_vram();
-    remove_some_task();
+    ScanlineEffect_Stop();
     ResetTasks();
     ResetSpriteData();
     ResetPaletteFade();