diff --git a/lib/fireplayer-extractor/src/main/java/eu/kanade/tachiyomi/lib/fireplayerextractor/FireplayerExtractor.kt b/lib/fireplayer-extractor/src/main/java/eu/kanade/tachiyomi/lib/fireplayerextractor/FireplayerExtractor.kt
index 4afa8d95..f9735def 100644
--- a/lib/fireplayer-extractor/src/main/java/eu/kanade/tachiyomi/lib/fireplayerextractor/FireplayerExtractor.kt
+++ b/lib/fireplayer-extractor/src/main/java/eu/kanade/tachiyomi/lib/fireplayerextractor/FireplayerExtractor.kt
@@ -36,7 +36,6 @@ class FireplayerExtractor(
 
             val script =
                 doc.selectFirst("script:containsData(eval):containsData(p,a,c,k,e,d)")?.data()
-                    ?.replace(Regex("[\\u00E0-\\u00FC]"), "-") // Fix a bug in JsUnpacker with accents
                     ?.let(JsUnpacker::unpackAndCombine)
                     ?: doc.selectFirst("script:containsData(FirePlayer)")?.data()
 
diff --git a/src/pt/anitube/build.gradle b/src/pt/anitube/build.gradle
index 519039b0..a468f926 100644
--- a/src/pt/anitube/build.gradle
+++ b/src/pt/anitube/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Anitube'
     extClass = '.Anitube'
-    extVersionCode = 20
+    extVersionCode = 19
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/pt/anitube/src/eu/kanade/tachiyomi/animeextension/pt/anitube/Anitube.kt b/src/pt/anitube/src/eu/kanade/tachiyomi/animeextension/pt/anitube/Anitube.kt
index 4f5f8ae6..9d5e4d02 100644
--- a/src/pt/anitube/src/eu/kanade/tachiyomi/animeextension/pt/anitube/Anitube.kt
+++ b/src/pt/anitube/src/eu/kanade/tachiyomi/animeextension/pt/anitube/Anitube.kt
@@ -4,7 +4,6 @@ import android.app.Application
 import androidx.preference.EditTextPreference
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
-import androidx.preference.SwitchPreferenceCompat
 import eu.kanade.tachiyomi.animeextension.pt.anitube.extractors.AnitubeDownloadExtractor
 import eu.kanade.tachiyomi.animeextension.pt.anitube.extractors.AnitubeExtractor
 import eu.kanade.tachiyomi.animesource.ConfigurableAnimeSource
@@ -200,10 +199,8 @@ class Anitube : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
         val links = mutableListOf(document.location())
 
-        if (preferences.getBoolean(PREF_FILE4GO_KEY, PREF_FILE4GO_DEFAULT)!!) {
-            document.selectFirst("div.abaItemDown > a")?.attr("href")?.let {
-                links.add(it)
-            }
+        document.selectFirst("div.abaItemDown > a")?.attr("href")?.let {
+            links.add(it)
         }
 
         val epName = document.selectFirst("meta[itemprop=name]")!!.attr("content")
@@ -238,16 +235,6 @@ class Anitube : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
             }
         }.also(screen::addPreference)
 
