diff --git a/src/CRE/auth_2d.cpp b/src/CRE/auth_2d.cpp
index 85dfdf9a..dd378445 100644
--- a/src/CRE/auth_2d.cpp
+++ b/src/CRE/auth_2d.cpp
@@ -254,7 +254,7 @@ void AetComp::put_number_sprite(int32_t value, int32_t max_digits,
     if (!comp || !names || !spr_ids)
         return;
 
-    for (int32_t i = 0; i < max_digits && (all_digits || value); i++) {
+    for (int32_t i = 0; i < max_digits; i++) {
         int32_t digit = value % 10;
         value /= 10;
 
@@ -262,6 +262,9 @@ void AetComp::put_number_sprite(int32_t value, int32_t max_digits,
         if (layout)
             aet_layout_data::put_sprite(spr_ids[digit],
                 spr::SPR_ATTR_CTR_CC, prio, pos, layout, spr_db);
+
+        if (!all_digits && !value)
+            break;
     }
 }
 
diff --git a/src/CRE/pv_db.cpp b/src/CRE/pv_db.cpp
index 9a988d4e..c1b66f54 100644
--- a/src/CRE/pv_db.cpp
+++ b/src/CRE/pv_db.cpp
@@ -1434,6 +1434,7 @@ namespace pv_db {
                                     pv_db_pv_motion motion;
                                     motion.index = (int32_t)m;
                                     motion.id = aft_mot_db->get_motion_id(motion_name);
+                                    motion.name.assign(motion_name);
                                     d.motion[l].push_back(motion);
                                 }
 
@@ -1970,8 +1971,10 @@ namespace pv_db {
 
                 j.field.data.reserve(count);
                 for (int32_t k = 0; k <= count; k++) {
-                    if (!kv.open_scope_fmt("%02d", k))
+                    if (!kv.open_scope_fmt("%02d", k)) {
+                        j.field.data.push_back({});
                         continue;
+                    }
 
                     pv_db_pv_field field;
 
diff --git a/src/ReDIVA/game_state.cpp b/src/ReDIVA/game_state.cpp
index 4b73f210..188007f6 100644
--- a/src/ReDIVA/game_state.cpp
+++ b/src/ReDIVA/game_state.cpp
@@ -1141,16 +1141,17 @@ bool SubGameState::PhotoModeDemo::Dest() {
 }
 
 bool SubGameState::Selector::Init() {
-    app::TaskWork::AddTask(&x_pv_game_selector, "X PVGAME SELECTOR", 0);
+    x_pv_game_selector_init();
+    app::TaskWork::AddTask(x_pv_game_selector_ptr, "X PVGAME SELECTOR", 0);
     return true;
 }
 
 bool SubGameState::Selector::Ctrl() {
-    if (x_pv_game_selector.exit) {
-        if (x_pv_game_selector.start && x_pv_game_init()) {
-            XPVGameSelector& sel = x_pv_game_selector;
+    if (x_pv_game_selector_ptr->exit) {
+        if (x_pv_game_selector_ptr->start && x_pv_game_init()) {
+            XPVGameSelector* sel = x_pv_game_selector_ptr;
             app::TaskWork::AddTask(x_pv_game_ptr, "X PVGAME", 0);
-            x_pv_game_ptr->Load(sel.pv_id, sel.stage_id, sel.charas, sel.modules);
+            x_pv_game_ptr->Load(sel->pv_id, sel->stage_id, sel->charas, sel->modules);
             game_state_set_sub_game_state_next(SUB_GAME_STATE_GAME_MAIN);
         }
         else
@@ -1161,8 +1162,13 @@ bool SubGameState::Selector::Ctrl() {
 }
 
 bool SubGameState::Selector::Dest() {
-    x_pv_game_selector.DelTask();
-    return true;
+    if (!app::TaskWork::CheckTaskReady(x_pv_game_selector_ptr)) {
+        x_pv_game_selector_free();
+        return true;
+    }
+
+    x_pv_game_selector_ptr->DelTask();
+    return false;
 }
 
 bool SubGameState::GameMain::Init() {
@@ -1646,6 +1652,10 @@ void game_state_ctrl() {
     game_state->call_count++;
 }
 
+GameStateEnum game_state_get_game_state() {
+    return game_state_get()->game_state;
+}
+
 size_t game_state_print(char* buf, size_t buf_size) {
     GameState* game_state = game_state_get();
     const char* game_state_name = game_state_names[game_state->game_state];
diff --git a/src/ReDIVA/game_state.hpp b/src/ReDIVA/game_state.hpp
index fd8e9e3d..c5a4cd84 100644
--- a/src/ReDIVA/game_state.hpp
+++ b/src/ReDIVA/game_state.hpp
@@ -71,6 +71,7 @@ enum SubGameStateEnum {
 
 extern void game_state_init();
 extern void game_state_ctrl();
+extern GameStateEnum game_state_get_game_state();
 extern size_t game_state_print(char* buf, size_t buf_size);
 extern void game_state_set_game_state_next(GameStateEnum state);
 extern void game_state_set_sub_game_state_next(SubGameStateEnum state);
diff --git a/src/ReDIVA/pv_game/pv_game.cpp b/src/ReDIVA/pv_game/pv_game.cpp
index bd61ae24..1a248a4e 100644
--- a/src/ReDIVA/pv_game/pv_game.cpp
+++ b/src/ReDIVA/pv_game/pv_game.cpp
@@ -269,12 +269,12 @@ current_reference_score(), target_count(), field_2CF84(), field_2CF88(), field_2
 slide_chain_length(), field_2CF98(), field_2CF9C(), field_2CFA0(), field_2CFA4(), pv(),field_2CFB0(),
 chance_point(), reference_score(), reference_score_no_flag(), reference_score_no_flag_life_bonus(),
 field_2CFE0(), field_2CFE4(), notes_passed(), field_2CFF0(), song_energy(), song_energy_base(),
-song_energy_border(), life_gauge_safety_time(), life_gauge_border(), stage_index(), field_2D00C(),
+song_energy_border(), life_gauge_safety_time(), life_gauge_border(), stage_index(), music_play(),
 no_fail(), changed_field(), challenge_time_start(), challenge_time_end(), max_time(), max_time_float(),
 current_time_float(), current_time(), field_2D038(), field_2D03C(), score_hold_multi(),
 score_hold(), score_slide(), has_slide(), has_success_se(), pv_disp2d(), life_gauge_final(),
-hit_border(), field_2D05D(), field_2D05E(), start_fade(), title_image_init(), field_2D061(),
-ex_stage(), field_2D063(), has_auth_3d_frame(), has_light_frame(), has_aet_frame(), has_aet_list(),
+hit_border(), field_2D05D(), field_2D05E(), start_fade(), title_image_init(), mute(),
+ex_stage(), play_success(), has_auth_3d_frame(), has_light_frame(), has_aet_frame(), has_aet_list(),
 field_index(), edit_effect_index(), slidertouch_counter(), change_field_branch_success_counter(),
 field_2D080(), field_2D084(), life_gauge_bonus(), life_gauge_total_bonus(), field_2D090(), no_clear(),
 field_2D092(), field_2D093(), field_2D094(), field_2D095(), field_2D096(), success(), title_image_state(),
@@ -464,7 +464,7 @@ bool pv_game_data::sub_140119960(bool* has_target, int64_t* dsc_time, int32_t* t
             case DSC_TARGET_FT_16:
             case DSC_TARGET_FT_SLIDE_L_CHANCE:
             case DSC_TARGET_FT_SLIDE_R_CHANCE:
-                *has_slide = 1;
+                *has_slide = true;
                 break;
             case DSC_TARGET_FT_0E:
                 *slide_chain_type = 1;
@@ -815,12 +815,12 @@ field_4(), state(), field_C(), pv_id(), field_14(), modules(), items() {
     data.life_gauge_safety_time = 0;
     data.life_gauge_border = 0;
     data.stage_index = 0;
-    data.field_2D00C = true;
+    data.music_play = true;
     data.challenge_time_start = -1;
     data.challenge_time_end = -1;
-    data.field_2D061 = false;
+    data.mute = false;
     data.ex_stage = false;
-    data.field_2D063 = false;
+    data.play_success = false;
     data.field_2D0BC = false;
     data.next_stage = false;
     data.has_frame_texture = false;
@@ -1153,7 +1153,7 @@ void pv_game::change_field(size_t field, ssize_t dsc_time, ssize_t curr_time) {
     if (!data.task_effect_init && (dsc_time > -1 || curr_time > -1)) {
         rand_state_array_4_set_seed_1393939();
         task_effect_parent_reset();
-        data.task_effect_init = 1;
+        data.task_effect_init = true;
     }
 
     pv_game_field& curr_field_data = data.field_data[data.current_field];
@@ -2359,6 +2359,8 @@ bool pv_game::load() {
             pv_db_pv* pv = task_pv_db_get_pv(pv_id);
             if (pv)
                 data.pv = pv;
+            else
+                break;
 
             const pv_db_pv_disp2d* pv_disp2d;
             int32_t pv_disp2d_pv_id;
@@ -2388,7 +2390,7 @@ bool pv_game::load() {
 
                     pv_disp2d_data.pv_spr_set_id = aft_spr_db->get_spr_set_id_by_name(spr_set_name.c_str());
                     pv_disp2d_data.pv_aet_set_id = aft_aet_db->get_aet_set_id_by_name(aet_set_name.c_str());
-                    pv_disp2d_data.pv_aet_id = aft_aet_db->get_aet_id_by_name(aet_set_name.c_str());
+                    pv_disp2d_data.pv_aet_id = aft_aet_db->get_aet_id_by_name(aet_name.c_str());
                 }
 
                 pv_disp2d_data.title_start_2d_field = pv_disp2d->title_start_2d_field;
@@ -2663,7 +2665,7 @@ bool pv_game::load() {
             sub_14013C8C0()->difficulty, sub_14013C8C0()->edition);
         if (diff && !data.field_2D094) {
             if (sub_14013C8C0()->sub_1400E7910() < 4
-                && !data.pv_data.read_dsc_file(std::string(diff->script_file_name), this, data.field_2D00C))
+                && !data.pv_data.read_dsc_file(std::string(diff->script_file_name), this, data.music_play))
                 return false;
 
             data.field_2D094 = true;
@@ -4017,7 +4019,7 @@ void pv_game::reset() {
     for (bool& i : data.has_aet_list)
         i = false;
 
-    data.success = data.field_2D063;
+    data.success = data.play_success;
     data.field_2CE98 = 0;
     data.se_index = -1;
     data.field_2DB34 = 0;
@@ -4760,7 +4762,7 @@ int32_t pv_game::sub_1400FDD80() {
 
 void pv_game::sub_140104FB0() {
     data.se_index = -1;
-    data.success = data.field_2D063;
+    data.success = data.play_success;
     data.field_2CE98 = 0;
     data.field_2DB34 = 0;
     data.field_2D0A8 = 0;
@@ -5056,25 +5058,25 @@ void pv_game_init_data::reset() {
 
 struc_14::struc_14() : edition(), pv(), field_10(), field_11(), field_12(),
 field_13(), field_14(), field_18(), field_1C(), field_24(), field_25(), field_26() {
-    field_0 = 8;
+    type = 8;
     difficulty = PV_DIFFICULTY_NORMAL;
     field_20 = 1.0f;
 }
 
 int32_t struc_14::sub_1400E7910() {
-    return field_0;
+    return type;
 }
 
 bool struc_14::sub_1400E7920() {
-    return field_0 == 2 || field_0 == 3 || field_0 == 5 || field_0 == 7;
+    return type == 2 || type == 3 || type == 5 || type == 7;
 }
 
 void struc_14::sub_1400E79E0(int32_t a2) {
-    field_0 = a2;
+    type = a2;
 }
 
 TaskPvGame::Args::Args() : init_data(), field_190(), field_191(), no_fail(),
-field_193(), field_194(), field_195(), ex_stage(), field_197(), test_pv(), option() {
+field_193(), field_194(), mute(), ex_stage(), success(), test_pv(), option() {
     Reset();
 }
 
@@ -5100,15 +5102,15 @@ void TaskPvGame::Args::Reset() {
     no_fail = false;
     field_193 = true;
     field_194 = false;
-    field_195 = false;
+    mute = false;
     ex_stage = false;
-    field_197 = false;
+    success = false;
     test_pv = false;
     option = 0;
 }
 
-TaskPvGame::Data::Data() : field_0(), init_data(), field_190(), field_191(), no_fail(),
-field_193(), field_194(), ex_stage(), field_196(), option() {
+TaskPvGame::Data::Data() : type(), init_data(), field_190(), music_play(),
+no_fail(), field_193(), mute(), ex_stage(), success(), option() {
     Reset();
 }
 
@@ -5127,16 +5129,16 @@ void TaskPvGame::Data::Clear() {
 }
 
 void TaskPvGame::Data::Reset() {
-    field_0 = 1;
+    type = 1;
     init_data.reset();
     Clear();
     field_190 = false;
-    field_191 = true;
+    music_play = true;
     no_fail = false;
     field_193 = true;
-    field_194 = false;
+    mute = false;
     ex_stage = false;
-    field_196 = false;
+    success = false;
     option = 0;
 }
 
@@ -5187,7 +5189,7 @@ void TaskPvGame::Load(TaskPvGame::Data& data) {
     pv_game_time_data.current_time.get_timestamp();
     pv_game_time_data.add_current_time = true;
 
-    sub_14013C8C0()->sub_1400E79E0(data.field_0);
+    sub_14013C8C0()->sub_1400E79E0(data.type);
     sub_14013C8C0()->pv = data.init_data.pv_id;;
     sub_14013C8C0()->difficulty = data.init_data.difficulty;
     sub_14013C8C0()->edition = data.init_data.edition;
@@ -5199,7 +5201,7 @@ void TaskPvGame::Load(TaskPvGame::Data& data) {
             pv_game_ptr->set_item_mask(i, i, data.init_data.items_mask[i].arr[j]);
     }
 
-    pv_game_ptr->data.field_2D00C = data.field_191;
+    pv_game_ptr->data.music_play = data.music_play;
     pv_game_ptr->data.no_fail = data.no_fail;
     pv_game_ptr->data.field_2D00E = data.field_193;
     pv_game_ptr->data.song_energy_base = (float_t)data.init_data.score_percentage_clear;
@@ -5213,9 +5215,9 @@ void TaskPvGame::Load(TaskPvGame::Data& data) {
     pv_game_ptr->data.play_data.other_chainslide_success_name.assign(data.chainslide_success_name);
     pv_game_ptr->data.play_data.other_chainslide_failure_name.assign(data.chainslide_failure_name);
     pv_game_ptr->data.play_data.other_slidertouch_name.assign(data.slidertouch_name);
-    pv_game_ptr->data.field_2D061 = data.field_194;
+    pv_game_ptr->data.mute = data.mute;
     pv_game_ptr->data.ex_stage = data.ex_stage;
-    pv_game_ptr->data.field_2D063 = data.field_196;
+    pv_game_ptr->data.play_success = data.success;
     pv_game_ptr->data.play_data.option = data.option;
 
     target_pos_scale_offset_get();
@@ -5252,7 +5254,7 @@ float_t bar_time_set_to_target_flying_time(int32_t bpm, int32_t time_signature,
 }
 
 float_t dsc_time_to_frame(int64_t time) {
-    return (float_t)((float_t)(int32_t)time / (float_t)1000000000) * 60.0f;
+    return (float_t)time / (float_t)1000000000 * 60.0f;
 }
 
 void pv_game_init() {
@@ -5279,7 +5281,7 @@ bool task_pv_game_add_task(TaskPvGame::Args& args) {
     if (!task_pv_game)
         task_pv_game = new TaskPvGame;
 
-    task_pv_game->data.field_0 = 1;
+    task_pv_game->data.type = 1;
     task_pv_game->data.init_data = args.init_data;
     task_pv_game->data.se_name.assign(args.se_name);
     task_pv_game->data.slide_se_name.assign(args.slide_se_name);
@@ -5289,17 +5291,17 @@ bool task_pv_game_add_task(TaskPvGame::Args& args) {
     task_pv_game->data.chainslide_failure_name.assign(args.chainslide_failure_name);
     task_pv_game->data.slidertouch_name.assign(args.slidertouch_name);
     task_pv_game->data.field_190 = args.field_190;
-    task_pv_game->data.field_191 = !args.field_195;
+    task_pv_game->data.music_play = !args.mute;
     task_pv_game->data.no_fail = args.no_fail;
     if (args.field_191) {
-        task_pv_game->data.field_0 = 2;
+        task_pv_game->data.type = 2;
         task_pv_game->data.field_193 = args.field_193;
     }
     else
         task_pv_game->data.field_193 = true;
-    task_pv_game->data.field_194 = args.field_195;
+    task_pv_game->data.mute = args.mute;
     task_pv_game->data.ex_stage = args.ex_stage;
-    task_pv_game->data.field_196 = args.field_197;
+    task_pv_game->data.success = args.success;
     task_pv_game->data.option = args.option;
 
     if (args.test_pv)
@@ -5391,15 +5393,15 @@ void task_pv_game_init_pv() {
 
     if (sub_14038BB30()->field_0.no_fail) {
         args.no_fail = true;
-        if (!sub_14038BB30()->field_0.field_15) {
-            args.field_190 = false;
-            args.field_191 = false;
-        }
-        else {
+        if (sub_14038BB30()->field_0.field_15) {
             args.field_190 = true;
             args.field_191 = true;
-            if (sub_14038BB30()->field_0.field_16)
-                args.field_197 = true;
+            if (sub_14038BB30()->field_0.success)
+                args.success = true;
+        }
+        else {
+            args.field_190 = false;
+            args.field_191 = false;
         }
     }
     else {
@@ -5429,7 +5431,7 @@ void task_pv_game_init_test_pv() {
     args.no_fail = false;
     args.field_193 = true;
     args.field_194 = true;
-    args.field_195 = true;
+    args.mute = true;
     args.test_pv = true;
     task_pv_game_add_task(args);
 }
@@ -5652,11 +5654,11 @@ static bool pv_game_parent_ctrl() {
 
     int64_t curr_time = pv_game_time_data.curr_time;
     if (pv_game_time_data.add_last_stop_time)
-        curr_time += (int64_t)(pv_game_time_data.last_stop_time.calc_time() * 100.0);
+        curr_time += (int64_t)(pv_game_time_data.last_stop_time.calc_time() * 1000.0);
 
     int64_t delta_time = pv_game_time_data.delta_time;
     if (pv_game_time_data.add_current_time)
-        delta_time += (int64_t)(pv_game_time_data.current_time.calc_time() * 100.0);
+        delta_time += (int64_t)(pv_game_time_data.current_time.calc_time() * 1000.0);
 
     pv_game_time_data.delta_time = 0;
     pv_game_time_data.current_time.get_timestamp();
@@ -5680,11 +5682,11 @@ static void pv_game_parent_disp() {
 
 static void pv_game_time_ctrl() {
     if (pv_game_time_data.add_last_stop_time)
-        pv_game_time_data.curr_time += (int64_t)(pv_game_time_data.last_stop_time.calc_time() * 100.0);
+        pv_game_time_data.curr_time += (int64_t)(pv_game_time_data.last_stop_time.calc_time() * 1000.0);
     pv_game_time_data.add_last_stop_time = false;
 
     if (pv_game_time_data.add_current_time)
-        pv_game_time_data.delta_time += (int64_t)(pv_game_time_data.current_time.calc_time() * 100.0);
+        pv_game_time_data.delta_time += (int64_t)(pv_game_time_data.current_time.calc_time() * 1000.0);
     pv_game_time_data.add_current_time = false;
 }
 
diff --git a/src/ReDIVA/pv_game/pv_game.hpp b/src/ReDIVA/pv_game/pv_game.hpp
index 28c52b4d..00044009 100644
--- a/src/ReDIVA/pv_game/pv_game.hpp
+++ b/src/ReDIVA/pv_game/pv_game.hpp
@@ -185,7 +185,7 @@ struct pv_game_data {
     int32_t life_gauge_safety_time;
     int32_t life_gauge_border;
     int32_t stage_index;
-    bool field_2D00C;
+    bool music_play;
     bool no_fail;
     bool field_2D00E;
     bool changed_field;
@@ -209,9 +209,9 @@ struct pv_game_data {
     bool field_2D05E;
     bool start_fade;
     bool title_image_init;
-    bool field_2D061;
+    bool mute;
     bool ex_stage;
-    bool field_2D063;
+    bool play_success;
     bool has_auth_3d_frame;
     bool has_light_frame;
     bool has_aet_frame[4];
@@ -473,7 +473,7 @@ struct pv_game_init_data {
 };
 
 struct struc_14 {
-    int32_t field_0;
+    int32_t type;
     pv_difficulty difficulty;
     int32_t edition;
     uint32_t pv;
@@ -504,7 +504,7 @@ struct struc_677 {
     int32_t field_10;
     bool no_fail;
     int8_t field_15;
-    int8_t field_16;
+    bool success;
     bool field_17;
     int32_t field_18;
     int32_t field_1C;
@@ -746,9 +746,9 @@ public:
         bool no_fail;
         bool field_193;
         bool field_194;
-        bool field_195;
+        bool mute;
         bool ex_stage;
-        bool field_197;
+        bool success;
         bool test_pv;
         int32_t option;
 
@@ -760,7 +760,7 @@ public:
     };
 
     struct Data {
-        int32_t field_0;
+        int32_t type;
         pv_game_init_data init_data;
         std::string se_name;
         std::string slide_se_name;
@@ -770,12 +770,12 @@ public:
         std::string chainslide_failure_name;
         std::string slidertouch_name;
         bool field_190;
-        bool field_191;
+        bool music_play;
         bool no_fail;
         bool field_193;
-        bool field_194;
+        bool mute;
         bool ex_stage;
-        bool field_196;
+        bool success;
         int32_t option;
 
         Data();
diff --git a/src/ReDIVA/pv_game/pv_game_pv_data.cpp b/src/ReDIVA/pv_game/pv_game_pv_data.cpp
index 72d4cbde..a14bc84e 100644
--- a/src/ReDIVA/pv_game/pv_game_pv_data.cpp
+++ b/src/ReDIVA/pv_game/pv_game_pv_data.cpp
@@ -296,18 +296,16 @@ void struc_676::reset() {
 pv_game_pv_data::pv_game_pv_data() : field_0(), dsc_state(), play()/*, dsc_buffer(), dsc_buffer_counter()*/,
 dsc_data_ptr(), dsc_data_ptr_end(), field_2BF38(), curr_time(), curr_time_float(), prev_time_float(),
 field_2BF50(), field_2BF60(), field_2BF64(), field_2BF68(), chara_id(), pv_game()/*, field_2BF80()*/,
-music(), dsc_file_handler(),
-dsc_time(),  music_play(), field_2BFC4(),
-pv_end(), field_2BFD4(), field_2BFD5(), data_camera(),
-has_signature(), has_perf_id(), targets_remaining(), target_index(), scene_rot_y(),
-field_2C550(), branch_mode(), last_challenge_note(), field_2C560() {
+music(), dsc_file_handler(), dsc_time(), music_playing(), field_2BFC4(), pv_end(), field_2BFD4(),
+field_2BFD5(), data_camera(), has_signature(), has_perf_id(), targets_remaining(), target_index(),
+scene_rot_y(), field_2C550(), branch_mode(), last_challenge_note(), field_2C560() {
     field_2BF30 = -1;
     field_2BF58 = -1i64;
     field_2BFB0 = -1;
     field_2BFB4 = -1;
     field_2BFB8 = -1;
     field_2BFBC = -1;
-    field_2BFC0 = true;
+    music_play = true;
     fov = 32.2673416137695f;
     min_dist = 0.05f;
     target_flying_time = -1.0f;
@@ -394,7 +392,8 @@ void pv_game_pv_data::dsc_buffer_set(const void* data, uint32_t size) {
     dsc_buffer_counter_set();
 }*/
 
-bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time, float_t* dsc_time_offset, bool* music_play, bool a6, bool ignore_targets) {
+bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time,
+    float_t* dsc_time_offset, bool* music_play, bool a6, bool ignore_targets) {
     if (sub_14013C8C0()->sub_1400E7910() >= 4 && field_2BF68 <= curr_time)
         pv_game->set_lyric(-1, { 0xFF, 0xFF, 0xFF, 0xFF });
 
@@ -422,8 +421,6 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time, float_t* d
         }
     }
 
-    dsc_data_ptr++;
-
     data_struct* aft_data = &data_list[DATA_AFT];
     bone_database* aft_bone_data = &aft_data->data_ft.bone_data;
     motion_database* aft_mot_db = &aft_data->data_ft.mot_db;
@@ -641,7 +638,7 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time, float_t* d
         playdata = &this->playdata[chara_id];
         rob_chr = playdata->rob_chr;
 
-        int32_t motion_index = (int32_t)data[0];
+        int32_t motion_index = (int32_t)data[1];
         if (motion_index >= 0) {
             pv_play_data_motion* motion = playdata->get_motion(motion_index);
             if (motion) {
@@ -688,7 +685,7 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time, float_t* d
 
             pv_game->set_data_campv(0, index, frame);
             rctx_ptr->camera->set_fast_change_hist0(true);
-            set_camera_max_frame((int32_t)data_camera[0].time);
+            set_camera_max_frame(data_camera[0].time);
         } break;
         case 1: {
             if (data_camera[1].index != index - 1) {
@@ -713,7 +710,7 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time, float_t* d
 
             pv_game->set_data_campv(1, index, frame);
             rctx_ptr->camera->set_fast_change_hist0(true);
-            set_camera_max_frame((int32_t)data_camera[1].time);
+            set_camera_max_frame(data_camera[1].time);
         } break;
         case 2: {
             pv_game->set_data_campv(2, index, 0.0f);
@@ -957,11 +954,11 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time, float_t* d
             music->play(4, pv_game->get_play_data_song_file_name(), false, 0.0f, 0.0f, 0.0f, 3.0f, false);
 
             int32_t v189 = 100;
-            int32_t v192 = 0;
-            if (sub_14013C8C0()->sub_1400E7910() != 2 || !sub_14013C8C0()->field_25)
-                v192 = 100;
+            int32_t v192 = 100;
+            if (sub_14013C8C0()->sub_1400E7910() == 2 && sub_14013C8C0()->field_25)
+                v192 = 0;
 
-            if (!field_2BFC0) {
+            if (!music_play) {
                 v192 = 0;
                 v189 = 0;
             }
@@ -978,7 +975,7 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time, float_t* d
             music->set_pause(true);
 
         *music_play = true;
-        this->music_play = true;
+        this->music_playing = true;
     } break;
     case DSC_FT_MODE_SELECT:
     case DSC_FT_EDIT_MODE_SELECT: {
@@ -2030,6 +2027,8 @@ bool pv_game_pv_data::dsc_ctrl(float_t delta_time, int64_t curr_time, float_t* d
         play = false;
     } return false;
     }
+
+    dsc_data_ptr++;
     return true;
 }
 
@@ -2353,7 +2352,7 @@ int32_t pv_game_pv_data::get_target_target_count(size_t index, float_t time_offs
     return targets[index].target_count;
 }
 
-void pv_game_pv_data::init(::pv_game* pv_game, bool a3) {
+void pv_game_pv_data::init(::pv_game* pv_game, bool music_play) {
     this->pv_game = pv_game;
     //field_2BF80 = sub_14013C8F0();
     music = pv_game_music_get();
@@ -2389,7 +2388,7 @@ void pv_game_pv_data::init(::pv_game* pv_game, bool a3) {
     field_2BFB4 = -1;
     field_2BFB8 = -1;
     field_2BFBC = -1;
-    field_2BFC0 = a3;
+    music_play = music_play;
     field_2BFD4 = false;
     field_2BFD5 = false;
     pv_end = false;
@@ -2405,7 +2404,7 @@ void pv_game_pv_data::init(::pv_game* pv_game, bool a3) {
     field_2BF30 = -1;
     field_2BF38 = 0;
     field_2BF68 = 0;
-    music_play = false;
+    music_playing = false;
 
     dsc_reset_position();
 
@@ -2444,7 +2443,7 @@ void pv_game_pv_data::init(::pv_game* pv_game, bool a3) {
     reset_camera_post_process();
 }
 
-bool pv_game_pv_data::read_dsc_file(std::string&& file_path, ::pv_game* pv_game, bool a4) {
+bool pv_game_pv_data::read_dsc_file(std::string&& file_path, ::pv_game* pv_game, bool music_play) {
     switch (dsc_state) {
     case 0:
         if (dsc_file_handler.read_file(&data_list[DATA_AFT], file_path.c_str()))
@@ -2473,7 +2472,7 @@ bool pv_game_pv_data::read_dsc_file(std::string&& file_path, ::pv_game* pv_game,
         dsc_state = 2;
     } break;
     case 2:
-        init(pv_game, a4);
+        init(pv_game, music_play);
         dsc_state = 0;
         return true;
     }
@@ -2521,9 +2520,9 @@ void pv_game_pv_data::reset() {
 void pv_game_pv_data::reset_camera_post_process() {
     camera* cam = rctx_ptr->camera;
     cam->set_ignore_min_dist(false);
-    cam->set_max_distance(0.05);
+    cam->set_min_distance(0.05f);
     cam->set_ignore_fov(false);
-    cam->set_fov(32.2673416137695);
+    cam->set_fov(32.2673416137695f);
 
     post_process* pp = &rctx_ptr->post_process;
     pp->tone_map->set_scene_fade_color(0.0f);
@@ -2547,7 +2546,7 @@ void pv_game_pv_data::scene_fade_ctrl(float_t delta_time) {
     scene_fade.ctrl(delta_time);
 }
 
-void pv_game_pv_data::set_camera_max_frame(int32_t time) {
+void pv_game_pv_data::set_camera_max_frame(int64_t time) {
     std::vector<int32_t>& data_camera = branch_mode != 2
         ? data_camera_branch_fail
         : data_camera_branch_success;
diff --git a/src/ReDIVA/pv_game/pv_game_pv_data.hpp b/src/ReDIVA/pv_game/pv_game_pv_data.hpp
index 8837168e..441aeaee 100644
--- a/src/ReDIVA/pv_game/pv_game_pv_data.hpp
+++ b/src/ReDIVA/pv_game/pv_game_pv_data.hpp
@@ -288,8 +288,8 @@ struct pv_game_pv_data {
     int32_t field_2BFB4;
     int32_t field_2BFB8;
     int32_t field_2BFBC;
-    bool field_2BFC0;
     bool music_play;
+    bool music_playing;
     int32_t field_2BFC4;
     bool pv_end;
     float_t fov;
@@ -325,7 +325,8 @@ struct pv_game_pv_data {
     int64_t ctrl(float_t delta_time, int64_t curr_time, bool a4);
     //void dsc_buffer_counter_set();
     //void dsc_buffer_set(const void* data, uint32_t size);
-    bool dsc_ctrl(float_t delta_time, int64_t curr_time, float_t* dsc_time_offset, bool* music_play, bool a6, bool ignore_targets);
+    bool dsc_ctrl(float_t delta_time, int64_t curr_time,
+        float_t* dsc_time_offset, bool* music_play, bool a6, bool ignore_targets);
     void dsc_reset_position();
     //void dsc_get_start_position(int32_t* value);
     dsc_data* find_func(int32_t func_name, int32_t* time,
@@ -338,12 +339,12 @@ struct pv_game_pv_data {
     const std::vector<pv_data_set_motion>* get_set_motion(size_t chara_id);
     pv_dsc_target_group* get_target();
     int32_t get_target_target_count(size_t index, float_t time_offset, bool a4);
-    void init(::pv_game * pv_game, bool a3);
-    bool read_dsc_file(std::string&& file_path, struct pv_game* pv_game, bool a4);
+    void init(::pv_game * pv_game, bool music_play);
+    bool read_dsc_file(std::string&& file_path, struct pv_game* pv_game, bool music_play);
     void reset();
     void reset_camera_post_process();
     void scene_fade_ctrl(float_t delta_time);
-    void set_camera_max_frame(int32_t time);
+    void set_camera_max_frame(int64_t time);
     void set_item_anim_max_frame(int32_t chara_id, int32_t index, int64_t time);
     void set_motion_max_frame(int32_t chara_id, int32_t motion_index, int64_t time);
 };
diff --git a/src/ReDIVA/system_startup.cpp b/src/ReDIVA/system_startup.cpp
index 567e31e4..e1b5de08 100644
--- a/src/ReDIVA/system_startup.cpp
+++ b/src/ReDIVA/system_startup.cpp
@@ -55,7 +55,7 @@ namespace system_startup_detail {
             system_startup.state = 3;
             break;
         case 3:
-            if (mdata_manager_get()->state == 5 ||mdata_manager_get()->state == 15)
+            if (!app::TaskWork::CheckTaskReady(mdata_manager_get()))
                 system_startup.state = 4;
             break;
         case 4: