diff --git a/src/main/kotlin/net/taehui/twilight/Twilight.kt b/src/main/kotlin/net/taehui/twilight/Twilight.kt
index f766efb..8275cb5 100644
--- a/src/main/kotlin/net/taehui/twilight/Twilight.kt
+++ b/src/main/kotlin/net/taehui/twilight/Twilight.kt
@@ -67,7 +67,7 @@
             TVSystem.loadAllowedTV()
 
             AbilityClassSystem.loadAbilityClass()
-            AbilitySystem.loadAbility()
+            AbilitySystem.load(false)
             EdgeSystem.loadEdge()
             LevelSystem.loadLevel()
             TitleSystem.loadTitle()
@@ -111,9 +111,11 @@
 
                 TVSystem.saveAllowedTV()
                 PlatformIDSystem.savePlatformID()
-                AvatarIPSystem.saveAvatarIP()
                 BannedIPSystem.saveBannedIP()
                 BannedNoteSystem.saveBannedNote()
+                AvatarIPSystem.saveAvatarIP()
+
+                Configure.saveConfigure()
             }
         }
     }
diff --git a/src/main/kotlin/net/taehui/twilight/system/AbilityClassSystem.kt b/src/main/kotlin/net/taehui/twilight/system/AbilityClassSystem.kt
index a6430c8..771d6e6 100644
--- a/src/main/kotlin/net/taehui/twilight/system/AbilityClassSystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/AbilityClassSystem.kt
@@ -5,7 +5,6 @@
 import com.fasterxml.jackson.databind.ObjectMapper
 import net.taehui.twilight.Logger
 import net.taehui.twilight.TwilightComponent