-        SwitchPreferenceCompat(screen.context).apply {
-            key = PREF_FILE4GO_KEY
-            title = "Usar File4Go como mirror"
-            setDefaultValue(PREF_FILE4GO_DEFAULT)
-            summary = PREF_FILE4GO_SUMMARY
-            setOnPreferenceChangeListener { _, newValue ->
-                preferences.edit().putBoolean(key, newValue as Boolean).commit()
-            }
-        }.also(screen::addPreference)
-
         // Auth Code
         EditTextPreference(screen.context).apply {
             key = PREF_AUTHCODE_KEY
@@ -321,9 +308,6 @@ class Anitube : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         private const val PREF_AUTHCODE_KEY = "authcode"
         private const val PREF_AUTHCODE_SUMMARY = "Código de Autenticação"
         private const val PREF_AUTHCODE_DEFAULT = ""
-        private const val PREF_FILE4GO_KEY = "file4go"
-        private const val PREF_FILE4GO_SUMMARY = "Usar File4Go como mirror"
-        private const val PREF_FILE4GO_DEFAULT = false
         private const val PREF_QUALITY_KEY = "preferred_quality"
         private const val PREF_QUALITY_TITLE = "Qualidade preferida"
         private const val PREF_QUALITY_DEFAULT = "HD"
diff --git a/src/pt/anitube/src/eu/kanade/tachiyomi/animeextension/pt/anitube/extractors/AnitubeDownloadExtractor.kt b/src/pt/anitube/src/eu/kanade/tachiyomi/animeextension/pt/anitube/extractors/AnitubeDownloadExtractor.kt
index a5e864ce..2d0bb1d6 100644
--- a/src/pt/anitube/src/eu/kanade/tachiyomi/animeextension/pt/anitube/extractors/AnitubeDownloadExtractor.kt
+++ b/src/pt/anitube/src/eu/kanade/tachiyomi/animeextension/pt/anitube/extractors/AnitubeDownloadExtractor.kt
@@ -8,7 +8,6 @@ import eu.kanade.tachiyomi.util.asJsoup
 import eu.kanade.tachiyomi.util.parallelMapNotNullBlocking
 import okhttp3.FormBody
 import okhttp3.Headers
-import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.OkHttpClient
 
 class AnitubeDownloadExtractor(
@@ -21,33 +20,23 @@ class AnitubeDownloadExtractor(
 
     private fun videosFromFile4Go(url: String, quality: String): Video? {
         Log.d(tag, "Checking download for $url")
+        val docDownload = client.newCall(GET(url)).execute().asJsoup()
 
-        val newHeaders = headers.newBuilder()
-            .set("Referer", "https://${url.toHttpUrl().host}/")
-            .add("Accept", "*/*")
-            .add("Cache-Control", "no-cache")
-            .add("Pragma", "no-cache")
-            .add("Connection", "keep-alive")
-            .add("Sec-Fetch-Dest", "empty")
-            .add("Sec-Fetch-Mode", "cors")
-            .add("Sec-Fetch-Site", "same-site")
-            .build()
+        val form =
+            docDownload.selectFirst("button.download")?.closest("form")
 
-        val id = url.split('/').last()
-        val idusuario =
-            client.newCall(GET("$ADS_URL/file4go.php", headers = newHeaders))
-                .execute()
-                .body.string()
-                .substringAfter("\"publicidade\"")
-                .substringAfter('"')
-                .substringBefore('"')
+        if (form == null) {
+            Log.d(tag, "Download form not found for $url")
+            return null
+        }
 
         val body = FormBody.Builder().apply {
-            add("id", id)
-            add("idusuario", idusuario)
+            form.select("input[name]").forEach {
+                add(it.attr("name"), it.attr("value"))
+            }
         }.build()
 
-        val postUrl = "https://www.file4go.net/getdownload_new_anitube.php"
+        val postUrl = form.attr("action")
 
         val postHeaders = headers.newBuilder()
             .set("Referer", url)
@@ -106,8 +95,4 @@ class AnitubeDownloadExtractor(
 
         return videosFromDownloadPage(url, epName)
     }
-
-    companion object {
-        private const val ADS_URL = "https://ads.anitube.vip"
-    }
 }
diff --git a/src/pt/megaflix/build.gradle b/src/pt/megaflix/build.gradle
index ff685850..ede65fca 100644
--- a/src/pt/megaflix/build.gradle
+++ b/src/pt/megaflix/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Megaflix'
     extClass = '.Megaflix'
-    extVersionCode = 20
+    extVersionCode = 19
     isNsfw = true
 }
 
diff --git a/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/Megaflix.kt b/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/Megaflix.kt
index e64a0785..edb032cb 100644
--- a/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/Megaflix.kt
+++ b/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/Megaflix.kt
@@ -1,6 +1,7 @@
 package eu.kanade.tachiyomi.animeextension.pt.megaflix
 
 import android.app.Application
+import android.util.Base64
 import androidx.preference.ListPreference
 import androidx.preference.PreferenceScreen
 import eu.kanade.tachiyomi.animeextension.pt.megaflix.extractors.MegaflixExtractor
@@ -13,7 +14,6 @@ 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.mixdropextractor.MixDropExtractor
-import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
 import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
 import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
 import eu.kanade.tachiyomi.lib.vidhideextractor.VidHideExtractor
@@ -35,7 +35,7 @@ class Megaflix : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override val name = "Megaflix"
 
-    override val baseUrl = "https://megaflix.ac"
+    override val baseUrl = "https://megaflix.co"
 
     override val lang = "pt-BR"
 
@@ -73,11 +73,7 @@ class Megaflix : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
     override fun latestUpdatesNextPageSelector() = "div.nav-links > a:containsOwn(PRÓXIMO)"
 
     // =============================== Search ===============================
-    override suspend fun getSearchAnime(
-        page: Int,
-        query: String,
-        filters: AnimeFilterList,
-    ): AnimesPage {
+    override suspend fun getSearchAnime(page: Int, query: String, filters: AnimeFilterList): AnimesPage {
         return if (query.startsWith(PREFIX_SEARCH)) { // URL intent handler
             val path = query.removePrefix(PREFIX_SEARCH)
             client.newCall(GET("$baseUrl/$path"))
@@ -139,7 +135,6 @@ class Megaflix : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
                     episode_number = 1F
                 },
             )
-
             else -> seasons.parallelFlatMapBlocking(::episodesFromSeason).reversed()
         }
     }
@@ -168,14 +163,12 @@ class Megaflix : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
             .parallelCatchingFlatMapBlocking { element ->
                 val language = element.text().substringAfter("-")
                 val id = element.attr("href")
-                val url = element.closest("body")?.selectFirst("div$id iframe")
-                    ?.let {
-                        val iframeUrl = it.attr("src")
-                        client.newCall(GET(iframeUrl, headers))
-                            .execute()
-                            .asJsoup()
-                            .selectFirst("iframe")
-                            ?.attr("src")
+                val url = element.parents().get(5)?.selectFirst("div$id a")
+                    ?.run {
+                        attr("href")
+                            .substringAfter("token=")
+                            .let { String(Base64.decode(it, Base64.DEFAULT)) }
+                            .substringAfter("||")
                     } ?: return@parallelCatchingFlatMapBlocking emptyList()
 
                 getVideoList(url, language)
@@ -183,9 +176,6 @@ class Megaflix : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
     }
 
     /*--------------------------------Video extractors------------------------------------*/
-    private val webViewResolver by lazy { WebViewResolver() }
-    private val playlistUtils by lazy { PlaylistUtils(client, headers) }
-
     private val mixdropExtractor by lazy { MixDropExtractor(client) }
     private val streamtapeExtractor by lazy { StreamTapeExtractor(client) }
     private val megaflixExtractor by lazy { MegaflixExtractor(client, headers) }
@@ -203,17 +193,6 @@ class Megaflix : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
             arrayOf("filemoon", "moonplayer").any(url) -> filemoonExtractor.videosFromUrl(url, prefix = "$language Filemoon:")
             arrayOf("vidhide", "vid.").any(url) -> vidHideExtractor.videosFromUrl(url, videoNameGen = { "$language VidHide:$it" })
             arrayOf("wishembed", "streamwish", "strwish", "wish", "jwplayerhls").any(url) -> streamWishExtractor.videosFromUrl(url, videoNameGen = { "$language StreamWish:$it" })
-            arrayOf("fembedder").any(url) -> {
-                val webViewResult = webViewResolver.getUrl(url, headers)
-                if (webViewResult.isBlank()) {
-                    return emptyList()
-                }
-                return if (webViewResult.contains("m3u8")) {
-                    playlistUtils.extractFromHls(webViewResult)
-                } else {
-                    listOf(Video(url, "Default", url))
-                }
-            }
             else -> emptyList()
         }
     }
