diff --git a/src/es/animeflv/build.gradle b/src/es/animeflv/build.gradle
index 87603ed75f..d6927a1303 100644
--- a/src/es/animeflv/build.gradle
+++ b/src/es/animeflv/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'AnimeFLV'
     extClass = '.AnimeFlv'
-    extVersionCode = 54
+    extVersionCode = 55
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/animeflv/src/eu/kanade/tachiyomi/animeextension/es/animeflv/AnimeFlv.kt b/src/es/animeflv/src/eu/kanade/tachiyomi/animeextension/es/animeflv/AnimeFlv.kt
index 35461a16cd..be897e0a66 100644
--- a/src/es/animeflv/src/eu/kanade/tachiyomi/animeextension/es/animeflv/AnimeFlv.kt
+++ b/src/es/animeflv/src/eu/kanade/tachiyomi/animeextension/es/animeflv/AnimeFlv.kt
@@ -17,11 +17,10 @@ import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
 import eu.kanade.tachiyomi.lib.youruploadextractor.YourUploadExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.jsonArray
-import kotlinx.serialization.json.jsonObject
-import kotlinx.serialization.json.jsonPrimitive
 import okhttp3.Request
 import okhttp3.Response
 import org.jsoup.nodes.Document
@@ -49,7 +48,7 @@ class AnimeFlv : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     companion object {
         private const val PREF_QUALITY_KEY = "preferred_quality"
-        private const val PREF_QUALITY_DEFAULT = "480"
+        private const val PREF_QUALITY_DEFAULT = "720"
         private val QUALITY_LIST = arrayOf("1080", "720", "480", "360")
 
         private const val PREF_SERVER_KEY = "preferred_server"
@@ -105,39 +104,25 @@ class AnimeFlv : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override fun episodeFromElement(element: Element) = throw UnsupportedOperationException()
 
+    /*--------------------------------Video extractors------------------------------------*/
+    private val streamTapeExtractor by lazy { StreamTapeExtractor(client) }
+    private val okruExtractor by lazy { OkruExtractor(client) }
+    private val yourUploadExtractor by lazy { YourUploadExtractor(client) }
+    private val streamWishExtractor by lazy { StreamWishExtractor(client, headers.newBuilder().add("Referer", "$baseUrl/").build()) }
+
     override fun videoListParse(response: Response): List<Video> {
         val document = response.asJsoup()
-        val videoList = mutableListOf<Video>()
-        document.select("script").forEach { script ->
-            if (script.data().contains("var videos = {")) {
-                val responseString = script.data().substringAfter("var videos =").substringBefore(";").trim()
-                val jObject = json.decodeFromString<JsonObject>(responseString)
-                jObject["SUB"]!!.jsonArray!!.forEach { servers ->
-                    val json = servers!!.jsonObject
-                    val quality = json!!["title"]!!.jsonPrimitive!!.content
-                    val url = json!!["code"]!!.jsonPrimitive!!.content
-                    val extractedVideos = runCatching {
-                        when (quality) {
-                            "Stape" -> {
-                                val stapeUrl = json!!["url"]!!.jsonPrimitive!!.content
-                                StreamTapeExtractor(client).videoFromUrl(stapeUrl)?.let(::listOf)
-                            }
-                            "Okru" -> OkruExtractor(client).videosFromUrl(url)
-                            "YourUpload" -> YourUploadExtractor(client).videoFromUrl(url, headers = headers)
-                            "SW" -> {
-                                val docHeaders = headers.newBuilder()
-                                    .add("Referer", "$baseUrl/")
-                                    .build()
-                                StreamWishExtractor(client, docHeaders).videosFromUrl(url, videoNameGen = { "StreamWish: $it" })
-                            }
-                            else -> null
-                        }
-                    }.getOrNull() ?: emptyList<Video>()
-                    videoList.addAll(extractedVideos)
-                }
+        val jsonString = document.selectFirst("script:containsData(var videos = {)")?.data() ?: return emptyList()
+        val responseString = jsonString.substringAfter("var videos =").substringBefore(";").trim()
+        return json.decodeFromString<ServerModel>(responseString).sub.parallelCatchingFlatMapBlocking {
+            when (it.title) {
+                "Stape" -> listOf(streamTapeExtractor.videoFromUrl(it.url ?: it.code)!!)
+                "Okru" -> okruExtractor.videosFromUrl(it.url ?: it.code)
+                "YourUpload" -> yourUploadExtractor.videoFromUrl(it.url ?: it.code, headers = headers)
+                "SW" -> streamWishExtractor.videosFromUrl(it.url ?: it.code, videoNameGen = { "StreamWish:$it" })
+                else -> emptyList()
             }
         }
-        return videoList
     }
 
     override fun videoListSelector() = throw UnsupportedOperationException()
@@ -335,4 +320,21 @@ class AnimeFlv : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
             }
         }.also(screen::addPreference)
     }
+
+    @Serializable
+    data class ServerModel(
+        @SerialName("SUB")
+        val sub: List<Sub> = emptyList(),
+    )
+
+    @Serializable
+    data class Sub(
+        val server: String? = "",
+        val title: String? = "",
+        val ads: Long? = null,
+        val url: String? = null,
+        val code: String = "",
+        @SerialName("allow_mobile")
+        val allowMobile: Boolean? = false,
+    )
 }
diff --git a/src/es/gnula/build.gradle b/src/es/gnula/build.gradle
index 2ea60cfbe9..6ff148892e 100644
--- a/src/es/gnula/build.gradle
+++ b/src/es/gnula/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Gnula'
     extClass = '.Gnula'
