diff --git a/include/constants/savedata/savedata.h b/include/constants/savedata/savedata.h
index 4ffd60586e..17b144766b 100644
--- a/include/constants/savedata/savedata.h
+++ b/include/constants/savedata/savedata.h
@@ -29,6 +29,12 @@ enum SaveSectorID {
 	SECTOR_ID_MAX = SECTOR_ID_ERROR,
 };
 
+enum SaveError {
+	SAVE_ERROR_DISABLE_WRITE = 0,
+	SAVE_ERROR_DISABLE_READ,
+};
+
+#define SECONDARY_FOOTER_SIZE		8
 
 #define SECTOR_SIGNATURE			0x20060623
 
diff --git a/include/savedata.h b/include/savedata.h
index 3ed47aec01..24a753b202 100644
--- a/include/savedata.h
+++ b/include/savedata.h
@@ -58,8 +58,8 @@ typedef struct SaveData {
     SavePageInfo pageInfo[SAVE_TABLE_ENTRY_MAX];
     SaveBlockInfo blockInfo[SAVE_BLOCK_ID_MAX];
     SaveDataState state;
-    int unk_202C4;
-    u32 unk_202C8;
+    int sectorSwitch;
+    u32 sectorCounter;
 } SaveData;
 
 typedef struct SaveCheckInfo {
@@ -68,13 +68,13 @@ typedef struct SaveCheckInfo {
     u32 blockCounter;
 } SaveCheckInfo;
 
-typedef struct UnkStruct_020253B4 {
-    u32 unk_00;
-    u32 unk_04;
-    u32 unk_08;
-    u16 unk_0C;
-    u16 unk_0E;
-} UnkStruct_020253B4;
+typedef struct SaveCheckFooter {
+    u32 signature;
+    u32 saveCounter;
+    u32 size;
+    u16 id;
+    u16 checksum;
+} SaveCheckFooter;
 
 SaveData* SaveData_Init(void);
 SaveData* SaveData_Ptr(void);
@@ -98,15 +98,15 @@ int SaveData_SaveStateMain(SaveData *saveData);
 void SaveData_SaveStateCancel(SaveData *saveData);
 u16 SaveData_CalculateChecksum(const SaveData *saveData, const void *startAddress, u32 size);
 int SaveTableEntry_BodySize(int saveTableID);
-void sub_02025340(SaveData * param0);
-int SaveDataExtra_Save(const SaveData * param0, int param1, void * param2);
-int SaveDataExtra_SaveMirror(SaveData * param0, int param1, void * param2);
-void * SaveDataExtra_Get(SaveData * param0, int param1, int param2, int * param3);
-void * SaveDataExtra_Mirror(SaveData * param0, int param1, int param2, int * param3, BOOL * param4);
-BOOL sub_02025A3C(void);
-BOOL sub_02025A9C(u32 param0, void * param1, u32 param2);
-BOOL sub_02025AC0(u32 param0, void * param1, u32 param2);
-BOOL SaveData_CRC(int param0);
-void sub_02025C84(int param0);
+void sub_02025340(SaveData *saveData);
+int SaveDataExtra_Save(const SaveData *saveData, int extraSaveID, void *data);
+int SaveDataExtra_SaveMirror(SaveData *saveData, int extraSaveID, void *data);
+void* SaveDataExtra_Get(SaveData *saveData, int heapID, int extraSaveID, int *loadResult);
+void* SaveDataExtra_Mirror(SaveData *saveData, int heapID, int extraSaveID, int *loadResult, BOOL *isOld);
+BOOL SaveData_CardBackupType(void);
+BOOL SaveData_CardSave(u32 address, void *data, u32 size);
+BOOL SaveData_CardLoad(u32 address, void *data, u32 size);
+BOOL SaveData_CRC(int saveTableID);
+void sub_02025C84(int saveTableID);
 
 #endif // POKEPLATINUM_SAVEDATA_H
diff --git a/src/savedata.c b/src/savedata.c
index d5feaab399..b3d1cfbaeb 100644
--- a/src/savedata.c
+++ b/src/savedata.c
@@ -16,9 +16,9 @@
 #include "unk_0209AA74.h"
 #include "constants/heap.h"
 
-static void sub_020252EC(SaveDataBody * param0, const SavePageInfo * param1);
-static void sub_020251DC(SavePageInfo * param0);
-static void sub_02025258(SaveBlockInfo * param0, const SavePageInfo * param1);
+static void SaveTable_Clear(SaveDataBody *body, const SavePageInfo *pageInfo);
+static void SavePageInfo_Init(SavePageInfo *pageInfo);
+static void SaveBlockInfo_Init(SaveBlockInfo *blockInfo, const SavePageInfo *pageInfo);
 static BOOL SaveDataState_Save(SaveData *saveData);
 static BOOL SaveDataState_Load(SaveData *saveData);
 static int SaveData_LoadCheck(SaveData *saveData);
@@ -28,13 +28,14 @@ static int SaveDataState_Main(SaveData *saveData, SaveDataState *state);
 static void SaveDataState_End(SaveData *saveData, SaveDataState *state, int saveResult);
 static void SaveDataState_Cancel(SaveData *saveData, SaveDataState *state);
 static BOOL SaveBlockFooter_Erase(const SaveData *saveData, int blockID, int sectorID);
-static s32 sub_02025B3C(u32 param0, void * param1, u32 param2);
-static BOOL sub_02025BB8(s32 param0, BOOL param1, BOOL * param2);
-static void sub_02025C1C(s32 param0, int param1);
-static void sub_020259F8(SaveData * param0, int param1, u32 * param2, u32 * param3, u8 * param4);
-static void sub_02025A18(SaveData * param0, int param1, u32 param2, u32 param3, u8 param4);
+static s32 SaveData_CardSave_Init(u32 address, void *data, u32 size);
+static BOOL SaveData_CardSave_Main(s32 lockID, BOOL lockFlag, BOOL *result);
+static void SaveData_CardSave_Error(s32 lockID, int errorID);
+static void SaveDataExtra_SaveKey(SaveData *saveData, int extraSaveID, u32 *returnKey, u32 *oldKey, u8 *keyFlag);
+static void SaveDataExtra_SetSaveKey(SaveData *saveData, int extraSaveID, u32 newKey, u32 oldKey, u8 keyFlag);
 
 static SaveData *sSaveDataPtr = NULL;
+static BOOL sSaveComplete;
 
 SaveData* SaveData_Init (void)
 {
@@ -44,13 +45,13 @@ SaveData* SaveData_Init (void)
 
     sSaveDataPtr = saveData;
 
-    saveData->backupExists = sub_02025A3C();
+    saveData->backupExists = SaveData_CardBackupType();
     saveData->dataExists = FALSE;
     saveData->isNewGameData = TRUE;
     saveData->fullSaveRequired = TRUE;
 
-    sub_020251DC(saveData->pageInfo);
-    sub_02025258(saveData->blockInfo, saveData->pageInfo);
+    SavePageInfo_Init(saveData->pageInfo);
+    SaveBlockInfo_Init(saveData->blockInfo, saveData->pageInfo);
 
     MI_CpuClearFast(saveData->blockCounters, sizeof(saveData->blockCounters));
 
@@ -127,9 +128,9 @@ BOOL SaveData_Erase (SaveData *saveData)
 
     MI_CpuFillFast(saveBuffer, 0xffffffff, SAVE_SECTOR_SIZE);
 
-    for (int sectorIndex = 0; sectorIndex < SAVE_PAGE_MAX * 2; sectorIndex++) {
-        sub_02025A9C(SAVE_SECTOR_SIZE * (sectorIndex + PRIMARY_SECTOR_START), saveBuffer, SAVE_SECTOR_SIZE);
-        sub_02025A9C(SAVE_SECTOR_SIZE * (sectorIndex + BACKUP_SECTOR_START), saveBuffer, SAVE_SECTOR_SIZE);
+    for (int i = 0; i < SAVE_PAGE_MAX * SECTOR_ID_MAX; i++) {
+        SaveData_CardSave(SAVE_SECTOR_SIZE * (i + PRIMARY_SECTOR_START), saveBuffer, SAVE_SECTOR_SIZE);
+        SaveData_CardSave(SAVE_SECTOR_SIZE * (i + BACKUP_SECTOR_START), saveBuffer, SAVE_SECTOR_SIZE);
     }
 
     Heap_FreeToHeap(saveBuffer);
@@ -211,7 +212,7 @@ void SaveData_Clear (SaveData *saveData)
     saveData->isNewGameData = TRUE;
     saveData->fullSaveRequired = TRUE;
 
-    sub_020252EC(&saveData->body, saveData->pageInfo);
+    SaveTable_Clear(&saveData->body, saveData->pageInfo);
 }
 
 BOOL SaveData_BackupExists (const SaveData *saveData)
@@ -234,25 +235,27 @@ BOOL SaveData_IsNewGameData (const SaveData *saveData)
     return saveData->isNewGameData;
 }
 
+//ravetodo SaveData_MiscSave_InitFlag
 BOOL sub_020247C8 (SaveData *saveData)
 {
-    UnkStruct_0202783C * v0;
+    UnkStruct_0202783C *miscSave;
 
-    v0 = sub_0202783C(saveData);
-    return sub_020278CC(v0);
+    miscSave = sub_0202783C(saveData);
+    return sub_020278CC(miscSave);
 }
 
+//ravetodo SaveData_MiscSave_SetInitFlag
 static void sub_020247D4 (SaveData *saveData)
 {
-    UnkStruct_0202783C * v0;
+    UnkStruct_0202783C *miscSave;
 
-    v0 = sub_0202783C(saveData);
-    sub_020278B8(v0);
+    miscSave = sub_0202783C(saveData);
+    sub_020278B8(miscSave);
 }
 
 BOOL SaveData_OverwriteCheck (const SaveData *saveData)
 {
-    return (SaveData_IsNewGameData(saveData) && SaveData_DataExists(saveData));
+    return SaveData_IsNewGameData(saveData) && SaveData_DataExists(saveData);
 }
 
 BOOL SaveData_FullSaveRequired (const SaveData *saveData)
@@ -457,7 +460,7 @@ static int SaveData_LoadCheck (SaveData *saveData)
     primaryBuffer = Heap_AllocFromHeapAtEnd(HEAP_ID_APPLICATION, SAVE_SECTOR_SIZE * SAVE_PAGE_MAX);
     backupBuffer = Heap_AllocFromHeapAtEnd(HEAP_ID_APPLICATION, SAVE_SECTOR_SIZE * SAVE_PAGE_MAX);
 
-    if (sub_02025AC0(PRIMARY_SECTOR_START * SAVE_SECTOR_SIZE, primaryBuffer, SAVE_SECTOR_SIZE * SAVE_PAGE_MAX)) {
+    if (SaveData_CardLoad(PRIMARY_SECTOR_START * SAVE_SECTOR_SIZE, primaryBuffer, SAVE_SECTOR_SIZE * SAVE_PAGE_MAX)) {
         SaveBlockFooter_CheckInfo(&normalInfo[SECTOR_ID_PRIMARY], saveData, (u32)primaryBuffer, SAVE_BLOCK_ID_NORMAL);
         SaveBlockFooter_CheckInfo(&boxInfo[SECTOR_ID_PRIMARY], saveData, (u32)primaryBuffer, SAVE_BLOCK_ID_BOXES);
     } else {
@@ -465,7 +468,7 @@ static int SaveData_LoadCheck (SaveData *saveData)
         SaveData_CheckInfoInit(&boxInfo[SECTOR_ID_PRIMARY]);
     }
 
-    if (sub_02025AC0(BACKUP_SECTOR_START * SAVE_SECTOR_SIZE, backupBuffer, SAVE_SECTOR_SIZE * SAVE_PAGE_MAX)) {
+    if (SaveData_CardLoad(BACKUP_SECTOR_START * SAVE_SECTOR_SIZE, backupBuffer, SAVE_SECTOR_SIZE * SAVE_PAGE_MAX)) {
         SaveBlockFooter_CheckInfo(&normalInfo[SECTOR_ID_BACKUP], saveData, (u32)backupBuffer, SAVE_BLOCK_ID_NORMAL);
         SaveBlockFooter_CheckInfo(&boxInfo[SECTOR_ID_BACKUP], saveData, (u32)backupBuffer, SAVE_BLOCK_ID_BOXES);
     } else {
@@ -535,11 +538,11 @@ static int SaveData_LoadCheck (SaveData *saveData)
 static void SaveDataExtra_LoadCheck (SaveData *saveData, int *frontierResult, int *videoResult)
 {
     int loadResult;
-    BOOL v2;
+    BOOL isOld;
     int extraSaveID;
-    UnkStruct_0202783C *v4 = sub_0202783C(saveData);
-    u32 v5, v6;
-    u8 v7;
+    UnkStruct_0202783C *miscSave = sub_0202783C(saveData);
+    u32 currKey, oldKey;
+    u8 loadFlag;
 
     *frontierResult = LOAD_RESULT_OK;
     *videoResult = LOAD_RESULT_OK;
@@ -548,31 +551,31 @@ static void SaveDataExtra_LoadCheck (SaveData *saveData, int *frontierResult, in
         return;
     }
 
-    sub_020279A8(v4, EXTRA_SAVE_TABLE_ENTRY_FRONTIER, &v5, &v6, &v7);
+    sub_020279A8(miscSave, EXTRA_SAVE_TABLE_ENTRY_FRONTIER, &currKey, &oldKey, &loadFlag);
 
     void *saveBuffer;
-    if ((v5 != EXTRA_SAVE_TABLE_ENTRY_NONE) || (v6 != EXTRA_SAVE_TABLE_ENTRY_NONE)) {
-        saveBuffer = SaveDataExtra_Mirror(saveData, HEAP_ID_APPLICATION, EXTRA_SAVE_TABLE_ENTRY_FRONTIER, &loadResult, &v2);
+    if (currKey != EXTRA_SAVE_TABLE_ENTRY_NONE || oldKey != EXTRA_SAVE_TABLE_ENTRY_NONE) {
+        saveBuffer = SaveDataExtra_Mirror(saveData, HEAP_ID_APPLICATION, EXTRA_SAVE_TABLE_ENTRY_FRONTIER, &loadResult, &isOld);
         Heap_FreeToHeap(saveBuffer);
 
         if (loadResult == LOAD_RESULT_CORRUPT) {
             *frontierResult = LOAD_RESULT_ERROR;
-        } else if ((loadResult == LOAD_RESULT_OK) && (v2 == TRUE)) {
+        } else if (loadResult == LOAD_RESULT_OK && isOld == TRUE) {
             *frontierResult = LOAD_RESULT_CORRUPT;
         }
     }
 
-    for (extraSaveID = 2; extraSaveID <= 5; extraSaveID++) {
-        sub_020279A8(v4, extraSaveID, &v5, &v6, &v7);
+    for (extraSaveID = EXTRA_SAVE_TABLE_ENTRY_MY_RECORDINGS; extraSaveID <= EXTRA_SAVE_TABLE_ENTRY_DL_RECORDINGS_2; extraSaveID++) {
+        sub_020279A8(miscSave, extraSaveID, &currKey, &oldKey, &loadFlag);
 
-        if ((v5 != 0xffffffff) || (v6 != 0xffffffff)) {
-            saveBuffer = SaveDataExtra_Mirror(saveData, 3, extraSaveID, &loadResult, &v2);
+        if (currKey != EXTRA_SAVE_TABLE_ENTRY_NONE || oldKey != EXTRA_SAVE_TABLE_ENTRY_NONE) {
+            saveBuffer = SaveDataExtra_Mirror(saveData, HEAP_ID_APPLICATION, extraSaveID, &loadResult, &isOld);
             Heap_FreeToHeap(saveBuffer);
 
             if (loadResult == LOAD_RESULT_CORRUPT) {
                 *videoResult = LOAD_RESULT_ERROR;
-            } else if ((loadResult == LOAD_RESULT_OK) && (v2 == TRUE)) {
-                if ((*videoResult) != LOAD_RESULT_ERROR) {
+            } else if (loadResult == LOAD_RESULT_OK && isOld == TRUE) {
+                if (*videoResult != LOAD_RESULT_ERROR) {
                     *videoResult = LOAD_RESULT_CORRUPT;
                 }
             }
@@ -582,12 +585,10 @@ static void SaveDataExtra_LoadCheck (SaveData *saveData, int *frontierResult, in
 
 static BOOL SaveBlock_Load (int sectorID, const SaveBlockInfo *blockInfo, u8 *blockOffset)
 {
-    u32 saveOffset;
-
-    saveOffset = SaveData_SaveOffset(sectorID, blockInfo);
+    u32 saveOffset = SaveData_SaveOffset(sectorID, blockInfo);
     blockOffset += blockInfo->offset;
 
-    return sub_02025AC0(saveOffset, blockOffset, blockInfo->size);
+    return SaveData_CardLoad(saveOffset, blockOffset, blockInfo->size);
 }
 
 static BOOL SaveDataState_Load (SaveData *saveData)
@@ -622,7 +623,7 @@ static s32 SaveDataState_InitBlock (SaveData *saveData, int blockID, u8 sectorID
     saveOffset = SaveData_SaveOffset(sectorID, blockInfo);
     bodyOffset = saveData->body.data + blockInfo->offset;
 
-    return sub_02025B3C(saveOffset, bodyOffset, blockInfo->size - sizeof(SaveBlockFooter));
+    return SaveData_CardSave_Init(saveOffset, bodyOffset, blockInfo->size - sizeof(SaveBlockFooter));
 }
 
 static s32 SaveDataState_InitFooter (SaveData *saveData, int blockID, u8 sectorID)
@@ -634,19 +635,19 @@ static s32 SaveDataState_InitFooter (SaveData *saveData, int blockID, u8 sectorI
     saveOffset = SaveData_SaveOffset(sectorID, blockInfo) + blockInfo->size - sizeof(SaveBlockFooter);
     bodyOffset = saveData->body.data + blockInfo->offset + blockInfo->size - sizeof(SaveBlockFooter);
 
-    return sub_02025B3C(saveOffset, bodyOffset, sizeof(SaveBlockFooter));
+    return SaveData_CardSave_Init(saveOffset, bodyOffset, sizeof(SaveBlockFooter));
 }
 
-static s32 sub_02024E98 (SaveData *saveData, int blockID, u8 sectorID)
+static s32 SaveDataState_InitFooter_Secondary (SaveData *saveData, int blockID, u8 sectorID)
 {
     u32 saveOffset;
     u8 *bodyOffset;
     const SaveBlockInfo *blockInfo = &saveData->blockInfo[blockID];
 
-    saveOffset = SaveData_SaveOffset(sectorID, blockInfo) + blockInfo->size - sizeof(SaveBlockFooter) + 8;
-    bodyOffset = saveData->body.data + blockInfo->offset + blockInfo->size - sizeof(SaveBlockFooter) + 8;
+    saveOffset = SaveData_SaveOffset(sectorID, blockInfo) + blockInfo->size - sizeof(SaveBlockFooter) + SECONDARY_FOOTER_SIZE;
+    bodyOffset = saveData->body.data + blockInfo->offset + blockInfo->size - sizeof(SaveBlockFooter) + SECONDARY_FOOTER_SIZE;
 
-    return sub_02025B3C(saveOffset, bodyOffset, 8);
+    return SaveData_CardSave_Init(saveOffset, bodyOffset, SECONDARY_FOOTER_SIZE);
 }
 
 static void SaveDataState_Init (SaveData *saveData, SaveDataState *state, int blockID)
@@ -695,7 +696,7 @@ static int SaveDataState_Main (SaveData *saveData, SaveDataState *state)
         state->locked = TRUE;
         state->mainSequence++;
     case 1:
-        if (sub_02025BB8(state->lockID, state->locked, &saveResult) == FALSE) {
+        if (SaveData_CardSave_Main(state->lockID, state->locked, &saveResult) == FALSE) {
             break;
         }
 
@@ -707,11 +708,11 @@ static int SaveDataState_Main (SaveData *saveData, SaveDataState *state)
 
         state->mainSequence++;
     case 2:
-        state->lockID = sub_02024E98(saveData, state->currentBlock, !saveData->blockOffsets[state->currentBlock]);
+        state->lockID = SaveDataState_InitFooter_Secondary(saveData, state->currentBlock, !saveData->blockOffsets[state->currentBlock]);
         state->locked = TRUE;
         state->mainSequence++;
     case 3:
-        if (sub_02025BB8(state->lockID, state->locked, &saveResult) == FALSE) {
+        if (SaveData_CardSave_Main(state->lockID, state->locked, &saveResult) == FALSE) {
             break;
         }
 
@@ -731,7 +732,7 @@ static int SaveDataState_Main (SaveData *saveData, SaveDataState *state)
         state->locked = TRUE;
         state->mainSequence++;
     case 5:
-        if (sub_02025BB8(state->lockID, state->locked, &saveResult) == FALSE) {
+        if (SaveData_CardSave_Main(state->lockID, state->locked, &saveResult) == FALSE) {
             break;
         }
 
@@ -828,7 +829,7 @@ static BOOL SaveBlockFooter_Erase (const SaveData *saveData, int blockID, int se
     MI_CpuFill8(&footer, 0xff, sizeof(SaveBlockFooter));
     saveOffset = SaveData_SaveOffset(sectorID, blockInfo) + blockInfo->size - sizeof(SaveBlockFooter);
 
-    return sub_02025A9C(saveOffset, &footer, sizeof(SaveBlockFooter));
+    return SaveData_CardSave(saveOffset, &footer, sizeof(SaveBlockFooter));
 }
 
 int SaveTableEntry_BodySize (int saveTableID)
@@ -845,585 +846,566 @@ int SaveTableEntry_BodySize (int saveTableID)
     return size;
 }
 
-static void sub_020251DC (SavePageInfo * param0)
+static void SavePageInfo_Init (SavePageInfo *pageInfo)
 {
-    const SaveTableEntry * v0 = gSaveTable;
-    int v1;
-    int v2 = 0;
+    const SaveTableEntry *saveTable = gSaveTable;
+    int i;
+    int totalSize = 0;
 
-    GF_ASSERT(gSaveTableSize == 38);
+    GF_ASSERT(gSaveTableSize == SAVE_TABLE_ENTRY_MAX);
 
-    for (v1 = 0; v1 < gSaveTableSize; v1++) {
-        GF_ASSERT(v0[v1].dataID == v1);
+    for (i = 0; i < gSaveTableSize; i++) {
+        GF_ASSERT(saveTable[i].dataID == i);
 
-        param0[v1].pageID = v0[v1].dataID;
-        param0[v1].size = SaveTableEntry_BodySize(v1);
-        param0[v1].location = v2;
-        param0[v1].checksum = 0;
-        param0[v1].blockID = v0[v1].blockID;
+        pageInfo[i].pageID = saveTable[i].dataID;
+        pageInfo[i].size = SaveTableEntry_BodySize(i);
+        pageInfo[i].location = totalSize;
+        pageInfo[i].checksum = 0;
+        pageInfo[i].blockID = saveTable[i].blockID;
 
-        v2 += param0[v1].size;
+        totalSize += pageInfo[i].size;
 
-        if ((v1 == gSaveTableSize - 1) || (v0[v1].blockID != v0[v1 + 1].blockID)) {
-            v2 += sizeof(SaveBlockFooter);
+        if ((i == gSaveTableSize - 1) || (saveTable[i].blockID != saveTable[i + 1].blockID)) {
+            totalSize += sizeof(SaveBlockFooter);
         }
     }
 
-    if (v1 % 4 != 0) {
-    }
-
-    GF_ASSERT(v2 <= 0x1000 * 32);
+    GF_ASSERT(totalSize <= SAVE_SECTOR_SIZE * SAVE_PAGE_MAX);
 }
 
-static void sub_02025258 (SaveBlockInfo * param0, const SavePageInfo * param1)
+static void SaveBlockInfo_Init (SaveBlockInfo *blockInfo, const SavePageInfo *pageInfo)
 {
-    int v0 = 0;
-    int v1, v2;
-    int v3, v4;
+    int totalSectors = 0, blockOffset = 0, block, page = 0;
 
-    v1 = 0;
-    v2 = 0;
-    v4 = 0;
+    for (block = 0; block < SAVE_BLOCK_ID_MAX; block++) {
+        blockInfo[block].saveBlockID = block;
+        blockInfo[block].size = 0;
 
-    for (v3 = 0; v3 < 2; v3++) {
-        param0[v3].saveBlockID = v3;
-        param0[v3].size = 0;
-
-        for (; param1[v4].blockID == v3 && v4 < gSaveTableSize; v4++) {
-            param0[v3].size += param1[v4].size;
+        for (; pageInfo[page].blockID == block && page < gSaveTableSize; page++) {
+            blockInfo[block].size += pageInfo[page].size;
         }
 
-        param0[v3].size += sizeof(SaveBlockFooter);
-        param0[v3].sectorStartPos = v1;
-        param0[v3].offset = v2;
-        param0[v3].sectorsInUse = (param0[v3].size + 0x1000 - 1) / 0x1000;
+        blockInfo[block].size += sizeof(SaveBlockFooter);
+        blockInfo[block].sectorStartPos = totalSectors;
+        blockInfo[block].offset = blockOffset;
+        blockInfo[block].sectorsInUse = (blockInfo[block].size + SAVE_SECTOR_SIZE - 1) / SAVE_SECTOR_SIZE;
 
-        v1 += param0[v3].sectorsInUse;
-        v2 += param0[v3].size;
+        totalSectors += blockInfo[block].sectorsInUse;
+        blockOffset += blockInfo[block].size;
     }
 
-    GF_ASSERT(v1 == param0[2 - 1].sectorStartPos + param0[2 - 1].sectorsInUse);
-    GF_ASSERT(v1 <= 32);
+    GF_ASSERT(totalSectors == blockInfo[SAVE_BLOCK_ID_MAX - 1].sectorStartPos + blockInfo[SAVE_BLOCK_ID_MAX - 1].sectorsInUse);
+    GF_ASSERT(totalSectors <= SAVE_PAGE_MAX);
 }
 
-static void sub_020252EC (SaveDataBody * param0, const SavePageInfo * param1)
+static void SaveTable_Clear (SaveDataBody *body, const SavePageInfo *pageInfo)
 {
-    const SaveTableEntry * v0 = gSaveTable;
-    int v1;
-    int v2;
-    void * v3;
-    u32 v4;
+    const SaveTableEntry *saveTable = gSaveTable;
+    int i, size;
+    void *page;
+    u32 location;
 
-    MI_CpuClearFast(param0->data, sizeof(param0->data));
+    MI_CpuClearFast(body->data, sizeof(body->data));
 
-    for (v1 = 0; v1 < gSaveTableSize; v1++) {
-        v4 = param1[v1].location;
-        v3 = &param0->data[v4];
-        v2 = param1[v1].size;
-        MI_CpuClearFast(v3, v2);
-        v0[v1].initFunc(v3);
+    for (i = 0; i < gSaveTableSize; i++) {
+        location = pageInfo[i].location;
+        page = &body->data[location];
+        size = pageInfo[i].size;
+        MI_CpuClearFast(page, size);
+        saveTable[i].initFunc(page);
     }
 }
 
-void sub_02025340 (SaveData * param0)
+//ravetodo SaveDataExtra_Init
+void sub_02025340 (SaveData *saveData)
 {
-    const SaveTableEntry * v0 = gExtraSaveTable;
-    int v1;
-    int v2;
-    void * v3;
+    const SaveTableEntry *extraTable = gExtraSaveTable;
+    int i;
+    int loadResult;
+    void *extraData;
 
-    if (sub_020247C8(param0) == 1) {
+    if (sub_020247C8(saveData) == TRUE) {
         return;
     }
 
-    for (v1 = 0; v1 < gExtraSaveTableSize; v1++) {
-        if (v0[v1].dataID == 0) {
+    for (i = 0; i < gExtraSaveTableSize; i++) {
+        if (extraTable[i].dataID == EXTRA_SAVE_TABLE_ENTRY_HALL_OF_FAME) {
             continue;
         }
 
-        v3 = SaveDataExtra_Get(param0, 3, v0[v1].dataID, &v2);
+        extraData = SaveDataExtra_Get(saveData, HEAP_ID_APPLICATION, extraTable[i].dataID, &loadResult);
 
-        GF_ASSERT(v3 != NULL);
-        MI_CpuClear8(v3, v0[v1].sizeFunc());
+        GF_ASSERT(extraData != NULL);
+        MI_CpuClear8(extraData, extraTable[i].sizeFunc());
 
-        v0[v1].initFunc(v3);
+        extraTable[i].initFunc(extraData);
 
-        SaveDataExtra_Save(param0, v0[v1].dataID, v3);
-        Heap_FreeToHeap(v3);
+        SaveDataExtra_Save(saveData, extraTable[i].dataID, extraData);
+        Heap_FreeToHeap(extraData);
     }
 
-    sub_020247D4(param0);
+    sub_020247D4(saveData);
 }
 
-static void sub_020253B4 (const SaveData * param0, void * param1, int param2, u32 param3)
+static void SaveCheckFooter_Set (const SaveData *saveData, void *saveBody, int extraSaveID, u32 size)
 {
-    UnkStruct_020253B4 * v0;
+    SaveCheckFooter *footer;
 
-    v0 = (UnkStruct_020253B4 *)((u8 *)param1 + param3);
+    footer = (SaveCheckFooter *)((u8 *)saveBody + size);
 
-    v0->unk_00 = SECTOR_SIGNATURE;
-    v0->unk_04 = param0->unk_202C8 + 1;
-    v0->unk_08 = param3;
-    v0->unk_0C = param2;
-    v0->unk_0E = sub_0201D628(param1, param3 + sizeof(UnkStruct_020253B4) - 2);
+    footer->signature = SECTOR_SIGNATURE;
+    footer->saveCounter = saveData->sectorCounter + 1;
+    footer->size = size;
+    footer->id = extraSaveID;
+    footer->checksum = sub_0201D628(saveBody, size + sizeof(SaveCheckFooter) - 2);
 }
 
-static BOOL sub_020253E0 (const SaveData * param0, void * param1, int param2, u32 param3)
+static BOOL SaveCheckFooter_Validate (const SaveData *saveData, void *saveBody, int extraSaveID, u32 size)
 {
-    const UnkStruct_020253B4 * v0;
+    const SaveCheckFooter *footer;
 
-    v0 = (const UnkStruct_020253B4 *)((u8 *)param1 + param3);
+    footer = (const SaveCheckFooter *)((u8 *)saveBody + size);
 
-    if (v0->unk_00 != SECTOR_SIGNATURE) {
-        return 0;
+    if (footer->signature != SECTOR_SIGNATURE) {
+        return FALSE;
     }
 
-    if (v0->unk_08 != param3) {
-        return 0;
+    if (footer->size != size) {
+        return FALSE;
     }
 
-    if (v0->unk_0C != param2) {
-        return 0;
+    if (footer->id != extraSaveID) {
+        return FALSE;
     }
 
-    if (v0->unk_0E != sub_0201D628(param1, param3 + sizeof(UnkStruct_020253B4) - 2)) {
-        return 0;
+    if (footer->checksum != sub_0201D628(saveBody, size + sizeof(SaveCheckFooter) - 2)) {
+        return FALSE;
     }
 
-    return 1;
+    return TRUE;
 }
 
-static u32 sub_02025420 (void * param0, u32 param1)
+static u32 SaveCheckFooter_SaveCounter (void *saveBody, u32 size)
 {
-    const UnkStruct_020253B4 * v0 = (const UnkStruct_020253B4 *)((u8 *)param0 + param1);
-    return v0->unk_04;
+    const SaveCheckFooter *footer = (const SaveCheckFooter *)((u8 *)saveBody + size);
+    return footer->saveCounter;
 }
 
-int SaveDataExtra_Save (const SaveData * param0, int param1, void * param2)
+int SaveDataExtra_Save (const SaveData *saveData, int extraSaveID, void *data)
 {
-    const SaveTableEntry * v0;
-    u32 v1;
-    BOOL v2;
+    const SaveTableEntry *saveTable;
+    u32 size;
+    BOOL saveResult;
 
     SleepLock(1);
 
-    GF_ASSERT(param1 < gExtraSaveTableSize);
-    v0 = &gExtraSaveTable[param1];
+    GF_ASSERT(extraSaveID < gExtraSaveTableSize);
+    saveTable = &gExtraSaveTable[extraSaveID];
 
-    GF_ASSERT(v0->dataID == param1);
-    v1 = v0->sizeFunc() + sizeof(UnkStruct_020253B4);
+    GF_ASSERT(saveTable->dataID == extraSaveID);
+    size = saveTable->sizeFunc() + sizeof(SaveCheckFooter);
 
-    if (param0->unk_202C4 == 1) {
-        sub_020253B4(param0, param2, param1, v0->sizeFunc());
-        v2 = sub_02025A9C((0 + v0->blockID) * 0x1000, param2, v1);
+    if (saveData->sectorSwitch == SECTOR_ID_BACKUP) {
+        SaveCheckFooter_Set(saveData, data, extraSaveID, saveTable->sizeFunc());
+        saveResult = SaveData_CardSave((PRIMARY_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, data, size);
 
-        GF_ASSERT(sub_020253E0(param0, param2, param1, v0->sizeFunc()) == 1);
-        sub_020253B4(param0, param2, param1, v0->sizeFunc());
+        GF_ASSERT(SaveCheckFooter_Validate(saveData, data, extraSaveID, saveTable->sizeFunc()) == TRUE);
+        SaveCheckFooter_Set(saveData, data, extraSaveID, saveTable->sizeFunc());
 
-        v2 |= sub_02025A9C((64 + v0->blockID) * 0x1000, param2, v1);
-        GF_ASSERT(sub_020253E0(param0, param2, param1, v0->sizeFunc()) == 1);
+        saveResult |= SaveData_CardSave((BACKUP_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, data, size);
+        GF_ASSERT(SaveCheckFooter_Validate(saveData, data, extraSaveID, saveTable->sizeFunc()) == TRUE);
     } else {
-        sub_020253B4(param0, param2, param1, v0->sizeFunc());
-        v2 = sub_02025A9C((64 + v0->blockID) * 0x1000, param2, v1);
+        SaveCheckFooter_Set(saveData, data, extraSaveID, saveTable->sizeFunc());
+        saveResult = SaveData_CardSave((BACKUP_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, data, size);
 
-        GF_ASSERT(sub_020253E0(param0, param2, param1, v0->sizeFunc()) == 1);
-        sub_020253B4(param0, param2, param1, v0->sizeFunc());
+        GF_ASSERT(SaveCheckFooter_Validate(saveData, data, extraSaveID, saveTable->sizeFunc()) == TRUE);
+        SaveCheckFooter_Set(saveData, data, extraSaveID, saveTable->sizeFunc());
 
-        v2 |= sub_02025A9C((0 + v0->blockID) * 0x1000, param2, v1);
-        GF_ASSERT(sub_020253E0(param0, param2, param1, v0->sizeFunc()) == 1);
+        saveResult |= SaveData_CardSave((PRIMARY_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, data, size);
+        GF_ASSERT(SaveCheckFooter_Validate(saveData, data, extraSaveID, saveTable->sizeFunc()) == TRUE);
     }
 
-    if (v2 == 1) {
+    if (saveResult == TRUE) {
         SleepUnlock(1);
-        return 2;
+        return SAVE_RESULT_OK;
     } else {
         SleepUnlock(1);
-        return 3;
+        return SAVE_RESULT_CORRUPT;
     }
 }
 
-int SaveDataExtra_SaveMirror (SaveData * param0, int param1, void * param2)
+int SaveDataExtra_SaveMirror (SaveData *saveData, int extraSaveID, void *data)
 {
-    const SaveTableEntry * v0;
-    u32 v1;
-    BOOL v2;
-    u32 v3, v4, v5;
-    u8 v6;
+    const SaveTableEntry *saveTable;
+    u32 size;
+    BOOL saveResult;
+    u32 currKey, oldKey, newKey;
+    u8 keyFlag;
 
     SleepLock(1);
 
-    GF_ASSERT(param1 < gExtraSaveTableSize);
-    v0 = &gExtraSaveTable[param1];
+    GF_ASSERT(extraSaveID < gExtraSaveTableSize);
+    saveTable = &gExtraSaveTable[extraSaveID];
 
-    GF_ASSERT(v0->dataID == param1);
-    v1 = v0->sizeFunc() + sizeof(UnkStruct_020253B4);
+    GF_ASSERT(saveTable->dataID == extraSaveID);
+    size = saveTable->sizeFunc() + sizeof(SaveCheckFooter);
 
-    sub_020259F8(param0, param1, &v3, &v4, &v6);
+    SaveDataExtra_SaveKey(saveData, extraSaveID, &currKey, &oldKey, &keyFlag);
 
     do {
-        v5 = ARNG_Next(v3);
-    } while (v5 == 0xffffffff);
+        newKey = ARNG_Next(currKey);
+    } while (newKey == EXTRA_SAVE_TABLE_ENTRY_NONE);
 
-    sub_02025A18(param0, param1, v5, v3, v6 ^ 1);
+    SaveDataExtra_SetSaveKey(saveData, extraSaveID, newKey, currKey, keyFlag ^ 1);
 
-    *((u32 *)param2) = v5;
+    *((u32 *)data) = newKey;
 
-    if (v6 == 1) {
-        sub_020253B4(param0, param2, param1, v0->sizeFunc());
-        v2 = sub_02025A9C((0 + v0->blockID) * 0x1000, param2, v1);
-        GF_ASSERT(sub_020253E0(param0, param2, param1, v0->sizeFunc()) == 1);
+    if (keyFlag == 1) {
+        SaveCheckFooter_Set(saveData, data, extraSaveID, saveTable->sizeFunc());
+        saveResult = SaveData_CardSave((PRIMARY_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, data, size);
+        GF_ASSERT(SaveCheckFooter_Validate(saveData, data, extraSaveID, saveTable->sizeFunc()) == TRUE);
     } else {
-        sub_020253B4(param0, param2, param1, v0->sizeFunc());
-        v2 = sub_02025A9C((64 + v0->blockID) * 0x1000, param2, v1);
-        GF_ASSERT(sub_020253E0(param0, param2, param1, v0->sizeFunc()) == 1);
+        SaveCheckFooter_Set(saveData, data, extraSaveID, saveTable->sizeFunc());
+        saveResult = SaveData_CardSave((BACKUP_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, data, size);
+        GF_ASSERT(SaveCheckFooter_Validate(saveData, data, extraSaveID, saveTable->sizeFunc()) == TRUE);
     }
 
-    if (v2 == 1) {
+    if (saveResult == TRUE) {
         SleepUnlock(1);
-        return 2;
+        return SAVE_RESULT_OK;
     } else {
         SleepUnlock(1);
-        return 3;
+        return SAVE_RESULT_CORRUPT;
     }
 }
 
-void * SaveDataExtra_Get (SaveData * param0, int param1, int param2, int * param3)
+void* SaveDataExtra_Get (SaveData *saveData, int heapID, int extraSaveID, int *loadResult)
 {
-    const SaveTableEntry * v0;
-    void * v1;
-    u32 v2;
-    BOOL v3, v4;
-    u32 v5, v6;
+    const SaveTableEntry *saveTable;
+    void *ret;
+    u32 size;
+    BOOL primaryResult, backupResult;
+    u32 primaryCounter, backupCounter;
 
-    GF_ASSERT(param2 < gExtraSaveTableSize);
-    v0 = &gExtraSaveTable[param2];
+    GF_ASSERT(extraSaveID < gExtraSaveTableSize);
+    saveTable = &gExtraSaveTable[extraSaveID];
 
-    GF_ASSERT(v0->dataID == param2);
-    v2 = v0->sizeFunc() + sizeof(UnkStruct_020253B4);
-    v1 = Heap_AllocFromHeap(param1, v2);
+    GF_ASSERT(saveTable->dataID == extraSaveID);
+    size = saveTable->sizeFunc() + sizeof(SaveCheckFooter);
+    ret = Heap_AllocFromHeap(heapID, size);
 
-    sub_02025AC0((0 + v0->blockID) * 0x1000, v1, v2);
+    SaveData_CardLoad((PRIMARY_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
 
-    v3 = sub_020253E0(param0, v1, param2, v0->sizeFunc());
-    v5 = sub_02025420(v1, v0->sizeFunc());
+    primaryResult = SaveCheckFooter_Validate(saveData, ret, extraSaveID, saveTable->sizeFunc());
+    primaryCounter = SaveCheckFooter_SaveCounter(ret, saveTable->sizeFunc());
 
-    sub_02025AC0((64 + v0->blockID) * 0x1000, v1, v2);
+    SaveData_CardLoad((BACKUP_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
 
-    v4 = sub_020253E0(param0, v1, param2, v0->sizeFunc());
-    v6 = sub_02025420(v1, v0->sizeFunc());
+    backupResult = SaveCheckFooter_Validate(saveData, ret, extraSaveID, saveTable->sizeFunc());
+    backupCounter = SaveCheckFooter_SaveCounter(ret, saveTable->sizeFunc());
 
-    *param3 = 1;
+    *loadResult = LOAD_RESULT_OK;
 
-    if ((v3 == 1) && (v4 == 0)) {
-        param0->unk_202C4 = 0;
-        param0->unk_202C8 = v5;
-        sub_02025AC0((0 + v0->blockID) * 0x1000, v1, v2);
-        return v1;
+    if (primaryResult == TRUE && backupResult == FALSE) {
+        saveData->sectorSwitch = SECTOR_ID_PRIMARY;
+        saveData->sectorCounter = primaryCounter;
+        SaveData_CardLoad((PRIMARY_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
+        return ret;
     }
 
-    if ((v3 == 0) && (v4 == 1)) {
-        param0->unk_202C4 = 1;
-        param0->unk_202C8 = v6;
-        sub_02025AC0((64 + v0->blockID) * 0x1000, v1, v2);
-        return v1;
+    if (primaryResult == FALSE && backupResult == TRUE) {
+        saveData->sectorSwitch = SECTOR_ID_BACKUP;
+        saveData->sectorCounter = backupCounter;
+        SaveData_CardLoad((BACKUP_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
+        return ret;
     }
 
-    if ((v3 == 1) && (v4 == 1)) {
-        if (SaveCheckInfo_CompareCounters(v5, v6) != -1) {
-            param0->unk_202C4 = 0;
-            param0->unk_202C8 = v5;
-            sub_02025AC0((0 + v0->blockID) * 0x1000, v1, v2);
-            return v1;
+    if (primaryResult == TRUE && backupResult == TRUE) {
+        if (SaveCheckInfo_CompareCounters(primaryCounter, backupCounter) != -1) {
+            saveData->sectorSwitch = SECTOR_ID_PRIMARY;
+            saveData->sectorCounter = primaryCounter;
+            SaveData_CardLoad((PRIMARY_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
+            return ret;
         } else {
-            param0->unk_202C4 = 1;
-            param0->unk_202C8 = v6;
-            sub_02025AC0((64 + v0->blockID) * 0x1000, v1, v2);
-            return v1;
+            saveData->sectorSwitch = SECTOR_ID_BACKUP;
+            saveData->sectorCounter = backupCounter;
+            SaveData_CardLoad((BACKUP_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
+            return ret;
         }
     }
 
-    *param3 = 2;
+    *loadResult = LOAD_RESULT_CORRUPT;
 
-    param0->unk_202C4 = 0;
-    param0->unk_202C8 = 0;
+    saveData->sectorSwitch = 0;
+    saveData->sectorCounter = 0;
 
-    return v1;
+    return ret;
 }
 
-void * SaveDataExtra_Mirror (SaveData * param0, int param1, int param2, int * param3, BOOL * param4)
+void* SaveDataExtra_Mirror (SaveData *saveData, int heapID, int extraSaveID, int *loadResult, BOOL *isOld)
 {
-    const SaveTableEntry * v0;
-    void * v1;
-    u32 v2;
-    BOOL v3, v4;
-    u32 v5, v6;
-    u32 v7, v8;
-    u8 v9;
-    UnkStruct_0202783C * v10 = sub_0202783C(param0);
+    const SaveTableEntry *saveTable;
+    void *ret;
+    u32 size;
+    BOOL primaryResult, backupResult;
+    u32 primaryKey, backupKey, currKey, oldKey;
+    u8 keyFlag;
+    UnkStruct_0202783C *miscSave = sub_0202783C(saveData);
 
-    GF_ASSERT(param2 < gExtraSaveTableSize);
-    GF_ASSERT(param2 != 0);
+    GF_ASSERT(extraSaveID < gExtraSaveTableSize);
+    GF_ASSERT(extraSaveID != EXTRA_SAVE_TABLE_ENTRY_HALL_OF_FAME);
 
-    v0 = &gExtraSaveTable[param2];
-    GF_ASSERT(v0->dataID == param2);
+    saveTable = &gExtraSaveTable[extraSaveID];
+    GF_ASSERT(saveTable->dataID == extraSaveID);
 
-    v2 = v0->sizeFunc() + sizeof(UnkStruct_020253B4);
-    v1 = Heap_AllocFromHeap(param1, v2);
+    size = saveTable->sizeFunc() + sizeof(SaveCheckFooter);
+    ret = Heap_AllocFromHeap(heapID, size);
 
-    sub_020259F8(param0, param2, &v7, &v8, &v9);
-    sub_02025AC0((0 + v0->blockID) * 0x1000, v1, v2);
+    SaveDataExtra_SaveKey(saveData, extraSaveID, &currKey, &oldKey, &keyFlag);
+    SaveData_CardLoad((PRIMARY_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
 
-    v3 = sub_020253E0(param0, v1, param2, v0->sizeFunc());
-    MI_CpuCopy8(v1, &v5, sizeof(u32));
+    primaryResult = SaveCheckFooter_Validate(saveData, ret, extraSaveID, saveTable->sizeFunc());
+    MI_CpuCopy8(ret, &primaryKey, sizeof(u32));
 
-    sub_02025AC0((64 + v0->blockID) * 0x1000, v1, v2);
-    v4 = sub_020253E0(param0, v1, param2, v0->sizeFunc());
+    SaveData_CardLoad((BACKUP_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
+    backupResult = SaveCheckFooter_Validate(saveData, ret, extraSaveID, saveTable->sizeFunc());
 
-    MI_CpuCopy8(v1, &v6, sizeof(u32));
+    MI_CpuCopy8(ret, &backupKey, sizeof(u32));
 
-    *param3 = 1;
-    *param4 = 0;
+    *loadResult = LOAD_RESULT_OK;
+    *isOld = FALSE;
 
-    if ((v3 == 1) && (v4 == 0)) {
-        if (v7 == v5) {
-            if (v9 == 1) {
-                sub_02025A18(param0, param2, v8, v8, 0);
-                *param4 = 1;
+    if (primaryResult == TRUE && backupResult == FALSE) {
+        if (currKey == primaryKey) {
+            if (keyFlag == 1) {
+                SaveDataExtra_SetSaveKey(saveData, extraSaveID, oldKey, oldKey, 0);
+                *isOld = TRUE;
             }
 
-            sub_02025AC0((0 + v0->blockID) * 0x1000, v1, v2);
-            return v1;
+            SaveData_CardLoad((PRIMARY_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
+            return ret;
         }
     }
 
-    if ((v3 == 0) && (v4 == 1)) {
-        if (v7 == v6) {
-            if (v9 == 0) {
-                sub_02025A18(param0, param2, v8, v8, 1);
-                *param4 = 1;
+    if (primaryResult == FALSE && backupResult == TRUE) {
+        if (currKey == backupKey) {
+            if (keyFlag == 0) {
+                SaveDataExtra_SetSaveKey(saveData, extraSaveID, oldKey, oldKey, 1);
+                *isOld = TRUE;
             }
 
-            sub_02025AC0((64 + v0->blockID) * 0x1000, v1, v2);
-            return v1;
+            SaveData_CardLoad((BACKUP_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
+            return ret;
         }
     }
 
-    if ((v3 == 1) && (v4 == 1)) {
-        if (v9 == 0) {
-            if (v7 == v5) {
-                sub_02025AC0((0 + v0->blockID) * 0x1000, v1, v2);
-                return v1;
-            } else if (v8 == v6) {
-                sub_02025A18(param0, param2, v8, v8, v9 ^ 1);
-                *param4 = 1;
-                sub_02025AC0((64 + v0->blockID) * 0x1000, v1, v2);
-                return v1;
+    if (primaryResult == TRUE && backupResult == TRUE) {
+        if (keyFlag == 0) {
+            if (currKey == primaryKey) {
+                SaveData_CardLoad((PRIMARY_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
+                return ret;
+            } else if (oldKey == backupKey) {
+                SaveDataExtra_SetSaveKey(saveData, extraSaveID, oldKey, oldKey, keyFlag ^ 1);
+                *isOld = TRUE;
+                SaveData_CardLoad((BACKUP_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
+                return ret;
             }
         } else {
-            if (v7 == v6) {
-                sub_02025AC0((64 + v0->blockID) * 0x1000, v1, v2);
-                return v1;
-            } else if (v8 == v5) {
-                sub_02025A18(param0, param2, v8, v8, v9 ^ 1);
-                *param4 = 1;
-                sub_02025AC0((0 + v0->blockID) * 0x1000, v1, v2);
-                return v1;
+            if (currKey == backupKey) {
+                SaveData_CardLoad((BACKUP_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
+                return ret;
+            } else if (oldKey == primaryKey) {
+                SaveDataExtra_SetSaveKey(saveData, extraSaveID, oldKey, oldKey, keyFlag ^ 1);
+                *isOld = TRUE;
+                SaveData_CardLoad((PRIMARY_SECTOR_START + saveTable->blockID) * SAVE_SECTOR_SIZE, ret, size);
+                return ret;
             }
         }
     }
 
-    *param3 = 2;
-    sub_020279D0(v10, v0->dataID, 0xffffffff, 0xffffffff, 0);
+    *loadResult = LOAD_RESULT_CORRUPT;
+    sub_020279D0(miscSave, saveTable->dataID, EXTRA_SAVE_TABLE_ENTRY_NONE, EXTRA_SAVE_TABLE_ENTRY_NONE, 0);
 
-    return v1;
+    return ret;
 }
 
-static void sub_020259F8 (SaveData * param0, int param1, u32 * param2, u32 * param3, u8 * param4)
+static void SaveDataExtra_SaveKey (SaveData *saveData, int extraSaveID, u32 *returnKey, u32 *oldKey, u8 *keyFlag)
 {
-    sub_020279A8(sub_0202783C(param0), param1, param2, param3, param4);
+    sub_020279A8(sub_0202783C(saveData), extraSaveID, returnKey, oldKey, keyFlag);
 }
 
-static void sub_02025A18 (SaveData * param0, int param1, u32 param2, u32 param3, u8 param4)
+static void SaveDataExtra_SetSaveKey (SaveData *saveData, int extraSaveID, u32 newKey, u32 oldKey, u8 keyFlag)
 {
-    sub_020279D0(sub_0202783C(param0), param1, param2, param3, param4);
+    sub_020279D0(sub_0202783C(saveData), extraSaveID, newKey, oldKey, keyFlag);
 }
 
-BOOL sub_02025A3C (void)
+BOOL SaveData_CardBackupType (void)
 {
-    s32 v0;
-    BOOL v1;
-    u32 v2;
+    s32 lockID;
+    BOOL result;
 
-    v0 = OS_GetLockID();
-    GF_ASSERT(v0 != OS_LOCK_ID_ERROR);
+    lockID = OS_GetLockID();
+    GF_ASSERT(lockID != OS_LOCK_ID_ERROR);
 
-    CARD_LockBackup(v0);
+    CARD_LockBackup(lockID);
 
     if (CARD_IdentifyBackup(CARD_BACKUP_TYPE_FLASH_4MBITS)) {
-        v1 = CARD_BACKUP_TYPE_FLASH_4MBITS;
+        result = CARD_BACKUP_TYPE_FLASH_4MBITS;
     } else if (CARD_IdentifyBackup(CARD_BACKUP_TYPE_FLASH_2MBITS)) {
-        v1 = CARD_BACKUP_TYPE_FLASH_2MBITS;
+        result = CARD_BACKUP_TYPE_FLASH_2MBITS;
     } else {
-        v1 = CARD_BACKUP_TYPE_NOT_USE;
+        result = CARD_BACKUP_TYPE_NOT_USE;
     }
 
-    CARD_UnlockBackup(v0);
-    OS_ReleaseLockID(v0);
+    CARD_UnlockBackup(lockID);
+    OS_ReleaseLockID(lockID);
 
-    if (v1 == CARD_BACKUP_TYPE_FLASH_4MBITS) {
-        (void)0;
-    } else if (v1 == CARD_BACKUP_TYPE_FLASH_2MBITS) {
-        (void)0;
-    } else {
-        (void)0;
-    }
-
-    return v1 != CARD_BACKUP_TYPE_NOT_USE;
+    return result != CARD_BACKUP_TYPE_NOT_USE;
 }
 
-BOOL sub_02025A9C (u32 param0, void * param1, u32 param2)
+BOOL SaveData_CardSave (u32 address, void *data, u32 size)
 {
-    s32 v0;
-    BOOL v1;
+    s32 lockID;
+    BOOL result;
 
-    v0 = sub_02025B3C(param0, param1, param2);
+    lockID = SaveData_CardSave_Init(address, data, size);
 
-    while (sub_02025BB8(v0, 1, &v1) == 0) {
+    while (SaveData_CardSave_Main(lockID, TRUE, &result) == FALSE) {
         (void)0;
     }
 
-    return v1;
+    return result;
 }
 
-BOOL sub_02025AC0 (u32 param0, void * param1, u32 param2)
+BOOL SaveData_CardLoad (u32 address, void *data, u32 size)
 {
-    s32 v0;
-    BOOL v1;
+    s32 lockID;
+    BOOL result;
 
-    v0 = OS_GetLockID();
-    GF_ASSERT(v0 != OS_LOCK_ID_ERROR);
+    lockID = OS_GetLockID();
+    GF_ASSERT(lockID != OS_LOCK_ID_ERROR);
 
-    CARD_LockBackup(v0);
-    CARD_ReadFlashAsync(param0, param1, param2, NULL, NULL);
+    CARD_LockBackup(lockID);
+    CARD_ReadFlashAsync(address, data, size, NULL, NULL);
 
-    v1 = CARD_WaitBackupAsync();
+    result = CARD_WaitBackupAsync();
 
-    CARD_UnlockBackup(v0);
-    OS_ReleaseLockID(v0);
+    CARD_UnlockBackup(lockID);
+    OS_ReleaseLockID(lockID);
 
-    if (!v1) {
+    if (!result) {
         Heap_FreeToHeap(sSaveDataPtr);
-        sub_0209A74C(1);
+        sub_0209A74C(HEAP_ID_SAVE);
     }
 
-    return v1;
+    return result;
 }
 
-static BOOL Unk_021C0798;
-
-static void sub_02025B30 (void * param0)
+static void CB_SaveComplete (void *unused)
 {
-    Unk_021C0798 = 1;
+    sSaveComplete = TRUE;
 }
 
-static s32 sub_02025B3C (u32 param0, void * param1, u32 param2)
+static s32 SaveData_CardSave_Init (u32 address, void *data, u32 size)
 {
-    s32 v0;
-    u32 v1;
-    BOOL v2;
+    s32 lockID;
+    u32 buffer;
+    BOOL readResult;
 
-    v0 = OS_GetLockID();
-    GF_ASSERT(v0 != OS_LOCK_ID_ERROR);
+    lockID = OS_GetLockID();
+    GF_ASSERT(lockID != OS_LOCK_ID_ERROR);
 
-    CARD_LockBackup(v0);
+    CARD_LockBackup(lockID);
 
-    v2 = CARD_ReadFlash(0, &v1, sizeof(v1));
+    readResult = CARD_ReadFlash(0, &buffer, sizeof(buffer));
 
-    if (!v2) {
-        sub_02025C1C(v0, 1);
+    if (!readResult) {
+        SaveData_CardSave_Error(lockID, SAVE_ERROR_DISABLE_READ);
     }
 
-    Unk_021C0798 = 0;
-    CARD_WriteAndVerifyFlashAsync(param0, param1, param2, sub_02025B30, NULL);
+    sSaveComplete = FALSE;
+    CARD_WriteAndVerifyFlashAsync(address, data, size, CB_SaveComplete, NULL);
 
-    return v0;
+    return lockID;
 }
 
-static BOOL sub_02025BB8 (s32 param0, BOOL param1, BOOL * param2)
+static BOOL SaveData_CardSave_Main (s32 lockID, BOOL lockFlag, BOOL *result)
 {
-    if (Unk_021C0798 == 1) {
-        if (param1 == 0) {
-            return 1;
+    if (sSaveComplete == TRUE) {
+        if (!lockFlag) {
+            return TRUE;
         }
 
-        CARD_UnlockBackup(param0);
-        OS_ReleaseLockID(param0);
+        CARD_UnlockBackup(lockID);
+        OS_ReleaseLockID(lockID);
 
         switch (CARD_GetResultCode()) {
         case CARD_RESULT_SUCCESS:
-            *param2 = 1;
+            *result = TRUE;
             break;
         default:
             GF_ASSERT(0);
         case CARD_RESULT_TIMEOUT:
-            *param2 = 0;
-            sub_02025C1C(param0, 0);
+            *result = FALSE;
+            SaveData_CardSave_Error(lockID, SAVE_ERROR_DISABLE_WRITE);
         case CARD_RESULT_NO_RESPONSE:
-            *param2 = 0;
-            sub_02025C1C(param0, 1);
+            *result = FALSE;
+            SaveData_CardSave_Error(lockID, SAVE_ERROR_DISABLE_READ);
             break;
         }
 
-        return 1;
+        return TRUE;
     }
 
-    return 0;
+    return FALSE;
 }
 
-static void sub_02025C1C (s32 param0, int param1)
+static void SaveData_CardSave_Error (s32 lockID, int errorID)
 {
-    CARD_UnlockBackup(param0);
-    OS_ReleaseLockID(param0);
+    CARD_UnlockBackup(lockID);
+    OS_ReleaseLockID(lockID);
 
     Heap_FreeToHeap(sSaveDataPtr);
-    sub_0209AA74(1, param1);
+    sub_0209AA74(HEAP_ID_SAVE, errorID);
 }
 
-BOOL SaveData_CRC (int param0)
+//ravetodo SaveData_Checksum
+BOOL SaveData_CRC (int saveTableID)
 {
-    SaveData * v0 = SaveData_Ptr();
-    void * v1 = SaveData_SaveTable(v0, param0);
-    int v2 = SaveTableEntry_BodySize(param0) - 4;
-    int v3 = v2 / 2;
-    u16 * v4 = v1;
-    u16 v5;
-    u32 v6;
+    SaveData *saveData = SaveData_Ptr();
+    void *table = SaveData_SaveTable(saveData, saveTableID);
+    int size = SaveTableEntry_BodySize(saveTableID) - 4;
+    int halfSize = size / 2;
+    u16 *halfTable = table;
+    u16 checkResult;
+    u32 address;
 
-    v5 = sub_0201D628(v1, v2);
+    checkResult = sub_0201D628(table, size);
 
-    if (v4[v3] == v5) {
-        return 1;
+    if (halfTable[halfSize] == checkResult) {
+        return TRUE;
     }
 
-    v6 = (u32) & v4[v3];
+    address = (u32) &halfTable[halfSize];
     GF_ASSERT(0);
 
-    return 0;
+    return FALSE;
 }
 
-void sub_02025C84 (int param0)
+//ravetodo SaveData_SetChecksum
+void sub_02025C84 (int saveTableID)
 {
-    SaveData * v0 = SaveData_Ptr();
-    void * v1 = SaveData_SaveTable(v0, param0);
-    u16 * v2 = v1;
-    int v3, v4;
-    u16 v5;
-    u32 v6;
+    SaveData *saveData = SaveData_Ptr();
+    void *table = SaveData_SaveTable(saveData, saveTableID);
+    u16 *halfTable = table;
+    int halfSize, size;
+    u16 checksum;
+    u32 address;
 
-    v4 = SaveTableEntry_BodySize(param0) - 4;
-    v3 = v4 / 2;
-    v2 = v1;
-    v5 = sub_0201D628(v1, v4);
-    v2[v3] = v5;
-    v6 = (u32) & v2[v3];
+    size = SaveTableEntry_BodySize(saveTableID) - 4;
+    halfSize = size / 2;
+    halfTable = table;
+    checksum = sub_0201D628(table, size);
+    halfTable[halfSize] = checksum;
+    address = (u32) &halfTable[halfSize];
 }