diff --git a/.github/workflows/build_push.yml b/.github/workflows/build_push.yml
index 43101393..fce227e8 100644
--- a/.github/workflows/build_push.yml
+++ b/.github/workflows/build_push.yml
@@ -57,7 +57,7 @@ jobs:
       #     ./.github/scripts/bump-versions.py ${{ steps.modified-libs.outputs.all_changed_files }}
 
       - name: Validate Gradle Wrapper
-        uses: gradle/wrapper-validation-action@a494d935f4b56874c4a5a87d19af7afcf3a163d0 # v2
+        uses: gradle/actions/wrapper-validation@v4
 
       - name: Get number of modules
         run: |
diff --git a/lib-multisrc/anilist/build.gradle.kts b/lib-multisrc/anilist/build.gradle.kts
index e2f11e9c..6e70fd15 100644
--- a/lib-multisrc/anilist/build.gradle.kts
+++ b/lib-multisrc/anilist/build.gradle.kts
@@ -2,4 +2,4 @@ plugins {
     id("lib-multisrc")
 }
 
-baseVersionCode = 3
+baseVersionCode = 4
diff --git a/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListFilters.kt b/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListFilters.kt
index 688d64e4..83b7b6dd 100644
--- a/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListFilters.kt
+++ b/lib-multisrc/anilist/src/eu/kanade/tachiyomi/multisrc/anilist/AniListFilters.kt
@@ -110,6 +110,8 @@ object AniListFilters {
 
         val YEAR_LIST = arrayOf(
             Pair("<Select>", ""),
+            Pair("2026", "2026"),
+            Pair("2025", "2025"),
             Pair("2024", "2024"),
             Pair("2023", "2023"),
             Pair("2022", "2022"),
diff --git a/lib-multisrc/dooplay/build.gradle.kts b/lib-multisrc/dooplay/build.gradle.kts
index 9dce2478..e2f11e9c 100644
--- a/lib-multisrc/dooplay/build.gradle.kts
+++ b/lib-multisrc/dooplay/build.gradle.kts
@@ -2,4 +2,4 @@ plugins {
     id("lib-multisrc")
 }
 
-baseVersionCode = 2
+baseVersionCode = 3
diff --git a/lib-multisrc/dooplay/src/eu/kanade/tachiyomi/multisrc/dooplay/DooPlay.kt b/lib-multisrc/dooplay/src/eu/kanade/tachiyomi/multisrc/dooplay/DooPlay.kt
index 7756075c..f15f184e 100644
--- a/lib-multisrc/dooplay/src/eu/kanade/tachiyomi/multisrc/dooplay/DooPlay.kt
+++ b/lib-multisrc/dooplay/src/eu/kanade/tachiyomi/multisrc/dooplay/DooPlay.kt
@@ -49,13 +49,13 @@ abstract class DooPlay(
         const val PREFIX_SEARCH = "path:"
     }
 
-    protected open val prefQualityDefault = "720p"
+    protected open val prefQualityDefault = "1080p"
     protected open val prefQualityKey = "preferred_quality"
     protected open val prefQualityTitle = when (lang) {
         "pt-BR" -> "Qualidade preferida"
         else -> "Preferred quality"
     }
-    protected open val prefQualityValues = arrayOf("480p", "720p")
+    protected open val prefQualityValues = arrayOf("360p", "480p", "720p", "1080p")
     protected open val prefQualityEntries = prefQualityValues
 
     protected open val videoSortPrefKey = prefQualityKey
diff --git a/lib-multisrc/zorotheme/build.gradle.kts b/lib-multisrc/zorotheme/build.gradle.kts
index c963594a..04988524 100644
--- a/lib-multisrc/zorotheme/build.gradle.kts
+++ b/lib-multisrc/zorotheme/build.gradle.kts
@@ -2,7 +2,7 @@ plugins {
     id("lib-multisrc")
 }
 
-baseVersionCode = 4
+baseVersionCode = 6
 
 dependencies {
     api(project(":lib:megacloud-extractor"))
diff --git a/lib-multisrc/zorotheme/src/eu/kanade/tachiyomi/multisrc/zorotheme/ZoroThemeFilters.kt b/lib-multisrc/zorotheme/src/eu/kanade/tachiyomi/multisrc/zorotheme/ZoroThemeFilters.kt
index 07dd3b22..46fd4e29 100644
--- a/lib-multisrc/zorotheme/src/eu/kanade/tachiyomi/multisrc/zorotheme/ZoroThemeFilters.kt
+++ b/lib-multisrc/zorotheme/src/eu/kanade/tachiyomi/multisrc/zorotheme/ZoroThemeFilters.kt
@@ -183,7 +183,7 @@ object ZoroThemeFilters {
             Pair("Most Watched", "most_watched"),
         )
 
-        val YEARS = arrayOf(ALL) + (1917..2024).map {
+        val YEARS = arrayOf(ALL) + (1917..2025).map {
             Pair(it.toString(), it.toString())
         }.reversed().toTypedArray()
 
diff --git a/lib/buzzheavier-extractor/build.gradle.kts b/lib/buzzheavier-extractor/build.gradle.kts
new file mode 100644
index 00000000..c26cbc8a
--- /dev/null
+++ b/lib/buzzheavier-extractor/build.gradle.kts
@@ -0,0 +1,3 @@
+plugins {
+    id("lib-android")
+}
diff --git a/lib/buzzheavier-extractor/src/main/java/eu/kanade/tachiyomi/lib/buzzheavierextractor/BuzzheavierExtractor.kt b/lib/buzzheavier-extractor/src/main/java/eu/kanade/tachiyomi/lib/buzzheavierextractor/BuzzheavierExtractor.kt
new file mode 100644
index 00000000..f03661f6
--- /dev/null
+++ b/lib/buzzheavier-extractor/src/main/java/eu/kanade/tachiyomi/lib/buzzheavierextractor/BuzzheavierExtractor.kt
@@ -0,0 +1,82 @@
+package eu.kanade.tachiyomi.lib.buzzheavierextractor
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parseAs
+import java.io.IOException
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.Serializable
+import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+
+class BuzzheavierExtractor(
+    private val client: OkHttpClient,
+    private val headers: Headers,
+) {
+
+    companion object {
+        private val SIZE_REGEX = Regex("""Size\s*-\s*([0-9.]+\s*[GMK]B)""")
+    }
+
+    @OptIn(ExperimentalSerializationApi::class)
+    fun videosFromUrl(url: String, prefix: String = "Buzzheavier - ", proxyUrl: String? = null): List<Video> {
+        val httpUrl = url.toHttpUrl()
+        val id = httpUrl.pathSegments.first()
+
+        val dlHeaders = headers.newBuilder().apply {
+            add("Accept", "*/*")
+            add("HX-Current-URL", url)
+            add("HX-Request", "true")
+            add("Priority", "u=1, i")
+            add("Referer", url)
+        }.build()
+
+        val videoHeaders = headers.newBuilder().apply {
+            add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7")
+            add("Priority", "u=0, i")
+            add("Referer", url)
+        }.build()
+
+        val siteRequest = client.newCall(GET(url)).execute()
+        val parsedHtml = siteRequest.asJsoup()
+        val detailsText = parsedHtml.selectFirst("li:contains(Details:)")?.text() ?: ""
+        val size = SIZE_REGEX.find(detailsText)?.groupValues?.getOrNull(1)?.trim() ?: "Unknown"
+
+        val downloadRequest = GET("https://${httpUrl.host}/$id/download", dlHeaders)
+        val path = client.executeWithRetry(downloadRequest, 5, 204).use { response ->
+            response.header("hx-redirect").orEmpty()
+        }
+
+        val videoUrl = if (path.isNotEmpty()) {
+            if (path.startsWith("http")) path else "https://${httpUrl.host}$path"
+        } else if (proxyUrl?.isNotEmpty() == true) {
+            client.executeWithRetry(GET(proxyUrl + id), 5, 200).parseAs<UrlDto>().url
+        } else {
+            return emptyList()
+        }
+
+        return listOf(Video(videoUrl, "${prefix}${size}", videoUrl, videoHeaders))
+    }
+
+    private fun OkHttpClient.executeWithRetry(request: Request, maxRetries: Int, validCode: Int): Response {
+        var response: Response? = null
+        for (attempt in 0 until maxRetries) {
+            response?.close()
+            response = this.newCall(request).execute()
+            if (response.code == validCode) {
+                return response
+            }
+            if (attempt < maxRetries - 1) {
+                Thread.sleep(1000)
+            }
+        }
+        return response ?: throw IOException("Failed to execute request after $maxRetries attempts")
+    }
+
+    @Serializable
+    data class UrlDto(val url: String)
+}
diff --git a/lib/chillx-extractor/src/main/java/eu/kanade/tachiyomi/lib/chillxextractor/ChillxExtractor.kt b/lib/chillx-extractor/src/main/java/eu/kanade/tachiyomi/lib/chillxextractor/ChillxExtractor.kt
index 747db057..d05720e0 100644
--- a/lib/chillx-extractor/src/main/java/eu/kanade/tachiyomi/lib/chillxextractor/ChillxExtractor.kt
+++ b/lib/chillx-extractor/src/main/java/eu/kanade/tachiyomi/lib/chillxextractor/ChillxExtractor.kt
@@ -1,73 +1,54 @@
 package eu.kanade.tachiyomi.lib.chillxextractor
 
-import android.util.Log
 import eu.kanade.tachiyomi.animesource.model.Track
 import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.lib.cryptoaes.CryptoAES
 import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.parseAs
-import kotlinx.serialization.ExperimentalSerializationApi
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.json.Json
 import okhttp3.Headers
 import okhttp3.OkHttpClient
-import uy.kohesive.injekt.injectLazy
 
 class ChillxExtractor(private val client: OkHttpClient, private val headers: Headers) {
-    private val json: Json by injectLazy()
     private val playlistUtils by lazy { PlaylistUtils(client, headers) }
+    private val webViewResolver by lazy { WebViewResolver(client, headers) }
 
     companion object {
-        private val REGEX_MASTER_JS = Regex("""\s*=\s*'([^']+)""")
         private val REGEX_SOURCES = Regex("""sources:\s*\[\{"file":"([^"]+)""")
         private val REGEX_FILE = Regex("""file: ?"([^"]+)"""")
         private val REGEX_SOURCE = Regex("""source = ?"([^"]+)"""")
         private val REGEX_SUBS = Regex("""\{"file":"([^"]+)","label":"([^"]+)","kind":"captions","default":\w+\}""")
-        private const val KEY_SOURCE = "https://raw.githubusercontent.com/Rowdy-Avocado/multi-keys/keys/index.html"
     }
 
-    fun videoFromUrl(url: String, referer: String, prefix: String = "Chillx - "): List<Video> {
-        val newHeaders = headers.newBuilder()
-            .set("Referer", "$referer/")
-            .set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8")
-            .set("Accept-Language", "en-US,en;q=0.5")
-            .build()
+    fun videoFromUrl(url: String, prefix: String = "Chillx - "): List<Video> {
+        val data = webViewResolver.getDecryptedData(url) ?: return emptyList()
 
-        val body = client.newCall(GET(url, newHeaders)).execute().body.string()
-
-        val master = REGEX_MASTER_JS.find(body)?.groupValues?.get(1) ?: return emptyList()
-        val aesJson = json.decodeFromString<CryptoInfo>(master)
-        val key = fetchKey() ?: throw ErrorLoadingException("Unable to get key")
-        val decryptedScript = CryptoAES.decryptWithSalt(aesJson.ciphertext, aesJson.salt, key)
-            .replace("\\n", "\n")
-            .replace("\\", "")
-
-        val masterUrl = REGEX_SOURCES.find(decryptedScript)?.groupValues?.get(1)
-            ?: REGEX_FILE.find(decryptedScript)?.groupValues?.get(1)
-            ?: REGEX_SOURCE.find(decryptedScript)?.groupValues?.get(1)
+        val masterUrl = REGEX_SOURCES.find(data)?.groupValues?.get(1)
+            ?: REGEX_FILE.find(data)?.groupValues?.get(1)
+            ?: REGEX_SOURCE.find(data)?.groupValues?.get(1)
             ?: return emptyList()
 
         val subtitleList = buildList {
-            val subtitles = REGEX_SUBS.findAll(decryptedScript)
+            val subtitles = REGEX_SUBS.findAll(data)
             subtitles.forEach {
-                Log.d("ChillxExtractor", "Found subtitle: ${it.groupValues}")
                 add(Track(it.groupValues[1], decodeUnicodeEscape(it.groupValues[2])))
             }
         }
 
-        return playlistUtils.extractFromHls(
+        val videoList = playlistUtils.extractFromHls(
             playlistUrl = masterUrl,
             referer = url,
             videoNameGen = { "$prefix$it" },
             subtitleList = subtitleList,
         )
-    }
 
-    @OptIn(ExperimentalSerializationApi::class)
-    private fun fetchKey(): String? {
-        return client.newCall(GET(KEY_SOURCE)).execute().parseAs<KeysData>().keys.firstOrNull()
+        return videoList.map {
+            Video(
+                url = it.url,
+                quality = it.quality,
+                videoUrl = it.videoUrl,
+                headers = it.headers,
+                audioTracks = it.audioTracks,
+                subtitleTracks = playlistUtils.fixSubtitles(it.subtitleTracks),
+            )
+        }
     }
 
     private fun decodeUnicodeEscape(input: String): String {
@@ -76,16 +57,4 @@ class ChillxExtractor(private val client: OkHttpClient, private val headers: Hea
             it.groupValues[1].toInt(16).toChar().toString()
         }
     }
-
-    @Serializable
-    data class CryptoInfo(
-        @SerialName("ct") val ciphertext: String,
-        @SerialName("s") val salt: String,
-    )
-
-    @Serializable
-    data class KeysData(
-        @SerialName("chillx") val keys: List<String>
-    )
 }
-class ErrorLoadingException(message: String) : Exception(message)
diff --git a/lib/chillx-extractor/src/main/java/eu/kanade/tachiyomi/lib/chillxextractor/WebViewResolver.kt b/lib/chillx-extractor/src/main/java/eu/kanade/tachiyomi/lib/chillxextractor/WebViewResolver.kt
new file mode 100644
index 00000000..1b647f96
--- /dev/null
+++ b/lib/chillx-extractor/src/main/java/eu/kanade/tachiyomi/lib/chillxextractor/WebViewResolver.kt
@@ -0,0 +1,125 @@
+package eu.kanade.tachiyomi.lib.chillxextractor
+
+import android.annotation.SuppressLint
+import android.app.Application
+import android.os.Handler
+import android.os.Looper
+import android.webkit.JavascriptInterface
+import android.webkit.WebResourceRequest
+import android.webkit.WebResourceResponse
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.Headers
+import okhttp3.OkHttpClient
+import uy.kohesive.injekt.injectLazy
+import java.io.ByteArrayInputStream
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+
+class WebViewResolver(
+    private val client: OkHttpClient,
+    private val globalHeaders: Headers,
+) {
+    private val context: Application by injectLazy()
+    private val handler by lazy { Handler(Looper.getMainLooper()) }
+
+    class JsInterface(private val latch: CountDownLatch) {
+        var result: String? = null
+
+        @JavascriptInterface
+        fun passPayload(payload: String) {
+            result = payload
+            latch.countDown()
+        }
+    }
+
+    @SuppressLint("SetJavaScriptEnabled")
+    fun getDecryptedData(embedUrl: String): String? {
+        val latch = CountDownLatch(1)
+        var webView: WebView? = null
+        val jsi = JsInterface(latch)
+        val interfaceName = randomString()
+
+        handler.post {
+            val webview = WebView(context)
+            webView = webview
+
+            with(webview.settings) {
+                javaScriptEnabled = true
+                domStorageEnabled = true
+                databaseEnabled = true
+                useWideViewPort = false
+                loadWithOverviewMode = false
+                userAgentString = globalHeaders["User-Agent"]
+            }
+
+            webview.addJavascriptInterface(jsi, interfaceName)
+            webview.webViewClient = object : WebViewClient() {
+                override fun shouldInterceptRequest(
+                    view: WebView?,
+                    request: WebResourceRequest?
+                ): WebResourceResponse? {
+                    if (request?.url.toString().equals(embedUrl, true)) {
+                        return patchBody(request!!.url.toString(), interfaceName)
+                            ?: super.shouldInterceptRequest(view, request)
+                    }
+
+                    return super.shouldInterceptRequest(view, request)
+                }
+            }
+
+            webView?.loadUrl(embedUrl)
+        }
+
+        latch.await(TIMEOUT_SEC, TimeUnit.SECONDS)
+
+        handler.post {
+            webView?.stopLoading()
+            webView?.destroy()
+            webView = null
+        }
+
+        return jsi.result
+    }
+
+    companion object {
+        const val TIMEOUT_SEC: Long = 30
+    }
+
+    private fun randomString(length: Int = 10): String {
+        val charPool = ('a'..'z') + ('A'..'Z')
+        return List(length) { charPool.random() }.joinToString("")
+    }
+
+    private fun patchBody(url: String, interfaceName: String): WebResourceResponse? {
+        val html = client.newCall(GET(url, globalHeaders)).execute().asJsoup()
+
+        val oldFunc = randomString()
+        val script = html.createElement("script").apply {
+            appendText(
+                """
+                    const $oldFunc = Function;
+                    window.Function = function (...args) {
+                      if (args.length == 1) {
+                        window.$interfaceName.passPayload(args[0]);
+                      }
+                      return $oldFunc(...args);
+                    };
+                """.trimIndent()
+            )
+        }
+
+        html.body().insertChildren(0, script)
+
+        return WebResourceResponse(
+            "text/html",
+            "utf-8",
+            200,
+            "ok",
+            mapOf("server" to "cloudflare"),
+            ByteArrayInputStream(html.outerHtml().toByteArray()),
+        )
+    }
+}
diff --git a/lib/filemoon-extractor/src/main/java/eu/kanade/tachiyomi/lib/filemoonextractor/FilemoonExtractor.kt b/lib/filemoon-extractor/src/main/java/eu/kanade/tachiyomi/lib/filemoonextractor/FilemoonExtractor.kt
index 567bf3bb..70250a71 100644
--- a/lib/filemoon-extractor/src/main/java/eu/kanade/tachiyomi/lib/filemoonextractor/FilemoonExtractor.kt
+++ b/lib/filemoon-extractor/src/main/java/eu/kanade/tachiyomi/lib/filemoonextractor/FilemoonExtractor.kt
@@ -1,5 +1,8 @@
 package eu.kanade.tachiyomi.lib.filemoonextractor
 
+import android.content.SharedPreferences
+import androidx.preference.EditTextPreference
+import androidx.preference.PreferenceScreen
 import dev.datlag.jsunpacker.JsUnpacker
 import eu.kanade.tachiyomi.animesource.model.Track
 import eu.kanade.tachiyomi.animesource.model.Video
@@ -13,20 +16,28 @@ import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.OkHttpClient
 import uy.kohesive.injekt.injectLazy
 
-class FilemoonExtractor(private val client: OkHttpClient) {
+class FilemoonExtractor(
+    private val client: OkHttpClient,
+    private val preferences: SharedPreferences? = null,
+) {
 
     private val playlistUtils by lazy { PlaylistUtils(client) }
     private val json: Json by injectLazy()
 
     fun videosFromUrl(url: String, prefix: String = "Filemoon - ", headers: Headers? = null): List<Video> {
-        val httpUrl = url.toHttpUrl()
+        var httpUrl = url.toHttpUrl()
         val videoHeaders = (headers?.newBuilder() ?: Headers.Builder())
             .set("Referer", url)
             .set("Origin", "https://${httpUrl.host}")
             .build()
 
         val doc = client.newCall(GET(url, videoHeaders)).execute().asJsoup()
-        val jsEval = doc.selectFirst("script:containsData(eval):containsData(m3u8)")!!.data()
+        val jsEval = doc.selectFirst("script:containsData(eval):containsData(m3u8)")?.data() ?: run {
+            val iframeUrl = doc.selectFirst("iframe[src]")!!.attr("src")
+            httpUrl = iframeUrl.toHttpUrl()
+            val iframeDoc = client.newCall(GET(iframeUrl, videoHeaders)).execute().asJsoup()
+            iframeDoc.selectFirst("script:containsData(eval):containsData(m3u8)")!!.data()
+        }
         val unpacked = JsUnpacker.unpackAndCombine(jsEval).orEmpty()
         val masterUrl = unpacked.takeIf(String::isNotBlank)
             ?.substringAfter("{file:\"", "")
@@ -50,14 +61,39 @@ class FilemoonExtractor(private val client: OkHttpClient) {
             }
         }
 
-        return playlistUtils.extractFromHls(
+        val videoList = playlistUtils.extractFromHls(
             masterUrl,
             subtitleList = subtitleTracks,
             referer = "https://${httpUrl.host}/",
             videoNameGen = { "$prefix$it" },
         )
+
+        val subPref = preferences?.getString(PREF_SUBTITLE_KEY, PREF_SUBTITLE_DEFAULT).orEmpty()
+        return videoList.map {
+            Video(
+                url = it.url,
+                quality = it.quality,
+                videoUrl = it.videoUrl,
+                audioTracks = it.audioTracks,
+                subtitleTracks = it.subtitleTracks.filter { tracks -> tracks.lang.contains(subPref, true) }
+            )
+        }
     }
 
     @Serializable
     data class SubtitleDto(val file: String, val label: String)
+
+    companion object {
+        fun addSubtitlePref(screen: PreferenceScreen) {
+            EditTextPreference(screen.context).apply {
+                key = PREF_SUBTITLE_KEY
+                title = "Filemoon subtitle preference"
+                summary = "Leave blank to use all subs"
+                setDefaultValue(PREF_SUBTITLE_DEFAULT)
+            }.also(screen::addPreference)
+        }
+
+        private const val PREF_SUBTITLE_KEY = "pref_filemoon_sub_lang_key"
+        private const val PREF_SUBTITLE_DEFAULT = "eng"
+    }
 }
diff --git a/lib/lulu-extractor/src/main/java/eu/kanade/tachiyomi/lib/luluextractor/LuluExtractor.kt b/lib/lulu-extractor/src/main/java/eu/kanade/tachiyomi/lib/luluextractor/LuluExtractor.kt
index afcd99bc..550ddae9 100644
--- a/lib/lulu-extractor/src/main/java/eu/kanade/tachiyomi/lib/luluextractor/LuluExtractor.kt
+++ b/lib/lulu-extractor/src/main/java/eu/kanade/tachiyomi/lib/luluextractor/LuluExtractor.kt
@@ -3,16 +3,18 @@ package eu.kanade.tachiyomi.lib.luluextractor
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.network.GET
 import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.OkHttpClient
 import java.util.regex.Pattern
 
-class LuluExtractor(private val client: OkHttpClient) {
+class LuluExtractor(private val client: OkHttpClient, headers: Headers) {
 
-    private val headers = Headers.Builder()
-        .add("Referer", "https://luluvdo.com")
+    private val headers = headers.newBuilder()
+        .add("Referer", "https://luluvdo.com/")
         .add("Origin", "https://luluvdo.com")
         .build()
 
+    //Credit: https://github.com/skoruppa/docchi-stremio-addon/blob/main/app/players/lulustream.py
     fun videosFromUrl(url: String, prefix: String): List<Video> {
         val videos = mutableListOf<Video>()
 
@@ -22,7 +24,7 @@ class LuluExtractor(private val client: OkHttpClient) {
             val fixedUrl = fixM3u8Link(m3u8Url)
             val quality = getResolution(fixedUrl)
 
-            videos.add(Video(fixedUrl, "${prefix}Lulu - $quality", fixedUrl))
+            videos.add(Video(fixedUrl, "${prefix}Lulu - $quality", fixedUrl, headers))
         } catch (e: Exception) {
             e.printStackTrace()
         }
@@ -50,34 +52,41 @@ class LuluExtractor(private val client: OkHttpClient) {
 
     private fun fixM3u8Link(link: String): String {
         val paramOrder = listOf("t", "s", "e", "f")
-        val baseUrl = link.split("?").first()
-        val params = link.split("?").getOrNull(1)?.split("&") ?: emptyList()
+        val params = Pattern.compile("[?&]([^=]*)=([^&]*)").matcher(link).let { matcher ->
+            generateSequence { if (matcher.find()) matcher.group(1) to matcher.group(2) else null }.toList()
+        }
 
-        val paramMap = mutableMapOf<String, String>()
-        val extraParams = mutableMapOf(
-            "i" to "0.3",
-            "sp" to "0"
-        )
+        val paramDict = mutableMapOf<String, String>()
+        val extraParams = mutableMapOf<String, String>()
 
-        params.forEachIndexed { index, param ->
-            val parts = param.split("=")
-            when {
-                parts.size == 2 -> {
-                    val (key, value) = parts
-                    if (key in paramOrder) paramMap[key] = value
-                    else extraParams[key] = value
+        params.forEachIndexed { index, (key , value) ->
+            if (key.isNullOrEmpty()) {
+                if (index < paramOrder.size) {
+                    if (value != null) {
+                        paramDict[paramOrder[index]] = value
+                    }
+                }
+            } else {
+                if (value != null) {
+                    extraParams[key] = value
                 }
-                index < paramOrder.size -> paramMap[paramOrder[index]] = parts.firstOrNull() ?: ""
             }
         }
 
-        return buildString {
-            append(baseUrl)
-            append("?")
-            append(paramOrder.joinToString("&") { "$it=${paramMap[it]}" })
-            append("&")
-            append(extraParams.map { "${it.key}=${it.value}" }.joinToString("&"))
+        extraParams["i"] = "0.3"
+        extraParams["sp"] = "0"
+
+        val baseUrl = link.split("?")[0]
+
+        val fixedLink = baseUrl.toHttpUrl().newBuilder()
+        paramOrder.filter { paramDict.containsKey(it) }.forEach { key ->
+            fixedLink.addQueryParameter(key, paramDict[key])
         }
+        extraParams.forEach { (key, value) ->
+            fixedLink.addQueryParameter(key, value)
+        }
+
+        return fixedLink.build().toString()
     }
 
     private fun getResolution(m3u8Url: String): String {
@@ -98,11 +107,10 @@ class LuluExtractor(private val client: OkHttpClient) {
 }
 
 object JavaScriptUnpacker {
-    private val UNPACK_REGEX = Regex(
-        """}\('(.*)', *(\d+), *(\d+), *'(.*?)'\.split\('\|'\)""",
-        RegexOption.DOT_MATCHES_ALL
-    )
-
+    private val UNPACK_REGEX by lazy {
+        Regex("""\}\('(.*)', *(\d+), *(\d+), *'(.*?)'\.split\('\|'\)""",
+            RegexOption.DOT_MATCHES_ALL)
+    }
     fun unpack(encodedJs: String): String? {
         val match = UNPACK_REGEX.find(encodedJs) ?: return null
         val (payload, radixStr, countStr, symtabStr) = match.destructured
@@ -121,8 +129,8 @@ object JavaScriptUnpacker {
         return Regex("""\b\w+\b""").replace(payload) { mr ->
             symtab.getOrNull(unbase(mr.value, radix, baseDict)) ?: mr.value
         }.replace("\\", "")
-    }
 
+    }
     private fun unbase(value: String, radix: Int, dict: Map<Char, Int>): Int {
         var result = 0
         var multiplier = 1
diff --git a/lib/lycoris-extractor/src/main/java/eu/kanade/tachiyomi/lib/lycorisextractor/LycorisExtractor.kt b/lib/lycoris-extractor/src/main/java/eu/kanade/tachiyomi/lib/lycorisextractor/LycorisExtractor.kt
index 57b47590..0b2430d4 100644
--- a/lib/lycoris-extractor/src/main/java/eu/kanade/tachiyomi/lib/lycorisextractor/LycorisExtractor.kt
+++ b/lib/lycoris-extractor/src/main/java/eu/kanade/tachiyomi/lib/lycorisextractor/LycorisExtractor.kt
@@ -4,13 +4,12 @@ import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.network.GET
 import android.util.Base64
 import eu.kanade.tachiyomi.util.asJsoup
-import kotlinx.serialization.json.Json
+import eu.kanade.tachiyomi.util.parseAs
 import kotlinx.serialization.Serializable
 import okhttp3.Headers
 import okhttp3.HttpUrl
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.OkHttpClient
-import uy.kohesive.injekt.injectLazy
 import java.nio.charset.Charset
 
 class LycorisCafeExtractor(private val client: OkHttpClient) {
@@ -19,7 +18,15 @@ class LycorisCafeExtractor(private val client: OkHttpClient) {
 
     private val GETLNKURL = "https://www.lycoris.cafe/api/watch/getLink"
 
-    private val json: Json by injectLazy()
+    private val wordsRegex by lazy {
+        Regex(
+        """\\U([0-9a-fA-F]{8})|""" +     // \UXXXXXXXX
+            """\\u([0-9a-fA-F]{4})|""" +     // \uXXXX
+            """\\x([0-9a-fA-F]{2})|""" +     // \xHH
+            """\\([0-7]{1,3})|""" +          // \OOO (octal)
+            """\\([btnfr"'$\\])"""         // \n, \t, itd.
+        )
+    }
 
     // Credit: https://github.com/skoruppa/docchi-stremio-addon/blob/main/app/players/lycoris.py
     fun getVideosFromUrl(url: String, headers: Headers, prefix: String): List<Video> {
@@ -33,72 +40,63 @@ class LycorisCafeExtractor(private val client: OkHttpClient) {
             GET(url, headers = embedHeaders),
         ).execute().asJsoup()
 
-        val scripts = document.select("script")
+        val script = document.selectFirst("script[type='application/json']")?.data() ?: return emptyList()
 
-        val episodeDataPattern = Regex("episodeInfo\\s*:\\s*(\\{.*?\\}),", RegexOption.DOT_MATCHES_ALL)
-        var episodeData: String? = null
+        val scriptData = script.parseAs<ScriptBody>()
 
-        for (script in scripts) {
-            val content = script.data()
-            val match = episodeDataPattern.find(content)
+        val data = scriptData.body.parseAs<ScriptEpisode>()
 
-            if (match != null) {
-                episodeData = match.groupValues[1]
-                break
-            }
+        val linkList = data.episodeInfo.id?.let {
+            fetchAndDecodeVideo(client, data.episodeInfo.id.toString(), isSecondary = false)
         }
 
-        val result = mutableMapOf<String, String?>()
-
-        val patterns = listOf(
-            "id" to Regex("id\\s*:\\s*(\\d+)"),
-            "FHD" to Regex("FHD\\s*:\\s*\"([^\"]+)\""),
-            "HD" to Regex("HD\\s*:\\s*\"([^\"]+)\""),
-            "SD" to Regex("SD\\s*:\\s*\"([^\"]+)\"")
-        )
-
-        patterns.forEach { (key, pattern) ->
-            result[key] = episodeData?.let { pattern.find(it)?.groups?.get(1)?.value }
+        val fhdLink = data.episodeInfo.FHD?.let {
+            fetchAndDecodeVideo(client, data.episodeInfo.FHD, isSecondary = true)
+        }
+        val sdLink = data.episodeInfo.SD?.let {
+            fetchAndDecodeVideo(client, data.episodeInfo.SD, isSecondary = true)
+        }
+        val hdLink = data.episodeInfo.HD?.let {
+            fetchAndDecodeVideo(client, data.episodeInfo.HD, isSecondary = true)
         }
-
-        var linkList: String? = fetchAndDecodeVideo(client, result["id"].toString(), isSecondary = false).toString()
-
-        val fhdLink = fetchAndDecodeVideo(client, result["FHD"].toString(), isSecondary = true).toString()
-        val sdLink = fetchAndDecodeVideo(client, result["SD"].toString(), isSecondary = true).toString()
-        val hdLink = fetchAndDecodeVideo(client, result["HD"].toString(), isSecondary = true).toString()
-
 
         if (linkList.isNullOrBlank() || linkList == "{}") {
-            if (fhdLink.isNotEmpty()) {
+            if (!fhdLink.isNullOrBlank()) {
                 videos.add(Video(fhdLink, "${prefix}lycoris.cafe - 1080p", fhdLink))
             }
-            if (hdLink.isNotEmpty()) {
+            if (!hdLink.isNullOrBlank()) {
                 videos.add(Video(hdLink, "${prefix}lycoris.cafe - 720p", hdLink))
             }
-            if (sdLink.isNotEmpty()) {
+            if (!sdLink.isNullOrBlank()) {
                 videos.add(Video(sdLink, "${prefix}lycoris.cafe - 480p", sdLink))
             }
-        }else {
-            val videoLinks = Json.decodeFromString<VideoLinks>(linkList)
+        } else {
+            val videoLinks = linkList.parseAs<VideoLinksApi>()
 
             videoLinks.FHD?.takeIf { checkLinks(client, it) }?.let {
                 videos.add(Video(it, "${prefix}lycoris.cafe - 1080p", it))
-            }?: videos.add(Video(fhdLink, "${prefix}lycoris.cafe - 1080p", fhdLink))
+            } ?: fhdLink?.takeIf { checkLinks(client, it) }?.let {
+                videos.add(Video(it, "${prefix}lycoris.cafe - 1080p", it))
+            }
 
             videoLinks.HD?.takeIf { checkLinks(client, it) }?.let {
                 videos.add(Video(it, "${prefix}lycoris.cafe - 720p", it))
-            }?: videos.add(Video(hdLink, "${prefix}lycoris.cafe - 720p", hdLink))
+            } ?: hdLink?.takeIf { checkLinks(client, it) }?.let {
+                videos.add(Video(it, "${prefix}lycoris.cafe - 720p", it))
+            }
 
             videoLinks.SD?.takeIf { checkLinks(client, it) }?.let {
                 videos.add(Video(it, "${prefix}lycoris.cafe - 480p", it))
-            }?: videos.add(Video(sdLink, "${prefix}lycoris.cafe - 480p", sdLink))
+            } ?: sdLink?.takeIf { checkLinks(client, it) }?.let {
+                videos.add(Video(it, "${prefix}lycoris.cafe - 480p", it))
+            }
         }
         return videos
 
     }
 
-    private fun decodeVideoLinks(encodedUrl: String?): Any? {
-        if (encodedUrl.isNullOrEmpty()) {
+    private fun decodeVideoLinks(encodedUrl: String): String? {
+        if (encodedUrl.isBlank()) {
             return null
         }
 
@@ -121,31 +119,33 @@ class LycorisCafeExtractor(private val client: OkHttpClient) {
         }
     }
 
-    private fun fetchAndDecodeVideo(client: OkHttpClient, episodeId: String, isSecondary: Boolean = false): Any? {
-            val url: HttpUrl
+    private fun fetchAndDecodeVideo(client: OkHttpClient, episodeId: String, isSecondary: Boolean = false): String? {
+        val url: HttpUrl
 
-            if (isSecondary) {
-                val convertedText = episodeId.toByteArray(Charset.forName("UTF-8")).toString(Charset.forName("ISO-8859-1"))
-                val unicodeEscape = decodePythonEscape(convertedText)
-                val finalText = unicodeEscape.toByteArray(Charsets.ISO_8859_1).toString(Charsets.UTF_8)
+        if (isSecondary) {
+            val convertedText = episodeId.toByteArray(Charset.forName("UTF-8")).toString(Charset.forName("ISO-8859-1"))
+            val unicodeEscape = decodePythonEscape(convertedText)
+            val finalText = unicodeEscape.toByteArray(Charsets.ISO_8859_1).toString(Charsets.UTF_8)
 
-                url = GETLNKURL.toHttpUrl().newBuilder()
-                    ?.addQueryParameter("link", finalText)
-                    ?.build() ?: throw IllegalStateException("Invalid URL")
-            } else {
-                url = GETSECONDARYURL.toHttpUrl().newBuilder()
-                    ?.addQueryParameter("id", episodeId)
-                    ?.build() ?: throw IllegalStateException("Invalid URL")
+            url = GETLNKURL.toHttpUrl().newBuilder()
+                .addQueryParameter("link", finalText)
+                .build()
+        } else {
+            url = GETSECONDARYURL.toHttpUrl().newBuilder()
+                .addQueryParameter("id", episodeId)
+                .build()
+        }
+        client.newCall(GET(url))
+            .execute()
+            .use { response ->
+                val data = response.body.string()
+                return decodeVideoLinks(data)
             }
-            client.newCall(GET(url))
-                .execute()
-                .use { response ->
-                    val data = response.body.string() ?: ""
-                    return decodeVideoLinks(data)
-                }
     }
 
     private fun checkLinks(client: OkHttpClient, link: String): Boolean {
+        if (!link.contains("https://")) return false
+
         client.newCall(GET(link)).execute().use { response ->
             return response.code.toString() == "200"
         }
@@ -155,16 +155,7 @@ class LycorisCafeExtractor(private val client: OkHttpClient) {
         // 1. Obsługa kontynuacji linii (backslash + newline)
         val withoutLineContinuation = text.replace("\\\n", "")
 
-        // 2. Regex do wykrywania wszystkich sekwencji escape
-        val regex = Regex(
-            """\\U([0-9a-fA-F]{8})|""" +     // \UXXXXXXXX
-                """\\u([0-9a-fA-F]{4})|""" +     // \uXXXX
-                """\\x([0-9a-fA-F]{2})|""" +     // \xHH
-                """\\([0-7]{1,3})|""" +          // \OOO (octal)
-                """\\([btnfr"'$\\\\])"""         // \n, \t, itd.
-        )
-
-        return regex.replace(withoutLineContinuation) { match ->
+        return wordsRegex.replace(withoutLineContinuation) { match ->
             val (u8, u4, x2, octal, simple) = match.destructured
             when {
                 u8.isNotEmpty() -> handleUnicode8(u8)
@@ -208,16 +199,32 @@ class LycorisCafeExtractor(private val client: OkHttpClient) {
     }
 
     @Serializable
-    data class VideoLinks(
+    data class ScriptBody(
+        val body: String
+    )
+
+    @Serializable
+    data class ScriptEpisode(
+        val episodeInfo: EpisodeInfo
+    )
+
+    @Serializable
+    data class EpisodeInfo(
+        val id: Int? = null,
+        val FHD: String? = null,
+        val HD: String? = null,
+        val SD: String? = null,
+    )
+
+    @Serializable
+    data class VideoLinksApi(
         val HD: String? = null,
         val SD: String? = null,
         val FHD: String? = null,
         val Source: String? = null,
-        val preview: String? = null,
         val SourceMKV: String? = null
     )
 
-
 }
 
 
diff --git a/lib/megacloud-extractor/src/main/java/eu/kanade/tachiyomi/lib/megacloudextractor/MegaCloudExtractor.kt b/lib/megacloud-extractor/src/main/java/eu/kanade/tachiyomi/lib/megacloudextractor/MegaCloudExtractor.kt
index ead4b50b..6b4d2fcf 100644
--- a/lib/megacloud-extractor/src/main/java/eu/kanade/tachiyomi/lib/megacloudextractor/MegaCloudExtractor.kt
+++ b/lib/megacloud-extractor/src/main/java/eu/kanade/tachiyomi/lib/megacloudextractor/MegaCloudExtractor.kt
@@ -47,7 +47,7 @@ class MegaCloudExtractor(
         private var shouldUpdateKey = false
         private const val PREF_KEY_KEY = "megacloud_key_"
         private const val PREF_KEY_DEFAULT = "[[0, 0]]"
-
+        
         private inline fun <reified R> runLocked(crossinline block: () -> R) = runBlocking(Dispatchers.IO) {
             MUTEX.withLock { block() }
         }
@@ -132,6 +132,7 @@ class MegaCloudExtractor(
             ?.filter { it.kind == "captions" }
             ?.map { Track(it.file, it.label) }
             .orEmpty()
+            .let { playlistUtils.fixSubtitles(it) }
         return playlistUtils.extractFromHls(
             masterUrl,
             videoNameGen = { "$name - $it - $type" },
@@ -141,7 +142,7 @@ class MegaCloudExtractor(
     }
 
     private fun getVideoDto(url: String): VideoDto {
-        val type = if (url.startsWith("https://megacloud.tv") or url.startsWith("https://megacloud.club")) 0 else 1
+        val type = if (url.startsWith("https://megacloud.tv") or url.startsWith("https://megacloud.blog")) 0 else 1
 
         val keyType = SOURCES_KEY[type]
 
@@ -184,4 +185,4 @@ class MegaCloudExtractor(
 
     @Serializable
     data class TrackDto(val file: String, val kind: String, val label: String = "")
-}
+} 
diff --git a/lib/megacloud-extractor/src/main/java/eu/kanade/tachiyomi/lib/megacloudextractor/WebViewResolver.kt b/lib/megacloud-extractor/src/main/java/eu/kanade/tachiyomi/lib/megacloudextractor/WebViewResolver.kt
index 45cc4d01..9ad99e22 100644
--- a/lib/megacloud-extractor/src/main/java/eu/kanade/tachiyomi/lib/megacloudextractor/WebViewResolver.kt
+++ b/lib/megacloud-extractor/src/main/java/eu/kanade/tachiyomi/lib/megacloudextractor/WebViewResolver.kt
@@ -92,7 +92,7 @@ class WebViewResolver(private val globalHeaders: Headers) {
             val headers = mapOf("X-Requested-With" to "org.lineageos.jelly")
 
             webView?.loadUrl("https://megacloud.tv/about", headers)
-        }
+        }  
 
         latch.await(TIMEOUT_SEC, TimeUnit.SECONDS)
 
diff --git a/lib/playlist-utils/src/main/java/eu/kanade/tachiyomi/lib/playlistutils/PlaylistUtils.kt b/lib/playlist-utils/src/main/java/eu/kanade/tachiyomi/lib/playlistutils/PlaylistUtils.kt
index f7adb84c..a84b7fae 100644
--- a/lib/playlist-utils/src/main/java/eu/kanade/tachiyomi/lib/playlistutils/PlaylistUtils.kt
+++ b/lib/playlist-utils/src/main/java/eu/kanade/tachiyomi/lib/playlistutils/PlaylistUtils.kt
@@ -1,5 +1,6 @@
 package eu.kanade.tachiyomi.lib.playlistutils
 
+import android.net.Uri
 import eu.kanade.tachiyomi.animesource.model.Track
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.network.GET
@@ -8,7 +9,7 @@ import okhttp3.Headers
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.OkHttpClient
 import okhttp3.internal.commonEmptyHeaders
-import kotlin.math.abs
+import java.io.File
 
 class PlaylistUtils(private val client: OkHttpClient, private val headers: Headers = commonEmptyHeaders) {
 
@@ -136,7 +137,7 @@ class PlaylistUtils(private val client: OkHttpClient, private val headers: Heade
             val resolution = it.substringAfter("RESOLUTION=")
                 .substringBefore("\n")
                 .substringAfter("x")
-                .substringBefore(",").let(::stnQuality)
+                .substringBefore(",")
 
             val videoUrl = it.substringAfter("\n").substringBefore("\n").let { url ->
                 getAbsoluteUrl(url, playlistUrl, masterUrlBasePath)?.trimEnd()
@@ -335,14 +336,32 @@ class PlaylistUtils(private val client: OkHttpClient, private val headers: Heade
 
     // ============================= Utilities ==============================
 
-    private fun stnQuality(quality: String): String {
-        val intQuality = quality.trim().toInt()
-        val standardQualities = listOf(144, 240, 360, 480, 720, 1080)
-        val result =  standardQualities.minByOrNull { abs(it - intQuality) } ?: quality
-        return "${result}p"
+    private fun cleanSubtitleData(matchResult: MatchResult): String {
+        val lineCount = matchResult.groupValues[1].count { it == '\n' }
+        return "\n" + "&nbsp;\n".repeat(lineCount - 1)
+    }
+
+    fun fixSubtitles(subtitleList: List<Track>): List<Track> {
+        return subtitleList.mapNotNull {
+            try {
+                val subData = client.newCall(GET(it.url)).execute().body.string()
+
+                val file = File.createTempFile("subs", "vtt")
+                    .also(File::deleteOnExit)
+
+                file.writeText(FIX_SUBTITLE_REGEX.replace(subData, ::cleanSubtitleData))
+                val uri = Uri.fromFile(file)
+
+                Track(uri.toString(), it.lang)
+            } catch (_: Exception) {
+                null
+            }
+        }
     }
 
     companion object {
+        private val FIX_SUBTITLE_REGEX = Regex("""${'$'}(\n{2,})(?!(?:\d+:)*\d+(?:\.\d+)?\s-+>\s(?:\d+:)*\d+(?:\.\d+)?)""", RegexOption.MULTILINE)
+        
         private const val PLAYLIST_SEPARATOR = "#EXT-X-STREAM-INF:"
 
         private val SUBTITLE_REGEX by lazy { Regex("""#EXT-X-MEDIA:TYPE=SUBTITLES.*?NAME="(.*?)".*?URI="(.*?)"""") }
diff --git a/lib/savefile-extractor/build.gradle.kts b/lib/savefile-extractor/build.gradle.kts
new file mode 100644
index 00000000..d31dd9ff
--- /dev/null
+++ b/lib/savefile-extractor/build.gradle.kts
@@ -0,0 +1,7 @@
+plugins {
+    id("lib-android")
+}
+
+dependencies {
+    implementation(project(":lib:playlist-utils"))
+}
diff --git a/lib/savefile-extractor/src/main/java/eu/kanade/tachiyomi/lib/savefileextractor/SavefileExtractor.kt b/lib/savefile-extractor/src/main/java/eu/kanade/tachiyomi/lib/savefileextractor/SavefileExtractor.kt
new file mode 100644
index 00000000..d2abbf54
--- /dev/null
+++ b/lib/savefile-extractor/src/main/java/eu/kanade/tachiyomi/lib/savefileextractor/SavefileExtractor.kt
@@ -0,0 +1,67 @@
+package eu.kanade.tachiyomi.lib.savefileextractor
+
+import android.content.SharedPreferences
+import androidx.preference.EditTextPreference
+import androidx.preference.PreferenceScreen
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.OkHttpClient
+
+class SavefileExtractor(
+    private val client: OkHttpClient,
+    private val preferences: SharedPreferences,
+) {
+
+    private val playlistUtils by lazy { PlaylistUtils(client) }
+
+    fun videosFromUrl(url: String, prefix: String = "Savefile - ", headers: Headers? = null): List<Video> {
+        val httpUrl = url.toHttpUrl()
+        val videoHeaders = (headers?.newBuilder() ?: Headers.Builder())
+            .set("Referer", url)
+            .set("Origin", "https://${httpUrl.host}")
+            .build()
+
+        val doc = client.newCall(GET(url, videoHeaders)).execute().asJsoup()
+        val js = doc.selectFirst("script:containsData(m3u8)")!!.data()
+        val masterUrl = js.takeIf(String::isNotBlank)
+            ?.substringAfter("{file:\"", "")
+            ?.substringBefore("\"}", "")
+            ?.takeIf(String::isNotBlank)
+            ?: return emptyList()
+
+        val videoList = playlistUtils.extractFromHls(
+            masterUrl,
+            referer = "https://${httpUrl.host}/",
+            videoNameGen = { "$prefix$it" },
+        )
+
+        val subPref = preferences.getString(PREF_SUBTITLE_KEY, PREF_SUBTITLE_DEFAULT).orEmpty()
+        return videoList.map {
+            Video(
+                url = it.url,
+                quality = it.quality,
+                videoUrl = it.videoUrl,
+                audioTracks = it.audioTracks,
+                subtitleTracks = it.subtitleTracks.filter { tracks -> tracks.lang.contains(subPref, true) }
+            )
+        }
+    }
+
+    companion object {
+        fun addSubtitlePref(screen: PreferenceScreen) {
+            EditTextPreference(screen.context).apply {
+                key = PREF_SUBTITLE_KEY
+                title = "Savefile subtitle preference"
+                summary = "Leave blank to use all subs"
+                setDefaultValue(PREF_SUBTITLE_DEFAULT)
+            }.also(screen::addPreference)
+        }
+
+        private const val PREF_SUBTITLE_KEY = "pref_savefile_sub_lang_key"
+        private const val PREF_SUBTITLE_DEFAULT = "eng"
+    }
+}
diff --git a/lib/streamwish-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamwishextractor/StreamWishExtractor.kt b/lib/streamwish-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamwishextractor/StreamWishExtractor.kt
index d5d7ecee..9896ba26 100644
--- a/lib/streamwish-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamwishextractor/StreamWishExtractor.kt
+++ b/lib/streamwish-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamwishextractor/StreamWishExtractor.kt
@@ -10,6 +10,7 @@ import kotlinx.serialization.Serializable
 import kotlinx.serialization.SerializationException
 import kotlinx.serialization.json.Json
 import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.OkHttpClient
 
 class StreamWishExtractor(private val client: OkHttpClient, private val headers: Headers) {
@@ -30,16 +31,19 @@ class StreamWishExtractor(private val client: OkHttpClient, private val headers:
                     script
                 }
             }
-        val masterUrl = scriptBody
-            ?.substringAfter("source", "")
-            ?.substringAfter("file:\"", "")
-            ?.substringBefore("\"", "")
-            ?.takeIf(String::isNotBlank)
+        val masterUrl = scriptBody?.let {
+            M3U8_REGEX.find(it)?.value
+        }
             ?: return emptyList()
 
         val subtitleList = extractSubtitles(scriptBody)
 
-        return playlistUtils.extractFromHls(masterUrl, url, videoNameGen = videoNameGen, subtitleList = subtitleList)
+        return playlistUtils.extractFromHls(
+            playlistUrl = masterUrl,
+            referer = "https://${url.toHttpUrl().host}/",
+            videoNameGen = videoNameGen,
+            subtitleList = playlistUtils.fixSubtitles(subtitleList),
+        )
     }
 
     private fun getEmbedUrl(url: String): String {
@@ -57,7 +61,11 @@ class StreamWishExtractor(private val client: OkHttpClient, private val headers:
                 .substringAfter("tracks")
                 .substringAfter("[")
                 .substringBefore("]")
-            json.decodeFromString<List<TrackDto>>("[$subtitleStr]")
+            val fixedSubtitleStr = FIX_TRACKS_REGEX.replace(subtitleStr) { match ->
+                "\"${match.value}\""
+            }
+
+            json.decodeFromString<List<TrackDto>>("[$fixedSubtitleStr]")
                 .filter { it.kind.equals("captions", true) }
                 .map { Track(it.file, it.label ?: "") }
         } catch (e: SerializationException) {
@@ -67,4 +75,7 @@ class StreamWishExtractor(private val client: OkHttpClient, private val headers:
 
     @Serializable
     private data class TrackDto(val file: String, val kind: String, val label: String? = null)
+
+    private val M3U8_REGEX = Regex("""https[^"]*m3u8[^"]*""")
+    private val FIX_TRACKS_REGEX = Regex("""(?<!["])(file|kind|label)(?!["])""")
 }
diff --git a/lib/universal-extractor/src/main/java/eu/kanade/tachiyomi/lib/universalextractor/UniversalExtractor.kt b/lib/universal-extractor/src/main/java/eu/kanade/tachiyomi/lib/universalextractor/UniversalExtractor.kt
index 16408cec..95c38dc3 100644
--- a/lib/universal-extractor/src/main/java/eu/kanade/tachiyomi/lib/universalextractor/UniversalExtractor.kt
+++ b/lib/universal-extractor/src/main/java/eu/kanade/tachiyomi/lib/universalextractor/UniversalExtractor.kt
@@ -18,6 +18,7 @@ import uy.kohesive.injekt.injectLazy
 import java.util.Locale
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
+import kotlin.math.abs
 
 class UniversalExtractor(private val client: OkHttpClient) {
     private val context: Application by injectLazy()
@@ -73,7 +74,7 @@ class UniversalExtractor(private val client: OkHttpClient) {
 
             for (quality in qualities) {
                 val modifiedUrl = resultUrl.replace("M3U8_AUTO_360", "M3U8_AUTO_$quality")
-                val videos = playlistUtils.extractFromHls(modifiedUrl, origRequestUrl, videoNameGen = { "$prefix - $host: $it $quality" + "p" })
+                val videos = playlistUtils.extractFromHls(modifiedUrl, origRequestUrl, videoNameGen = { "$prefix - $host: ${stnQuality(it)} $quality" + "p" })
 
                 if (videos.isNotEmpty()) {
                     allVideos.addAll(videos)
@@ -89,7 +90,7 @@ class UniversalExtractor(private val client: OkHttpClient) {
         return when {
             "m3u8" in resultUrl -> {
                 Log.d("UniversalExtractor", "m3u8 URL: $resultUrl")
-                playlistUtils.extractFromHls(resultUrl, origRequestUrl, videoNameGen = { "$prefix - $host: $it" })
+                playlistUtils.extractFromHls(resultUrl, origRequestUrl, videoNameGen = { "$prefix - $host: ${stnQuality(it)}" })
             }
             "mpd" in resultUrl -> {
                 Log.d("UniversalExtractor", "mpd URL: $resultUrl")
@@ -103,6 +104,13 @@ class UniversalExtractor(private val client: OkHttpClient) {
         }
     }
 
+    private fun stnQuality(quality: String): String {
+        val intQuality = quality.trim().toInt()
+        val standardQualities = listOf(144, 240, 360, 480, 720, 1080)
+        val result =  standardQualities.minByOrNull { abs(it - intQuality) } ?: quality
+        return "${result}p"
+    }
+
     private fun String.proper(): String {
         return this.replaceFirstChar { if (it.isLowerCase()) it.titlecase(
             Locale.getDefault()) else it.toString() }
diff --git a/src/all/animeworldindia/build.gradle b/src/all/animeworldindia/build.gradle
index 0c887191..506389ba 100644
--- a/src/all/animeworldindia/build.gradle
+++ b/src/all/animeworldindia/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AnimeWorld India'
     extClass = '.AnimeWorldIndiaFactory'
-    extVersionCode = 15
+    extVersionCode = 16
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/all/animexin/build.gradle b/src/all/animexin/build.gradle
index 6240f5b8..782866fc 100644
--- a/src/all/animexin/build.gradle
+++ b/src/all/animexin/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.AnimeXin'
     themePkg = 'animestream'
     baseUrl = 'https://animexin.vip'
-    overrideVersionCode = 10
+    overrideVersionCode = 11
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/all/anizone/build.gradle b/src/all/anizone/build.gradle
index 2d7a05d4..69c775f3 100644
--- a/src/all/anizone/build.gradle
+++ b/src/all/anizone/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AniZone'
     extClass = '.AniZone'
-    extVersionCode = 3
+    extVersionCode = 4
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/all/chineseanime/build.gradle b/src/all/chineseanime/build.gradle
index 7c30f6a7..1be0f821 100644
--- a/src/all/chineseanime/build.gradle
+++ b/src/all/chineseanime/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.ChineseAnime'
     themePkg = 'animestream'
     baseUrl = 'https://www.chineseanime.vip'
-    overrideVersionCode = 13
+    overrideVersionCode = 15
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/all/hikari/build.gradle b/src/all/hikari/build.gradle
index 28dd06bc..26912f8b 100644
--- a/src/all/hikari/build.gradle
+++ b/src/all/hikari/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Hikari'
     extClass = '.Hikari'
-    extVersionCode = 16
+    extVersionCode = 22
 }
 
 apply from: "$rootDir/common.gradle"
@@ -9,6 +9,7 @@ apply from: "$rootDir/common.gradle"
 dependencies {
     implementation(project(':lib:chillx-extractor'))
     implementation(project(':lib:filemoon-extractor'))
+    implementation(project(':lib:savefile-extractor'))
+    implementation(project(':lib:buzzheavier-extractor'))
     implementation(project(':lib:streamwish-extractor'))
-    implementation(project(':lib:vidhide-extractor'))
-}
\ No newline at end of file
+}
diff --git a/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Dto.kt b/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Dto.kt
new file mode 100644
index 00000000..4aa65ef0
--- /dev/null
+++ b/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Dto.kt
@@ -0,0 +1,118 @@
+package eu.kanade.tachiyomi.animeextension.all.hikari
+
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class CatalogResponseDto<T>(
+    val next: String? = null,
+    val results: List<T>,
+)
+
+@Serializable
+data class AnimeDto(
+    val uid: String,
+
+    @SerialName("ani_ename")
+    val aniEName: String? = null,
+    @SerialName("ani_name")
+    val aniName: String,
+    @SerialName("ani_poster")
+    val aniPoster: String? = null,
+    @SerialName("ani_synopsis")
+    val aniSynopsis: String? = null,
+    @SerialName("ani_synonyms")
+    val aniSynonyms: String? = null,
+    @SerialName("ani_genre")
+    val aniGenre: String? = null,
+    @SerialName("ani_studio")
+    val aniStudio: String? = null,
+    @SerialName("ani_producers")
+    val aniProducers: String? = null,
+    @SerialName("ani_stats")
+    val aniStats: Int? = null,
+    @SerialName("ani_time")
+    val aniTime: String? = null,
+    @SerialName("ani_ep")
+    val aniEp: String? = null,
+    @SerialName("ani_type")
+    val aniType: Int? = null,
+    @SerialName("ani_score")
+    val aniScore: Double? = null,
+) {
+    fun toSAnime(preferEnglish: Boolean): SAnime = SAnime.create().apply {
+        url = uid
+        title = if (preferEnglish) aniEName?.takeUnless(String::isBlank) ?: aniName else aniName
+        thumbnail_url = aniPoster
+        genre = aniGenre?.split(",")?.joinToString(transform = String::trim)
+        artist = aniStudio
+        author = aniProducers?.split(",")?.joinToString(transform = String::trim)
+        description = buildString {
+            aniScore?.let { append("Score: %.2f/10\n\n".format(it)) }
+            aniSynopsis?.trim()?.let(::append)
+            append("\n\n")
+            aniType?.let {
+                val type = when (it) {
+                    1 -> "TV"
+                    2 -> "Movie"
+                    3 -> "OVA"
+                    4 -> "ONA"
+                    5 -> "Special"
+                    else -> "Unknown"
+                }
+                append("Type: $type\n")
+            }
+            aniEp?.let { append("Total Episode count: $it\n") }
+            aniTime?.let { append("Runtime: $it\n") }
+            aniSynonyms?.let { append("Synonyms: $it") }
+        }.trim()
+
+        status = when (aniStats) {
+            1 -> SAnime.UNKNOWN
+            2 -> SAnime.COMPLETED
+            3 -> SAnime.ONGOING
+            else -> SAnime.UNKNOWN
+        }
+    }
+}
+
+@Serializable
+data class LatestEpisodeDto(
+    val uid: Int,
+    val title: String,
+    @SerialName("title_en")
+    val titleEn: String? = null,
+    val imageUrl: String,
+) {
+    fun toSAnime(preferEnglish: Boolean): SAnime = SAnime.create().apply {
+        url = uid.toString()
+        title = if (preferEnglish) titleEn?.takeUnless(String::isBlank) ?: this@LatestEpisodeDto.title else this@LatestEpisodeDto.title
+        thumbnail_url = imageUrl
+    }
+}
+
+@Serializable
+data class EpisodeDto(
+    @SerialName("ep_id_name")
+    val epId: String,
+    @SerialName("ep_name")
+    val epName: String? = null,
+) {
+    fun toSEpisode(uid: String): SEpisode = SEpisode.create().apply {
+        url = "$uid-$epId"
+        name = epName?.let { "Ep. $epId - $it" } ?: "Episode $epId"
+        episode_number = epId.toFloatOrNull() ?: 1f
+    }
+}
+
+@Serializable
+data class EmbedDto(
+    @SerialName("embed_type")
+    val embedType: String,
+    @SerialName("embed_name")
+    val embedName: String,
+    @SerialName("embed_frame")
+    val embedFrame: String,
+)
diff --git a/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Filters.kt b/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Filters.kt
index 7f29c05f..8c9cf7a5 100644
--- a/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Filters.kt
+++ b/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Filters.kt
@@ -5,7 +5,7 @@ import okhttp3.HttpUrl
 import java.util.Calendar
 
 interface UriFilter {
-    fun addToUri(url: HttpUrl.Builder)
+    fun addToUri(builder: HttpUrl.Builder)
 }
 
 sealed class UriPartFilter(
@@ -20,7 +20,10 @@ sealed class UriPartFilter(
 ),
     UriFilter {
     override fun addToUri(builder: HttpUrl.Builder) {
-        builder.addQueryParameter(param, vals[state].second)
+        val value = vals[state].second
+        if (value.isNotEmpty()) {
+            builder.addQueryParameter(param, value)
+        }
     }
 }
 
@@ -33,13 +36,15 @@ sealed class UriMultiSelectFilter(
 ) : AnimeFilter.Group<UriMultiSelectOption>(name, vals.map { UriMultiSelectOption(it.first, it.second) }), UriFilter {
     override fun addToUri(builder: HttpUrl.Builder) {
         val checked = state.filter { it.state }
-        builder.addQueryParameter(param, checked.joinToString(",") { it.value })
+        if (checked.isNotEmpty()) {
+            builder.addQueryParameter(param, checked.joinToString(",") { it.value })
+        }
     }
 }
 
 class TypeFilter : UriPartFilter(
     "Type",
-    "type",
+    "ani_type",
     arrayOf(
         Pair("All", ""),
         Pair("TV", "1"),
@@ -50,165 +55,53 @@ class TypeFilter : UriPartFilter(
     ),
 )
 
-class CountryFilter : UriPartFilter(
-    "Country",
-    "country",
-    arrayOf(
-        Pair("All", ""),
-        Pair("Japanese", "1"),
-        Pair("Chinese", "2"),
-    ),
-)
-
 class StatusFilter : UriPartFilter(
     "Status",
-    "stats",
+    "ani_stats",
     arrayOf(
         Pair("All", ""),
-        Pair("Currently Airing", "1"),
-        Pair("Finished Airing", "2"),
-        Pair("Not yet Aired", "3"),
-    ),
-)
-
-class RatingFilter : UriPartFilter(
-    "Rating",
-    "rate",
-    arrayOf(
-        Pair("All", ""),
-        Pair("G", "1"),
-        Pair("PG", "2"),
-        Pair("PG-13", "3"),
-        Pair("R-17+", "4"),
-        Pair("R+", "5"),
-        Pair("Rx", "6"),
-    ),
-)
-
-class SourceFilter : UriPartFilter(
-    "Source",
-    "source",
-    arrayOf(
-        Pair("All", ""),
-        Pair("LightNovel", "1"),
-        Pair("Manga", "2"),
-        Pair("Original", "3"),
+        Pair("Ongoing", "1"),
+        Pair("Completed", "2"),
+        Pair("Upcoming", "3"),
     ),
 )
 
 class SeasonFilter : UriPartFilter(
     "Season",
-    "season",
+    "ani_release_season",
     arrayOf(
         Pair("All", ""),
-        Pair("Spring", "1"),
-        Pair("Summer", "2"),
-        Pair("Fall", "3"),
-        Pair("Winter", "4"),
+        Pair("Winter", "1"),
+        Pair("Spring", "2"),
+        Pair("Summer", "3"),
+        Pair("Fall", "4"),
     ),
 )
 
-class LanguageFilter : UriPartFilter(
-    "Language",
-    "language",
-    arrayOf(
-        Pair("All", ""),
-        Pair("Raw", "1"),
-        Pair("Sub", "2"),
-        Pair("Dub", "3"),
-        Pair("Turk", "4"),
-    ),
-)
-
-class SortFilter : UriPartFilter(
-    "Sort",
-    "sort",
-    arrayOf(
-        Pair("Default", "default"),
-        Pair("Recently Added", "recently_added"),
-        Pair("Recently Updated", "recently_updated"),
-        Pair("Score", "score"),
-        Pair("Name A-Z", "name_az"),
-        Pair("Released Date", "released_date"),
-        Pair("Most Watched", "most_watched"),
-    ),
-)
-
-class YearFilter(name: String, param: String) : UriPartFilter(
-    name,
-    param,
+class YearFilter : UriPartFilter(
+    "Release Year",
+    "ani_release",
     YEARS,
 ) {
     companion object {
-        private val NEXT_YEAR by lazy {
-            Calendar.getInstance()[Calendar.YEAR] + 1
+        private val CURRENT_YEAR by lazy {
+            Calendar.getInstance()[Calendar.YEAR]
         }
 
-        private val YEARS = Array(NEXT_YEAR - 1917) { year ->
-            if (year == 0) {
-                Pair("Any", "")
-            } else {
-                (NEXT_YEAR - year).toString().let { Pair(it, it) }
-            }
-        }
-    }
-}
-
-class MonthFilter(name: String, param: String) : UriPartFilter(
-    name,
-    param,
-    MONTHS,
-) {
-    companion object {
-        private val MONTHS = Array(13) { months ->
-            if (months == 0) {
-                Pair("Any", "")
-            } else {
-                val monthStr = "%02d".format(months)
-                Pair(monthStr, monthStr)
-            }
-        }
-    }
-}
-
-class DayFilter(name: String, param: String) : UriPartFilter(
-    name,
-    param,
-    DAYS,
-) {
-    companion object {
-        private val DAYS = Array(32) { day ->
-            if (day == 0) {
-                Pair("Any", "")
-            } else {
-                val dayStr = "%02d".format(day)
-                Pair(dayStr, dayStr)
-            }
-        }
-    }
-}
-
-class AiringDateFilter(
-    private val values: List<UriPartFilter> = PARTS,
-) : AnimeFilter.Group<UriPartFilter>("Airing Date", values), UriFilter {
-    override fun addToUri(builder: HttpUrl.Builder) {
-        values.forEach {
-            it.addToUri(builder)
-        }
-    }
-
-    companion object {
-        private val PARTS = listOf(
-            YearFilter("Year", "aired_year"),
-            MonthFilter("Month", "aired_month"),
-            DayFilter("Day", "aired_day"),
-        )
+        private val YEARS = buildList {
+            add(Pair("Any", ""))
+            addAll(
+                (1990..CURRENT_YEAR).map {
+                    Pair(it.toString(), it.toString())
+                },
+            )
+        }.toTypedArray()
     }
 }
 
 class GenreFilter : UriMultiSelectFilter(
     "Genre",
-    "genres",
+    "ani_genre",
     arrayOf(
         Pair("Action", "Action"),
         Pair("Adventure", "Adventure"),
@@ -233,7 +126,7 @@ class GenreFilter : UriMultiSelectFilter(
         Pair("Music", "Music"),
         Pair("Mystery", "Mystery"),
         Pair("Parody", "Parody"),
-        Pair("Police", "Police"),
+        Pair("Policy", "Policy"),
         Pair("Psychological", "Psychological"),
         Pair("Romance", "Romance"),
         Pair("Samurai", "Samurai"),
@@ -253,3 +146,12 @@ class GenreFilter : UriMultiSelectFilter(
         Pair("Vampire", "Vampire"),
     ),
 )
+
+class LanguageFilter : UriPartFilter(
+    "Language",
+    "ani_genre",
+    arrayOf(
+        Pair("Any", ""),
+        Pair("Portuguese", "Portuguese"),
+    ),
+)
diff --git a/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Hikari.kt b/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Hikari.kt
index 26b65154..5e3fd6af 100644
--- a/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Hikari.kt
+++ b/src/all/hikari/src/eu/kanade/tachiyomi/animeextension/all/hikari/Hikari.kt
@@ -1,48 +1,45 @@
 package eu.kanade.tachiyomi.animeextension.all.hikari
 
 import android.app.Application
-import android.util.Log
+import android.content.SharedPreferences
 import androidx.preference.ListPreference
+import androidx.preference.MultiSelectListPreference
 import androidx.preference.PreferenceScreen
+import androidx.preference.SwitchPreferenceCompat
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-import eu.kanade.tachiyomi.animesource.model.AnimeFilter
 import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
 import eu.kanade.tachiyomi.animesource.model.AnimesPage
 import eu.kanade.tachiyomi.animesource.model.SAnime
 import eu.kanade.tachiyomi.animesource.model.SEpisode
 import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.animesource.online.ParsedAnimeHttpSource
+import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
+import eu.kanade.tachiyomi.lib.buzzheavierextractor.BuzzheavierExtractor
 import eu.kanade.tachiyomi.lib.chillxextractor.ChillxExtractor
 import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
+import eu.kanade.tachiyomi.lib.savefileextractor.SavefileExtractor
 import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
-import eu.kanade.tachiyomi.lib.vidhideextractor.VidHideExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
 import eu.kanade.tachiyomi.util.parseAs
-import kotlinx.serialization.Serializable
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.Request
 import okhttp3.Response
-import org.jsoup.Jsoup
-import org.jsoup.nodes.Document
-import org.jsoup.nodes.Element
 import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 
-class Hikari : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
+class Hikari : AnimeHttpSource(), ConfigurableAnimeSource {
 
     override val name = "Hikari"
 
-    override val baseUrl = "https://watch.hikaritv.xyz"
+    private val proxyUrl = "https://hikari.gg/hiki-proxy/extract/"
+    private val apiUrl = "https://api.hikari.gg/api"
+    override val baseUrl = "https://hikari.gg"
 
     override val lang = "all"
 
-    override val supportsLatest = true
+    override val versionId = 2
 
-    override fun headersBuilder() = super.headersBuilder().apply {
-        add("Origin", baseUrl)
-        add("Referer", "$baseUrl/")
-    }
+    override val supportsLatest = true
 
     private val preferences by lazy {
         Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
@@ -50,75 +47,40 @@ class Hikari : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
 
     // ============================== Popular ===============================
 
-    override fun popularAnimeRequest(page: Int): Request {
-        val url = "$baseUrl/ajax/getfilter?type=&country=&stats=&rate=&source=&season=&language=&aired_year=&aired_month=&aired_day=&sort=score&genres=&page=$page"
-        val headers = headersBuilder().set("Referer", "$baseUrl/filter").build()
-        return GET(url, headers)
-    }
+    override fun popularAnimeRequest(page: Int) = searchAnimeRequest(page, "", AnimeFilterList())
 
-    override fun popularAnimeParse(response: Response): AnimesPage {
-        val parsed = response.parseAs<HtmlResponseDto>()
-
-        val hasNextPage = response.request.url.queryParameter("page")!!.toInt() < parsed.page!!.totalPages
-        val animeList = parsed.toHtml(baseUrl).select(popularAnimeSelector())
-            .map(::popularAnimeFromElement)
-
-        return AnimesPage(animeList, hasNextPage)
-    }
-
-    override fun popularAnimeSelector(): String = ".flw-item"
-
-    override fun popularAnimeFromElement(element: Element): SAnime = SAnime.create().apply {
-        setUrlWithoutDomain(element.selectFirst("a[data-id]")!!.attr("abs:href"))
-        thumbnail_url = element.selectFirst("img")!!.attr("abs:src")
-        title = element.selectFirst(".film-name")!!.text()
-    }
-
-    override fun popularAnimeNextPageSelector(): String? = null
+    override fun popularAnimeParse(response: Response) = searchAnimeParse(response)
 
     // =============================== Latest ===============================
 
     override fun latestUpdatesRequest(page: Int): Request {
-        val url = "$baseUrl/ajax/getfilter?type=&country=&stats=&rate=&source=&season=&language=&aired_year=&aired_month=&aired_day=&sort=recently_updated&genres=&page=$page"
-        val headers = headersBuilder().set("Referer", "$baseUrl/filter").build()
+        val url = "$apiUrl/episode/new/".toHttpUrl().newBuilder().apply {
+            addQueryParameter("limit", "100")
+            addQueryParameter("language", "EN")
+        }.build()
         return GET(url, headers)
     }
 
-    override fun latestUpdatesParse(response: Response): AnimesPage =
-        popularAnimeParse(response)
+    override fun latestUpdatesParse(response: Response): AnimesPage {
+        val data = response.parseAs<CatalogResponseDto<LatestEpisodeDto>>()
+        val preferEnglish = preferences.getTitleLang
 
-    override fun latestUpdatesSelector(): String =
-        throw UnsupportedOperationException()
-
-    override fun latestUpdatesFromElement(element: Element): SAnime =
-        throw UnsupportedOperationException()
-
-    override fun latestUpdatesNextPageSelector(): String =
-        throw UnsupportedOperationException()
+        val animeList = data.results.distinctBy { it.uid }.map { it.toSAnime(preferEnglish) }
+        return AnimesPage(animeList, false)
+    }
 
     // =============================== Search ===============================
 
     override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val url = baseUrl.toHttpUrl().newBuilder().apply {
-            if (query.isNotEmpty()) {
-                addPathSegment("search")
-                addQueryParameter("keyword", query)
-                addQueryParameter("page", page.toString())
-            } else {
-                addPathSegment("ajax")
-                addPathSegment("getfilter")
-                filters.filterIsInstance<UriFilter>().forEach {
-                    it.addToUri(this)
-                }
-                addQueryParameter("page", page.toString())
+        val url = "$apiUrl/anime/".toHttpUrl().newBuilder().apply {
+            addQueryParameter("sort", "created_at")
+            addQueryParameter("order", "asc")
+            addQueryParameter("page", page.toString())
+            filters.filterIsInstance<UriFilter>().forEach {
+                it.addToUri(this)
             }
-        }.build()
-
-        val headers = headersBuilder().apply {
             if (query.isNotEmpty()) {
-                set("Referer", url.toString().substringBeforeLast("&page"))
-            } else {
-                set("Referer", "$baseUrl/filter")
+                addQueryParameter("search", query)
             }
         }.build()
 
@@ -126,280 +88,179 @@ class Hikari : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
     }
 
     override fun searchAnimeParse(response: Response): AnimesPage {
-        return if (response.request.url.encodedPath.startsWith("/search")) {
-            super.searchAnimeParse(response)
-        } else {
-            popularAnimeParse(response)
-        }
+        val data = response.parseAs<CatalogResponseDto<AnimeDto>>()
+        val preferEnglish = preferences.getTitleLang
+
+        val animeList = data.results.map { it.toSAnime(preferEnglish) }
+        val hasNextPage = data.next != null
+
+        return AnimesPage(animeList, hasNextPage)
     }
 
-    override fun searchAnimeSelector(): String = popularAnimeSelector()
-
-    override fun searchAnimeFromElement(element: Element): SAnime = popularAnimeFromElement(element)
-
-    override fun searchAnimeNextPageSelector(): String = "ul.pagination > li.active + li"
-
     // ============================== Filters ===============================
 
     override fun getFilterList(): AnimeFilterList = AnimeFilterList(
-        AnimeFilter.Header("Note: text search ignores filters"),
-        AnimeFilter.Separator(),
         TypeFilter(),
-        CountryFilter(),
         StatusFilter(),
-        RatingFilter(),
-        SourceFilter(),
         SeasonFilter(),
-        LanguageFilter(),
-        SortFilter(),
-        AiringDateFilter(),
+        YearFilter(),
         GenreFilter(),
+        LanguageFilter(),
     )
 
     // =========================== Anime Details ============================
 
-    override fun animeDetailsParse(document: Document): SAnime = SAnime.create().apply {
-        with(document.selectFirst("#ani_detail")!!) {
-            title = selectFirst(".film-name")!!.text()
-            thumbnail_url = selectFirst(".film-poster img")!!.attr("abs:src")
-            description = selectFirst(".film-description > .text")?.text()
-            genre = select(".item-list:has(span:contains(Genres)) > a").joinToString { it.text() }
-            author = select(".item:has(span:contains(Studio)) > a").joinToString { it.text() }
-            status = selectFirst(".item:has(span:contains(Status)) > .name").parseStatus()
-        }
+    override fun getAnimeUrl(anime: SAnime): String {
+        return "$baseUrl/info/${anime.url}"
     }
 
-    private fun Element?.parseStatus(): Int = when (this?.text()?.lowercase()) {
-        "currently airing" -> SAnime.ONGOING
-        "finished" -> SAnime.COMPLETED
-        else -> SAnime.UNKNOWN
+    override fun animeDetailsRequest(anime: SAnime): Request {
+        return GET("$apiUrl/anime/uid/${anime.url}/", headers)
+    }
+
+    override fun animeDetailsParse(response: Response): SAnime {
+        return response.parseAs<AnimeDto>().toSAnime(preferences.getTitleLang)
     }
 
     // ============================== Episodes ==============================
 
-    private val specialCharRegex = Regex("""(?![\-_])\W{1,}""")
-
     override fun episodeListRequest(anime: SAnime): Request {
-        val animeId = anime.url.split("/")[2]
-
-        val sanitized = anime.title.replace(" ", "_")
-
-        val refererUrl = baseUrl.toHttpUrl().newBuilder().apply {
-            addPathSegment("watch")
-            addQueryParameter("anime", specialCharRegex.replace(sanitized, ""))
-            addQueryParameter("uid", animeId)
-            addQueryParameter("eps", "1")
-        }.build()
-
-        val headers = headersBuilder()
-            .set("Referer", refererUrl.toString())
-            .build()
-
-        return GET("$baseUrl/ajax/episodelist/$animeId", headers)
+        return GET("$apiUrl/episode/uid/${anime.url}/", headers)
     }
 
     override fun episodeListParse(response: Response): List<SEpisode> {
-        return response.parseAs<HtmlResponseDto>().toHtml(baseUrl)
-            .select(episodeListSelector())
-            .map(::episodeFromElement)
-            .reversed()
-    }
+        val guid = response.request.url.pathSegments[3]
 
-    override fun episodeListSelector() = "a[class~=ep-item]"
-
-    override fun episodeFromElement(element: Element): SEpisode {
-        val epText = element.selectFirst(".ssli-order")?.text()?.trim()
-            ?: element.attr("data-number").trim()
-        val ep = epText.toFloatOrNull() ?: 0F
-
-        val nameText = element.selectFirst(".ep-name")?.text()?.trim()
-            ?: element.attr("title").replace("Episode-", "Ep. ") ?: ""
-
-        return SEpisode.create().apply {
-            setUrlWithoutDomain(element.attr("abs:href"))
-            episode_number = ep
-            name = "Ep. $ep - $nameText"
-        }
+        return response.parseAs<List<EpisodeDto>>().map { it.toSEpisode(guid) }.reversed()
     }
 
     // ============================ Video Links =============================
 
-    private val filemoonExtractor by lazy { FilemoonExtractor(client) }
-    private val vidHideExtractor by lazy { VidHideExtractor(client, headers) }
+    private val filemoonExtractor by lazy { FilemoonExtractor(client, preferences) }
+    private val savefileExtractor by lazy { SavefileExtractor(client, preferences) }
+    private val buzzheavierExtractor by lazy { BuzzheavierExtractor(client, headers) }
     private val chillxExtractor by lazy { ChillxExtractor(client, headers) }
     private val streamwishExtractor by lazy { StreamWishExtractor(client, headers) }
-    private val embedRegex = Regex("""getEmbed\(\s*(\d+)\s*,\s*(\d+)\s*,\s*'(\d+)'""")
+
+    private fun getEmbedTypeName(type: String): String {
+        return when (type) {
+            "2" -> "[SUB] "
+            "3" -> "[DUB] "
+            "4" -> "[MULTI AUDIO] "
+            "8" -> "[HARD-SUB] "
+            else -> ""
+        }
+    }
 
     override fun videoListRequest(episode: SEpisode): Request {
-        val url = (baseUrl + episode.url).toHttpUrl()
-        val animeId = url.queryParameter("uid")!!
-        val episodeNum = url.queryParameter("eps")!!
-
-        val headers = headersBuilder()
-            .set("Referer", baseUrl + episode.url)
-            .build()
-
-        return GET("$baseUrl/ajax/embedserver/$animeId/$episodeNum", headers)
+        val (guid, epId) = episode.url.split("-")
+        return GET("$apiUrl/embed/$guid/$epId/", headers)
     }
 
     override fun videoListParse(response: Response): List<Video> {
-        val html = response.parseAs<HtmlResponseDto>().toHtml(baseUrl)
-        Log.d("Hikari", html.toString())
+        val data = response.parseAs<List<EmbedDto>>()
 
-        val headers = headersBuilder()
-            .set("Referer", response.request.url.toString())
-            .build()
+        val selectedProviders = preferences.getStringSet(PREF_PROVIDER_KEY, PREF_PROVIDERS_DEFAULT)?.map(String::lowercase)?.toSet() ?: emptySet()
 
-        val subEmbedUrls = html.select(".servers-sub div.item.server-item").flatMap { item ->
-            val name = item.text().trim() + " (Sub)"
-            val onClick = item.selectFirst("a")?.attr("onclick")
-            if (onClick == null) {
-                Log.e("Hikari", "onClick attribute is null for item: $item")
-                return@flatMap emptyList<Pair<String, String>>()
-            }
+        return data.parallelCatchingFlatMapBlocking { embed ->
+            val embedName = embed.embedName.lowercase()
 
-            val match = embedRegex.find(onClick)?.groupValues
-            if (match == null) {
-                Log.e("Hikari", "No match found for onClick: $onClick")
-                return@flatMap emptyList<Pair<String, String>>()
-            }
+            if (embedName !in selectedProviders) return@parallelCatchingFlatMapBlocking emptyList()
 
-            val url = "$baseUrl/ajax/embed/${match[1]}/${match[2]}/${match[3]}"
-            val iframeList = client.newCall(
-                GET(url, headers),
-            ).execute().parseAs<List<String>>()
+            val prefix = getEmbedTypeName(embed.embedType) + embed.embedName
 
-            iframeList.map {
-                val iframeSrc = Jsoup.parseBodyFragment(it).selectFirst("iframe")?.attr("src")
-                if (iframeSrc == null) {
-                    Log.e("Hikari", "iframe src is null for URL: $url")
-                    return@map Pair("", "")
-                }
-                Pair(iframeSrc, name)
-            }.filter { it.first.isNotEmpty() }
-        }
-        val dubEmbedUrls = html.select(".servers-dub div.item.server-item").flatMap { item ->
-            val name = item.text().trim() + " (Dub)"
-            val onClick = item.selectFirst("a")?.attr("onclick")
-            if (onClick == null) {
-                Log.e("Hikari", "onClick attribute is null for item: $item")
-                return@flatMap emptyList<Pair<String, String>>()
-            }
-
-            val match = embedRegex.find(onClick)?.groupValues
-            if (match == null) {
-                Log.e("Hikari", "No match found for onClick: $onClick")
-                return@flatMap emptyList<Pair<String, String>>()
-            }
-
-            val url = "$baseUrl/ajax/embed/${match[1]}/${match[2]}/${match[3]}"
-            val iframeList = client.newCall(
-                GET(url, headers),
-            ).execute().parseAs<List<String>>()
-
-            iframeList.map {
-                val iframeSrc = Jsoup.parseBodyFragment(it).selectFirst("iframe")?.attr("src")
-                if (iframeSrc == null) {
-                    Log.e("Hikari", "iframe src is null for URL: $url")
-                    return@map Pair("", "")
-                }
-                Pair(iframeSrc, name)
-            }.filter { it.first.isNotEmpty() }
-        }
-
-        val sdEmbedUrls = html.select(".servers-sub.\\&.dub div.item.server-item").flatMap { item ->
-            val name = item.text().trim() + " (Sub + Dub)"
-            val onClick = item.selectFirst("a")?.attr("onclick")
-            if (onClick == null) {
-                Log.e("Hikari", "onClick attribute is null for item: $item")
-                return@flatMap emptyList<Pair<String, String>>()
-            }
-
-            val match = embedRegex.find(onClick)?.groupValues
-            if (match == null) {
-                Log.e("Hikari", "No match found for onClick: $onClick")
-                return@flatMap emptyList<Pair<String, String>>()
-            }
-
-            val url = "$baseUrl/ajax/embed/${match[1]}/${match[2]}/${match[3]}"
-            val iframeList = client.newCall(
-                GET(url, headers),
-            ).execute().parseAs<List<String>>()
-
-            iframeList.map {
-                val iframeSrc = Jsoup.parseBodyFragment(it).selectFirst("iframe")?.attr("src")
-                if (iframeSrc == null) {
-                    Log.e("Hikari", "iframe src is null for URL: $url")
-                    return@map Pair("", "")
-                }
-                Pair(iframeSrc, name)
-            }.filter { it.first.isNotEmpty() }
-        }
-
-        return sdEmbedUrls.parallelCatchingFlatMapBlocking {
-            getVideosFromEmbed(it.first, it.second)
-        }.ifEmpty {
-            (subEmbedUrls + dubEmbedUrls).parallelCatchingFlatMapBlocking {
-                getVideosFromEmbed(it.first, it.second)
+            when (embedName) {
+                "streamwish" -> streamwishExtractor.videosFromUrl(embed.embedFrame, videoNameGen = { "$prefix - $it" })
+                "filemoon" -> filemoonExtractor.videosFromUrl(embed.embedFrame, "$prefix - ")
+                "sv" -> savefileExtractor.videosFromUrl(embed.embedFrame, "$prefix - ")
+                "playerx" -> chillxExtractor.videoFromUrl(embed.embedFrame, "$prefix - ")
+                "hiki" -> hikiExtraction(embed.embedFrame, "$prefix - ")
+                else -> emptyList()
             }
         }
     }
 
-    private fun getVideosFromEmbed(embedUrl: String, name: String): List<Video> = when {
-        name.contains("vidhide", true) -> vidHideExtractor.videosFromUrl(embedUrl, videoNameGen = { s -> "$name - $s" })
-        embedUrl.contains("filemoon", true) -> filemoonExtractor.videosFromUrl(embedUrl, prefix = "$name - ", headers = headers)
-        name.contains("streamwish", true) -> streamwishExtractor.videosFromUrl(embedUrl, prefix = "$name - ")
-        else -> chillxExtractor.videoFromUrl(embedUrl, referer = baseUrl, prefix = "$name - ")
-    }
+    private fun hikiExtraction(url: String, prefix: String): List<Video> {
+        val hikiMirror = preferences.getString(PREF_HIKI_KEY, PREF_HIKI_DEFAULT)!!
 
-    override fun videoListSelector() = ".server-item:has(a[onclick~=getEmbed])"
+        if (hikiMirror == "hiki") {
+            return buzzheavierExtractor.videosFromUrl(url, prefix, proxyUrl)
+        }
+        val id = url.toHttpUrl().pathSegments[0]
+        val videoUrl = "https://$hikiMirror/$id"
+        return buzzheavierExtractor.videosFromUrl(videoUrl, prefix)
+    }
 
     override fun List<Video>.sort(): List<Video> {
         val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
+        val type = preferences.getString(PREF_TYPE_KEY, PREF_TYPE_DEFAULT)!!
+        val hoster = preferences.getString(PREF_HOSTER_KEY, PREF_HOSTER_DEFAULT)!!
 
         return sortedWith(
             compareBy(
+                { it.quality.startsWith(type) },
                 { it.quality.contains(quality) },
                 { QUALITY_REGEX.find(it.quality)?.groupValues?.get(1)?.toIntOrNull() ?: 0 },
+                { it.quality.contains(hoster, true) },
             ),
         ).reversed()
     }
 
-    override fun videoFromElement(element: Element): Video =
-        throw UnsupportedOperationException()
-
-    override fun videoUrlParse(document: Document): String =
-        throw UnsupportedOperationException()
-
     // ============================= Utilities ==============================
 
-    @Serializable
-    class HtmlResponseDto(
-        val html: String,
-        val page: PageDto? = null,
-    ) {
-        fun toHtml(baseUrl: String): Document = Jsoup.parseBodyFragment(html, baseUrl)
-
-        @Serializable
-        class PageDto(
-            val totalPages: Int,
-        )
-    }
-
     companion object {
         private val QUALITY_REGEX = Regex("""(\d+)p""")
 
+        private const val PREF_ENGLISH_TITLE_KEY = "preferred_title_lang"
+        private const val PREF_ENGLISH_TITLE_DEFAULT = true
+
         private const val PREF_QUALITY_KEY = "preferred_quality"
         private const val PREF_QUALITY_DEFAULT = "1080"
         private val PREF_QUALITY_VALUES = arrayOf("1080", "720", "480", "360")
         private val PREF_QUALITY_ENTRIES = PREF_QUALITY_VALUES.map {
             "${it}p"
         }.toTypedArray()
+
+        private val TYPE_LIST = arrayOf("[SUB] ", "[DUB] ", "[MULTI AUDIO] ", "[HARD-SUB] ")
+        private const val PREF_TYPE_KEY = "pref_type"
+        private const val PREF_TYPE_DEFAULT = ""
+        private val PREF_TYPE_VALUES = arrayOf("") + TYPE_LIST
+        private val PREF_TYPE_ENTRIES = arrayOf("Any") + TYPE_LIST
+
+        private val HOSTER_LIST = arrayOf("Streamwish", "Filemoon", "SV", "PlayerX", "Hiki")
+        private const val PREF_HOSTER_KEY = "pref_hoster"
+        private const val PREF_HOSTER_DEFAULT = ""
+        private val PREF_HOSTER_VALUES = arrayOf("") + HOSTER_LIST
+        private val PREF_HOSTER_ENTRIES = arrayOf("Any") + HOSTER_LIST
+
+        private const val PREF_HIKI_KEY = "preferred_hiki_mirror"
+        private const val PREF_HIKI_DEFAULT = "hiki"
+        private val PREF_HIKI_VALUES = arrayOf("hiki", "buzzheavier.com", "bzzhr.co", "fuckingfast.net")
+        private val PREF_HIKI_ENTRIES = PREF_HIKI_VALUES
+
+        // Provider
+        private const val PREF_PROVIDER_KEY = "provider_selection"
+        private val PREF_PROVIDERS = arrayOf("Streamwish", "Filemoon", "SV", "PlayerX", "Hiki")
+
+        private val PREF_PROVIDERS_VALUE = arrayOf("streamwish", "filemoon", "sv", "playerx", "hiki")
+
+        private val PREF_DEFAULT_PROVIDERS_VALUE = arrayOf("streamwish", "filemoon", "sv", "playerx", "hiki")
+
+        private val PREF_PROVIDERS_DEFAULT = PREF_DEFAULT_PROVIDERS_VALUE.toSet()
     }
 
     // ============================== Settings ==============================
 
+    private val SharedPreferences.getTitleLang
+        get() = getBoolean(PREF_ENGLISH_TITLE_KEY, PREF_ENGLISH_TITLE_DEFAULT)
+
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        SwitchPreferenceCompat(screen.context).apply {
+            key = PREF_ENGLISH_TITLE_KEY
+            title = "Prefer english titles"
+            setDefaultValue(PREF_ENGLISH_TITLE_DEFAULT)
+        }.also(screen::addPreference)
+
         ListPreference(screen.context).apply {
             key = PREF_QUALITY_KEY
             title = "Preferred quality"
@@ -407,13 +268,44 @@ class Hikari : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
             entryValues = PREF_QUALITY_VALUES
             setDefaultValue(PREF_QUALITY_DEFAULT)
             summary = "%s"
-
-            setOnPreferenceChangeListener { _, newValue ->
-                val selected = newValue as String
-                val index = findIndexOfValue(selected)
-                val entry = entryValues[index] as String
-                preferences.edit().putString(key, entry).commit()
-            }
         }.also(screen::addPreference)
+
+        ListPreference(screen.context).apply {
+            key = PREF_TYPE_KEY
+            title = "Preferred type"
+            entries = PREF_TYPE_ENTRIES
+            entryValues = PREF_TYPE_VALUES
+            setDefaultValue(PREF_TYPE_DEFAULT)
+            summary = "%s"
+        }.also(screen::addPreference)
+
+        ListPreference(screen.context).apply {
+            key = PREF_HOSTER_KEY
+            title = "Preferred hoster"
+            entries = PREF_HOSTER_ENTRIES
+            entryValues = PREF_HOSTER_VALUES
+            setDefaultValue(PREF_HOSTER_DEFAULT)
+            summary = "%s"
+        }.also(screen::addPreference)
+
+        MultiSelectListPreference(screen.context).apply {
+            key = PREF_PROVIDER_KEY
+            title = "Enable/Disable Video Providers"
+            entries = PREF_PROVIDERS
+            entryValues = PREF_PROVIDERS_VALUE
+            setDefaultValue(PREF_PROVIDERS_DEFAULT)
+        }.also(screen::addPreference)
+
+        ListPreference(screen.context).apply {
+            key = PREF_HIKI_KEY
+            title = "Hiki provider mirrors"
+            entries = PREF_HIKI_ENTRIES
+            entryValues = PREF_HIKI_VALUES
+            setDefaultValue(PREF_HIKI_DEFAULT)
+            summary = "%s"
+        }.also(screen::addPreference)
+
+        FilemoonExtractor.addSubtitlePref(screen)
+        SavefileExtractor.addSubtitlePref(screen)
     }
 }
diff --git a/src/all/javgg/build.gradle b/src/all/javgg/build.gradle
index c339dcad..940ad754 100644
--- a/src/all/javgg/build.gradle
+++ b/src/all/javgg/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'JavGG'
     extClass = '.Javgg'
-    extVersionCode = 5
+    extVersionCode = 7
     isNsfw = true
 }
 
diff --git a/src/all/javguru/build.gradle b/src/all/javguru/build.gradle
index e25b3386..37177624 100644
--- a/src/all/javguru/build.gradle
+++ b/src/all/javguru/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Jav Guru'
     extClass = '.JavGuru'
-    extVersionCode = 26
+    extVersionCode = 28
     isNsfw = true
 }
 
diff --git a/src/all/lmanime/build.gradle b/src/all/lmanime/build.gradle
index 2fda6918..6f46c51b 100644
--- a/src/all/lmanime/build.gradle
+++ b/src/all/lmanime/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.LMAnime'
     themePkg = 'animestream'
     baseUrl = 'https://lmanime.com'
-    overrideVersionCode = 9
+    overrideVersionCode = 11
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/all/missav/build.gradle b/src/all/missav/build.gradle
index 8bc253d8..03f809a8 100644
--- a/src/all/missav/build.gradle
+++ b/src/all/missav/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'MissAV'
     extClass = '.MissAV'
-    extVersionCode = 15
+    extVersionCode = 16
     isNsfw = true
 }
 
diff --git a/src/all/newgrounds/build.gradle b/src/all/newgrounds/build.gradle
new file mode 100644
index 00000000..b835c961
--- /dev/null
+++ b/src/all/newgrounds/build.gradle
@@ -0,0 +1,8 @@
+ext {
+    extName = 'Newgrounds'
+    extClass = '.NewGrounds'
+    extVersionCode = 1
+    isNsfw = true
+}
+
+apply from: "$rootDir/common.gradle"
diff --git a/src/all/newgrounds/res/mipmap-hdpi/ic_launcher.png b/src/all/newgrounds/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000..430ff8b3
Binary files /dev/null and b/src/all/newgrounds/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/all/newgrounds/res/mipmap-mdpi/ic_launcher.png b/src/all/newgrounds/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000..ada390ae
Binary files /dev/null and b/src/all/newgrounds/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/all/newgrounds/res/mipmap-xhdpi/ic_launcher.png b/src/all/newgrounds/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000..90138a7a
Binary files /dev/null and b/src/all/newgrounds/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/all/newgrounds/res/mipmap-xxhdpi/ic_launcher.png b/src/all/newgrounds/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000..ddd9259b
Binary files /dev/null and b/src/all/newgrounds/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/all/newgrounds/res/mipmap-xxxhdpi/ic_launcher.png b/src/all/newgrounds/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 00000000..de547fdd
Binary files /dev/null and b/src/all/newgrounds/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/all/newgrounds/src/eu/kanade/tachiyomi/animeextension/all/newgrounds/DateUtils.kt b/src/all/newgrounds/src/eu/kanade/tachiyomi/animeextension/all/newgrounds/DateUtils.kt
new file mode 100644
index 00000000..1da32290
--- /dev/null
+++ b/src/all/newgrounds/src/eu/kanade/tachiyomi/animeextension/all/newgrounds/DateUtils.kt
@@ -0,0 +1,13 @@
+import java.text.ParseException
+import java.text.SimpleDateFormat
+
+@Suppress("NOTHING_TO_INLINE")
+inline fun SimpleDateFormat.tryParse(date: String?): Long {
+    date ?: return 0L
+
+    return try {
+        parse(date)?.time ?: 0L
+    } catch (_: ParseException) {
+        0L
+    }
+}
diff --git a/src/all/newgrounds/src/eu/kanade/tachiyomi/animeextension/all/newgrounds/NewGrounds.kt b/src/all/newgrounds/src/eu/kanade/tachiyomi/animeextension/all/newgrounds/NewGrounds.kt
new file mode 100644
index 00000000..500c0406
--- /dev/null
+++ b/src/all/newgrounds/src/eu/kanade/tachiyomi/animeextension/all/newgrounds/NewGrounds.kt
@@ -0,0 +1,545 @@
+package eu.kanade.tachiyomi.animeextension.all.newgrounds
+
+import android.app.Application
+import android.os.Handler
+import android.os.Looper
+import android.widget.Toast
+import androidx.preference.CheckBoxPreference
+import androidx.preference.ListPreference
+import androidx.preference.MultiSelectListPreference
+import androidx.preference.PreferenceScreen
+import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.AnimesPage
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.ParsedAnimeHttpSource
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.FormBody
+import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.Request
+import okhttp3.Response
+import org.json.JSONObject
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+import tryParse
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import java.text.SimpleDateFormat
+import java.util.Locale
+
+private const val PAGE_SIZE = 20
+
+class NewGrounds : ParsedAnimeHttpSource(), ConfigurableAnimeSource {
+
+    override val lang = "all"
+    override val baseUrl = "https://www.newgrounds.com"
+    override val name = "Newgrounds"
+    override val supportsLatest = true
+
+    private val dateFormat = SimpleDateFormat("MMM dd, yyyy", Locale.ENGLISH)
+
+    private val preferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    private val context = Injekt.get<Application>()
+    private val handler by lazy { Handler(Looper.getMainLooper()) }
+
+    private val videoListHeaders by lazy {
+        headers.newBuilder()
+            .add("Accept", "application/json, text/javascript, */*; q=0.01")
+            .add("X-Requested-With", "XMLHttpRequest")
+            .add("Referer", baseUrl)
+            .build()
+    }
+
+    // Latest
+
+    private fun getLatestSection(): String {
+        return preferences.getString("LATEST", PREF_SECTIONS["Latest"])!!
+    }
+
+    override fun latestUpdatesRequest(page: Int): Request {
+        val offset = (page - 1) * PAGE_SIZE
+        return GET("$baseUrl/${getLatestSection()}?offset=$offset", headers)
+    }
+
+    override fun latestUpdatesNextPageSelector(): String = "#load-more-items a"
+
+    override fun latestUpdatesParse(response: Response): AnimesPage {
+        checkAdultContentFiltered(response.headers)
+        return super.latestUpdatesParse(response)
+    }
+
+    override fun latestUpdatesSelector(): String = animeSelector(getLatestSection())
+
+    override fun latestUpdatesFromElement(element: Element): SAnime {
+        return animeFromElement(element, getLatestSection())
+    }
+
+    // Browse
+
+    private fun getPopularSection(): String {
+        return preferences.getString("POPULAR", PREF_SECTIONS["Popular"])!!
+    }
+
+    override fun popularAnimeRequest(page: Int): Request {
+        val offset = (page - 1) * PAGE_SIZE
+        return GET("$baseUrl/${getPopularSection()}?offset=$offset", headers)
+    }
+
+    override fun popularAnimeNextPageSelector(): String = "#load-more-items a"
+
+    override fun popularAnimeParse(response: Response): AnimesPage {
+        checkAdultContentFiltered(response.headers)
+        return super.popularAnimeParse(response)
+    }
+
+    override fun popularAnimeSelector(): String = animeSelector(getPopularSection())
+
+    override fun popularAnimeFromElement(element: Element): SAnime {
+        return animeFromElement(element, getPopularSection())
+    }
+
+    // Search
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        val searchUrl = "$baseUrl/search/conduct/movies".toHttpUrl().newBuilder()
+            .addQueryParameter("page", page.toString())
+
+        if (query.isNotEmpty()) searchUrl.addQueryParameter("terms", query)
+
+        filters.findInstance<MatchAgainstFilter>().ifFilterSet {
+            searchUrl.addQueryParameter("match", MATCH_AGAINST.values.elementAt(it.state))
+        }
+        filters.findInstance<TuningFilterGroup>()?.state
+            ?.findInstance<TuningExactFilter>().ifFilterSet {
+                searchUrl.addQueryParameter("exact", "1")
+            }
+        filters.findInstance<TuningFilterGroup>()?.state
+            ?.findInstance<TuningAnyFilter>().ifFilterSet {
+                searchUrl.addQueryParameter("any", "1")
+            }
+        filters.findInstance<AuthorFilter>().ifFilterSet {
+            searchUrl.addQueryParameter("user", it.state)
+        }
+        filters.findInstance<GenreFilter>().ifFilterSet {
+            searchUrl.addQueryParameter("genre", GENRE.values.elementAt(it.state))
+        }
+        filters.findInstance<LengthFilterGroup>()?.state
+            ?.findInstance<MinLengthFilter>().ifFilterSet {
+                searchUrl.addQueryParameter("min_length", it.state)
+            }
+        filters.findInstance<LengthFilterGroup>()?.state
+            ?.findInstance<MaxLengthFilter>().ifFilterSet {
+                searchUrl.addQueryParameter("max_length", it.state)
+            }
+        filters.findInstance<FrontpagedFilter>().ifFilterSet {
+            searchUrl.addQueryParameter("frontpaged", "1")
+        }
+        filters.findInstance<DateFilterGroup>()?.state
+            ?.findInstance<AfterDateFilter>().ifFilterSet {
+                searchUrl.addQueryParameter("after", it.state)
+            }
+        filters.findInstance<DateFilterGroup>()?.state
+            ?.findInstance<BeforeDateFilter>().ifFilterSet {
+                searchUrl.addQueryParameter("before", it.state)
+            }
+        filters.findInstance<SortingFilter>().ifFilterSet {
+            if (it.state?.index != 0) {
+                val sortOption = SORTING.values.elementAt(it.state?.index ?: return@ifFilterSet)
+                val direction = if (it.state?.ascending == true) "asc" else "desc"
+                searchUrl.addQueryParameter(
+                    "sort",
+                    "$sortOption-$direction",
+                )
+            }
+        }
+        filters.findInstance<TagsFilter>().ifFilterSet {
+            searchUrl.addQueryParameter("tags", it.state)
+        }
+
+        return GET(searchUrl.build(), headers)
+    }
+
+    override fun searchAnimeNextPageSelector(): String = "#results-load-more"
+
+    override fun searchAnimeParse(response: Response): AnimesPage {
+        checkAdultContentFiltered(response.headers)
+        return super.searchAnimeParse(response)
+    }
+
+    override fun searchAnimeSelector(): String = "ul.itemlist li:not(#results-load-more) a"
+
+    override fun searchAnimeFromElement(element: Element): SAnime = animeFromListElement(element)
+
+    // Etc.
+
+    override fun animeDetailsParse(document: Document): SAnime {
+        fun getStarRating(): String {
+            val score: Double = document.selectFirst("#score_number")?.text()?.toDouble() ?: 0.0
+            val fullStars = score.toInt()
+            val hasHalfStar = (score % 1) >= 0.5
+            val totalStars = if (hasHalfStar) fullStars + 1 else fullStars
+            val emptyStars = 5 - totalStars
+
+            return "✪".repeat(fullStars) + (if (hasHalfStar) "✪" else "") + "⬤".repeat(emptyStars) + " ($score)"
+        }
+
+        fun getAdultRating(): String {
+            val rating = document.selectFirst("#embed_header h2")!!.className().substringAfter("rated-")
+            return when (rating) {
+                "e" -> "🟩 Everyone"
+                "t" -> "🟦 Ages 13+"
+                "m" -> "🟪 Ages 17+"
+                "a" -> "🟥 Adults Only"
+                else -> "❓"
+            }
+        }
+
+        fun getStats(): String {
+            val statsElement = document.selectFirst("#sidestats > dl:first-of-type")
+            val views = statsElement?.selectFirst("dd:first-of-type")?.text() ?: "?"
+            val faves = statsElement?.selectFirst("dd:nth-of-type(2)")?.text() ?: "?"
+            val votes = statsElement?.selectFirst("dd:nth-of-type(3)")?.text() ?: "?"
+
+            return "👀 $views  |  ❤️ $faves  |  🗳️ $votes"
+        }
+
+        fun prepareDescription(): String {
+            val descriptionElements = preferences.getStringSet("DESCRIPTION_ELEMENTS", setOf("short"))
+                ?: return ""
+
+            val shortDescription = document.selectFirst("meta[itemprop=\"description\"]")?.attr("content")
+            val longDescription = document.selectFirst("#author_comments")?.wholeText()
+            val statsSummary = "${getAdultRating()}  |  ${getStarRating()}  |  ${getStats()}"
+
+            val description = StringBuilder()
+
+            if (descriptionElements.contains("short")) {
+                description.append(shortDescription)
+            }
+
+            if (descriptionElements.contains("long")) {
+                description.append("\n\n" + longDescription)
+            }
+
+            if (descriptionElements.contains("stats") || preferences.getBoolean("STATS_SUMMARY", false)) {
+                description.append("\n\n" + statsSummary)
+            }
+
+            return description.toString()
+        }
+
+        val relatedPlaylistElement = document.selectFirst("div[id^=\"related_playlists\"] ")
+        val relatedPlaylistUrl = relatedPlaylistElement?.selectFirst("a:not([id^=\"related_playlists\"])")?.absUrl("href")
+        val relatedPlaylistName = relatedPlaylistElement?.selectFirst(".detail-title h4")?.text()
+        val isPartOfSeries = relatedPlaylistUrl?.startsWith("$baseUrl/series") ?: false
+
+        return SAnime.create().apply {
+            title = relatedPlaylistName.takeIf { isPartOfSeries }
+                ?: document.selectFirst("h2[itemprop=\"name\"]")!!.text()
+            description = prepareDescription()
+            author = document.selectFirst(".authorlinks > div:first-of-type .item-details-main")?.text()
+            artist = document.select(".authorlinks > div:not(:first-of-type) .item-details-main").joinToString {
+                it.text()
+            }
+            thumbnail_url = document.selectFirst("meta[itemprop=\"thumbnailUrl\"]")?.absUrl("content")
+            genre = document.select(".tags li a").joinToString { it.text() } + document.selectFirst("div[id^=\"genre-view\"] dt")?.text()
+            status = SAnime.ONGOING.takeIf { isPartOfSeries } ?: SAnime.COMPLETED
+        }
+    }
+
+    override fun episodeListSelector(): String = throw UnsupportedOperationException("Not Used")
+
+    override fun episodeFromElement(element: Element): SEpisode = throw UnsupportedOperationException("Not Used")
+
+    override suspend fun getEpisodeList(anime: SAnime): List<SEpisode> {
+        val response = client.newCall(GET("${baseUrl}${anime.url}", headers)).execute()
+        val document = response.asJsoup()
+
+        val relatedPlaylistUrl = document.selectFirst("div[id^=\"related_playlists\"] a:not([id^=\"related_playlists\"])")?.absUrl("href")
+        val isPartOfSeries = relatedPlaylistUrl?.startsWith("$baseUrl/series") ?: false
+
+        val episodes = if (isPartOfSeries) {
+            val response2 = client.newCall(GET(relatedPlaylistUrl!!, headers)).execute()
+            val document2 = response2.asJsoup()
+            parseEpisodeList(document2)
+        } else {
+            val dateString = document.selectFirst("#sidestats  > dl:nth-of-type(2) > dd:first-of-type")?.text()
+
+            return listOf(
+                SEpisode.create().apply {
+                    episode_number = 1f
+                    date_upload = dateFormat.tryParse(dateString)
+                    name = document.selectFirst("meta[name=\"title\"]")!!.attr("content")
+                    setUrlWithoutDomain("$baseUrl${anime.url.replace("/view/","/video/")}")
+                },
+            )
+        }
+
+        return episodes
+    }
+
+    override fun episodeListRequest(anime: SAnime): Request = throw UnsupportedOperationException()
+
+    override fun episodeListParse(response: Response): List<SEpisode> = throw UnsupportedOperationException()
+
+    private fun parseEpisodeList(document: Document): List<SEpisode> {
+        val ids = document.select("li.visual-link-container").map { it.attr("data-visual-link") }
+        val formBody = FormBody.Builder()
+            .add("ids", ids.toString())
+            .add("component_params[include_author]", "1")
+            .add("include_all_suitabilities", "0")
+            .add("isAjaxRequest", "1")
+            .build()
+
+        val request = Request.Builder()
+            .url("$baseUrl/visual-links-fetch")
+            .post(formBody)
+            .headers(headers)
+            .build()
+
+        val response = client.newCall(request).execute()
+
+        val jsonObject = JSONObject(response.body.string())
+        val episodes = mutableListOf<SEpisode>()
+
+        val simples = jsonObject.getJSONObject("simples")
+        var index = 1
+        for (key in simples.keys()) {
+            val subObject = simples.getJSONObject(key)
+
+            for (episodeKey in subObject.keys()) {
+                val episodeData = subObject.getJSONObject(episodeKey)
+                val uploaderData = episodeData.getJSONObject("user")
+
+                val episode = SEpisode.create().apply {
+                    episode_number = index.toFloat()
+                    name = episodeData.getString("title")
+                    scanlator = uploaderData.getString("user_name")
+                    setUrlWithoutDomain("$baseUrl/portal/video/${episodeData.getString("id")}")
+                }
+
+                episodes.add(episode)
+                index++
+            }
+        }
+
+        return episodes.reversed()
+    }
+
+    override fun videoListRequest(episode: SEpisode): Request = GET("$baseUrl${episode.url}", videoListHeaders)
+
+    override fun videoListParse(response: Response): List<Video> {
+        val responseBody = response.body.string()
+        val json = JSONObject(responseBody)
+        val sources = json.getJSONObject("sources")
+
+        val videos = mutableListOf<Video>()
+
+        for (quality in sources.keys()) {
+            val qualityArray = sources.getJSONArray(quality)
+            for (i in 0 until qualityArray.length()) {
+                val videoObject = qualityArray.getJSONObject(i)
+                val videoUrl = videoObject.getString("src")
+
+                videos.add(
+                    Video(
+                        url = videoUrl,
+                        quality = quality,
+                        videoUrl = videoUrl,
+                        headers = headers,
+                    ),
+                )
+            }
+        }
+
+        return videos
+    }
+
+    override fun videoListSelector(): String = throw UnsupportedOperationException("Not Used")
+
+    override fun videoFromElement(element: Element): Video = throw UnsupportedOperationException("Not Used")
+
+    override fun videoUrlParse(document: Document): String = throw UnsupportedOperationException("Not Used")
+
+    // ============================== Filters ===============================
+
+    override fun getFilterList(): AnimeFilterList = AnimeFilterList(
+        SortingFilter(),
+        MatchAgainstFilter(),
+        TuningFilterGroup(),
+        GenreFilter(),
+        AuthorFilter(),
+        TagsFilter(),
+        LengthFilterGroup(),
+        DateFilterGroup(),
+        FrontpagedFilter(),
+        AnimeFilter.Separator(),
+        AnimeFilter.Header("Age rating: to change age rating open WebView and in Movies tab click on 🟩🟦🟪🟥 icons on the right. Then refresh search."), // uses ng_user0 cookie
+    )
+
+    // ============================ Preferences =============================
+    /*
+        According to the labels on the website:
+        Featured    -> /movies/featured
+        Latest      -> /movies/browse
+        Popular     -> /movies/popular
+        Your Feed   -> /social/feeds/show/favorite-artists-movies
+        Under Judgement -> /movies/browse?interval=all&artist-type=unjudged
+     */
+
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        ListPreference(screen.context).apply {
+            key = "POPULAR"
+            title = "Popular section content"
+            entries = PREF_SECTIONS.keys.toTypedArray()
+            entryValues = PREF_SECTIONS.values.toTypedArray()
+            setDefaultValue(PREF_SECTIONS["Popular"])
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                preferences.edit().putString(key, selected).commit()
+            }
+        }.also(screen::addPreference)
+
+        ListPreference(screen.context).apply {
+            key = "LATEST"
+            title = "Latest section content"
+            entries = PREF_SECTIONS.keys.toTypedArray()
+            entryValues = PREF_SECTIONS.values.toTypedArray()
+            setDefaultValue(PREF_SECTIONS["Latest"])
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selected = newValue as String
+                preferences.edit().putString(key, selected).commit()
+            }
+        }.also(screen::addPreference)
+
+        MultiSelectListPreference(screen.context).apply {
+            key = "DESCRIPTION_ELEMENTS"
+            title = "Description elements"
+            entries = arrayOf("Short description", "Long description (author comments)", "Stats (score, favs, views)")
+            entryValues = arrayOf("short", "long", "stats")
+            setDefaultValue(setOf("short", "stats"))
+            summary = "Elements to be included in description"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                val selectedItems = newValue as Set<*>
+                preferences.edit().putStringSet(key, selectedItems as Set<String>).apply()
+                true
+            }
+        }.also(screen::addPreference)
+
+        CheckBoxPreference(screen.context).apply {
+            key = "PROMPT_CONTENT_FILTERED"
+            title = "Prompt to log in"
+            setDefaultValue(true)
+            summary = "Show toast when user is not logged in and therefore adult content is not accessible"
+        }.also(screen::addPreference)
+    }
+
+    // ========================== Helper Functions ==========================
+
+    /**
+     * Chooses an extraction technique for anime information, based on section selected in Preferences
+     */
+    private fun animeFromElement(element: Element, section: String): SAnime {
+        return if (section == PREF_SECTIONS["Your Feed"]) {
+            animeFromFeedElement(element)
+        } else {
+            animeFromGridElement(element)
+        }
+    }
+
+    /**
+     * Extracts anime information from element of grid-like list typical for /popular, /browse or /featured
+     */
+    private fun animeFromGridElement(element: Element): SAnime = SAnime.create().apply {
+        title = element.selectFirst(".card-title h4")!!.text()
+        author = element.selectFirst(".card-title span")?.text()?.replace("By ", "")
+        description = element.selectFirst("a")?.attr("title")
+        thumbnail_url = element.selectFirst("img")?.absUrl("src")
+        setUrlWithoutDomain(element.selectFirst("a")!!.absUrl("href"))
+    }
+
+    /**
+     * Extracts anime information from element of list returned in Your Feed
+     */
+    private fun animeFromFeedElement(element: Element): SAnime = SAnime.create().apply {
+        title = element.selectFirst(".detail-title h4")!!.text()
+        author = element.selectFirst(".detail-title strong")?.text()
+        description = element.selectFirst(".detail-description")?.text()
+        thumbnail_url = element.selectFirst(".item-icon img")?.absUrl("src")
+        setUrlWithoutDomain(element.selectFirst("a")!!.absUrl("href"))
+    }
+
+    /**
+     * Extracts anime information from element of list typical for /search or /series
+     */
+    private fun animeFromListElement(element: Element): SAnime = SAnime.create().apply {
+        title = element.selectFirst(".detail-title > h4")!!.text()
+        author = element.selectFirst(".detail-title > span > strong")?.text()
+        description = element.selectFirst(".detail-description")?.text()
+        thumbnail_url = element.selectFirst(".item-icon img")?.absUrl("src")
+        setUrlWithoutDomain(element.selectFirst("a")!!.absUrl("href"))
+    }
+
+    /**
+     * Returns CSS selector for anime, based on the section selected in Preferences
+     */
+    private fun animeSelector(section: String): String {
+        return if (section == PREF_SECTIONS["Your Feed"]) {
+            "a.item-portalsubmission"
+        } else {
+            "a.inline-card-portalsubmission"
+        }
+    }
+
+    /**
+     * Checks if cookie with username is present in response headers.
+     * If cookie is missing: displays a toast with information.
+     */
+    private fun checkAdultContentFiltered(headers: Headers) {
+        val usernameCookie: Boolean = headers.values("Set-Cookie").any { it.startsWith("NG_GG_username=") }
+        if (usernameCookie) return // user already logged in
+
+        val shouldPrompt = preferences.getBoolean("PROMPT_CONTENT_FILTERED", true)
+        if (shouldPrompt) {
+            handler.post {
+                Toast.makeText(context, "Log in via WebView to include adult content", Toast.LENGTH_SHORT).show()
+            }
+        }
+    }
+
+    private inline fun <reified T> Iterable<*>.findInstance() = find { it is T } as? T
+
+    /**
+     * Executes the given [action] if the filter is set to a meaningful value.
+     *
+     *  @param action A function to execute if the filter is set.
+     */
+    private inline fun <T> T?.ifFilterSet(action: (T) -> Unit) where T : AnimeFilter<*> {
+        val state = this?.state
+        if (this != null && state != null && state != "" && state != 0 && state != false) {
+            action(this)
+        }
+    }
+
+    companion object {
+        private val PREF_SECTIONS = mapOf(
+            "Featured" to "movies/featured",
+            "Latest" to "movies/browse",
+            "Popular" to "movies/popular",
+            "Your Feed" to "social/feeds/show/favorite-artists-movies",
+        )
+    }
+}
diff --git a/src/all/newgrounds/src/eu/kanade/tachiyomi/animeextension/all/newgrounds/NewGroundsFilters.kt b/src/all/newgrounds/src/eu/kanade/tachiyomi/animeextension/all/newgrounds/NewGroundsFilters.kt
new file mode 100644
index 00000000..1ead1c08
--- /dev/null
+++ b/src/all/newgrounds/src/eu/kanade/tachiyomi/animeextension/all/newgrounds/NewGroundsFilters.kt
@@ -0,0 +1,75 @@
+package eu.kanade.tachiyomi.animeextension.all.newgrounds
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+
+class MatchAgainstFilter : AnimeFilter.Select<String>("Match against", MATCH_AGAINST.keys.toTypedArray(), 0)
+
+class TuningExactFilter : AnimeFilter.CheckBox("exact matches", false)
+class TuningAnyFilter : AnimeFilter.CheckBox("match any words", false)
+class TuningFilterGroup : AnimeFilter.Group<AnimeFilter.CheckBox>(
+    "Tuning",
+    listOf(
+        TuningExactFilter(),
+        TuningAnyFilter(),
+    ),
+)
+
+class AuthorFilter : AnimeFilter.Text("Author")
+
+class GenreFilter : AnimeFilter.Select<String>("Genre", GENRE.keys.toTypedArray())
+
+class MinLengthFilter : AnimeFilter.Text("Min Length")
+class MaxLengthFilter : AnimeFilter.Text("Max Length")
+class LengthFilterGroup : AnimeFilter.Group<AnimeFilter.Text>(
+    "Length (00:00:00)",
+    listOf(
+        MinLengthFilter(),
+        MaxLengthFilter(),
+    ),
+)
+
+class FrontpagedFilter : AnimeFilter.CheckBox("Frontpaged?", false)
+
+class AfterDateFilter : AnimeFilter.Text("On, or after")
+class BeforeDateFilter : AnimeFilter.Text("Before")
+class DateFilterGroup : AnimeFilter.Group<AnimeFilter.Text>(
+    "Date (YYYY-MM-DD)",
+    listOf(
+        AfterDateFilter(),
+        BeforeDateFilter(),
+    ),
+)
+
+class SortingFilter() : AnimeFilter.Sort("Sort by", SORTING.keys.toTypedArray(), Selection(0, true))
+
+class TagsFilter() : AnimeFilter.Text("Tags (comma separated)")
+
+// ===================================================================
+val MATCH_AGAINST = mapOf(
+    "Default" to "",
+    "title / description / tags / author" to "tdtu",
+    "title / description / tags" to "tdt",
+    "title / description" to "td",
+    "title" to "t",
+    "description" to "d",
+)
+
+val GENRE = mapOf(
+    "All" to "",
+    "Action" to "45",
+    "Comedy - Original" to "60",
+    "Comedy - Parody" to "61",
+    "Drama" to "47",
+    "Experimental" to "49",
+    "Informative" to "48",
+    "Music Video" to "50",
+    "Other" to "51",
+    "Spam" to "55",
+)
+
+val SORTING = mapOf(
+    "Default (Relevance)" to "relevance",
+    "Date" to "date",
+    "Score" to "score",
+    "Views" to "views",
+)
diff --git a/src/all/sudatchi/build.gradle b/src/all/sudatchi/build.gradle
index 9be5a3f8..929db6cf 100644
--- a/src/all/sudatchi/build.gradle
+++ b/src/all/sudatchi/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Sudatchi'
     extClass = '.Sudatchi'
-    extVersionCode = 12
+    extVersionCode = 13
     isNsfw = true
 }
 
diff --git a/src/all/supjav/build.gradle b/src/all/supjav/build.gradle
index 21cbb8f9..9b310234 100644
--- a/src/all/supjav/build.gradle
+++ b/src/all/supjav/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'SupJav'
     extClass = '.SupJavFactory'
-    extVersionCode = 14
+    extVersionCode = 16
     isNsfw = true
 }
 
diff --git a/src/all/torrentioanime/build.gradle b/src/all/torrentioanime/build.gradle
index 258789ef..2245029d 100644
--- a/src/all/torrentioanime/build.gradle
+++ b/src/all/torrentioanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Torrentio Anime (Torrent / Debrid)'
     extClass = '.Torrentio'
-    extVersionCode = 15
+    extVersionCode = 16
     containsNsfw = false
 }
 
diff --git a/src/all/torrentioanime/src/eu/kanade/tachiyomi/animeextension/all/torrentioanime/Torrentio.kt b/src/all/torrentioanime/src/eu/kanade/tachiyomi/animeextension/all/torrentioanime/Torrentio.kt
index 021cf57f..2b30443a 100644
--- a/src/all/torrentioanime/src/eu/kanade/tachiyomi/animeextension/all/torrentioanime/Torrentio.kt
+++ b/src/all/torrentioanime/src/eu/kanade/tachiyomi/animeextension/all/torrentioanime/Torrentio.kt
@@ -310,7 +310,7 @@ class Torrentio : ConfigurableAnimeSource, AnimeHttpSource() {
         val aniZipResponse = json.decodeFromString<AniZipResponse>(responseString)
 
         return when (aniZipResponse.mappings?.type) {
-            "TV" -> {
+            "TV", "ONA", "OVA" -> {
                 aniZipResponse.episodes
                     ?.let { episodes ->
                         if (preferences.getBoolean(UPCOMING_EP_KEY, UPCOMING_EP_DEFAULT)) {
diff --git a/src/ar/anime4up/build.gradle b/src/ar/anime4up/build.gradle
index b6223b2b..24042cd1 100644
--- a/src/ar/anime4up/build.gradle
+++ b/src/ar/anime4up/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Anime4up'
     extClass = '.Anime4Up'
-    extVersionCode = 62
+    extVersionCode = 64
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ar/animeblkom/build.gradle b/src/ar/animeblkom/build.gradle
index b6415201..7c79265b 100644
--- a/src/ar/animeblkom/build.gradle
+++ b/src/ar/animeblkom/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Anime Blkom'
     extClass = '.AnimeBlkom'
-    extVersionCode = 18
+    extVersionCode = 19
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ar/animelek/build.gradle b/src/ar/animelek/build.gradle
index e4d48d78..335a1d37 100644
--- a/src/ar/animelek/build.gradle
+++ b/src/ar/animelek/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AnimeLek'
     extClass = '.AnimeLek'
-    extVersionCode = 31
+    extVersionCode = 32
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ar/animerco/build.gradle b/src/ar/animerco/build.gradle
index 5d6cf123..00f0afde 100644
--- a/src/ar/animerco/build.gradle
+++ b/src/ar/animerco/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Animerco'
     extClass = '.Animerco'
-    extVersionCode = 41
+    extVersionCode = 43
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ar/arabseed/build.gradle b/src/ar/arabseed/build.gradle
index 7a932843..3d003221 100644
--- a/src/ar/arabseed/build.gradle
+++ b/src/ar/arabseed/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Arab Seed'
     extClass = '.ArabSeed'
-    extVersionCode = 17
+    extVersionCode = 19
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ar/asia2tv/build.gradle b/src/ar/asia2tv/build.gradle
index 52ee7f8a..acfad40f 100644
--- a/src/ar/asia2tv/build.gradle
+++ b/src/ar/asia2tv/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'asia2tv'
     extClass = '.Asia2TV'
-    extVersionCode = 22
+    extVersionCode = 24
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ar/cimaleek/build.gradle b/src/ar/cimaleek/build.gradle
index 6a6a7d1b..ee656c81 100644
--- a/src/ar/cimaleek/build.gradle
+++ b/src/ar/cimaleek/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Cimaleek'
     extClass = '.Cimaleek'
-    extVersionCode = 3
+    extVersionCode = 4
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ar/egydead/build.gradle b/src/ar/egydead/build.gradle
index 42a1e788..3527474b 100644
--- a/src/ar/egydead/build.gradle
+++ b/src/ar/egydead/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Egy Dead'
     extClass = '.EgyDead'
-    extVersionCode = 17
+    extVersionCode = 19
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ar/faselhd/build.gradle b/src/ar/faselhd/build.gradle
index 8881dcbd..7b5911ec 100644
--- a/src/ar/faselhd/build.gradle
+++ b/src/ar/faselhd/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'FASELHD'
     extClass = '.FASELHD'
-    extVersionCode = 17
+    extVersionCode = 18
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ar/mycima/build.gradle b/src/ar/mycima/build.gradle
index 6914fdd1..cc9038e1 100644
--- a/src/ar/mycima/build.gradle
+++ b/src/ar/mycima/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'MY CIMA'
     extClass = '.MyCima'
-    extVersionCode = 23
+    extVersionCode = 24
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ar/okanime/build.gradle b/src/ar/okanime/build.gradle
index d705bea9..183277dd 100644
--- a/src/ar/okanime/build.gradle
+++ b/src/ar/okanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Okanime'
     extClass = '.Okanime'
-    extVersionCode = 13
+    extVersionCode = 14
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ar/witanime/build.gradle b/src/ar/witanime/build.gradle
index 31d0c2e7..d2751fb1 100644
--- a/src/ar/witanime/build.gradle
+++ b/src/ar/witanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'WIT ANIME'
     extClass = '.WitAnime'
-    extVersionCode = 51
+    extVersionCode = 53
 }
 
 apply from: "$rootDir/common.gradle"
@@ -12,4 +12,4 @@ dependencies {
     implementation(project(':lib:okru-extractor'))
     implementation(project(':lib:mp4upload-extractor'))
     implementation(project(':lib:vidbom-extractor'))
-}
\ No newline at end of file
+}
diff --git a/src/ar/witanime/src/eu/kanade/tachiyomi/animeextension/ar/witanime/WitAnime.kt b/src/ar/witanime/src/eu/kanade/tachiyomi/animeextension/ar/witanime/WitAnime.kt
index aa64432e..c4ec264a 100644
--- a/src/ar/witanime/src/eu/kanade/tachiyomi/animeextension/ar/witanime/WitAnime.kt
+++ b/src/ar/witanime/src/eu/kanade/tachiyomi/animeextension/ar/witanime/WitAnime.kt
@@ -30,7 +30,7 @@ class WitAnime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override val name = "WIT ANIME"
 
-    override val baseUrl = "https://witanime.pics"
+    override val baseUrl = "https://witanime.cyou"
 
     override val lang = "ar"
 
diff --git a/src/de/animebase/build.gradle b/src/de/animebase/build.gradle
index cb6418d0..e21acc18 100644
--- a/src/de/animebase/build.gradle
+++ b/src/de/animebase/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Anime-Base'
     extClass = '.AnimeBase'
-    extVersionCode = 31
+    extVersionCode = 33
     isNsfw = true
 }
 
diff --git a/src/de/animeloads/build.gradle b/src/de/animeloads/build.gradle
index b351bc68..af63a075 100644
--- a/src/de/animeloads/build.gradle
+++ b/src/de/animeloads/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Anime-Loads'
     extClass = '.AnimeLoads'
-    extVersionCode = 17
+    extVersionCode = 18
     isNsfw = true
 }
 
diff --git a/src/de/animetoast/build.gradle b/src/de/animetoast/build.gradle
index 27df90c6..3134269b 100644
--- a/src/de/animetoast/build.gradle
+++ b/src/de/animetoast/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AnimeToast'
     extClass = '.AnimeToast'
-    extVersionCode = 21
+    extVersionCode = 23
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/de/aniworld/build.gradle b/src/de/aniworld/build.gradle
index d8179c15..8ece4c3e 100644
--- a/src/de/aniworld/build.gradle
+++ b/src/de/aniworld/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AniWorld'
     extClass = '.AniWorld'
-    extVersionCode = 25
+    extVersionCode = 26
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/de/cinemathek/build.gradle b/src/de/cinemathek/build.gradle
index 783562c0..9549dd9f 100644
--- a/src/de/cinemathek/build.gradle
+++ b/src/de/cinemathek/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.Cinemathek'
     themePkg = 'dooplay'
     baseUrl = 'https://cinemathek.net'
-    overrideVersionCode = 24
+    overrideVersionCode = 26
     isNsfw = true
 }
 
diff --git a/src/de/einfach/build.gradle b/src/de/einfach/build.gradle
index 71a83273..71d5c911 100644
--- a/src/de/einfach/build.gradle
+++ b/src/de/einfach/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Einfach'
     extClass = '.Einfach'
-    extVersionCode = 16
+    extVersionCode = 18
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/de/filmpalast/build.gradle b/src/de/filmpalast/build.gradle
index 9441d99d..b1ed4fcf 100644
--- a/src/de/filmpalast/build.gradle
+++ b/src/de/filmpalast/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'FilmPalast'
     extClass = '.FilmPalast'
-    extVersionCode = 19
+    extVersionCode = 20
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/de/kinoking/build.gradle b/src/de/kinoking/build.gradle
index 3a010a84..103b5868 100644
--- a/src/de/kinoking/build.gradle
+++ b/src/de/kinoking/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.Kinoking'
     themePkg = 'dooplay'
     baseUrl = 'https://kinoking.cc'
-    overrideVersionCode = 23
+    overrideVersionCode = 24
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/de/kool/build.gradle b/src/de/kool/build.gradle
index ab338000..75eecc45 100644
--- a/src/de/kool/build.gradle
+++ b/src/de/kool/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Kool'
     extClass = '.Kool'
-    extVersionCode = 13
+    extVersionCode = 15
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/de/moflixstream/build.gradle b/src/de/moflixstream/build.gradle
index d669b46a..a8129448 100644
--- a/src/de/moflixstream/build.gradle
+++ b/src/de/moflixstream/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Moflix-Stream'
     extClass = '.MoflixStream'
-    extVersionCode = 15
+    extVersionCode = 17
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/de/movie4k/build.gradle b/src/de/movie4k/build.gradle
index f77bcc76..7b718a43 100644
--- a/src/de/movie4k/build.gradle
+++ b/src/de/movie4k/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Movie4k'
     extClass = '.Movie4k'
-    extVersionCode = 11
+    extVersionCode = 12
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/de/serienstream/build.gradle b/src/de/serienstream/build.gradle
index 4968da16..a178cf51 100644
--- a/src/de/serienstream/build.gradle
+++ b/src/de/serienstream/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Serienstream'
     extClass = '.Serienstream'
-    extVersionCode = 24
+    extVersionCode = 25
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/allanime/build.gradle b/src/en/allanime/build.gradle
index 6326ced1..d29692d3 100644
--- a/src/en/allanime/build.gradle
+++ b/src/en/allanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AllAnime'
     extClass = '.AllAnime'
-    extVersionCode = 35
+    extVersionCode = 37
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/allanimechi/build.gradle b/src/en/allanimechi/build.gradle
index 3f9e5bc8..c3e653aa 100644
--- a/src/en/allanimechi/build.gradle
+++ b/src/en/allanimechi/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AllAnimeChi'
     extClass = '.AllAnimeChi'
-    extVersionCode = 12
+    extVersionCode = 14
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/animekhor/build.gradle b/src/en/animekhor/build.gradle
index 8d59dca2..b958f815 100644
--- a/src/en/animekhor/build.gradle
+++ b/src/en/animekhor/build.gradle
@@ -2,8 +2,8 @@ ext {
     extName = 'AnimeKhor'
     extClass = '.AnimeKhor'
     themePkg = 'animestream'
-    baseUrl = 'https://animekhor.xyz'
-    overrideVersionCode = 6
+    baseUrl = 'https://animekhor.org'
+    overrideVersionCode = 9
 }
 
 apply from: "$rootDir/common.gradle"
@@ -12,4 +12,4 @@ dependencies {
     implementation(project(':lib:okru-extractor'))
     implementation(project(':lib:streamwish-extractor'))
     implementation(libs.jsunpacker)
-}
\ No newline at end of file
+}
diff --git a/src/en/animekhor/src/eu/kanade/tachiyomi/animeextension/en/animekhor/AnimeKhor.kt b/src/en/animekhor/src/eu/kanade/tachiyomi/animeextension/en/animekhor/AnimeKhor.kt
index 321e1ac3..160464a4 100644
--- a/src/en/animekhor/src/eu/kanade/tachiyomi/animeextension/en/animekhor/AnimeKhor.kt
+++ b/src/en/animekhor/src/eu/kanade/tachiyomi/animeextension/en/animekhor/AnimeKhor.kt
@@ -9,7 +9,7 @@ import eu.kanade.tachiyomi.multisrc.animestream.AnimeStream
 class AnimeKhor : AnimeStream(
     "en",
     "AnimeKhor",
-    "https://animekhor.xyz",
+    "https://animekhor.org",
 ) {
     // ============================ Video Links =============================
 
diff --git a/src/en/animenosub/build.gradle b/src/en/animenosub/build.gradle
index faadad95..1bc3c680 100644
--- a/src/en/animenosub/build.gradle
+++ b/src/en/animenosub/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.Animenosub'
     themePkg = 'animestream'
     baseUrl = 'https://animenosub.com'
-    overrideVersionCode = 8
+    overrideVersionCode = 10
     isNsfw = true
 }
 
diff --git a/src/en/animeowl/src/eu/kanade/tachiyomi/animeextension/en/animeowl/AnimeOwl.kt b/src/en/animeowl/src/eu/kanade/tachiyomi/animeextension/en/animeowl/AnimeOwl.kt
index 2f1f3d17..3b061288 100644
--- a/src/en/animeowl/src/eu/kanade/tachiyomi/animeextension/en/animeowl/AnimeOwl.kt
+++ b/src/en/animeowl/src/eu/kanade/tachiyomi/animeextension/en/animeowl/AnimeOwl.kt
@@ -129,7 +129,7 @@ class AnimeOwl : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         val document = response.asJsoup()
         val sub = document.select("#anime-cover-sub-content .episode-node").mapIndexed { idx, it ->
             EpisodeResponse.Episode(
-                id = idx.toDouble(),
+                id = it.attr("title").toDoubleOrNull(),
                 episodeIndex = idx.toString(),
                 name = it.attr("title"),
                 lang = "Sub",
@@ -138,7 +138,7 @@ class AnimeOwl : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         }
         val dub = document.select("#anime-cover-dub-content .episode-node").mapIndexed { idx, it ->
             EpisodeResponse.Episode(
-                id = idx.toDouble(),
+                id = it.attr("title").toDoubleOrNull(),
                 episodeIndex = idx.toString(),
                 name = it.attr("title"),
                 lang = "Dub",
@@ -301,6 +301,6 @@ class AnimeOwl : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         private const val PREF_QUALITY_KEY = "preferred_quality"
         private const val PREF_QUALITY_TITLE = "Preferred quality"
         private const val PREF_QUALITY_DEFAULT = "1080p"
-        private val PREF_QUALITY_LIST = arrayOf("2K", "1080p", "720p", "480p", "360p")
+        private val PREF_QUALITY_LIST = arrayOf("1080p", "720p", "480p", "360p")
     }
 }
diff --git a/src/en/animeowl/src/eu/kanade/tachiyomi/animeextension/en/animeowl/extractors/OwlExtractor.kt b/src/en/animeowl/src/eu/kanade/tachiyomi/animeextension/en/animeowl/extractors/OwlExtractor.kt
index d768aa1c..3d4c22a9 100644
--- a/src/en/animeowl/src/eu/kanade/tachiyomi/animeextension/en/animeowl/extractors/OwlExtractor.kt
+++ b/src/en/animeowl/src/eu/kanade/tachiyomi/animeextension/en/animeowl/extractors/OwlExtractor.kt
@@ -48,13 +48,8 @@ class OwlExtractor(private val client: OkHttpClient, private val baseUrl: String
                     luffy.forEach { stream ->
                         noRedirectClient.newCall(GET("${stream.url}$jwt")).execute()
                             .use { it.headers["Location"] }?.let {
-                                val resolution = when {
-                                    stream.resolution?.endsWith("0") == true -> "${stream.resolution}p"
-                                    else -> stream.resolution
-                                }
-
                                 videoList.add(
-                                    Video(it, "${link.lang} Luffy:${resolution ?: "Unknown"}", it),
+                                    Video(it, "${link.lang} Luffy:${stream.resolution}", it),
                                 )
                             }
                     }
@@ -88,10 +83,7 @@ class OwlExtractor(private val client: OkHttpClient, private val baseUrl: String
         return client.newCall(GET(url)).execute().let { it ->
             if (it.isSuccessful) {
                 it.parseAs<Stream>().url.let {
-                    playlistUtils.extractFromHls(
-                        it,
-                        videoNameGen = { qty -> "$lang $server:$qty" },
-                    )
+                    playlistUtils.extractFromHls(it, videoNameGen = { qty -> "$lang $server:$qty" })
                 }
             } else {
                 emptyList()
diff --git a/src/en/animepahe/build.gradle b/src/en/animepahe/build.gradle
index d2c0f169..077eaa8b 100644
--- a/src/en/animepahe/build.gradle
+++ b/src/en/animepahe/build.gradle
@@ -1,11 +1,11 @@
 ext {
     extName = 'AnimePahe'
     extClass = '.AnimePahe'
-    extVersionCode = 29
+    extVersionCode = 31
 }
 
 apply from: "$rootDir/common.gradle"
 
 dependencies {
     implementation(libs.jsunpacker)
-}
\ No newline at end of file
+}
diff --git a/src/en/animepahe/src/eu/kanade/tachiyomi/animeextension/en/animepahe/AnimePahe.kt b/src/en/animepahe/src/eu/kanade/tachiyomi/animeextension/en/animepahe/AnimePahe.kt
index c85d1679..16aef34d 100644
--- a/src/en/animepahe/src/eu/kanade/tachiyomi/animeextension/en/animepahe/AnimePahe.kt
+++ b/src/en/animepahe/src/eu/kanade/tachiyomi/animeextension/en/animepahe/AnimePahe.kt
@@ -153,7 +153,16 @@ class AnimePahe : ConfigurableAnimeSource, AnimeHttpSource() {
     override fun episodeListParse(response: Response): List<SEpisode> {
         val url = response.request.url.toString()
         val session = url.substringAfter("&id=").substringBefore("&")
-        return recursivePages(response, session)
+        val episodeList = recursivePages(response, session)
+
+        return episodeList
+            .sortedBy { it.date_upload } // Optional, makes sure it's in correct order
+            .mapIndexed { index, episode ->
+                episode.episode_number = (index + 1).toFloat()
+                episode.name = "Episode ${index + 1}"
+                episode
+            }
+            .reversed()
     }
 
     private fun parseEpisodePage(episodes: List<EpisodeDto>, animeSession: String): MutableList<SEpisode> {
diff --git a/src/en/animetake/build.gradle b/src/en/animetake/build.gradle
index 8b4afa73..99209aef 100644
--- a/src/en/animetake/build.gradle
+++ b/src/en/animetake/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AnimeTake'
     extClass = '.AnimeTake'
-    extVersionCode = 7
+    extVersionCode = 9
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/aniplay/build.gradle b/src/en/aniplay/build.gradle
index edce2f4c..ec0ebbdd 100644
--- a/src/en/aniplay/build.gradle
+++ b/src/en/aniplay/build.gradle
@@ -2,7 +2,7 @@ ext {
     extName = 'AniPlay'
     extClass = '.AniPlay'
     themePkg = 'anilist'
-    overrideVersionCode = 15
+    overrideVersionCode = 20
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlay.kt b/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlay.kt
index e23034ec..9f166f7e 100644
--- a/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlay.kt
+++ b/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlay.kt
@@ -30,7 +30,9 @@ import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import java.io.IOException
 import java.text.SimpleDateFormat
+import java.util.Date
 import java.util.Locale
+import java.util.concurrent.locks.ReentrantLock
 
 @Suppress("unused")
 class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
@@ -244,9 +246,9 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
         val response = client.newCall(request).execute()
 
         val responseString = response.body.string()
-        val sourcesString = extractSourcesList(responseString) ?: return emptyList()
-        Log.i("AniPlay", "${extra.source} $language -> $sourcesString")
         try {
+            val sourcesString = extractSourcesList(responseString) ?: throw Exception("extractSourcesList null")
+            Log.i("AniPlay", "${extra.source} $language -> $sourcesString")
             return processEpisodeData(
                 EpisodeData(
                     source = extra.source,
@@ -260,14 +262,6 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
         }
     }
 
-    private fun getProxiedUrl(originalUrl: String, serverName: String, referer: String?): String {
-        return when (serverName) {
-            "Yuki" -> "$PROXY_URL/yukiprox?url=$originalUrl"
-            "Pahe" -> "$PROXY_URL/fetch?url=$originalUrl?ref=$referer"
-            else -> return originalUrl
-        }
-    }
-
     private fun processEpisodeData(episodeData: EpisodeData): List<Video> {
         val defaultSource = episodeData.response.sources?.firstOrNull {
             it.quality in listOf("default", "auto")
@@ -290,19 +284,42 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
         }
 
         try {
-            val url = getProxiedUrl(defaultSource.url, serverName, episodeData.response.headers?.Referer)
-            return playlistUtils.extractFromHls(
-                playlistUrl = url,
-                videoNameGen = { quality -> "$serverName - $quality - $typeName" },
-                subtitleList = subtitles,
-                masterHeadersGen = { baseHeaders: Headers, _: String ->
-                    baseHeaders.newBuilder().apply {
+            when (serverName) {
+                "Yuki" -> {
+                    val url = "https://yukiproxy.aniplaynow.live/m3u8-proxy?url=${defaultSource.url}&headers={\"Referer\":\"https://megacloud.club/\"}"
+                    return playlistUtils.extractFromHls(
+                        playlistUrl = url,
+                        videoNameGen = { quality -> "$serverName - $quality - $typeName" },
+                        subtitleList = playlistUtils.fixSubtitles(subtitles),
+                        masterHeadersGen = { baseHeaders: Headers, _: String ->
+                            baseHeaders.newBuilder().apply {
+                                set("Accept", "*/*")
+                                set("Origin", baseUrl)
+                                set("Referer", "$baseUrl/")
+                            }.build()
+                        },
+                        videoHeadersGen = { baseHeaders: Headers, _, _: String ->
+                            baseHeaders.newBuilder().apply {
+                                set("Accept", "*/*")
+                                set("Origin", baseUrl)
+                                set("Referer", "$baseUrl/")
+                            }.build()
+                        },
+                    )
+                }
+                "Pahe" -> {
+                    val url = "https://paheproxy.aniplaynow.live/proxy?url=${defaultSource.url}&headers={\"Referer\":\"https://kwik.si/\"}"
+                    val headers = headers.newBuilder().apply {
                         set("Accept", "*/*")
                         set("Origin", baseUrl)
                         set("Referer", "$baseUrl/")
                     }.build()
-                },
-            )
+                    return listOf(Video(url, "$serverName - Video - $typeName", url, headers, subtitles, listOf()))
+                }
+                else -> {
+                    throw Exception("Unknown serverName: $serverName (${episodeData.source})")
+                }
+            }
         } catch (e: Exception) {
             Log.e("AniPlay", "processEpisodeData extractFromHls Error (\"$serverName - $typeName\"): $e")
         }
@@ -358,6 +375,60 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
         return if (bracketCount == 0) input.substring(startIndex - 1, endIndex) else null
     }
 
+    private val headerFetchLock = ReentrantLock()
+    private var lastHeaderFetch = 0L
+    private fun fetchHeaders() {
+        val internalFetchHeaders = internalFetchHeaders@{
+            val currentTimestamp = Date().time
+            val timeout = lastHeaderFetch + (HEADERS_TIMEOUT_MINUTES * 60 * 1000)
+            // check only after 15 minutes
+            if (timeout > currentTimestamp) {
+                Log.i("AniPlay", "Skipping header update. $timeout > $currentTimestamp (${timeout - currentTimestamp}).")
+                return@internalFetchHeaders
+            }
+
+            val baseUrl = Base64.decode("aHR0cHM6Ly9qb3NlZmZzdHJha2EuZ2l0aHViLmlvL2FuaXBsYXktaGVhZGVycy8=", Base64.DEFAULT).toString(Charsets.UTF_8)
+
+            val preferredDomain = preferences.getString(PREF_DOMAIN_KEY, PREF_DOMAIN_DEFAULT)!!
+
+            try {
+                val url = ("$baseUrl$preferredDomain/headers.json").toHttpUrl()
+                val response = client.newCall(Request(url)).execute()
+                val body = response.body.string()
+                val domainHeaders = body.parseAs<DomainHeaders>()
+                domainsHeaders[preferredDomain] = domainHeaders
+                Log.i("AniPlay", "Fetched headers($preferredDomain): $domainHeaders")
+            } catch (e: Exception) {
+                Log.e("AniPlay", "Failed to fetch new headers: \"e\"")
+                return@internalFetchHeaders
+            }
+
+            lastHeaderFetch = Date().time
+        }
+
+        headerFetchLock.lock()
+        try {
+            internalFetchHeaders()
+        } finally {
+            headerFetchLock.unlock()
+        }
+    }
+
+    private fun getHeaderValue(serverHost: String, key: String): String {
+        fetchHeaders()
+        try {
+            val domainHeaders = domainsHeaders[serverHost] ?: throw Exception("Bad host: $serverHost")
+            return when (key) {
+                NEXT_ACTION_EPISODE_LIST -> domainHeaders.episodes
+                NEXT_ACTION_SOURCES_LIST -> domainHeaders.sources
+                else -> throw Exception("Bad key: $key")
+            }
+        } catch (e: Exception) {
+            Log.e("AniPlay", "getHeaderValue error. $e. (s:${domainsHeaders.size}, l:$lastHeaderFetch)")
+            throw e
+        }
+    }
+
     /* ====================================== Preferences ====================================== */
 
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
@@ -485,10 +556,6 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
         } ?: 0L
     }
 
-    private fun getHeaderValue(serverHost: String, key: String): String {
-        return HEADER_NEXT_ACTION[serverHost]?.get(key) ?: throw Exception("Bad host/key")
-    }
-
     companion object {
         private const val PREF_DOMAIN_KEY = "domain"
         private val PREF_DOMAIN_ENTRIES = arrayOf("aniplaynow.live (default)", "aniplay.lol (backup/experimental)")
@@ -496,8 +563,8 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
         private const val PREF_DOMAIN_DEFAULT = "aniplaynow.live"
 
         private const val PREF_SERVER_KEY = "server"
-        private val PREF_SERVER_ENTRIES = arrayOf("Maze", "Yuki", "Pahe", "Kuro")
-        private val PREF_SERVER_ENTRY_VALUES = arrayOf("maze", "yuki", "pahe", "kuro")
+        private val PREF_SERVER_ENTRIES = arrayOf("Pahe", "Yuki") // , "Hika")
+        private val PREF_SERVER_ENTRY_VALUES = arrayOf("pahe", "yuki") // , "hika")
         private const val PREF_SERVER_DEFAULT = "yuki"
         private const val SERVER_UNKNOWN = "Other"
 
@@ -524,18 +591,10 @@ class AniPlay : AniListAnimeHttpSource(), ConfigurableAnimeSource {
         private const val NEXT_ACTION_EPISODE_LIST = "NEXT_ACTION_EPISODE_LIST"
         private const val NEXT_ACTION_SOURCES_LIST = "NEXT_ACTION_SOURCES_LIST"
 
-        private val HEADER_NEXT_ACTION = mapOf(
-            PREF_DOMAIN_ENTRY_VALUES[0] to mapOf(
-                "NEXT_ACTION_EPISODE_LIST" to "7f07777b5f74e3edb312e0b718a560f9d3ad21aeba",
-                "NEXT_ACTION_SOURCES_LIST" to "7f11490e43dca1ed90fcb5b90bac1e5714a3e11232",
-            ),
-            PREF_DOMAIN_ENTRY_VALUES[1] to mapOf(
-                "NEXT_ACTION_EPISODE_LIST" to "7f57233b7a6486e8211b883c502fa0450775f0ee98",
-                "NEXT_ACTION_SOURCES_LIST" to "7f48c7ffeb25edece852102a65d794a1dffa37aaac",
-            ),
-        )
-        private const val PROXY_URL = "https://prox.aniplaynow.live"
+        private const val HEADERS_TIMEOUT_MINUTES = 60
 
         private val DATE_FORMATTER = SimpleDateFormat("yyyy-MM-dd", Locale.ENGLISH)
+
+        private var domainsHeaders = mutableMapOf<String, DomainHeaders>()
     }
 }
diff --git a/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlayDto.kt b/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlayDto.kt
index 4f909466..b6ba3e80 100644
--- a/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlayDto.kt
+++ b/src/en/aniplay/src/eu/kanade/tachiyomi/animeextension/en/aniplay/AniPlayDto.kt
@@ -79,3 +79,11 @@ data class EpisodeExtra(
     val episodeId: String,
     val hasDub: Boolean,
 )
+
+// Headers
+@Serializable
+data class DomainHeaders(
+    val episodes: String,
+    val sources: String,
+    val time: Long,
+)
diff --git a/src/en/aniwatch/build.gradle b/src/en/aniwatch/build.gradle
new file mode 100644
index 00000000..8182905f
--- /dev/null
+++ b/src/en/aniwatch/build.gradle
@@ -0,0 +1,9 @@
+ext {
+    extName = 'AniWatchtv'
+    extClass = '.AniWatchtv'
+    themePkg = 'zorotheme'
+    baseUrl = 'https://aniwatchtv.to'
+    overrideVersionCode = 1
+}
+
+apply from: "$rootDir/common.gradle"
diff --git a/src/en/aniwatch/res/mipmap-hdpi/ic_launcher.png b/src/en/aniwatch/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000..4ee31d9d
Binary files /dev/null and b/src/en/aniwatch/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/en/aniwatch/res/mipmap-mdpi/ic_launcher.png b/src/en/aniwatch/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000..db658e48
Binary files /dev/null and b/src/en/aniwatch/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/en/aniwatch/res/mipmap-xhdpi/ic_launcher.png b/src/en/aniwatch/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000..0d963107
Binary files /dev/null and b/src/en/aniwatch/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/en/aniwatch/res/mipmap-xxhdpi/ic_launcher.png b/src/en/aniwatch/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000..c1a4969c
Binary files /dev/null and b/src/en/aniwatch/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/en/aniwatch/res/mipmap-xxxhdpi/ic_launcher.png b/src/en/aniwatch/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 00000000..b114f3d5
Binary files /dev/null and b/src/en/aniwatch/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/en/aniwatch/src/eu/kanade/tachiyomi/animeextension/en/aniwatch/AniWatchtv.kt b/src/en/aniwatch/src/eu/kanade/tachiyomi/animeextension/en/aniwatch/AniWatchtv.kt
new file mode 100644
index 00000000..673c8687
--- /dev/null
+++ b/src/en/aniwatch/src/eu/kanade/tachiyomi/animeextension/en/aniwatch/AniWatchtv.kt
@@ -0,0 +1,40 @@
+package eu.kanade.tachiyomi.animeextension.en.aniwatch
+
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.lib.megacloudextractor.MegaCloudExtractor
+import eu.kanade.tachiyomi.multisrc.zorotheme.ZoroTheme
+import eu.kanade.tachiyomi.network.GET
+import okhttp3.Request
+import org.jsoup.nodes.Element
+
+class AniWatchtv : ZoroTheme(
+    "en",
+    "AniWatchtv",
+    "https://aniwatchtv.to",
+    hosterNames = listOf(
+        "VidSrc",
+        "MegaCloud",
+    ),
+) {
+    override val id = 8051984946387208343L
+
+    override val ajaxRoute = "/v2"
+
+    private val megaCloudExtractor by lazy { MegaCloudExtractor(client, headers, preferences) }
+
+    override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/recently-updated?page=$page", docHeaders)
+
+    override fun popularAnimeFromElement(element: Element): SAnime {
+        return super.popularAnimeFromElement(element).apply {
+            url = url.substringBefore("?")
+        }
+    }
+
+    override fun extractVideo(server: VideoData): List<Video> {
+        return when (server.name) {
+            "VidSrc", "MegaCloud" -> megaCloudExtractor.getVideosFromUrl(server.link, server.type, server.name)
+            else -> emptyList()
+        }
+    }
+}
diff --git a/src/en/asiaflix/build.gradle b/src/en/asiaflix/build.gradle
index d6c6e49d..2a801534 100644
--- a/src/en/asiaflix/build.gradle
+++ b/src/en/asiaflix/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AsiaFlix'
     extClass = '.AsiaFlix'
-    extVersionCode = 16
+    extVersionCode = 18
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/donghuastream/build.gradle b/src/en/donghuastream/build.gradle
index 824241ab..33868d3f 100644
--- a/src/en/donghuastream/build.gradle
+++ b/src/en/donghuastream/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.DonghuaStream'
     themePkg = 'animestream'
     baseUrl = 'https://donghuastream.org'
-    overrideVersionCode = 9
+    overrideVersionCode = 10
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/dopebox/build.gradle b/src/en/dopebox/build.gradle
index 5a3b21c2..22176851 100644
--- a/src/en/dopebox/build.gradle
+++ b/src/en/dopebox/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.DopeBox'
     themePkg = 'dopeflix'
     baseUrl = 'https://dopebox.to'
-    overrideVersionCode = 11
+    overrideVersionCode = 12
 }
 
 apply from: "$rootDir/common.gradle"
\ No newline at end of file
diff --git a/src/en/dramacool/build.gradle b/src/en/dramacool/build.gradle
deleted file mode 100644
index 950c5ea8..00000000
--- a/src/en/dramacool/build.gradle
+++ /dev/null
@@ -1,13 +0,0 @@
-ext {
-    extName = 'DramaCool'
-    extClass = '.DramaCool'
-    extVersionCode = 54
-}
-
-apply from: "$rootDir/common.gradle"
-
-dependencies {
-    implementation(project(':lib:streamwish-extractor'))
-    implementation(project(':lib:streamtape-extractor'))
-    implementation(project(':lib:dood-extractor'))
-}
\ No newline at end of file
diff --git a/src/en/dramacool/res/mipmap-hdpi/ic_launcher.png b/src/en/dramacool/res/mipmap-hdpi/ic_launcher.png
deleted file mode 100644
index 386283c6..00000000
Binary files a/src/en/dramacool/res/mipmap-hdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/dramacool/res/mipmap-mdpi/ic_launcher.png b/src/en/dramacool/res/mipmap-mdpi/ic_launcher.png
deleted file mode 100644
index 3d81dfbc..00000000
Binary files a/src/en/dramacool/res/mipmap-mdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/dramacool/res/mipmap-xhdpi/ic_launcher.png b/src/en/dramacool/res/mipmap-xhdpi/ic_launcher.png
deleted file mode 100644
index d0126fee..00000000
Binary files a/src/en/dramacool/res/mipmap-xhdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/dramacool/res/mipmap-xxhdpi/ic_launcher.png b/src/en/dramacool/res/mipmap-xxhdpi/ic_launcher.png
deleted file mode 100644
index 9ab42d45..00000000
Binary files a/src/en/dramacool/res/mipmap-xxhdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/dramacool/res/mipmap-xxxhdpi/ic_launcher.png b/src/en/dramacool/res/mipmap-xxxhdpi/ic_launcher.png
deleted file mode 100644
index 6d99bf28..00000000
Binary files a/src/en/dramacool/res/mipmap-xxxhdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/dramacool/src/eu/kanade/tachiyomi/animeextension/en/dramacool/DramaCool.kt b/src/en/dramacool/src/eu/kanade/tachiyomi/animeextension/en/dramacool/DramaCool.kt
deleted file mode 100644
index 4ec49eb0..00000000
--- a/src/en/dramacool/src/eu/kanade/tachiyomi/animeextension/en/dramacool/DramaCool.kt
+++ /dev/null
@@ -1,202 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.en.dramacool
-
-import android.app.Application
-import androidx.preference.ListPreference
-import androidx.preference.PreferenceScreen
-import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
-import eu.kanade.tachiyomi.animesource.model.SAnime
-import eu.kanade.tachiyomi.animesource.model.SEpisode
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.animesource.online.ParsedAnimeHttpSource
-import eu.kanade.tachiyomi.lib.doodextractor.DoodExtractor
-import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
-import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import okhttp3.Request
-import okhttp3.Response
-import org.jsoup.nodes.Document
-import org.jsoup.nodes.Element
-import uy.kohesive.injekt.Injekt
-import uy.kohesive.injekt.api.get
-import java.text.SimpleDateFormat
-import java.util.Locale
-
-class DramaCool : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
-
-    override val name = "DramaCool"
-
-    // TODO: Check frequency of url changes to potentially
-    // add back overridable baseurl preference
-    override val baseUrl = "https://asianc.co/"
-
-    override val lang = "en"
-
-    override val supportsLatest = true
-
-    private val preferences by lazy {
-        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
-    }
-
-    // ============================== Popular ===============================
-    override fun popularAnimeRequest(page: Int) = GET("$baseUrl/most-popular-drama?page=$page") // page/$page
-
-    override fun popularAnimeSelector() = "ul.list-episode-item li a"
-
-    override fun popularAnimeFromElement(element: Element) = SAnime.create().apply {
-        setUrlWithoutDomain(element.attr("href"))
-        thumbnail_url = element.selectFirst("img")?.attr("data-original")?.replace(" ", "%20")
-        title = element.selectFirst("h3")?.text() ?: "Serie"
-    }
-
-    override fun popularAnimeNextPageSelector() = "li.next a"
-
-    // =============================== Latest ===============================
-    override fun latestUpdatesRequest(page: Int) = GET("$baseUrl/recently-added?page=$page")
-
-    override fun latestUpdatesSelector() = "ul.switch-block a"
-
-    override fun latestUpdatesFromElement(element: Element) = popularAnimeFromElement(element)
-
-    override fun latestUpdatesNextPageSelector() = popularAnimeNextPageSelector()
-
-    // =============================== Search ===============================
-    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList) =
-        GET("$baseUrl/search?keyword=$query&page=$page")
-
-    override fun searchAnimeSelector() = popularAnimeSelector()
-
-    override fun searchAnimeFromElement(element: Element) = popularAnimeFromElement(element)
-
-    override fun searchAnimeNextPageSelector() = popularAnimeNextPageSelector()
-
-    // =========================== Anime Details ============================
-    override fun animeDetailsRequest(anime: SAnime): Request {
-        if (anime.url.contains("-episode-") && anime.url.endsWith(".html")) {
-            val doc = client.newCall(GET(baseUrl + anime.url)).execute().asJsoup()
-            anime.setUrlWithoutDomain(doc.selectFirst("div.category a")!!.attr("href"))
-        }
-        return GET(baseUrl + anime.url)
-    }
-
-    override fun animeDetailsParse(document: Document) = SAnime.create().apply {
-        document.selectFirst("div.img img")!!.run {
-            title = attr("alt")
-            thumbnail_url = absUrl("src")
-        }
-
-        with(document.selectFirst("div.info")!!) {
-            description = select("p:contains(Description) ~ p:not(:has(span))").eachText()
-                .joinToString("\n")
-                .takeUnless(String::isBlank)
-            author = selectFirst("p:contains(Original Network:) > a")?.text()
-            genre = select("p:contains(Genre:) > a").joinToString { it.text() }.takeUnless(String::isBlank)
-            status = parseStatus(selectFirst("p:contains(Status) a")?.text())
-        }
-    }
-
-    // ============================== Episodes ==============================
-    override fun episodeListSelector() = "ul.all-episode li a"
-
-    override fun episodeFromElement(element: Element) = SEpisode.create().apply {
-        setUrlWithoutDomain(element.attr("href"))
-        val epNum = element.selectFirst("h3")!!.text().substringAfterLast("Episode ")
-        val type = element.selectFirst("span.type")?.text() ?: "RAW"
-        name = "$type: Episode $epNum".trimEnd()
-        episode_number = when {
-            epNum.isNotEmpty() -> epNum.toFloatOrNull() ?: 1F
-            else -> 1F
-        }
-        date_upload = element.selectFirst("span.time")?.text().orEmpty().toDate()
-    }
-
-    // ============================ Video Links =============================
-    override fun videoListSelector() = "ul.list-server-items li"
-
-    override fun videoListParse(response: Response): List<Video> {
-        val document = response.asJsoup()
-        val iframeUrl = document.selectFirst("iframe")?.absUrl("src") ?: return emptyList()
-        val iframeDoc = client.newCall(GET(iframeUrl)).execute().asJsoup()
-
-        return iframeDoc.select(videoListSelector()).flatMap(::videosFromElement)
-    }
-
-    private val doodExtractor by lazy { DoodExtractor(client) }
-    private val streamwishExtractor by lazy { StreamWishExtractor(client, headers) }
-    private val streamtapeExtractor by lazy { StreamTapeExtractor(client) }
-
-    // TODO: Create a extractor for the "Standard server" thingie.
-    // it'll require Synchrony or something similar, but synchrony is too slow >:(
-    private fun videosFromElement(element: Element): List<Video> {
-        val url = element.attr("data-video")
-        return runCatching {
-            when {
-                url.contains("dood") -> doodExtractor.videosFromUrl(url)
-                url.contains("dwish") -> streamwishExtractor.videosFromUrl(url)
-                url.contains("streamtape") -> streamtapeExtractor.videosFromUrl(url)
-                else -> emptyList()
-            }
-        }.getOrElse { emptyList() }
-    }
-
-    override fun videoFromElement(element: Element) = throw UnsupportedOperationException()
-
-    override fun videoUrlParse(document: Document) = throw UnsupportedOperationException()
-
-    // ============================== Settings ==============================
-    override fun setupPreferenceScreen(screen: PreferenceScreen) {
-        ListPreference(screen.context).apply {
-            key = PREF_QUALITY_KEY
-            title = PREF_QUALITY_TITLE
-            entries = PREF_QUALITY_ENTRIES
-            entryValues = PREF_QUALITY_VALUES
-            setDefaultValue(PREF_QUALITY_DEFAULT)
-            summary = "%s"
-
-            setOnPreferenceChangeListener { _, newValue ->
-                val selected = newValue as String
-                val index = findIndexOfValue(selected)
-                val entry = entryValues[index] as String
-                preferences.edit().putString(key, entry).commit()
-            }
-        }.also(screen::addPreference)
-    }
-
-    // ============================= Utilities ==============================
-    override fun List<Video>.sort(): List<Video> {
-        val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
-
-        return sortedWith(
-            compareBy(
-                { it.quality.contains(quality) },
-                { Regex("""(\d+)p""").find(it.quality)?.groupValues?.get(1)?.toIntOrNull() ?: 0 },
-            ),
-        ).reversed()
-    }
-
-    private fun parseStatus(statusString: String?): Int {
-        return when (statusString) {
-            "Ongoing" -> SAnime.ONGOING
-            "Completed" -> SAnime.COMPLETED
-            else -> SAnime.UNKNOWN
-        }
-    }
-
-    private fun String.toDate(): Long {
-        return runCatching { DATE_FORMATTER.parse(trim())?.time }
-            .getOrNull() ?: 0L
-    }
-
-    companion object {
-        private val DATE_FORMATTER by lazy {
-            SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.ENGLISH)
-        }
-
-        private const val PREF_QUALITY_KEY = "preferred_quality"
-        private const val PREF_QUALITY_TITLE = "Preferred quality"
-        private const val PREF_QUALITY_DEFAULT = "1080"
-        private val PREF_QUALITY_ENTRIES = arrayOf("1080p", "720p", "480p", "360p", "Doodstream", "StreamTape")
-        private val PREF_QUALITY_VALUES = PREF_QUALITY_ENTRIES
-    }
-}
diff --git a/src/en/fmovies/build.gradle b/src/en/fmovies/build.gradle
deleted file mode 100644
index 3d5bb63a..00000000
--- a/src/en/fmovies/build.gradle
+++ /dev/null
@@ -1,13 +0,0 @@
-ext {
-    extName = 'FMovies'
-    extClass = '.FMovies'
-    extVersionCode = 26
-}
-
-apply from: "$rootDir/common.gradle"
-
-dependencies {
-    implementation(project(':lib:vidsrc-extractor'))
-    implementation(project(':lib:filemoon-extractor'))
-    implementation(project(':lib:streamtape-extractor'))
-}
diff --git a/src/en/fmovies/res/mipmap-hdpi/ic_launcher.png b/src/en/fmovies/res/mipmap-hdpi/ic_launcher.png
deleted file mode 100644
index 20e890a4..00000000
Binary files a/src/en/fmovies/res/mipmap-hdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/fmovies/res/mipmap-mdpi/ic_launcher.png b/src/en/fmovies/res/mipmap-mdpi/ic_launcher.png
deleted file mode 100644
index 341c5611..00000000
Binary files a/src/en/fmovies/res/mipmap-mdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/fmovies/res/mipmap-xhdpi/ic_launcher.png b/src/en/fmovies/res/mipmap-xhdpi/ic_launcher.png
deleted file mode 100644
index 7732fbf3..00000000
Binary files a/src/en/fmovies/res/mipmap-xhdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/fmovies/res/mipmap-xxhdpi/ic_launcher.png b/src/en/fmovies/res/mipmap-xxhdpi/ic_launcher.png
deleted file mode 100644
index fede27d7..00000000
Binary files a/src/en/fmovies/res/mipmap-xxhdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/fmovies/res/mipmap-xxxhdpi/ic_launcher.png b/src/en/fmovies/res/mipmap-xxxhdpi/ic_launcher.png
deleted file mode 100644
index 62f3def9..00000000
Binary files a/src/en/fmovies/res/mipmap-xxxhdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FMovies.kt b/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FMovies.kt
deleted file mode 100644
index 9e062a7e..00000000
--- a/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FMovies.kt
+++ /dev/null
@@ -1,368 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.en.fmovies
-
-import android.app.Application
-import android.content.SharedPreferences
-import androidx.preference.ListPreference
-import androidx.preference.MultiSelectListPreference
-import androidx.preference.PreferenceScreen
-import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
-import eu.kanade.tachiyomi.animesource.model.SAnime
-import eu.kanade.tachiyomi.animesource.model.SEpisode
-import eu.kanade.tachiyomi.animesource.model.Track
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.animesource.online.ParsedAnimeHttpSource
-import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
-import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
-import eu.kanade.tachiyomi.lib.vidsrcextractor.VidsrcExtractor
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.network.await
-import eu.kanade.tachiyomi.network.awaitSuccess
-import eu.kanade.tachiyomi.util.asJsoup
-import eu.kanade.tachiyomi.util.parallelCatchingFlatMap
-import eu.kanade.tachiyomi.util.parseAs
-import kotlinx.serialization.encodeToString
-import kotlinx.serialization.json.Json
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.Request
-import okhttp3.Response
-import org.jsoup.Jsoup
-import org.jsoup.nodes.Document
-import org.jsoup.nodes.Element
-import uy.kohesive.injekt.Injekt
-import uy.kohesive.injekt.api.get
-import uy.kohesive.injekt.injectLazy
-
-class FMovies : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
-
-    override val name = "FMovies"
-
-    override val baseUrl = "https://fmovies24.to"
-
-    override val lang = "en"
-
-    override val supportsLatest = true
-
-    private val json: Json by injectLazy()
-
-    private val preferences: SharedPreferences by lazy {
-        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
-    }
-
-    private val utils by lazy { FmoviesUtils(client, headers) }
-
-    // ============================== Popular ===============================
-
-    override fun popularAnimeRequest(page: Int): Request = GET("$baseUrl/trending${page.toPageQuery()}", headers)
-
-    override fun popularAnimeSelector(): String = "div.items > div.item"
-
-    override fun popularAnimeFromElement(element: Element): SAnime = SAnime.create().apply {
-        element.selectFirst("div.meta a")!!.let { a ->
-            title = a.text()
-            setUrlWithoutDomain(a.attr("abs:href"))
-        }
-
-        thumbnail_url = element.select("div.poster img").attr("data-src")
-    }
-
-    override fun popularAnimeNextPageSelector(): String = "ul.pagination > li.active + li"
-
-    // =============================== Latest ===============================
-
-    override fun latestUpdatesRequest(page: Int): Request =
-        GET("$baseUrl/filter?keyword=&sort=recently_updated${page.toPageQuery(false)}", headers)
-
-    override fun latestUpdatesSelector(): String = popularAnimeSelector()
-
-    override fun latestUpdatesFromElement(element: Element): SAnime = popularAnimeFromElement(element)
-
-    override fun latestUpdatesNextPageSelector(): String = popularAnimeNextPageSelector()
-
-    // =============================== Search ===============================
-
-    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val params = FMoviesFilters.getSearchParameters(filters)
-
-        return GET("$baseUrl/filter?keyword=$query${params.filter}${page.toPageQuery(false)}", headers)
-    }
-
-    override fun searchAnimeSelector(): String = popularAnimeSelector()
-
-    override fun searchAnimeFromElement(element: Element): SAnime = popularAnimeFromElement(element)
-
-    override fun searchAnimeNextPageSelector(): String = popularAnimeNextPageSelector()
-
-    // ============================== Filters ===============================
-
-    override fun getFilterList(): AnimeFilterList = FMoviesFilters.FILTER_LIST
-
-    // =========================== Anime Details ============================
-
-    override fun animeDetailsParse(document: Document): SAnime {
-        val info = document.selectFirst("section#w-info > div.info")!!
-        val detail = info.selectFirst("div.detail")
-
-        val descElement = info.selectFirst("div.description")
-        val desc = descElement?.selectFirst("div[data-name=full]")?.ownText() ?: descElement?.ownText() ?: ""
-        val extraInfo = detail?.select("> div")?.joinToString("\n") { it.text() } ?: ""
-
-        val mediaTitle = info.selectFirst("h1.name")!!.text()
-        val mediaDetail = utils.getDetail(mediaTitle)
-
-        return SAnime.create().apply {
-            title = mediaTitle
-            status = when (mediaDetail?.status) {
-                "Ended", "Released" -> SAnime.COMPLETED
-                "In Production" -> SAnime.LICENSED
-                "Canceled" -> SAnime.CANCELLED
-                "Returning Series" -> {
-                    mediaDetail.nextEpisode?.let { SAnime.ONGOING } ?: SAnime.ON_HIATUS
-                }
-                else -> SAnime.UNKNOWN
-            }
-            thumbnail_url = document.selectFirst("section#w-info > div.poster img")!!.attr("src")
-            description = buildString {
-                appendLine(desc.ifBlank { mediaDetail?.overview })
-                appendLine()
-                mediaDetail?.nextEpisode?.let {
-                    appendLine("Next: Ep ${it.epNumber} - ${it.name}")
-                    appendLine("Air Date: ${it.airDate}")
-                    appendLine()
-                }
-                appendLine(extraInfo)
-            }
-            genre = detail?.let { dtl ->
-                dtl.select("> div:has(> div:contains(Genre:)) span").joinToString { it.text() }
-            }
-            author = detail?.let { dtl ->
-                dtl.select("> div:has(> div:contains(Production:)) span").joinToString { it.text() }
-            }
-        }
-    }
-
-    // ============================== Episodes ==============================
-
-    override fun episodeListRequest(anime: SAnime): Request {
-        val id = client.newCall(GET(baseUrl + anime.url)).execute().asJsoup()
-            .selectFirst("div[data-id]")!!.attr("data-id")
-
-        val vrf = utils.vrfEncrypt(id)
-        val vrfHeaders = headers.newBuilder().apply {
-            add("Accept", "application/json, text/javascript, */*; q=0.01")
-            add("Host", baseUrl.toHttpUrl().host)
-            add("Referer", baseUrl + anime.url)
-            add("X-Requested-With", "XMLHttpRequest")
-        }.build()
-
-        return GET("$baseUrl/ajax/episode/list/$id?vrf=$vrf", headers = vrfHeaders)
-    }
-
-    override fun episodeListParse(response: Response): List<SEpisode> {
-        val document = Jsoup.parse(
-            response.parseAs<AjaxResponse>().result,
-        )
-        val episodeList = mutableListOf<SEpisode>()
-        val seasons = document.select("div.body > ul.episodes")
-        seasons.forEach { season ->
-            val seasonPrefix = if (seasons.size > 1) {
-                "Season ${season.attr("data-season")} "
-            } else {
-                ""
-            }
-
-            season.select("li").forEach { ep ->
-                episodeList.add(
-                    SEpisode.create().apply {
-                        name = "$seasonPrefix${ep.text().trim()}".replace("Episode ", "Ep. ")
-
-                        ep.selectFirst("a")!!.let { a ->
-                            episode_number = a.attr("data-num").toFloatOrNull() ?: 0F
-                            url = json.encodeToString(
-                                EpisodeInfo(
-                                    id = a.attr("data-id"),
-                                    url = "$baseUrl${a.attr("href")}",
-                                ),
-                            )
-                        }
-                    },
-                )
-            }
-        }
-
-        return episodeList.reversed()
-    }
-
-    override fun episodeListSelector() = throw UnsupportedOperationException()
-
-    override fun episodeFromElement(element: Element): SEpisode = throw UnsupportedOperationException()
-
-    // ============================ Video Links =============================
-
-    override suspend fun getVideoList(episode: SEpisode): List<Video> {
-        return client.newCall(videoListRequest(episode))
-            .awaitSuccess()
-            .let { response ->
-                videoListParse(response, episode).sort()
-            }
-    }
-
-    override fun videoListRequest(episode: SEpisode): Request {
-        val data = json.decodeFromString<EpisodeInfo>(episode.url)
-        val vrf = utils.vrfEncrypt(data.id)
-
-        val vrfHeaders = headers.newBuilder()
-            .add("Accept", "application/json, text/javascript, */*; q=0.01")
-            .add("Host", baseUrl.toHttpUrl().host)
-            .add("Referer", data.url)
-            .add("X-Requested-With", "XMLHttpRequest")
-            .build()
-
-        return GET("$baseUrl/ajax/server/list/${data.id}?vrf=$vrf", headers = vrfHeaders)
-    }
-
-    private val vidsrcExtractor by lazy { VidsrcExtractor(client, headers) }
-    private val filemoonExtractor by lazy { FilemoonExtractor(client) }
-    private val streamtapeExtractor by lazy { StreamTapeExtractor(client) }
-
-    private suspend fun videoListParse(response: Response, episode: SEpisode): List<Video> {
-        val data = json.decodeFromString<EpisodeInfo>(episode.url)
-        val document = Jsoup.parse(
-            response.parseAs<AjaxResponse>().result,
-        )
-        val hosterSelection = preferences.getStringSet(PREF_HOSTER_KEY, PREF_HOSTER_DEFAULT)!!
-
-        return document.select("ul.servers > li.server").parallelCatchingFlatMap { server ->
-            val name = server.text().trim()
-            if (!hosterSelection.contains(name)) return@parallelCatchingFlatMap emptyList()
-
-            // Get decrypted url
-            val vrf = utils.vrfEncrypt(server.attr("data-link-id"))
-
-            val vrfHeaders = headers.newBuilder()
-                .add("Accept", "application/json, text/javascript, */*; q=0.01")
-                .add("Host", baseUrl.toHttpUrl().host)
-                .add("Referer", data.url)
-                .add("X-Requested-With", "XMLHttpRequest")
-                .build()
-            val encrypted = client.newCall(
-                GET("$baseUrl/ajax/server/${server.attr("data-link-id")}?vrf=$vrf", headers = vrfHeaders),
-            ).await().parseAs<AjaxServerResponse>().result.url
-
-            val decrypted = utils.vrfDecrypt(encrypted)
-            when (name) {
-                "Vidplay", "MyCloud" -> {
-                    val subs = client.newCall(
-                        GET("$baseUrl/ajax/episode/subtitles/${data.id}"),
-                    ).execute().toTracks()
-                    vidsrcExtractor.videosFromUrl(decrypted, name, subtitleList = subs)
-                }
-                "Filemoon" -> filemoonExtractor.videosFromUrl(decrypted, headers = headers)
-                "Streamtape" -> {
-                    val subtitleList = decrypted.toHttpUrl().queryParameter("sub.info")?.let {
-                        client.newCall(GET(it, headers)).await().toTracks()
-                    } ?: emptyList()
-
-                    streamtapeExtractor.videoFromUrl(decrypted, subtitleList = subtitleList)?.let(::listOf) ?: emptyList()
-                }
-                else -> emptyList()
-            }
-        }
-    }
-
-    override fun videoListSelector() = throw UnsupportedOperationException()
-
-    override fun videoFromElement(element: Element) = throw UnsupportedOperationException()
-
-    override fun videoUrlParse(document: Document) = throw UnsupportedOperationException()
-
-    // ============================= Utilities ==============================
-
-    override fun List<Video>.sort(): List<Video> {
-        val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
-        val server = preferences.getString(PREF_SERVER_KEY, PREF_SERVER_DEFAULT)!!
-
-        return this.sortedWith(
-            compareBy(
-                { it.quality.contains(server) },
-                { it.quality.contains(quality) },
-                { Regex("""(\d+)p""").find(it.quality)?.groupValues?.get(1)?.toIntOrNull() ?: 0 },
-            ),
-        ).reversed()
-    }
-
-    private fun Int.toPageQuery(first: Boolean = true): String {
-        return if (this == 1) "" else "${if (first) "?" else "&"}page=$this"
-    }
-
-    private fun Response.toTracks(): List<Track> = parseAs<List<FMoviesSubs>>()
-        .map { t ->
-            Track(t.file, t.label)
-        }
-
-    companion object {
-        private val HOSTERS = arrayOf(
-            "Vidplay",
-            "MyCloud",
-            "Filemoon",
-            "Streamtape",
-        )
-
-        private const val PREF_QUALITY_KEY = "preferred_quality"
-        private const val PREF_QUALITY_DEFAULT = "1080"
-
-        private const val PREF_SERVER_KEY = "preferred_server"
-        private const val PREF_SERVER_DEFAULT = "Vidplay"
-
-        private const val PREF_HOSTER_KEY = "hoster_selection"
-        private val PREF_HOSTER_DEFAULT = setOf("Vidplay", "Filemoon")
-    }
-    // ============================== Settings ==============================
-
-    override fun setupPreferenceScreen(screen: PreferenceScreen) {
-        ListPreference(screen.context).apply {
-            key = PREF_QUALITY_KEY
-            title = "Preferred quality"
-            entries = arrayOf("1080p", "720p", "480p", "360p")
-            entryValues = arrayOf("1080", "720", "480", "360")
-            setDefaultValue(PREF_QUALITY_DEFAULT)
-            summary = "%s"
-
-            setOnPreferenceChangeListener { _, newValue ->
-                val selected = newValue as String
-                val index = findIndexOfValue(selected)
-                val entry = entryValues[index] as String
-                preferences.edit().putString(key, entry).commit()
-            }
-        }.also(screen::addPreference)
-
-        ListPreference(screen.context).apply {
-            key = PREF_SERVER_KEY
-            title = "Preferred server"
-            entries = HOSTERS
-            entryValues = HOSTERS
-            setDefaultValue(PREF_SERVER_DEFAULT)
-            summary = "%s"
-
-            setOnPreferenceChangeListener { _, newValue ->
-                val selected = newValue as String
-                val index = findIndexOfValue(selected)
-                val entry = entryValues[index] as String
-                preferences.edit().putString(key, entry).commit()
-            }
-        }.also(screen::addPreference)
-
-        MultiSelectListPreference(screen.context).apply {
-            key = PREF_HOSTER_KEY
-            title = "Enable/Disable Hosts"
-            entries = HOSTERS
-            entryValues = HOSTERS
-            setDefaultValue(PREF_HOSTER_DEFAULT)
-
-            setOnPreferenceChangeListener { _, newValue ->
-                @Suppress("UNCHECKED_CAST")
-                preferences.edit().putStringSet(key, newValue as Set<String>).commit()
-            }
-        }.also(screen::addPreference)
-    }
-}
diff --git a/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FMoviesDto.kt b/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FMoviesDto.kt
deleted file mode 100644
index f6f964a8..00000000
--- a/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FMoviesDto.kt
+++ /dev/null
@@ -1,54 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.en.fmovies
-
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class AjaxResponse(
-    val result: String,
-)
-
-@Serializable
-data class AjaxServerResponse(
-    val result: UrlObject,
-) {
-    @Serializable
-    data class UrlObject(
-        val url: String,
-    )
-}
-
-@Serializable
-data class EpisodeInfo(
-    val id: String,
-    val url: String,
-)
-
-@Serializable
-data class FMoviesSubs(
-    val file: String,
-    val label: String,
-)
-
-@Serializable
-data class MediaResponseBody(
-    val status: Int,
-    val result: Result,
-) {
-    @Serializable
-    data class Result(
-        val sources: ArrayList<Source>,
-        val tracks: ArrayList<SubTrack> = ArrayList(),
-    ) {
-        @Serializable
-        data class Source(
-            val file: String,
-        )
-
-        @Serializable
-        data class SubTrack(
-            val file: String,
-            val label: String = "",
-            val kind: String,
-        )
-    }
-}
diff --git a/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FMoviesFilters.kt b/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FMoviesFilters.kt
deleted file mode 100644
index 19c3a036..00000000
--- a/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FMoviesFilters.kt
+++ /dev/null
@@ -1,304 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.en.fmovies
-
-import eu.kanade.tachiyomi.animesource.model.AnimeFilter
-import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
-
-object FMoviesFilters {
-
-    open class QueryPartFilter(
-        displayName: String,
-        val vals: Array<Pair<String, String>>,
-    ) : AnimeFilter.Select<String>(
-        displayName,
-        vals.map { it.first }.toTypedArray(),
-    ) {
-        fun toQueryPart(name: String) = "&$name=${vals[state].second}"
-    }
-
-    open class CheckBoxFilterList(name: String, values: List<CheckBox>) : AnimeFilter.Group<AnimeFilter.CheckBox>(name, values)
-
-    private class CheckBoxVal(name: String, state: Boolean = false) : AnimeFilter.CheckBox(name, state)
-
-    open class TriStateFilterList(name: String, values: List<TriFilter>) : AnimeFilter.Group<AnimeFilter.TriState>(name, values)
-
-    class TriFilter(name: String, val value: String) : AnimeFilter.TriState(name)
-
-    private inline fun <reified R> AnimeFilterList.asQueryPart(name: String): String {
-        return (this.getFirst<R>() as QueryPartFilter).toQueryPart(name)
-    }
-
-    private inline fun <reified R> AnimeFilterList.getFirst(): R {
-        return this.filterIsInstance<R>().first()
-    }
-
-    private inline fun <reified R> AnimeFilterList.parseCheckbox(
-        options: Array<Pair<String, String>>,
-        name: String,
-    ): String {
-        return (this.getFirst<R>() as CheckBoxFilterList).state
-            .mapNotNull { checkbox ->
-                if (checkbox.state) {
-                    options.find { it.first == checkbox.name }!!.second
-                } else {
-                    null
-                }
-            }.joinToString("&$name[]=").let {
-                if (it.isBlank()) {
-                    ""
-                } else {
-                    "&$name[]=$it"
-                }
-            }
-    }
-
-    private inline fun <reified R> AnimeFilterList.parseTriFilter(
-        options: Array<Pair<String, String>>,
-        name: String,
-    ): String {
-        return (this.getFirst<R>() as TriStateFilterList).state
-            .mapNotNull { checkbox ->
-                if (checkbox.state != AnimeFilter.TriState.STATE_IGNORE) {
-                    (if (checkbox.state == AnimeFilter.TriState.STATE_EXCLUDE) "-" else "") + options.find { it.first == checkbox.name }!!.second
-                } else {
-                    null
-                }
-            }.joinToString("&$name[]=").let {
-                if (it.isBlank()) {
-                    ""
-                } else {
-                    "&$name[]=$it"
-                }
-            }
-    }
-
-    class TypesFilter : CheckBoxFilterList(
-        "Type",
-        FMoviesFiltersData.TYPES.map { CheckBoxVal(it.first, false) },
-    )
-
-    class GenresFilter : TriStateFilterList(
-        "Genre",
-        FMoviesFiltersData.GENRES.map { TriFilter(it.first, it.second) },
-    )
-
-    class CountriesFilter : CheckBoxFilterList(
-        "Country",
-        FMoviesFiltersData.COUNTRIES.map { CheckBoxVal(it.first, false) },
-    )
-
-    class YearsFilter : CheckBoxFilterList(
-        "Year",
-        FMoviesFiltersData.YEARS.map { CheckBoxVal(it.first, false) },
-    )
-
-    class RatingsFilter : CheckBoxFilterList(
-        "Rating",
-        FMoviesFiltersData.RATINGS.map { CheckBoxVal(it.first, false) },
-    )
-
-    class QualitiesFilter : CheckBoxFilterList(
-        "Quality",
-        FMoviesFiltersData.QUALITIES.map { CheckBoxVal(it.first, false) },
-    )
-
-    class SortFilter : QueryPartFilter("Sort", FMoviesFiltersData.SORT)
-
-    val FILTER_LIST get() = AnimeFilterList(
-        TypesFilter(),
-        GenresFilter(),
-        CountriesFilter(),
-        YearsFilter(),
-        RatingsFilter(),
-        QualitiesFilter(),
-        SortFilter(),
-    )
-
-    data class FilterSearchParams(
-        val filter: String = "",
-    )
-
-    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
-        if (filters.isEmpty()) return FilterSearchParams()
-
-        return FilterSearchParams(
-            filters.parseCheckbox<TypesFilter>(FMoviesFiltersData.TYPES, "type") +
-                filters.parseTriFilter<GenresFilter>(FMoviesFiltersData.GENRES, "genre") +
-                filters.parseCheckbox<CountriesFilter>(FMoviesFiltersData.COUNTRIES, "country") +
-                filters.parseCheckbox<YearsFilter>(FMoviesFiltersData.YEARS, "year") +
-                filters.parseCheckbox<RatingsFilter>(FMoviesFiltersData.RATINGS, "rating") +
-                filters.parseCheckbox<QualitiesFilter>(FMoviesFiltersData.QUALITIES, "quality") +
-                filters.asQueryPart<SortFilter>("sort"),
-        )
-    }
-
-    private object FMoviesFiltersData {
-        val TYPES = arrayOf(
-            Pair("Movie", "movie"),
-            Pair("TV-Shows", "tv"),
-        )
-
-        val GENRES = arrayOf(
-            Pair("Action", "25"),
-            Pair("Adult", "1068691"),
-            Pair("Adventure", "17"),
-            Pair("Animation", "10"),
-            Pair("Biography", "215"),
-            Pair("Comedy", "14"),
-            Pair("Costume", "1693"),
-            Pair("Crime", "26"),
-            Pair("Documentary", "131"),
-            Pair("Drama", "1"),
-            Pair("Family", "43"),
-            Pair("Fantasy", "31"),
-            Pair("Film-Noir", "1068395"),
-            Pair("Game-Show", "212"),
-            Pair("History", "47"),
-            Pair("Horror", "74"),
-            Pair("Kungfu", "248"),
-            Pair("Music", "199"),
-            Pair("Musical", "1066604"),
-            Pair("Mystery", "64"),
-            Pair("News", "1066549"),
-            Pair("Reality", "1123750"),
-            Pair("Reality-TV", "4"),
-            Pair("Romance", "23"),
-            Pair("Sci-Fi", "15"),
-            Pair("Short", "1066916"),
-            Pair("Sport", "44"),
-            Pair("Talk", "1124002"),
-            Pair("Talk-Show", "1067786"),
-            Pair("Thriller", "7"),
-            Pair("TV Movie", "1123752"),
-            Pair("TV Show", "139"),
-            Pair("War", "58"),
-            Pair("Western", "28"),
-        )
-
-        val COUNTRIES = arrayOf(
-            Pair("Argentina", "181863"),
-            Pair("Australia", "181851"),
-            Pair("Austria", "181882"),
-            Pair("Belgium", "181849"),
-            Pair("Brazil", "181867"),
-            Pair("Canada", "181861"),
-            Pair("China", "108"),
-            Pair("Czech Republic", "181859"),
-            Pair("Denmark", "181855"),
-            Pair("Finland", "181877"),
-            Pair("France", "11"),
-            Pair("Germany", "1025332"),
-            Pair("Hong Kong", "2630"),
-            Pair("Hungary", "181876"),
-            Pair("India", "34"),
-            Pair("Ireland", "181862"),
-            Pair("Israel", "181887"),
-            Pair("Italy", "181857"),
-            Pair("Japan", "36"),
-            Pair("Luxembourg", "181878"),
-            Pair("Mexico", "181852"),
-            Pair("Netherlands", "181848"),
-            Pair("New Zealand", "181847"),
-            Pair("Norway", "181901"),
-            Pair("Philippines", "1025339"),
-            Pair("Poland", "181880"),
-            Pair("Romania", "181895"),
-            Pair("Russia", "181860"),
-            Pair("South Africa", "181850"),
-            Pair("South Korea", "1025429"),
-            Pair("Spain", "181871"),
-            Pair("Sweden", "181883"),
-            Pair("Switzerland", "181869"),
-            Pair("Thailand", "94"),
-            Pair("Turkey", "1025379"),
-            Pair("United Kingdom", "8"),
-            Pair("United States", "2"),
-        )
-
-        val YEARS = arrayOf(
-            Pair("2024", "2024"),
-            Pair("2023", "2023"),
-            Pair("2022", "2022"),
-            Pair("2021", "2021"),
-            Pair("2020", "2020"),
-            Pair("2019", "2019"),
-            Pair("2018", "2018"),
-            Pair("2017", "2017"),
-            Pair("2016", "2016"),
-            Pair("2015", "2015"),
-            Pair("2014", "2014"),
-            Pair("2013", "2013"),
-            Pair("2012", "2012"),
-            Pair("2011", "2011"),
-            Pair("2010", "2010"),
-            Pair("2009", "2009"),
-            Pair("2008", "2008"),
-            Pair("2007", "2007"),
-            Pair("2006", "2006"),
-            Pair("2005", "2005"),
-            Pair("2004", "2004"),
-            Pair("2003", "2003"),
-            Pair("2000s", "2000s"),
-            Pair("1990s", "1990s"),
-            Pair("1980s", "1980s"),
-            Pair("1970s", "1970s"),
-            Pair("1960s", "1960s"),
-            Pair("1950s", "1950s"),
-            Pair("1940s", "1940s"),
-            Pair("1930s", "1930s"),
-            Pair("1920s", "1920s"),
-            Pair("1910s", "1910s"),
-        )
-
-        val RATINGS = arrayOf(
-            Pair("12", "12"),
-            Pair("13+", "13+"),
-            Pair("16+", "16+"),
-            Pair("18", "18"),
-            Pair("18+", "18+"),
-            Pair("AO", "AO"),
-            Pair("C", "C"),
-            Pair("E", "E"),
-            Pair("G", "G"),
-            Pair("GP", "GP"),
-            Pair("M", "M"),
-            Pair("M/PG", "M/PG"),
-            Pair("MA-13", "MA-13"),
-            Pair("MA-17", "MA-17"),
-            Pair("NC-17", "NC-17"),
-            Pair("PG", "PG"),
-            Pair("PG-13", "PG-13"),
-            Pair("R", "R"),
-            Pair("TV_MA", "TV_MA"),
-            Pair("TV-13", "TV-13"),
-            Pair("TV-14", "TV-14"),
-            Pair("TV-G", "TV-G"),
-            Pair("TV-MA", "TV-MA"),
-            Pair("TV-PG", "TV-PG"),
-            Pair("TV-Y", "TV-Y"),
-            Pair("TV-Y7", "TV-Y7"),
-            Pair("TV-Y7-FV", "TV-Y7-FV"),
-            Pair("X", "X"),
-        )
-
-        val QUALITIES = arrayOf(
-            Pair("HD", "HD"),
-            Pair("HDRip", "HDRip"),
-            Pair("SD", "SD"),
-            Pair("TS", "TS"),
-            Pair("CAM", "CAM"),
-        )
-
-        val SORT = arrayOf(
-            Pair("Most relevance", "most_relevance"),
-            Pair("Recently updated", "recently_updated"),
-            Pair("Recently added", "recently_added"),
-            Pair("Release date", "release_date"),
-            Pair("Trending", "trending"),
-            Pair("Name A-Z", "title_az"),
-            Pair("Scores", "scores"),
-            Pair("IMDb", "imdb"),
-            Pair("Most watched", "most_watched"),
-            Pair("Most favourited", "most_favourited"),
-        )
-    }
-}
diff --git a/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FmoviesUtils.kt b/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FmoviesUtils.kt
deleted file mode 100644
index 31b7a95c..00000000
--- a/src/en/fmovies/src/eu/kanade/tachiyomi/animeextension/en/fmovies/FmoviesUtils.kt
+++ /dev/null
@@ -1,140 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.en.fmovies
-
-import android.util.Base64
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import eu.kanade.tachiyomi.util.parseAs
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-import okhttp3.Headers
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.OkHttpClient
-import java.net.URLDecoder
-import javax.crypto.Cipher
-import javax.crypto.spec.SecretKeySpec
-
-class FmoviesUtils(private val client: OkHttpClient, private val headers: Headers) {
-
-    // ===================== Media Detail ================================
-
-    private val tmdbURL = "https://api.themoviedb.org/3".toHttpUrl()
-
-    private val seez = "https://seez.su"
-
-    private val apiKey by lazy {
-        val jsUrl = client.newCall(GET(seez, headers)).execute().asJsoup()
-            .select("script[defer][src]")[1].attr("abs:src")
-
-        val jsBody = client.newCall(GET(jsUrl, headers)).execute().use { it.body.string() }
-        Regex("""f="(\w{20,})"""").find(jsBody)!!.groupValues[1]
-    }
-
-    private val apiHeaders = headers.newBuilder().apply {
-        add("Accept", "application/json, text/javascript, */*; q=0.01")
-        add("Host", "api.themoviedb.org")
-        add("Origin", seez)
-        add("Referer", "$seez/")
-    }.build()
-
-    fun getDetail(mediaTitle: String): TmdbDetailsResponse? =
-        runCatching {
-            val searchUrl = tmdbURL.newBuilder().apply {
-                addPathSegment("search")
-                addPathSegment("multi")
-                addQueryParameter("query", mediaTitle)
-                addQueryParameter("api_key", apiKey)
-            }.build().toString()
-            val searchResp = client.newCall(GET(searchUrl, headers = apiHeaders))
-                .execute()
-                .parseAs<TmdbResponse>()
-
-            val media = searchResp.results.first()
-
-            val detailUrl = tmdbURL.newBuilder().apply {
-                addPathSegment(media.mediaType)
-                addPathSegment(media.id.toString())
-                addQueryParameter("api_key", apiKey)
-            }.build().toString()
-            client.newCall(GET(detailUrl, headers = apiHeaders))
-                .execute()
-                .parseAs<TmdbDetailsResponse>()
-        }.getOrNull()
-
-    // ===================== Encryption ================================
-    fun vrfEncrypt(input: String): String {
-        val rc4Key = SecretKeySpec("Ij4aiaQXgluXQRs6".toByteArray(), "RC4")
-        val cipher = Cipher.getInstance("RC4")
-        cipher.init(Cipher.ENCRYPT_MODE, rc4Key, cipher.parameters)
-
-        var vrf = cipher.doFinal(input.toByteArray())
-        vrf = Base64.encode(vrf, Base64.URL_SAFE or Base64.NO_WRAP)
-//        vrf = rot13(vrf)
-        vrf = Base64.encode(vrf, Base64.URL_SAFE or Base64.NO_WRAP)
-        vrf.reverse()
-        vrf = Base64.encode(vrf, Base64.URL_SAFE or Base64.NO_WRAP)
-        vrf = vrfShift(vrf)
-        val stringVrf = vrf.toString(Charsets.UTF_8)
-        return java.net.URLEncoder.encode(stringVrf, "utf-8")
-    }
-
-    fun vrfDecrypt(input: String): String {
-        var vrf = input.toByteArray()
-        vrf = Base64.decode(vrf, Base64.URL_SAFE)
-
-        val rc4Key = SecretKeySpec("8z5Ag5wgagfsOuhz".toByteArray(), "RC4")
-        val cipher = Cipher.getInstance("RC4")
-        cipher.init(Cipher.DECRYPT_MODE, rc4Key, cipher.parameters)
-        vrf = cipher.doFinal(vrf)
-
-        return URLDecoder.decode(vrf.toString(Charsets.UTF_8), "utf-8")
-    }
-
-    private fun rot13(vrf: ByteArray): ByteArray {
-        for (i in vrf.indices) {
-            val byte = vrf[i]
-            if (byte in 'A'.code..'Z'.code) {
-                vrf[i] = ((byte - 'A'.code + 13) % 26 + 'A'.code).toByte()
-            } else if (byte in 'a'.code..'z'.code) {
-                vrf[i] = ((byte - 'a'.code + 13) % 26 + 'a'.code).toByte()
-            }
-        }
-        return vrf
-    }
-
-    private fun vrfShift(vrf: ByteArray): ByteArray {
-        for (i in vrf.indices) {
-            val shift = arrayOf(4, 3, -2, 5, 2, -4, -4, 2)[i % 8]
-            vrf[i] = vrf[i].plus(shift).toByte()
-        }
-        return vrf
-    }
-}
-
-@Serializable
-data class TmdbResponse(
-    val results: List<TmdbResult>,
-) {
-    @Serializable
-    data class TmdbResult(
-        val id: Int,
-        @SerialName("media_type")
-        val mediaType: String = "tv",
-    )
-}
-
-@Serializable
-data class TmdbDetailsResponse(
-    val status: String,
-    val overview: String? = null,
-    @SerialName("next_episode_to_air")
-    val nextEpisode: NextEpisode? = null,
-) {
-    @Serializable
-    data class NextEpisode(
-        val name: String? = "",
-        @SerialName("episode_number")
-        val epNumber: Int,
-        @SerialName("air_date")
-        val airDate: String,
-    )
-}
diff --git a/src/en/gogoanime/build.gradle b/src/en/gogoanime/build.gradle
deleted file mode 100644
index 9ac6d8eb..00000000
--- a/src/en/gogoanime/build.gradle
+++ /dev/null
@@ -1,14 +0,0 @@
-ext {
-    extName = 'Gogoanime'
-    extClass = '.GogoAnime'
-    extVersionCode = 87
-}
-
-apply from: "$rootDir/common.gradle"
-
-dependencies {
-    implementation(project(':lib:streamwish-extractor'))
-    implementation(project(':lib:mp4upload-extractor'))
-    implementation(project(':lib:dood-extractor'))
-    implementation(project(':lib:gogostream-extractor'))
-}
\ No newline at end of file
diff --git a/src/en/gogoanime/res/mipmap-hdpi/ic_launcher.png b/src/en/gogoanime/res/mipmap-hdpi/ic_launcher.png
deleted file mode 100644
index 9e4d2f6b..00000000
Binary files a/src/en/gogoanime/res/mipmap-hdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/gogoanime/res/mipmap-mdpi/ic_launcher.png b/src/en/gogoanime/res/mipmap-mdpi/ic_launcher.png
deleted file mode 100644
index 1bd68c8c..00000000
Binary files a/src/en/gogoanime/res/mipmap-mdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/gogoanime/res/mipmap-xhdpi/ic_launcher.png b/src/en/gogoanime/res/mipmap-xhdpi/ic_launcher.png
deleted file mode 100644
index 4f2d6d97..00000000
Binary files a/src/en/gogoanime/res/mipmap-xhdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/gogoanime/res/mipmap-xxhdpi/ic_launcher.png b/src/en/gogoanime/res/mipmap-xxhdpi/ic_launcher.png
deleted file mode 100644
index 1a6056f7..00000000
Binary files a/src/en/gogoanime/res/mipmap-xxhdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/gogoanime/res/mipmap-xxxhdpi/ic_launcher.png b/src/en/gogoanime/res/mipmap-xxxhdpi/ic_launcher.png
deleted file mode 100644
index 67e41341..00000000
Binary files a/src/en/gogoanime/res/mipmap-xxxhdpi/ic_launcher.png and /dev/null differ
diff --git a/src/en/gogoanime/src/eu/kanade/tachiyomi/animeextension/en/gogoanime/GogoAnime.kt b/src/en/gogoanime/src/eu/kanade/tachiyomi/animeextension/en/gogoanime/GogoAnime.kt
deleted file mode 100644
index b05f103c..00000000
--- a/src/en/gogoanime/src/eu/kanade/tachiyomi/animeextension/en/gogoanime/GogoAnime.kt
+++ /dev/null
@@ -1,299 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.en.gogoanime
-
-import android.app.Application
-import androidx.preference.ListPreference
-import androidx.preference.MultiSelectListPreference
-import androidx.preference.PreferenceScreen
-import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
-import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
-import eu.kanade.tachiyomi.animesource.model.SAnime
-import eu.kanade.tachiyomi.animesource.model.SEpisode
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.animesource.online.ParsedAnimeHttpSource
-import eu.kanade.tachiyomi.lib.doodextractor.DoodExtractor
-import eu.kanade.tachiyomi.lib.gogostreamextractor.GogoStreamExtractor
-import eu.kanade.tachiyomi.lib.mp4uploadextractor.Mp4uploadExtractor
-import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
-import okhttp3.Request
-import okhttp3.Response
-import org.jsoup.nodes.Document
-import org.jsoup.nodes.Element
-import uy.kohesive.injekt.Injekt
-import uy.kohesive.injekt.api.get
-
-class GogoAnime : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
-
-    override val name = "Gogoanime"
-
-    // TODO: Check frequency of url changes to potentially
-    // add back overridable baseurl preference
-    override val baseUrl = "https://anitaku.to"
-
-    override val lang = "en"
-
-    override val supportsLatest = true
-
-    override fun headersBuilder() = super.headersBuilder()
-        .add("Origin", baseUrl)
-        .add("Referer", "$baseUrl/")
-
-    private val preferences by lazy {
-        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
-    }
-
-    // ============================== Popular ===============================
-    override fun popularAnimeRequest(page: Int): Request = GET("$baseUrl/popular.html?page=$page", headers)
-
-    override fun popularAnimeSelector(): String = "div.img a"
-
-    override fun popularAnimeFromElement(element: Element): SAnime = SAnime.create().apply {
-        setUrlWithoutDomain(element.attr("href"))
-        thumbnail_url = element.selectFirst("img")!!.attr("src")
-        title = element.attr("title")
-    }
-
-    override fun popularAnimeNextPageSelector(): String = "ul.pagination-list li:last-child:not(.selected)"
-
-    // =============================== Latest ===============================
-    override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/home.html?page=$page", headers)
-
-    override fun latestUpdatesSelector(): String = "div.img a"
-
-    override fun latestUpdatesFromElement(element: Element) = SAnime.create().apply {
-        thumbnail_url = element.selectFirst("img")?.attr("src")
-        title = element.attr("title")
-        val slug = element.attr("href").substringAfter(baseUrl)
-            .trimStart('/')
-            .substringBefore("-episode-")
-        setUrlWithoutDomain("/category/$slug")
-    }
-
-    override fun latestUpdatesNextPageSelector(): String = popularAnimeNextPageSelector()
-
-    // =============================== Search ===============================
-    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
-        val params = GogoAnimeFilters.getSearchParameters(filters)
-
-        return when {
-            params.genre.isNotEmpty() -> GET("$baseUrl/genre/${params.genre}?page=$page", headers)
-            params.recent.isNotEmpty() -> GET("$AJAX_URL/page-recent-release.html?page=$page&type=${params.recent}", headers)
-            params.season.isNotEmpty() -> GET("$baseUrl/${params.season}?page=$page", headers)
-            else -> GET("$baseUrl/filter.html?keyword=$query&${params.filter}&page=$page", headers)
-        }
-    }
-
-    override fun searchAnimeSelector(): String = popularAnimeSelector()
-
-    override fun searchAnimeFromElement(element: Element): SAnime = popularAnimeFromElement(element)
-
-    override fun searchAnimeNextPageSelector(): String = popularAnimeNextPageSelector()
-
-    // ============================== Filters ===============================
-    override fun getFilterList(): AnimeFilterList = GogoAnimeFilters.FILTER_LIST
-
-    // =========================== Anime Details ============================
-    override fun animeDetailsParse(document: Document): SAnime {
-        val infoDocument = document.selectFirst("div.anime-info a[href]")?.let {
-            client.newCall(GET(it.absUrl("href"), headers)).execute().asJsoup()
-        } ?: document
-
-        return SAnime.create().apply {
-            title = infoDocument.selectFirst("div.anime_info_body_bg > h1")!!.text()
-            genre = infoDocument.getInfo("Genre:")
-            status = parseStatus(infoDocument.getInfo("Status:").orEmpty())
-
-            description = buildString {
-                val summary = infoDocument.selectFirst("div.anime_info_body_bg > div.description")
-                append(summary?.text())
-
-                // add alternative name to anime description
-                infoDocument.getInfo("Other name:")?.also {
-                    if (isNotBlank()) append("\n\n")
-                    append("Other name(s): $it")
-                }
-            }
-        }
-    }
-
-    // ============================== Episodes ==============================
-    private fun episodesRequest(totalEpisodes: String, id: String): List<SEpisode> {
-        val request = GET("$AJAX_URL/load-list-episode?ep_start=0&ep_end=$totalEpisodes&id=$id", headers)
-        val epResponse = client.newCall(request).execute()
-        val document = epResponse.asJsoup()
-        return document.select("a").map(::episodeFromElement)
-    }
-
-    override fun episodeListParse(response: Response): List<SEpisode> {
-        val document = response.asJsoup()
-        val totalEpisodes = document.select(episodeListSelector()).last()!!.attr("ep_end")
-        val id = document.select("input#movie_id").attr("value")
-        return episodesRequest(totalEpisodes, id)
-    }
-
-    override fun episodeListSelector() = "ul#episode_page li a"
-
-    override fun episodeFromElement(element: Element): SEpisode {
-        val ep = element.selectFirst("div.name")!!.ownText().substringAfter(" ")
-        return SEpisode.create().apply {
-            setUrlWithoutDomain(element.attr("abs:href"))
-            episode_number = ep.toFloat()
-            name = "Episode $ep"
-        }
-    }
-
-    // ============================ Video Links =============================
-    private val gogoExtractor by lazy { GogoStreamExtractor(client) }
-    private val streamwishExtractor by lazy { StreamWishExtractor(client, headers) }
-    private val doodExtractor by lazy { DoodExtractor(client) }
-    private val mp4uploadExtractor by lazy { Mp4uploadExtractor(client) }
-
-    override fun videoListParse(response: Response): List<Video> {
-        val document = response.asJsoup()
-        val hosterSelection = preferences.getStringSet(PREF_HOSTER_KEY, PREF_HOSTER_DEFAULT)!!
-
-        return document.select("div.anime_muti_link > ul > li").parallelCatchingFlatMapBlocking { server ->
-            val className = server.className()
-            if (!hosterSelection.contains(className)) return@parallelCatchingFlatMapBlocking emptyList()
-            val serverUrl = server.selectFirst("a")
-                ?.attr("abs:data-video")
-                ?: return@parallelCatchingFlatMapBlocking emptyList()
-
-            getHosterVideos(className, serverUrl)
-        }
-    }
-
-    private fun getHosterVideos(className: String, serverUrl: String): List<Video> {
-        return when (className) {
-            "anime", "vidcdn" -> gogoExtractor.videosFromUrl(serverUrl)
-            "streamwish" -> streamwishExtractor.videosFromUrl(serverUrl)
-            "doodstream" -> doodExtractor.videosFromUrl(serverUrl)
-            "mp4upload" -> mp4uploadExtractor.videosFromUrl(serverUrl, headers)
-            "filelions" -> {
-                streamwishExtractor.videosFromUrl(serverUrl, videoNameGen = { quality -> "FileLions - $quality" })
-            }
-            else -> emptyList()
-        }
-    }
-
-    override fun videoListSelector() = throw UnsupportedOperationException()
-
-    override fun videoFromElement(element: Element) = throw UnsupportedOperationException()
-
-    override fun videoUrlParse(document: Document) = throw UnsupportedOperationException()
-
-    // ============================= Utilities ==============================
-    private fun Document.getInfo(text: String): String? {
-        val base = selectFirst("p.type:has(span:containsOwn($text))") ?: return null
-        return base.select("a").eachText().joinToString("")
-            .ifBlank { base.ownText() }
-            .takeUnless(String::isBlank)
-    }
-
-    override fun List<Video>.sort(): List<Video> {
-        val quality = preferences.getString(PREF_QUALITY_KEY, PREF_QUALITY_DEFAULT)!!
-        val server = preferences.getString(PREF_SERVER_KEY, PREF_SERVER_DEFAULT)!!
-
-        return sortedWith(
-            compareBy(
-                { it.quality.contains(quality) },
-                { Regex("""(\d+)p""").find(it.quality)?.groupValues?.get(1)?.toIntOrNull() ?: 0 },
-                { it.quality.contains(server) },
-            ),
-        ).reversed()
-    }
-
-    private fun parseStatus(statusString: String): Int {
-        return when (statusString) {
-            "Ongoing" -> SAnime.ONGOING
-            "Completed" -> SAnime.COMPLETED
-            else -> SAnime.UNKNOWN
-        }
-    }
-
-    companion object {
-        private const val AJAX_URL = "https://ajax.gogocdn.net/ajax"
-
-        private val HOSTERS = arrayOf(
-            "Gogostream",
-            "Vidstreaming",
-            "Doodstream",
-            "StreamWish",
-            "Mp4upload",
-            "FileLions",
-        )
-        private val HOSTERS_NAMES = arrayOf(
-            // Names that appears in the gogo html
-            "vidcdn",
-            "anime",
-            "doodstream",
-            "streamwish",
-            "mp4upload",
-            "filelions",
-        )
-
-        private const val PREF_QUALITY_KEY = "preferred_quality"
-        private const val PREF_QUALITY_TITLE = "Preferred quality"
-        private const val PREF_QUALITY_DEFAULT = "1080"
-        private val PREF_QUALITY_ENTRIES = arrayOf("1080p", "720p", "480p", "360p")
-        private val PREF_QUALITY_VALUES = arrayOf("1080", "720", "480", "360")
-
-        private const val PREF_SERVER_KEY = "preferred_server"
-        private const val PREF_SERVER_TITLE = "Preferred server"
-        private const val PREF_SERVER_DEFAULT = "Gogostream"
-
-        private const val PREF_HOSTER_KEY = "hoster_selection"
-        private const val PREF_HOSTER_TITLE = "Enable/Disable Hosts"
-        private val PREF_HOSTER_DEFAULT = HOSTERS_NAMES.toSet()
-    }
-
-    // ============================== Settings ==============================
-    override fun setupPreferenceScreen(screen: PreferenceScreen) {
-        ListPreference(screen.context).apply {
-            key = PREF_QUALITY_KEY
-            title = PREF_QUALITY_TITLE
-            entries = PREF_QUALITY_ENTRIES
-            entryValues = PREF_QUALITY_VALUES
-            setDefaultValue(PREF_QUALITY_DEFAULT)
-            summary = "%s"
-
-            setOnPreferenceChangeListener { _, newValue ->
-                val selected = newValue as String
-                val index = findIndexOfValue(selected)
-                val entry = entryValues[index] as String
-                preferences.edit().putString(key, entry).commit()
-            }
-        }.also(screen::addPreference)
-
-        ListPreference(screen.context).apply {
-            key = PREF_SERVER_KEY
-            title = PREF_SERVER_TITLE
-            entries = HOSTERS
-            entryValues = HOSTERS
-            setDefaultValue(PREF_SERVER_DEFAULT)
-            summary = "%s"
-
-            setOnPreferenceChangeListener { _, newValue ->
-                val selected = newValue as String
-                val index = findIndexOfValue(selected)
-                val entry = entryValues[index] as String
-                preferences.edit().putString(key, entry).commit()
-            }
-        }.also(screen::addPreference)
-
-        MultiSelectListPreference(screen.context).apply {
-            key = PREF_HOSTER_KEY
-            title = PREF_HOSTER_TITLE
-            entries = HOSTERS
-            entryValues = HOSTERS_NAMES
-            setDefaultValue(PREF_HOSTER_DEFAULT)
-
-            setOnPreferenceChangeListener { _, newValue ->
-                @Suppress("UNCHECKED_CAST")
-                preferences.edit().putStringSet(key, newValue as Set<String>).commit()
-            }
-        }.also(screen::addPreference)
-    }
-}
diff --git a/src/en/gogoanime/src/eu/kanade/tachiyomi/animeextension/en/gogoanime/GogoAnimeFilters.kt b/src/en/gogoanime/src/eu/kanade/tachiyomi/animeextension/en/gogoanime/GogoAnimeFilters.kt
deleted file mode 100644
index a72b81a3..00000000
--- a/src/en/gogoanime/src/eu/kanade/tachiyomi/animeextension/en/gogoanime/GogoAnimeFilters.kt
+++ /dev/null
@@ -1,414 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.en.gogoanime
-
-import eu.kanade.tachiyomi.animesource.model.AnimeFilter
-import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
-
-object GogoAnimeFilters {
-    open class QueryPartFilter(
-        displayName: String,
-        val vals: Array<Pair<String, String>>,
-    ) : AnimeFilter.Select<String>(
-        displayName,
-        vals.map { it.first }.toTypedArray(),
-    ) {
-        fun toQueryPart() = vals[state].second
-    }
-
-    open class CheckBoxFilterList(name: String, val pairs: Array<Pair<String, String>>) :
-        AnimeFilter.Group<AnimeFilter.CheckBox>(name, pairs.map { CheckBoxVal(it.first, false) })
-
-    private class CheckBoxVal(name: String, state: Boolean = false) : AnimeFilter.CheckBox(name, state)
-
-    private inline fun <reified R> AnimeFilterList.asQueryPart(): String {
-        return (getFirst<R>() as QueryPartFilter).toQueryPart()
-    }
-
-    private inline fun <reified R> AnimeFilterList.getFirst(): R {
-        return first { it is R } as R
-    }
-
-    private inline fun <reified R> AnimeFilterList.parseCheckbox(
-        options: Array<Pair<String, String>>,
-        name: String,
-    ): String {
-        return (getFirst<R>() as CheckBoxFilterList).state
-            .filter { it.state }
-            .map { checkbox -> options.find { it.first == checkbox.name }!!.second }
-            .filter(String::isNotBlank)
-            .joinToString("&") { "$name[]=$it" }
-    }
-
-    class GenreSearchFilter : CheckBoxFilterList("Genre", GogoAnimeFiltersData.GENRE_SEARCH_LIST)
-    class CountrySearchFilter : CheckBoxFilterList("Country", GogoAnimeFiltersData.COUNTRY_SEARCH_LIST)
-    class SeasonSearchFilter : CheckBoxFilterList("Season", GogoAnimeFiltersData.SEASON_SEARCH_LIST)
-    class YearSearchFilter : CheckBoxFilterList("Year", GogoAnimeFiltersData.YEAR_SEARCH_LIST)
-    class LanguageSearchFilter : CheckBoxFilterList("Language", GogoAnimeFiltersData.LANGUAGE_SEARCH_LIST)
-    class TypeSearchFilter : CheckBoxFilterList("Type", GogoAnimeFiltersData.TYPE_SEARCH_LIST)
-    class StatusSearchFilter : CheckBoxFilterList("Status", GogoAnimeFiltersData.STATUS_SEARCH_LIST)
-    class SortSearchFilter : QueryPartFilter("Sort by", GogoAnimeFiltersData.SORT_SEARCH_LIST)
-
-    class GenreFilter : QueryPartFilter("Genre", GogoAnimeFiltersData.GENRE_LIST)
-    class RecentFilter : QueryPartFilter("Recent episodes", GogoAnimeFiltersData.RECENT_LIST)
-    class SeasonFilter : QueryPartFilter("Season", GogoAnimeFiltersData.SEASON_LIST)
-
-    val FILTER_LIST get() = AnimeFilterList(
-        AnimeFilter.Header("Advanced search"),
-        GenreSearchFilter(),
-        CountrySearchFilter(),
-        SeasonSearchFilter(),
-        YearSearchFilter(),
-        LanguageSearchFilter(),
-        TypeSearchFilter(),
-        StatusSearchFilter(),
-        SortSearchFilter(),
-        AnimeFilter.Separator(),
-        AnimeFilter.Header("Select sub-page"),
-        AnimeFilter.Header("Note: Ignores search & other filters"),
-        GenreFilter(),
-        RecentFilter(),
-        SeasonFilter(),
-    )
-
-    data class FilterSearchParams(
-        val filter: String = "",
-        val genre: String = "",
-        val recent: String = "",
-        val season: String = "",
-    )
-
-    internal fun getSearchParameters(filters: AnimeFilterList): FilterSearchParams {
-        if (filters.isEmpty()) return FilterSearchParams()
-
-        val filter = buildList {
-            add(filters.parseCheckbox<GenreSearchFilter>(GogoAnimeFiltersData.GENRE_SEARCH_LIST, "genre"))
-            add(filters.parseCheckbox<CountrySearchFilter>(GogoAnimeFiltersData.GENRE_SEARCH_LIST, "country"))
-            add(filters.parseCheckbox<SeasonSearchFilter>(GogoAnimeFiltersData.SEASON_SEARCH_LIST, "season"))
-            add(filters.parseCheckbox<YearSearchFilter>(GogoAnimeFiltersData.YEAR_SEARCH_LIST, "year"))
-            add(filters.parseCheckbox<LanguageSearchFilter>(GogoAnimeFiltersData.LANGUAGE_SEARCH_LIST, "language"))
-            add(filters.parseCheckbox<TypeSearchFilter>(GogoAnimeFiltersData.TYPE_SEARCH_LIST, "type"))
-            add(filters.parseCheckbox<StatusSearchFilter>(GogoAnimeFiltersData.STATUS_SEARCH_LIST, "status"))
-            add("sort=${filters.asQueryPart<SortSearchFilter>()}")
-        }.filter(String::isNotBlank).joinToString("&")
-
-        return FilterSearchParams(
-            filter,
-            filters.asQueryPart<GenreFilter>(),
-            filters.asQueryPart<RecentFilter>(),
-            filters.asQueryPart<SeasonFilter>(),
-        )
-    }
-
-    private object GogoAnimeFiltersData {
-        // copy($("div.cls_genre ul.dropdown-menu li").map((i,el) => `Pair("${$(el).text().trim()}", "${$(el).find("input").first().attr('value')}")`).get().join(',\n'))
-        // on /filter.html
-        val GENRE_SEARCH_LIST = arrayOf(
-            Pair("Action", "action"),
-            Pair("Adult Cast", "adult-cast"),
-            Pair("Adventure", "adventure"),
-            Pair("Anthropomorphic", "anthropomorphic"),
-            Pair("Avant Garde", "avant-garde"),
-            Pair("Boys Love", "shounen-ai"),
-            Pair("Cars", "cars"),
-            Pair("CGDCT", "cgdct"),
-            Pair("Childcare", "childcare"),
-            Pair("Comedy", "comedy"),
-            Pair("Comic", "comic"),
-            Pair("Crime", "crime"),
-            Pair("Crossdressing", "crossdressing"),
-            Pair("Delinquents", "delinquents"),
-            Pair("Dementia", "dementia"),
-            Pair("Demons", "demons"),
-            Pair("Detective", "detective"),
-            Pair("Drama", "drama"),
-            Pair("Dub", "dub"),
-            Pair("Ecchi", "ecchi"),
-            Pair("Erotica", "erotica"),
-            Pair("Family", "family"),
-            Pair("Fantasy", "fantasy"),
-            Pair("Gag Humor", "gag-humor"),
-            Pair("Game", "game"),
-            Pair("Gender Bender", "gender-bender"),
-            Pair("Gore", "gore"),
-            Pair("Gourmet", "gourmet"),
-            Pair("Harem", "harem"),
-            Pair("Hentai", "hentai"),
-            Pair("High Stakes Game", "high-stakes-game"),
-            Pair("Historical", "historical"),
-            Pair("Horror", "horror"),
-            Pair("Isekai", "isekai"),
-            Pair("Iyashikei", "iyashikei"),
-            Pair("Josei", "josei"),
-            Pair("Kids", "kids"),
-            Pair("Magic", "magic"),
-            Pair("Magical Sex Shift", "magical-sex-shift"),
-            Pair("Mahou Shoujo", "mahou-shoujo"),
-            Pair("Martial Arts", "martial-arts"),
-            Pair("Mecha", "mecha"),
-            Pair("Medical", "medical"),
-            Pair("Military", "military"),
-            Pair("Music", "music"),
-            Pair("Mystery", "mystery"),
-            Pair("Mythology", "mythology"),
-            Pair("Organized Crime", "organized-crime"),
-            Pair("Parody", "parody"),
-            Pair("Performing Arts", "performing-arts"),
-            Pair("Pets", "pets"),
-            Pair("Police", "police"),
-            Pair("Psychological", "psychological"),
-            Pair("Racing", "racing"),
-            Pair("Reincarnation", "reincarnation"),
-            Pair("Romance", "romance"),
-            Pair("Romantic Subtext", "romantic-subtext"),
-            Pair("Samurai", "samurai"),
-            Pair("School", "school"),
-            Pair("Sci-Fi", "sci-fi"),
-            Pair("Seinen", "seinen"),
-            Pair("Shoujo", "shoujo"),
-            Pair("Shoujo Ai", "shoujo-ai"),
-            Pair("Shounen", "shounen"),
-            Pair("Showbiz", "showbiz"),
-            Pair("Slice of Life", "slice-of-life"),
-            Pair("Space", "space"),
-            Pair("Sports", "sports"),
-            Pair("Strategy Game", "strategy-game"),
-            Pair("Super Power", "super-power"),
-            Pair("Supernatural", "supernatural"),
-            Pair("Survival", "survival"),
-            Pair("Suspense", "suspense"),
-            Pair("Team Sports", "team-sports"),
-            Pair("Thriller", "thriller"),
-            Pair("Time Travel", "time-travel"),
-            Pair("Vampire", "vampire"),
-            Pair("Visual Arts", "visual-arts"),
-            Pair("Work Life", "work-life"),
-            Pair("Workplace", "workplace"),
-            Pair("Yaoi", "yaoi"),
-            Pair("Yuri", "yuri"),
-        )
-
-        // copy($("div.cls_genre ul.dropdown-menu li").map((i,el) => `Pair("${$(el).text().trim()}", "${$(el).find("input").first().attr('value')}")`).get().join(',\n'))
-        // on /filter.html
-        val COUNTRY_SEARCH_LIST = arrayOf(
-            Pair("China", "5"),
-            Pair("Japan", "2"),
-        )
-
-        // copy($("div.cls_season ul.dropdown-menu li").map((i,el) => `Pair("${$(el).text().trim()}", "${$(el).find("input").first().attr('value')}")`).get().join(',\n'))
-        // on /filter.html
-        val SEASON_SEARCH_LIST = arrayOf(
-            Pair("Fall", "fall"),
-            Pair("Summer", "summer"),
-            Pair("Spring", "spring"),
-            Pair("Winter", "winter"),
-        )
-
-        // copy($("div.cls_year ul.dropdown-menu li").map((i,el) => `Pair("${$(el).text().trim()}", "${$(el).find("input").first().attr('value')}")`).get().join(',\n'))
-        // on /filter.html
-        val YEAR_SEARCH_LIST = arrayOf(
-            Pair("2024", "2024"),
-            Pair("2023", "2023"),
-            Pair("2022", "2022"),
-            Pair("2021", "2021"),
-            Pair("2020", "2020"),
-            Pair("2019", "2019"),
-            Pair("2018", "2018"),
-            Pair("2017", "2017"),
-            Pair("2016", "2016"),
-            Pair("2015", "2015"),
-            Pair("2014", "2014"),
-            Pair("2013", "2013"),
-            Pair("2012", "2012"),
-            Pair("2011", "2011"),
-            Pair("2010", "2010"),
-            Pair("2009", "2009"),
-            Pair("2008", "2008"),
-            Pair("2007", "2007"),
-            Pair("2006", "2006"),
-            Pair("2005", "2005"),
-            Pair("2004", "2004"),
-            Pair("2003", "2003"),
-            Pair("2002", "2002"),
-            Pair("2001", "2001"),
-            Pair("2000", "2000"),
-            Pair("1999", "1999"),
-        )
-
-        // copy($("div.cls_lang ul.dropdown-menu li").map((i,el) => `Pair("${$(el).text().trim()}", "${$(el).find("input").first().attr('value')}")`).get().join(',\n'))
-        // on /filter.html
-        val LANGUAGE_SEARCH_LIST = arrayOf(
-            Pair("Sub & Dub", "subdub"),
-            Pair("Sub", "sub"),
-            Pair("Dub", "dub"),
-        )
-
-        // copy($("div.cls_type ul.dropdown-menu li").map((i,el) => `Pair("${$(el).text().trim()}", "${$(el).find("input").first().attr('value')}")`).get().join(',\n'))
-        // on /filter.html
-        val TYPE_SEARCH_LIST = arrayOf(
-            Pair("Movie", "3"),
-            Pair("TV", "1"),
-            Pair("OVA", "26"),
-            Pair("ONA", "30"),
-            Pair("Special", "2"),
-            Pair("Music", "32"),
-        )
-
-        // copy($("div.cls_status ul.dropdown-menu li").map((i,el) => `Pair("${$(el).text().trim()}", "${$(el).find("input").first().attr('value')}")`).get().join(',\n'))
-        // on /filter.html
-        val STATUS_SEARCH_LIST = arrayOf(
-            Pair("Not Yet Aired", "Upcoming"),
-            Pair("Ongoing", "Ongoing"),
-            Pair("Completed", "Completed"),
-        )
-
-        // copy($("div.cls_sort ul.dropdown-menu li").map((i,el) => `Pair("${$(el).text().trim()}", "${$(el).find("input").first().attr('value')}")`).get().join(',\n'))
-        // on /filter.html
-        val SORT_SEARCH_LIST = arrayOf(
-            Pair("Name A-Z", "title_az"),
-            Pair("Recently updated", "recently_updated"),
-            Pair("Recently added", "recently_added"),
-            Pair("Release date", "release_date"),
-        )
-
-        // copy($("div.dropdown-menu > a.dropdown-item").map((i,el) => `Pair("${$(el).text().trim()}", "${$(el).attr('href').trim().slice(18)}")`).get().join(',\n'))
-        // on /
-        val GENRE_LIST = arrayOf(
-            Pair("<select>", ""),
-            Pair("Action", "action"),
-            Pair("Adult Cast", "adult-cast"),
-            Pair("Adventure", "adventure"),
-            Pair("Anthropomorphic", "anthropomorphic"),
-            Pair("Avant Garde", "avant-garde"),
-            Pair("Boys Love", "shounen-ai"),
-            Pair("Cars", "cars"),
-            Pair("CGDCT", "cgdct"),
-            Pair("Childcare", "childcare"),
-            Pair("Comedy", "comedy"),
-            Pair("Comic", "comic"),
-            Pair("Crime", "crime"),
-            Pair("Crossdressing", "crossdressing"),
-            Pair("Delinquents", "delinquents"),
-            Pair("Dementia", "dementia"),
-            Pair("Demons", "demons"),
-            Pair("Detective", "detective"),
-            Pair("Drama", "drama"),
-            Pair("Dub", "dub"),
-            Pair("Ecchi", "ecchi"),
-            Pair("Erotica", "erotica"),
-            Pair("Family", "family"),
-            Pair("Fantasy", "fantasy"),
-            Pair("Gag Humor", "gag-humor"),
-            Pair("Game", "game"),
-            Pair("Gender Bender", "gender-bender"),
-            Pair("Gore", "gore"),
-            Pair("Gourmet", "gourmet"),
-            Pair("Harem", "harem"),
-            Pair("Hentai", "hentai"),
-            Pair("High Stakes Game", "high-stakes-game"),
-            Pair("Historical", "historical"),
-            Pair("Horror", "horror"),
-            Pair("Isekai", "isekai"),
-            Pair("Iyashikei", "iyashikei"),
-            Pair("Josei", "josei"),
-            Pair("Kids", "kids"),
-            Pair("Magic", "magic"),
-            Pair("Magical Sex Shift", "magical-sex-shift"),
-            Pair("Mahou Shoujo", "mahou-shoujo"),
-            Pair("Martial Arts", "martial-arts"),
-            Pair("Mecha", "mecha"),
-            Pair("Medical", "medical"),
-            Pair("Military", "military"),
-            Pair("Music", "music"),
-            Pair("Mystery", "mystery"),
-            Pair("Mythology", "mythology"),
-            Pair("Organized Crime", "organized-crime"),
-            Pair("Parody", "parody"),
-            Pair("Performing Arts", "performing-arts"),
-            Pair("Pets", "pets"),
-            Pair("Police", "police"),
-            Pair("Psychological", "psychological"),
-            Pair("Racing", "racing"),
-            Pair("Reincarnation", "reincarnation"),
-            Pair("Romance", "romance"),
-            Pair("Romantic Subtext", "romantic-subtext"),
-            Pair("Samurai", "samurai"),
-            Pair("School", "school"),
-            Pair("Sci-Fi", "sci-fi"),
-            Pair("Seinen", "seinen"),
-            Pair("Shoujo", "shoujo"),
-            Pair("Shoujo Ai", "shoujo-ai"),
-            Pair("Shounen", "shounen"),
-            Pair("Showbiz", "showbiz"),
-            Pair("Slice of Life", "slice-of-life"),
-            Pair("Space", "space"),
-            Pair("Sports", "sports"),
-            Pair("Strategy Game", "strategy-game"),
-            Pair("Super Power", "super-power"),
-            Pair("Supernatural", "supernatural"),
-            Pair("Survival", "survival"),
-            Pair("Suspense", "suspense"),
-            Pair("Team Sports", "team-sports"),
-            Pair("Thriller", "thriller"),
-            Pair("Time Travel", "time-travel"),
-            Pair("Vampire", "vampire"),
-            Pair("Visual Arts", "visual-arts"),
-            Pair("Work Life", "work-life"),
-            Pair("Workplace", "workplace"),
-            Pair("Yaoi", "yaoi"),
-            Pair("Yuri", "yuri"),
-        )
-
-        val RECENT_LIST = arrayOf(
-            Pair("<select>", ""),
-            Pair("Recent Release", "1"),
-            Pair("Recent Dub", "2"),
-            Pair("Recent Chinese", "3"),
-        )
-
-        val SEASON_LIST = arrayOf(
-            Pair("<select>", ""),
-            Pair("Latest season", "new-season.html"),
-            Pair("Spring 2024", "sub-category/spring-2024-anime"),
-            Pair("Winter 2024", "sub-category/winter-2024-anime"),
-            Pair("Fall 2023", "sub-category/fall-2023-anime"),
-            Pair("Summer 2023", "sub-category/summer-2023-anime"),
-            Pair("Spring 2023", "sub-category/spring-2023-anime"),
-            Pair("Winter 2023", "sub-category/winter-2023-anime"),
-            Pair("Fall 2022", "sub-category/fall-2022-anime"),
-            Pair("Summer 2022", "sub-category/summer-2022-anime"),
-            Pair("Spring 2022", "sub-category/spring-2022-anime"),
-            Pair("Winter 2022", "sub-category/winter-2022-anime"),
-            Pair("Fall 2021", "sub-category/fall-2021-anime"),
-            Pair("Summer 2021", "sub-category/summer-2021-anime"),
-            Pair("Spring 2021", "sub-category/spring-2021-anime"),
-            Pair("Winter 2021", "sub-category/winter-2021-anime"),
-            Pair("Fall 2020", "sub-category/fall-2020-anime"),
-            Pair("Summer 2020", "sub-category/summer-2020-anime"),
-            Pair("Spring 2020", "sub-category/spring-2020-anime"),
-            Pair("Winter 2020", "sub-category/winter-2020-anime"),
-            Pair("Fall 2019", "sub-category/fall-2019-anime"),
-            Pair("Summer 2019", "sub-category/summer-2019-anime"),
-            Pair("Spring 2019", "sub-category/spring-2019-anime"),
-            Pair("Winter 2019", "sub-category/winter-2019-anime"),
-            Pair("Fall 2018", "sub-category/fall-2018-anime"),
-            Pair("Summer 2018", "sub-category/summer-2018-anime"),
-            Pair("Spring 2018", "sub-category/spring-2018-anime"),
-            Pair("Winter 2018", "sub-category/winter-2018-anime"),
-            Pair("Fall 2017", "sub-category/fall-2017-anime"),
-            Pair("Summer 2017", "sub-category/summer-2017-anime"),
-            Pair("Spring 2017", "sub-category/spring-2017-anime"),
-            Pair("Winter 2017", "sub-category/winter-2017-anime"),
-            Pair("Fall 2016", "sub-category/fall-2016-anime"),
-            Pair("Summer 2016", "sub-category/summer-2016-anime"),
-            Pair("Spring 2016", "sub-category/spring-2016-anime"),
-            Pair("Winter 2016", "sub-category/winter-2016-anime"),
-            Pair("Fall 2015", "sub-category/fall-2015-anime"),
-            Pair("Summer 2015", "sub-category/summer-2015-anime"),
-            Pair("Spring 2015", "sub-category/spring-2015-anime"),
-            Pair("Winter 2015", "sub-category/winter-2015-anime"),
-            Pair("Fall 2014", "sub-category/fall-2014-anime"),
-            Pair("Summer 2014", "sub-category/summer-2014-anime"),
-            Pair("Spring 2014", "sub-category/spring-2014-anime"),
-            Pair("Winter 2014", "sub-category/winter-2014-anime"),
-        )
-    }
-}
diff --git a/src/en/jpfilms/build.gradle b/src/en/jpfilms/build.gradle
new file mode 100644
index 00000000..4d0d4e22
--- /dev/null
+++ b/src/en/jpfilms/build.gradle
@@ -0,0 +1,12 @@
+ext {
+    extName = 'JPFilms'
+    extClass = '.JPFilms'
+    extVersionCode = 1
+    isNsfw = true
+}
+
+apply from: "$rootDir/common.gradle"
+
+dependencies {
+    implementation(project(":lib:playlist-utils"))
+}
diff --git a/src/en/jpfilms/res/mipmap-hdpi/ic_launcher.png b/src/en/jpfilms/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000..80d4f02b
Binary files /dev/null and b/src/en/jpfilms/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/en/jpfilms/res/mipmap-mdpi/ic_launcher.png b/src/en/jpfilms/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000..4738b546
Binary files /dev/null and b/src/en/jpfilms/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/en/jpfilms/res/mipmap-xhdpi/ic_launcher.png b/src/en/jpfilms/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000..f8eeb7f4
Binary files /dev/null and b/src/en/jpfilms/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/en/jpfilms/res/mipmap-xxhdpi/ic_launcher.png b/src/en/jpfilms/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000..8f193b70
Binary files /dev/null and b/src/en/jpfilms/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/en/jpfilms/res/mipmap-xxxhdpi/ic_launcher.png b/src/en/jpfilms/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 00000000..b43b57de
Binary files /dev/null and b/src/en/jpfilms/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/en/jpfilms/src/eu/kanade/tachiyomi/animeextension/en/jpfilms/JPFilms.kt b/src/en/jpfilms/src/eu/kanade/tachiyomi/animeextension/en/jpfilms/JPFilms.kt
new file mode 100644
index 00000000..b3434690
--- /dev/null
+++ b/src/en/jpfilms/src/eu/kanade/tachiyomi/animeextension/en/jpfilms/JPFilms.kt
@@ -0,0 +1,406 @@
+package eu.kanade.tachiyomi.animeextension.en.jpfilms
+
+import android.app.Application
+import android.content.SharedPreferences
+import android.util.Log
+import androidx.preference.ListPreference
+import androidx.preference.PreferenceScreen
+import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
+import eu.kanade.tachiyomi.animesource.model.AnimeFilterList
+import eu.kanade.tachiyomi.animesource.model.SAnime
+import eu.kanade.tachiyomi.animesource.model.SEpisode
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.animesource.online.ParsedAnimeHttpSource
+import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.Json
+import okhttp3.Headers
+import okhttp3.Request
+import okhttp3.Response
+import org.jsoup.nodes.Document
+import org.jsoup.nodes.Element
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+
+class JPFilms : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
+    override val name = "JPFilms"
+    override val baseUrl = "https://jp-films.com"
+    override val lang = "en"
+    override val supportsLatest = true
+
+    private val preferences: SharedPreferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    // ============================== Popular Anime ==============================
+    override fun popularAnimeSelector(): String =
+        "div.item"
+
+    override fun popularAnimeRequest(page: Int): Request = GET("https://jp-films.com/wp-content/themes/halimmovies/halim-ajax.php?action=halim_get_popular_post&showpost=50&type=all")
+
+    override fun popularAnimeFromElement(element: Element): SAnime {
+        val anime = SAnime.create()
+        anime.setUrlWithoutDomain(element.select("a").attr("href"))
+        anime.title = element.select("h3.title").text()
+        anime.thumbnail_url = element.selectFirst("img")?.attr("abs:data-src")
+        Log.d("JPFilmsDebug", "Thumbnail URL: ${anime.thumbnail_url}")
+        return anime
+    }
+
+    override fun popularAnimeNextPageSelector(): String? = null
+
+    // ============================== Latest Anime ==============================
+    override fun latestUpdatesSelector(): String =
+        "#ajax-vertical-widget-movie > div.item, " +
+            "#ajax-vertical-widget-tv_series > div.item"
+
+    override fun latestUpdatesRequest(page: Int): Request = GET(baseUrl)
+
+    override fun latestUpdatesFromElement(element: Element): SAnime {
+        val anime = SAnime.create()
+        anime.setUrlWithoutDomain(element.select("a").attr("href"))
+        anime.title = element.select("h3.title").text()
+        anime.thumbnail_url = element.select("img").attr("data-src")
+        Log.d("JPFilmsDebug", "Poster: ${anime.thumbnail_url}")
+        return anime
+    }
+
+    override fun latestUpdatesNextPageSelector(): String? = null
+
+    // ============================== Search Anime ==============================
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        val searchQuery = query.replace(" ", "+")
+        return GET("$baseUrl/?s=$searchQuery", headers)
+    }
+
+    override fun searchAnimeSelector(): String = "#main-contents > section > div.halim_box > article"
+
+    override fun searchAnimeFromElement(element: Element): SAnime {
+        val anime = SAnime.create()
+        anime.setUrlWithoutDomain(element.select("a.halim-thumb").attr("href"))
+        anime.title = element.select("a.halim-thumb").attr("title")
+        anime.thumbnail_url = element.select("img").attr("data-src")
+        Log.d("JPFilmsDebug", "Poster: ${anime.thumbnail_url}")
+        return anime
+    }
+
+    override fun searchAnimeNextPageSelector(): String? = null
+
+    // ============================== Anime Details ==============================
+    override suspend fun getAnimeDetails(anime: SAnime): SAnime {
+        val document = client.newCall(GET(baseUrl + anime.url, headers)).execute().asJsoup()
+        anime.title = document.select("h1.entry-title").text()
+        anime.genre = document.select("p.category a").joinToString(", ") { it.text() }
+        anime.description = document.select("#content > div > div.entry-content.htmlwrap.clearfix > div.video-item.halim-entry-box article p").text()
+        anime.thumbnail_url = document.select("#content > div > div.halim-movie-wrapper.tpl-2 > div > div.movie-poster.col-md-4 > img").attr("data-src")
+        anime.author = "forsyth47"
+        return anime
+    }
+
+    override fun animeDetailsParse(document: Document): SAnime = throw UnsupportedOperationException()
+
+    // ============================== Episode List ==============================
+
+    @Serializable
+    data class JsonLdData(
+        @SerialName("@type") val type: String? = null,
+    )
+
+    override fun episodeListSelector(): String {
+        throw UnsupportedOperationException("Not used because we override episodeListParse.")
+    }
+
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val document = response.asJsoup()
+
+        // Extract JSON-LD data to determine if it's a Movie or TVSeries
+        val jsonLdScript = document.selectFirst("script[type=application/ld+json]:not(.rank-math-schema)")?.data()
+        Log.d("JPFilmsDebug", "JSON-LD Script: $jsonLdScript")
+
+        val jsonLdData = json.decodeFromString<JsonLdData>(jsonLdScript ?: "{}")
+        Log.d("JPFilmsDebug", "JSON-LD Data: $jsonLdData")
+
+        val isMovie = jsonLdData.type == "Movie"
+        Log.d("JPFilmsDebug", "Type: ${if (isMovie) "Movie" else "TVSeries"}")
+
+        val serverAvailable = document.select("#halim-list-server > ul > li")
+        Log.d("JPFilmsDebug", "Server Available: $serverAvailable")
+
+        var freeServerFound: Boolean = false
+        val episodeContainerSelector = run {
+            freeServerFound = false
+            var selectedContainer: String? = null
+
+            // Iterate through each server div
+            for (serverDiv in serverAvailable) {
+                Log.d("JPFilmsDebug", "Server Div: $serverDiv")
+
+                // Log the title of the current server div
+                val title = serverDiv.select("li > a").text()
+                Log.d("JPFilmsDebug", "Server Div Title: $title")
+
+                // Check if the current server contains a <li> with a title containing "FREE"
+                val hasFreeServer = title.contains("FREE")
+                Log.d("JPFilmsDebug", "Has Free Server: $hasFreeServer")
+
+                if (hasFreeServer) {
+                    // Mark that a FREE server was found
+                    freeServerFound = true
+                    Log.d("JPFilmsDebug", "FREE Server Found")
+
+                    // Select this server's container
+                    selectedContainer = "${serverDiv.select("a").attr("href")} > div > ul"
+                    break // Exit the loop once a FREE server is found
+                } else if (!freeServerFound) {
+                    // If no FREE server is found yet, select the first available server
+                    selectedContainer = "${serverDiv.select("a").attr("href")} > div > ul"
+                }
+            }
+
+            // Return the selected container or an empty string if none is found
+            selectedContainer ?: ""
+        }
+        Log.d("JPFilmsDebug", "Episode Container Selector: $episodeContainerSelector")
+
+        // Extract all <li> elements from the selected container
+        val episodeElements = document.select("$episodeContainerSelector > li")
+        Log.d("JPFilmsDebug", "Episode Elements: $episodeElements")
+
+        return episodeElements.map { element ->
+            SEpisode.create().apply {
+                // Get the href attribute from either the anchor tag or the span tag
+                var href = if (element.select("a").hasAttr("href")) {
+                    element.select("a").attr("href")
+                } else {
+                    element.select("span").attr("data-href")
+                }
+                if (!freeServerFound) {
+                    href = "$href?svid=2"
+                }
+                setUrlWithoutDomain(href)
+                Log.d("JPFilmsDebug", "Episode URL: $href")
+
+                // Determine if the episode belongs to a FREE or VIP server
+                val isFreeServer = element.select("a").attr("title").contains("FREE") ||
+                    element.select("span").text().contains("FREE")
+                val serverPrefix = if (isFreeServer) "[FREE] " else "[VIP] "
+
+                // Use the title attribute of the anchor tag as the episode name
+                name = serverPrefix + (
+                    element.select("a").attr("title").ifEmpty {
+                        element.select("span").text()
+                    }
+                    )
+                Log.d("JPFilmsDebug", "Episode Name: $name")
+
+                // Generate an episode number based on the text content
+                episode_number = element.text()
+                    .filter { it.isDigit() }
+                    .toFloatOrNull() ?: 1F
+                Log.d("JPFilmsDebug", "Episode Number: $episode_number")
+            }
+        }.reversed()
+    }
+
+    override fun episodeFromElement(element: Element): SEpisode {
+        throw UnsupportedOperationException("Not used because we override episodeListParse.")
+    }
+
+    // ============================== Video List ==============================
+
+    // Define the JSON serializer
+    private val json = Json { ignoreUnknownKeys = true }
+
+    override fun videoListParse(response: Response): List<Video> {
+        Log.d("JPFilmsDebug", "Episode Chosen Response URL: ${response.request.url}")
+        val document = response.asJsoup()
+        val postId = extractPostId(document)
+        val episodeSlug = response.request.url.pathSegments.last().split("-").dropLast(1).joinToString("-")
+
+        // Debugging: Log episode slug and post ID
+        Log.d("JPFilmsDebug", "Episode Slug: $episodeSlug")
+        Log.d("JPFilmsDebug", "Post ID: $postId")
+
+        // Helper function to construct the player URL
+        fun getPlayerUrl(serverId: Int, subsvId: String? = null): String {
+            return "$baseUrl/wp-content/themes/halimmovies/player.php?" +
+                "episode_slug=$episodeSlug&" +
+                "server_id=$serverId&" +
+                (if (subsvId != null) "subsv_id=$subsvId&" else "") +
+                "post_id=$postId&" +
+                "nonce=8c934fd387&custom_var="
+        }
+
+        // Create custom headers to match Postman
+        val customHeaders = Headers.Builder()
+            .add("sec-ch-ua-platform", "\"macOS\"")
+            .add("X-Requested-With", "XMLHttpRequest")
+            .add("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36")
+            .add("Accept", "text/html, */*; q=0.01")
+            .add("sec-ch-ua", "\"Brave\";v=\"135\", \"Not-A.Brand\";v=\"8\", \"Chromium\";v=\"135\"")
+            .add("DNT", "1")
+            .add("sec-ch-ua-mobile", "?0")
+            .add("Sec-GPC", "1")
+            .add("Sec-Fetch-Site", "same-origin")
+            .add("Sec-Fetch-Mode", "cors")
+            .add("Sec-Fetch-Dest", "empty")
+            .add("Host", "jp-films.com")
+            .build()
+
+        // Helper function to fetch and parse the player response
+        fun fetchAndParsePlayerResponse(playerUrl: String): Pair<String, String> {
+            // Debugging: Log the constructed player URL
+            Log.d("JPFilmsDebug", "Player URL: $playerUrl")
+
+            // Make the request with custom headers
+            val playerResponse = client.newCall(GET(playerUrl, customHeaders)).execute().body.string()
+
+            // Debugging: Log the player response
+            Log.d("JPFilmsDebug", "Player Response: $playerResponse")
+
+            // Parse the JSON response into a strongly-typed structure
+            val jsonResponse = json.decodeFromString<PlayerResponse>(playerResponse)
+
+            // Extract the 'sources' field from the parsed JSON
+            val sources = jsonResponse.data?.sources ?: ""
+
+            // Debugging: Log the extracted sources
+            Log.d("JPFilmsDebug", "Extracted Sources: $sources")
+
+            // Extract the HLS URL using string manipulation
+            val hlsUrl = sources.split("source src=\"").getOrNull(1)?.split("\" type=")?.getOrNull(0) ?: ""
+
+            // Debugging: Log the extracted HLS URL
+            Log.d("JPFilmsDebug", "Extracted HLS URL: $hlsUrl")
+
+            return Pair(sources, hlsUrl)
+        }
+
+        val serverAvailable = document.select("#halim-list-server > ul > li")
+        Log.d("JPFilmsDebug", "Server Available: $serverAvailable")
+
+        val episodeContainerSelector = run {
+            var freeServerFound: Boolean = false
+            var selectedContainer: String? = null
+
+            // Iterate through each server div
+            for (serverDiv in serverAvailable) {
+                Log.d("JPFilmsDebug", "Server Div: $serverDiv")
+
+                // Log the title of the current server div
+                val title = serverDiv.select("li > a").text()
+                Log.d("JPFilmsDebug", "Server Div Title: $title")
+
+                // Check if the current server contains a <li> with a title containing "FREE"
+                val hasFreeServer = title.contains("FREE")
+                Log.d("JPFilmsDebug", "Has Free Server: $hasFreeServer")
+
+                if (hasFreeServer) {
+                    // Mark that a FREE server was found
+                    freeServerFound = true
+                    Log.d("JPFilmsDebug", "FREE Server Found")
+
+                    // Select this server's container
+                    selectedContainer = "${serverDiv.select("a").attr("href")} > div > ul"
+                    break // Exit the loop once a FREE server is found
+                } else if (!freeServerFound) {
+                    // If no FREE server is found yet, select the first available server
+                    selectedContainer = "${serverDiv.select("a").attr("href")} > div > ul"
+                }
+            }
+
+            // Return the selected container or an empty string if none is found
+            selectedContainer ?: ""
+        }
+
+        val episodeElements = document.select("$episodeContainerSelector > li")
+        Log.d("JPFilmsDebug", "Episode Elements: $episodeElements")
+
+        val targetEpisodeElement = episodeElements.firstOrNull { element ->
+            element.select("span").attr("data-episode-slug") == episodeSlug
+        } ?: run {
+            Log.e("JPFilmsDebug", "No matching episode element found for slug: $episodeSlug")
+            return emptyList() // Exit early if no matching element is found
+        }
+
+        // Extract the server ID from the target <li> element
+        val serverId = targetEpisodeElement.select("span").attr("data-server").toIntOrNull() ?: 0
+
+        // Debugging: Log the extracted server ID
+        Log.d("JPFilmsDebug", "Extracted Server ID: $serverId")
+
+        // First attempt with server_id=serverId and no subsvId
+        var subsvId: String? = null
+        val playerUrl1 = getPlayerUrl(serverId = serverId, subsvId = subsvId)
+        val (_, hlsUrl1) = fetchAndParsePlayerResponse(playerUrl1)
+
+        // Retry with subsvId=2 if the first attempt fails
+        val hlsUrl = if (hlsUrl1.isEmpty()) {
+            subsvId = "2"
+            val playerUrl2 = getPlayerUrl(serverId = serverId, subsvId = subsvId)
+            val (_, hlsUrl2) = fetchAndParsePlayerResponse(playerUrl2)
+            hlsUrl2
+        } else {
+            hlsUrl1
+        }
+
+        // Return the video list if the HLS URL is found, otherwise return an empty list
+        return if (hlsUrl.isNotEmpty()) {
+            PlaylistUtils(client).extractFromHls(hlsUrl, referer = baseUrl)
+        } else {
+            emptyList()
+        }
+    }
+
+    // Data classes for JSON parsing
+    @Serializable
+    data class PlayerResponse(
+        val data: PlayerData? = null,
+    )
+
+    @Serializable
+    data class PlayerData(
+        val status: Boolean? = null,
+        val sources: String? = null,
+    )
+
+    private fun extractPostId(document: Document): String {
+        val bodyClass = document.select("body").attr("class")
+        return Regex("postid-(\\d+)").find(bodyClass)?.groupValues?.get(1) ?: ""
+    }
+
+    override fun videoListSelector(): String = throw UnsupportedOperationException()
+
+    override fun videoFromElement(element: Element): Video = throw UnsupportedOperationException()
+
+    override fun videoUrlParse(document: Document): String = throw UnsupportedOperationException()
+
+    // ============================== ToDo ==============================
+    // Plan to add option to change between original title and translated title
+    // Plan to add backup server too.
+    // ============================== Preferences ==============================
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        ListPreference(screen.context).apply {
+            key = Companion.PREF_TITLE_STYLE_KEY
+            title = "Preferred Title Style"
+            entries = arrayOf("Original", "Translated")
+            entryValues = arrayOf("original", "translated")
+            setDefaultValue("translated")
+            summary = "%s"
+
+            setOnPreferenceChangeListener { _, newValue ->
+                preferences.edit().putString(key, newValue as String).commit()
+            }
+        }.also(screen::addPreference)
+    }
+
+    private val SharedPreferences.titleStyle
+        get() = getString(Companion.PREF_TITLE_STYLE_KEY, "translated")!!
+
+    companion object {
+        private const val PREF_TITLE_STYLE_KEY = "preferred_title_style"
+    }
+}
diff --git a/src/en/kaido/build.gradle b/src/en/kaido/build.gradle
index 6bcd6429..534ef8dc 100644
--- a/src/en/kaido/build.gradle
+++ b/src/en/kaido/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.Kaido'
     themePkg = 'zorotheme'
     baseUrl = 'https://kaido.to'
-    overrideVersionCode = 8
+    overrideVersionCode = 9
 }
 
 apply from: "$rootDir/common.gradle"
\ No newline at end of file
diff --git a/src/en/kickassanime/build.gradle b/src/en/kickassanime/build.gradle
index fd3ddc54..d8c21bab 100644
--- a/src/en/kickassanime/build.gradle
+++ b/src/en/kickassanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'KickAssAnime'
     extClass = '.KickAssAnime'
-    extVersionCode = 45
+    extVersionCode = 48
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/KickAssAnime.kt b/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/KickAssAnime.kt
index ec74afc7..84788210 100644
--- a/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/KickAssAnime.kt
+++ b/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/KickAssAnime.kt
@@ -338,8 +338,8 @@ class KickAssAnime : ConfigurableAnimeSource, AnimeHttpSource() {
 
         private const val PREF_DOMAIN_KEY = "preferred_domain"
         private const val PREF_DOMAIN_TITLE = "Preferred domain (requires app restart)"
-        private const val PREF_DOMAIN_DEFAULT = "https://kaas.to"
-        private val PREF_DOMAIN_ENTRIES = arrayOf("kaas.to", "kaas.ro", "kickassanimes.io", "www1.kickassanime.mx")
+        private const val PREF_DOMAIN_DEFAULT = "https://kaa.mx"
+        private val PREF_DOMAIN_ENTRIES = arrayOf("kaa.mx", "kaas.ro", "kaas.to", "kickassanimes.io", "www1.kickassanime.mx")
         private val PREF_DOMAIN_ENTRY_VALUES = PREF_DOMAIN_ENTRIES.map { "https://$it" }.toTypedArray()
 
         private const val PREF_HOSTER_KEY = "hoster_selection"
diff --git a/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/KickAssAnimeFilters.kt b/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/KickAssAnimeFilters.kt
index 81a06bbf..bbd39bfc 100644
--- a/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/KickAssAnimeFilters.kt
+++ b/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/KickAssAnimeFilters.kt
@@ -270,6 +270,7 @@ object KickAssAnimeFilters {
             Pair("2022", "2022"),
             Pair("2023", "2023"),
             Pair("2024", "2024"),
+            Pair("2025", "2025"),
         )
 
         val STATUS = arrayOf(
diff --git a/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/extractors/KickAssAnimeExtractor.kt b/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/extractors/KickAssAnimeExtractor.kt
index 0fc5d08c..d256986b 100644
--- a/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/extractors/KickAssAnimeExtractor.kt
+++ b/src/en/kickassanime/src/eu/kanade/tachiyomi/animeextension/en/kickassanime/extractors/KickAssAnimeExtractor.kt
@@ -18,6 +18,8 @@ class KickAssAnimeExtractor(
     private val json: Json,
     private val headers: Headers,
 ) {
+    private val playlistUtils by lazy { PlaylistUtils(client, headers) }
+
     fun videosFromUrl(url: String, name: String): List<Video> {
         val host = url.toHttpUrl().host
         val mid = if (name == "DuckStream") "mid" else "id"
@@ -77,7 +79,7 @@ class KickAssAnimeExtractor(
             val language = "${it.name} (${it.language})"
 
             Track(subUrl, language)
-        }
+        }.let { playlistUtils.fixSubtitles(it) }
 
         fun getVideoHeaders(baseHeaders: Headers, referer: String, videoUrl: String): Headers {
             return baseHeaders.newBuilder().apply {
@@ -92,8 +94,8 @@ class KickAssAnimeExtractor(
 
         return when {
             videoObject.hls.isBlank() ->
-                PlaylistUtils(client, headers).extractFromDash(videoObject.playlistUrl, videoNameGen = { res -> "$name - $res" }, subtitleList = subtitles)
-            else -> PlaylistUtils(client, headers).extractFromHls(
+                playlistUtils.extractFromDash(videoObject.playlistUrl, videoNameGen = { res -> "$name - $res" }, subtitleList = subtitles)
+            else -> playlistUtils.extractFromHls(
                 videoObject.playlistUrl,
                 videoNameGen = { "$name - $it" },
                 videoHeadersGen = ::getVideoHeaders,
diff --git a/src/en/kissanime/build.gradle b/src/en/kissanime/build.gradle
index 09d45e70..5228d2ed 100644
--- a/src/en/kissanime/build.gradle
+++ b/src/en/kissanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'KissAnime'
     extClass = '.KissAnime'
-    extVersionCode = 7
+    extVersionCode = 8
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/luciferdonghua/build.gradle b/src/en/luciferdonghua/build.gradle
index 5a7c9c49..f658b417 100644
--- a/src/en/luciferdonghua/build.gradle
+++ b/src/en/luciferdonghua/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.LuciferDonghua'
     themePkg = 'animestream'
     baseUrl = 'https://luciferdonghua.in'
-    overrideVersionCode = 6
+    overrideVersionCode = 8
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/myanime/build.gradle b/src/en/myanime/build.gradle
index 172db47c..1de5d7c1 100644
--- a/src/en/myanime/build.gradle
+++ b/src/en/myanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Myanime'
     extClass = '.Myanime'
-    extVersionCode = 6
+    extVersionCode = 7
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/putlocker/build.gradle b/src/en/putlocker/build.gradle
index fa4b0f23..f9b2bcc8 100644
--- a/src/en/putlocker/build.gradle
+++ b/src/en/putlocker/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'PutLocker'
     extClass = '.PutLocker'
-    extVersionCode = 10
+    extVersionCode = 11
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/sflix/build.gradle b/src/en/sflix/build.gradle
index 0cb31426..9b76ef8d 100644
--- a/src/en/sflix/build.gradle
+++ b/src/en/sflix/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.SFlix'
     themePkg = 'dopeflix'
     baseUrl = 'https://sflix.to'
-    overrideVersionCode = 10
+    overrideVersionCode = 11
 }
 
 apply from: "$rootDir/common.gradle"
\ No newline at end of file
diff --git a/src/en/tokuzilla/build.gradle b/src/en/tokuzilla/build.gradle
index ce66cf1a..e918fd26 100644
--- a/src/en/tokuzilla/build.gradle
+++ b/src/en/tokuzilla/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Tokuzilla'
     extClass = '.Tokuzilla'
-    extVersionCode = 21
+    extVersionCode = 24
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/wcostream/build.gradle b/src/en/wcostream/build.gradle
index f59699a8..4e4d43ec 100644
--- a/src/en/wcostream/build.gradle
+++ b/src/en/wcostream/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'WCOStream'
     extClass = '.WCOStream'
-    extVersionCode = 5
+    extVersionCode = 6
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/en/wcostream/src/eu/kanade/tachiyomi/animeextension/en/wcostream/WCOStream.kt b/src/en/wcostream/src/eu/kanade/tachiyomi/animeextension/en/wcostream/WCOStream.kt
index cf7767d2..f131d793 100644
--- a/src/en/wcostream/src/eu/kanade/tachiyomi/animeextension/en/wcostream/WCOStream.kt
+++ b/src/en/wcostream/src/eu/kanade/tachiyomi/animeextension/en/wcostream/WCOStream.kt
@@ -36,7 +36,7 @@ class WCOStream : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override val name = "WCOStream"
 
-    override val baseUrl = "https://www.wcostream.org"
+    override val baseUrl = "https://www.wcostream.tv"
 
     override val lang = "en"
 
@@ -50,7 +50,7 @@ class WCOStream : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override fun headersBuilder(): Headers.Builder {
         return super.headersBuilder()
-            .add("Referer", "https://wcostream.org/")
+            .add("Referer", "https://wcostream.tv/")
     }
 
     // Popular Anime
diff --git a/src/en/zoro/build.gradle b/src/en/zoro/build.gradle
index 3266e57a..ffcebb65 100644
--- a/src/en/zoro/build.gradle
+++ b/src/en/zoro/build.gradle
@@ -2,8 +2,8 @@ ext {
     extName = 'HiAnime'
     extClass = '.HiAnime'
     themePkg = 'zorotheme'
-    baseUrl = 'https://hianime.to'
-    overrideVersionCode = 46
+    baseUrl = 'https://hianimez.to'
+    overrideVersionCode = 51
 }
 
-apply from: "$rootDir/common.gradle"
\ No newline at end of file
+apply from: "$rootDir/common.gradle"
diff --git a/src/en/zoro/src/eu/kanade/tachiyomi/animeextension/en/zoro/HiAnime.kt b/src/en/zoro/src/eu/kanade/tachiyomi/animeextension/en/zoro/HiAnime.kt
index f05e35d3..307fa43f 100644
--- a/src/en/zoro/src/eu/kanade/tachiyomi/animeextension/en/zoro/HiAnime.kt
+++ b/src/en/zoro/src/eu/kanade/tachiyomi/animeextension/en/zoro/HiAnime.kt
@@ -1,5 +1,8 @@
 package eu.kanade.tachiyomi.animeextension.en.zoro
 
+import android.widget.Toast
+import androidx.preference.ListPreference
+import androidx.preference.PreferenceScreen
 import eu.kanade.tachiyomi.animesource.model.SAnime
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.lib.megacloudextractor.MegaCloudExtractor
@@ -12,7 +15,7 @@ import org.jsoup.nodes.Element
 class HiAnime : ZoroTheme(
     "en",
     "HiAnime",
-    "https://hianime.to",
+    "https://hianimez.to",
     hosterNames = listOf(
         "HD-1",
         "HD-2",
@@ -24,9 +27,16 @@ class HiAnime : ZoroTheme(
     override val ajaxRoute = "/v2"
 
     private val streamtapeExtractor by lazy { StreamTapeExtractor(client) }
+
     private val megaCloudExtractor by lazy { MegaCloudExtractor(client, headers, preferences) }
 
-    override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/recently-updated?page=$page", docHeaders)
+    override val baseUrl: String
+        get() = preferences.getString(PREF_DOMAIN_KEY, PREF_DOMAIN_DEFAULT) ?: PREF_DOMAIN_DEFAULT
+
+    override fun latestUpdatesRequest(page: Int): Request = GET(
+        "$baseUrl/recently-updated?page=$page",
+        docHeaders,
+    )
 
     override fun popularAnimeFromElement(element: Element): SAnime {
         return super.popularAnimeFromElement(element).apply {
@@ -37,12 +47,51 @@ class HiAnime : ZoroTheme(
     override fun extractVideo(server: VideoData): List<Video> {
         return when (server.name) {
             "StreamTape" -> {
-                streamtapeExtractor.videoFromUrl(server.link, "Streamtape - ${server.type}")
-                    ?.let(::listOf)
-                    ?: emptyList()
+                streamtapeExtractor.videoFromUrl(
+                    server.link,
+                    "Streamtape - ${server.type}",
+                )?.let(::listOf) ?: emptyList()
             }
-            "HD-1", "HD-2" -> megaCloudExtractor.getVideosFromUrl(server.link, server.type, server.name)
+
+            "HD-1", "HD-2" -> megaCloudExtractor.getVideosFromUrl(
+                server.link,
+                server.type,
+                server.name,
+            )
+
             else -> emptyList()
         }
     }
+
+    // Added the setupPreferenceScreen method here
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        super.setupPreferenceScreen(screen)
+        screen.addPreference(
+            ListPreference(screen.context).apply {
+                key = PREF_DOMAIN_KEY
+                title = "Preferred domain"
+                entries = arrayOf("hianimez.to", "hianime.to", "hianimez.is", "hianime.nz", "hianime.pe")
+                entryValues = arrayOf("https://hianimez.to", "https://hianime.to", "https://hianimez.is", "https://hianime.nz", "https://hianime.pe")
+                setDefaultValue(PREF_DOMAIN_DEFAULT)
+                summary = "%s"
+
+                setOnPreferenceChangeListener { _, newValue ->
+                    val selected = newValue as String
+                    val index = findIndexOfValue(selected)
+                    val entry = entryValues[index] as String
+                    Toast.makeText(
+                        screen.context,
+                        "Restart Aniyomi to apply changes",
+                        Toast.LENGTH_LONG,
+                    ).show()
+                    preferences.edit().putString(key, entry).commit()
+                }
+            },
+        )
+    }
+
+    companion object {
+        private const val PREF_DOMAIN_KEY = "preferred_domain"
+        private const val PREF_DOMAIN_DEFAULT = "https://hianimez.to"
+    }
 }
diff --git a/src/es/animebum/build.gradle b/src/es/animebum/build.gradle
index 9c54088a..e0747375 100644
--- a/src/es/animebum/build.gradle
+++ b/src/es/animebum/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AnimeBum'
     extClass = '.AnimeBum'
-    extVersionCode = 5
+    extVersionCode = 7
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/animefenix/build.gradle b/src/es/animefenix/build.gradle
index 38c7f15a..23cfae57 100644
--- a/src/es/animefenix/build.gradle
+++ b/src/es/animefenix/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Animefenix'
     extClass = '.Animefenix'
-    extVersionCode = 57
+    extVersionCode = 59
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/animeflv/build.gradle b/src/es/animeflv/build.gradle
index 5781e41b..ed967977 100644
--- a/src/es/animeflv/build.gradle
+++ b/src/es/animeflv/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AnimeFLV'
     extClass = '.AnimeFlv'
-    extVersionCode = 64
+    extVersionCode = 66
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/animeid/build.gradle b/src/es/animeid/build.gradle
index 591dddf4..08d6b323 100644
--- a/src/es/animeid/build.gradle
+++ b/src/es/animeid/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AnimeID'
     extClass = '.AnimeID'
-    extVersionCode = 16
+    extVersionCode = 18
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/animejl/build.gradle b/src/es/animejl/build.gradle
index 195c2645..26dc81bc 100644
--- a/src/es/animejl/build.gradle
+++ b/src/es/animejl/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Animejl'
     extClass = '.Animejl'
-    extVersionCode = 5
+    extVersionCode = 7
     isNsfw = true
 }
 
diff --git a/src/es/animelatinohd/build.gradle b/src/es/animelatinohd/build.gradle
index a79f7eaa..c9a8e1a9 100644
--- a/src/es/animelatinohd/build.gradle
+++ b/src/es/animelatinohd/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AnimeLatinoHD'
     extClass = '.AnimeLatinoHD'
-    extVersionCode = 39
+    extVersionCode = 41
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/animemovil/build.gradle b/src/es/animemovil/build.gradle
index 30f61d24..0a328760 100644
--- a/src/es/animemovil/build.gradle
+++ b/src/es/animemovil/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AnimeMovil'
     extClass = '.AnimeMovil'
-    extVersionCode = 29
+    extVersionCode = 31
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/animenix/build.gradle b/src/es/animenix/build.gradle
index 1ac55757..01eb8a5e 100644
--- a/src/es/animenix/build.gradle
+++ b/src/es/animenix/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.Animenix'
     themePkg = 'dooplay'
     baseUrl = 'https://animenix.com'
-    overrideVersionCode = 9
+    overrideVersionCode = 11
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/animeonlineninja/build.gradle b/src/es/animeonlineninja/build.gradle
index 5c5fd46c..50a1ce91 100644
--- a/src/es/animeonlineninja/build.gradle
+++ b/src/es/animeonlineninja/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.AnimeOnlineNinja'
     themePkg = 'dooplay'
     baseUrl = 'https://ww3.animeonline.ninja'
-    overrideVersionCode = 44
+    overrideVersionCode = 46
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/animeyt/build.gradle b/src/es/animeyt/build.gradle
index dd7471cf..1e9686d0 100644
--- a/src/es/animeyt/build.gradle
+++ b/src/es/animeyt/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Animeyt'
     extClass = '.Animeyt'
-    extVersionCode = 11
+    extVersionCode = 12
 }
 apply from: "$rootDir/common.gradle"
 
diff --git a/src/es/animeytes/build.gradle b/src/es/animeytes/build.gradle
index eb62857f..498ed8aa 100644
--- a/src/es/animeytes/build.gradle
+++ b/src/es/animeytes/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.AnimeYTES'
     themePkg = 'animestream'
     baseUrl = 'https://animeyt.pro'
-    overrideVersionCode = 9
+    overrideVersionCode = 11
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/asialiveaction/build.gradle b/src/es/asialiveaction/build.gradle
index fcf9c358..5f2ce842 100644
--- a/src/es/asialiveaction/build.gradle
+++ b/src/es/asialiveaction/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AsiaLiveAction'
     extClass = '.AsiaLiveAction'
-    extVersionCode = 36
+    extVersionCode = 38
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/cine24h/build.gradle b/src/es/cine24h/build.gradle
index 1037606e..658c440a 100644
--- a/src/es/cine24h/build.gradle
+++ b/src/es/cine24h/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Cine24h'
     extClass = '.Cine24h'
-    extVersionCode = 11
+    extVersionCode = 13
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/cinecalidad/build.gradle b/src/es/cinecalidad/build.gradle
index 748cdd65..4c606c05 100644
--- a/src/es/cinecalidad/build.gradle
+++ b/src/es/cinecalidad/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'CineCalidad'
     extClass = '.CineCalidad'
-    extVersionCode = 17
+    extVersionCode = 19
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/cineplus123/build.gradle b/src/es/cineplus123/build.gradle
index b6598a0f..75e3e2ad 100644
--- a/src/es/cineplus123/build.gradle
+++ b/src/es/cineplus123/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.Cineplus123'
     themePkg = 'dooplay'
     baseUrl = 'https://cineplus123.org'
-    overrideVersionCode = 6
+    overrideVersionCode = 8
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/cuevana/build.gradle b/src/es/cuevana/build.gradle
index b1198287..298a1cdc 100644
--- a/src/es/cuevana/build.gradle
+++ b/src/es/cuevana/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Cuevana'
     extClass = '.CuevanaFactory'
-    extVersionCode = 46
+    extVersionCode = 48
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/detodopeliculas/build.gradle b/src/es/detodopeliculas/build.gradle
index a8fd0f63..a16f2ec7 100644
--- a/src/es/detodopeliculas/build.gradle
+++ b/src/es/detodopeliculas/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.DeTodoPeliculas'
     themePkg = 'dooplay'
     baseUrl = 'https://detodopeliculas.nu'
-    overrideVersionCode = 3
+    overrideVersionCode = 5
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/doramasflix/build.gradle b/src/es/doramasflix/build.gradle
index 4a3548a2..27309246 100644
--- a/src/es/doramasflix/build.gradle
+++ b/src/es/doramasflix/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Doramasflix'
     extClass = '.Doramasflix'
-    extVersionCode = 33
+    extVersionCode = 35
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/doramasyt/build.gradle b/src/es/doramasyt/build.gradle
index 0923c038..f2479621 100644
--- a/src/es/doramasyt/build.gradle
+++ b/src/es/doramasyt/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Doramasyt'
     extClass = '.Doramasyt'
-    extVersionCode = 20
+    extVersionCode = 22
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/ennovelas/build.gradle b/src/es/ennovelas/build.gradle
index 3c61380a..bdcdf379 100644
--- a/src/es/ennovelas/build.gradle
+++ b/src/es/ennovelas/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'EnNovelas'
     extClass = '.EnNovelas'
-    extVersionCode = 20
+    extVersionCode = 21
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/estrenosdoramas/build.gradle b/src/es/estrenosdoramas/build.gradle
index 5c437a4b..f0450e5b 100644
--- a/src/es/estrenosdoramas/build.gradle
+++ b/src/es/estrenosdoramas/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'EstrenosDoramas'
     extClass = '.EstrenosDoramas'
-    extVersionCode = 5
+    extVersionCode = 7
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/fanpelis/build.gradle b/src/es/fanpelis/build.gradle
index 9bcdaed9..5a43e987 100644
--- a/src/es/fanpelis/build.gradle
+++ b/src/es/fanpelis/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'FanPelis'
     extClass = '.FanPelis'
-    extVersionCode = 16
+    extVersionCode = 17
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/flixlatam/build.gradle b/src/es/flixlatam/build.gradle
index 3e2c1fa1..49d4ac96 100644
--- a/src/es/flixlatam/build.gradle
+++ b/src/es/flixlatam/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.FlixLatam'
     themePkg = 'dooplay'
     baseUrl = 'https://flixlatam.com'
-    overrideVersionCode = 4
+    overrideVersionCode = 6
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/gnula/build.gradle b/src/es/gnula/build.gradle
index e9b646a2..af41eae9 100644
--- a/src/es/gnula/build.gradle
+++ b/src/es/gnula/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Gnula'
     extClass = '.Gnula'
-    extVersionCode = 31
+    extVersionCode = 33
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/hackstore/build.gradle b/src/es/hackstore/build.gradle
index 6bf040da..393cf295 100644
--- a/src/es/hackstore/build.gradle
+++ b/src/es/hackstore/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Hackstore'
     extClass = '.Hackstore'
-    extVersionCode = 25
+    extVersionCode = 27
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/hentaijk/build.gradle b/src/es/hentaijk/build.gradle
index 8bf9830d..2fd94c19 100644
--- a/src/es/hentaijk/build.gradle
+++ b/src/es/hentaijk/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Hentaijk'
     extClass = '.Hentaijk'
-    extVersionCode = 12
+    extVersionCode = 13
     isNsfw = true
 }
 
diff --git a/src/es/hentaila/build.gradle b/src/es/hentaila/build.gradle
index 72d8448c..921f5c22 100644
--- a/src/es/hentaila/build.gradle
+++ b/src/es/hentaila/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'HentaiLA'
     extClass = '.Hentaila'
-    extVersionCode = 34
+    extVersionCode = 36
     isNsfw = true
 }
 
diff --git a/src/es/hentaitk/build.gradle b/src/es/hentaitk/build.gradle
index b0542c73..c3b8e478 100644
--- a/src/es/hentaitk/build.gradle
+++ b/src/es/hentaitk/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'HentaiTk'
     extClass = '.Hentaitk'
-    extVersionCode = 13
+    extVersionCode = 15
     isNsfw = true
 }
 
diff --git a/src/es/homecine/build.gradle b/src/es/homecine/build.gradle
index a6c09108..017f7402 100644
--- a/src/es/homecine/build.gradle
+++ b/src/es/homecine/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'HomeCine'
     extClass = '.HomeCine'
-    extVersionCode = 5
+    extVersionCode = 7
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/jkanime/build.gradle b/src/es/jkanime/build.gradle
index 45d001fb..044d39b5 100644
--- a/src/es/jkanime/build.gradle
+++ b/src/es/jkanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Jkanime'
     extClass = '.Jkanime'
-    extVersionCode = 35
+    extVersionCode = 37
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/katanime/build.gradle b/src/es/katanime/build.gradle
index 3010fde4..59938690 100644
--- a/src/es/katanime/build.gradle
+++ b/src/es/katanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Katanime'
     extClass = '.Katanime'
-    extVersionCode = 5
+    extVersionCode = 7
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/lacartoons/build.gradle b/src/es/lacartoons/build.gradle
index 314804e2..736a8264 100644
--- a/src/es/lacartoons/build.gradle
+++ b/src/es/lacartoons/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'LACartoons'
     extClass = '.Lacartoons'
-    extVersionCode = 11
+    extVersionCode = 13
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/latanime/build.gradle b/src/es/latanime/build.gradle
index df1416eb..79979909 100644
--- a/src/es/latanime/build.gradle
+++ b/src/es/latanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Latanime'
     extClass = '.Latanime'
-    extVersionCode = 24
+    extVersionCode = 25
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/legionanime/build.gradle b/src/es/legionanime/build.gradle
index 07a08cbf..156f28a0 100644
--- a/src/es/legionanime/build.gradle
+++ b/src/es/legionanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'LegionAnime'
     extClass = '.LegionAnime'
-    extVersionCode = 35
+    extVersionCode = 37
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/locopelis/build.gradle b/src/es/locopelis/build.gradle
index 1d6be8b8..a1f85e6c 100644
--- a/src/es/locopelis/build.gradle
+++ b/src/es/locopelis/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'LocoPelis'
     extClass = '.LocoPelis'
-    extVersionCode = 29
+    extVersionCode = 30
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/metroseries/build.gradle b/src/es/metroseries/build.gradle
index 1a0b5e73..64ee7944 100644
--- a/src/es/metroseries/build.gradle
+++ b/src/es/metroseries/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'MetroSeries'
     extClass = '.MetroSeries'
-    extVersionCode = 18
+    extVersionCode = 20
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/mhdflix/build.gradle b/src/es/mhdflix/build.gradle
index d816f1d8..c97e51d5 100644
--- a/src/es/mhdflix/build.gradle
+++ b/src/es/mhdflix/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'MhdFlix'
     extClass = '.MhdFlix'
-    extVersionCode = 6
+    extVersionCode = 8
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/monoschinos/build.gradle b/src/es/monoschinos/build.gradle
index fe88e25d..ef4e4706 100644
--- a/src/es/monoschinos/build.gradle
+++ b/src/es/monoschinos/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'MonosChinos'
     extClass = '.MonosChinos'
-    extVersionCode = 35
+    extVersionCode = 37
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/mundodonghua/build.gradle b/src/es/mundodonghua/build.gradle
index 03ee9a53..eb40cc9b 100644
--- a/src/es/mundodonghua/build.gradle
+++ b/src/es/mundodonghua/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'MundoDonghua'
     extClass = '.MundoDonghua'
-    extVersionCode = 29
+    extVersionCode = 31
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/otakuverso/build.gradle b/src/es/otakuverso/build.gradle
index 830bd251..842568f9 100644
--- a/src/es/otakuverso/build.gradle
+++ b/src/es/otakuverso/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Otakuverso'
     extClass = '.Otakuverso'
-    extVersionCode = 1
+    extVersionCode = 3
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/pandrama/build.gradle b/src/es/pandrama/build.gradle
index 36a69da3..dfe09271 100644
--- a/src/es/pandrama/build.gradle
+++ b/src/es/pandrama/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Pandrama'
     extClass = '.Pandrama'
-    extVersionCode = 2
+    extVersionCode = 3
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/pelisforte/build.gradle b/src/es/pelisforte/build.gradle
index 03fafc85..2c628e61 100644
--- a/src/es/pelisforte/build.gradle
+++ b/src/es/pelisforte/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'PelisForte'
     extClass = '.PelisForte'
-    extVersionCode = 30
+    extVersionCode = 32
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/pelisplushd/build.gradle b/src/es/pelisplushd/build.gradle
index 5b320ba5..b9d23c62 100644
--- a/src/es/pelisplushd/build.gradle
+++ b/src/es/pelisplushd/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Pelisplushd'
     extClass = '.PelisplushdFactory'
-    extVersionCode = 73
+    extVersionCode = 75
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/serieskao/build.gradle b/src/es/serieskao/build.gradle
index 0019d12b..86343da2 100644
--- a/src/es/serieskao/build.gradle
+++ b/src/es/serieskao/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Serieskao'
     extClass = '.Serieskao'
-    extVersionCode = 4
+    extVersionCode = 6
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/sololatino/build.gradle b/src/es/sololatino/build.gradle
index 494a153a..77ed2e8d 100644
--- a/src/es/sololatino/build.gradle
+++ b/src/es/sololatino/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.SoloLatino'
     themePkg = 'dooplay'
     baseUrl = 'https://sololatino.net'
-    overrideVersionCode = 6
+    overrideVersionCode = 8
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/tioanimeh/build.gradle b/src/es/tioanimeh/build.gradle
index 49ea5f1f..614fe1a3 100644
--- a/src/es/tioanimeh/build.gradle
+++ b/src/es/tioanimeh/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'TioanimeH'
     extClass = '.TioanimeHFactory'
-    extVersionCode = 25
+    extVersionCode = 26
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/tiodonghua/build.gradle b/src/es/tiodonghua/build.gradle
index fbefcff5..8fd1bc00 100644
--- a/src/es/tiodonghua/build.gradle
+++ b/src/es/tiodonghua/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.Tiodonghua'
     themePkg = 'animestream'
     baseUrl = 'https://anime.tiodonghua.com'
-    overrideVersionCode = 6
+    overrideVersionCode = 7
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/veranimes/build.gradle b/src/es/veranimes/build.gradle
index 13732043..8988ea52 100644
--- a/src/es/veranimes/build.gradle
+++ b/src/es/veranimes/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'VerAnimes'
     extClass = '.VerAnimes'
-    extVersionCode = 10
+    extVersionCode = 12
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/verseriesonline/build.gradle b/src/es/verseriesonline/build.gradle
index 0070c5e6..3c55ec39 100644
--- a/src/es/verseriesonline/build.gradle
+++ b/src/es/verseriesonline/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'VerSeriesOnline'
     extClass = '.VerSeriesOnline'
-    extVersionCode = 4
+    extVersionCode = 6
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/zeroanime/build.gradle b/src/es/zeroanime/build.gradle
index 21506d70..75722125 100644
--- a/src/es/zeroanime/build.gradle
+++ b/src/es/zeroanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'zeroanime'
     extClass = '.Zeroanime'
-    extVersionCode = 3
+    extVersionCode = 5
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/zonaleros/build.gradle b/src/es/zonaleros/build.gradle
index 30e67c19..12f73a68 100644
--- a/src/es/zonaleros/build.gradle
+++ b/src/es/zonaleros/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Zonaleros'
     extClass = '.Zonaleros'
-    extVersionCode = 1
+    extVersionCode = 3
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/fr/animesama/build.gradle b/src/fr/animesama/build.gradle
index b5a99a22..ae52c318 100644
--- a/src/fr/animesama/build.gradle
+++ b/src/fr/animesama/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Anime-Sama'
     extClass = '.AnimeSama'
-    extVersionCode = 11
+    extVersionCode = 12
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/fr/anisama/build.gradle b/src/fr/anisama/build.gradle
index d15cbb71..2c7cfb91 100644
--- a/src/fr/anisama/build.gradle
+++ b/src/fr/anisama/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AniSama'
     extClass = '.AniSama'
-    extVersionCode = 11
+    extVersionCode = 13
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/fr/empirestreaming/build.gradle b/src/fr/empirestreaming/build.gradle
index 52420a55..5e82879a 100644
--- a/src/fr/empirestreaming/build.gradle
+++ b/src/fr/empirestreaming/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'EmpireStreaming'
     extClass = '.EmpireStreaming'
-    extVersionCode = 18
+    extVersionCode = 19
 }
 apply from: "$rootDir/common.gradle"
 
diff --git a/src/fr/franime/build.gradle b/src/fr/franime/build.gradle
index 59725aa1..d36f22cc 100644
--- a/src/fr/franime/build.gradle
+++ b/src/fr/franime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'FrAnime'
     extClass = '.FrAnime'
-    extVersionCode = 17
+    extVersionCode = 18
     isNsfw = true
 }
 apply from: "$rootDir/common.gradle"
diff --git a/src/fr/frenchanime/build.gradle b/src/fr/frenchanime/build.gradle
index 17f4182a..2f352dc7 100644
--- a/src/fr/frenchanime/build.gradle
+++ b/src/fr/frenchanime/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.FrenchAnime'
     themePkg = 'datalifeengine'
     baseUrl = 'https://french-anime.com'
-    overrideVersionCode = 17
+    overrideVersionCode = 18
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/fr/hds/build.gradle b/src/fr/hds/build.gradle
index d7ce4c06..a1516795 100644
--- a/src/fr/hds/build.gradle
+++ b/src/fr/hds/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.Hds'
     themePkg = 'dooplay'
     baseUrl = 'https://www.hds.quest'
-    overrideVersionCode = 4
+    overrideVersionCode = 6
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/fr/jetanime/build.gradle b/src/fr/jetanime/build.gradle
index 81243b31..e1b5a7c0 100644
--- a/src/fr/jetanime/build.gradle
+++ b/src/fr/jetanime/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.JetAnime'
     themePkg = 'dooplay'
     baseUrl = 'https://ssl.jetanimes.com'
-    overrideVersionCode = 9
+    overrideVersionCode = 10
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/fr/mykdrama/build.gradle b/src/fr/mykdrama/build.gradle
index 357ab5b9..c3b0b463 100644
--- a/src/fr/mykdrama/build.gradle
+++ b/src/fr/mykdrama/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.MyKdrama'
     themePkg = 'animestream'
     baseUrl = 'https://mykdrama.co'
-    overrideVersionCode = 1
+    overrideVersionCode = 2
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/fr/otakufr/build.gradle b/src/fr/otakufr/build.gradle
index 8781806c..852aa3a7 100644
--- a/src/fr/otakufr/build.gradle
+++ b/src/fr/otakufr/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'OtakuFR'
     extClass = '.OtakuFR'
-    extVersionCode = 25
+    extVersionCode = 27
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/fr/voircartoon/build.gradle b/src/fr/voircartoon/build.gradle
index 0057b5fd..7492f5ac 100644
--- a/src/fr/voircartoon/build.gradle
+++ b/src/fr/voircartoon/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.VoirCartoon'
     themePkg = 'dooplay'
     baseUrl = 'https://voircartoon.com'
-    overrideVersionCode = 7
+    overrideVersionCode = 8
     isNsfw = true
 }
 
diff --git a/src/fr/vostfree/build.gradle b/src/fr/vostfree/build.gradle
index d8aa79e3..bdd145a8 100644
--- a/src/fr/vostfree/build.gradle
+++ b/src/fr/vostfree/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Vostfree'
     extClass = '.Vostfree'
-    extVersionCode = 26
+    extVersionCode = 27
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/fr/wiflix/build.gradle b/src/fr/wiflix/build.gradle
index 8cba671b..a1b350d6 100644
--- a/src/fr/wiflix/build.gradle
+++ b/src/fr/wiflix/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.Wiflix'
     themePkg = 'datalifeengine'
     baseUrl = 'https://wiflix.voto'
-    overrideVersionCode = 15
+    overrideVersionCode = 16
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/hi/animesaga/build.gradle b/src/hi/animesaga/build.gradle
index bcfeeaa0..b52e6be8 100644
--- a/src/hi/animesaga/build.gradle
+++ b/src/hi/animesaga/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.AniSAGA'
     themePkg = 'dooplay'
     baseUrl = 'https://www.anisaga.org'
-    overrideVersionCode = 16
+    overrideVersionCode = 20
     isNsfw = false
 }
 
diff --git a/src/hi/animesaga/res/mipmap-hdpi/ic_launcher.png b/src/hi/animesaga/res/mipmap-hdpi/ic_launcher.png
index 404391dc..c7ade7ab 100644
Binary files a/src/hi/animesaga/res/mipmap-hdpi/ic_launcher.png and b/src/hi/animesaga/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/hi/animesaga/res/mipmap-mdpi/ic_launcher.png b/src/hi/animesaga/res/mipmap-mdpi/ic_launcher.png
index b5d3bc49..3269ef51 100644
Binary files a/src/hi/animesaga/res/mipmap-mdpi/ic_launcher.png and b/src/hi/animesaga/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/hi/animesaga/res/mipmap-xhdpi/ic_launcher.png b/src/hi/animesaga/res/mipmap-xhdpi/ic_launcher.png
index db11dc4b..8f5bbabf 100644
Binary files a/src/hi/animesaga/res/mipmap-xhdpi/ic_launcher.png and b/src/hi/animesaga/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/hi/animesaga/res/mipmap-xxhdpi/ic_launcher.png b/src/hi/animesaga/res/mipmap-xxhdpi/ic_launcher.png
index c77d71ed..a36ac1cf 100644
Binary files a/src/hi/animesaga/res/mipmap-xxhdpi/ic_launcher.png and b/src/hi/animesaga/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/hi/animesaga/res/mipmap-xxxhdpi/ic_launcher.png b/src/hi/animesaga/res/mipmap-xxxhdpi/ic_launcher.png
index 3ce95e50..15ff6ade 100644
Binary files a/src/hi/animesaga/res/mipmap-xxxhdpi/ic_launcher.png and b/src/hi/animesaga/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/hi/animesaga/src/eu/kanade/tachiyomi/animeextension/hi/animesaga/AniSAGA.kt b/src/hi/animesaga/src/eu/kanade/tachiyomi/animeextension/hi/animesaga/AniSAGA.kt
index 6c077aed..c9b58d31 100644
--- a/src/hi/animesaga/src/eu/kanade/tachiyomi/animeextension/hi/animesaga/AniSAGA.kt
+++ b/src/hi/animesaga/src/eu/kanade/tachiyomi/animeextension/hi/animesaga/AniSAGA.kt
@@ -14,7 +14,7 @@ class AniSAGA : DooPlay(
     "AniSAGA",
     "https://www.anisaga.org",
 ) {
-    private val videoHost = "https://plyrxcdn.site/"
+    private val videoHost = "https://plyrxcdn.site"
 
     // ============================== Popular ===============================
     override fun popularAnimeSelector() = "div.top-imdb-list > div.top-imdb-item"
diff --git a/src/hi/yomovies/build.gradle b/src/hi/yomovies/build.gradle
index 5c2f13b3..f17d62d7 100644
--- a/src/hi/yomovies/build.gradle
+++ b/src/hi/yomovies/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'YoMovies'
     extClass = '.YoMovies'
-    extVersionCode = 23
+    extVersionCode = 24
     isNsfw = true
 }
 
diff --git a/src/id/animeindo/build.gradle b/src/id/animeindo/build.gradle
index f4a4b2d4..0abc46a5 100644
--- a/src/id/animeindo/build.gradle
+++ b/src/id/animeindo/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.AnimeIndo'
     themePkg = 'animestream'
     baseUrl = 'https://animeindo.skin'
-    overrideVersionCode = 12
+    overrideVersionCode = 13
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/id/neonime/build.gradle b/src/id/neonime/build.gradle
index 9c6f473b..f0b46227 100644
--- a/src/id/neonime/build.gradle
+++ b/src/id/neonime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'NeoNime'
     extClass = '.NeoNime'
-    extVersionCode = 14
+    extVersionCode = 15
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/id/otakudesu/build.gradle b/src/id/otakudesu/build.gradle
index 8afaaba1..22e6903d 100644
--- a/src/id/otakudesu/build.gradle
+++ b/src/id/otakudesu/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'OtakuDesu'
     extClass = '.OtakuDesu'
-    extVersionCode = 31
+    extVersionCode = 33
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/it/animeworld/build.gradle b/src/it/animeworld/build.gradle
index 9020acf2..1b4c689e 100644
--- a/src/it/animeworld/build.gradle
+++ b/src/it/animeworld/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'ANIMEWORLD.tv'
     extClass = '.ANIMEWORLD'
-    extVersionCode = 47
+    extVersionCode = 48
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/it/aniplay/build.gradle b/src/it/aniplay/build.gradle
index b1a5c283..d44a69ea 100644
--- a/src/it/aniplay/build.gradle
+++ b/src/it/aniplay/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AniPlay'
     extClass = '.AniPlay'
-    extVersionCode = 13
+    extVersionCode = 14
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/it/streamingcommunity/build.gradle b/src/it/streamingcommunity/build.gradle
index bff9384f..e990e1ae 100644
--- a/src/it/streamingcommunity/build.gradle
+++ b/src/it/streamingcommunity/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'StreamingCommunity'
     extClass = '.StreamingCommunity'
-    extVersionCode = 5
+    extVersionCode = 6
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/it/streamingcommunity/src/eu/kanade/tachiyomi/animeextension/it/streamingcommunity/StreamingCommunity.kt b/src/it/streamingcommunity/src/eu/kanade/tachiyomi/animeextension/it/streamingcommunity/StreamingCommunity.kt
index 82fadc5a..a41d9088 100644
--- a/src/it/streamingcommunity/src/eu/kanade/tachiyomi/animeextension/it/streamingcommunity/StreamingCommunity.kt
+++ b/src/it/streamingcommunity/src/eu/kanade/tachiyomi/animeextension/it/streamingcommunity/StreamingCommunity.kt
@@ -30,7 +30,7 @@ class StreamingCommunity : ConfigurableAnimeSource, AnimeHttpSource() {
 
     override val name = "StreamingCommunity"
 
-    override val baseUrl = "https://streamingcommunity.photos"
+    override val baseUrl = "https://streamingcommunity.spa"
 
     override val lang = "it"
 
diff --git a/src/it/toonitalia/build.gradle b/src/it/toonitalia/build.gradle
index c2f2e9aa..5152aa4d 100644
--- a/src/it/toonitalia/build.gradle
+++ b/src/it/toonitalia/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Toonitalia'
     extClass = '.Toonitalia'
-    extVersionCode = 25
+    extVersionCode = 26
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/ko/aniweek/build.gradle b/src/ko/aniweek/build.gradle
index b71da9ab..362376b5 100644
--- a/src/ko/aniweek/build.gradle
+++ b/src/ko/aniweek/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Aniweek'
     extClass = '.Aniweek'
-    extVersionCode = 10
+    extVersionCode = 11
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/pl/desuonline/build.gradle b/src/pl/desuonline/build.gradle
index 0ef68f2b..f0b0a3aa 100644
--- a/src/pl/desuonline/build.gradle
+++ b/src/pl/desuonline/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.DesuOnline'
     themePkg = 'animestream'
     baseUrl = 'https://desu-online.pl'
-    overrideVersionCode = 5
+    overrideVersionCode = 6
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/pl/docchi/build.gradle b/src/pl/docchi/build.gradle
index 79a34009..961cf4d5 100644
--- a/src/pl/docchi/build.gradle
+++ b/src/pl/docchi/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Docchi'
     extClass = '.Docchi'
-    extVersionCode = 2
+    extVersionCode = 4
     isNsfw = true
 }
 
diff --git a/src/pl/docchi/src/eu/kanade/tachiyomi/animeextension/pl/docchi/Docchi.kt b/src/pl/docchi/src/eu/kanade/tachiyomi/animeextension/pl/docchi/Docchi.kt
index 62daaed8..37b3b385 100644
--- a/src/pl/docchi/src/eu/kanade/tachiyomi/animeextension/pl/docchi/Docchi.kt
+++ b/src/pl/docchi/src/eu/kanade/tachiyomi/animeextension/pl/docchi/Docchi.kt
@@ -137,7 +137,7 @@ class Docchi : ConfigurableAnimeSource, AnimeHttpSource() {
     private val sibnetExtractor by lazy { SibnetExtractor(client) }
     private val doodExtractor by lazy { DoodExtractor(client) }
     private val lycorisExtractor by lazy { LycorisCafeExtractor(client) }
-    private val luluExtractor by lazy { LuluExtractor(client) }
+    private val luluExtractor by lazy { LuluExtractor(client, headers) }
     private val googledriveExtractor by lazy { GoogleDriveExtractor(client, headers) }
 
     override fun videoListParse(response: Response): List<Video> {
@@ -278,7 +278,7 @@ class Docchi : ConfigurableAnimeSource, AnimeHttpSource() {
         val genres: List<String>,
         val broadcast_day: String?,
         val aired_from: String?,
-        val episodes: Int,
+        val episodes: Int?,
         val season: String,
         val season_year: Int,
         val series_type: String,
@@ -294,7 +294,7 @@ class Docchi : ConfigurableAnimeSource, AnimeHttpSource() {
         val cover: String,
         val adult_content: String,
         val series_type: String,
-        val episodes: Int,
+        val episodes: Int?,
         val season: String,
         val season_year: Int,
     )
@@ -315,7 +315,7 @@ class Docchi : ConfigurableAnimeSource, AnimeHttpSource() {
         val genres: List<String>,
         val broadcast_day: String?,
         val aired_from: String?,
-        val episodes: Int,
+        val episodes: Int?,
         val season: String,
         val season_year: Int,
         val series_type: String,
diff --git a/src/pl/wbijam/build.gradle b/src/pl/wbijam/build.gradle
index bcff6f7f..5c7a01ec 100644
--- a/src/pl/wbijam/build.gradle
+++ b/src/pl/wbijam/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Wbijam'
     extClass = '.Wbijam'
-    extVersionCode = 5
+    extVersionCode = 6
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/pt/animesbr/build.gradle b/src/pt/animesbr/build.gradle
index f16f26e0..90d44879 100644
--- a/src/pt/animesbr/build.gradle
+++ b/src/pt/animesbr/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.AnimesBr'
     themePkg = 'dooplay'
     baseUrl = 'https://animesbr.tv'
-    overrideVersionCode = 1
+    overrideVersionCode = 2
     isNsfw = true
 }
 
diff --git a/src/pt/animesgratis/build.gradle b/src/pt/animesgratis/build.gradle
index 8e0c3b14..208b539f 100644
--- a/src/pt/animesgratis/build.gradle
+++ b/src/pt/animesgratis/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.Q1N'
     themePkg = 'dooplay'
     baseUrl = 'https://q1n.net'
-    overrideVersionCode = 18
+    overrideVersionCode = 20
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/pt/darkmahou/build.gradle b/src/pt/darkmahou/build.gradle
index 72ec2b3b..ca045f0f 100644
--- a/src/pt/darkmahou/build.gradle
+++ b/src/pt/darkmahou/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.DarkMahou'
     themePkg = 'animestream'
     baseUrl = 'https://darkmahou.org'
-    overrideVersionCode = 3
+    overrideVersionCode = 4
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/pt/doramogo/build.gradle b/src/pt/doramogo/build.gradle
index 82057653..be7fa984 100644
--- a/src/pt/doramogo/build.gradle
+++ b/src/pt/doramogo/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Doramogo'
     extClass = '.Doramogo'
-    extVersionCode = 6
+    extVersionCode = 7
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/pt/pifansubs/build.gradle b/src/pt/pifansubs/build.gradle
index b21d7a3c..8576e316 100644
--- a/src/pt/pifansubs/build.gradle
+++ b/src/pt/pifansubs/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.PiFansubs'
     themePkg = 'dooplay'
     baseUrl = 'https://pifansubs.club'
-    overrideVersionCode = 22
+    overrideVersionCode = 23
     isNsfw = true
 }
 
diff --git a/src/ru/animelib/build.gradle b/src/ru/animelib/build.gradle
index af264279..8dbf9698 100644
--- a/src/ru/animelib/build.gradle
+++ b/src/ru/animelib/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Animelib'
     extClass = '.Animelib'
-    extVersionCode = 3
+    extVersionCode = 4
     isNsfw = true
 }
 
diff --git a/src/sr/animebalkan/build.gradle b/src/sr/animebalkan/build.gradle
index e0facc3e..91862aa1 100644
--- a/src/sr/animebalkan/build.gradle
+++ b/src/sr/animebalkan/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.AnimeBalkan'
     themePkg = 'animestream'
     baseUrl = 'https://animebalkan.org'
-    overrideVersionCode = 2
+    overrideVersionCode = 3
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/sr/animesrbija/build.gradle b/src/sr/animesrbija/build.gradle
index dcb1115b..1a5e02dc 100644
--- a/src/sr/animesrbija/build.gradle
+++ b/src/sr/animesrbija/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Anime Srbija'
     extClass = '.AnimeSrbija'
-    extVersionCode = 11
+    extVersionCode = 13
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/tr/animeler/build.gradle b/src/tr/animeler/build.gradle
index 58181623..70b0f798 100644
--- a/src/tr/animeler/build.gradle
+++ b/src/tr/animeler/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Animeler'
     extClass = '.Animeler'
-    extVersionCode = 16
+    extVersionCode = 18
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/tr/anizm/build.gradle b/src/tr/anizm/build.gradle
index 102ced5e..a3e0532d 100644
--- a/src/tr/anizm/build.gradle
+++ b/src/tr/anizm/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Anizm'
     extClass = '.Anizm'
-    extVersionCode = 25
+    extVersionCode = 27
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/tr/asyaanimeleri/build.gradle b/src/tr/asyaanimeleri/build.gradle
index 5520f4ef..915227b1 100644
--- a/src/tr/asyaanimeleri/build.gradle
+++ b/src/tr/asyaanimeleri/build.gradle
@@ -3,7 +3,7 @@ ext {
     extClass = '.AsyaAnimeleri'
     themePkg = 'animestream'
     baseUrl = 'https://asyaanimeleri.com'
-    overrideVersionCode = 5
+    overrideVersionCode = 6
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/tr/hdfilmcehennemi/build.gradle b/src/tr/hdfilmcehennemi/build.gradle
index b3905c3a..4342e877 100644
--- a/src/tr/hdfilmcehennemi/build.gradle
+++ b/src/tr/hdfilmcehennemi/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'HDFilmCehennemi'
     extClass = '.HDFilmCehennemi'
-    extVersionCode = 21
+    extVersionCode = 22
     isNsfw = true
 }
 
diff --git a/src/tr/tranimeizle/build.gradle b/src/tr/tranimeizle/build.gradle
index 426aa9a6..d133e553 100644
--- a/src/tr/tranimeizle/build.gradle
+++ b/src/tr/tranimeizle/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'TR Anime Izle'
     extClass = '.TRAnimeIzle'
-    extVersionCode = 21
+    extVersionCode = 23
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/tr/turkanime/build.gradle b/src/tr/turkanime/build.gradle
index 3f3d3007..1a4a3b3b 100644
--- a/src/tr/turkanime/build.gradle
+++ b/src/tr/turkanime/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Türk Anime TV'
     extClass = '.TurkAnime'
-    extVersionCode = 34
+    extVersionCode = 36
 }
 
 apply from: "$rootDir/common.gradle"