-    extVersionCode = 14
+    extVersionCode = 15
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/gnula/src/eu/kanade/tachiyomi/animeextension/es/gnula/DataModel.kt b/src/es/gnula/src/eu/kanade/tachiyomi/animeextension/es/gnula/DataModel.kt
new file mode 100644
index 0000000000..efa169014c
--- /dev/null
+++ b/src/es/gnula/src/eu/kanade/tachiyomi/animeextension/es/gnula/DataModel.kt
@@ -0,0 +1,235 @@
+package eu.kanade.tachiyomi.animeextension.es.gnula
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+// ---------------------Popular Model-------------------------
+@Serializable
+data class PopularModel(
+    val props: Props = Props(),
+    val page: String? = null,
+    val query: Query? = null,
+)
+
+@Serializable
+data class Props(
+    val pageProps: PageProps = PageProps(),
+    @SerialName("__N_SSG")
+    val nSsg: Boolean = false,
+)
+
+@Serializable
+data class PageProps(
+    val currentPage: String? = null,
+    val results: Results = Results(),
+)
+
+@Serializable
+data class Results(
+    @SerialName("__typename")
+    val typename: String? = null,
+    val pages: Long? = null,
+    val data: List<Daum> = emptyList(),
+)
+
+@Serializable
+data class Daum(
+    val titles: Titles = Titles(),
+    @SerialName("TMDbId")
+    val tmdbId: String? = null,
+    val images: Images = Images(),
+    val releaseDate: String? = null,
+    val slug: Slug = Slug(),
+    val url: Url = Url(),
+)
+
+@Serializable
+data class Titles(
+    val name: String? = null,
+)
+
+@Serializable
+data class Images(
+    val poster: String? = null,
+)
+
+@Serializable
+data class Slug(
+    val name: String? = null,
+)
+
+@Serializable
+data class Url(
+    val slug: String? = null,
+)
+
+@Serializable
+data class Query(
+    val slug: List<String> = emptyList(),
+)
+
+// ---------------------Season Model-------------------------
+
+@Serializable
+data class SeasonModel(
+    val props: SeasonProps = SeasonProps(),
+    val page: String,
+    val query: SeasonQuery = SeasonQuery(),
+)
+
+@Serializable
+data class SeasonProps(
+    val pageProps: SeasonPageProps = SeasonPageProps(),
+    @SerialName("__N_SSG")
+    val nSsg: Boolean = false,
+)
+
+@Serializable
+data class SeasonPageProps(
+    val post: SeasonPost = SeasonPost(),
+)
+
+@Serializable
+data class SeasonPost(
+    @SerialName("TMDbId")
+    val tmdbId: String? = null,
+    val titles: SeasonTitles = SeasonTitles(),
+    val images: SeasonImages = SeasonImages(),
+    val overview: String? = null,
+    val genres: List<SeasonGenre> = emptyList(),
+    val cast: SeasonCast = SeasonCast(),
+    val slug: SeasonSlug = SeasonSlug(),
+    val players: Players = Players(),
+    val releaseDate: String? = null,
+    val seasons: List<Season> = emptyList(),
+)
+
+@Serializable
+data class Players(
+    val latino: List<Region> = emptyList(),
+    val spanish: List<Region> = emptyList(),
+    val english: List<Region> = emptyList(),
+)
+
+@Serializable
+data class Region(
+    val cyberlocker: String = "",
+    val result: String = "",
+    val quality: String = "",
+)
+
+@Serializable
+data class SeasonTitles(
+    val name: String? = null,
+    val original: Original? = null,
+)
+
+@Serializable
+data class Original(
+    val name: String? = null,
+)
+
+@Serializable
+data class SeasonImages(
+    val poster: String? = null,
+    val backdrop: String? = null,
+)
+
+@Serializable
+data class SeasonGenre(
+    val name: String? = null,
+)
+
+@Serializable
+data class SeasonCast(
+    val acting: List<Acting> = emptyList(),
+    val directing: List<Directing> = emptyList(),
+    val production: List<Production> = emptyList(),
+)
+
+@Serializable
+data class Acting(
+    val name: String? = null,
+)
+
+@Serializable
+data class Directing(
+    val name: String? = null,
+)
+
+@Serializable
+data class Production(
+    val name: String? = null,
+)
+
+@Serializable
+data class SeasonSlug(
+    val name: String? = null,
+)
+
+@Serializable
+data class Season(
+    val number: Long? = null,
+    val episodes: List<SeasonEpisode> = emptyList(),
+)
+
+@Serializable
+data class SeasonEpisode(
+    val title: String? = null,
+    @SerialName("TMDbId")
+    val tmdbId: String? = null,
+    val number: Long? = null,
+    val releaseDate: String? = null,
+    val image: String? = null,
+    val slug: Slug2 = Slug2(),
+)
+
+@Serializable
+data class Slug2(
+    val name: String? = null,
+    val season: String? = null,
+    val episode: String? = null,
+)
+
+@Serializable
+data class SeasonQuery(
+    val slug: String? = null,
+)
+
+// -----------------------Episode Model----------------------
+
+@Serializable
+data class EpisodeModel(
+    val props: EpisodeProps = EpisodeProps(),
+    val page: String,
+)
+
+@Serializable
+data class EpisodeProps(
+    val pageProps: EpisodePageProps = EpisodePageProps(),
+    @SerialName("__N_SSG")
+    val nSsg: Boolean = false,
+)
+
+@Serializable
+data class EpisodePageProps(
+    val episode: Episode = Episode(),
+)
+
+@Serializable
+data class Episode(
+    @SerialName("TMDbId")
+    val tmdbId: String? = null,
+    val title: String? = null,
+    val number: Long? = null,
+    val image: String? = null,
+    val slug: EpisodeSlug = EpisodeSlug(),
+    val players: Players = Players(),
+)
+
+@Serializable
+data class EpisodeSlug(
+    val name: String? = null,
+    val season: String? = null,
+    val episode: String? = null,
+)
diff --git a/src/es/gnula/src/eu/kanade/tachiyomi/animeextension/es/gnula/Gnula.kt b/src/es/gnula/src/eu/kanade/tachiyomi/animeextension/es/gnula/Gnula.kt
index 89f2205d74..4242040409 100644
--- a/src/es/gnula/src/eu/kanade/tachiyomi/animeextension/es/gnula/Gnula.kt
+++ b/src/es/gnula/src/eu/kanade/tachiyomi/animeextension/es/gnula/Gnula.kt
@@ -1,6 +1,5 @@
 package eu.kanade.tachiyomi.animeextension.es.gnula
 
-import android.annotation.SuppressLint
 import android.app.Application
 import android.content.SharedPreferences
 import androidx.preference.ListPreference
@@ -29,11 +28,8 @@ import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
 import eu.kanade.tachiyomi.lib.youruploadextractor.YourUploadExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
 import kotlinx.serialization.json.Json
-import kotlinx.serialization.json.JsonObject
-import kotlinx.serialization.json.jsonArray
-import kotlinx.serialization.json.jsonObject
-import kotlinx.serialization.json.jsonPrimitive
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.Request
 import okhttp3.Response
@@ -52,7 +48,7 @@ class Gnula : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     override val lang = "es"
 
-    override val supportsLatest = false
+    override val supportsLatest = true
 
     private val json: Json by injectLazy()
 
@@ -77,236 +73,126 @@ class Gnula : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         private const val PREF_LANGUAGE_KEY = "preferred_language"
         private const val PREF_LANGUAGE_DEFAULT = "[LAT]"
         private val LANGUAGE_LIST = arrayOf("[LAT]", "[CAST]", "[SUB]")
-        private val LANGUAGE_LIST_VALUES = arrayOf("latino", "spanish", "english")
+
+        private val DATE_FORMATTER by lazy {
+            SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
+        }
     }