diff --git a/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/MegaflixUrlActivity.kt b/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/MegaflixUrlActivity.kt
index cec9a93d..f3f5edff 100644
--- a/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/MegaflixUrlActivity.kt
+++ b/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/MegaflixUrlActivity.kt
@@ -8,7 +8,7 @@ import android.util.Log
 import kotlin.system.exitProcess
 
 /**
- * Springboard that accepts https://megaflix.ac/<type>/<item> intents
+ * Springboard that accepts https://megaflix.co/<type>/<item> intents
  * and redirects them to the main Aniyomi process.
  */
 class MegaflixUrlActivity : Activity() {
diff --git a/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/WebViewResolver.kt b/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/WebViewResolver.kt
deleted file mode 100644
index a1c377b0..00000000
--- a/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/WebViewResolver.kt
+++ /dev/null
@@ -1,69 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.megaflix
-
-import android.annotation.SuppressLint
-import android.app.Application
-import android.os.Handler
-import android.os.Looper
-import android.webkit.WebResourceRequest
-import android.webkit.WebResourceResponse
-import android.webkit.WebView
-import android.webkit.WebViewClient
-import okhttp3.Headers
-import uy.kohesive.injekt.injectLazy
-import java.util.concurrent.CountDownLatch
-import java.util.concurrent.TimeUnit
-
-class WebViewResolver() {
-    private val context: Application by injectLazy()
-    private val handler by lazy { Handler(Looper.getMainLooper()) }
-
-    @SuppressLint("SetJavaScriptEnabled")
-    fun getUrl(origRequestUrl: String, origRequestheader: Headers): String {
-        val latch = CountDownLatch(1)
-        var webView: WebView? = null
-        var resultUrl = ""
-        val headers = origRequestheader.toMultimap().mapValues { it.value.getOrNull(0) ?: "" }.toMutableMap()
-
-        handler.post {
-            val webview = WebView(context)
-            webView = webview
-            with(webview.settings) {
-                javaScriptEnabled = true
-                domStorageEnabled = true
-                databaseEnabled = true
-                useWideViewPort = false
-                loadWithOverviewMode = false
-                userAgentString = origRequestheader["User-Agent"]
-            }
-            webview.webViewClient = object : WebViewClient() {
-                override fun shouldInterceptRequest(
-                    view: WebView,
-                    request: WebResourceRequest,
-                ): WebResourceResponse? {
-                    val url = request.url.toString()
-                    if (VIDEO_REGEX.containsMatchIn(url)) {
-                        resultUrl = url
-                        latch.countDown()
-                    }
-                    return super.shouldInterceptRequest(view, request)
-                }
-            }
-
-            webView?.loadUrl(origRequestUrl, headers)
-        }
-
-        latch.await(TIMEOUT_SEC, TimeUnit.SECONDS)
-
-        handler.post {
-            webView?.stopLoading()
-            webView?.destroy()
-            webView = null
-        }
-        return resultUrl
-    }
-
-    companion object {
-        const val TIMEOUT_SEC: Long = 20
-        private val VIDEO_REGEX by lazy { Regex("\\.(mp4|m3u8)") }
-    }
-}
diff --git a/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/extractors/MegaflixExtractor.kt b/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/extractors/MegaflixExtractor.kt
index 849511d8..a7a4e96e 100644
--- a/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/extractors/MegaflixExtractor.kt
+++ b/src/pt/megaflix/src/eu/kanade/tachiyomi/animeextension/pt/megaflix/extractors/MegaflixExtractor.kt
@@ -21,7 +21,7 @@ class MegaflixExtractor(private val client: OkHttpClient, private val headers: H
 
         return playlistUtils.extractFromHls(
             playlistUrl,
-            "https://megaflix.ac",
+            "https://megaflix.co",
             videoNameGen = { "Megaflix($lang) - $it" },
         )
     }
diff --git a/src/pt/pobreflix/build.gradle b/src/pt/pobreflix/build.gradle
index dc3a63cd..ec1d8eb7 100644
--- a/src/pt/pobreflix/build.gradle
+++ b/src/pt/pobreflix/build.gradle
@@ -2,8 +2,8 @@ ext {
     extName = 'Pobreflix'
     extClass = '.Pobreflix'
     themePkg = 'dooplay'
-    baseUrl = 'https://pobreflix.global'
-    overrideVersionCode = 13
+    baseUrl = 'https://pobreflix1.art'
+    overrideVersionCode = 10
     isNsfw = true
 }
 
@@ -11,7 +11,6 @@ apply from: "$rootDir/common.gradle"
 
 dependencies {
     implementation(project(":lib:filemoon-extractor"))
-    implementation(project(":lib:fireplayer-extractor"))
     implementation(project(":lib:streamwish-extractor"))
     implementation(project(":lib:streamtape-extractor"))
     implementation(project(":lib:playlist-utils"))
diff --git a/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/Pobreflix.kt b/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/Pobreflix.kt
index c1159018..30783608 100644
--- a/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/Pobreflix.kt
+++ b/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/Pobreflix.kt
@@ -1,25 +1,23 @@
 package eu.kanade.tachiyomi.animeextension.pt.pobreflix
 
 import android.util.Base64
+import eu.kanade.tachiyomi.animeextension.pt.pobreflix.extractors.FireplayerExtractor
 import eu.kanade.tachiyomi.animeextension.pt.pobreflix.extractors.MyStreamExtractor
-import eu.kanade.tachiyomi.animeextension.pt.pobreflix.extractors.PlayerFlixExtractor
 import eu.kanade.tachiyomi.animeextension.pt.pobreflix.extractors.SuperFlixExtractor
 import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.lib.filemoonextractor.FilemoonExtractor
-import eu.kanade.tachiyomi.lib.fireplayerextractor.FireplayerExtractor
 import eu.kanade.tachiyomi.lib.streamtapeextractor.StreamTapeExtractor
 import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
 import eu.kanade.tachiyomi.multisrc.dooplay.DooPlay
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
-import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.Response
 
 class Pobreflix : DooPlay(
     "pt-BR",
     "Pobreflix",
-    "https://pobreflix.global",
+    "https://pobreflix1.art",
 ) {
     // ============================== Popular ===============================
     override fun popularAnimeSelector() = "div.featured div.poster"
@@ -28,52 +26,53 @@ class Pobreflix : DooPlay(
     override fun latestUpdatesRequest(page: Int) = GET("$baseUrl/series/page/$page/", headers)
 
     // ============================ Video Links =============================
-    private val fireplayerExtractor by lazy { FireplayerExtractor(client) }
+    private val embedplayerExtractor by lazy { FireplayerExtractor(client) }
+    private val brbeastExtractor by lazy { FireplayerExtractor(client, "https://brbeast.com") }
+    private val superembedsExtractor by lazy { FireplayerExtractor(client, "https://superembeds.com/") }
     private val filemoonExtractor by lazy { FilemoonExtractor(client) }
     private val mystreamExtractor by lazy { MyStreamExtractor(client, headers) }
     private val streamtapeExtractor by lazy { StreamTapeExtractor(client) }
     private val streamwishExtractor by lazy { StreamWishExtractor(client, headers) }
-    private val playerflixExtractor by lazy { PlayerFlixExtractor(client, headers, ::genericExtractor) }
     private val superflixExtractor by lazy { SuperFlixExtractor(client, headers, ::genericExtractor) }
     private val supercdnExtractor by lazy { SuperFlixExtractor(client, headers, ::genericExtractor, "https://supercdn.org") }
 
     override fun videoListParse(response: Response): List<Video> {
         val doc = response.asJsoup()
-        return doc.select("div.source-box > a").parallelCatchingFlatMapBlocking {
-            val data = it.attr("href").trim().toHttpUrl().queryParameter("auth")
-                ?.let { Base64.decode(it, Base64.DEFAULT) }
-                ?.let(::String)
-                ?: return@parallelCatchingFlatMapBlocking emptyList()
-            val url = data.replace("\\", "").substringAfter("url\":\"").substringBefore('"')
-            genericExtractor(url)
+        return doc.select("div.source-box > a").flatMap {
+            runCatching {
+                val data = it.attr("href").toHttpUrl().queryParameter("auth")
+                    ?.let { Base64.decode(it, Base64.DEFAULT) }
+                    ?.let(::String)
+                    ?: return@flatMap emptyList()
+                val url = data.replace("\\", "").substringAfter("url\":\"").substringBefore('"')
+                genericExtractor(url)
+            }.getOrElse { emptyList() }
         }
     }
 
     private fun genericExtractor(url: String, language: String = ""): List<Video> {
-        val langSubstr = if (language.isBlank()) "" else "[$language] "
+        val langSubstr = "[$language]"
         return when {
             url.contains("superflix") ->
                 superflixExtractor.videosFromUrl(url)
             url.contains("supercdn") ->
                 supercdnExtractor.videosFromUrl(url)
             url.contains("filemoon") ->
-                filemoonExtractor.videosFromUrl(url, "${langSubstr}Filemoon - ", headers = headers)
+                filemoonExtractor.videosFromUrl(url, "$langSubstr Filemoon - ", headers = headers)
             url.contains("watch.brplayer") || url.contains("/watch?v=") ->
                 mystreamExtractor.videosFromUrl(url, language)
             url.contains("brbeast") ->
-                fireplayerExtractor.videosFromUrl(url = url, videoNameGen = { "${langSubstr}BrBeast - $it" })
+                brbeastExtractor.videosFromUrl(url, language)
             url.contains("embedplayer") ->
-                fireplayerExtractor.videosFromUrl(url = url, videoNameGen = { "${langSubstr}EmbedPlayer - $it" })
+                embedplayerExtractor.videosFromUrl(url, language)
             url.contains("superembeds") ->
-                fireplayerExtractor.videosFromUrl(url = url, videoNameGen = { "${langSubstr}SuperEmbeds - $it" })
+                superembedsExtractor.videosFromUrl(url, language)
             url.contains("streamtape") ->
-                streamtapeExtractor.videosFromUrl(url, "${langSubstr}Streamtape")
+                streamtapeExtractor.videosFromUrl(url, "$langSubstr Streamtape")
             url.contains("filelions") ->
-                streamwishExtractor.videosFromUrl(url, videoNameGen = { "${langSubstr}FileLions - $it" })
+                streamwishExtractor.videosFromUrl(url, videoNameGen = { "$langSubstr FileLions - $it" })
             url.contains("streamwish") ->
-                streamwishExtractor.videosFromUrl(url, videoNameGen = { "${langSubstr}Streamwish - $it" })
-            url.contains("playerflix") ->
-                playerflixExtractor.videosFromUrl(url)
+                streamwishExtractor.videosFromUrl(url, videoNameGen = { "$langSubstr Streamwish - $it" })
             else -> emptyList()
         }
     }
diff --git a/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/extractors/FireplayerExtractor.kt b/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/extractors/FireplayerExtractor.kt
new file mode 100644
index 00000000..98cf0104
--- /dev/null
+++ b/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/extractors/FireplayerExtractor.kt
@@ -0,0 +1,56 @@
+package eu.kanade.tachiyomi.animeextension.pt.pobreflix.extractors
+
+import dev.datlag.jsunpacker.JsUnpacker
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.lib.playlistutils.PlaylistUtils
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.FormBody
+import okhttp3.Headers
+import okhttp3.OkHttpClient
+
+class FireplayerExtractor(private val client: OkHttpClient, private val host: String = "https://embedplayer.online") {
+    private val headers by lazy {
+        Headers.headersOf(
+            "X-Requested-With",
+            "XMLHttpRequest",
+            "Referer",
+            host,
+            "Origin",
+            host,
+        )
+    }
+
+    private val playlistUtils by lazy { PlaylistUtils(client, headers) }
+
+    fun videosFromUrl(url: String, lang: String): List<Video> {
+        var id = url.substringAfterLast("/")
+
+        if (id.length < 32) {
+            val doc = client.newCall(GET(url, headers)).execute().asJsoup()
+
+            val script = doc.selectFirst("script:containsData(eval):containsData(p,a,c,k,e,d)")?.data()
+                ?.let(JsUnpacker::unpackAndCombine)
+                ?: doc.selectFirst("script:containsData(FirePlayer)")?.data()
+
+            if (script?.contains("FirePlayer(") == true) {
+                id = script.substringAfter("FirePlayer(\"").substringBefore('"')
+            }
+        }
+
+        val postUrl = "$host/player/index.php?data=$id&do=getVideo"
+        val body = FormBody.Builder()
+            .add("hash", id)
+            .add("r", "")
+            .build()
+
+        val masterUrl = client.newCall(POST(postUrl, headers, body = body)).execute()
+            .body.string()
+            .substringAfter("securedLink\":\"")
+            .substringBefore('"')
+            .replace("\\", "")
+
+        return playlistUtils.extractFromHls(masterUrl, videoNameGen = { "[$lang] EmbedPlayer - $it" })
+    }
+}
diff --git a/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/extractors/PlayerFlixExtractor.kt b/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/extractors/PlayerFlixExtractor.kt
deleted file mode 100644
index 0dab9340..00000000
--- a/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/extractors/PlayerFlixExtractor.kt
+++ /dev/null
@@ -1,35 +0,0 @@
-package eu.kanade.tachiyomi.animeextension.pt.pobreflix.extractors
-
-import eu.kanade.tachiyomi.animesource.model.Video
-import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.util.asJsoup
-import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
-import okhttp3.Headers
-import okhttp3.OkHttpClient
-
-class PlayerFlixExtractor(
-    private val client: OkHttpClient,
-    private val defaultHeaders: Headers,
-    private val genericExtractor: (String, String) -> List<Video>,
-) {
-    fun videosFromUrl(url: String): List<Video> {
-        val doc = client.newCall(GET(url, defaultHeaders)).execute().asJsoup()
-
-        val items = doc.select("#hostList div.buttonLoadHost").mapNotNull {
-            val url = it.attr("onclick")
-                .substringAfter('"', "")
-                .substringBefore('"')
-                ?: return@mapNotNull null
-
-            val language = if (it.hasClass("hostDub")) {
-                "Dublado"
-            } else {
-                "Legendado"
-            }
-
-            language to url // (Language, videoId)
-        }
-
-        return items.parallelCatchingFlatMapBlocking { genericExtractor(it.second, it.first) }
-    }
-}
diff --git a/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/extractors/SuperFlixExtractor.kt b/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/extractors/SuperFlixExtractor.kt
index 92a2dcbe..70d588bb 100644
--- a/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/extractors/SuperFlixExtractor.kt
+++ b/src/pt/pobreflix/src/eu/kanade/tachiyomi/animeextension/pt/pobreflix/extractors/SuperFlixExtractor.kt
@@ -18,7 +18,7 @@ class SuperFlixExtractor(
     private val client: OkHttpClient,
     private val defaultHeaders: Headers,
     private val genericExtractor: (String, String) -> List<Video>,
-    private val host: String = "https://superflixapi.dev",
+    private val host: String = "https://superflixapi.top",
 ) {
     private val json: Json by injectLazy()
 
diff --git a/src/pt/vizer/build.gradle b/src/pt/vizer/build.gradle
index 48d8f03c..3dcd0271 100644
--- a/src/pt/vizer/build.gradle
+++ b/src/pt/vizer/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Vizer.tv'
     extClass = '.Vizer'
-    extVersionCode = 20
+    extVersionCode = 18
     isNsfw = true
 }
 
diff --git a/src/zh/xfani/build.gradle b/src/zh/xfani/build.gradle
new file mode 100644
index 00000000..03ea0350
--- /dev/null
+++ b/src/zh/xfani/build.gradle
@@ -0,0 +1,7 @@
+ext {
+    extName = 'Xfani'
+    extClass = '.Xfani'
+    extVersionCode = 1
+}
+
+apply from: "$rootDir/common.gradle"
diff --git a/src/zh/xfani/res/mipmap-hdpi/ic_launcher.png b/src/zh/xfani/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 00000000..73206bc4
Binary files /dev/null and b/src/zh/xfani/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/zh/xfani/res/mipmap-mdpi/ic_launcher.png b/src/zh/xfani/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 00000000..6175f3a9
Binary files /dev/null and b/src/zh/xfani/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/zh/xfani/res/mipmap-xhdpi/ic_launcher.png b/src/zh/xfani/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 00000000..c73e72b3
Binary files /dev/null and b/src/zh/xfani/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/zh/xfani/res/mipmap-xxhdpi/ic_launcher.png b/src/zh/xfani/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 00000000..606c02d5
Binary files /dev/null and b/src/zh/xfani/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/zh/xfani/res/mipmap-xxxhdpi/ic_launcher.png b/src/zh/xfani/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 00000000..ae7a4dda
Binary files /dev/null and b/src/zh/xfani/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Filters.kt b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Filters.kt
new file mode 100644
index 00000000..17c9656b
--- /dev/null
+++ b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Filters.kt
@@ -0,0 +1,64 @@
+package eu.kanade.tachiyomi.animeextension.zh.xfani
+
+import eu.kanade.tachiyomi.animesource.model.AnimeFilter
+
+abstract class SelectFilter(name: String, private val options: Array<Pair<String, String>>) :
+    AnimeFilter.Select<String>(name, options.map { it.first }.toTypedArray()) {
+    val selected
+        get() = options[state].second
+}
+
+abstract class TagFilter(name: String, values: Array<String>) :
+    SelectFilter(
+        name,
+        values.mapIndexed { index, s ->
+            if (index == 0) {
+                s to ""
+            } else {
+                s to s
+            }
+        }.toTypedArray(),
+    )
+
+class TypeFilter(
+    kv: Array<Pair<String, String>> = arrayOf(
+        "连载新番" to "1",
+        "完结旧番" to "2",
+        "剧场版" to "3",
+    ),
+) : SelectFilter("频道", kv)
+
+class ClassFilter(
+    tags: Array<String> = arrayOf(
+        "全部",
+        "搞笑",
+        "原创",
+        "轻小说改",
+        "恋爱",
+        "百合",
+        "漫改",
+    ),
+) : TagFilter("类型", tags)
+
+class VersionFilter(
+    tags: Array<String> = arrayOf(
+        "全部",
+        "BD",
+        "OVA",
+        "SP",
+        "OAD",
+    ),
+) : TagFilter("版本", tags)
+
+class LetterFilter(
+    tags: Array<String> = "ABCDEFGHIJKLMNOPQRSTUYWXYZ".map { it.toString() }.toMutableList()
+        .also { it.add("0-9") }.toTypedArray(),
+) : TagFilter("字母", tags)
+
+class SortFilter(
+    kv: Array<Pair<String, String>> = arrayOf(
+        "按最新" to "time",
+        "按热门" to "hits",
+        "按评分" to "score",
+    ),
+) : SelectFilter("排序", kv)
diff --git a/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Signature.kt b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Signature.kt
new file mode 100644
index 00000000..421af488
--- /dev/null
+++ b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Signature.kt
@@ -0,0 +1,15 @@
+package eu.kanade.tachiyomi.animeextension.zh.xfani
+
+import java.security.MessageDigest
+
+private const val UID = "DCC147D11943AF75"
+
+internal fun generateKey(time: Long): String {
+    return "DS${time}$UID".md5()
+}
+
+internal fun String.md5(): String {
+    val md = MessageDigest.getInstance("MD5")
+    val digest = md.digest(this.toByteArray())
+    return digest.joinToString(separator = "") { eachByte -> "%02x".format(eachByte) }
+}
diff --git a/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Xfani.kt b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Xfani.kt
new file mode 100644
index 00000000..be71aeb7
--- /dev/null
+++ b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/Xfani.kt
@@ -0,0 +1,212 @@
+package eu.kanade.tachiyomi.animeextension.zh.xfani
+
+import android.app.Application
+import android.content.SharedPreferences
+import androidx.preference.ListPreference
+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.AnimeHttpSource
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.util.asJsoup
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.jsonObject
+import kotlinx.serialization.json.jsonPrimitive
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.MultipartBody
+import okhttp3.Request
+import okhttp3.Response
+import uy.kohesive.injekt.Injekt
+import uy.kohesive.injekt.api.get
+import uy.kohesive.injekt.injectLazy
+
+class Xfani : AnimeHttpSource(), ConfigurableAnimeSource {
+    override val baseUrl: String
+        get() = "https://dick.xfani.com"
+    override val lang: String
+        get() = "zh"
+    override val name: String
+        get() = "稀饭动漫"
+    override val supportsLatest: Boolean
+        get() = true
+
+    private val json by injectLazy<Json>()
+    private val preferences: SharedPreferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+    private val numberRegex = Regex("\\d+")
+
+    private val selectedVideoSource
+        get() = preferences.getString(PREF_KEY_VIDEO_SOURCE, DEFAULT_VIDEO_SOURCE)!!.toInt()
+
+    override fun animeDetailsParse(response: Response): SAnime = SAnime.create()
+
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val jsoup = response.asJsoup()
+        val result = jsoup.select("ul.anthology-list-play.size")
+        val episodeList = if (result.size > selectedVideoSource) {
+            result[selectedVideoSource]
+        } else {
+            result[0]
+        }.select("li > a")
+        return episodeList.map {
+            SEpisode.create().apply {
+                name = it.text()
+                url = it.attr("href")
+                episode_number = numberRegex.find(name)?.value?.toFloat() ?: -1F
+            }
+        }
+    }
+
+    override fun videoListParse(response: Response): List<Video> {
+        val script = response.asJsoup().select("script:containsData(player_aaaa)").first()!!.data()
+        val info = script.substringAfter("player_aaaa=").let { json.parseToJsonElement(it) }
+        val url = info.jsonObject["url"]!!.jsonPrimitive.content
+        return listOf(Video(url, "SingleFile", videoUrl = url))
+    }
+
+    override fun latestUpdatesParse(response: Response): AnimesPage {
+        return vodListToAnimePageList(response)
+    }
+
+    override fun latestUpdatesRequest(page: Int): Request =
+        searchAnimeRequest(page, "", AnimeFilterList())
+
+    override fun popularAnimeParse(response: Response): AnimesPage {
+        return vodListToAnimePageList(response)
+    }
+
+    override fun popularAnimeRequest(page: Int): Request =
+        searchAnimeRequest(page, "", AnimeFilterList(SortFilter().apply { state = 1 }))
+
+    private fun vodListToAnimePageList(response: Response): AnimesPage {
+        val vodResponse = json.decodeFromString<VodResponse>(response.body.string())
+        val animeList = vodResponse.list.map {
+            SAnime.create().apply {
+                url = "/bangumi/${it.vodId}.html"
+                thumbnail_url = it.vodPicThumb.ifEmpty { it.vodPic }
+                title = it.vodName
+                author = it.vodActor
+                description = it.vodBlurb
+                genre = it.vodClass
+            }
+        }
+        return AnimesPage(
+            animeList,
+            animeList.isNotEmpty() && vodResponse.page * vodResponse.limit < vodResponse.total,
+        )
+    }
+
+    override fun searchAnimeParse(response: Response): AnimesPage {
+        val jsoup = response.asJsoup()
+        val items = jsoup.select("div.public-list-box.search-box.flex.rel")
+        val animeList = items.map { item ->
+            SAnime.create().apply {
+                title = item.select(".thumb-txt").text()
+                url = item.select("div.left.public-list-bj a.public-list-exp").attr("href")
+                thumbnail_url =
+                    item.select("div.left.public-list-bj img[data-src]").attr("data-src")
+                author = item.select("div.thumb-actor").text().removeSuffix("/")
+                artist = item.select("div.thumb-director").text().removeSuffix("/")
+                description = item.select(".thumb-blurb").text()
+                genre = item.select("div.thumb-else").text()
+                val statusString = item.select("div.left.public-list-bj .public-list-prb").text()
+                status = STATUS_STR_MAPPING.getOrElse(statusString) { SAnime.ONGOING }
+            }
+        }
+        val tip = jsoup.select("div.pages div.page-tip").text()
+        return AnimesPage(animeList, tip.isNotEmpty() && hasMorePage(tip))
+    }
+
+    private fun hasMorePage(tip: String): Boolean {
+        val pageIndicator = tip.substringAfter("当前").substringBefore("页")
+        val numbers = pageIndicator.split("/")
+        return numbers.size == 2 && numbers[0] != numbers[1]
+    }
+
+    override fun getFilterList(): AnimeFilterList {
+        return AnimeFilterList(
+            AnimeFilter.Header("设置筛选后关键字搜索会失效"),
+            TypeFilter(),
+            ClassFilter(),
+            VersionFilter(),
+            LetterFilter(),
+            SortFilter(),
+        )
+    }
+
+    private fun doSearch(page: Int, query: String): Request {
+        val url = baseUrl.toHttpUrl().newBuilder()
+        if (page <= 1) {
+            url.addPathSegment("search.html")
+                .addQueryParameter("wd", query)
+        } else {
+            url.addPathSegments("search/wd/")
+                .addPathSegment(query)
+                .addPathSegments("page/$page.html")
+        }
+        return GET(url.build())
+    }
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        if (query.isNotBlank()) {
+            return doSearch(page, query)
+        }
+        val url = baseUrl.toHttpUrl().newBuilder()
+            .addPathSegments("index.php/api/vod")
+            .build()
+        val time = System.currentTimeMillis() / 1000
+        val formBody = MultipartBody.Builder()
+            .setType(MultipartBody.FORM)
+            .addFormDataPart("page", "$page")
+            .addFormDataPart("time", "$time")
+            .addFormDataPart("key", generateKey(time))
+        filters.forEach { filter ->
+            when (filter) {
+                is TypeFilter -> formBody.addFormDataPart("type", filter.selected)
+                is ClassFilter -> formBody.addFormDataPart("class", filter.selected)
+                is VersionFilter -> formBody.addFormDataPart("version", filter.selected)
+                is LetterFilter -> formBody.addFormDataPart("letter", filter.selected)
+                is SortFilter -> formBody.addFormDataPart("by", filter.selected)
+                else -> {}
+            }
+        }
+        if (filters.filterIsInstance<TypeFilter>().isEmpty()) {
+            formBody.addFormDataPart("type", "1")
+        }
+        return POST(url.toString(), body = formBody.build())
+    }
+
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        screen.addPreference(
+            ListPreference(screen.context).apply {
+                key = PREF_KEY_VIDEO_SOURCE
+                title = "请设置首选视频源线路"
+                entries = arrayOf("主线-1", "主线-2", "备用-1")
+                entryValues = arrayOf("0", "1", "2")
+                setDefaultValue(DEFAULT_VIDEO_SOURCE)
+                summary = "当前选择：${entries[selectedVideoSource]}"
+                setOnPreferenceChangeListener { _, newValue ->
+                    summary = "当前选择 ${entries[(newValue as String).toInt()]}"
+                    true
+                }
+            },
+        )
+    }
+
+    companion object {
+        const val PREF_KEY_VIDEO_SOURCE = "PREF_KEY_VIDEO_SOURCE"
+
+        const val DEFAULT_VIDEO_SOURCE = "0"
+
+        val STATUS_STR_MAPPING = mapOf(
+            "已完结" to SAnime.COMPLETED,
+        )
+    }
+}
diff --git a/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/XfaniDTO.kt b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/XfaniDTO.kt
new file mode 100644
index 00000000..e5cdfd8f
--- /dev/null
+++ b/src/zh/xfani/src/eu/kanade/tachiyomi/animeextension/zh/xfani/XfaniDTO.kt
@@ -0,0 +1,42 @@
+package eu.kanade.tachiyomi.animeextension.zh.xfani
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class VodInfo(
+    @SerialName("vod_id")
+    val vodId: Int,
+    @SerialName("vod_level")
+    val vodLevel: Int = 0,
+    @SerialName("vod_name")
+    val vodName: String,
+    @SerialName("vod_pic")
+    val vodPic: String,
+    @SerialName("vod_pic_thumb")
+    val vodPicThumb: String = "",
+    @SerialName("vod_tag")
+    val vodTag: String = "",
+    @SerialName("vod_class")
+    val vodClass: String,
+    @SerialName("vod_remarks")
+    val vodRemarks: String,
+    @SerialName("vod_serial")
+    val vodSerial: String,
+    @SerialName("vod_sub")
+    val vodSub: String,
+    @SerialName("vod_actor")
+    val vodActor: String,
+    @SerialName("vod_blurb")
+    val vodBlurb: String,
+)
+
+@Serializable
+data class VodResponse(
+    val page: Int,
+    @SerialName("pagecount")
+    val pageCount: Int,
+    val limit: Int,
+    val total: Int,
+    val list: List<VodInfo>,
+)