diff --git a/lib/streamsb-extractor/build.gradle.kts b/lib/streamsb-extractor/build.gradle.kts
index a4b917a72..6ffaf2993 100644
--- a/lib/streamsb-extractor/build.gradle.kts
+++ b/lib/streamsb-extractor/build.gradle.kts
@@ -1,5 +1,6 @@
 plugins {
     id("com.android.library")
+    id("kotlinx-serialization") // for the DTO
     kotlin("android")
 }
 
diff --git a/lib/streamsb-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamsbextractor/StreamSBExtractor.kt b/lib/streamsb-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamsbextractor/StreamSBExtractor.kt
index 27d39a3ac..4c2a92043 100644
--- a/lib/streamsb-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamsbextractor/StreamSBExtractor.kt
+++ b/lib/streamsb-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamsbextractor/StreamSBExtractor.kt
@@ -5,8 +5,6 @@ import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.network.GET
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.jsonObject
 import okhttp3.Headers
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.OkHttpClient
@@ -50,14 +48,30 @@ class StreamSBExtractor(private val client: OkHttpClient) {
             .build()
         return try {
             val master = fixUrl(url, common)
-            val json = Json.decodeFromString<JsonObject>(
+            val json = Json { ignoreUnknownKeys = true }.decodeFromString<Response>(
                 client.newCall(GET(master, newHeaders))
                     .execute().body.string()
             )
-            val masterUrl = json["stream_data"]!!.jsonObject["file"].toString().trim('"')
+            val masterUrl = json.stream_data.file.trim('"')
+            val subtitleList = json.stream_data.subs?.let {
+                it.map { s -> Track(s.file, s.label) }
+            } ?: emptyList()
+
             val masterPlaylist = client.newCall(GET(masterUrl, newHeaders))
                 .execute()
                 .body.string()
+
+            val audioList = mutableListOf<Track>()
+            val audioRegex = Regex("""#EXT-X-MEDIA:TYPE=AUDIO.*?NAME="(.*?)".*?URI="(.*?)"""")
+            audioList.addAll(
+                audioRegex.findAll(masterPlaylist).map {
+                    Track(
+                        it.groupValues[2],
+                        it.groupValues[1]
+                    )
+                }
+            )
+
             val separator = "#EXT-X-STREAM-INF"
             masterPlaylist.substringAfter(separator).split(separator).map {
                 val resolution = it.substringAfter("RESOLUTION=")
@@ -72,7 +86,11 @@ class StreamSBExtractor(private val client: OkHttpClient) {
                     else it
                 }
                 val videoUrl = it.substringAfter("\n").substringBefore("\n")
-                Video(videoUrl, quality, videoUrl, headers = newHeaders)
+                if (audioList.isEmpty()) {
+                    Video(videoUrl, quality, videoUrl, headers = newHeaders, subtitleTracks = subtitleList)
+                } else {
+                    Video(videoUrl, quality, videoUrl, headers = newHeaders, subtitleTracks = subtitleList, audioTracks = audioList)
+                }
             }
         } catch (e: Exception) {
             emptyList<Video>()
@@ -81,9 +99,25 @@ class StreamSBExtractor(private val client: OkHttpClient) {
 
     fun videosFromDecryptedUrl(realUrl: String, headers: Headers, prefix: String = "", suffix: String = ""): List<Video> {
         return try {
-            val json = Json.decodeFromString<JsonObject>(client.newCall(GET(realUrl, headers)).execute().body.string())
-            val masterUrl = json["stream_data"]!!.jsonObject["file"].toString().trim('"')
+            val json = Json { ignoreUnknownKeys = true }.decodeFromString<Response>(client.newCall(GET(realUrl, headers)).execute().body.string())
+            val masterUrl = json.stream_data.file.trim('"')
+            val subtitleList = json.stream_data.subs?.let {
+                it.map { s -> Track(s.file, s.label) }
+            } ?: emptyList()
+
             val masterPlaylist = client.newCall(GET(masterUrl, headers)).execute().body.string()
+
+            val audioList = mutableListOf<Track>()
+            val audioRegex = Regex("""#EXT-X-MEDIA:TYPE=AUDIO.*?NAME="(.*?)".*?URI="(.*?)"""")
+            audioList.addAll(
+                audioRegex.findAll(masterPlaylist).map {
+                    Track(
+                        it.groupValues[2],
+                        it.groupValues[1]
+                    )
+                }
+            )
+
             val separator = "#EXT-X-STREAM-INF"
             masterPlaylist.substringAfter(separator).split(separator).map {
                 val resolution = it.substringAfter("RESOLUTION=")
@@ -98,7 +132,11 @@ class StreamSBExtractor(private val client: OkHttpClient) {
                     else it
                 }
                 val videoUrl = it.substringAfter("\n").substringBefore("\n")
-                Video(videoUrl, quality, videoUrl, headers = headers)
+                if (audioList.isEmpty()) {
+                    Video(videoUrl, quality, videoUrl, headers = headers, subtitleTracks = subtitleList)
+                } else {
+                    Video(videoUrl, quality, videoUrl, headers = headers, subtitleTracks = subtitleList, audioTracks = audioList)
+                }
             }
         } catch (e: Exception) {
             emptyList()
diff --git a/lib/streamsb-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamsbextractor/StreamSBExtractorDto.kt b/lib/streamsb-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamsbextractor/StreamSBExtractorDto.kt
new file mode 100644
index 000000000..a4c15291c
--- /dev/null
+++ b/lib/streamsb-extractor/src/main/java/eu/kanade/tachiyomi/lib/streamsbextractor/StreamSBExtractorDto.kt
@@ -0,0 +1,20 @@
+package eu.kanade.tachiyomi.lib.streamsbextractor
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class Response(
+    val stream_data: ResponseObject
+) {
+    @Serializable
+    data class ResponseObject(
+        val file: String,
+        val subs: List<Subtitle>? = null
+    )
+}
+
+@Serializable
+data class Subtitle(
+    val label: String,
+    val file: String
+)
diff --git a/src/en/multimovies/AndroidManifest.xml b/src/en/multimovies/AndroidManifest.xml
new file mode 100644
index 000000000..acb4de356
--- /dev/null
+++ b/src/en/multimovies/AndroidManifest.xml
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="eu.kanade.tachiyomi.animeextension" />
\ No newline at end of file
diff --git a/src/en/multimovies/build.gradle b/src/en/multimovies/build.gradle
new file mode 100644
index 000000000..993a6d2a1
--- /dev/null
+++ b/src/en/multimovies/build.gradle
@@ -0,0 +1,20 @@
+apply plugin: 'com.android.application'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlinx-serialization'
+
+ext {
+    extName = 'Multimovies'
+    pkgNameSuffix = 'en.multimovies'
+    extClass = '.Multimovies'
+    extVersionCode = 1
+    libVersion = '13'
+}
+
+dependencies {
+    implementation(project(':lib-streamsb-extractor'))
+    implementation(project(':lib-voe-extractor'))
+    implementation(project(':lib-dood-extractor'))
+    implementation "dev.datlag.jsunpacker:jsunpacker:1.0.1"
+}
+
+apply from: "$rootDir/common.gradle"
diff --git a/src/en/multimovies/res/mipmap-hdpi/ic_launcher.png b/src/en/multimovies/res/mipmap-hdpi/ic_launcher.png
new file mode 100644
index 000000000..1d118d112
Binary files /dev/null and b/src/en/multimovies/res/mipmap-hdpi/ic_launcher.png differ
diff --git a/src/en/multimovies/res/mipmap-mdpi/ic_launcher.png b/src/en/multimovies/res/mipmap-mdpi/ic_launcher.png
new file mode 100644
index 000000000..8b64905ab
Binary files /dev/null and b/src/en/multimovies/res/mipmap-mdpi/ic_launcher.png differ
diff --git a/src/en/multimovies/res/mipmap-xhdpi/ic_launcher.png b/src/en/multimovies/res/mipmap-xhdpi/ic_launcher.png
new file mode 100644
index 000000000..a4abae26b
Binary files /dev/null and b/src/en/multimovies/res/mipmap-xhdpi/ic_launcher.png differ
diff --git a/src/en/multimovies/res/mipmap-xxhdpi/ic_launcher.png b/src/en/multimovies/res/mipmap-xxhdpi/ic_launcher.png
new file mode 100644
index 000000000..fd112788e
Binary files /dev/null and b/src/en/multimovies/res/mipmap-xxhdpi/ic_launcher.png differ
diff --git a/src/en/multimovies/res/mipmap-xxxhdpi/ic_launcher.png b/src/en/multimovies/res/mipmap-xxxhdpi/ic_launcher.png
new file mode 100644
index 000000000..23cbc002b
Binary files /dev/null and b/src/en/multimovies/res/mipmap-xxxhdpi/ic_launcher.png differ
diff --git a/src/en/multimovies/res/web_hi_res_512.png b/src/en/multimovies/res/web_hi_res_512.png
new file mode 100644
index 000000000..6518f7ebb
Binary files /dev/null and b/src/en/multimovies/res/web_hi_res_512.png differ
diff --git a/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/Multimovies.kt b/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/Multimovies.kt
new file mode 100644
index 000000000..436ed37c1
--- /dev/null
+++ b/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/Multimovies.kt
@@ -0,0 +1,429 @@
+package eu.kanade.tachiyomi.animeextension.en.multimovies
+
+import android.app.Application
+import android.content.SharedPreferences
+import androidx.preference.ListPreference
+import androidx.preference.PreferenceScreen
+import eu.kanade.tachiyomi.animeextension.en.multimovies.extractors.AutoEmbedExtractor
+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.lib.streamsbextractor.StreamSBExtractor
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.util.asJsoup
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.json.Json
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.RequestBody.Companion.toRequestBody
+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
+import java.lang.Exception
+
+class Multimovies : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
+
+    override val name = "Multimovies"
+
+    override val baseUrl = "https://multimovies.fun"
+
+    override val lang = "en"
+
+    override val supportsLatest = false
+
+    override val client: OkHttpClient = network.cloudflareClient
+
+    private val json: Json by injectLazy()
+
+    private val preferences: SharedPreferences by lazy {
+        Injekt.get<Application>().getSharedPreferences("source_$id", 0x0000)
+    }
+
+    // ============================== Popular ===============================
+
+    override fun popularAnimeSelector(): String = "div.content > div.items > article.item"
+
+    override fun popularAnimeRequest(page: Int): Request {
+        return GET("$baseUrl/genre/anime-series/page/$page/")
+    }
+
+    override fun popularAnimeFromElement(element: Element): SAnime {
+        val anime = SAnime.create()
+
+        anime.setUrlWithoutDomain(element.selectFirst("div h3 a")!!.attr("href").toHttpUrl().encodedPath)
+        anime.title = element.selectFirst("div h3 a")!!.text()
+        anime.thumbnail_url = element.selectFirst("div.poster img")!!.attr("src")
+        if (!anime.thumbnail_url.toString().startsWith("https://")) {
+            anime.thumbnail_url = element.select("div.poster img").attr("data-src")
+        }
+
+        return anime
+    }
+
+    override fun popularAnimeNextPageSelector(): String = "div.pagination span.current ~ a"
+
+    // =============================== Latest ===============================
+
+    override fun latestUpdatesNextPageSelector(): String = throw Exception("Not used")
+
+    override fun latestUpdatesFromElement(element: Element): SAnime = throw Exception("Not used")
+
+    override fun latestUpdatesRequest(page: Int): Request = throw Exception("Not used")
+
+    override fun latestUpdatesSelector(): String = throw Exception("Not used")
+
+    // =============================== Search ===============================
+
+    override fun searchAnimeParse(response: Response): AnimesPage {
+        val document = response.asJsoup()
+
+        val animes = if (response.request.url.encodedPath.startsWith("/genre/")) {
+            document.select(searchGenreAnimeSelector()).map { element ->
+                searchGenreAnimeFromElement(element)
+            }
+        } else {
+            document.select(searchAnimeSelector()).map { element ->
+                searchAnimeFromElement(element)
+            }
+        }
+
+        val hasNextPage = searchAnimeNextPageSelector()?.let { selector ->
+            document.select(selector).first()
+        } != null
+
+        return AnimesPage(animes, hasNextPage)
+    }
+
+    override fun searchAnimeSelector(): String = "div.search-page > div.result-item"
+
+    override fun searchAnimeFromElement(element: Element): SAnime {
+        val anime = SAnime.create()
+
+        anime.setUrlWithoutDomain(element.select("div.details > div.title a").attr("href").toHttpUrl().encodedPath)
+        anime.title = element.select("div.details > div.title a").text()
+        anime.thumbnail_url = element.select("div.image img").attr("src")
+        if (!anime.thumbnail_url.toString().startsWith("https://")) {
+            anime.thumbnail_url = element.select("div.poster img").attr("data-src")
+        }
+
+        return anime
+    }
+
+    private fun searchGenreAnimeSelector(): String = "div.items > article.item"
+
+    private fun searchGenreAnimeFromElement(element: Element): SAnime {
+        val anime = SAnime.create()
+
+        anime.setUrlWithoutDomain(element.select("div.data h3 a").attr("href").toHttpUrl().encodedPath)
+        anime.title = element.select("div.data h3 a").text()
+        anime.thumbnail_url = element.select("div.poster img").attr("src")
+        if (!anime.thumbnail_url.toString().startsWith("https://")) {
+            anime.thumbnail_url = element.select("div.poster img").attr("data-src")
+        }
+
+        return anime
+    }
+
+    override fun searchAnimeNextPageSelector(): String = "div.pagination span.current ~ a"
+
+    override fun searchAnimeRequest(page: Int, query: String, filters: AnimeFilterList): Request {
+        return if (query.isNotBlank()) {
+            GET("$baseUrl/page/$page/?s=$query", headers)
+        } else {
+            val filterList = if (filters.isEmpty()) getFilterList() else filters
+            val genreFilter = filterList.find { it is GenreFilter } as GenreFilter
+            val streamingFilter = filterList.find { it is StreamingFilter } as StreamingFilter
+            val ficUniFilter = filterList.find { it is FicUniFilter } as FicUniFilter
+            val channelFilter = filterList.find { it is ChannelFilter } as ChannelFilter
+
+            when {
+                genreFilter.state != 0 -> GET("$baseUrl/genre/${genreFilter.toUriPart()}/page/$page", headers)
+                streamingFilter.state != 0 -> GET("$baseUrl/genre/${streamingFilter.toUriPart()}/page/$page", headers)
+                ficUniFilter.state != 0 -> GET("$baseUrl/genre/${ficUniFilter.toUriPart()}/page/$page", headers)
+                channelFilter.state != 0 -> GET("$baseUrl/genre/${channelFilter.toUriPart()}/page/$page", headers)
+                else -> popularAnimeRequest(page)
+            }
+        }
+    }
+
+    // ============================== Filters ===============================
+
+    override fun getFilterList() = AnimeFilterList(
+        AnimeFilter.Header("NOTE: Ignored if using text search!"),
+        AnimeFilter.Separator(),
+        GenreFilter(getGenreList()),
+        StreamingFilter(getStreamingList()),
+        FicUniFilter(getFictionalUniverseList()),
+        ChannelFilter(getChannelList()),
+    )
+
+    private class GenreFilter(vals: Array<Pair<String, String>>) : UriPartFilter("Genres", vals)
+    private class StreamingFilter(vals: Array<Pair<String, String>>) : UriPartFilter("Streaming service", vals)
+    private class FicUniFilter(vals: Array<Pair<String, String>>) : UriPartFilter("Fictional universe", vals)
+    private class ChannelFilter(vals: Array<Pair<String, String>>) : UriPartFilter("Channel", vals)
+
+    private fun getGenreList() = arrayOf(
+        Pair("<select>", ""),
+        Pair("Action", "action"),
+        Pair("Adventure", "adventure"),
+        Pair("Animation", "animation"),
+        Pair("Anime Movies", "anime-movies"),
+        Pair("Anime Series", "anime-series"),
+        Pair("Crime", "crime"),
+        Pair("Comedy", "comedy"),
+        Pair("Drama", "drama"),
+        Pair("Fantasy", "fantasy"),
+        Pair("Horror", "horror"),
+        Pair("Family", "family"),
+        Pair("History", "history"),
+        Pair("Romance", "romance"),
+        Pair("Science Fiction", "science-fiction"),
+        Pair("Thriller", "thriller"),
+    )
+
+    private fun getStreamingList() = arrayOf(
+        Pair("<select>", ""),
+        Pair("Amazon Prime", "amazone-prime"),
+        Pair("Apple TV +", "apple-tv"),
+        Pair("Disney+Hotstar", "disneyhotstar"),
+        Pair("HBO MAX", "hbo-max"),
+        Pair("Hulu", "hulu"),
+        Pair("Netflix", "netflix"),
+        Pair("Sony Liv", "sony-liv"),
+        Pair("Voot", "voot"),
+    )
+
+    private fun getFictionalUniverseList() = arrayOf(
+        Pair("<select>", ""),
+        Pair("DC Universe", "dc-universe"),
+        Pair("Fast and Furious", "fast-and-furious"),
+        Pair("Harry Potter", "harry"),
+        Pair("Jurassic Park", "jurassic-park"),
+        Pair("Marvel Cinematic", "marvel"),
+        Pair("Matrix", "matrix"),
+        Pair("Mission Impossible", "mission-impossible"),
+        Pair("Pirates of the Caribbean", "pirates"),
+        Pair("Resident Evil", "resident-evil"),
+        Pair("Star Wars", "star-wars"),
+        Pair("Terminator", "terminator"),
+        Pair("Transformers", "transformer"),
+        Pair("Wrong Turn", "wrong-turn"),
+        Pair("X-Men", "xmen"),
+    )
+
+    private fun getChannelList() = arrayOf(
+        Pair("<select>", ""),
+        Pair("Cartoon Network", "cartoon-network"),
+        Pair("Disney Channel", "disney"),
+        Pair("Disney XD", "disney-xd"),
+        Pair("Hungama", "hungama"),
+        Pair("Nick", "nick"),
+        Pair("Pogo", "pogo"),
+    )
+
+    open class UriPartFilter(displayName: String, private val vals: Array<Pair<String, String>>) :
+        AnimeFilter.Select<String>(displayName, vals.map { it.first }.toTypedArray()) {
+        fun toUriPart() = vals[state].second
+    }
+
+    // =========================== Anime Details ============================
+
+    override fun animeDetailsParse(document: Document): SAnime {
+        val anime = SAnime.create()
+        anime.title = document.select("div.sheader > div.data > h1").text()
+        anime.genre = document.select("div.sgeneros a").eachText().joinToString(separator = ", ")
+        anime.description = document.selectFirst("div#info p")!!.text()
+        return anime
+    }
+
+    // ============================== Episodes ==============================
+
+    override fun episodeListSelector() = throw Exception("Not used")
+
+    override fun episodeListParse(response: Response): List<SEpisode> {
+        val document = response.asJsoup()
+        val episodeList = mutableListOf<SEpisode>()
+
+        if (response.request.url.encodedPath.startsWith("/movies/")) {
+            val episode = SEpisode.create()
+
+            episode.name = document.select("div.data > h1").text()
+            episode.episode_number = 1F
+            episode.setUrlWithoutDomain(response.request.url.encodedPath)
+            episodeList.add(episode)
+        } else {
+            var counter = 1
+            for (season in document.select("div#seasons > div")) {
+                val seasonList = mutableListOf<SEpisode>()
+                for (ep in season.select("ul > li")) {
+                    if (ep.childrenSize() > 0) {
+                        val episode = SEpisode.create()
+
+                        episode.name = "Season ${ep.selectFirst("div.numerando")!!.ownText().substringAfter("E")} - ${ep.selectFirst("a[href]")!!.ownText()}"
+                        episode.episode_number = counter.toFloat()
+                        episode.setUrlWithoutDomain(ep.selectFirst("a[href]")!!.attr("href").toHttpUrl().encodedPath)
+
+                        if (ep.selectFirst("p:contains(Filler)") != null) episode.scanlator = "Filler Episode"
+
+                        seasonList.add(episode)
+
+                        counter++
+                    }
+                }
+                episodeList.addAll(seasonList)
+            }
+        }
+
+        return episodeList.reversed()
+    }
+
+    override fun episodeFromElement(element: Element): SEpisode = throw Exception("Not used")
+
+    // ============================ Video Links =============================
+
+    override fun videoListParse(response: Response): List<Video> {
+        val document = response.asJsoup()
+        val videoList = mutableListOf<Video>()
+        val reqUrL = response.request.url
+
+        document.select("ul.ajax_mode > li").forEach {
+            if (it.attr("data-nume") == "trailer") return@forEach
+
+            val postHeaders = headers.newBuilder()
+                .add("Accept", "*/*")
+                .add("Conent-Type", "application/x-www-form-urlencoded; charset=UTF-8")
+                .add("Host", reqUrL.host)
+                .add("Origin", "https://${reqUrL.host}")
+                .add("Referer", reqUrL.toString())
+                .add("X-Requested-With", "XMLHttpRequest")
+                .build()
+
+            val postData = "action=doo_player_ajax&post=${it.attr("data-post")}&nume=${it.attr("data-nume")}&type=${it.attr("data-type")}".toRequestBody("application/x-www-form-urlencoded".toMediaType())
+            val embedded = client.newCall(
+                POST("$baseUrl/wp-admin/admin-ajax.php", body = postData, headers = postHeaders),
+            ).execute().body.string()
+
+            val parsed = json.decodeFromString<Embed>(embedded)
+            val url = if (parsed.embed_url.contains("<iframe", true)) {
+                Jsoup.parse(parsed.embed_url).selectFirst("iframe")!!.attr("src")
+            } else {
+                parsed.embed_url
+            }
+
+            when {
+                url.contains("sbembed.com") || url.contains("sbembed1.com") || url.contains("sbplay.org") ||
+                    url.contains("sbvideo.net") || url.contains("streamsb.net") || url.contains("sbplay.one") ||
+                    url.contains("cloudemb.com") || url.contains("playersb.com") || url.contains("tubesb.com") ||
+                    url.contains("sbplay1.com") || url.contains("embedsb.com") || url.contains("watchsb.com") ||
+                    url.contains("sbplay2.com") || url.contains("japopav.tv") || url.contains("viewsb.com") ||
+                    url.contains("sbfast") || url.contains("sbfull.com") || url.contains("javplaya.com") ||
+                    url.contains("ssbstream.net") || url.contains("p1ayerjavseen.com") || url.contains("sbthe.com") ||
+                    url.contains("sbchill.com") || url.contains("sblongvu.com") || url.contains("sbanh.com") ||
+                    url.contains("sblanh.com") || url.contains("sbhight.com") || url.contains("sbbrisk.com") ||
+                    url.contains("sbspeed.com") || url.contains("multimovies.website") -> {
+                    videoList.addAll(
+                        StreamSBExtractor(client).videosFromUrl(url, headers = headers, prefix = "[multimovies]"),
+                    )
+                }
+                url.contains("autoembed.to") || url.contains("2embed.to") -> {
+                    val newHeaders = headers.newBuilder()
+                        .add("Referer", url).build()
+                    videoList.addAll(
+                        AutoEmbedExtractor(client).videosFromUrl(url, headers = newHeaders),
+                    )
+                }
+            }
+        }
+
+        return videoList.sort()
+    }
+
+    override fun videoListSelector() = throw Exception("Not used")
+
+    override fun videoFromElement(element: Element) = throw Exception("Not used")
+
+    override fun videoUrlParse(document: Document) = throw Exception("Not used")
+
+    // ============================= Utilities ==============================
+
+    @Serializable
+    data class Embed(
+        val embed_url: String,
+    )
+
+    override fun List<Video>.sort(): List<Video> {
+        val quality = preferences.getString("preferred_quality", "1080")!!
+        val server = preferences.getString("preferred_server", "multimovies")!!
+        val qualityRegex = """(\d+)p""".toRegex()
+
+        return this.sortedWith(
+            compareBy(
+                { it.quality.contains(server, true) },
+                { it.quality.contains(quality) },
+                { qualityRegex.find(it.quality)?.groupValues?.get(1)?.toIntOrNull() ?: 0 },
+            ),
+        ).reversed()
+    }
+
+    override fun setupPreferenceScreen(screen: PreferenceScreen) {
+        val videoQualityPref = ListPreference(screen.context).apply {
+            key = "preferred_quality"
+            title = "Preferred quality"
+            entries = arrayOf("1080p", "720p", "480p", "360p", "240p")
+            entryValues = arrayOf("1080", "720", "480", "360", "240")
+            setDefaultValue("1080")
+            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()
+            }
+        }
+        val serverPref = ListPreference(screen.context).apply {
+            key = "preferred_server"
+            title = "Preferred Server"
+            entries = arrayOf(
+                "multimovies",
+                "2Embed Vidcloud",
+                "2Embed Voe",
+                "2Embed Streamlare",
+                "2Embed MixDrop",
+                "Gomo Dood",
+            )
+            entryValues = arrayOf(
+                "multimovies",
+                "[2embed] server vidcloud",
+                "[2embed] server voe",
+                "[2embed] server streamlare",
+                "[2embed] server mixdrop",
+                "[gomostream] dood",
+            )
+            setDefaultValue("multimovies")
+            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()
+            }
+        }
+        screen.addPreference(serverPref)
+        screen.addPreference(videoQualityPref)
+    }
+}
diff --git a/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/AutoEmbedExtractor.kt b/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/AutoEmbedExtractor.kt
new file mode 100644
index 000000000..4194f2f6f
--- /dev/null
+++ b/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/AutoEmbedExtractor.kt
@@ -0,0 +1,927 @@
+/*
+Credit goes to @justfoolingaround and @Blatzar from https://github.com/recloudstream/cloudstream
+Code taken, and modified from https://github.com/recloudstream/cloudstream/blob/master/app/src/main/java/com/lagradost/cloudstream3/MainAPI.kt
+
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>. */
+
+package eu.kanade.tachiyomi.animeextension.en.multimovies.extractors
+
+import android.util.Base64
+import app.cash.quickjs.QuickJs
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.lib.doodextractor.DoodExtractor
+import eu.kanade.tachiyomi.lib.streamsbextractor.StreamSBExtractor
+import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.POST
+import eu.kanade.tachiyomi.util.asJsoup
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.runBlocking
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.json.Json
+import okhttp3.FormBody
+import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.RequestBody.Companion.toRequestBody
+import uy.kohesive.injekt.injectLazy
+
+class AutoEmbedExtractor(private val client: OkHttpClient) {
+
+    private val json: Json by injectLazy()
+
+    fun videosFromUrl(url: String, headers: Headers): List<Video> {
+        val videoList = mutableListOf<Video>()
+        val serverList = mutableListOf<Server>()
+        val containerList = mutableListOf<Server>()
+
+        val docHeaders = headers.newBuilder()
+            .add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8")
+            .add("Host", url.toHttpUrl().host)
+            .build()
+        val document = client.newCall(
+            GET(url, headers = docHeaders),
+        ).execute().asJsoup()
+
+        // First get all containers
+        document.select("div > a[id*=server]").forEach {
+            val slug = it.attr("href")
+            val newDocument = client.newCall(
+                GET("https://${url.toHttpUrl().host}$slug", headers = headers),
+            ).execute().asJsoup()
+
+            val container = newDocument.selectFirst("iframe[src]")!!.attr("src")
+                .substringAfter("replace(\"").substringBefore("\"")
+
+            when {
+                container.contains("2embed.to", true) -> {
+                    containerList.add(Server(container, "2embed"))
+                }
+                container.contains("gomostream", true) -> {
+                    containerList.add(Server(container, "gomostream"))
+                }
+            }
+        }
+
+        // Get video servers from containers
+        serverList.addAll(
+            containerList.parallelMap { container ->
+                runCatching {
+                    when (container.name) {
+                        "2embed" -> {
+                            getTwoEmbedServers(container.url, container.name, headers = headers)
+                        }
+                        "gomostream" -> {
+                            getGomoStreamServers(container.url, container.name, headers = headers)
+                        }
+                        else -> null
+                    }
+                }.getOrNull()
+            }.filterNotNull().flatten(),
+        )
+
+        val videoHeaders = headers.newBuilder()
+            .add("Referer", "https://www.2embed.to/")
+            .build()
+
+        videoList.addAll(
+            serverList.parallelMap { server ->
+                runCatching {
+                    val prefix = server.name
+                    val url = server.url
+
+                    when {
+                        url.contains("streamsb") -> {
+                            StreamSBExtractor(client).videosFromUrl(url, headers = headers, prefix = prefix)
+                        }
+                        url.contains("streamlare") -> {
+                            StreamlareExtractor(client).videosFromUrl(url, prefix = prefix)
+                        }
+                        url.contains("mixdrop") -> {
+                            MixDropExtractor(client).videoFromUrl(url, prefix = prefix)
+                        }
+                        url.contains("https://voe") -> {
+                            VoeExtractor(client).videoFromUrl(url, server.name)?.let { listOf(it) }
+                        }
+                        url.contains("rabbitstream") -> {
+                            RabbitStreamExtractor(client).videosFromUrl(url, headers = videoHeaders, prefix = prefix)
+                        }
+                        url.contains("mixdrop") -> {
+                            MixDropExtractor(client).videoFromUrl(url, prefix = prefix)
+                        }
+                        url.contains("https://dood") -> {
+                            val video = DoodExtractor(client).videoFromUrl(url, server.name, false)
+                            video?.let { listOf(it) }
+                        }
+                        else -> null
+                    }
+                }.getOrNull()
+            }.filterNotNull().flatten(),
+        )
+
+        return videoList
+    }
+
+    data class Server(
+        val url: String,
+        val name: String,
+    )
+
+    @Serializable
+    data class Stream(
+        val link: String,
+    )
+
+    private fun getGomoStreamServers(url: String, name: String, headers: Headers): List<Server> {
+        val serverList = mutableListOf<Server>()
+
+        val response = client.newCall(
+            GET(url, headers = headers),
+        ).execute()
+        val responseUrl = response.request.url
+        val document = response.asJsoup()
+        val script = document.selectFirst("script:containsData(_token)")?.data() ?: return serverList
+        val token = script.substringAfter("\"_token\": \"").substringBefore("\"")
+        val tokenCode = script.substringAfter("var tc = '").substringBefore("';")
+        val postUrl = script.substringAfter("\"POST\"").substringAfter("\"").substringBefore("\"")
+
+        // Function to get x-token
+        val functionName = script.substringAfter("'x-token': ").substringBefore("(")
+        val toExecute = "function $functionName${script.substringAfter("function $functionName")};$functionName(\"$tokenCode\")"
+
+        val quickJs = QuickJs.create()
+        val xToken = quickJs.evaluate(toExecute).toString()
+        quickJs.close()
+
+        val postHeaders = Headers.headersOf(
+            "Accept", "*/*",
+            "Content-Type", "application/x-www-form-urlencoded; charset=UTF-8",
+            "Host", responseUrl.host,
+            "Origin", "https://${responseUrl.host}",
+            "Referer", responseUrl.toString(),
+            "User-Agent", headers["User-Agent"] ?: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:108.0) Gecko/20100101 Firefox/108.0",
+            "X-Requested-With", "XMLHttpRequest",
+            "x-token", xToken,
+        )
+
+        val postBody = "tokenCode=$tokenCode&_token=$token".toRequestBody("application/x-www-form-urlencoded".toMediaType())
+        val postResponse = client.newCall(
+            POST(postUrl, headers = postHeaders, body = postBody),
+        ).execute().body.string()
+        val list = json.decodeFromString<List<String>>(postResponse)
+
+        serverList.addAll(
+            list.filter { x -> x != "" }.map {
+                Server(it, "[gomostream] ${it.toHttpUrl().host} -")
+            },
+        )
+
+        return serverList
+    }
+
+    private fun getTwoEmbedServers(url: String, name: String, headers: Headers): List<Server> {
+        val serverList = mutableListOf<Server>()
+        val document = client.newCall(
+            GET(url),
+        ).execute().asJsoup()
+
+        val captcha = document.selectFirst("script[src*=recaptcha/api.js]")!!
+            .attr("src")
+            .substringAfter("render=")
+
+        // Get video host urls
+        document.select("div.dropdown-menu > a[data-id]").map {
+            val ajaxHeaders = Headers.headersOf(
+                "Accept", "*/*",
+                "Host", url.toHttpUrl().host,
+                "Referer", url,
+                "User-Agent", headers["User-Agent"]!!,
+                "X-Requested-With", "XMLHttpRequest",
+            )
+            val token = getCaptchaToken(url, captcha)
+
+            val streamUrl = client.newCall(
+                GET("https://www.2embed.to/ajax/embed/play?id=${it.attr("data-id")}&_token=$token", headers = ajaxHeaders),
+            ).execute().body.string()
+            val parsed = json.decodeFromString<Stream>(streamUrl)
+            serverList.add(
+                Server(parsed.link, "[2embed] ${it.text()} - "),
+            )
+        }
+
+        return serverList
+    }
+
+    // https://github.com/recloudstream/cloudstream/blob/7b47f93190fb2b106da44150c4431178eb3995dc/app/src/main/java/com/lagradost/cloudstream3/MainAPI.kt#L123
+    private fun getCaptchaToken(url: String, key: String): String? {
+        try {
+            val domain = Base64.encodeToString(
+                (url.toHttpUrl().scheme + "://" + url.toHttpUrl().host + ":443").encodeToByteArray(),
+                0,
+            ).replace("\n", "").replace("=", ".")
+            val vToken = client.newCall(
+                GET("https://www.google.com/recaptcha/api.js?render=$key"),
+            ).execute().body.string().substringAfter("releases/").substringBefore("/")
+            val recapToken = client.newCall(
+                GET("https://www.google.com/recaptcha/api2/anchor?ar=1&hl=en&size=invisible&cb=cs3&k=$key&co=$domain&v=$vToken"),
+            ).execute().asJsoup().selectFirst("#recaptcha-token")?.attr("value")
+            if (recapToken != null) {
+                val body = FormBody.Builder()
+                    .add("v", vToken)
+                    .add("k", key)
+                    .add("c", recapToken)
+                    .add("co", domain)
+                    .add("sa", "")
+                    .add("reason", "q")
+                    .build()
+                return client.newCall(
+                    POST("https://www.google.com/recaptcha/api2/reload?k=$key", body = body),
+                ).execute().body.string().substringAfter("rresp\",\"").substringBefore("\"")
+            }
+        } catch (_: Exception) { }
+        return null
+    }
+
+    // From Dopebox
+    private fun <A, B> Iterable<A>.parallelMap(f: suspend (A) -> B): List<B> =
+        runBlocking {
+            map { async(Dispatchers.Default) { f(it) } }.awaitAll()
+        }
+}
diff --git a/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/MixDropExtractor.kt b/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/MixDropExtractor.kt
new file mode 100644
index 000000000..f7cecf686
--- /dev/null
+++ b/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/MixDropExtractor.kt
@@ -0,0 +1,29 @@
+package eu.kanade.tachiyomi.animeextension.en.multimovies.extractors
+
+import dev.datlag.jsunpacker.JsUnpacker
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.util.asJsoup
+import okhttp3.Headers
+import okhttp3.OkHttpClient
+
+class MixDropExtractor(private val client: OkHttpClient) {
+    fun videoFromUrl(url: String, lang: String = "", prefix: String = ""): List<Video> {
+        val doc = client.newCall(GET(url)).execute().asJsoup()
+        val unpacked = doc.selectFirst("script:containsData(eval):containsData(MDCore)")
+            ?.data()
+            ?.let { JsUnpacker.unpackAndCombine(it) }
+            ?: return emptyList<Video>()
+        val videoUrl = "https:" + unpacked.substringAfter("Core.wurl=\"")
+            .substringBefore("\"")
+        val quality = ("MixDrop").let {
+            if (lang.isNotBlank()) {
+                "$it($lang)"
+            } else {
+                it
+            }
+        }
+        val referer = Headers.headersOf("Referer", "https://mixdrop.co/")
+        return listOf(Video(url, prefix + quality, videoUrl, headers = referer))
+    }
+}
diff --git a/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/RabbitStreamExtractor.kt b/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/RabbitStreamExtractor.kt
new file mode 100644
index 000000000..6f6ddfa4f
--- /dev/null
+++ b/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/RabbitStreamExtractor.kt
@@ -0,0 +1,166 @@
+package eu.kanade.tachiyomi.animeextension.en.multimovies.extractors
+
+import android.util.Base64
+import eu.kanade.tachiyomi.animesource.model.Track
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.json.Json
+import okhttp3.Headers
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import okhttp3.OkHttpClient
+import uy.kohesive.injekt.injectLazy
+import java.security.DigestException
+import java.security.MessageDigest
+import javax.crypto.Cipher
+import javax.crypto.spec.IvParameterSpec
+import javax.crypto.spec.SecretKeySpec
+
+class RabbitStreamExtractor(private val client: OkHttpClient) {
+
+    // Prevent (automatic) caching the .JS file for different episodes, because it
+    // changes everytime, and a cached old .js will have a invalid AES password,
+    // invalidating the decryption algorithm.
+    // We cache it manually when initializing the class.
+    private val newClient = client.newBuilder()
+        .cache(null)
+        .build()
+
+    private val json: Json by injectLazy()
+
+    fun videosFromUrl(url: String, headers: Headers, prefix: String): List<Video> {
+        val videoList = mutableListOf<Video>()
+        val id = url.toHttpUrl().pathSegments.last()
+        val embed = url.toHttpUrl().pathSegments.first()
+
+        val newHeaders = headers.newBuilder()
+            .add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8")
+            .add("Host", url.toHttpUrl().host)
+            .build()
+
+        val jsonBody = client.newCall(
+            GET("https://rabbitstream.net/ajax/$embed/getSources?id=$id", headers = newHeaders),
+        ).execute().body.string()
+        val parsed = json.decodeFromString<Source>(jsonBody)
+
+        val key = newClient.newCall(
+            GET("https://raw.githubusercontent.com/enimax-anime/key/e4/key.txt"),
+        ).execute().body.string()
+
+        val decrypted = decrypt(parsed.sources, key) ?: return videoList
+        val subtitleList = parsed.tracks.map {
+            Track(it.file, it.label)
+        }
+
+        val files = json.decodeFromString<List<File>>(decrypted)
+        files.forEach {
+            val videoHeaders = Headers.headersOf(
+                "Accept",
+                "*/*",
+                "Origin",
+                "https://${url.toHttpUrl().host}",
+                "Referer",
+                "https://${url.toHttpUrl().host}/",
+                "User-Agent",
+                headers["User-Agent"] ?: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:101.0) Gecko/20100101 Firefox/101.0",
+            )
+
+            val masterPlaylist = client.newCall(
+                GET(it.file, headers = videoHeaders),
+            ).execute().body.string()
+
+            masterPlaylist.substringAfter("#EXT-X-STREAM-INF:").split("#EXT-X-STREAM-INF:")
+                .forEach { res ->
+                    val quality = prefix + res.substringAfter("RESOLUTION=").substringAfter("x").substringBefore("\n") + "p "
+                    val videoUrl = res.substringAfter("\n").substringBefore("\n")
+                    videoList.add(
+                        Video(videoUrl, quality, videoUrl, headers = videoHeaders, subtitleTracks = subtitleList),
+                    )
+                }
+        }
+
+        return videoList
+    }
+
+    @Serializable
+    data class Source(
+        val sources: String,
+        val tracks: List<Sub>,
+    ) {
+        @Serializable
+        data class Sub(
+            val file: String,
+            val label: String,
+        )
+    }
+
+    @Serializable
+    data class File(
+        val file: String,
+    )
+
+    // Stolen from zoro extension
+    private fun decrypt(encodedData: String, remoteKey: String): String? {
+        val saltedData = Base64.decode(encodedData, Base64.DEFAULT)
+        val salt = saltedData.copyOfRange(8, 16)
+        val ciphertext = saltedData.copyOfRange(16, saltedData.size)
+        val password = remoteKey.toByteArray()
+        val (key, iv) = GenerateKeyAndIv(password, salt) ?: return null
+        val keySpec = SecretKeySpec(key, "AES")
+        val ivSpec = IvParameterSpec(iv)
+        val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
+        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec)
+        val decryptedData = String(cipher.doFinal(ciphertext))
+        return decryptedData
+    }
+
+    // https://stackoverflow.com/a/41434590/8166854
+    private fun GenerateKeyAndIv(
+        password: ByteArray,
+        salt: ByteArray,
+        hashAlgorithm: String = "MD5",
+        keyLength: Int = 32,
+        ivLength: Int = 16,
+        iterations: Int = 1,
+    ): List<ByteArray>? {
+        val md = MessageDigest.getInstance(hashAlgorithm)
+        val digestLength = md.getDigestLength()
+        val targetKeySize = keyLength + ivLength
+        val requiredLength = (targetKeySize + digestLength - 1) / digestLength * digestLength
+        var generatedData = ByteArray(requiredLength)
+        var generatedLength = 0
+
+        try {
+            md.reset()
+
+            while (generatedLength < targetKeySize) {
+                if (generatedLength > 0) {
+                    md.update(
+                        generatedData,
+                        generatedLength - digestLength,
+                        digestLength,
+                    )
+                }
+
+                md.update(password)
+                md.update(salt, 0, 8)
+                md.digest(generatedData, generatedLength, digestLength)
+
+                for (i in 1 until iterations) {
+                    md.update(generatedData, generatedLength, digestLength)
+                    md.digest(generatedData, generatedLength, digestLength)
+                }
+
+                generatedLength += digestLength
+            }
+            val result = listOf(
+                generatedData.copyOfRange(0, keyLength),
+                generatedData.copyOfRange(keyLength, targetKeySize),
+            )
+            return result
+        } catch (e: DigestException) {
+            return null
+        }
+    }
+}
diff --git a/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/StreamlareExtractor.kt b/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/StreamlareExtractor.kt
new file mode 100644
index 000000000..415983f7e
--- /dev/null
+++ b/src/en/multimovies/src/eu/kanade/tachiyomi/animeextension/en/multimovies/extractors/StreamlareExtractor.kt
@@ -0,0 +1,46 @@
+package eu.kanade.tachiyomi.animeextension.en.multimovies.extractors
+
+import eu.kanade.tachiyomi.animesource.model.Video
+import eu.kanade.tachiyomi.network.GET
+import eu.kanade.tachiyomi.network.POST
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.OkHttpClient
+import okhttp3.RequestBody.Companion.toRequestBody
+
+class StreamlareExtractor(private val client: OkHttpClient) {
+    fun videosFromUrl(url: String, prefix: String): List<Video> {
+        val id = url.split("/").last()
+        val videoList = mutableListOf<Video>()
+        val playlist = client.newCall(
+            POST(
+                "https://slwatch.co/api/video/stream/get",
+                body = "{\"id\":\"$id\"}"
+                    .toRequestBody("application/json".toMediaType()),
+            ),
+        ).execute().body.string()
+
+        val type = playlist.substringAfter("\"type\":\"").substringBefore("\"")
+        if (type == "hls") {
+            val masterPlaylistUrl = playlist.substringAfter("\"file\":\"").substringBefore("\"").replace("\\/", "/")
+            val masterPlaylist = client.newCall(GET(masterPlaylistUrl)).execute().body.string()
+
+            val separator = "#EXT-X-STREAM-INF"
+            masterPlaylist.substringAfter(separator).split(separator).map {
+                val quality = it.substringAfter("RESOLUTION=").substringAfter("x").substringBefore(",") + "p"
+                var videoUrl = it.substringAfter("\n").substringBefore("\n")
+                if (!videoUrl.startsWith("http")) videoUrl = "${masterPlaylistUrl.substringBefore("master.m3u8")}$videoUrl"
+                videoList.add(Video(videoUrl, "$prefix $quality (Streamlare)", videoUrl))
+            }
+        } else {
+            playlist.substringAfter("\"label\":\"").split("\"label\":\"").forEach {
+                val quality = it.substringAfter("\"label\":\"").substringBefore("\",") + " (Sl-mp4)"
+                val token = it.substringAfter("\"file\":\"https:\\/\\/larecontent.com\\/video?token=")
+                    .substringBefore("\",")
+                val response = client.newCall(POST("https://larecontent.com/video?token=$token")).execute()
+                val videoUrl = response.request.url.toString()
+                videoList.add(Video(videoUrl, "$prefix $quality (Streamlare)", videoUrl))
+            }
+        }
+        return videoList
+    }
+}