diff --git a/src/main/kotlin/net/taehui/twilight/Component.kt b/src/main/kotlin/net/taehui/twilight/Component.kt
index d4d2845..78cf7ae 100644
--- a/src/main/kotlin/net/taehui/twilight/Component.kt
+++ b/src/main/kotlin/net/taehui/twilight/Component.kt
@@ -108,6 +108,8 @@
     }
 
     companion object {
+        const val AUTOABLE_AUTO_MODE = 1
+
         const val DEFAULT_JUDGMENT_MODE = 1
         const val HIGHER_JUDGMENT_MODE = 2
         const val HIGHEST_JUDGMENT_MODE = 4
diff --git a/src/main/kotlin/net/taehui/twilight/qwilight/QwilightAvatar.kt b/src/main/kotlin/net/taehui/twilight/qwilight/QwilightAvatar.kt
index 4443a30..bf8e7b2 100644
--- a/src/main/kotlin/net/taehui/twilight/qwilight/QwilightAvatar.kt
+++ b/src/main/kotlin/net/taehui/twilight/qwilight/QwilightAvatar.kt
@@ -22,6 +22,7 @@
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.StandardOpenOption
+import java.sql.Timestamp
 import java.time.LocalDateTime
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
@@ -87,7 +88,7 @@
                     val isSilent = isSilent
                     val data = bundles.first.map {
                         object {
-                            val date = it[0] as Long
+                            val date = it[0] as Timestamp
                             val bundleName = it[1] as String
                             val bundleLength = it[2] as Long
                             val bundleCompetence = it[3] as Int
diff --git a/src/main/kotlin/net/taehui/twilight/system/DB.kt b/src/main/kotlin/net/taehui/twilight/system/DB.kt
index 51e8511..9809917 100644
--- a/src/main/kotlin/net/taehui/twilight/system/DB.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/DB.kt
@@ -27,6 +27,14 @@
 import kotlin.math.pow
 
 object DB : Logger {
+    private fun getAbilityFilter(vararg inputFavorModes: Int): String {
+        return "(Hit_Points_Mode = ${Component.DEFAULT_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHER_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHEST_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.FAILED_HIT_POINTS_MODE}) AND (Judgment_Mode = ${Component.DEFAULT_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHER_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHEST_JUDGMENT_MODE}) AND (${
+            inputFavorModes.joinToString(
+                " OR "
+            ) { "Input_Favor_Mode = $it" }
+        }) AND Long_Note_Mode = ${Component.DEFAULT_LONG_NOTE_MODE} AND Note_Modify_Mode = ${Component.DEFAULT_NOTE_MODIFY_MODE}"
+    }
+
     private val pool = BasicDataSource()
     private val yyyyMMFormat = DateTimeFormatter.ofPattern("yyyy-MM").withZone(ZoneId.systemDefault())
     private val yyyyMMDDFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd").withZone(ZoneId.systemDefault())
@@ -499,9 +507,9 @@
             pool.connection.use {
                 it.prepareStatement(
                     """
-                    DELETE
-                    FROM tw_note
-                """.trimIndent()
+                        DELETE
+                        FROM tw_note
+                    """.trimIndent()
                 ).use { dbStatement -> dbStatement.execute() }
             }
         }
@@ -614,17 +622,19 @@
                 }
             }
             Files.newDirectoryStream(TwilightComponent.COMMENT_ENTRY_PATH).use { commentEntryPaths ->
-                commentEntryPaths.map { commentEntryPath ->
-                    Files.list(commentEntryPath).use { commentFilePaths ->
-                        commentFilePaths.map { commentFilePath ->
-                            if (commentIDs.contains(FilenameUtils.removeExtension(commentFilePath.fileName.toString()))) {
-                                null
-                            } else {
-                                commentFilePath
-                            }
-                        }.toList()
-                    }
-                }.flatMap { it.toList() }.filterNotNull()
+                StreamSupport.stream(commentEntryPaths.spliterator(), true).use { parallel ->
+                    parallel.map { commentEntryPath ->
+                        Files.list(commentEntryPath).use { commentFilePaths ->
+                            commentFilePaths.map { commentFilePath ->
+                                if (commentIDs.contains(FilenameUtils.removeExtension(commentFilePath.fileName.toString()))) {
+                                    null
+                                } else {
+                                    commentFilePath
+                                }
+                            }.toList()
+                        }
+                    }.toList().flatten().filterNotNull()
+                }
             }
         }
     }
@@ -646,69 +656,71 @@
         return logFuture {
             pool.connection.use {
                 Files.newDirectoryStream(TwilightComponent.COMMENT_ENTRY_PATH).use { commentEntryPaths ->
-                    commentEntryPaths.forEach { commentEntryPath ->
-                        Files.list(commentEntryPath).use { commentFilePaths ->
-                            commentFilePaths.forEach { commentFilePath ->
-                                try {
-                                    val commentID =
-                                        FilenameUtils.removeExtension(commentFilePath.fileName.toString())
-                                    it.prepareStatement(
-                                        """
+                    StreamSupport.stream(commentEntryPaths.spliterator(), true).use { parallel ->
+                        parallel.forEach { commentEntryPath ->
+                            Files.list(commentEntryPath).use { commentFilePaths ->
+                                commentFilePaths.forEach { commentFilePath ->
+                                    try {
+                                        val commentID =
+                                            FilenameUtils.removeExtension(commentFilePath.fileName.toString())
+                                        it.prepareStatement(
+                                            """
                                             SELECT Audio_Multiplier
                                             FROM tw_comment
                                             WHERE Comment_ID = ?
                                         """.trimIndent()
-                                    ).use { dbStatement ->
-                                        dbStatement.setString(1, commentID)
-                                        dbStatement.executeQuery().use { rows ->
-                                            if (rows.next()) {
-                                                val audioMultiplier = rows.getDouble("Audio_Multiplier")
-                                                val comment =
-                                                    XZCompressorInputStream(
-                                                        Files.readAllBytes(commentFilePath).inputStream()
-                                                    ).use {
-                                                        CommentOuterClass.Comment.parseFrom(it)
-                                                    }
-                                                if (comment.audioMultipliersCount > 0) {
-                                                    it.prepareStatement(
-                                                        """
+                                        ).use { dbStatement ->
+                                            dbStatement.setString(1, commentID)
+                                            dbStatement.executeQuery().use { rows ->
+                                                if (rows.next()) {
+                                                    val audioMultiplier = rows.getDouble("Audio_Multiplier")
+                                                    val comment =
+                                                        XZCompressorInputStream(
+                                                            Files.readAllBytes(commentFilePath).inputStream()
+                                                        ).use {
+                                                            CommentOuterClass.Comment.parseFrom(it)
+                                                        }
+                                                    if (comment.audioMultipliersCount > 0) {
+                                                        it.prepareStatement(
+                                                            """
                                                             UPDATE tw_comment
                                                             SET Lowest_Audio_Multiplier = ?, Highest_Audio_Multiplier = ?
                                                             WHERE Comment_ID = ?
                                                         """.trimIndent()
-                                                    ).use { dbStatement ->
-                                                        dbStatement.setDouble(
-                                                            1,
-                                                            comment.audioMultipliersList.map { it.audioMultiplier }
-                                                                .plus(audioMultiplier).min()
-                                                        )
-                                                        dbStatement.setDouble(
-                                                            2,
-                                                            comment.audioMultipliersList.map { it.audioMultiplier }
-                                                                .plus(audioMultiplier).max()
-                                                        )
-                                                        dbStatement.setString(3, commentID)
-                                                        dbStatement.executeUpdate()
-                                                    }
-                                                } else {
-                                                    it.prepareStatement(
-                                                        """
+                                                        ).use { dbStatement ->
+                                                            dbStatement.setDouble(
+                                                                1,
+                                                                comment.audioMultipliersList.map { it.audioMultiplier }
+                                                                    .plus(audioMultiplier).min()
+                                                            )
+                                                            dbStatement.setDouble(
+                                                                2,
+                                                                comment.audioMultipliersList.map { it.audioMultiplier }
+                                                                    .plus(audioMultiplier).max()
+                                                            )
+                                                            dbStatement.setString(3, commentID)
+                                                            dbStatement.executeUpdate()
+                                                        }
+                                                    } else {
+                                                        it.prepareStatement(
+                                                            """
                                                             UPDATE tw_comment
                                                             SET Lowest_Audio_Multiplier = Audio_Multiplier, Highest_Audio_Multiplier = Audio_Multiplier
                                                             WHERE Comment_ID = ?
                                                         """.trimIndent()
-                                                    ).use { dbStatement ->
-                                                        dbStatement.setString(1, commentID)
-                                                        dbStatement.executeUpdate()
+                                                        ).use { dbStatement ->
+                                                            dbStatement.setString(1, commentID)
+                                                            dbStatement.executeUpdate()
+                                                        }
                                                     }
                                                 }
                                             }
                                         }
+                                    } catch (e: Throwable) {
+                                        logFault(e)
                                     }
-                                } catch (e: Throwable) {
-                                    logFault(e)
+                                    futureLearnCommentsStatus.incrementAndGet()
                                 }
-                                futureLearnCommentsStatus.incrementAndGet()
                             }
                         }
                     }
@@ -717,76 +729,89 @@
         }
     }
 
-    fun learnHandled(futureLearnHandledStatus: AtomicInteger): CompletableFuture<Void> {
-        data class Comment(val avatar: String, val noteID: String, val hitPointsMode: Int, val isP: Boolean)
-
+    fun wipeHandled(): CompletableFuture<Void> {
         return logFuture {
-            val comments = mutableListOf<Comment>()
             pool.connection.use {
                 it.prepareStatement(
                     """
-                        SELECT Avatar, Note_ID, Hit_Points_Mode, Is_P
-                        FROM tw_comment
-                        WHERE Lowest_Audio_Multiplier >= 1.0 AND (Hit_Points_Mode = ${Component.DEFAULT_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHER_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHEST_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.FAILED_HIT_POINTS_MODE}) AND (Judgment_Mode = ${Component.DEFAULT_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHER_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHEST_JUDGMENT_MODE}) AND Long_Note_Mode = ${Component.DEFAULT_LONG_NOTE_MODE} AND Input_Favor_Mode = ${Component.DEFAULT_INPUT_FAVOR_MODE} AND Note_Modify_Mode = ${Component.DEFAULT_NOTE_MODIFY_MODE}
+                        DELETE
+                        FROM tw_handled
                     """.trimIndent()
-                ).use { dbStatement ->
-                    dbStatement.executeQuery().use { rows ->
-                        while (rows.next()) {
-                            comments.add(
-                                Comment(
-                                    rows.getString("Avatar"),
-                                    rows.getString("Note_ID"),
-                                    rows.getInt("Hit_Points_Mode"),
-                                    rows.getBoolean("Is_P")
-                                )
+                ).use { dbStatement -> dbStatement.execute() }
+            }
+        }
+    }
+
+    fun learnHandled(futureLearnHandledStatus: AtomicInteger) {
+        data class Comment(val avatar: String, val noteID: String, val hitPointsMode: Int, val isP: Boolean)
+
+        val comments = mutableListOf<Comment>()
+        pool.connection.use {
+            it.prepareStatement(
+                """
+                    SELECT Avatar, Note_ID, Hit_Points_Mode, Is_P
+                    FROM tw_comment
+                    WHERE Lowest_Audio_Multiplier >= 1.0 AND Auto_Mode = ${Component.AUTOABLE_AUTO_MODE} AND ${
+                    getAbilityFilter(
+                        Component.DEFAULT_INPUT_FAVOR_MODE
+                    )
+                }
+                """.trimIndent()
+            ).use { dbStatement ->
+                dbStatement.executeQuery().use { rows ->
+                    while (rows.next()) {
+                        comments.add(
+                            Comment(
+                                rows.getString("Avatar"),
+                                rows.getString("Note_ID"),
+                                rows.getInt("Hit_Points_Mode"),
+                                rows.getBoolean("Is_P")
                             )
-                        }
+                        )
                     }
                 }
             }
-            StreamSupport.stream(comments.groupBy { Pair(it.avatar, it.noteID) }.toList().spliterator(), true)
-                .use { parallel ->
-                    parallel.forEach { (avatarNoteID, comments) ->
-                        val isP = comments.any { it.isP }
-                        val hitPointsMode = comments.maxBy {
-                            when (it.hitPointsMode) {
-                                Component.HIGHEST_HIT_POINTS_MODE, Component.FAILED_HIT_POINTS_MODE -> 2
-                                Component.HIGHER_HIT_POINTS_MODE -> 1
-                                else -> 0
-                            }
-                        }.hitPointsMode
-                        pool.connection.use {
-                            it.prepareStatement(
-                                """
+        }
+        StreamSupport.stream(comments.groupBy { Pair(it.avatar, it.noteID) }.toList().spliterator(), true)
+            .use { parallel ->
+                parallel.forEach { (avatarNoteID, comments) ->
+                    val isP = comments.any { it.isP }
+                    val hitPointsMode = comments.maxBy {
+                        when (it.hitPointsMode) {
+                            Component.HIGHEST_HIT_POINTS_MODE, Component.FAILED_HIT_POINTS_MODE -> 2
+                            Component.HIGHER_HIT_POINTS_MODE -> 1
+                            else -> 0
+                        }
+                    }.hitPointsMode
+                    pool.connection.use {
+                        it.prepareStatement(
+                            """
                                 REPLACE INTO tw_handled
                                 VALUES(?, ?, ?)
                             """.trimIndent()
-                            ).use { dbStatement ->
-                                dbStatement.setString(1, avatarNoteID.first)
-                                dbStatement.setString(2, avatarNoteID.second)
-                                dbStatement.setInt(
-                                    3, (if (isP) Component.Handled.BAND1 else {
-                                        when (hitPointsMode) {
-                                            Component.HIGHEST_HIT_POINTS_MODE, Component.FAILED_HIT_POINTS_MODE -> Component.Handled.HIGHEST_CLEAR
-                                            Component.HIGHER_HIT_POINTS_MODE -> Component.Handled.HIGHER_CLEAR
-                                            else -> Component.Handled.CLEAR
-                                        }
-                                    }).value
-                                )
-                                dbStatement.execute()
-                            }
+                        ).use { dbStatement ->
+                            dbStatement.setString(1, avatarNoteID.first)
+                            dbStatement.setString(2, avatarNoteID.second)
+                            dbStatement.setInt(
+                                3, (if (isP) Component.Handled.BAND1 else {
+                                    when (hitPointsMode) {
+                                        Component.HIGHEST_HIT_POINTS_MODE, Component.FAILED_HIT_POINTS_MODE -> Component.Handled.HIGHEST_CLEAR
+                                        Component.HIGHER_HIT_POINTS_MODE -> Component.Handled.HIGHER_CLEAR
+                                        else -> Component.Handled.CLEAR
+                                    }
+                                }).value
+                            )
+                            dbStatement.execute()
                         }
-                        futureLearnHandledStatus.incrementAndGet()
                     }
+                    futureLearnHandledStatus.incrementAndGet()
                 }
-        }
+            }
     }
 
     fun getWipeBundles(): CompletableFuture<Collection<Path>> {
         return logValueFuture {
-            data class BundleID(val avatarID: String, val bundleName: String)
-
-            val bundleIDs = mutableSetOf<BundleID>()
+            val bundleIDs = mutableSetOf<Pair<String, String>>()
             pool.connection.use {
                 it.prepareStatement(
                     """
@@ -796,30 +821,33 @@
                 ).use { dbStatement ->
                     dbStatement.executeQuery().use { rows ->
                         while (rows.next()) {
-                            bundleIDs.add(BundleID(rows.getString("Avatar"), rows.getString("Name")))
+                            bundleIDs.add(Pair(rows.getString("Avatar"), rows.getString("Name")))
                         }
                     }
                 }
             }
 
             Files.newDirectoryStream(TwilightComponent.BUNDLE_ENTRY_PATH).use { bundleEntryPaths ->
-                bundleEntryPaths.map { bundleEntryPath ->
-                    Files.list(bundleEntryPath).use { bundleFilePaths ->
-                        bundleFilePaths.map { bundleFilePath ->
-                            if (bundleIDs.contains(
-                                    BundleID(
-                                        bundleEntryPath.fileName.toString(),
-                                        FilenameUtils.removeExtension(bundleFilePath.fileName.toString())
-                                    )
-                                )
-                            ) {
-                                null
-                            } else {
-                                bundleFilePath
+                StreamSupport.stream(bundleEntryPaths.spliterator(), true)
+                    .use { parallel ->
+                        parallel.map { bundleEntryPath ->
+                            Files.list(bundleEntryPath).use { bundleFilePaths ->
+                                bundleFilePaths.map { bundleFilePath ->
+                                    if (bundleIDs.contains(
+                                            Pair(
+                                                bundleEntryPath.fileName.toString(),
+                                                FilenameUtils.removeExtension(bundleFilePath.fileName.toString())
+                                            )
+                                        )
+                                    ) {
+                                        null
+                                    } else {
+                                        bundleFilePath
+                                    }
+                                }.toList()
                             }
-                        }.toList()
-                    }
-                }.flatMap { it.toList() }.filterNotNull()
+                        }
+                    }.toList().flatten().filterNotNull()
             }
         }
     }
@@ -2899,7 +2927,13 @@
                 """
                     SELECT tw_note.Note_ID, Note_Variety, Artist, Title, Genre, Level_Text, tw_note.Level, Stand, Avatar_ID, Avatar_Name, Ability_5K * (POWER(Stand / 1000000, 3) - 0.5 * POWER(Stand / 1000000, 2) + 0.5 * (Stand / 1000000)) AS Value
                     FROM tw_note, tw_comment, tn_avatar
-                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Ability_5K > 0.0 AND (Input_Favor_Mode = ${Component.DEFAULT_INPUT_FAVOR_MODE} OR Input_Favor_Mode = ${Component.MODE_5_INPUT_FAVOR_MODE} OR Input_Favor_Mode = ${Component.MODE_5_1_INPUT_FAVOR_MODE}) AND (Hit_Points_Mode = ${Component.DEFAULT_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHER_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHEST_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.FAILED_HIT_POINTS_MODE}) AND (Judgment_Mode = ${Component.DEFAULT_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHER_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHEST_JUDGMENT_MODE}) AND Is_Max = true
+                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Ability_5K > 0.0 AND ${
+                    getAbilityFilter(
+                        Component.DEFAULT_INPUT_FAVOR_MODE,
+                        Component.MODE_5_INPUT_FAVOR_MODE,
+                        Component.MODE_5_1_INPUT_FAVOR_MODE
+                    )
+                } AND Is_Max = true
                     ORDER BY Value DESC
                 """.trimIndent()
             ).use { dbStatement ->
@@ -2932,7 +2966,13 @@
                 """
                     SELECT Ability_5K * (POWER(Stand / 1000000, 3) - 0.5 * POWER(Stand / 1000000, 2) + 0.5 * (Stand / 1000000)) AS Value
                     FROM tw_note, tw_comment, tn_avatar
-                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Avatar_ID = ? AND Ability_5K > 0.0 AND (Input_Favor_Mode = ${Component.DEFAULT_INPUT_FAVOR_MODE} OR Input_Favor_Mode = ${Component.MODE_5_INPUT_FAVOR_MODE} OR Input_Favor_Mode = ${Component.MODE_5_1_INPUT_FAVOR_MODE}) AND (Hit_Points_Mode = ${Component.DEFAULT_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHER_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHEST_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.FAILED_HIT_POINTS_MODE}) AND (Judgment_Mode = ${Component.DEFAULT_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHER_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHEST_JUDGMENT_MODE}) AND Is_Max = true
+                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Avatar_ID = ? AND Ability_5K > 0.0 AND ${
+                    getAbilityFilter(
+                        Component.DEFAULT_INPUT_FAVOR_MODE,
+                        Component.MODE_5_INPUT_FAVOR_MODE,
+                        Component.MODE_5_1_INPUT_FAVOR_MODE
+                    )
+                } AND Is_Max = true
                     ORDER BY Value DESC
                     LIMIT 50
                 """.trimIndent()
@@ -2956,7 +2996,13 @@
                 """
                     SELECT tw_note.Note_ID, Note_Variety, Artist, Title, Genre, Level_Text, tw_note.Level, Stand, Avatar_ID, Avatar_Name, Ability_7K * (POWER(Stand / 1000000, 3) - 0.5 * POWER(Stand / 1000000, 2) + 0.5 * (Stand / 1000000)) AS Value
                     FROM tw_note, tw_comment, tn_avatar
-                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Ability_7K > 0.0 AND (Input_Favor_Mode = ${Component.DEFAULT_INPUT_FAVOR_MODE} OR Input_Favor_Mode = ${Component.MODE_7_INPUT_FAVOR_MODE} OR Input_Favor_Mode = ${Component.MODE_7_1_INPUT_FAVOR_MODE}) AND (Hit_Points_Mode = ${Component.DEFAULT_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHER_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHEST_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.FAILED_HIT_POINTS_MODE}) AND (Judgment_Mode = ${Component.DEFAULT_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHER_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHEST_JUDGMENT_MODE}) AND Is_Max = true
+                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Ability_7K > 0.0 AND ${
+                    getAbilityFilter(
+                        Component.DEFAULT_INPUT_FAVOR_MODE,
+                        Component.MODE_7_INPUT_FAVOR_MODE,
+                        Component.MODE_7_1_INPUT_FAVOR_MODE
+                    )
+                } AND Is_Max = true
                     ORDER BY Value DESC
                 """.trimIndent()
             ).use { dbStatement ->
@@ -2989,7 +3035,13 @@
                 """
                     SELECT Ability_7K * (POWER(Stand / 1000000, 3) - 0.5 * POWER(Stand / 1000000, 2) + 0.5 * (Stand / 1000000)) AS Value
                     FROM tw_note, tw_comment, tn_avatar
-                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Avatar_ID = ? AND Ability_7K > 0.0 AND (Input_Favor_Mode = ${Component.DEFAULT_INPUT_FAVOR_MODE} OR Input_Favor_Mode = ${Component.MODE_7_INPUT_FAVOR_MODE} OR Input_Favor_Mode = ${Component.MODE_7_1_INPUT_FAVOR_MODE}) AND (Hit_Points_Mode = ${Component.DEFAULT_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHER_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHEST_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.FAILED_HIT_POINTS_MODE}) AND (Judgment_Mode = ${Component.DEFAULT_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHER_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHEST_JUDGMENT_MODE}) AND Is_Max = true
+                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Avatar_ID = ? AND Ability_7K > 0.0 AND ${
+                    getAbilityFilter(
+                        Component.DEFAULT_INPUT_FAVOR_MODE,
+                        Component.MODE_7_INPUT_FAVOR_MODE,
+                        Component.MODE_7_1_INPUT_FAVOR_MODE
+                    )
+                } AND Is_Max = true
                     ORDER BY Value DESC
                     LIMIT 50
                 """.trimIndent()
@@ -3013,7 +3065,12 @@
                 """
                     SELECT tw_note.Note_ID, Note_Variety, Artist, Title, Genre, Level_Text, tw_note.Level, Stand, Avatar_ID, Avatar_Name, Ability_9K * (POWER(Stand / 1000000, 3) - 0.5 * POWER(Stand / 1000000, 2) + 0.5 * (Stand / 1000000)) AS Value
                     FROM tw_note, tw_comment, tn_avatar
-                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Ability_9K > 0.0 AND (Input_Favor_Mode = ${Component.DEFAULT_INPUT_FAVOR_MODE} OR Input_Favor_Mode = ${Component.MODE_9_INPUT_FAVOR_MODE}) AND (Hit_Points_Mode = ${Component.DEFAULT_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHER_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHEST_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.FAILED_HIT_POINTS_MODE}) AND (Judgment_Mode = ${Component.DEFAULT_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHER_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHEST_JUDGMENT_MODE}) AND Is_Max = true
+                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Ability_9K > 0.0 AND ${
+                    getAbilityFilter(
+                        Component.DEFAULT_INPUT_FAVOR_MODE,
+                        Component.MODE_9_INPUT_FAVOR_MODE
+                    )
+                } AND Is_Max = true
                     ORDER BY Value DESC
                 """.trimIndent()
             ).use { dbStatement ->
@@ -3046,7 +3103,12 @@
                 """
                     SELECT Ability_9K * (POWER(Stand / 1000000, 3) - 0.5 * POWER(Stand / 1000000, 2) + 0.5 * (Stand / 1000000)) AS Value
                     FROM tw_note, tw_comment, tn_avatar
-                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Avatar_ID = ? AND Ability_9K > 0.0 AND (Input_Favor_Mode = ${Component.DEFAULT_INPUT_FAVOR_MODE} OR Input_Favor_Mode = ${Component.MODE_9_INPUT_FAVOR_MODE}) AND (Hit_Points_Mode = ${Component.DEFAULT_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHER_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.HIGHEST_HIT_POINTS_MODE} OR Hit_Points_Mode = ${Component.FAILED_HIT_POINTS_MODE}) AND (Judgment_Mode = ${Component.DEFAULT_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHER_JUDGMENT_MODE} OR Judgment_Mode = ${Component.HIGHEST_JUDGMENT_MODE}) AND Is_Max = true
+                    WHERE tw_note.Note_ID = tw_comment.Note_ID AND tw_comment.Avatar = tn_avatar.Avatar_ID AND Avatar_ID = ? AND Ability_9K > 0.0 AND ${
+                    getAbilityFilter(
+                        Component.DEFAULT_INPUT_FAVOR_MODE,
+                        Component.MODE_9_INPUT_FAVOR_MODE
+                    )
+                } AND Is_Max = true
                     ORDER BY Value DESC
                     LIMIT 50
                 """.trimIndent()
diff --git a/src/main/kotlin/net/taehui/twilight/system/IO.kt b/src/main/kotlin/net/taehui/twilight/system/IO.kt
index 385315d..b5b2e58 100644
--- a/src/main/kotlin/net/taehui/twilight/system/IO.kt
+++ b/src/main/kotlin/net/taehui/twilight/system/IO.kt
@@ -263,13 +263,13 @@
                                 when (w[1]) {
                                     "learn" -> {
                                         if (futureLearnHandled?.isDone != false) {
-                                            futureLearnHandled =
-                                                DB.learnHandled(futureLearnHandledStatus).thenAccept {
-                                                    logInfo(
-                                                        "Learned ${futureLearnHandledStatus.get()} Handled"
-                                                    )
-                                                    futureLearnHandledStatus.set(0)
-                                                }
+                                            futureLearnHandled = DB.wipeHandled().thenAccept {
+                                                DB.learnHandled(futureLearnHandledStatus)
+                                                logInfo(
+                                                    "Learned ${futureLearnHandledStatus.get()} Handled"
+                                                )
+                                                futureLearnHandledStatus.set(0)
+                                            }
                                         } else {
                                             logInfo(
                                                 "Learning ${futureLearnHandledStatus.get()} Handled"