-import java.io.IOException
 import java.nio.file.Files
 
 object AbilityClassSystem : Logger {
@@ -114,82 +113,78 @@
     }
 
     fun loadAbilityClass() {
-        try {
-            val jm = ObjectMapper()
-            abilityClasses = jm.readValue(
-                TwilightComponent.ABILITY_CLASS_ENTRY_PATH.resolve("Default.json").toFile().absoluteFile,
-                object : TypeReference<Array<Array<Double>>>() {})
+        val jm = ObjectMapper()
+        abilityClasses = jm.readValue(
+            TwilightComponent.ABILITY_CLASS_ENTRY_PATH.resolve("Default.json").toFile().absoluteFile,
+            object : TypeReference<Array<Array<Double>>>() {})
 
-            fun loadAbilityClass(abilityClassVariety: AbilityClassVariety) {
-                fun loadDrawing(fileName: String): ByteArray {
-                    return Files.readAllBytes(
-                        TwilightComponent.ABILITY_CLASS_ENTRY_PATH.resolve(
-                            when (abilityClassVariety) {
-                                AbilityClassVariety.ETC -> ""
-                                AbilityClassVariety.INPUT_MODE_6K -> "6K"
-                                AbilityClassVariety.INPUT_MODE_5K -> "5K"
-                                AbilityClassVariety.INPUT_MODE_7K -> "7K"
-                                AbilityClassVariety.INPUT_MODE_9K -> "9K"
-                            }
-                        ).resolve(fileName)
-                    )
-                }
-
-                drawings[abilityClassVariety.value] = arrayOf(
-                    loadDrawing("S+1.png"),
-                    loadDrawing("S+2.png"),
-                    loadDrawing("S+3.png"),
-                    loadDrawing("S+4.png"),
-                    loadDrawing("S+5.png"),
-                    loadDrawing("S1.png"),
-                    loadDrawing("S2.png"),
-                    loadDrawing("S3.png"),
-                    loadDrawing("S4.png"),
-                    loadDrawing("S5.png"),
-                    loadDrawing("A+1.png"),
-                    loadDrawing("A+2.png"),
-                    loadDrawing("A+3.png"),
-                    loadDrawing("A+4.png"),
-                    loadDrawing("A+5.png"),
-                    loadDrawing("A1.png"),
-                    loadDrawing("A2.png"),
-                    loadDrawing("A3.png"),
-                    loadDrawing("A4.png"),
-                    loadDrawing("A5.png"),
-                    loadDrawing("B1.png"),
-                    loadDrawing("B2.png"),
-                    loadDrawing("B3.png"),
-                    loadDrawing("B4.png"),
-                    loadDrawing("B5.png"),
-                    loadDrawing("C1.png"),
-                    loadDrawing("C2.png"),
-                    loadDrawing("C3.png"),
-                    loadDrawing("C4.png"),
-                    loadDrawing("C5.png"),
-                    loadDrawing("D1.png"),
-                    loadDrawing("D2.png"),
-                    loadDrawing("D3.png"),
-                    loadDrawing("D4.png"),
-                    loadDrawing("D5.png"),
-                    loadDrawing("F.png")
+        fun loadAbilityClass(abilityClassVariety: AbilityClassVariety) {
+            fun loadDrawing(fileName: String): ByteArray {
+                return Files.readAllBytes(
+                    TwilightComponent.ABILITY_CLASS_ENTRY_PATH.resolve(
+                        when (abilityClassVariety) {
+                            AbilityClassVariety.ETC -> ""
+                            AbilityClassVariety.INPUT_MODE_6K -> "6K"
+                            AbilityClassVariety.INPUT_MODE_5K -> "5K"
+                            AbilityClassVariety.INPUT_MODE_7K -> "7K"
+                            AbilityClassVariety.INPUT_MODE_9K -> "9K"
+                        }
+                    ).resolve(fileName)
                 )
             }
 
-            loadAbilityClass(AbilityClassVariety.INPUT_MODE_6K)
-            loadAbilityClass(AbilityClassVariety.INPUT_MODE_5K)
-            loadAbilityClass(AbilityClassVariety.INPUT_MODE_7K)
-            loadAbilityClass(AbilityClassVariety.INPUT_MODE_9K)
-
-            logInfo("Loaded Ability Class")
-
-            jm.writerWithDefaultPrettyPrinter()
-                .writeValue(
-                    TwilightComponent.ABILITY_CLASS_ENTRY_PATH.resolve("Default.json").toFile().absoluteFile,
-                    abilityClasses
-                )
-            logInfo("Saved Ability Class")
-        } catch (e: IOException) {
-            logFault(e)
+            drawings[abilityClassVariety.value] = arrayOf(
+                loadDrawing("S+1.png"),
+                loadDrawing("S+2.png"),
+                loadDrawing("S+3.png"),
+                loadDrawing("S+4.png"),
+                loadDrawing("S+5.png"),
+                loadDrawing("S1.png"),
+                loadDrawing("S2.png"),
+                loadDrawing("S3.png"),
+                loadDrawing("S4.png"),
+                loadDrawing("S5.png"),
+                loadDrawing("A+1.png"),
+                loadDrawing("A+2.png"),
+                loadDrawing("A+3.png"),
+                loadDrawing("A+4.png"),
+                loadDrawing("A+5.png"),
+                loadDrawing("A1.png"),
+                loadDrawing("A2.png"),
+                loadDrawing("A3.png"),
+                loadDrawing("A4.png"),
+                loadDrawing("A5.png"),
+                loadDrawing("B1.png"),
+                loadDrawing("B2.png"),
+                loadDrawing("B3.png"),
+                loadDrawing("B4.png"),
+                loadDrawing("B5.png"),
+                loadDrawing("C1.png"),
+                loadDrawing("C2.png"),
+                loadDrawing("C3.png"),
+                loadDrawing("C4.png"),
+                loadDrawing("C5.png"),
+                loadDrawing("D1.png"),
+                loadDrawing("D2.png"),
+                loadDrawing("D3.png"),
+                loadDrawing("D4.png"),
+                loadDrawing("D5.png"),
+                loadDrawing("F.png")
+            )
         }
+
+        loadAbilityClass(AbilityClassVariety.INPUT_MODE_6K)
+        loadAbilityClass(AbilityClassVariety.INPUT_MODE_5K)
+        loadAbilityClass(AbilityClassVariety.INPUT_MODE_7K)
+        loadAbilityClass(AbilityClassVariety.INPUT_MODE_9K)
+
+        logInfo("Loaded Ability Class")
+
+        jm.writerWithDefaultPrettyPrinter()
+            .writeValue(
+                TwilightComponent.ABILITY_CLASS_ENTRY_PATH.resolve("Default.json").toFile().absoluteFile,
+                abilityClasses
+            )
+        logInfo("Saved Ability Class")
     }
 }
\ No newline at end of file
diff --git a/src/main/kotlin/net/taehui/twilight/system/AbilitySystem.kt b/src/main/kotlin/net/taehui/twilight/system/AbilitySystem.kt
index 7bb2957..09009af 100644
--- a/src/main/kotlin/net/taehui/twilight/system/AbilitySystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/AbilitySystem.kt
@@ -53,152 +53,144 @@
     private val abilityNameAbilityIDsMap = mutableMapOf<String, MutableCollection<String>>()
     private val abilityNameAbilityIDNoteIDCountMap = mutableMapOf<String, MutableMap<String, AtomicInteger>>()
 
-    fun loadAbility() {
-        logFuture {
-            val jm = ObjectMapper()
-            val defaultAbility = jm.readValue(
-                TwilightComponent.ABILITY_ENTRY_PATH.resolve("Default.json").toFile().absoluteFile,
-                DefaultAbility::class.java
-            )
-            if (Configure.mode.getAbility) {
-                defaultAbility.abilityWww.forEach { target ->
-                    try {
-                        val o = Jsoup.connect(target).get()
-                        var dataValue = o.selectXpath("/html/head/meta[@name='bmstable']")
-                        if (dataValue.isEmpty()) {
-                            dataValue = o.selectXpath("/html/body/meta[@name='bmstable']")
-                        }
-                        if (dataValue.isEmpty()) {
-                            dataValue = o.selectXpath("/html/head/body/meta[@name='bmstable']")
-                        }
-                        if (!dataValue.isEmpty()) {
-                            val www = dataValue[0].attr("content")
-                            HttpClients.createDefault().use {
-                                fun doModifyDataValue(target: String, dataValue: String): String {
-                                    return if (!Utility.isValidWww(dataValue)) {
-                                        if (target.substring(target.lastIndexOf('/'))
-                                                .contains(".") || target.endsWith("/")
-                                        ) {
-                                            "$target/../$dataValue"
-                                        } else {
-                                            "$target/$dataValue"
-                                        }
-                                    } else {
-                                        dataValue
-                                    }
-                                }
-
-                                val text = it.execute(
-                                    HttpGet(doModifyDataValue(target, www)),
-                                    BasicHttpClientResponseHandler()
-                                )
-                                val abilityTable = text.byteInputStream().use { src ->
-                                    ObjectMapper().readValue(src, JSON.BMSTable::class.java)
-                                }
-                                Files.writeString(
-                                    TwilightComponent.ABILITY_ENTRY_PATH.resolve("#" + abilityTable.name + ".json"),
-                                    text
-                                )
-                                Files.writeString(
-                                    TwilightComponent.ABILITY_ENTRY_PATH.resolve(abilityTable.name + ".json"),
-                                    it.execute(
-                                        HttpGet(doModifyDataValue(target, abilityTable.data_url)),
-                                        BasicHttpClientResponseHandler()
-                                    )
-                                )
-                                logInfo("Saved Ability (${abilityTable.name})")
-                            }
-                        }
-                    } catch (e: IOException) {
-                        logFault(e)
-                    }
-                }
-            }
+    private fun getAbility(defaultAbility: DefaultAbility) {
+        defaultAbility.abilityWww.forEach { target ->
             try {
-                val abilityMap = defaultAbility.abilityMap
-                noteIDAbilityMap[AbilityClassSystem.AbilityClassVariety.ETC]?.wipe()
-                noteIDAbilityMap[AbilityClassSystem.AbilityClassVariety.INPUT_MODE_6K]?.wipe()
-                noteIDAbilityMap[AbilityClassSystem.AbilityClassVariety.INPUT_MODE_5K]?.wipe()
-                noteIDAbilityMap[AbilityClassSystem.AbilityClassVariety.INPUT_MODE_7K]?.wipe()
-                noteIDAbilityMap[AbilityClassSystem.AbilityClassVariety.INPUT_MODE_9K]?.wipe()
-                noteIDAbilityIDsMap.wipe()
-                noteIDAbilityNamesMap.wipe()
-                abilityNameAbilityIDsMap.clear()
-                abilityNameAbilityIDNoteIDCountMap.clear()
-                Files.list(TwilightComponent.ABILITY_ENTRY_PATH).use { abilityFilePaths ->
-                    abilityFilePaths.filter { it.fileName.toString().startsWith('#') }.sorted(
-                        Comparator.comparingInt { abilityFilePath ->
-                            defaultAbility.abilityFiles.indexOfFirst {
-                                it.fileName == abilityFilePath.fileName.toString()
+                val o = Jsoup.connect(target).get()
+                var dataValue = o.selectXpath("/html/head/meta[@name='bmstable']")
+                if (dataValue.isEmpty()) {
+                    dataValue = o.selectXpath("/html/body/meta[@name='bmstable']")
+                }
+                if (dataValue.isEmpty()) {
+                    dataValue = o.selectXpath("/html/head/body/meta[@name='bmstable']")
+                }
+                if (!dataValue.isEmpty()) {
+                    val www = dataValue[0].attr("content")
+                    HttpClients.createDefault().use {
+                        fun doModifyDataValue(target: String, dataValue: String): String {
+                            return if (!Utility.isValidWww(dataValue)) {
+                                if (target.substring(target.lastIndexOf('/'))
+                                        .contains(".") || target.endsWith("/")
+                                ) {
+                                    "$target/../$dataValue"
+                                } else {
+                                    "$target/$dataValue"
+                                }
+                            } else {
+                                dataValue
                             }
                         }
-                    ).forEach { abilityFilePath ->
-                        val abilityFileName = abilityFilePath.fileName.toString()
-                        val abilityName = FilenameUtils.removeExtension(
-                            abilityFileName.substring(abilityFileName.indexOf('#') + 1)
+
+                        val text = it.execute(
+                            HttpGet(doModifyDataValue(target, www)),
+                            BasicHttpClientResponseHandler()
                         )
-                        val abilityClassVariety = defaultAbility.abilityFiles.find {
-                            it.fileName == abilityFileName
-                        }?.abilityClassVariety
-                        if (abilityClassVariety != null) {
-                            val noteIDAbilityMap = noteIDAbilityMap[abilityClassVariety]
-                            val abilityTable = jm.readValue(abilityFilePath.toFile().absoluteFile, JSON.BMSTable::class.java)
-                            val levels =
-                                abilityTable.level_order.map { "${abilityTable.symbol}$it" }.toTypedArray()
-                            jm.readValue(
-                                TwilightComponent.ABILITY_ENTRY_PATH.resolve("$abilityName.json")
-                                    .toFile().absoluteFile,
-                                Array<JSON.BMSTableData>::class.java
-                            ).forEach { abilityTableData ->
-                                val abilityID = "${abilityTable.symbol}${abilityTableData.level}"
-                                val ability = abilityMap[abilityID] ?: 0.0
-                                if (ability > 0.0) {
-                                    if (abilityTableData.md5.isNotEmpty()) {
-                                        noteIDAbilityMap?.noteID128Map?.putIfAbsent(abilityTableData.md5, ability)
-                                    }
-                                    if (abilityTableData.sha256.isNotEmpty()) {
-                                        noteIDAbilityMap?.noteID256Map?.putIfAbsent(abilityTableData.sha256, ability)
-                                    }
-                                }
-                                if (abilityTableData.md5.isNotEmpty()) {
-                                    noteIDAbilityIDsMap.noteID128Map.computeIfAbsent(
-                                        abilityTableData.md5
-                                    ) { mutableListOf() }.add(abilityID)
-                                    noteIDAbilityNamesMap.noteID128Map.computeIfAbsent(
-                                        abilityTableData.md5
-                                    ) { mutableListOf() }.add(abilityName)
-                                }
-                                if (abilityTableData.sha256.isNotEmpty()) {
-                                    noteIDAbilityIDsMap.noteID256Map.computeIfAbsent(
-                                        abilityTableData.sha256
-                                    ) { mutableListOf() }.add(abilityID)
-                                    noteIDAbilityNamesMap.noteID256Map.computeIfAbsent(
-                                        abilityTableData.md5
-                                    ) { mutableListOf() }.add(abilityName)
-                                }
-                                abilityNameAbilityIDsMap.computeIfAbsent(abilityName) {
-                                    if (levels.isEmpty()) mutableSetOf() else TreeSet { o1, o2 ->
-                                        levels.indexOf(o1).compareTo(levels.indexOf(o2))
-                                    }
-                                }.add(abilityID)
-                                abilityNameAbilityIDNoteIDCountMap.computeIfAbsent(abilityName) {
-                                    mutableMapOf()
-                                }.computeIfAbsent(abilityID) {
-                                    AtomicInteger()
-                                }.incrementAndGet()
-                            }
-                            logInfo("Loaded Ability (${abilityTable.name})")
+                        val abilityTable = text.byteInputStream().use { src ->
+                            ObjectMapper().readValue(src, JSON.BMSTable::class.java)
                         }
+                        Files.writeString(
+                            TwilightComponent.ABILITY_ENTRY_PATH.resolve("#${abilityTable.name}.json"),
+                            text
+                        )
+                        Files.writeString(
+                            TwilightComponent.ABILITY_ENTRY_PATH.resolve("${abilityTable.name}.json"),
+                            it.execute(
+                                HttpGet(doModifyDataValue(target, abilityTable.data_url)),
+                                BasicHttpClientResponseHandler()
+                            )
+                        )
+                        logInfo("Saved Ability (${abilityTable.name})")
                     }
                 }
-                DB.learnAbility()
-                logInfo("Learned Ability")
             } catch (e: IOException) {
                 logFault(e)
             }
         }
     }
 
+    private fun loadAbility(defaultAbility: DefaultAbility) {
+        val jm = ObjectMapper()
+        val abilityMap = defaultAbility.abilityMap
+        noteIDAbilityMap[AbilityClassSystem.AbilityClassVariety.ETC]?.wipe()
+        noteIDAbilityMap[AbilityClassSystem.AbilityClassVariety.INPUT_MODE_6K]?.wipe()
+        noteIDAbilityMap[AbilityClassSystem.AbilityClassVariety.INPUT_MODE_5K]?.wipe()
+        noteIDAbilityMap[AbilityClassSystem.AbilityClassVariety.INPUT_MODE_7K]?.wipe()
+        noteIDAbilityMap[AbilityClassSystem.AbilityClassVariety.INPUT_MODE_9K]?.wipe()
+        noteIDAbilityIDsMap.wipe()
+        noteIDAbilityNamesMap.wipe()
+        abilityNameAbilityIDsMap.clear()
+        abilityNameAbilityIDNoteIDCountMap.clear()
+        defaultAbility.abilityFiles.forEach { abilityFile ->
+            val abilityFilePath = TwilightComponent.ABILITY_ENTRY_PATH.resolve(abilityFile.fileName)
+            val abilityFileName = abilityFilePath.fileName.toString()
+            val abilityName = FilenameUtils.removeExtension(
+                abilityFileName.substring(abilityFileName.indexOf('#') + 1)
+            )
+            val noteIDAbilityMap = noteIDAbilityMap[abilityFile.abilityClassVariety]
+            val abilityTable =
+                jm.readValue(abilityFilePath.toFile().absoluteFile, JSON.BMSTable::class.java)
+            val levels =
+                abilityTable.level_order.map { "${abilityTable.symbol}$it" }.toTypedArray()
+            jm.readValue(
+                TwilightComponent.ABILITY_ENTRY_PATH.resolve("$abilityName.json")
+                    .toFile().absoluteFile,
+                Array<JSON.BMSTableData>::class.java
+            ).forEach { abilityTableData ->
+                val abilityID = "${abilityTable.symbol}${abilityTableData.level}"
+                val ability = abilityMap[abilityID] ?: 0.0
+                if (ability > 0.0) {
+                    if (abilityTableData.md5.isNotEmpty()) {
+                        noteIDAbilityMap?.noteID128Map?.putIfAbsent(abilityTableData.md5, ability)
+                    }
+                    if (abilityTableData.sha256.isNotEmpty()) {
+                        noteIDAbilityMap?.noteID256Map?.putIfAbsent(abilityTableData.sha256, ability)
+                    }
+                }
+                if (abilityTableData.md5.isNotEmpty()) {
+                    noteIDAbilityIDsMap.noteID128Map.computeIfAbsent(
+                        abilityTableData.md5
+                    ) { mutableListOf() }.add(abilityID)
+                    noteIDAbilityNamesMap.noteID128Map.computeIfAbsent(
+                        abilityTableData.md5
+                    ) { mutableListOf() }.add(abilityName)
+                }
+                if (abilityTableData.sha256.isNotEmpty()) {
+                    noteIDAbilityIDsMap.noteID256Map.computeIfAbsent(
+                        abilityTableData.sha256
+                    ) { mutableListOf() }.add(abilityID)
+                    noteIDAbilityNamesMap.noteID256Map.computeIfAbsent(
+                        abilityTableData.md5
+                    ) { mutableListOf() }.add(abilityName)
+                }
+                abilityNameAbilityIDsMap.computeIfAbsent(abilityName) {
+                    if (levels.isEmpty()) mutableSetOf() else TreeSet { o1, o2 ->
+                        levels.indexOf(o1).compareTo(levels.indexOf(o2))
+                    }
+                }.add(abilityID)
+                abilityNameAbilityIDNoteIDCountMap.computeIfAbsent(abilityName) {
+                    mutableMapOf()
+                }.computeIfAbsent(abilityID) {
+                    AtomicInteger()
+                }.incrementAndGet()
+            }
+            logInfo("Loaded Ability ($abilityName.json)")
+        }
+        DB.learnAbility()
+        logInfo("Learned Ability")
+    }
+
+    fun load(getAbility: Boolean) {
+        val jm = ObjectMapper()
+        val defaultAbility = jm.readValue(
+            TwilightComponent.ABILITY_ENTRY_PATH.resolve("Default.json").toFile().absoluteFile,
+            DefaultAbility::class.java
+        )
+        if (getAbility) {
+            getAbility(defaultAbility)
+        }
+        loadAbility(defaultAbility)
+    }
+
     fun getAbility(
         abilityClassVariety: AbilityClassSystem.AbilityClassVariety,
         noteID128: String,
diff --git a/src/main/kotlin/net/taehui/twilight/system/AvatarIPSystem.kt b/src/main/kotlin/net/taehui/twilight/system/AvatarIPSystem.kt
index 5d43bb7..4d75168 100644
--- a/src/main/kotlin/net/taehui/twilight/system/AvatarIPSystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/AvatarIPSystem.kt
@@ -4,7 +4,6 @@
 import com.fasterxml.jackson.databind.ObjectMapper
 import net.taehui.twilight.Avatar
 import net.taehui.twilight.Logger
-import java.io.IOException
 import java.nio.file.Files
 import java.nio.file.Paths
 import java.util.concurrent.ConcurrentHashMap
@@ -14,16 +13,12 @@
     private var avatarIPStore = ConcurrentHashMap<String, CopyOnWriteArraySet<String>>()
 
     fun loadAvatarIP() {
-        try {
-            avatarIPStore.putAll(
-                ObjectMapper().readValue(
-                    Paths.get("Avatar IP.json").toFile().absoluteFile,
-                    object : TypeReference<ConcurrentHashMap<String, CopyOnWriteArraySet<String>>>() {})
-            )
-            logInfo("Loaded Avatar IP")
-        } catch (e: IOException) {
-            logFault(e)
-        }
+        avatarIPStore = ObjectMapper().readValue(
+            Paths.get("Avatar IP.json").toFile().absoluteFile,
+            object : TypeReference<ConcurrentHashMap<String, CopyOnWriteArraySet<String>>>() {})
+        logInfo("Loaded Avatar IP")
+
+        saveAvatarIP()
     }
 
     fun saveAvatarIP() {
diff --git a/src/main/kotlin/net/taehui/twilight/system/BannedIPSystem.kt b/src/main/kotlin/net/taehui/twilight/system/BannedIPSystem.kt
index 5028e51..6b9948a 100644
--- a/src/main/kotlin/net/taehui/twilight/system/BannedIPSystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/BannedIPSystem.kt
@@ -4,13 +4,12 @@
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule
 import net.taehui.twilight.Logger
-import java.io.IOException
 import java.nio.file.Paths
 import java.time.LocalDateTime
 import java.util.concurrent.ConcurrentHashMap
 
 object BannedIPSystem : Logger {
-    private val bannedIPStore = ConcurrentHashMap<String, LocalDateTime>()
+    private var bannedIPStore = ConcurrentHashMap<String, LocalDateTime>()
 
     private fun getJSONMapper(): ObjectMapper {
         val jm = ObjectMapper()
@@ -19,16 +18,12 @@
     }
 
     fun loadBannedIP() {
-        try {
-            bannedIPStore.putAll(
-                getJSONMapper().readValue(
-                    Paths.get("Banned IP.json").toFile().absoluteFile,
-                    object : TypeReference<ConcurrentHashMap<String, LocalDateTime>>() {})
-            )
-            logInfo("Loaded Banned IP")
-        } catch (e: IOException) {
-            logFault(e)
-        }
+        bannedIPStore = getJSONMapper().readValue(
+            Paths.get("Banned IP.json").toFile().absoluteFile,
+            object : TypeReference<ConcurrentHashMap<String, LocalDateTime>>() {})
+        logInfo("Loaded Banned IP")
+
+        saveBannedIP()
     }
 
     fun saveBannedIP() {
diff --git a/src/main/kotlin/net/taehui/twilight/system/BannedNoteSystem.kt b/src/main/kotlin/net/taehui/twilight/system/BannedNoteSystem.kt
index a1b24a4..4d79d54 100644
--- a/src/main/kotlin/net/taehui/twilight/system/BannedNoteSystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/BannedNoteSystem.kt
@@ -3,24 +3,19 @@
 import com.fasterxml.jackson.core.type.TypeReference
 import com.fasterxml.jackson.databind.ObjectMapper
 import net.taehui.twilight.Logger
-import java.io.IOException
 import java.nio.file.Paths
 import java.util.concurrent.ConcurrentHashMap
 
 object BannedNoteSystem : Logger {
-    private val bannedNoteStore = ConcurrentHashMap<String, String>()
+    private var bannedNoteStore = ConcurrentHashMap<String, String>()
 
     fun loadBannedNote() {
-        try {
-            bannedNoteStore.putAll(
-                ObjectMapper().readValue(
-                    Paths.get("Banned Note.json").toFile().absoluteFile,
-                    object : TypeReference<ConcurrentHashMap<String, String>>() {})
-            )
-            logInfo("Loaded Banned Note")
-        } catch (e: IOException) {
-            logFault(e)
-        }
+        bannedNoteStore = ObjectMapper().readValue(
+            Paths.get("Banned Note.json").toFile().absoluteFile,
+            object : TypeReference<ConcurrentHashMap<String, String>>() {})
+        logInfo("Loaded Banned Note")
+
+        saveBannedNote()
     }
 
     fun saveBannedNote() {
diff --git a/src/main/kotlin/net/taehui/twilight/system/Configure.kt b/src/main/kotlin/net/taehui/twilight/system/Configure.kt
index 5fcbe64..7db1beb 100644
--- a/src/main/kotlin/net/taehui/twilight/system/Configure.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/Configure.kt
@@ -85,7 +85,6 @@
     }
 
     class Mode {
-        var getAbility = false
         var platform = false
         var tv = false
 
@@ -113,27 +112,25 @@
     lateinit var www: Www
     lateinit var nhn: NHN
     var awilightCount = 0
+
     @JsonIgnore
     var defaultNoteDate = 0L
+
     @JsonIgnore
     var defaultUIDate = 0L
 
     fun loadConfigure() {
-        try {
-            val text = ObjectMapper().readValue(Paths.get("Configure.json").toFile().absoluteFile, Configure::class.java)
-            Configure::class.java.fields.forEach {
-                if (it.getAnnotation(JsonIgnore::class.java)?.value != true && it.modifiers and Modifier.FINAL != Modifier.FINAL) {
-                    it[this] = it[text] ?: throw RuntimeException(it.name)
-                }
+        val text = ObjectMapper().readValue(Paths.get("Configure.json").toFile().absoluteFile, Configure::class.java)
+        Configure::class.java.fields.forEach {
+            if (it.getAnnotation(JsonIgnore::class.java)?.value != true && it.modifiers and Modifier.FINAL != Modifier.FINAL) {
+                it[this] = it[text] ?: throw RuntimeException(it.name)
             }
-            defaultNoteDate = Files.getLastModifiedTime(TwilightComponent.DEFAULT_NOTE_ENTRY).to(TimeUnit.MILLISECONDS)
-            defaultUIDate = Files.getLastModifiedTime(TwilightComponent.DEFAULT_UI_ENTRY).to(TimeUnit.MILLISECONDS)
-            logInfo("Loaded Configure")
-
-            saveConfigure()
-        } catch (e: IOException) {
-            logFault(e)
         }
+        defaultNoteDate = Files.getLastModifiedTime(TwilightComponent.DEFAULT_NOTE_ENTRY).to(TimeUnit.MILLISECONDS)
+        defaultUIDate = Files.getLastModifiedTime(TwilightComponent.DEFAULT_UI_ENTRY).to(TimeUnit.MILLISECONDS)
+        logInfo("Loaded Configure")
+
+        saveConfigure()
     }
 
     fun saveConfigure() {
diff --git a/src/main/kotlin/net/taehui/twilight/system/EdgeSystem.kt b/src/main/kotlin/net/taehui/twilight/system/EdgeSystem.kt
index fa9d914..f90070c 100644
--- a/src/main/kotlin/net/taehui/twilight/system/EdgeSystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/EdgeSystem.kt
@@ -5,7 +5,6 @@
 import net.taehui.twilight.Logger
 import net.taehui.twilight.TwilightComponent
 import org.apache.commons.io.FilenameUtils
-import java.io.IOException
 import java.nio.file.Files
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
@@ -26,48 +25,36 @@
     }
 
     fun loadEdge() {
-        try {
-            fileNameEdgeItemMap.clear()
-            edgeIDDrawingMap.clear()
-            Files.list(TwilightComponent.EDGE_ENTRY_PATH).use { edgeEntryPaths ->
-                edgeEntryPaths.forEach { edgeEntryPath ->
-                    try {
-                        if (Files.isDirectory(edgeEntryPath)) {
-                            Files.list(edgeEntryPath).use { edgeFilePaths ->
-                                edgeFilePaths.forEach { edgeFilePath ->
-                                    try {
-                                        edgeIDDrawingMap[FilenameUtils.removeExtension(edgeFilePath.fileName.toString())] =
-                                            Files.readAllBytes(edgeFilePath)
-                                        logInfo("Loaded Edge (${edgeFilePath.fileName})")
-                                    } catch (e: IOException) {
-                                        logFault(e)
-                                    }
-                                }
-                            }
-                        } else if (edgeEntryPath.fileName.toString() == "Default.json") {
-                            val jm = ObjectMapper()
-                            val fileNameEdgeItems = TreeMap(
-                                jm.readValue(
-                                    edgeEntryPath.toFile().absoluteFile,
-                                    object : TypeReference<Map<String, EdgeItem>>() {})
-                            )
-                            fileNameEdgeItemMap.putAll(fileNameEdgeItems)
-                            logInfo("Loaded Edge (${edgeEntryPath.fileName})")
-
-                            jm.writerWithDefaultPrettyPrinter()
-                                .writeValue(
-                                    TwilightComponent.EDGE_ENTRY_PATH.resolve("Default.json").toFile().absoluteFile,
-                                    fileNameEdgeItems
-                                )
-                            logInfo("Saved Edge (${edgeEntryPath.fileName})")
+        fileNameEdgeItemMap.clear()
+        edgeIDDrawingMap.clear()
+        Files.list(TwilightComponent.EDGE_ENTRY_PATH).use { edgeEntryPaths ->
+            edgeEntryPaths.forEach { edgeEntryPath ->
+                if (Files.isDirectory(edgeEntryPath)) {
+                    Files.list(edgeEntryPath).use { edgeFilePaths ->
+                        edgeFilePaths.forEach { edgeFilePath ->
+                            edgeIDDrawingMap[FilenameUtils.removeExtension(edgeFilePath.fileName.toString())] =
+                                Files.readAllBytes(edgeFilePath)
+                            logInfo("Loaded Edge (${edgeFilePath.fileName})")
                         }
-                    } catch (e: IOException) {
-                        logFault(e)
                     }
+                } else if (edgeEntryPath.fileName.toString() == "Default.json") {
+                    val jm = ObjectMapper()
+                    val fileNameEdgeItems = TreeMap(
+                        jm.readValue(
+                            edgeEntryPath.toFile().absoluteFile,
+                            object : TypeReference<Map<String, EdgeItem>>() {})
+                    )
+                    fileNameEdgeItemMap.putAll(fileNameEdgeItems)
+                    logInfo("Loaded Edge (${edgeEntryPath.fileName})")
+
+                    jm.writerWithDefaultPrettyPrinter()
+                        .writeValue(
+                            TwilightComponent.EDGE_ENTRY_PATH.resolve("Default.json").toFile().absoluteFile,
+                            fileNameEdgeItems
+                        )
+                    logInfo("Saved Edge (${edgeEntryPath.fileName})")
                 }
             }
-        } catch (e: IOException) {
-            logFault(e)
         }
     }
 
@@ -77,8 +64,7 @@
                     (edgeItem.wwwLevel.isEmpty() || levelIDs.any { it == edgeItem.wwwLevel }) &&
                     edgeItem.noteIDs?.all { noteID -> noteIDs.any { it == noteID } } != false &&
                     edgeItem.wwwLevelCount <= levelIDs.size
-        }
-            .map { it.key }
+        }.map { it.key }
     }
 
     fun getEdgeIDs(levelID: String): Collection<String> {
diff --git a/src/main/kotlin/net/taehui/twilight/system/IO.kt b/src/main/kotlin/net/taehui/twilight/system/IO.kt
index a6946ee..3345760 100644
--- a/src/main/kotlin/net/taehui/twilight/system/IO.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/IO.kt
@@ -500,6 +500,15 @@
                         }
 
                         "reload" -> {
+                            if (w.size > 1) {
+                                when (w[1]) {
+                                    "ability" -> {
+                                        AbilitySystem.load(true)
+                                        continue
+                                    }
+                                }
+                            }
+
                             AvatarIPSystem.loadAvatarIP()
                             BannedNoteSystem.loadBannedNote()
                             BannedIPSystem.loadBannedIP()
@@ -507,14 +516,11 @@
                             TVSystem.loadAllowedTV()
 
                             AbilityClassSystem.loadAbilityClass()
-                            AbilitySystem.loadAbility()
+                            AbilitySystem.load(false)
                             EdgeSystem.loadEdge()
                             LevelSystem.loadLevel()
                             TitleSystem.loadTitle()
                             VoteSystem.loadVote()
-
-                            NoteFilesSystem.loadNoteFiles()
-                            QwilightNamesSystem.loadQwilightNames()
                             continue
                         }
 
diff --git a/src/main/kotlin/net/taehui/twilight/system/LevelSystem.kt b/src/main/kotlin/net/taehui/twilight/system/LevelSystem.kt
index 9e68860..ed675f0 100644
--- a/src/main/kotlin/net/taehui/twilight/system/LevelSystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/LevelSystem.kt
@@ -5,11 +5,10 @@
 import net.taehui.twilight.Logger
 import net.taehui.twilight.TwilightComponent
 import org.apache.commons.io.FilenameUtils
-import java.io.IOException
 import java.nio.file.Files
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.CopyOnWriteArraySet
 import java.util.stream.Stream
 import kotlin.io.path.exists
 
@@ -126,52 +125,44 @@
     private val levelNameLevelGroupMap = ConcurrentHashMap<String, LevelGroup>()
     private val avatarIDLevelNameMap = ConcurrentHashMap<String, MutableList<String>>()
     private val levelIDDrawingMap = ConcurrentHashMap<String, ByteArray>()
-    val levelNoteIDs = CopyOnWriteArrayList<String>()
+    val levelNoteIDs = CopyOnWriteArraySet<String>()
 
     fun loadLevel() {
-        try {
-            avatarIDLevelGroupMap.clear()
-            levelNameLevelGroupMap.clear()
-            avatarIDLevelNameMap.clear()
-            levelIDDrawingMap.clear()
-            levelNoteIDs.clear()
-            Files.list(TwilightComponent.LEVEL_ENTRY_PATH).use {
-                it.forEach { levelFilePath ->
-                    if (!Files.isDirectory(levelFilePath)) {
-                        try {
-                            val jm = ObjectMapper()
-                            val levelGroup = jm.readValue(levelFilePath.toFile().absoluteFile, LevelGroup::class.java)
-                            levelGroup.levelItems.map { data ->
-                                data.noteID.split("/".toRegex()).toTypedArray()
-                            }.forEach { noteIDs -> levelNoteIDs.addAll(listOf(*noteIDs)) }
-                            Arrays.sort(levelGroup.levelItems)
+        avatarIDLevelGroupMap.clear()
+        levelNameLevelGroupMap.clear()
+        avatarIDLevelNameMap.clear()
+        levelIDDrawingMap.clear()
+        levelNoteIDs.clear()
+        Files.list(TwilightComponent.LEVEL_ENTRY_PATH).use {
+            it.forEach { levelFilePath ->
+                if (!Files.isDirectory(levelFilePath)) {
+                    val jm = ObjectMapper()
+                    val levelGroup = jm.readValue(levelFilePath.toFile().absoluteFile, LevelGroup::class.java)
+                    levelGroup.levelItems.map { data ->
+                        data.noteID.split("/".toRegex()).toTypedArray()
+                    }.forEach { noteIDs -> levelNoteIDs.addAll(listOf(*noteIDs)) }
+                    Arrays.sort(levelGroup.levelItems)
 
-                            val avatarID = levelGroup.avatarID
-                            val levelName = FilenameUtils.removeExtension(levelFilePath.fileName.toString())
-                            avatarIDLevelGroupMap.computeIfAbsent(avatarID) { mutableListOf() }.add(levelGroup)
-                            levelNameLevelGroupMap[levelName] = levelGroup
-                            avatarIDLevelNameMap.computeIfAbsent(avatarID) { mutableListOf() }.add(levelName)
-                            levelGroup.levelItems.forEach { levelItem ->
-                                val levelID = levelItem.levelID
-                                val levelIDDrawingFilePath = TwilightComponent.LEVEL_ENTRY_PATH.resolve(levelName)
-                                    .resolve("$levelID.png")
-                                if (levelIDDrawingFilePath.exists()) {
-                                    levelIDDrawingMap[levelID] = Files.readAllBytes(levelIDDrawingFilePath)
-                                }
-                            }
-                            logInfo("Loaded Level (${levelFilePath.fileName})")
-
-                            jm.writerWithDefaultPrettyPrinter()
-                                .writeValue(levelFilePath.toFile().absoluteFile, levelGroup)
-                            logInfo("Saved Level (${levelFilePath.fileName})")
-                        } catch (e: IOException) {
-                            logFault(e)
+                    val avatarID = levelGroup.avatarID
+                    val levelName = FilenameUtils.removeExtension(levelFilePath.fileName.toString())
+                    avatarIDLevelGroupMap.computeIfAbsent(avatarID) { mutableListOf() }.add(levelGroup)
+                    levelNameLevelGroupMap[levelName] = levelGroup
+                    avatarIDLevelNameMap.computeIfAbsent(avatarID) { mutableListOf() }.add(levelName)
+                    levelGroup.levelItems.forEach { levelItem ->
+                        val levelID = levelItem.levelID
+                        val levelIDDrawingFilePath = TwilightComponent.LEVEL_ENTRY_PATH.resolve(levelName)
+                            .resolve("$levelID.png")
+                        if (levelIDDrawingFilePath.exists()) {
+                            levelIDDrawingMap[levelID] = Files.readAllBytes(levelIDDrawingFilePath)
                         }
                     }
+                    logInfo("Loaded Level (${levelFilePath.fileName})")
+
+                    jm.writerWithDefaultPrettyPrinter()
+                        .writeValue(levelFilePath.toFile().absoluteFile, levelGroup)
+                    logInfo("Saved Level (${levelFilePath.fileName})")
                 }
             }
-        } catch (e: IOException) {
-            logFault(e)
         }
     }
 
diff --git a/src/main/kotlin/net/taehui/twilight/system/NoteFilesSystem.kt b/src/main/kotlin/net/taehui/twilight/system/NoteFilesSystem.kt
index 6fc1f1a..77725f2 100644
--- a/src/main/kotlin/net/taehui/twilight/system/NoteFilesSystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/NoteFilesSystem.kt
@@ -3,7 +3,6 @@
 import net.taehui.twilight.Logger
 import net.taehui.twilight.TwilightComponent
 import net.taehui.twilight.Utility
-import java.io.IOException
 import java.nio.file.Path
 import java.util.concurrent.ConcurrentHashMap
 
@@ -12,14 +11,10 @@
 
     fun loadNoteFiles() {
         DB.getNotes().thenAccept { notes ->
-            try {
-                noteFiles = ConcurrentHashMap(notes.associateWith {
-                    TwilightComponent.NOTE_ENTRY_PATH.resolve(Utility.getNoteID512(it))
-                })
-                logInfo("Loaded Note Files")
-            } catch (e: IOException) {
-                logFault(e)
-            }
+            noteFiles = ConcurrentHashMap(notes.associateWith {
+                TwilightComponent.NOTE_ENTRY_PATH.resolve(Utility.getNoteID512(it))
+            })
+            logInfo("Loaded Note Files")
         }
     }
 
diff --git a/src/main/kotlin/net/taehui/twilight/system/PlatformIDSystem.kt b/src/main/kotlin/net/taehui/twilight/system/PlatformIDSystem.kt
index 7667d50..af4e837 100644
--- a/src/main/kotlin/net/taehui/twilight/system/PlatformIDSystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/PlatformIDSystem.kt
@@ -3,7 +3,6 @@
 import com.fasterxml.jackson.core.type.TypeReference
 import com.fasterxml.jackson.databind.ObjectMapper
 import net.taehui.twilight.Logger
-import java.io.IOException
 import java.nio.file.Paths
 import java.util.concurrent.ConcurrentHashMap
 
@@ -12,20 +11,15 @@
     private var avatarIDPlatformIDMap = ConcurrentHashMap<String, String>()
 
     fun loadPlatformID() {
-        try {
-            platformIDAvatarIDMap.putAll(
-                ObjectMapper().readValue(Paths.get("Platform ID.json").toFile().absoluteFile,
-                    object : TypeReference<ConcurrentHashMap<String, String>>() {})
-            )
+        platformIDAvatarIDMap = ObjectMapper().readValue(Paths.get("Platform ID.json").toFile().absoluteFile,
+            object : TypeReference<ConcurrentHashMap<String, String>>() {})
+        avatarIDPlatformIDMap = ConcurrentHashMap(platformIDAvatarIDMap.map {
+            Pair(it.value, it.key)
+        }.toMap())
 
-            platformIDAvatarIDMap.forEach { (platformID, avatarID) ->
-                avatarIDPlatformIDMap[avatarID] = platformID
-            }
+        logInfo("Loaded Platform ID")
 
-            logInfo("Loaded Platform ID")
-        } catch (e: IOException) {
-            logFault(e)
-        }
+        savePlatformID()
     }
 
     fun savePlatformID() {
diff --git a/src/main/kotlin/net/taehui/twilight/system/TVSystem.kt b/src/main/kotlin/net/taehui/twilight/system/TVSystem.kt
index 410633f..b4be5bc 100644
--- a/src/main/kotlin/net/taehui/twilight/system/TVSystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/TVSystem.kt
@@ -10,7 +10,6 @@
 import org.openqa.selenium.edge.EdgeOptions
 import org.openqa.selenium.support.ui.ExpectedConditions
 import org.openqa.selenium.support.ui.WebDriverWait
-import java.io.IOException
 import java.nio.file.Files
 import java.nio.file.Paths
 import java.time.Duration
@@ -38,7 +37,7 @@
     }
     private var tv: WebDriver? = null
     private var future: ScheduledFuture<*>? = null
-    private var allowedTVStore = ConcurrentSkipListSet<String>()
+    private var allowedTVStore = CopyOnWriteArraySet<String>()
 
     fun handleSystem() {
         if (tv != null) {
@@ -134,16 +133,12 @@
     }
 
     fun loadAllowedTV() {
-        try {
-            allowedTVStore.addAll(
-                ObjectMapper().readValue(
-                    Paths.get("Allowed TV.json").toFile().absoluteFile,
-                    object : TypeReference<ConcurrentSkipListSet<String>>() {})
-            )
-            logInfo("Loaded Allowed TV")
-        } catch (e: IOException) {
-            logFault(e)
-        }
+        allowedTVStore = ObjectMapper().readValue(
+            Paths.get("Allowed TV.json").toFile().absoluteFile,
+            object : TypeReference<CopyOnWriteArraySet<String>>() {})
+        logInfo("Loaded Allowed TV")
+
+        saveAllowedTV()
     }
 
     fun saveAllowedTV() {
diff --git a/src/main/kotlin/net/taehui/twilight/system/TitleSystem.kt b/src/main/kotlin/net/taehui/twilight/system/TitleSystem.kt
index 1eb641d..e4a25b1 100644
--- a/src/main/kotlin/net/taehui/twilight/system/TitleSystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/TitleSystem.kt
@@ -5,7 +5,6 @@
 import net.taehui.twilight.JSON
 import net.taehui.twilight.Logger
 import net.taehui.twilight.TwilightComponent
-import java.io.IOException
 import java.nio.file.Files
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
@@ -46,30 +45,23 @@
     private val titleIDTitleItemMap = ConcurrentHashMap<String, TitleItem>()
 
     fun loadTitle() {
-        try {
-            titleIDTitleItemMap.clear()
-            Files.list(TwilightComponent.TITLE_ENTRY_PATH).use { titleFilePaths ->
-                titleFilePaths.forEach { titleFilePath ->
-                    try {
-                        val jm = ObjectMapper()
-                        val titleItems =
-                            jm.readValue(
-                                titleFilePath.toFile().absoluteFile,
-                                object : TypeReference<Map<String, TitleItem>>() {})
-                        val titleIDTitleItems = TreeMap<String, TitleItem>(Comparator.comparing { titleItems[it]!! })
-                        titleIDTitleItems.putAll(titleItems)
-                        titleIDTitleItemMap.putAll(titleIDTitleItems)
-                        logInfo("Loaded Title (${titleFilePath.fileName})")
+        titleIDTitleItemMap.clear()
+        Files.list(TwilightComponent.TITLE_ENTRY_PATH).use { titleFilePaths ->
+            titleFilePaths.forEach { titleFilePath ->
+                val jm = ObjectMapper()
+                val titleItems =
+                    jm.readValue(
+                        titleFilePath.toFile().absoluteFile,
+                        object : TypeReference<Map<String, TitleItem>>() {})
+                val titleIDTitleItems = TreeMap<String, TitleItem>(Comparator.comparing { titleItems[it]!! })
+                titleIDTitleItems.putAll(titleItems)
+                titleIDTitleItemMap.putAll(titleIDTitleItems)
+                logInfo("Loaded Title (${titleFilePath.fileName})")
 
-                        jm.writerWithDefaultPrettyPrinter().writeValue(titleFilePath.toFile().absoluteFile, titleIDTitleItems)
-                        logInfo("Saved Title (${titleFilePath.fileName})")
-                    } catch (e: IOException) {
-                        logFault(e)
-                    }
-                }
+                jm.writerWithDefaultPrettyPrinter()
+                    .writeValue(titleFilePath.toFile().absoluteFile, titleIDTitleItems)
+                logInfo("Saved Title (${titleFilePath.fileName})")
             }
-        } catch (e: IOException) {
-            logFault(e)
         }
     }
 
diff --git a/src/main/kotlin/net/taehui/twilight/system/VoteSystem.kt b/src/main/kotlin/net/taehui/twilight/system/VoteSystem.kt
index e6916de..7a9ea6e 100644
--- a/src/main/kotlin/net/taehui/twilight/system/VoteSystem.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/VoteSystem.kt
@@ -4,7 +4,6 @@
 import net.taehui.twilight.Logger
 import net.taehui.twilight.TwilightComponent
 import org.apache.commons.io.FilenameUtils
-import java.io.IOException
 import java.nio.file.Files
 import java.util.*
 
@@ -41,22 +40,18 @@
     }
 
     fun loadVote() {
-        try {
-            val jm = ObjectMapper()
-            voteNameVoteItemsMap.clear()
-            Files.list(TwilightComponent.VOTE_ENTRY_PATH).use {
-                it.forEach { voteFilePath ->
-                    val voteItems = jm.readValue(voteFilePath.toFile().absoluteFile, Array<VoteItem>::class.java)
-                    Arrays.sort(voteItems)
-                    voteNameVoteItemsMap[FilenameUtils.removeExtension(voteFilePath.fileName.toString())] = voteItems
-                    logInfo("Loaded Vote (${voteFilePath.fileName})")
+        val jm = ObjectMapper()
+        voteNameVoteItemsMap.clear()
+        Files.list(TwilightComponent.VOTE_ENTRY_PATH).use {
+            it.forEach { voteFilePath ->
+                val voteItems = jm.readValue(voteFilePath.toFile().absoluteFile, Array<VoteItem>::class.java)
+                Arrays.sort(voteItems)
+                voteNameVoteItemsMap[FilenameUtils.removeExtension(voteFilePath.fileName.toString())] = voteItems
+                logInfo("Loaded Vote (${voteFilePath.fileName})")
 
-                    jm.writerWithDefaultPrettyPrinter().writeValue(voteFilePath.toFile().absoluteFile, voteItems)
-                    logInfo("Saved Vote (${voteFilePath.fileName})")
-                }
+                jm.writerWithDefaultPrettyPrinter().writeValue(voteFilePath.toFile().absoluteFile, voteItems)
+                logInfo("Saved Vote (${voteFilePath.fileName})")
             }
-        } catch (e: IOException) {
-            logFault(e)
         }
     }
 
diff --git a/src/main/kotlin/net/taehui/twilight/taehui/TaehuiAvatar.kt b/src/main/kotlin/net/taehui/twilight/taehui/TaehuiAvatar.kt
index 3f24c7e..45e1954 100644
--- a/src/main/kotlin/net/taehui/twilight/taehui/TaehuiAvatar.kt
+++ b/src/main/kotlin/net/taehui/twilight/taehui/TaehuiAvatar.kt
@@ -99,7 +99,6 @@
                     date = date.replace("!", "")
                     Configure.hash.add(hashAMD64)
                     Configure.hash.add(hashARM64)
-                    Configure.saveConfigure()
                     val jm = ObjectMapper()
                     val qwilightDateFilePath = Configure.path.wwwPath.resolve(Configure.path.datePath)
                     val qwilightDate =