-    override fun popularAnimeRequest(page: Int): Request = GET("$baseUrl/archives/movies/releases/page/$page")
+
+    override fun popularAnimeRequest(page: Int): Request = GET("$baseUrl/archives/movies/page/$page")
 
     override fun popularAnimeParse(response: Response): AnimesPage {
         val document = response.asJsoup()
-        val animeList = mutableListOf<SAnime>()
+        val jsonString = document.selectFirst("script:containsData({\"props\":{\"pageProps\":)")?.data()
+            ?: return AnimesPage(emptyList(), false)
+        val jsonData = jsonString.parseTo<PopularModel>().props.pageProps
         val hasNextPage = document.selectFirst("ul.pagination > li.page-item.active ~ li > a > span.visually-hidden")?.text()?.contains("Next") ?: false
-        document.select("script").forEach { script ->
-            if (script.data().contains("{\"props\":{\"pageProps\":")) {
-                val jObject = json.decodeFromString<JsonObject>(script.data())
-                val props = jObject["props"]!!.jsonObject
-                val pageProps = props["pageProps"]!!.jsonObject
-                val results = pageProps["results"]!!.jsonObject
-                val data = results["data"]!!.jsonArray
-                data.forEach { item ->
-                    val animeItem = item!!.jsonObject
-                    val anime = SAnime.create()
-                    val slug = animeItem["slug"]!!.jsonObject["name"]!!.jsonPrimitive!!.content
-                    val type = animeItem["url"]?.jsonObject?.get("slug")?.jsonPrimitive?.content ?: response.request.url.toString()
-
-                    anime.title = animeItem["titles"]!!.jsonObject["name"]!!.jsonPrimitive!!.content
-                    anime.thumbnail_url = animeItem["images"]!!.jsonObject["poster"]!!.jsonPrimitive!!.content
-                    anime.setUrlWithoutDomain(if (type.contains("movies") || type.contains("genres")) "$baseUrl/movies/$slug" else "$baseUrl/series/$slug")
-                    animeList.add(anime)
+        var type = jsonData.results.typename ?: ""
+
+        val animeList = jsonData.results.data.map {
+            if (!it.url.slug.isNullOrEmpty()) {
+                type = when {
+                    "series" in it.url.slug -> "PaginatedSerie"
+                    "movies" in it.url.slug -> "PaginatedMovie"
+                    else -> ""
                 }
             }
+
+            SAnime.create().apply {
+                title = it.titles.name ?: ""
+                thumbnail_url = it.images.poster?.replace("/original/", "/w200/")
+                setUrlWithoutDomain(urlSolverByType(type, it.slug.name ?: ""))
+            }
         }
         return AnimesPage(animeList, hasNextPage)
     }
 
-    @SuppressLint("SimpleDateFormat")
+    override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/archives/movies/releases/page/$page")
+
+    override fun latestUpdatesParse(response: Response) = popularAnimeParse(response)
+
     override fun episodeListParse(response: Response): List<SEpisode> {
         val document = response.asJsoup()
-        val episodeList = mutableListOf<SEpisode>()
-        if (response.request.url.toString().contains("/movies/")) {
-            val episode = SEpisode.create()
-            episode.episode_number = 1F
-            episode.name = "Película"
-            episode.setUrlWithoutDomain(response.request.url.toString())
-            episodeList.add(episode)
+        return if (response.request.url.toString().contains("/movies/")) {
+            listOf(
+                SEpisode.create().apply {
+                    name = "Película"
+                    episode_number = 1F
+                    setUrlWithoutDomain(response.request.url.toString())
+                },
+            )
         } else {
-            document.select("script").forEach { script ->
-                if (script.data().contains("{\"props\":{\"pageProps\"")) {
-                    val jObject = json.decodeFromString<JsonObject>(script.data())
-                    val props = jObject["props"]!!.jsonObject
-                    val pageProps = props["pageProps"]!!.jsonObject
-                    val post = pageProps["post"]!!.jsonObject
-                    val slug = post["slug"]!!.jsonObject["name"]!!.jsonPrimitive!!.content
-                    val seasons = post["seasons"]!!.jsonArray
-                    var realNoEpisode = 0F
-                    seasons!!.forEach { it ->
-                        val season = it!!.jsonObject
-                        val seasonNumber = season["number"]!!.jsonPrimitive!!.content
-                        season["episodes"]!!.jsonArray!!.map {
-                            realNoEpisode += 1
-                            val noEp = it.jsonObject["number"]!!.jsonPrimitive!!.content
-                            val episode = SEpisode.create()
-                            episode.name = "T$seasonNumber - E$noEp - Capítulo $noEp"
-                            episode.episode_number = realNoEpisode
-                            episode.setUrlWithoutDomain("$baseUrl/series/$slug/seasons/$seasonNumber/episodes/$noEp")
-                            val date = it!!.jsonObject["releaseDate"]!!.jsonPrimitive!!.content!!.substringBefore("T")
-                            val epDate = try { SimpleDateFormat("yyyy-MM-dd").parse(date) } catch (e: Exception) { null }
-                            if (epDate != null) episode.date_upload = epDate.time
-                            episodeList.add(episode)
+            val jsonString = document.selectFirst("script:containsData({\"props\":{\"pageProps\":)")?.data() ?: return emptyList()
+            val jsonData = jsonString.parseTo<SeasonModel>().props.pageProps
+            var episodeCounter = 1F
+            jsonData.post.seasons
+                .flatMap { season ->
+                    season.episodes.map { ep ->
+                        val episode = SEpisode.create().apply {
+                            episode_number = episodeCounter++
+                            name = "T${season.number} - E${ep.number} - ${ep.title}"
+                            date_upload = ep.releaseDate?.toDate() ?: 0L
+                            setUrlWithoutDomain("$baseUrl/series/${ep.slug.name}/seasons/${ep.slug.season}/episodes/${ep.slug.episode}")
                         }
+                        episode
                     }
                 }
-            }
-        }
-        return episodeList
+        }.reversed()
     }
 
     override fun videoListParse(response: Response): List<Video> {
         val document = response.asJsoup()
         val videoList = mutableListOf<Video>()
+        val jsonString = document.selectFirst("script:containsData({\"props\":{\"pageProps\":)")?.data() ?: return emptyList()
 
         if (response.request.url.toString().contains("/movies/")) {
-            document.select("script").forEach { script ->
-                if (script.data().contains("{\"props\":{\"pageProps\"")) {
-                    val jObject = json.decodeFromString<JsonObject>(script.data())
-                    val props = jObject["props"]!!.jsonObject
-                    val pageProps = props["pageProps"]!!.jsonObject
-                    val post = pageProps["post"]!!.jsonObject
-                    post["players"]!!.jsonObject.entries.map {
-                        val key = it.key
-                        val langVal = try {
-                            LANGUAGE_LIST[LANGUAGE_LIST.indexOf(LANGUAGE_LIST_VALUES.firstOrNull { it == key })]
-                        } catch (_: Exception) { "" }
-                        it.value!!.jsonArray!!.map {
-                            val server = it!!.jsonObject["result"]!!.jsonPrimitive!!.content
-                            var url = ""
-                            client.newCall(GET(server)).execute()!!.asJsoup()!!.select("script")!!.map { sc ->
-                                if (sc.data().contains("var url = '")) {
-                                    url = sc.data().substringAfter("var url = '").substringBefore("';")
-                                }
-                            }
-                            serverVideoResolver(url, langVal).let { videos -> videoList.addAll(videos) }
-                        }
-                    }
-                }
-            }
+            val pageProps = jsonString.parseTo<SeasonModel>().props.pageProps
+            pageProps.post.players.latino.toVideoList("[LAT]").also(videoList::addAll)
+            pageProps.post.players.spanish.toVideoList("[CAST]").also(videoList::addAll)
+            pageProps.post.players.english.toVideoList("[SUB]").also(videoList::addAll)
         } else {
-            document.select("script").forEach { script ->
-                if (script.data().contains("{\"props\":{\"pageProps\"")) {
-                    val jObject = json.decodeFromString<JsonObject>(script.data())
-                    val props = jObject["props"]!!.jsonObject
-                    val pageProps = props["pageProps"]!!.jsonObject
-                    val episode = pageProps["episode"]!!.jsonObject
-                    val players = episode["players"]!!.jsonObject.entries
-                    players.map {
-                        val key = it.key
-                        val langVal = try {
-                            LANGUAGE_LIST[LANGUAGE_LIST.indexOf(LANGUAGE_LIST_VALUES.firstOrNull { it == key })]
-                        } catch (_: Exception) { "" }
-
-                        it.value!!.jsonArray!!.map {
-                            val server = it!!.jsonObject["result"]!!.jsonPrimitive!!.content
-                            var url = ""
-                            client.newCall(GET(server)).execute()!!.asJsoup()!!.select("script")!!.map { sc ->
-                                if (sc.data().contains("var url = '")) {
-                                    url = sc.data().substringAfter("var url = '").substringBefore("';")
-                                }
-                            }
-                            serverVideoResolver(url, langVal).let { videos -> videoList.addAll(videos) }
-                        }
-                    }
-                }
-            }
+            val pageProps = jsonString.parseTo<EpisodeModel>().props.pageProps
+            pageProps.episode.players.latino.toVideoList("[LAT]").also(videoList::addAll)
+            pageProps.episode.players.spanish.toVideoList("[CAST]").also(videoList::addAll)
+            pageProps.episode.players.english.toVideoList("[SUB]").also(videoList::addAll)
         }
         return videoList
     }
 
     private fun serverVideoResolver(url: String, prefix: String = ""): List<Video> {
-        val videoList = mutableListOf<Video>()
         val embedUrl = url.lowercase()
-        try {
-            if (embedUrl.contains("voe")) {
-                VoeExtractor(client).videosFromUrl(url, prefix).also(videoList::addAll)
-            }
-            if ((embedUrl.contains("amazon") || embedUrl.contains("amz")) && !embedUrl.contains("disable")) {
-                val body = client.newCall(GET(url)).execute().asJsoup()
-                if (body.select("script:containsData(var shareId)").toString().isNotBlank()) {
-                    val shareId = body.selectFirst("script:containsData(var shareId)")!!.data()
-                        .substringAfter("shareId = \"").substringBefore("\"")
-                    val amazonApiJson = client.newCall(GET("https://www.amazon.com/drive/v1/shares/$shareId?resourceVersion=V2&ContentType=JSON&asset=ALL"))
-                        .execute().asJsoup()
-                    val epId = amazonApiJson.toString().substringAfter("\"id\":\"").substringBefore("\"")
-                    val amazonApi =
-                        client.newCall(GET("https://www.amazon.com/drive/v1/nodes/$epId/children?resourceVersion=V2&ContentType=JSON&limit=200&sort=%5B%22kind+DESC%22%2C+%22modifiedDate+DESC%22%5D&asset=ALL&tempLink=true&shareId=$shareId"))
-                            .execute().asJsoup()
-                    val videoUrl = amazonApi.toString().substringAfter("\"FOLDER\":").substringAfter("tempLink\":\"").substringBefore("\"")
-                    videoList.add(Video(videoUrl, "$prefix Amazon", videoUrl))
-                }
-            }
-            if (embedUrl.contains("ok.ru") || embedUrl.contains("okru")) {
-                OkruExtractor(client).videosFromUrl(url, prefix).also(videoList::addAll)
-            }
-            if (embedUrl.contains("filemoon") || embedUrl.contains("moonplayer")) {
+        return when {
+            embedUrl.contains("voe") -> VoeExtractor(client).videosFromUrl(url, prefix)
+            embedUrl.contains("ok.ru") || embedUrl.contains("okru") -> OkruExtractor(client).videosFromUrl(url, prefix)
+            embedUrl.contains("filemoon") || embedUrl.contains("moonplayer") -> {
                 val vidHeaders = headers.newBuilder()
                     .add("Origin", "https://${url.toHttpUrl().host}")
                     .add("Referer", "https://${url.toHttpUrl().host}/")
                     .build()
-                FilemoonExtractor(client).videosFromUrl(url, prefix = "$prefix Filemoon:", headers = vidHeaders).also(videoList::addAll)
+                FilemoonExtractor(client).videosFromUrl(url, prefix = "$prefix Filemoon:", headers = vidHeaders)
             }
-            if (embedUrl.contains("uqload")) {
-                UqloadExtractor(client).videosFromUrl(url, prefix = prefix).also(videoList::addAll)
-            }
-            if (embedUrl.contains("mp4upload")) {
-                Mp4uploadExtractor(client).videosFromUrl(url, headers, prefix = prefix).let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("wishembed") || embedUrl.contains("streamwish") || embedUrl.contains("strwish") || embedUrl.contains("wish")) {
+            embedUrl.contains("uqload") -> UqloadExtractor(client).videosFromUrl(url, prefix = prefix)
+            embedUrl.contains("mp4upload") -> Mp4uploadExtractor(client).videosFromUrl(url, headers, prefix = prefix)
+            embedUrl.contains("wishembed") || embedUrl.contains("streamwish") || embedUrl.contains("strwish") || embedUrl.contains("wish") -> {
                 val docHeaders = headers.newBuilder()
                     .add("Origin", "https://streamwish.to")
                     .add("Referer", "https://streamwish.to/")
                     .build()
-                StreamWishExtractor(client, docHeaders).videosFromUrl(url, videoNameGen = { "$prefix StreamWish:$it" }).also(videoList::addAll)
+                StreamWishExtractor(client, docHeaders).videosFromUrl(url, videoNameGen = { "$prefix StreamWish:$it" })
             }
-            if (embedUrl.contains("doodstream") || embedUrl.contains("dood.")) {
+            embedUrl.contains("doodstream") || embedUrl.contains("dood.") || embedUrl.contains("ds2play") || embedUrl.contains("doods.") -> {
                 val url2 = url.replace("https://doodstream.com/e/", "https://dood.to/e/")
-                DoodExtractor(client).videoFromUrl(url2, "$prefix DoodStream", false)?.let { videoList.add(it) }
-            }
-            if (embedUrl.contains("streamlare")) {
-                StreamlareExtractor(client).videosFromUrl(url, prefix = prefix).let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("yourupload") || embedUrl.contains("upload")) {
-                YourUploadExtractor(client).videoFromUrl(url, headers = headers, prefix = prefix).let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("burstcloud") || embedUrl.contains("burst")) {
-                BurstCloudExtractor(client).videoFromUrl(url, headers = headers, prefix = prefix).let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("fastream")) {
-                FastreamExtractor(client, headers).videosFromUrl(url, prefix = "$prefix Fastream:").also(videoList::addAll)
+                listOf(DoodExtractor(client).videoFromUrl(url2, "$prefix DoodStream", false)!!)
             }
-            if (embedUrl.contains("upstream")) {
-                UpstreamExtractor(client).videosFromUrl(url, prefix = prefix).let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("streamtape") || embedUrl.contains("stp") || embedUrl.contains("stape")) {
-                StreamTapeExtractor(client).videoFromUrl(url, quality = "$prefix StreamTape")?.let { videoList.add(it) }
-            }
-            if (embedUrl.contains("ahvsh") || embedUrl.contains("streamhide")) {
-                StreamHideVidExtractor(client).videosFromUrl(url, "$prefix ").let { videoList.addAll(it) }
-            }
-            if (embedUrl.contains("tomatomatela")) {
-                runCatching {
-                    val mainUrl = url.substringBefore("/embed.html#").substringAfter("https://")
-                    val headers = headers.newBuilder()
-                        .set("authority", mainUrl)
-                        .set("accept", "application/json, text/javascript, */*; q=0.01")
-                        .set("accept-language", "es-MX,es-419;q=0.9,es;q=0.8,en;q=0.7")
-                        .set("sec-ch-ua", "\"Chromium\";v=\"106\", \"Google Chrome\";v=\"106\", \"Not;A=Brand\";v=\"99\"")
-                        .set("sec-ch-ua-mobile", "?0")
-                        .set("sec-ch-ua-platform", "Windows")
-                        .set("sec-fetch-dest", "empty")
-                        .set("sec-fetch-mode", "cors")
-                        .set("sec-fetch-site", "same-origin")
-                        .set("x-requested-with", "XMLHttpRequest")
-                        .build()
-                    val token = url.substringAfter("/embed.html#")
-                    val urlRequest = "https://$mainUrl/details.php?v=$token"
-                    val response = client.newCall(GET(urlRequest, headers = headers)).execute().asJsoup()
-                    val bodyText = response.select("body").text()
-                    val json = json.decodeFromString<JsonObject>(bodyText)
-                    val status = json["status"]!!.jsonPrimitive!!.content
-                    val file = json["file"]!!.jsonPrimitive!!.content
-                    if (status == "200") { videoList.add(Video(file, "$prefix Tomatomatela", file, headers = null)) }
-                }
-            }
-        } catch (_: Exception) { }
-        return videoList
+            embedUrl.contains("streamlare") -> StreamlareExtractor(client).videosFromUrl(url, prefix = prefix)
+            embedUrl.contains("yourupload") || embedUrl.contains("upload") -> YourUploadExtractor(client).videoFromUrl(url, headers = headers, prefix = prefix)
+            embedUrl.contains("burstcloud") || embedUrl.contains("burst") -> BurstCloudExtractor(client).videoFromUrl(url, headers = headers, prefix = prefix)
+            embedUrl.contains("fastream") -> FastreamExtractor(client, headers).videosFromUrl(url, prefix = "$prefix Fastream:")
+            embedUrl.contains("upstream") -> UpstreamExtractor(client).videosFromUrl(url, prefix = prefix)
+            embedUrl.contains("streamtape") || embedUrl.contains("stp") || embedUrl.contains("stape") -> listOf(StreamTapeExtractor(client).videoFromUrl(url, quality = "$prefix StreamTape")!!)
+            embedUrl.contains("ahvsh") || embedUrl.contains("streamhide") || embedUrl.contains("guccihide") || embedUrl.contains("streamvid") -> StreamHideVidExtractor(client).videosFromUrl(url, "$prefix StreamHide")
+            else -> emptyList()
+        }
     }
 
     override fun List<Video>.sort(): List<Video> {
@@ -341,23 +227,29 @@ class Gnula : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
     override fun searchAnimeSelector(): String = popularAnimeSelector()
 
     override fun animeDetailsParse(document: Document): SAnime {
-        val anime = SAnime.create()
-        document.select("script").forEach { script ->
-            if (script.data().contains("{\"props\":{\"pageProps\"")) {
-                val jObject = json.decodeFromString<JsonObject>(script.data())
-                val props = jObject["props"]!!.jsonObject
-                val pageProps = props["pageProps"]!!.jsonObject
-                val post = pageProps["post"]!!.jsonObject
-                val page = jObject["page"]?.jsonPrimitive?.content ?: ""
-                anime.title = post["titles"]!!.jsonObject["name"]!!.jsonPrimitive!!.content
-                anime.thumbnail_url = post["images"]!!.jsonObject["poster"]!!.jsonPrimitive!!.content
-                anime.description = post["overview"]!!.jsonPrimitive!!.content
-                anime.genre = try { post["genres"]!!.jsonArray!!.joinToString { it!!.jsonObject["name"]!!.jsonPrimitive!!.content } } catch (e: Exception) { "" }
-                anime.status = if (page.contains("movie") || page.contains("movies")) SAnime.COMPLETED else SAnime.UNKNOWN
-                anime.artist = try { post["cast"]!!.jsonObject["acting"]!!.jsonArray!!.first()!!.jsonObject["name"]!!.jsonPrimitive!!.content } catch (e: Exception) { null }
+        val jsonString = document.selectFirst("script:containsData({\"props\":{\"pageProps\":)")?.data() ?: return SAnime.create()
+        val json = jsonString.parseTo<SeasonModel>()
+        val post = json.props.pageProps.post
+        return SAnime.create().apply {
+            title = post.titles.name ?: ""
+            thumbnail_url = post.images.poster
+            description = post.overview
+            genre = post.genres.joinToString { it.name ?: "" }
+            artist = post.cast.acting.firstOrNull()?.name ?: ""
+            status = if (json.page.contains("movie", true)) SAnime.COMPLETED else SAnime.UNKNOWN
+        }
+    }
+
+    private fun List<Region>.toVideoList(lang: String): List<Video> {
+        return this.parallelCatchingFlatMapBlocking {
+            var url = ""
+            client.newCall(GET(it.result)).execute().asJsoup().select("script").map { sc ->
+                if (sc.data().contains("var url = '")) {
+                    url = sc.data().substringAfter("var url = '").substringBefore("';")
+                }
             }
+            serverVideoResolver(url, lang)
         }
-        return anime
     }
 
     override fun getFilterList(): AnimeFilterList = AnimeFilterList(
@@ -391,6 +283,22 @@ class Gnula : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         fun toUriPart() = vals[state].second
     }
 
+    private inline fun <reified T> String.parseTo(): T {
+        return json.decodeFromString<T>(this)
+    }
+
+    private fun String.toDate(): Long {
+        return runCatching { DATE_FORMATTER.parse(trim())?.time }.getOrNull() ?: 0L
+    }
+
+    private fun urlSolverByType(type: String, slug: String): String {
+        return when (type) {
+            "PaginatedMovie", "PaginatedGenre" -> "$baseUrl/movies/$slug"
+            "PaginatedSerie" -> "$baseUrl/series/$slug"
+            else -> ""
+        }
+    }
+
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
         ListPreference(screen.context).apply {
             key = PREF_LANGUAGE_KEY
@@ -451,9 +359,8 @@ class Gnula : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
     override fun searchAnimeFromElement(element: Element): SAnime = throw UnsupportedOperationException()
     override fun videoUrlParse(document: Document) = throw UnsupportedOperationException()
     override fun videoFromElement(element: Element) = throw UnsupportedOperationException()
-    override fun latestUpdatesNextPageSelector() = throw UnsupportedOperationException()
-    override fun latestUpdatesFromElement(element: Element): SAnime = throw UnsupportedOperationException()
-    override fun latestUpdatesRequest(page: Int) = throw UnsupportedOperationException()
-    override fun latestUpdatesSelector() = throw UnsupportedOperationException()
+    override fun latestUpdatesFromElement(element: Element) = throw UnsupportedOperationException()
+    override fun latestUpdatesNextPageSelector(): String = throw UnsupportedOperationException()
+    override fun latestUpdatesSelector(): String = throw UnsupportedOperationException()
     // Not Used
 }
diff --git a/src/es/hackstore/build.gradle b/src/es/hackstore/build.gradle
index 689f2a1db6..0d7852f788 100644
--- a/src/es/hackstore/build.gradle
+++ b/src/es/hackstore/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'Hackstore'
     extClass = '.Hackstore'
-    extVersionCode = 5
+    extVersionCode = 6
 }
 
 apply from: "$rootDir/common.gradle"
diff --git a/src/es/hackstore/src/eu/kanade/tachiyomi/animeextension/es/hackstore/Hackstore.kt b/src/es/hackstore/src/eu/kanade/tachiyomi/animeextension/es/hackstore/Hackstore.kt
index c63d9c600f..9f87aee736 100644
--- a/src/es/hackstore/src/eu/kanade/tachiyomi/animeextension/es/hackstore/Hackstore.kt
+++ b/src/es/hackstore/src/eu/kanade/tachiyomi/animeextension/es/hackstore/Hackstore.kt
@@ -19,6 +19,7 @@ import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
 import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
 import okhttp3.Request
 import okhttp3.Response
 import org.jsoup.Jsoup
@@ -47,31 +48,21 @@ class Hackstore : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
     override fun popularAnimeSelector(): String = "div.movie-thumbnail"
 
     override fun popularAnimeFromElement(element: Element): SAnime {
-        val anime = SAnime.create()
-        anime.setUrlWithoutDomain(element.select("div.movie-thumbnail > div.movie-back > a").attr("href"))
-        anime.title = element.select("h3 > a.movie-title").attr("title")
-        anime.thumbnail_url = element.select("div.movie-back > a > div.poster-pad > img.imghacks").attr("data-src")
-
-        anime.description = ""
-        return anime
+        return SAnime.create().apply {
+            title = element.select(".movie-title").attr("title")
+            thumbnail_url = element.select(".poster-pad img").attr("abs:data-src")
+            description = ""
+            setUrlWithoutDomain(element.select(".movie-thumbnail a").attr("abs:href"))
+        }
     }
 
-    override fun popularAnimeNextPageSelector(): String = "div.wp-pagenavi"
+    override fun popularAnimeNextPageSelector(): String = "div.wp-pagenavi .current ~ a"
 
     // =============================== Latest ===============================
 
     override fun latestUpdatesNextPageSelector(): String = popularAnimeNextPageSelector()
 
-    override fun latestUpdatesFromElement(element: Element): SAnime {
-        val anime = SAnime.create()
-
-        anime.setUrlWithoutDomain(element.select("div.movie-thumbnail > div.movie-back > a").attr("href"))
-        anime.title = element.select("h3 > a.movie-title").attr("title")
-        anime.thumbnail_url = element.select("div.movie-thumbnail > div.movie-back > div > div.poster-pad > a > img").attr("data-src")
-        anime.description = ""
-
-        return anime
-    }
+    override fun latestUpdatesFromElement(element: Element) = popularAnimeFromElement(element)
 
     override fun latestUpdatesRequest(page: Int): Request = GET("$baseUrl/page/$page/?s")
 
@@ -98,9 +89,7 @@ class Hackstore : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         fun toUriPart() = vals[state].second
     }
 
-    override fun searchAnimeFromElement(element: Element): SAnime {
-        return popularAnimeFromElement(element)
-    }
+    override fun searchAnimeFromElement(element: Element) = popularAnimeFromElement(element)
 
     override fun searchAnimeNextPageSelector(): String = popularAnimeNextPageSelector()
 
@@ -118,81 +107,57 @@ class Hackstore : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
 
     // =========================== Anime Details ============================
     override fun animeDetailsParse(document: Document): SAnime {
-        val ismovie = document.selectFirst("#main-content > div > div.content-area.twelve.columns > div.watch-content > center > div > p:nth-child(1)") != null
-        if (ismovie) {
-            val anime = SAnime.create()
-            anime.description = document.selectFirst("#main-content > div > div.content-area.twelve.columns > div.watch-content > center > div > p:nth-child(1)")!!.text().removeSurrounding("\"")
-            document.select("#main-content > div > div.content-area.twelve.columns > div.watch-content > center > div > p").map {
-                val textContent = it.text()
-                val tempContent = textContent.lowercase()
-                if (tempContent.contains("titulo latino")) anime.title = textContent.replace("Titulo Latino:", "").trim()
-                if (tempContent.contains("genero")) anime.genre = textContent.replace("Genero:", "").trim()
-                if (tempContent.contains("Director")) anime.author = textContent.replace("Director:", "").trim()
-                textContent.replace("en 1 Link", "").trim()
+        val isMovie = document.location().contains("/peliculas/")
+        if (isMovie) {
+            val infoText = document.select(".watch-content .watch-text strong ~ p").text()
+            return SAnime.create().apply {
+                description = document.selectFirst(".watch-content .watch-text p:nth-child(1)")?.text()?.removeSurrounding("\"")
+                title = if (infoText.contains("Título Latino:", true)) infoText.substringAfter("Título Latino:").substringBefore(")").trim() + ")" else ""
+                genre = if (infoText.contains("Genero:", true)) infoText.substringAfter("Genero:").substringBefore("País").trim().replace(",", ", ") else null
+                author = if (infoText.contains("Director:", true)) infoText.substringAfter("Director:").substringBefore(",").trim() else null
+                artist = if (infoText.contains("Elenco:", true)) infoText.substringAfter("Elenco:").substringBefore(",").trim() else null
+                thumbnail_url = document.selectFirst(".watch-content img")?.attr("abs:data-src")?.replace("-200x300", "")
+                status = SAnime.COMPLETED
             }
-            return anime
         } else {
-            val anime = SAnime.create()
-
-            anime.description = document.selectFirst("#pcontent > p")?.text()?.trim() ?: document.selectFirst("#zcontent > p")?.text()?.trim() ?: ""
-
-            document.select("#zcontent, #pcontent > p").forEach { infoElement ->
-                val textContent = infoElement.text().trim().lowercase()
-
-                when {
-                    "titulo original" in textContent -> anime.title = textContent.replace("titulo original:", "").trim()
-                    "generos" in textContent -> anime.genre = textContent.replace("generos:", "").trim()
-                    "director" in textContent -> anime.author = textContent.replace("director:", "").trim()
-                }
+            return SAnime.create().apply {
+                title = document.selectFirst(".serieee h2")?.text() ?: ""
+                description = document.selectFirst("#pcontent > p")?.text()?.trim() ?: document.selectFirst("#zcontent > p")?.text()?.trim() ?: ""
+                genre = document.select("#ggenre [rel=tag]").joinToString { it.text() }
+                thumbnail_url = document.selectFirst(".imghacks")?.attr("abs:data-src")
             }
-
-            return anime
         }
     }
 
-    private fun externalOrInternalImg(url: String): String {
-        return if (url.contains("https")) url else "$baseUrl/$url"
-    }
-
     override fun episodeListParse(response: Response): List<SEpisode> {
         val document = response.asJsoup()
-
-        val episodeList = mutableListOf<SEpisode>()
         val ismovie = response.request.url.toString().contains("/peliculas/")
-        if (ismovie) {
-            val ep = SEpisode.create()
-            ep.setUrlWithoutDomain(response.request.url.toString())
-            ep.name = "PELÍCULA"
-            ep.episode_number = 1f
-            episodeList.add(ep)
+        return if (ismovie) {
+            listOf(
+                SEpisode.create().apply {
+                    name = "PELÍCULA"
+                    setUrlWithoutDomain(response.request.url.toString())
+                    episode_number = 1f
+                },
+            )
         } else {
-            document.select(".movie-thumbnail").forEach { thumbnail ->
-                val episode = SEpisode.create()
-
+            document.select(".movie-thumbnail").map { thumbnail ->
                 val episodeLink = thumbnail.select("a").attr("href")
                 val seasonMatch = Regex("-(\\d+)x(\\d+)/$").find(episodeLink)
                 val seasonNumber = seasonMatch?.groups?.get(1)?.value?.toInt() ?: 0
                 val episodeNumber = seasonMatch?.groups?.get(2)?.value?.toInt() ?: 0
-
-                episode.name = "T$seasonNumber - E$episodeNumber"
-                episode.episode_number = episodeNumber.toFloat()
-                episodeList.add(0, episode)
-                episode.setUrlWithoutDomain(episodeLink)
-
-                episodeList.add(episode)
+                SEpisode.create().apply {
+                    name = "T$seasonNumber - E$episodeNumber"
+                    episode_number = episodeNumber.toFloat()
+                    setUrlWithoutDomain(episodeLink)
+                }
             }
-        }
-
-        return episodeList
+        }.reversed()
     }
 
     // ============================== Episodes ==============================
     override fun episodeListSelector() = "uwu"
 
-    private fun getNumberFromString(epsStr: String): String {
-        return epsStr.filter { it.isDigit() }.ifEmpty { "0" }
-    }
-
     override fun episodeFromElement(element: Element): SEpisode { throw UnsupportedOperationException() }
 
     // ============================ Video Links =============================
@@ -206,13 +171,16 @@ class Hackstore : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         return matchResult?.groupValues?.get(1) ?: "url not found"
     }
 
+    /*--------------------------------Video extractors------------------------------------*/
+    private val streamTapeExtractor by lazy { StreamTapeExtractor(client) }
+    private val voeExtractor by lazy { VoeExtractor(client) }
+    private val filemoonExtractor by lazy { FilemoonExtractor(client) }
+    private val streamWishExtractor by lazy { StreamWishExtractor(client, headers) }
+    private val doodExtractor by lazy { DoodExtractor(client) }
+
     override fun videoListParse(response: Response): List<Video> {
         val document = response.asJsoup()
-        val videoList = mutableListOf<Video>()
-
-        val tabs = document.select("ul.TbVideoNv li.pres")
-
-        tabs.forEach { tab ->
+        return document.select("ul.TbVideoNv li.pres").parallelCatchingFlatMapBlocking { tab ->
             val server = tab.select("a.playr").text()
             val deco = tab.select("a.playr").attr("data-href")
             val langs = tab.select("a.playr").attr("data-lang")
@@ -220,35 +188,25 @@ class Hackstore : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
             val url = extractUrlFromDonFunction(fullUrl)
             val isLatino = langs.contains("latino")
             val isSub = langs.contains("subtitulado") || langs.contains("sub") || langs.contains("japonés")
+            val prefix = if (isLatino) "[LAT]" else if (isSub) "[SUB]" else "[CAST]"
 
             when {
-                server.contains("streamtape") -> {
-                    val video = StreamTapeExtractor(client).videoFromUrl(url, if (isLatino) "StreamTape Latino" else if (isSub) "StreamTape Subtitulado" else "StreamTape Castellano")
-                    if (video != null) {
-                        videoList.add(video)
-                    }
-                }
-                server.contains("voe") -> {
-                    val video = VoeExtractor(client).videosFromUrl(url, if (isLatino) "(Latino) " else if (isSub) "(Subtitulado) " else "(Castellano) ")
-                    videoList.addAll(video)
-                }
-                server.contains("filemoon") -> {
-                    val video = FilemoonExtractor(client).videosFromUrl(url, if (isLatino) "Filemoon Latino" else if (isSub) "Filemoon Subtitulado" else "Filemoon Castellano")
-                    videoList.addAll(video)
+                server.contains("streamtape") || server.contains("stp") || server.contains("stape") -> {
+                    listOf(streamTapeExtractor.videoFromUrl(url, quality = "$prefix StreamTape")!!)
                 }
-                server.contains("streamwish") -> {
-                    val video = StreamWishExtractor(client, headers).videosFromUrl(url, if (isLatino) "StreamWish Latino" else if (isSub) "StreamWish Subtitulado" else "StreamWish Castellano")
-                    videoList.addAll(video)
+                server.contains("voe") -> voeExtractor.videosFromUrl(url, prefix)
+                server.contains("filemoon") -> filemoonExtractor.videosFromUrl(url, prefix = "$prefix Filemoon:")
+                server.contains("wishembed") || server.contains("streamwish") || server.contains("strwish") || server.contains("wish") -> {
+                    streamWishExtractor.videosFromUrl(url, videoNameGen = { "$prefix StreamWish:$it" })
                 }
-                server.contains("dood") -> {
-                    val video = DoodExtractor(client).videosFromUrl(url, if (isLatino) "Dood Latino" else if (isSub) "Dood Subtitulado" else "Dood Castellano")
-                    videoList.addAll(video)
+                server.contains("doodstream") || server.contains("dood.") || server.contains("ds2play") || server.contains("doods.") -> {
+                    doodExtractor.videosFromUrl(url, "$prefix DoodStream")
                 }
+                else -> emptyList()
             }
         }
-
-        return videoList
     }
+
     override fun videoListSelector(): String = "ul.TbVideoNv li.pres a.playr"
 
     override fun videoFromElement(element: Element): Video { throw UnsupportedOperationException() }
@@ -276,12 +234,14 @@ class Hackstore : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
         private const val PREF_QUALITY_KEY = "preferred_quality"
         private const val PREF_QUALITY_DEFAULT = "1080"
         private val QUALITY_LIST = arrayOf("1080", "720", "480", "360")
+
         private const val PREF_LANGUAGE_KEY = "preferred_language"
-        private const val PREF_LANGUAGE_DEFAULT = "Latino"
+        private const val PREF_LANGUAGE_DEFAULT = "[LAT]"
         private val LANGUAGE_LIST = arrayOf("Latino", "Castellano", "Subtitulado")
+        private val LANGUAGE_VALUES = arrayOf("[LAT]", "[CAST]", "[SUB]")
 
         private const val PREF_SERVER_KEY = "preferred_server"
-        private const val PREF_SERVER_DEFAULT = "DoodStream"
+        private const val PREF_SERVER_DEFAULT = "StreamWish"
         private val SERVER_LIST = arrayOf("DoodStream", "StreamTape", "Voe", "Filemoon", "StreamWish")
     }
 
@@ -322,7 +282,7 @@ class Hackstore : ConfigurableAnimeSource, ParsedAnimeHttpSource() {
             key = PREF_LANGUAGE_KEY
             title = "Preferred language"
             entries = LANGUAGE_LIST
-            entryValues = LANGUAGE_LIST
+            entryValues = LANGUAGE_VALUES
             setDefaultValue(PREF_LANGUAGE_DEFAULT)
             summary = "%s"
 
diff --git a/src/es/hentaila/build.gradle b/src/es/hentaila/build.gradle
index 268d31ac58..d8779387a8 100644
--- a/src/es/hentaila/build.gradle
+++ b/src/es/hentaila/build.gradle
@@ -1,7 +1,7 @@
 ext {
     extName = 'HentaiLA'
     extClass = '.Hentaila'
-    extVersionCode = 21
+    extVersionCode = 22
     isNsfw = true
 }
 
@@ -13,4 +13,5 @@ dependencies {
     implementation(project(':lib:streamwish-extractor'))
     implementation(project(':lib:voe-extractor'))
     implementation(project(':lib:yourupload-extractor'))
+    implementation(project(':lib:streamhidevid-extractor'))
 }
\ No newline at end of file
diff --git a/src/es/hentaila/src/eu/kanade/tachiyomi/animeextension/es/hentaila/Hentaila.kt b/src/es/hentaila/src/eu/kanade/tachiyomi/animeextension/es/hentaila/Hentaila.kt
index bcced33296..7a9f43a25b 100644
--- a/src/es/hentaila/src/eu/kanade/tachiyomi/animeextension/es/hentaila/Hentaila.kt
+++ b/src/es/hentaila/src/eu/kanade/tachiyomi/animeextension/es/hentaila/Hentaila.kt
@@ -14,12 +14,14 @@ import eu.kanade.tachiyomi.animesource.model.Video
 import eu.kanade.tachiyomi.animesource.online.AnimeHttpSource
 import eu.kanade.tachiyomi.lib.burstcloudextractor.BurstCloudExtractor
 import eu.kanade.tachiyomi.lib.mp4uploadextractor.Mp4uploadExtractor
+import eu.kanade.tachiyomi.lib.streamhidevidextractor.StreamHideVidExtractor
 import eu.kanade.tachiyomi.lib.streamwishextractor.StreamWishExtractor
 import eu.kanade.tachiyomi.lib.voeextractor.VoeExtractor
 import eu.kanade.tachiyomi.lib.youruploadextractor.YourUploadExtractor
 import eu.kanade.tachiyomi.network.GET
 import eu.kanade.tachiyomi.network.POST
 import eu.kanade.tachiyomi.util.asJsoup
+import eu.kanade.tachiyomi.util.parallelCatchingFlatMapBlocking
 import kotlinx.serialization.json.Json
 import okhttp3.FormBody
 import okhttp3.HttpUrl.Companion.toHttpUrl
@@ -29,7 +31,6 @@ import uy.kohesive.injekt.Injekt
 import uy.kohesive.injekt.api.get
 import uy.kohesive.injekt.injectLazy
 import java.io.IOException
-import java.lang.Exception
 import java.text.SimpleDateFormat
 import java.util.Locale
 
@@ -55,7 +56,7 @@ class Hentaila : ConfigurableAnimeSource, AnimeHttpSource() {
         private val QUALITY_LIST = arrayOf("1080", "720", "480", "360")
 
         private const val PREF_SERVER_KEY = "preferred_server"
-        private const val PREF_SERVER_DEFAULT = "Voe"
+        private const val PREF_SERVER_DEFAULT = "StreamWish"
         private val SERVER_LIST = arrayOf(
             "StreamWish",
             "Voe",
@@ -63,7 +64,12 @@ class Hentaila : ConfigurableAnimeSource, AnimeHttpSource() {
             "YourUpload",
             "Mp4Upload",
             "BurstCloud",
+            "StreamHideVid",
         )
+
+        private val DATE_FORMATTER by lazy {
+            SimpleDateFormat("MMMMM dd, yyyy", Locale.ENGLISH)
+        }
     }
 
     override fun popularAnimeRequest(page: Int) = GET("$baseUrl/directorio?filter=popular&p=$page", headers)
@@ -185,10 +191,7 @@ class Hentaila : ConfigurableAnimeSource, AnimeHttpSource() {
                 episode_number = epNum.toFloat()
                 name = "Episodio $epNum"
                 url = "/ver/$animeId-$epNum"
-                date_upload = try {
-                    val date = it.select(".h-header time").text()
-                    SimpleDateFormat("MMMMM dd, yyyy", Locale.ENGLISH).parse(date).time
-                } catch (_: Exception) { System.currentTimeMillis() }
+                date_upload = it.select(".h-header time").text().toDate()
             }
             episodes.add(episode)
         }
@@ -196,41 +199,37 @@ class Hentaila : ConfigurableAnimeSource, AnimeHttpSource() {
         return episodes
     }
 
+    /*--------------------------------Video extractors------------------------------------*/
+    private val streamWishExtractor by lazy { StreamWishExtractor(client, headers) }
+    private val voeExtractor by lazy { VoeExtractor(client) }
+    private val yourUploadExtractor by lazy { YourUploadExtractor(client) }
+    private val mp4uploadExtractor by lazy { Mp4uploadExtractor(client) }
+    private val burstCloudExtractor by lazy { BurstCloudExtractor(client) }
+    private val streamHideVidExtractor by lazy { StreamHideVidExtractor(client) }
+
     override fun videoListParse(response: Response): List<Video> {
         val document = response.asJsoup()
-        val videoList = mutableListOf<Video>()
-        val videoServers = document.selectFirst("script:containsData(var videos = [)")!!.data().substringAfter("videos = ").substringBefore(";")
+        val videoServers = document.selectFirst("script:containsData(var videos = [)")!!.data()
+            .substringAfter("videos = ").substringBefore(";")
             .replace("[[", "").replace("]]", "")
+
         val videoServerList = videoServers.split("],[")
-        videoServerList.forEach {
+        return videoServerList.parallelCatchingFlatMapBlocking {
             val server = it.split(",").map { a -> a.replace("\"", "") }
             val urlServer = server[1].replace("\\/", "/")
             val nameServer = server[0]
 
             when (nameServer.lowercase()) {
-                "streamwish" -> {
-                    videoList.addAll(StreamWishExtractor(client, headers).videosFromUrl(urlServer, videoNameGen = { "StreamWish:$it" }))
-                }
-                "voe" -> {
-                    videoList.addAll(VoeExtractor(client).videosFromUrl(urlServer))
-                }
-                "arc" -> {
-                    val videoUrl = urlServer.substringAfter("#")
-                    videoList.add(Video(videoUrl, "Arc", videoUrl))
-                }
-                "yupi" -> {
-                    videoList.addAll(YourUploadExtractor(client).videoFromUrl(urlServer, headers = headers))
-                }
-                "mp4upload" -> {
-                    videoList.addAll(Mp4uploadExtractor(client).videosFromUrl(urlServer, headers = headers))
-                }
-                "burst" -> {
-                    videoList.addAll(BurstCloudExtractor(client).videoFromUrl(urlServer, headers = headers))
-                }
+                "streamwish" -> streamWishExtractor.videosFromUrl(urlServer, videoNameGen = { "StreamWish:$it" })
+                "voe" -> voeExtractor.videosFromUrl(urlServer)
+                "arc" -> listOf(Video(urlServer.substringAfter("#"), "Arc", urlServer.substringAfter("#")))
+                "yupi" -> yourUploadExtractor.videoFromUrl(urlServer, headers = headers)
+                "mp4upload" -> mp4uploadExtractor.videosFromUrl(urlServer, headers = headers)
+                "burst" -> burstCloudExtractor.videoFromUrl(urlServer, headers = headers)
+                "vidhide", "streamhide", "guccihide", "streamvid" -> streamHideVidExtractor.videosFromUrl(urlServer)
+                else -> emptyList()
             }
         }
-
-        return videoList
     }
 
     override fun List<Video>.sort(): List<Video> {
@@ -315,6 +314,11 @@ class Hentaila : ConfigurableAnimeSource, AnimeHttpSource() {
         fun toUriPart() = vals[state].second
     }
 
+    private fun String.toDate(): Long {
+        return runCatching { DATE_FORMATTER.parse(trim())?.time }
+            .getOrNull() ?: 0L
+    }
+
     override fun setupPreferenceScreen(screen: PreferenceScreen) {
         ListPreference(screen.context).apply {
             key = PREF_SERVER_KEY