diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/Constants.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/Constants.kt
index 751a99243..60dd20956 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/Constants.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/Constants.kt
@@ -17,8 +17,8 @@ object Constants {
     const val FILE_PROVIDER_AUTHORITY: String = BuildConfig.APPLICATION_ID + ".file_provider"
     const val VK_ANDROID_APP_VERSION_NAME = "8.15"
     const val VK_ANDROID_APP_VERSION_CODE = "15271"
-    const val KATE_APP_VERSION_NAME = "97.1 lite"
-    const val KATE_APP_VERSION_CODE = "532"
+    const val KATE_APP_VERSION_NAME = "99 lite"
+    const val KATE_APP_VERSION_CODE = "535"
     const val API_ID: Int = BuildConfig.VK_API_APP_ID
     const val SECRET: String = BuildConfig.VK_CLIENT_SECRET
     const val PHOTOS_PATH = "DCIM/Fenrir"
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/activity/photopager/PhotoPagerPresenter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/activity/photopager/PhotoPagerPresenter.kt
index 7e0004a44..df39393df 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/activity/photopager/PhotoPagerPresenter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/activity/photopager/PhotoPagerPresenter.kt
@@ -86,11 +86,11 @@ open class PhotoPagerPresenter internal constructor(
 
     override fun onViewHostAttached(view: IPhotoPagerView) {
         super.onViewHostAttached(view)
-        resolveOptionMenu()
+        resolveOptionMenu(view)
     }
 
-    private fun resolveOptionMenu() {
-        view?.setupOptionMenu(
+    private fun resolveOptionMenu(view: IPhotoPagerView) {
+        view.setupOptionMenu(
             canSaveYourself(),
             canDelete()
         )
@@ -198,7 +198,7 @@ open class PhotoPagerPresenter internal constructor(
     private fun onPositionChanged() {
         refreshInfoViews(true)
         resolveRestoreButtonVisibility()
-        resolveOptionMenu()
+        view?.let { resolveOptionMenu(it) }
     }
 
     private fun showPhotoInfo(photo: Photo, album: PhotoAlbum?, bundle: IOwnersBundle?) {
@@ -301,7 +301,7 @@ open class PhotoPagerPresenter internal constructor(
         resolveWithUserView()
         resolveShareView()
         resolveCommentsView()
-        resolveOptionMenu()
+        view?.let { resolveOptionMenu(it) }
         if (need_update && need_update_info() && hasPhotos()) {
             val photo = current
             if (photo.albumId != -311) {
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/HttpLoggerAndParser.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/HttpLoggerAndParser.kt
index 8bf90a82f..68cf72f18 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/HttpLoggerAndParser.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/HttpLoggerAndParser.kt
@@ -100,11 +100,11 @@ object HttpLoggerAndParser {
         return this
     }
 
-    val DEFAULT_LOGGING_INTERCEPTOR: OkHttp3LoggingInterceptor by lazy {
+    private val DEFAULT_LOGGING_INTERCEPTOR: OkHttp3LoggingInterceptor by lazy {
         OkHttp3LoggingInterceptor().setLevel(OkHttp3LoggingInterceptor.Level.BODY)
     }
 
-    val UPLOAD_LOGGING_INTERCEPTOR: OkHttp3LoggingInterceptor by lazy {
+    private val UPLOAD_LOGGING_INTERCEPTOR: OkHttp3LoggingInterceptor by lazy {
         //OkHttp3LoggingInterceptor().setLevel(OkHttp3LoggingInterceptor.Level.HEADERS)
         OkHttp3LoggingInterceptor().setLevel(OkHttp3LoggingInterceptor.Level.BODY)
     }
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/impl/DocsApi.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/impl/DocsApi.kt
index 84b0adaee..05fb243e7 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/impl/DocsApi.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/impl/DocsApi.kt
@@ -7,7 +7,6 @@ import dev.ragnarok.fenrir.api.model.AccessIdPair
 import dev.ragnarok.fenrir.api.model.Items
 import dev.ragnarok.fenrir.api.model.VKApiDoc
 import dev.ragnarok.fenrir.api.model.server.VKApiDocsUploadServer
-import dev.ragnarok.fenrir.api.model.server.VKApiVideosUploadServer
 import dev.ragnarok.fenrir.api.services.IDocsService
 import io.reactivex.rxjava3.core.Single
 
@@ -75,18 +74,6 @@ internal class DocsApi(accountId: Long, provider: IServiceProvider) : AbsApi(acc
             }
     }
 
-    override fun getVideoServer(
-        isPrivate: Int?,
-        group_id: Long?,
-        name: String?
-    ): Single<VKApiVideosUploadServer> {
-        return provideService(IDocsService(), TokenType.USER)
-            .flatMap { service ->
-                service.getVideoServer(isPrivate, group_id, name)
-                    .map(extractResponseWithErrorHandling())
-            }
-    }
-
     override fun get(
         ownerId: Long?,
         count: Int?,
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/impl/VideoApi.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/impl/VideoApi.kt
index 483a3e205..e03416adb 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/impl/VideoApi.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/impl/VideoApi.kt
@@ -10,6 +10,7 @@ import dev.ragnarok.fenrir.api.model.VKApiVideoAlbum
 import dev.ragnarok.fenrir.api.model.interfaces.IAttachmentToken
 import dev.ragnarok.fenrir.api.model.response.DefaultCommentsResponse
 import dev.ragnarok.fenrir.api.model.response.SearchVideoResponse
+import dev.ragnarok.fenrir.api.model.server.VKApiVideosUploadServer
 import dev.ragnarok.fenrir.api.services.IVideoService
 import io.reactivex.rxjava3.core.Single
 
@@ -183,4 +184,20 @@ internal class VideoApi(accountId: Long, provider: IServiceProvider) :
                     .map { it == 1 }
             }
     }
+
+    override fun getVideoServer(
+        isPrivate: Int?,
+        group_id: Long?,
+        name: String?
+    ): Single<VKApiVideosUploadServer> {
+        return provideService(IVideoService(), TokenType.USER)
+            .flatMap { service ->
+                var finalName = name
+                if (finalName?.startsWith("VID_", false) == true) {
+                    finalName = "Telegram $finalName"
+                }
+                service.getVideoServer(isPrivate, group_id, finalName)
+                    .map(extractResponseWithErrorHandling())
+            }
+    }
 }
\ No newline at end of file
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/interfaces/IDocsApi.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/interfaces/IDocsApi.kt
index 5d7b9523c..508fefd52 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/interfaces/IDocsApi.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/interfaces/IDocsApi.kt
@@ -5,7 +5,6 @@ import dev.ragnarok.fenrir.api.model.AccessIdPair
 import dev.ragnarok.fenrir.api.model.Items
 import dev.ragnarok.fenrir.api.model.VKApiDoc
 import dev.ragnarok.fenrir.api.model.server.VKApiDocsUploadServer
-import dev.ragnarok.fenrir.api.model.server.VKApiVideosUploadServer
 import io.reactivex.rxjava3.core.Single
 
 interface IDocsApi {
@@ -30,13 +29,6 @@ interface IDocsApi {
     @CheckResult
     fun getMessagesUploadServer(peerId: Long?, type: String?): Single<VKApiDocsUploadServer>
 
-    @CheckResult
-    fun getVideoServer(
-        isPrivate: Int?,
-        group_id: Long?,
-        name: String?
-    ): Single<VKApiVideosUploadServer>
-
     @CheckResult
     operator fun get(
         ownerId: Long?,
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/interfaces/IVideoApi.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/interfaces/IVideoApi.kt
index 079b1df0a..9ba201b16 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/interfaces/IVideoApi.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/interfaces/IVideoApi.kt
@@ -8,6 +8,7 @@ import dev.ragnarok.fenrir.api.model.VKApiVideoAlbum
 import dev.ragnarok.fenrir.api.model.interfaces.IAttachmentToken
 import dev.ragnarok.fenrir.api.model.response.DefaultCommentsResponse
 import dev.ragnarok.fenrir.api.model.response.SearchVideoResponse
+import dev.ragnarok.fenrir.api.model.server.VKApiVideosUploadServer
 import io.reactivex.rxjava3.core.Single
 
 interface IVideoApi {
@@ -75,4 +76,11 @@ interface IVideoApi {
 
     @CheckResult
     fun edit(ownerId: Long, video_id: Int, name: String?, desc: String?): Single<Boolean>
+
+    @CheckResult
+    fun getVideoServer(
+        isPrivate: Int?,
+        group_id: Long?,
+        name: String?
+    ): Single<VKApiVideosUploadServer>
 }
\ No newline at end of file
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/services/IDocsService.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/services/IDocsService.kt
index b2727f958..eeb22b4e3 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/services/IDocsService.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/services/IDocsService.kt
@@ -4,7 +4,6 @@ import dev.ragnarok.fenrir.api.model.Items
 import dev.ragnarok.fenrir.api.model.VKApiDoc
 import dev.ragnarok.fenrir.api.model.response.BaseResponse
 import dev.ragnarok.fenrir.api.model.server.VKApiDocsUploadServer
-import dev.ragnarok.fenrir.api.model.server.VKApiVideosUploadServer
 import dev.ragnarok.fenrir.api.rest.IServiceRest
 import io.reactivex.rxjava3.core.Single
 
@@ -126,20 +125,6 @@ class IDocsService : IServiceRest() {
         )
     }
 
-    fun getVideoServer(
-        is_private: Int?,
-        group_id: Long?,
-        name: String?
-    ): Single<BaseResponse<VKApiVideosUploadServer>> {
-        return rest.request(
-            "video.save", form(
-                "is_private" to is_private,
-                "group_id" to group_id,
-                "name" to name
-            ), base(VKApiVideosUploadServer.serializer())
-        )
-    }
-
     /**
      * Returns detailed information about user or community documents.
      *
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/services/IVideoService.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/services/IVideoService.kt
index 8758bddf7..67164aa1e 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/services/IVideoService.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/api/services/IVideoService.kt
@@ -6,6 +6,7 @@ import dev.ragnarok.fenrir.api.model.VKApiVideoAlbum
 import dev.ragnarok.fenrir.api.model.response.BaseResponse
 import dev.ragnarok.fenrir.api.model.response.DefaultCommentsResponse
 import dev.ragnarok.fenrir.api.model.response.SearchVideoResponse
+import dev.ragnarok.fenrir.api.model.server.VKApiVideosUploadServer
 import dev.ragnarok.fenrir.api.rest.IServiceRest
 import io.reactivex.rxjava3.core.Single
 
@@ -227,4 +228,18 @@ class IVideoService : IServiceRest() {
             ), baseInt
         )
     }
+
+    fun getVideoServer(
+        is_private: Int?,
+        group_id: Long?,
+        name: String?
+    ): Single<BaseResponse<VKApiVideosUploadServer>> {
+        return rest.request(
+            "video.save", form(
+                "is_private" to is_private,
+                "group_id" to group_id,
+                "name" to name
+            ), base(VKApiVideosUploadServer.serializer())
+        )
+    }
 }
\ No newline at end of file
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/abswall/WallAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/abswall/WallAdapter.kt
index 63d66be34..a3af97484 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/abswall/WallAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/abswall/WallAdapter.kt
@@ -60,9 +60,9 @@ class WallAdapter(
             }
 
             TYPE_SCHEDULED -> {
-                val scheludedHolder = viewHolder as ScheludedHolder
-                configNormalPost(scheludedHolder, item)
-                bindScheludedButtonsBlock(scheludedHolder, item)
+                val scheduledHolder = viewHolder as ScheduledHolder
+                configNormalPost(scheduledHolder, item)
+                bindScheludedButtonsBlock(scheduledHolder, item)
             }
 
             TYPE_DELETED -> bindDeleted(viewHolder as DeletedHolder, item)
@@ -73,7 +73,7 @@ class WallAdapter(
         nonPublishedPostActionListener = listener
     }
 
-    private fun bindScheludedButtonsBlock(holder: ScheludedHolder, post: Post) {
+    private fun bindScheludedButtonsBlock(holder: ScheduledHolder, post: Post) {
         holder.deleteButton.setOnClickListener {
             nonPublishedPostActionListener?.onButtonRemoveClick(post)
         }
@@ -194,7 +194,7 @@ class WallAdapter(
         when (type) {
             TYPE_NORMAL -> return NormalHolder(view)
             TYPE_DELETED -> return DeletedHolder(view)
-            TYPE_SCHEDULED -> return ScheludedHolder(view)
+            TYPE_SCHEDULED -> return ScheduledHolder(view)
         }
         throw IllegalArgumentException()
     }
@@ -287,7 +287,7 @@ class WallAdapter(
 
     }
 
-    private inner class ScheludedHolder(view: View) : AbsPostHolder(view) {
+    private inner class ScheduledHolder(view: View) : AbsPostHolder(view) {
         val deleteButton: CircleCounterButton = root.findViewById(R.id.button_delete)
     }
 
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/attachments/absattachmentsedit/AttchmentsEditorAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/attachments/absattachmentsedit/AttchmentsEditorAdapter.kt
index 39fde6ce6..85d6c808f 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/attachments/absattachmentsedit/AttchmentsEditorAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/attachments/absattachmentsedit/AttchmentsEditorAdapter.kt
@@ -47,7 +47,7 @@ class AttchmentsEditorAdapter(
         sharedHolders.put(attachment.id, viewHolder)
         configView(attachment, viewHolder)
         viewHolder.vRemove.setOnClickListener {
-            val dataposition = viewHolder.bindingAdapterPosition - headersCount
+            val dataposition = getItemRawPosition(viewHolder.bindingAdapterPosition)
             callback.onRemoveClick(dataposition, attachment)
         }
     }
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/audios/AudioRecyclerAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/audios/AudioRecyclerAdapter.kt
index 656a70d98..40df8b0a4 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/audios/AudioRecyclerAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/audios/AudioRecyclerAdapter.kt
@@ -729,9 +729,9 @@ class AudioRecyclerAdapter(
         }
         viewHolder.play.setOnClickListener { v: View ->
             if (Settings.get().main().isRevert_play_audio) {
-                doMenu(viewHolder, position, v, audio)
+                doMenu(viewHolder, getItemRawPosition(viewHolder.bindingAdapterPosition), v, audio)
             } else {
-                doPlay(position, audio)
+                doPlay(getItemRawPosition(viewHolder.bindingAdapterPosition), audio)
             }
         }
         if (!iSSelectMode) {
@@ -785,9 +785,14 @@ class AudioRecyclerAdapter(
                 viewHolder.cancelSelectionAnimation()
                 viewHolder.startSomeAnimation()
                 if (Settings.get().main().isRevert_play_audio) {
-                    doPlay(position, audio)
+                    doPlay(getItemRawPosition(viewHolder.bindingAdapterPosition), audio)
                 } else {
-                    doMenu(viewHolder, position, view, audio)
+                    doMenu(
+                        viewHolder,
+                        getItemRawPosition(viewHolder.bindingAdapterPosition),
+                        view,
+                        audio
+                    )
                 }
             }
         } else {
@@ -854,7 +859,7 @@ class AudioRecyclerAdapter(
         val Track: View = itemView.findViewById(R.id.track_option)
         val selectionView: MaterialCardView = itemView.findViewById(R.id.item_audio_selection)
         val isSelectedView: MaterialCardView = itemView.findViewById(R.id.item_audio_select_add)
-        val animationAdapter: Animator.AnimatorListener
+        private val animationAdapter: Animator.AnimatorListener
         var animator: ObjectAnimator? = null
         fun startSelectionAnimation() {
             selectionView.setCardBackgroundColor(CurrentTheme.getColorPrimary(mContext))
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/catalog_v2/sections/CatalogV2SectionAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/catalog_v2/sections/CatalogV2SectionAdapter.kt
index 6cd9caff6..d6566aeb2 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/catalog_v2/sections/CatalogV2SectionAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/catalog_v2/sections/CatalogV2SectionAdapter.kt
@@ -1063,9 +1063,9 @@ class CatalogV2SectionAdapter(
             }
             play.setOnClickListener { v: View ->
                 if (Settings.get().main().isRevert_play_audio) {
-                    doMenu(this, position, v, audio)
+                    doMenu(this, getItemRawPosition(bindingAdapterPosition), v, audio)
                 } else {
-                    doPlay(position, audio)
+                    doPlay(getItemRawPosition(bindingAdapterPosition), audio)
                 }
             }
             if (isLongPressDownload) {
@@ -1121,9 +1121,9 @@ class CatalogV2SectionAdapter(
                 cancelSelectionAnimation()
                 startSomeAnimation()
                 if (Settings.get().main().isRevert_play_audio) {
-                    doPlay(position, audio)
+                    doPlay(getItemRawPosition(bindingAdapterPosition), audio)
                 } else {
-                    doMenu(this, position, view, audio)
+                    doMenu(this, getItemRawPosition(bindingAdapterPosition), view, audio)
                 }
             }
         }
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/local/audioslocal/AudioLocalRecyclerAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/local/audioslocal/AudioLocalRecyclerAdapter.kt
index 3a1a85189..8bed5cedc 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/local/audioslocal/AudioLocalRecyclerAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/audio/local/audioslocal/AudioLocalRecyclerAdapter.kt
@@ -367,18 +367,18 @@ class AudioLocalRecyclerAdapter(private val mContext: Context, private var data:
         }
         holder.play.setOnClickListener { v: View ->
             if (Settings.get().main().isRevert_play_audio) {
-                doMenu(position, v, audio)
+                doMenu(holder.bindingAdapterPosition, v, audio)
             } else {
-                doPlay(position, audio)
+                doPlay(holder.bindingAdapterPosition, audio)
             }
         }
         holder.Track.setOnClickListener { view: View ->
             holder.cancelSelectionAnimation()
             holder.startSomeAnimation()
             if (Settings.get().main().isRevert_play_audio) {
-                doPlay(position, audio)
+                doPlay(holder.bindingAdapterPosition, audio)
             } else {
-                doMenu(position, view, audio)
+                doMenu(holder.bindingAdapterPosition, view, audio)
             }
         }
     }
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalMenuAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalMenuAdapter.kt
index 4b9c6380f..cc50750b8 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalMenuAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalMenuAdapter.kt
@@ -20,9 +20,17 @@ class HorizontalMenuAdapter(data: MutableList<CommunityDetails.Menu>) :
             viewHolder.menu_image.visibility = View.VISIBLE
             displayAvatar(viewHolder.menu_image, null, item.cover, Constants.PICASSO_TAG)
         } else viewHolder.menu_image.visibility = View.INVISIBLE
-        viewHolder.itemView.setOnClickListener { listener?.onWallMenuClick(item, position) }
+        viewHolder.itemView.setOnClickListener {
+            listener?.onWallMenuClick(
+                item,
+                getItemRawPosition(viewHolder.bindingAdapterPosition)
+            )
+        }
         viewHolder.itemView.setOnLongClickListener {
-            listener?.onWallMenuLongClick(item, position)
+            listener?.onWallMenuLongClick(
+                item,
+                getItemRawPosition(viewHolder.bindingAdapterPosition)
+            )
             true
         }
     }
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalOptionsAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalOptionsAdapter.kt
index dd95b7053..8a679cfd1 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalOptionsAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalOptionsAdapter.kt
@@ -48,7 +48,10 @@ class HorizontalOptionsAdapter<T : Entry>(data: MutableList<T>) :
         viewHolder.delete.visibility = if (item.isCustom) View.VISIBLE else View.GONE
         viewHolder.delete.setOnClickListener {
             if (item.isCustom) {
-                delete_listener?.onDeleteOptionClick(item, position)
+                delete_listener?.onDeleteOptionClick(
+                    item,
+                    getItemRawPosition(viewHolder.bindingAdapterPosition)
+                )
             }
         }
     }
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalPlaylistAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalPlaylistAdapter.kt
index 17f390454..580f4c012 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalPlaylistAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalPlaylistAdapter.kt
@@ -68,8 +68,18 @@ class HorizontalPlaylistAdapter(data: MutableList<AudioPlaylist>) :
         }
         viewHolder.update.text =
             AppTextUtils.getDateFromUnixTime(context, playlist.getUpdate_time())
-        viewHolder.add.setOnClickListener { listener?.onPlayListClick(playlist, position) }
-        viewHolder.share.setOnClickListener { listener?.onShareClick(playlist, position) }
+        viewHolder.add.setOnClickListener {
+            listener?.onPlayListClick(
+                playlist,
+                getItemRawPosition(viewHolder.bindingAdapterPosition)
+            )
+        }
+        viewHolder.share.setOnClickListener {
+            listener?.onShareClick(
+                playlist,
+                getItemRawPosition(viewHolder.bindingAdapterPosition)
+            )
+        }
         if (playlist.getId() >= 0) {
             viewHolder.add.visibility = View.VISIBLE
             viewHolder.share.visibility = View.VISIBLE
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalStoryAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalStoryAdapter.kt
index 57732b383..8d395db35 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalStoryAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/HorizontalStoryAdapter.kt
@@ -61,11 +61,16 @@ class HorizontalStoryAdapter(data: MutableList<Story>) :
                 Constants.PICASSO_TAG
             )
         }
-        viewHolder.itemView.setOnClickListener { listener?.onStoryClick(item, position) }
+        viewHolder.itemView.setOnClickListener {
+            listener?.onStoryClick(
+                item,
+                getItemRawPosition(viewHolder.bindingAdapterPosition)
+            )
+        }
         viewHolder.itemView.setOnLongClickListener {
             listener?.onStoryLongClick(
                 item,
-                position
+                getItemRawPosition(viewHolder.bindingAdapterPosition)
             ) == true
         }
     }
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/ImageListAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/ImageListAdapter.kt
index 222ac7808..33a59e18c 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/ImageListAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/base/horizontal/ImageListAdapter.kt
@@ -84,8 +84,8 @@ class ImageListAdapter : RecyclerView.Adapter<ImageListAdapter.ImageVewHolder>()
             }
 
             itemView.setOnClickListener {
-                mOnRecyclerImageClickListener?.onRecyclerImageClick(position)
-                selectPosition(position)
+                mOnRecyclerImageClickListener?.onRecyclerImageClick(bindingAdapterPosition)
+                selectPosition(bindingAdapterPosition)
             }
 
             if (mCurrentSelectedIndex == position)
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/docs/DocsAsImagesAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/docs/DocsAsImagesAdapter.kt
index 4c69a3efd..b7b05bdcb 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/docs/DocsAsImagesAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/docs/DocsAsImagesAdapter.kt
@@ -38,10 +38,13 @@ class DocsAsImagesAdapter(data: MutableList<Document>) :
                 .cancelRequest(viewHolder.image)
         }
         viewHolder.itemView.setOnClickListener {
-            mActionListener?.onDocClick(viewHolder.bindingAdapterPosition, item)
+            mActionListener?.onDocClick(getItemRawPosition(viewHolder.bindingAdapterPosition), item)
         }
         viewHolder.itemView.setOnLongClickListener {
-            mActionListener?.onDocLongClick(viewHolder.bindingAdapterPosition, item) == true
+            mActionListener?.onDocLongClick(
+                getItemRawPosition(viewHolder.bindingAdapterPosition),
+                item
+            ) == true
         }
     }
 
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/fave/favearticles/FaveArticlesAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/fave/favearticles/FaveArticlesAdapter.kt
index b89d50eee..9dbbbcda8 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/fave/favearticles/FaveArticlesAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/fave/favearticles/FaveArticlesAdapter.kt
@@ -30,7 +30,12 @@ class FaveArticlesAdapter(private var data: List<Article>, private val context:
     override fun onBindViewHolder(holder: Holder, position: Int) {
         val article = data[position]
         holder.btFave.setImageResource(R.drawable.favorite)
-        holder.btFave.setOnClickListener { clickListener?.onDelete(position, article) }
+        holder.btFave.setOnClickListener {
+            clickListener?.onDelete(
+                holder.bindingAdapterPosition,
+                article
+            )
+        }
         if (article.uRL != null) {
             holder.ivButton.visibility = View.VISIBLE
             holder.ivButton.setOnClickListener {
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/fave/favevideos/FaveVideosAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/fave/favevideos/FaveVideosAdapter.kt
index eab5cbcb1..b1d258d30 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/fave/favevideos/FaveVideosAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/fave/favevideos/FaveVideosAdapter.kt
@@ -48,7 +48,7 @@ class FaveVideosAdapter(private val context: Context, private var data: List<Vid
             holder.videoService.visibility = View.GONE
         }
         holder.card.setOnClickListener {
-            videoOnClickListener?.onVideoClick(position, video)
+            videoOnClickListener?.onVideoClick(holder.bindingAdapterPosition, video)
         }
     }
 
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/groupchats/GroupChatsAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/groupchats/GroupChatsAdapter.kt
index bf931793f..4e1a583c0 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/groupchats/GroupChatsAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/groupchats/GroupChatsAdapter.kt
@@ -27,7 +27,7 @@ class GroupChatsAdapter(
     private val transformation: Transformation = CurrentTheme.createTransformationForAvatar()
     private var firstLastPadding = 0
     override fun onBindItemViewHolder(viewHolder: ViewHolder, position: Int, type: Int) {
-        val item = getItem(position - headersCount)
+        val item = getItem(position)
         val context = viewHolder.itemView.context
         viewHolder.title.text = item.getTitle()
         viewHolder.subtitle.text = context.getString(
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/localserver/audioslocalserver/AudioLocalServerRecyclerAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/localserver/audioslocalserver/AudioLocalServerRecyclerAdapter.kt
index aab6ad622..09cca97c9 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/localserver/audioslocalserver/AudioLocalServerRecyclerAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/localserver/audioslocalserver/AudioLocalServerRecyclerAdapter.kt
@@ -449,9 +449,9 @@ class AudioLocalServerRecyclerAdapter(
         }
         holder.play.setOnClickListener { v: View ->
             if (Settings.get().main().isRevert_play_audio) {
-                doMenu(holder, position, v, audio)
+                doMenu(holder, holder.bindingAdapterPosition, v, audio)
             } else {
-                doPlay(position, audio)
+                doPlay(holder.bindingAdapterPosition, audio)
             }
         }
         holder.Track.setOnLongClickListener { v: View? ->
@@ -500,9 +500,9 @@ class AudioLocalServerRecyclerAdapter(
             holder.cancelSelectionAnimation()
             holder.startSomeAnimation()
             if (Settings.get().main().isRevert_play_audio) {
-                doPlay(position, audio)
+                doPlay(holder.bindingAdapterPosition, audio)
             } else {
-                doMenu(holder, position, view, audio)
+                doMenu(holder, holder.bindingAdapterPosition, view, audio)
             }
         }
     }
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/localserver/filemanagerremote/FileManagerRemoteAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/localserver/filemanagerremote/FileManagerRemoteAdapter.kt
index cfaf73475..c30f4524e 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/localserver/filemanagerremote/FileManagerRemoteAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/localserver/filemanagerremote/FileManagerRemoteAdapter.kt
@@ -482,7 +482,7 @@ class FileManagerRemoteAdapter(private var context: Context, private var data: L
             }
         }
         holder.itemView.setOnLongClickListener {
-            doAudioMenu(position, item, it)
+            doAudioMenu(holder.bindingAdapterPosition, item, it)
             true
         }
         updateAudioStatus(holder, item)
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/logs/LogsAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/logs/LogsAdapter.kt
index 6867e787c..930079d48 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/logs/LogsAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/logs/LogsAdapter.kt
@@ -32,7 +32,7 @@ class LogsAdapter(data: MutableList<LogEventWrapper>, private val actionListener
     }
 
     private fun canReduce(body: String?): Boolean {
-        return Utils.safeLenghtOf(body) > MAX_BODY_LENGHT
+        return Utils.safeLenghtOf(body) > MAX_BODY_LENGTH
     }
 
     private fun setupBodyRoot(holder: Holder, wrapper: LogEventWrapper) {
@@ -43,7 +43,7 @@ class LogsAdapter(data: MutableList<LogEventWrapper>, private val actionListener
             holder.body.text = body
         } else {
             holder.buttonExpand.visibility = View.VISIBLE
-            holder.body.text = AppTextUtils.reduceText(body, MAX_BODY_LENGHT)
+            holder.body.text = AppTextUtils.reduceText(body, MAX_BODY_LENGTH)
         }
     }
 
@@ -71,6 +71,6 @@ class LogsAdapter(data: MutableList<LogEventWrapper>, private val actionListener
     }
 
     companion object {
-        private const val MAX_BODY_LENGHT = 400
+        private const val MAX_BODY_LENGTH = 400
     }
 }
\ No newline at end of file
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/messages/chat/MessagesAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/messages/chat/MessagesAdapter.kt
index 39b54a18d..7eff03ae0 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/messages/chat/MessagesAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/messages/chat/MessagesAdapter.kt
@@ -85,34 +85,34 @@ class MessagesAdapter(
     ) {
         val message = getItem(position)
         when (type) {
-            TYPE_SERVICE -> bindServiceHolder(viewHolder as ServiceMessageHolder, message, position)
+            TYPE_SERVICE -> bindServiceHolder(viewHolder as ServiceMessageHolder, message)
             TYPE_GRAFFITI_FRIEND, TYPE_GRAFFITI_MY, TYPE_MY_MESSAGE, TYPE_FRIEND_MESSAGE -> bindNormalMessage(
                 viewHolder as MessageHolder,
-                message,
-                position
+                message
             )
 
             TYPE_STICKER_FRIEND, TYPE_STICKER_MY -> bindStickerHolder(
                 viewHolder as StickerMessageHolder,
-                message,
-                position
+                message
             )
 
             TYPE_GIFT_FRIEND, TYPE_GIFT_MY -> bindGiftHolder(
                 viewHolder as GiftMessageHolder,
-                message,
-                position
+                message
             )
         }
     }
 
-    private fun bindStickerHolder(holder: StickerMessageHolder, message: Message, position: Int) {
-        bindBaseMessageHolder(holder, message, position)
+    private fun bindStickerHolder(holder: StickerMessageHolder, message: Message) {
+        bindBaseMessageHolder(holder, message)
         if (message.isDeleted) {
             holder.root.alpha = 0.6f
             holder.Restore.visibility = View.VISIBLE
             holder.Restore.setOnClickListener {
-                onMessageActionListener?.onRestoreClick(message, holder.bindingAdapterPosition)
+                onMessageActionListener?.onRestoreClick(
+                    message,
+                    getItemRawPosition(holder.bindingAdapterPosition)
+                )
             }
         } else {
             holder.root.alpha = 1f
@@ -166,13 +166,16 @@ class MessagesAdapter(
         setItems(messages)
     }
 
-    private fun bindGiftHolder(holder: GiftMessageHolder, message: Message, position: Int) {
-        bindBaseMessageHolder(holder, message, position)
+    private fun bindGiftHolder(holder: GiftMessageHolder, message: Message) {
+        bindBaseMessageHolder(holder, message)
         if (message.isDeleted) {
             holder.root.alpha = 0.6f
             holder.Restore.visibility = View.VISIBLE
             holder.Restore.setOnClickListener {
-                onMessageActionListener?.onRestoreClick(message, holder.bindingAdapterPosition)
+                onMessageActionListener?.onRestoreClick(
+                    message,
+                    getItemRawPosition(holder.bindingAdapterPosition)
+                )
             }
         } else {
             holder.root.alpha = 1f
@@ -251,7 +254,7 @@ class MessagesAdapter(
         root.background.alpha = 60
     }
 
-    private fun bindBaseMessageHolder(holder: BaseMessageHolder, message: Message, position: Int) {
+    private fun bindBaseMessageHolder(holder: BaseMessageHolder, message: Message) {
         holder.important.visibility = if (message.isImportant) View.VISIBLE else View.GONE
         bindStatusText(holder.status, message.status, message.date, message.updateTime)
         var read =
@@ -270,22 +273,36 @@ class MessagesAdapter(
         }
         if (holder.user != null) holder.user.text = message.sender?.fullName
         holder.avatar.setOnClickListener {
-            onMessageActionListener?.onAvatarClick(message, message.senderId, position)
+            onMessageActionListener?.onAvatarClick(
+                message,
+                message.senderId,
+                getItemRawPosition(holder.bindingAdapterPosition)
+            )
         }
         holder.avatar.setOnLongClickListener {
-            onMessageActionListener?.onLongAvatarClick(message, message.senderId, position)
+            onMessageActionListener?.onLongAvatarClick(
+                message,
+                message.senderId,
+                getItemRawPosition(holder.bindingAdapterPosition)
+            )
             true
         }
         holder.itemView.setOnClickListener {
-            onMessageActionListener?.onMessageClicked(message, position)
+            onMessageActionListener?.onMessageClicked(
+                message,
+                getItemRawPosition(holder.bindingAdapterPosition)
+            )
         }
         holder.itemView.setOnLongClickListener {
-            onMessageActionListener?.onMessageLongClick(message, position) == true
+            onMessageActionListener?.onMessageLongClick(
+                message,
+                getItemRawPosition(holder.bindingAdapterPosition)
+            ) == true
         }
     }
 
-    private fun bindNormalMessage(holder: MessageHolder, message: Message, position: Int) {
-        bindBaseMessageHolder(holder, message, position)
+    private fun bindNormalMessage(holder: MessageHolder, message: Message) {
+        bindBaseMessageHolder(holder, message)
         if (holder.botKeyboardView != null && message.keyboard?.inline == true && message.keyboard?.buttons?.size.orZero() > 0) {
             holder.botKeyboardView.visibility = View.VISIBLE
             holder.botKeyboardView.setButtons(message.keyboard?.buttons, false)
@@ -301,7 +318,10 @@ class MessagesAdapter(
             holder.root.alpha = 0.6f
             holder.Restore.visibility = View.VISIBLE
             holder.Restore.setOnClickListener {
-                onMessageActionListener?.onRestoreClick(message, holder.bindingAdapterPosition)
+                onMessageActionListener?.onRestoreClick(
+                    message,
+                    getItemRawPosition(holder.bindingAdapterPosition)
+                )
             }
         } else {
             holder.root.alpha = 1f
@@ -382,16 +402,19 @@ class MessagesAdapter(
         }
     }
 
-    private fun bindServiceHolder(holder: ServiceMessageHolder, message: Message, position: Int) {
+    private fun bindServiceHolder(holder: ServiceMessageHolder, message: Message) {
         if (message.isDeleted) {
             holder.root.alpha = 0.6f
-            holder.Restore.visibility = View.VISIBLE
-            holder.Restore.setOnClickListener {
-                onMessageActionListener?.onRestoreClick(message, holder.bindingAdapterPosition)
+            holder.bRestore.visibility = View.VISIBLE
+            holder.bRestore.setOnClickListener {
+                onMessageActionListener?.onRestoreClick(
+                    message,
+                    getItemRawPosition(holder.bindingAdapterPosition)
+                )
             }
         } else {
             holder.root.alpha = 1f
-            holder.Restore.visibility = View.GONE
+            holder.bRestore.visibility = View.GONE
         }
         if (message.keyboard?.inline == true && message.keyboard?.buttons?.size.orZero() > 0) {
             holder.botKeyboardView.visibility = View.VISIBLE
@@ -410,7 +433,10 @@ class MessagesAdapter(
         bindReadState(holder.itemView, message.status == MessageStatus.SENT && read)
         holder.tvAction.text = message.getServiceText(context)
         holder.itemView.setOnClickListener {
-            onMessageActionListener?.onMessageClicked(message, position)
+            onMessageActionListener?.onMessageClicked(
+                message,
+                getItemRawPosition(holder.bindingAdapterPosition)
+            )
         }
         holder.itemView.setOnLongClickListener {
             onMessageActionListener?.onMessageDelete(message)
@@ -527,7 +553,7 @@ class MessagesAdapter(
         val attachmentsRoot: View = itemView.findViewById(R.id.item_message_attachment_container)
         val mAttachmentsHolder: AttachmentsHolder = AttachmentsHolder()
         val botKeyboardView: BotKeyboardView = itemView.findViewById(R.id.input_keyboard_container)
-        val Restore: Button = itemView.findViewById(R.id.item_message_restore)
+        val bRestore: Button = itemView.findViewById(R.id.item_message_restore)
 
         init {
             mAttachmentsHolder.setVgAudios(itemView.findViewById(R.id.audio_attachments))
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/ownerarticles/OwnerArticlesAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/ownerarticles/OwnerArticlesAdapter.kt
index 1ec5385fc..1841d11e4 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/ownerarticles/OwnerArticlesAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/ownerarticles/OwnerArticlesAdapter.kt
@@ -28,9 +28,9 @@ class OwnerArticlesAdapter(private var data: List<Article>, private val context:
         holder.btFave.setImageResource(if (article.isFavorite) R.drawable.favorite else R.drawable.star_add)
         holder.btFave.setOnClickListener {
             if (article.isFavorite) {
-                clickListener?.onDelete(position, article)
+                clickListener?.onDelete(holder.bindingAdapterPosition, article)
             } else {
-                clickListener?.onAdd(position, article)
+                clickListener?.onAdd(holder.bindingAdapterPosition, article)
             }
         }
         holder.btShare.setOnClickListener { clickListener?.onShare(article) }
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/theme/ThemeAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/theme/ThemeAdapter.kt
index 506231ed5..4850e3365 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/theme/ThemeAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/theme/ThemeAdapter.kt
@@ -95,7 +95,7 @@ class ThemeAdapter(private var data: List<ThemeValue>, context: Context) :
             }
         }
         holder.clicked.setOnClickListener {
-            clickListener?.onClick(position, category)
+            clickListener?.onClick(holder.bindingAdapterPosition, category)
         }
     }
 
@@ -133,7 +133,7 @@ class ThemeAdapter(private var data: List<ThemeValue>, context: Context) :
             }
         }
         holder.clicked.setOnClickListener {
-            clickListener?.onClick(position, category)
+            clickListener?.onClick(holder.bindingAdapterPosition, category)
         }
         holder.gradient.background = GradientDrawable(
             GradientDrawable.Orientation.TL_BR,
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/topics/TopicsAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/topics/TopicsAdapter.kt
index 23223eac5..52ee6782d 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/topics/TopicsAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/topics/TopicsAdapter.kt
@@ -27,7 +27,7 @@ class TopicsAdapter(
     private val transformation: Transformation = CurrentTheme.createTransformationForAvatar()
     private var firstLastPadding = 0
     override fun onBindItemViewHolder(viewHolder: ViewHolder, position: Int, type: Int) {
-        val item = getItem(position - headersCount)
+        val item = getItem(position)
         val context = viewHolder.itemView.context
         viewHolder.title.text = item.title
         viewHolder.subtitle.text = context.getString(
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/videos/VideosAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/videos/VideosAdapter.kt
index daa522147..9cf13fb1e 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/videos/VideosAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/videos/VideosAdapter.kt
@@ -44,11 +44,11 @@ class VideosAdapter(private val context: Context, private var data: List<Video>)
             holder.videoService.visibility = View.GONE
         }
         holder.card.setOnClickListener {
-            videoOnClickListener?.onVideoClick(position, video)
+            videoOnClickListener?.onVideoClick(holder.bindingAdapterPosition, video)
         }
         holder.card.setOnLongClickListener {
             videoOnClickListener?.onVideoLongClick(
-                position,
+                holder.bindingAdapterPosition,
                 video
             ) == true
         }
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/wallattachments/walllinksattachments/LinksAdapter.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/wallattachments/walllinksattachments/LinksAdapter.kt
index 594a13884..a130f249b 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/wallattachments/walllinksattachments/LinksAdapter.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/fragment/wallattachments/walllinksattachments/LinksAdapter.kt
@@ -58,7 +58,10 @@ class LinksAdapter(data: MutableList<Link>) :
             viewHolder.ivEmpty.visibility = View.VISIBLE
         }
         viewHolder.itemView.setOnClickListener {
-            mActionListener?.onLinkClick(viewHolder.bindingAdapterPosition, item)
+            mActionListener?.onLinkClick(
+                getItemRawPosition(viewHolder.bindingAdapterPosition),
+                item
+            )
         }
         viewHolder.itemView.setOnLongClickListener {
             linkConversationListener ?: return@setOnLongClickListener false
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/Video2WallUploadable.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/Video2WallUploadable.kt
index 20be151d7..5188cc5ff 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/Video2WallUploadable.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/Video2WallUploadable.kt
@@ -37,7 +37,7 @@ class Video2WallUploadable(
         val ownerId = upload.destination.ownerId
         val groupId = if (ownerId < 0) abs(ownerId) else null
         val serverSingle = networker.vkDefault(accountId)
-            .docs()
+            .video()
             .getVideoServer(1, groupId, UploadUtils.findFileName(context, upload.fileUri))
             .map<UploadServer> { s: VKApiVideosUploadServer -> s }
         return serverSingle.flatMap { server ->
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/VideoToMessageUploadable.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/VideoToMessageUploadable.kt
index 23845a1be..494d2769a 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/VideoToMessageUploadable.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/VideoToMessageUploadable.kt
@@ -36,7 +36,7 @@ class VideoToMessageUploadable(
         val accountId = upload.accountId
         val messageId = upload.destination.id
         val serverSingle = networker.vkDefault(accountId)
-            .docs()
+            .video()
             .getVideoServer(1, null, UploadUtils.findFileName(context, upload.fileUri))
             .map<UploadServer> { s: VKApiVideosUploadServer -> s }
         return serverSingle.flatMap { server ->
diff --git a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/VideoUploadable.kt b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/VideoUploadable.kt
index 27ed2bbf6..432e992a2 100644
--- a/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/VideoUploadable.kt
+++ b/app_fenrir/src/main/kotlin/dev/ragnarok/fenrir/upload/impl/VideoUploadable.kt
@@ -30,7 +30,7 @@ class VideoUploadable(private val context: Context, private val networker: INetw
         val groupId = if (ownerId >= 0) null else ownerId
         val isPrivate = upload.destination.id == 0
         val serverSingle = networker.vkDefault(accountId)
-            .docs()
+            .video()
             .getVideoServer(
                 if (isPrivate) 1 else 0, groupId, UploadUtils.findFileName(
                     context, upload.fileUri
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/Constants.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/Constants.kt
index bc6edca44..a6fcd0975 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/Constants.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/Constants.kt
@@ -27,7 +27,8 @@ object Constants {
     const val AUDIO_PLAYER_SERVICE_IDLE = 300000
     const val FILE_PROVIDER_AUTHORITY = APPLICATION_ID + ".file_provider"
 
-    const val API_TIMEOUT = 60L
+    const val API_TIMEOUT = 25L
+    const val UPLOAD_TIMEOUT = 60L
     const val EXO_PLAYER_TIMEOUT = 60L
     const val DOWNLOAD_TIMEOUT = 3600L
     const val PICASSO_TIMEOUT = 15L
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/IPhotoPagerView.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/IPhotoPagerView.kt
index 60cb0c167..8d5944ecc 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/IPhotoPagerView.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/IPhotoPagerView.kt
@@ -18,4 +18,5 @@ interface IPhotoPagerView : IMvpView, IErrorView, IToastView {
     fun returnOnlyPos(position: Int)
     fun returnFileInfo(path: String)
     fun displayVideo(video: Video)
+    fun setupOptionMenu(isLocal: Boolean)
 }
\ No newline at end of file
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/PhotoPagerActivity.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/PhotoPagerActivity.kt
index c09b23daa..1b6c91930 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/PhotoPagerActivity.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/PhotoPagerActivity.kt
@@ -15,13 +15,16 @@ import androidx.annotation.ColorInt
 import androidx.annotation.IdRes
 import androidx.annotation.LayoutRes
 import androidx.appcompat.widget.Toolbar
+import androidx.core.content.FileProvider
 import androidx.core.net.toFile
+import androidx.core.view.MenuProvider
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import androidx.viewpager2.widget.ViewPager2
 import com.google.android.material.floatingactionbutton.FloatingActionButton
 import com.squareup.picasso3.Callback
 import com.squareup.picasso3.Rotatable
+import dev.ragnarok.filegallery.Constants
 import dev.ragnarok.filegallery.Extra
 import dev.ragnarok.filegallery.R
 import dev.ragnarok.filegallery.StubAnimatorListener
@@ -57,7 +60,7 @@ import java.util.concurrent.TimeUnit
 
 
 class PhotoPagerActivity : BaseMvpActivity<PhotoPagerPresenter, IPhotoPagerView>(), IPhotoPagerView,
-    PlaceProvider, AppStyleable {
+    PlaceProvider, AppStyleable, MenuProvider {
     companion object {
         private const val EXTRA_PHOTOS = "photos"
         private const val ACTION_OPEN =
@@ -105,6 +108,7 @@ class PhotoPagerActivity : BaseMvpActivity<PhotoPagerPresenter, IPhotoPagerView>
     private var mPagerAdapter: Adapter? = null
     private val bShowPhotosLine = Settings.get().main().isShow_photos_line()
     private val mAdapterRecycler = ImageListAdapter()
+    private var isLocalPhoto = false
 
     @get:LayoutRes
     override val noMainContentView: Int
@@ -186,7 +190,7 @@ class PhotoPagerActivity : BaseMvpActivity<PhotoPagerPresenter, IPhotoPagerView>
                 }
             }
         })
-
+        addMenuProvider(this, this)
         if (bShowPhotosLine) {
             mPreviewsRecycler?.layoutManager =
                 LinearLayoutManager(this, LinearLayoutManager.HORIZONTAL, false)
@@ -223,22 +227,69 @@ class PhotoPagerActivity : BaseMvpActivity<PhotoPagerPresenter, IPhotoPagerView>
         }
     }
 
-    override fun onCreateOptionsMenu(menu: Menu): Boolean {
-        super.onCreateOptionsMenu(menu)
+    override fun onPrepareMenu(menu: Menu) {
+        menu.findItem(R.id.save_on_drive).isVisible = !isLocalPhoto
+        if (!isLocalPhoto) {
+            menu.findItem(R.id.start_select_mode).isVisible = false
+            menu.findItem(R.id.end_select_mode).isVisible = false
+            menu.findItem(R.id.send_action).isVisible = false
+        } else {
+            menu.findItem(R.id.start_select_mode).isVisible = !Utils.shouldSelectPhoto
+            menu.findItem(R.id.end_select_mode).isVisible = Utils.shouldSelectPhoto
+            menu.findItem(R.id.send_action).isVisible =
+                Utils.shouldSelectPhoto && Utils.listSelected.isNotEmpty()
+        }
+    }
+
+    override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
         menuInflater.inflate(R.menu.photo_menu, menu)
-        return true
     }
 
-    override fun onOptionsItemSelected(item: MenuItem): Boolean {
-        when (item.itemId) {
+    override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
+        when (menuItem.itemId) {
             R.id.save_on_drive -> {
                 presenter?.fireSaveOnDriveClick()
                 return true
             }
 
-            R.id.detect_qr -> presenter?.fireDetectQRClick(this)
+            R.id.detect_qr -> {
+                presenter?.fireDetectQRClick(this)
+                return true
+            }
+
+            R.id.start_select_mode -> {
+                Utils.shouldSelectPhoto = true
+                return true
+            }
+
+            R.id.end_select_mode -> {
+                Utils.shouldSelectPhoto = false
+                Utils.listSelected.clear()
+                mPagerAdapter?.notifyDataSetChanged()
+                return true
+            }
+
+            R.id.send_action -> {
+                val intent_send = Intent(Intent.ACTION_SEND_MULTIPLE)
+                intent_send.type = "image/*"
+                val listImage: ArrayList<Uri> = ArrayList(Utils.listSelected.size)
+                for (i in Utils.listSelected) {
+                    listImage.add(
+                        FileProvider.getUriForFile(
+                            this,
+                            Constants.FILE_PROVIDER_AUTHORITY,
+                            Uri.parse(i).toFile()
+                        )
+                    )
+                }
+                intent_send.putParcelableArrayListExtra(
+                    Intent.EXTRA_STREAM, listImage
+                ).addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                startActivity(intent_send)
+                return true
+            }
         }
-        return super.onOptionsItemSelected(item)
+        return false
     }
 
     override fun getPresenterFactory(saveInstanceState: Bundle?): IPresenterFactory<PhotoPagerPresenter> =
@@ -360,6 +411,11 @@ class PhotoPagerActivity : BaseMvpActivity<PhotoPagerPresenter, IPhotoPagerView>
         PlaceFactory.getInternalPlayerPlace(video).tryOpenWith(this)
     }
 
+    override fun setupOptionMenu(isLocal: Boolean) {
+        isLocalPhoto = isLocal
+        this.invalidateOptionsMenu()
+    }
+
     @Suppress("DEPRECATION")
     override fun setStatusbarColored(colored: Boolean, invertIcons: Boolean) {
         val statusbarNonColored = CurrentTheme.getStatusBarNonColored(this)
@@ -406,11 +462,43 @@ class PhotoPagerActivity : BaseMvpActivity<PhotoPagerPresenter, IPhotoPagerView>
         val reload: FloatingActionButton
         private val mPicassoLoadCallback: WeakPicassoLoadCallback
         val photo: TouchImageView
+        val selected: View
         val progress: RLottieImageView
         var animationDispose: Disposable = Disposable.disposed()
         private var mAnimationLoaded = false
         private var mLoadingNow = false
         fun bindTo(photo_image: Photo) {
+            selected.visibility =
+                if (Utils.shouldSelectPhoto && photo_image.inLocal() && Utils.listSelected.contains(
+                        photo_image.photo_url
+                    )
+                ) View.VISIBLE else View.GONE
+            photo.setOnLongClickListener {
+                if (Utils.shouldSelectPhoto) {
+                    if (photo_image.inLocal()) {
+                        if (Utils.listSelected.contains(photo_image.photo_url)) {
+                            Utils.listSelected.remove(photo_image.photo_url)
+                            selected.visibility = View.GONE
+                        } else {
+                            photo_image.photo_url?.let { it1 -> Utils.listSelected.add(it1) }
+                            selected.visibility = View.VISIBLE
+                        }
+                    }
+                    true
+                } else {
+                    val o = presenter?.fireSaveOnDriveClick()
+                    if (o == true && photo.drawable is Rotatable) {
+                        var rot = (photo.drawable as Rotatable).getRotation() + 45f
+                        if (rot >= 360f) {
+                            rot = 0f
+                        }
+                        (photo.drawable as Rotatable).rotate(rot)
+                        photo.fitImageToView()
+                        photo.invalidate()
+                    }
+                    true
+                }
+            }
             photo.resetZoom()
             reload.setOnClickListener {
                 reload.visibility = View.INVISIBLE
@@ -511,6 +599,7 @@ class PhotoPagerActivity : BaseMvpActivity<PhotoPagerPresenter, IPhotoPagerView>
 
         init {
             photo = view.findViewById(idOfImageView())
+            selected = view.findViewById(R.id.selected_view)
             photo.maxZoom = 8f
             photo.doubleTapScale = 2f
             photo.doubleTapMaxZoom = 4f
@@ -529,19 +618,6 @@ class PhotoPagerActivity : BaseMvpActivity<PhotoPagerPresenter, IPhotoPagerView>
                 LayoutInflater.from(container.context)
                     .inflate(R.layout.content_photo_page, container, false)
             )
-            ret.photo.setOnLongClickListener {
-                val o = presenter?.fireSaveOnDriveClick()
-                if (o == true && ret.photo.drawable is Rotatable) {
-                    var rot = (ret.photo.drawable as Rotatable).getRotation() + 45f
-                    if (rot >= 360f) {
-                        rot = 0f
-                    }
-                    (ret.photo.drawable as Rotatable).rotate(rot)
-                    ret.photo.fitImageToView()
-                    ret.photo.invalidate()
-                }
-                true
-            }
             ret.photo.setOnTouchListener { view: View, event: MotionEvent ->
                 if (event.pointerCount >= 2 || view.canScrollHorizontally(1) && view.canScrollHorizontally(
                         -1
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/PhotoPagerPresenter.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/PhotoPagerPresenter.kt
index f48328813..669baa10d 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/PhotoPagerPresenter.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/activity/photopager/PhotoPagerPresenter.kt
@@ -105,6 +105,7 @@ open class PhotoPagerPresenter internal constructor(
 
     private fun onPositionChanged() {
         refreshInfoViews()
+        view?.let { resolveOptionMenu(it) }
     }
 
     fun refreshInfoViews() {
@@ -310,6 +311,21 @@ open class PhotoPagerPresenter internal constructor(
         view?.setToolbarVisible(hasPhotos() && !mFullScreen)
     }
 
+    override fun onViewHostAttached(view: IPhotoPagerView) {
+        super.onViewHostAttached(view)
+        resolveOptionMenu(view)
+    }
+
+    private fun isLocal(): Boolean {
+        return hasPhotos() && current.inLocal()
+    }
+
+    private fun resolveOptionMenu(view: IPhotoPagerView) {
+        view.setupOptionMenu(
+            isLocal()
+        )
+    }
+
     val currentFile: String
         get() = Uri.parse(mPhotos[currentIndex].photo_url).toFile().absolutePath
 
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/HttpLoggerAndParser.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/HttpLoggerAndParser.kt
index 844c0e044..bfff1eb82 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/HttpLoggerAndParser.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/HttpLoggerAndParser.kt
@@ -38,16 +38,34 @@ object HttpLoggerAndParser {
         return this
     }
 
-    val DEFAULT_LOGGING_INTERCEPTOR: OkHttp3LoggingInterceptor by lazy {
+    private val DEFAULT_LOGGING_INTERCEPTOR: OkHttp3LoggingInterceptor by lazy {
+        OkHttp3LoggingInterceptor().setLevel(OkHttp3LoggingInterceptor.Level.BODY)
+    }
+
+    private val UPLOAD_LOGGING_INTERCEPTOR: OkHttp3LoggingInterceptor by lazy {
+        //OkHttp3LoggingInterceptor().setLevel(OkHttp3LoggingInterceptor.Level.HEADERS)
         OkHttp3LoggingInterceptor().setLevel(OkHttp3LoggingInterceptor.Level.BODY)
     }
 
     fun adjust(builder: OkHttpClient.Builder) {
         if (Constants.IS_DEBUG) {
+            /*
+            if (Settings.get().other().currentParser == ParserType.JSON) {
+                builder.addInterceptor(DEFAULT_LOGGING_INTERCEPTOR)
+            } else {
+                builder.addInterceptor(UPLOAD_LOGGING_INTERCEPTOR)
+            }
+             */
             builder.addInterceptor(DEFAULT_LOGGING_INTERCEPTOR)
         }
     }
 
+    fun adjustUpload(builder: OkHttpClient.Builder) {
+        if (Constants.IS_DEBUG) {
+            builder.addInterceptor(UPLOAD_LOGGING_INTERCEPTOR)
+        }
+    }
+
     fun configureToIgnoreCertificates(builder: OkHttpClient.Builder) {
         if (Settings.get().main().isValidate_tls) {
             return
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/IOtherRestProvider.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/ILocalServerRestProvider.kt
similarity index 83%
rename from app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/IOtherRestProvider.kt
rename to app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/ILocalServerRestProvider.kt
index 93c3b62b8..10f84fc01 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/IOtherRestProvider.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/ILocalServerRestProvider.kt
@@ -3,6 +3,6 @@ package dev.ragnarok.filegallery.api
 import dev.ragnarok.filegallery.api.rest.SimplePostHttp
 import io.reactivex.rxjava3.core.Single
 
-interface IOtherRestProvider {
+interface ILocalServerRestProvider {
     fun provideLocalServerRest(): Single<SimplePostHttp>
 }
\ No newline at end of file
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/IUploadRestProvider.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/IUploadRestProvider.kt
new file mode 100644
index 000000000..cfce36199
--- /dev/null
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/IUploadRestProvider.kt
@@ -0,0 +1,8 @@
+package dev.ragnarok.filegallery.api
+
+import dev.ragnarok.filegallery.api.rest.SimplePostHttp
+import io.reactivex.rxjava3.core.Single
+
+interface IUploadRestProvider {
+    fun provideUploadRest(): Single<SimplePostHttp>
+}
\ No newline at end of file
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/OtherRestProvider.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/LocalServerRestProvider.kt
similarity index 95%
rename from app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/OtherRestProvider.kt
rename to app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/LocalServerRestProvider.kt
index 1a443bf89..3f5cb509e 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/OtherRestProvider.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/LocalServerRestProvider.kt
@@ -15,8 +15,8 @@ import okhttp3.MultipartBody
 import okhttp3.OkHttpClient
 import java.util.concurrent.TimeUnit
 
-class OtherRestProvider @SuppressLint("CheckResult") constructor(private val mainSettings: IMainSettings) :
-    IOtherRestProvider {
+class LocalServerRestProvider @SuppressLint("CheckResult") constructor(private val mainSettings: IMainSettings) :
+    ILocalServerRestProvider {
     private val localServerRestLock = Any()
     private var localServerRestInstance: SimplePostHttp? = null
     private fun onLocalServerSettingsChanged() {
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/UploadRestProvider.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/UploadRestProvider.kt
new file mode 100644
index 000000000..ac5832e11
--- /dev/null
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/UploadRestProvider.kt
@@ -0,0 +1,90 @@
+package dev.ragnarok.filegallery.api
+
+import android.annotation.SuppressLint
+import dev.ragnarok.filegallery.Constants
+import dev.ragnarok.filegallery.api.HttpLoggerAndParser.serverHeader
+import dev.ragnarok.filegallery.api.rest.SimplePostHttp
+import dev.ragnarok.filegallery.nonNullNoEmpty
+import dev.ragnarok.filegallery.settings.ISettings
+import dev.ragnarok.filegallery.util.UncompressDefaultInterceptor
+import dev.ragnarok.filegallery.util.Utils
+import io.reactivex.rxjava3.core.Single
+import okhttp3.FormBody
+import okhttp3.Interceptor
+import okhttp3.MultipartBody
+import okhttp3.OkHttpClient
+import java.util.concurrent.TimeUnit
+
+@SuppressLint("CheckResult")
+class UploadRestProvider(private val mainSettings: ISettings.IMainSettings) : IUploadRestProvider {
+    private val uploadRestLock = Any()
+
+    @Volatile
+    private var uploadRestInstance: SimplePostHttp? = null
+    private fun onLocalServerSettingsChanged() {
+        synchronized(uploadRestLock) {
+            if (uploadRestInstance != null) {
+                uploadRestInstance?.stop()
+                uploadRestInstance = null
+            }
+        }
+    }
+
+    override fun provideUploadRest(): Single<SimplePostHttp> {
+        return Single.fromCallable {
+            if (uploadRestInstance == null) {
+                synchronized(uploadRestLock) {
+                    if (uploadRestInstance == null) {
+                        uploadRestInstance = createUploadRest()
+                    }
+                }
+            }
+            uploadRestInstance!!
+        }
+    }
+
+    private fun createUploadRest(): SimplePostHttp {
+        val localSettings = mainSettings.getLocalServer()
+        val builder: OkHttpClient.Builder = OkHttpClient.Builder()
+            .readTimeout(Constants.UPLOAD_TIMEOUT, TimeUnit.SECONDS)
+            .connectTimeout(Constants.UPLOAD_TIMEOUT, TimeUnit.SECONDS)
+            .writeTimeout(Constants.UPLOAD_TIMEOUT, TimeUnit.SECONDS)
+            .callTimeout(Constants.UPLOAD_TIMEOUT, TimeUnit.SECONDS)
+            .addInterceptor(Interceptor { chain: Interceptor.Chain ->
+                val request =
+                    chain.request().newBuilder().serverHeader(false)
+                        .addHeader("User-Agent", Constants.USER_AGENT)
+                        .build()
+                chain.proceed(request)
+            }).addInterceptor(Interceptor { chain: Interceptor.Chain ->
+                if (chain.request().body is MultipartBody) {
+                    return@Interceptor chain.proceed(chain.request())
+                }
+                val original = chain.request()
+                val formBuilder = FormBody.Builder()
+                val body = original.body
+                if (body is FormBody) {
+                    for (i in 0 until body.size) {
+                        formBuilder.add(body.name(i), body.value(i))
+                    }
+                }
+                localSettings.password.nonNullNoEmpty {
+                    formBuilder.add("password", it)
+                }
+                val request = original.newBuilder()
+                    .post(formBuilder.build())
+                    .build()
+                chain.proceed(request)
+            })
+            .addInterceptor(UncompressDefaultInterceptor)
+        HttpLoggerAndParser.adjustUpload(builder)
+        HttpLoggerAndParser.configureToIgnoreCertificates(builder)
+        val url = Utils.firstNonEmptyString(localSettings.url, "https://debug.dev")!!
+        return SimplePostHttp("$url/method", builder)
+    }
+
+    init {
+        mainSettings.observeLocalServer()
+            .subscribe { onLocalServerSettingsChanged() }
+    }
+}
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/impl/LocalServerApi.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/impl/LocalServerApi.kt
index 47b68436e..f06dcc5cf 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/impl/LocalServerApi.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/impl/LocalServerApi.kt
@@ -16,9 +16,6 @@ import dev.ragnarok.filegallery.util.Utils.firstNonEmptyString
 import io.reactivex.rxjava3.core.Single
 import io.reactivex.rxjava3.exceptions.Exceptions
 import io.reactivex.rxjava3.functions.Function
-import okhttp3.MediaType.Companion.toMediaTypeOrNull
-import okhttp3.MultipartBody
-import java.io.InputStream
 
 internal class LocalServerApi(private val service: ILocalServerServiceProvider) : ILocalServerApi {
     override fun getVideos(offset: Int?, count: Int?, reverse: Boolean): Single<List<Video>> {
@@ -220,19 +217,4 @@ internal class LocalServerApi(private val service: ILocalServerServiceProvider)
             }
         }
     }
-
-    override fun remotePlayAudioRx(
-        server: String,
-        filename: String?,
-        inputStream: InputStream,
-        listener: PercentagePublisher?
-    ): Single<BaseResponse<Int>> {
-        val body = ProgressRequestBody(
-            inputStream, wrapPercentageListener(listener),
-            "*/*".toMediaTypeOrNull()
-        )
-        val part: MultipartBody.Part = MultipartBody.Part.createFormData("audio", filename, body)
-        return service.provideLocalServerService()
-            .flatMap { it.remotePlayAudioRx(server, part) }
-    }
 }
\ No newline at end of file
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/impl/Networker.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/impl/Networker.kt
index 827c88cad..175d92b7d 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/impl/Networker.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/impl/Networker.kt
@@ -1,20 +1,24 @@
 package dev.ragnarok.filegallery.api.impl
 
+import dev.ragnarok.filegallery.api.ILocalServerRestProvider
 import dev.ragnarok.filegallery.api.ILocalServerServiceProvider
-import dev.ragnarok.filegallery.api.IOtherRestProvider
-import dev.ragnarok.filegallery.api.OtherRestProvider
+import dev.ragnarok.filegallery.api.IUploadRestProvider
+import dev.ragnarok.filegallery.api.LocalServerRestProvider
+import dev.ragnarok.filegallery.api.UploadRestProvider
 import dev.ragnarok.filegallery.api.interfaces.ILocalServerApi
 import dev.ragnarok.filegallery.api.interfaces.INetworker
+import dev.ragnarok.filegallery.api.interfaces.IUploadApi
 import dev.ragnarok.filegallery.api.services.ILocalServerService
 import dev.ragnarok.filegallery.settings.ISettings.IMainSettings
 import io.reactivex.rxjava3.core.Single
 
 class Networker(settings: IMainSettings) : INetworker {
-    private val otherVkRestProvider: IOtherRestProvider
+    private val localServerRestProvider: ILocalServerRestProvider
+    private val uploadRestProvider: IUploadRestProvider
     override fun localServerApi(): ILocalServerApi {
         return LocalServerApi(object : ILocalServerServiceProvider {
             override fun provideLocalServerService(): Single<ILocalServerService> {
-                return otherVkRestProvider.provideLocalServerRest()
+                return localServerRestProvider.provideLocalServerRest()
                     .map {
                         val ret = ILocalServerService()
                         ret.addon(it)
@@ -24,7 +28,12 @@ class Networker(settings: IMainSettings) : INetworker {
         })
     }
 
+    override fun uploads(): IUploadApi {
+        return UploadApi(uploadRestProvider)
+    }
+
     init {
-        otherVkRestProvider = OtherRestProvider(settings)
+        localServerRestProvider = LocalServerRestProvider(settings)
+        uploadRestProvider = UploadRestProvider(settings)
     }
 }
\ No newline at end of file
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/impl/UploadApi.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/impl/UploadApi.kt
new file mode 100644
index 000000000..51031ad9b
--- /dev/null
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/impl/UploadApi.kt
@@ -0,0 +1,37 @@
+package dev.ragnarok.filegallery.api.impl
+
+import dev.ragnarok.filegallery.api.IUploadRestProvider
+import dev.ragnarok.filegallery.api.PercentagePublisher
+import dev.ragnarok.filegallery.api.interfaces.IUploadApi
+import dev.ragnarok.filegallery.api.model.response.BaseResponse
+import dev.ragnarok.filegallery.api.services.IUploadService
+import dev.ragnarok.filegallery.api.util.ProgressRequestBody
+import io.reactivex.rxjava3.core.Single
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import okhttp3.MultipartBody
+import java.io.InputStream
+
+class UploadApi internal constructor(private val provider: IUploadRestProvider) : IUploadApi {
+    private fun service(): Single<IUploadService> {
+        return provider.provideUploadRest().map {
+            val ret = IUploadService()
+            ret.addon(it)
+            ret
+        }
+    }
+
+    override fun remotePlayAudioRx(
+        server: String,
+        filename: String?,
+        inputStream: InputStream,
+        listener: PercentagePublisher?
+    ): Single<BaseResponse<Int>> {
+        val body = ProgressRequestBody(
+            inputStream, LocalServerApi.wrapPercentageListener(listener),
+            "*/*".toMediaTypeOrNull()
+        )
+        val part: MultipartBody.Part = MultipartBody.Part.createFormData("audio", filename, body)
+        return service()
+            .flatMap { it.remotePlayAudioRx(server, part) }
+    }
+}
\ No newline at end of file
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/interfaces/ILocalServerApi.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/interfaces/ILocalServerApi.kt
index 1c0352648..ce2ac25da 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/interfaces/ILocalServerApi.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/interfaces/ILocalServerApi.kt
@@ -1,14 +1,11 @@
 package dev.ragnarok.filegallery.api.interfaces
 
 import androidx.annotation.CheckResult
-import dev.ragnarok.filegallery.api.PercentagePublisher
-import dev.ragnarok.filegallery.api.model.response.BaseResponse
 import dev.ragnarok.filegallery.model.Audio
 import dev.ragnarok.filegallery.model.FileRemote
 import dev.ragnarok.filegallery.model.Photo
 import dev.ragnarok.filegallery.model.Video
 import io.reactivex.rxjava3.core.Single
-import java.io.InputStream
 
 interface ILocalServerApi {
     @CheckResult
@@ -72,12 +69,4 @@ interface ILocalServerApi {
 
     @CheckResult
     fun rebootPC(type: String?): Single<Int>
-
-    @CheckResult
-    fun remotePlayAudioRx(
-        server: String,
-        filename: String?,
-        inputStream: InputStream,
-        listener: PercentagePublisher?
-    ): Single<BaseResponse<Int>>
 }
\ No newline at end of file
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/interfaces/INetworker.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/interfaces/INetworker.kt
index 443d978ab..507e40ec7 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/interfaces/INetworker.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/interfaces/INetworker.kt
@@ -2,4 +2,5 @@ package dev.ragnarok.filegallery.api.interfaces
 
 interface INetworker {
     fun localServerApi(): ILocalServerApi
+    fun uploads(): IUploadApi
 }
\ No newline at end of file
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/interfaces/IUploadApi.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/interfaces/IUploadApi.kt
new file mode 100644
index 000000000..953994732
--- /dev/null
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/interfaces/IUploadApi.kt
@@ -0,0 +1,17 @@
+package dev.ragnarok.filegallery.api.interfaces
+
+import androidx.annotation.CheckResult
+import dev.ragnarok.filegallery.api.PercentagePublisher
+import dev.ragnarok.filegallery.api.model.response.BaseResponse
+import io.reactivex.rxjava3.core.Single
+import java.io.InputStream
+
+interface IUploadApi {
+    @CheckResult
+    fun remotePlayAudioRx(
+        server: String,
+        filename: String?,
+        inputStream: InputStream,
+        listener: PercentagePublisher?
+    ): Single<BaseResponse<Int>>
+}
\ No newline at end of file
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/services/ILocalServerService.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/services/ILocalServerService.kt
index b1219320e..9bb2c6a8f 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/services/ILocalServerService.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/services/ILocalServerService.kt
@@ -8,7 +8,6 @@ import dev.ragnarok.filegallery.model.FileRemote
 import dev.ragnarok.filegallery.model.Photo
 import dev.ragnarok.filegallery.model.Video
 import io.reactivex.rxjava3.core.Single
-import okhttp3.MultipartBody
 
 class ILocalServerService : IServiceRest() {
     fun getAudios(
@@ -166,11 +165,4 @@ class ILocalServerService : IServiceRest() {
     ): Single<BaseResponse<Int>> {
         return rest.request("rebootPC", form("type" to type), baseInt)
     }
-
-    fun remotePlayAudioRx(
-        server: String,
-        file: MultipartBody.Part
-    ): Single<BaseResponse<Int>> {
-        return rest.doMultipartFormFullUrl(server, file, baseInt)
-    }
 }
\ No newline at end of file
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/services/IUploadService.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/services/IUploadService.kt
new file mode 100644
index 000000000..f34603521
--- /dev/null
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/api/services/IUploadService.kt
@@ -0,0 +1,15 @@
+package dev.ragnarok.filegallery.api.services
+
+import dev.ragnarok.filegallery.api.model.response.BaseResponse
+import dev.ragnarok.filegallery.api.rest.IServiceRest
+import io.reactivex.rxjava3.core.Single
+import okhttp3.MultipartBody
+
+class IUploadService : IServiceRest() {
+    fun remotePlayAudioRx(
+        server: String,
+        file: MultipartBody.Part
+    ): Single<BaseResponse<Int>> {
+        return rest.doMultipartFormFullUrl(server, file, baseInt)
+    }
+}
\ No newline at end of file
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/filemanager/FileManagerAdapter.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/filemanager/FileManagerAdapter.kt
index 7c97068c8..4e96fdedd 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/filemanager/FileManagerAdapter.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/filemanager/FileManagerAdapter.kt
@@ -448,7 +448,7 @@ class FileManagerAdapter(private var context: Context, private var data: List<Fi
             }
         }
         holder.itemView.setOnLongClickListener {
-            doAudioMenu(position, item)
+            doAudioMenu(holder.bindingAdapterPosition, item)
             true
         }
         updateAudioStatus(holder, item)
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/localserver/audioslocalserver/AudioLocalServerRecyclerAdapter.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/localserver/audioslocalserver/AudioLocalServerRecyclerAdapter.kt
index 72bb19074..4b8beed9a 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/localserver/audioslocalserver/AudioLocalServerRecyclerAdapter.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/localserver/audioslocalserver/AudioLocalServerRecyclerAdapter.kt
@@ -415,9 +415,9 @@ class AudioLocalServerRecyclerAdapter(
         }
         holder.play.setOnClickListener { v: View ->
             if (get().main().isRevert_play_audio()) {
-                doMenu(holder, position, v, audio)
+                doMenu(holder, holder.bindingAdapterPosition, v, audio)
             } else {
-                doPlay(position, audio)
+                doPlay(holder.bindingAdapterPosition, audio)
             }
         }
         holder.Track.setOnLongClickListener { v: View? ->
@@ -454,9 +454,9 @@ class AudioLocalServerRecyclerAdapter(
             holder.cancelSelectionAnimation()
             holder.startSomeAnimation()
             if (get().main().isRevert_play_audio()) {
-                doPlay(position, audio)
+                doPlay(holder.bindingAdapterPosition, audio)
             } else {
-                doMenu(holder, position, view, audio)
+                doMenu(holder, holder.bindingAdapterPosition, view, audio)
             }
         }
     }
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/localserver/filemanagerremote/FileManagerRemoteAdapter.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/localserver/filemanagerremote/FileManagerRemoteAdapter.kt
index 8a3fab1d3..16b2e9f3b 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/localserver/filemanagerremote/FileManagerRemoteAdapter.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/localserver/filemanagerremote/FileManagerRemoteAdapter.kt
@@ -456,7 +456,7 @@ class FileManagerRemoteAdapter(private var context: Context, private var data: L
             }
         }
         holder.itemView.setOnLongClickListener {
-            doAudioMenu(position, item, it)
+            doAudioMenu(holder.bindingAdapterPosition, item, it)
             true
         }
         updateAudioStatus(holder, item)
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/theme/ThemeAdapter.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/theme/ThemeAdapter.kt
index f3128b0ae..8d580b29d 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/theme/ThemeAdapter.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/fragment/theme/ThemeAdapter.kt
@@ -95,7 +95,7 @@ class ThemeAdapter(private var data: List<ThemeValue>, context: Context) :
             }
         }
         holder.clicked.setOnClickListener {
-            clickListener?.onClick(position, category)
+            clickListener?.onClick(holder.bindingAdapterPosition, category)
         }
     }
 
@@ -133,7 +133,7 @@ class ThemeAdapter(private var data: List<ThemeValue>, context: Context) :
             }
         }
         holder.clicked.setOnClickListener {
-            clickListener?.onClick(position, category)
+            clickListener?.onClick(holder.bindingAdapterPosition, category)
         }
         holder.gradient.background = GradientDrawable(
             GradientDrawable.Orientation.TL_BR,
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/upload/impl/RemoteAudioPlayUploadable.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/upload/impl/RemoteAudioPlayUploadable.kt
index c4c023783..5c44d7d38 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/upload/impl/RemoteAudioPlayUploadable.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/upload/impl/RemoteAudioPlayUploadable.kt
@@ -51,7 +51,7 @@ class RemoteAudioPlayUploadable(private val context: Context, private val networ
             val filename = UploadUtils.findFileName(
                 context, uri
             )
-            networker.localServerApi()
+            networker.uploads()
                 .remotePlayAudioRx(server_url, filename, inputStream, listener)
                 .doFinally(safelyCloseAction(inputStream))
                 .flatMap { dto ->
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/util/OkHttp3LoggingInterceptor.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/util/OkHttp3LoggingInterceptor.kt
index a9be36b7f..40ba74717 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/util/OkHttp3LoggingInterceptor.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/util/OkHttp3LoggingInterceptor.kt
@@ -92,7 +92,6 @@ class OkHttp3LoggingInterceptor @JvmOverloads constructor(
 
         companion object {
             /** A [Logger] defaults output appropriate for the current platform. */
-            @JvmField
             val DEFAULT: Logger = DefaultLogger()
 
             private class DefaultLogger : Logger {
diff --git a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/util/Utils.kt b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/util/Utils.kt
index c139715aa..fd26ba48f 100644
--- a/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/util/Utils.kt
+++ b/app_filegallery/src/main/kotlin/dev/ragnarok/filegallery/util/Utils.kt
@@ -46,6 +46,9 @@ object Utils {
     var density = 1f
         private set
 
+    var shouldSelectPhoto = false
+    val listSelected: ArrayList<String> = ArrayList()
+
     fun stringEmptyIfNull(orig: String?): String {
         return orig ?: ""
     }
diff --git a/app_filegallery/src/main/res/layout/content_photo_page.xml b/app_filegallery/src/main/res/layout/content_photo_page.xml
index 9d490f1d6..bd184d818 100644
--- a/app_filegallery/src/main/res/layout/content_photo_page.xml
+++ b/app_filegallery/src/main/res/layout/content_photo_page.xml
@@ -10,6 +10,15 @@
         android:layout_height="match_parent"
         android:layout_centerInParent="true" />
 
+    <View
+        android:id="@+id/selected_view"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:layout_centerInParent="true"
+        android:alpha="0.7"
+        android:background="?colorPrimary"
+        android:visibility="gone" />
+
     <dev.ragnarok.filegallery.view.natives.rlottie.RLottieImageView
         android:id="@+id/progress_bar"
         android:layout_width="wrap_content"
diff --git a/app_filegallery/src/main/res/menu/photo_menu.xml b/app_filegallery/src/main/res/menu/photo_menu.xml
index f921d54b5..569373620 100644
--- a/app_filegallery/src/main/res/menu/photo_menu.xml
+++ b/app_filegallery/src/main/res/menu/photo_menu.xml
@@ -6,4 +6,13 @@
     <item
         android:id="@+id/save_on_drive"
         android:title="@string/save_to_drive" />
+    <item
+        android:id="@+id/start_select_mode"
+        android:title="@string/start_select_mode" />
+    <item
+        android:id="@+id/end_select_mode"
+        android:title="@string/end_select_mode" />
+    <item
+        android:id="@+id/send_action"
+        android:title="@string/send_action" />
 </menu>
\ No newline at end of file
diff --git a/app_filegallery/src/main/res/values-be/strings.xml b/app_filegallery/src/main/res/values-be/strings.xml
index 90eabce39..8a2b36a73 100644
--- a/app_filegallery/src/main/res/values-be/strings.xml
+++ b/app_filegallery/src/main/res/values-be/strings.xml
@@ -243,4 +243,7 @@
     <string name="scan_qr">Сканаваць QR</string>
     <string name="client_rest_shutdown">Запыт скасаваны</string>
     <string name="internal_server_error">Памылка сервера (HTTP: %1$d)</string>
+    <string name="start_select_mode">Рэжым выбару</string>
+    <string name="end_select_mode">Завяршыць выбар</string>
+    <string name="send_action">Адправіць</string>
 </resources>
diff --git a/app_filegallery/src/main/res/values-ru/strings.xml b/app_filegallery/src/main/res/values-ru/strings.xml
index eb764ee34..b129a607c 100644
--- a/app_filegallery/src/main/res/values-ru/strings.xml
+++ b/app_filegallery/src/main/res/values-ru/strings.xml
@@ -243,4 +243,7 @@
     <string name="scan_qr">Сканировать QR</string>
     <string name="client_rest_shutdown">Запрос отменён</string>
     <string name="internal_server_error">Ошибка сервера (HTTP: %1$d)</string>
+    <string name="start_select_mode">Режим выбора</string>
+    <string name="end_select_mode">Завершить выбор</string>
+    <string name="send_action">Отправить</string>
 </resources>
diff --git a/app_filegallery/src/main/res/values/strings.xml b/app_filegallery/src/main/res/values/strings.xml
index fe7bccfc6..b74976395 100644
--- a/app_filegallery/src/main/res/values/strings.xml
+++ b/app_filegallery/src/main/res/values/strings.xml
@@ -362,4 +362,7 @@
     <string name="scan_qr">Scan QR</string>
     <string name="client_rest_shutdown">Request canceled</string>
     <string name="internal_server_error">Server error (HTTP: %1$d)</string>
+    <string name="start_select_mode">Select Mode</string>
+    <string name="end_select_mode">End selection</string>
+    <string name="send_action">Send</string>
 </resources>
diff --git a/build.gradle b/build.gradle
index e568dcaef..aedfb3d3a 100644
--- a/build.gradle
+++ b/build.gradle
@@ -13,38 +13,38 @@ buildscript {
     ext.appFileGalleryVersionName = "1.999"
 
     //androidx libraries
-    ext.activityVersion = "1.7.0-rc01"
+    ext.activityVersion = "1.7.0"
     ext.annotationVersion = "1.6.0"
     ext.appcompatVersion = "1.6.1"
     ext.biometricVersion = "1.2.0-alpha05"
     ext.browserVersion = "1.5.0"
-    ext.cameraVersion = "1.2.1"
+    ext.cameraVersion = "1.2.2"
     ext.cardviewVersion = "1.0.0"
-    ext.collectionVersion = "1.3.0-alpha02"
+    ext.collectionVersion = "1.3.0-alpha04"
     ext.concurentVersion = "1.2.0-alpha01"
-    ext.constraintlayoutVersion = "2.2.0-alpha08"
+    ext.constraintlayoutVersion = "2.2.0-alpha09"
     ext.coordinatorlayoutVersion = "1.2.0"
     ext.coreVersion = "1.10.0-rc01"
     ext.customviewVersion = "1.2.0-alpha02"
     ext.customviewPoolingcontainerVersion = "1.0.0"
-    ext.drawerlayoutVersion = "1.2.0-rc01"
+    ext.drawerlayoutVersion = "1.2.0"
     ext.dynamicanimationVersion = "1.1.0-alpha03"
     ext.exifinterfaceVersion = "1.3.6"
-    ext.fragmentVersion = "1.6.0-alpha07"
-    ext.lifecycleVersion = "2.6.0"
+    ext.fragmentVersion = "1.6.0-alpha08"
+    ext.lifecycleVersion = "2.6.1"
     ext.loaderVersion = "1.1.0"
     ext.mediaVersion = "1.7.0-alpha01"
     ext.recyclerviewVersion = "1.3.0"
-    ext.savedStateVersion = "1.2.0"
+    ext.savedStateVersion = "1.2.1"
     ext.swiperefreshlayoutVersion = "1.2.0-alpha01"
-    ext.tracingVersion = "1.2.0-beta01"
+    ext.tracingVersion = "1.2.0-beta02"
     ext.transitionVersion = "1.4.1"
     ext.vectordrawableVersion = "1.2.0-beta01"
-    ext.webkitVersion = "1.6.0"
-    ext.workVersion = "2.8.0"
+    ext.webkitVersion = "1.6.1"
+    ext.workVersion = "2.8.1"
 
     //firebase libraries
-    ext.firebaseDatatransportVersion = "18.1.7"
+    ext.firebaseDatatransportVersion = "18.1.8"
     ext.firebaseMessagingVersion = "23.1.2"
 
     //firebase common libraries
@@ -56,7 +56,7 @@ buildscript {
     ext.autoValueVersion = "1.10.1"
 
     //common libraries
-    ext.kotlin_version = "1.8.20-RC2"
+    ext.kotlin_version = "1.8.20"
     ext.kotlin_coroutines = "1.7.0-Beta"
     ext.kotlin_serializer = "1.5.0"
     ext.okhttpLibraryVersion = "5.0.0-alpha.11"
@@ -67,7 +67,7 @@ buildscript {
     ext.errorproneVersion = "2.15.0"
     ext.checkerCompatQualVersion = "2.5.5"
     ext.checkerQualAndroidVersion = "3.32.0"
-    ext.desugarLibraryVersion = "2.0.2"
+    ext.desugarLibraryVersion = "2.0.3"
 
     //APP_PROPS
     ext.targetAbi = is_developer_build ? ["arm64-v8a", "x86_64"] : ["arm64-v8a", "armeabi-v7a", "x86_64"]
@@ -91,7 +91,7 @@ buildscript {
         mavenCentral()
     }
     dependencies {
-        classpath "com.android.tools.build:gradle:8.0.0-beta05"
+        classpath "com.android.tools.build:gradle:8.0.0-rc01"
         classpath "com.google.gms:google-services:4.3.15"
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath "org.jetbrains.kotlin:kotlin-serialization:$kotlin_version"
diff --git a/libfenrir/src/main/jni/animation/libyuv/include/libyuv/version.h b/libfenrir/src/main/jni/animation/libyuv/include/libyuv/version.h
index e3905b460..56c41fe5b 100644
--- a/libfenrir/src/main/jni/animation/libyuv/include/libyuv/version.h
+++ b/libfenrir/src/main/jni/animation/libyuv/include/libyuv/version.h
@@ -11,6 +11,6 @@
 #ifndef INCLUDE_LIBYUV_VERSION_H_
 #define INCLUDE_LIBYUV_VERSION_H_
 
-#define LIBYUV_VERSION 1863
+#define LIBYUV_VERSION 1864
 
 #endif  // INCLUDE_LIBYUV_VERSION_H_
diff --git a/libfenrir/src/main/jni/animation/libyuv/source/row_neon.cc b/libfenrir/src/main/jni/animation/libyuv/source/row_neon.cc
index b3e800d91..d734b817c 100644
--- a/libfenrir/src/main/jni/animation/libyuv/source/row_neon.cc
+++ b/libfenrir/src/main/jni/animation/libyuv/source/row_neon.cc
@@ -89,12 +89,14 @@ extern "C" {
   "vsli.u16   d2, d2, #8                     \n" \
   "vsri.u16   d3, d3, #8                     \n"
 
+// TODO: Use single register for kUVCoeff and multiply by lane
 #define YUVTORGB_SETUP                                        \
+  "vld1.16    {d31}, [%[kRGBCoeffBias]]                   \n" \
   "vld4.8     {d26[], d27[], d28[], d29[]}, [%[kUVCoeff]] \n" \
-  "vld1.16    {d31[]}, [%[kRGBCoeffBias]]!   \n"              \
-  "vld1.16    {d20[], d21[]}, [%[kRGBCoeffBias]]! \n"         \
-  "vld1.16    {d22[], d23[]}, [%[kRGBCoeffBias]]! \n"         \
-  "vld1.16    {d24[], d25[]}, [%[kRGBCoeffBias]] \n"
+  "vdup.u16   q10, d31[1]                                 \n" \
+  "vdup.u16   q11, d31[2]                                 \n" \
+  "vdup.u16   q12, d31[3]                                 \n" \
+  "vdup.u16   d31, d31[0]                                 \n"
 
 // q0: B uint16x8_t
 // q1: G uint16x8_t
@@ -725,23 +727,23 @@ void UnpackMT2T_NEON(const uint8_t* src, uint16_t* dst, size_t size) {
       "1:                                        \n"
       "vld1.8      q14, [%0]!                    \n"  // Load lower bits.
       "vld1.8      q9, [%0]!                     \n"  // Load upper bits row
-                                                        // by row.
+                                                      // by row.
       "vld1.8      q11, [%0]!                    \n"
       "vld1.8      q13, [%0]!                    \n"
       "vld1.8      q15, [%0]!                    \n"
       "vshl.u8     q8, q14, #6                   \n"  // Shift lower bit data
-                                                        // appropriately.
+                                                      // appropriately.
       "vshl.u8     q10, q14, #4                  \n"
       "vshl.u8     q12, q14, #2                  \n"
       "vzip.u8     q8, q9                        \n"  // Interleave upper and
-                                                        // lower bits.
+                                                      // lower bits.
       "vzip.u8     q10, q11                      \n"
       "vzip.u8     q12, q13                      \n"
       "vzip.u8     q14, q15                      \n"
       "vsri.u16    q8, q8, #10                   \n"  // Copy upper 6 bits
-                                                        // into lower 6 bits for
-                                                        // better accuracy in
-                                                        // conversions.
+                                                      // into lower 6 bits for
+                                                      // better accuracy in
+                                                      // conversions.
       "vsri.u16    q9, q9, #10                   \n"
       "vsri.u16    q10, q10, #10                 \n"
       "vsri.u16    q11, q11, #10                 \n"
@@ -750,7 +752,7 @@ void UnpackMT2T_NEON(const uint8_t* src, uint16_t* dst, size_t size) {
       "vsri.u16    q14, q14, #10                 \n"
       "vsri.u16    q15, q15, #10                 \n"
       "vstmia      %1!, {q8-q15}                 \n"  // Store pixel block (64
-                                                        // pixels).
+                                                      // pixels).
       "subs        %2, %2, #80                   \n"
       "bgt         1b                            \n"
       : "+r"(src),  // %0
diff --git a/libfenrir/src/main/jni/animation/libyuv/source/row_neon64.cc b/libfenrir/src/main/jni/animation/libyuv/source/row_neon64.cc
index 2b5522f03..ba34ff4c9 100644
--- a/libfenrir/src/main/jni/animation/libyuv/source/row_neon64.cc
+++ b/libfenrir/src/main/jni/animation/libyuv/source/row_neon64.cc
@@ -1982,21 +1982,20 @@ void ARGBToRGB565DitherRow_NEON(const uint8_t* src_argb,
                                 const uint32_t dither4,
                                 int width) {
   asm volatile(
-      "dup         v1.4s, %w2                    \n"  // dither4
+      "dup         v1.4s, %w3                    \n"  // dither4
       "1:                                        \n"
-      "ld4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%1], #32 \n"  // load 8
-                                                                 // pixels
-      "subs        %w3, %w3, #8                  \n"  // 8 processed per loop.
+      "ld4         {v16.8b,v17.8b,v18.8b,v19.8b}, [%0], #32 \n"  // load 8 ARGB
+      "subs        %w2, %w2, #8                  \n"  // 8 processed per loop.
       "uqadd       v16.8b, v16.8b, v1.8b         \n"
       "prfm        pldl1keep, [%0, 448]          \n"
       "uqadd       v17.8b, v17.8b, v1.8b         \n"
       "uqadd       v18.8b, v18.8b, v1.8b         \n" ARGBTORGB565
-      "st1         {v18.16b}, [%0], #16          \n"  // store 8 pixels RGB565.
+      "st1         {v18.16b}, [%1], #16          \n"  // store 8 pixels RGB565.
       "b.gt        1b                            \n"
-      : "+r"(dst_rgb)   // %0
-      : "r"(src_argb),  // %1
-        "r"(dither4),   // %2
-        "r"(width)      // %3
+      : "+r"(src_argb),  // %0
+        "+r"(dst_rgb),   // %1
+        "+r"(width)      // %2
+      : "r"(dither4)     // %3
       : "cc", "memory", "v1", "v16", "v17", "v18", "v19");
 }
 
diff --git a/libfenrir/src/main/jni/compress/zstd/common/allocations.h b/libfenrir/src/main/jni/compress/zstd/common/allocations.h
new file mode 100644
index 000000000..a3153c4ba
--- /dev/null
+++ b/libfenrir/src/main/jni/compress/zstd/common/allocations.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
+ */
+
+/* This file provides custom allocation primitives
+ */
+
+#define ZSTD_DEPS_NEED_MALLOC
+#include "zstd_deps.h"   /* ZSTD_malloc, ZSTD_calloc, ZSTD_free, ZSTD_memset */
+
+#include "mem.h" /* MEM_STATIC */
+#define ZSTD_STATIC_LINKING_ONLY
+#include "../zstd.h" /* ZSTD_customMem */
+
+#ifndef ZSTD_ALLOCATIONS_H
+#define ZSTD_ALLOCATIONS_H
+
+/* custom memory allocation functions */
+
+MEM_STATIC void* ZSTD_customMalloc(size_t size, ZSTD_customMem customMem)
+{
+    if (customMem.customAlloc)
+        return customMem.customAlloc(customMem.opaque, size);
+    return ZSTD_malloc(size);
+}
+
+MEM_STATIC void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem)
+{
+    if (customMem.customAlloc) {
+        /* calloc implemented as malloc+memset;
+         * not as efficient as calloc, but next best guess for custom malloc */
+        void* const ptr = customMem.customAlloc(customMem.opaque, size);
+        ZSTD_memset(ptr, 0, size);
+        return ptr;
+    }
+    return ZSTD_calloc(1, size);
+}
+
+MEM_STATIC void ZSTD_customFree(void* ptr, ZSTD_customMem customMem)
+{
+    if (ptr!=NULL) {
+        if (customMem.customFree)
+            customMem.customFree(customMem.opaque, ptr);
+        else
+            ZSTD_free(ptr);
+    }
+}
+
+#endif /* ZSTD_ALLOCATIONS_H */
diff --git a/libfenrir/src/main/jni/compress/zstd/common/bits.h b/libfenrir/src/main/jni/compress/zstd/common/bits.h
index 7939f3d0f..def56c474 100644
--- a/libfenrir/src/main/jni/compress/zstd/common/bits.h
+++ b/libfenrir/src/main/jni/compress/zstd/common/bits.h
@@ -17,7 +17,7 @@ MEM_STATIC unsigned ZSTD_countTrailingZeros32_fallback(U32 val)
 {
     assert(val != 0);
     {
-        static const int DeBruijnBytePos[32] = {0, 1, 28, 2, 29, 14, 24, 3,
+        static const U32 DeBruijnBytePos[32] = {0, 1, 28, 2, 29, 14, 24, 3,
                                                 30, 22, 20, 15, 25, 17, 4, 8,
                                                 31, 27, 13, 23, 21, 19, 16, 7,
                                                 26, 12, 18, 6, 11, 5, 10, 9};
@@ -30,7 +30,7 @@ MEM_STATIC unsigned ZSTD_countTrailingZeros32(U32 val)
     assert(val != 0);
 #   if defined(_MSC_VER)
 #       if STATIC_BMI2 == 1
-            return _tzcnt_u32(val);
+            return (unsigned)_tzcnt_u32(val);
 #       else
             if (val != 0) {
                 unsigned long r;
@@ -69,7 +69,7 @@ MEM_STATIC unsigned ZSTD_countLeadingZeros32(U32 val)
     assert(val != 0);
 #   if defined(_MSC_VER)
 #       if STATIC_BMI2 == 1
-            return _lzcnt_u32(val);
+            return (unsigned)_lzcnt_u32(val);
 #       else
             if (val != 0) {
                 unsigned long r;
@@ -92,7 +92,7 @@ MEM_STATIC unsigned ZSTD_countTrailingZeros64(U64 val)
     assert(val != 0);
 #   if defined(_MSC_VER) && defined(_WIN64)
 #       if STATIC_BMI2 == 1
-            return _tzcnt_u64(val);
+            return (unsigned)_tzcnt_u64(val);
 #       else
             if (val != 0) {
                 unsigned long r;
@@ -123,7 +123,7 @@ MEM_STATIC unsigned ZSTD_countLeadingZeros64(U64 val)
     assert(val != 0);
 #   if defined(_MSC_VER) && defined(_WIN64)
 #       if STATIC_BMI2 == 1
-            return _lzcnt_u64(val);
+            return (unsigned)_lzcnt_u64(val);
 #       else
             if (val != 0) {
                 unsigned long r;
@@ -172,4 +172,29 @@ MEM_STATIC unsigned ZSTD_highbit32(U32 val)   /* compress, dictBuilder, decodeCo
     return 31 - ZSTD_countLeadingZeros32(val);
 }
 
+/* ZSTD_rotateRight_*():
+ * Rotates a bitfield to the right by "count" bits.
+ * https://en.wikipedia.org/w/index.php?title=Circular_shift&oldid=991635599#Implementing_circular_shifts
+ */
+MEM_STATIC
+U64 ZSTD_rotateRight_U64(U64 const value, U32 count) {
+    assert(count < 64);
+    count &= 0x3F; /* for fickle pattern recognition */
+    return (value >> count) | (U64)(value << ((0U - count) & 0x3F));
+}
+
+MEM_STATIC
+U32 ZSTD_rotateRight_U32(U32 const value, U32 count) {
+    assert(count < 32);
+    count &= 0x1F; /* for fickle pattern recognition */
+    return (value >> count) | (U32)(value << ((0U - count) & 0x1F));
+}
+
+MEM_STATIC
+U16 ZSTD_rotateRight_U16(U16 const value, U32 count) {
+    assert(count < 16);
+    count &= 0x0F; /* for fickle pattern recognition */
+    return (value >> count) | (U16)(value << ((0U - count) & 0x0F));
+}
+
 #endif /* ZSTD_BITS_H */
diff --git a/libfenrir/src/main/jni/compress/zstd/common/bitstream.h b/libfenrir/src/main/jni/compress/zstd/common/bitstream.h
index db1b4cf13..72b0b3df2 100644
--- a/libfenrir/src/main/jni/compress/zstd/common/bitstream.h
+++ b/libfenrir/src/main/jni/compress/zstd/common/bitstream.h
@@ -396,7 +396,7 @@ MEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)
  *  This function is safe, it guarantees it will not read beyond src buffer.
  * @return : status of `BIT_DStream_t` internal register.
  *           when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */
-MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
+MEM_STATIC FORCE_INLINE_ATTR BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
 {
     if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* overflow detected, like end of stream */
         return BIT_DStream_overflow;
diff --git a/libfenrir/src/main/jni/compress/zstd/common/compiler.h b/libfenrir/src/main/jni/compress/zstd/common/compiler.h
index d4f2f285d..73f8d0199 100644
--- a/libfenrir/src/main/jni/compress/zstd/common/compiler.h
+++ b/libfenrir/src/main/jni/compress/zstd/common/compiler.h
@@ -311,6 +311,10 @@ void __msan_poison(const volatile void *a, size_t size);
 /* Returns the offset of the first (at least partially) poisoned byte in the
    memory range, or -1 if the whole range is good. */
 intptr_t __msan_test_shadow(const volatile void *x, size_t size);
+
+/* Print shadow and origin for the memory range to stderr in a human-readable
+   format. */
+void __msan_print_shadow(const volatile void *x, size_t size);
 #endif
 
 #if ZSTD_ADDRESS_SANITIZER && !defined(ZSTD_ASAN_DONT_POISON_WORKSPACE)
diff --git a/libfenrir/src/main/jni/compress/zstd/common/pool.c b/libfenrir/src/main/jni/compress/zstd/common/pool.c
index f3d9d0854..d5ca5a780 100644
--- a/libfenrir/src/main/jni/compress/zstd/common/pool.c
+++ b/libfenrir/src/main/jni/compress/zstd/common/pool.c
@@ -10,9 +10,9 @@
 
 
 /* ======   Dependencies   ======= */
+#include "../common/allocations.h"  /* ZSTD_customCalloc, ZSTD_customFree */
 #include "zstd_deps.h" /* size_t */
 #include "debug.h"     /* assert */
-#include "zstd_internal.h"  /* ZSTD_customCalloc, ZSTD_customFree */
 #include "pool.h"
 
 /* ======   Compiler specifics   ====== */
diff --git a/libfenrir/src/main/jni/compress/zstd/common/threading.c b/libfenrir/src/main/jni/compress/zstd/common/threading.c
index f2341105a..ca155b9b9 100644
--- a/libfenrir/src/main/jni/compress/zstd/common/threading.c
+++ b/libfenrir/src/main/jni/compress/zstd/common/threading.c
@@ -47,7 +47,7 @@ static unsigned __stdcall worker(void *arg)
     void* (*start_routine)(void*);
     void* thread_arg;
 
-    /* Inialized thread_arg and start_routine and signal main thread that we don't need it
+    /* Initialized thread_arg and start_routine and signal main thread that we don't need it
      * to wait any longer.
      */
     {
diff --git a/libfenrir/src/main/jni/compress/zstd/common/zstd_common.c b/libfenrir/src/main/jni/compress/zstd/common/zstd_common.c
index 320855247..3f04c22ab 100644
--- a/libfenrir/src/main/jni/compress/zstd/common/zstd_common.c
+++ b/libfenrir/src/main/jni/compress/zstd/common/zstd_common.c
@@ -14,7 +14,6 @@
 *  Dependencies
 ***************************************/
 #define ZSTD_DEPS_NEED_MALLOC
-#include "zstd_deps.h"   /* ZSTD_malloc, ZSTD_calloc, ZSTD_free, ZSTD_memset */
 #include "error_private.h"
 #include "zstd_internal.h"
 
@@ -47,37 +46,3 @@ ZSTD_ErrorCode ZSTD_getErrorCode(size_t code) { return ERR_getErrorCode(code); }
 /*! ZSTD_getErrorString() :
  *  provides error code string from enum */
 const char* ZSTD_getErrorString(ZSTD_ErrorCode code) { return ERR_getErrorString(code); }
-
-
-
-/*=**************************************************************
-*  Custom allocator
-****************************************************************/
-void* ZSTD_customMalloc(size_t size, ZSTD_customMem customMem)
-{
-    if (customMem.customAlloc)
-        return customMem.customAlloc(customMem.opaque, size);
-    return ZSTD_malloc(size);
-}
-
-void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem)
-{
-    if (customMem.customAlloc) {
-        /* calloc implemented as malloc+memset;
-         * not as efficient as calloc, but next best guess for custom malloc */
-        void* const ptr = customMem.customAlloc(customMem.opaque, size);
-        ZSTD_memset(ptr, 0, size);
-        return ptr;
-    }
-    return ZSTD_calloc(1, size);
-}
-
-void ZSTD_customFree(void* ptr, ZSTD_customMem customMem)
-{
-    if (ptr!=NULL) {
-        if (customMem.customFree)
-            customMem.customFree(customMem.opaque, ptr);
-        else
-            ZSTD_free(ptr);
-    }
-}
diff --git a/libfenrir/src/main/jni/compress/zstd/common/zstd_internal.h b/libfenrir/src/main/jni/compress/zstd/common/zstd_internal.h
index 37836dc70..1f942f27b 100644
--- a/libfenrir/src/main/jni/compress/zstd/common/zstd_internal.h
+++ b/libfenrir/src/main/jni/compress/zstd/common/zstd_internal.h
@@ -350,11 +350,6 @@ typedef struct {
 const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx);   /* compress & dictBuilder */
 int ZSTD_seqToCodes(const seqStore_t* seqStorePtr);   /* compress, dictBuilder, decodeCorpus (shouldn't get its definition from here) */
 
-/* custom memory allocation functions */
-void* ZSTD_customMalloc(size_t size, ZSTD_customMem customMem);
-void* ZSTD_customCalloc(size_t size, ZSTD_customMem customMem);
-void ZSTD_customFree(void* ptr, ZSTD_customMem customMem);
-
 
 /* ZSTD_invalidateRepCodes() :
  * ensures next compression will not use repcodes from previous block.
diff --git a/libfenrir/src/main/jni/compress/zstd/compress/zstd_compress.c b/libfenrir/src/main/jni/compress/zstd/compress/zstd_compress.c
index b55f684cd..d91f80060 100644
--- a/libfenrir/src/main/jni/compress/zstd/compress/zstd_compress.c
+++ b/libfenrir/src/main/jni/compress/zstd/compress/zstd_compress.c
@@ -11,6 +11,7 @@
 /*-*************************************
 *  Dependencies
 ***************************************/
+#include "../common/allocations.h"  /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */
 #include "../common/zstd_deps.h"  /* INT_MAX, ZSTD_memset, ZSTD_memcpy */
 #include "../common/mem.h"
 #include "hist.h"           /* HIST_countFast_wksp */
@@ -26,7 +27,7 @@
 #include "zstd_opt.h"
 #include "zstd_ldm.h"
 #include "zstd_compress_superblock.h"
-#include  "../common/bits.h"      /* ZSTD_highbit32 */
+#include  "../common/bits.h"      /* ZSTD_highbit32, ZSTD_rotateRight_U64 */
 
 /* ***************************************************************
 *  Tuning parameters
@@ -1177,16 +1178,39 @@ size_t ZSTD_CCtx_setParametersUsingCCtxParams(
 
 size_t ZSTD_CCtx_setCParams(ZSTD_CCtx* cctx, ZSTD_compressionParameters cparams)
 {
+    ZSTD_STATIC_ASSERT(sizeof(cparams) == 7 * 4 /* all params are listed below */);
     DEBUGLOG(4, "ZSTD_CCtx_setCParams");
-    assert(cctx != NULL);
-    if (cctx->streamStage != zcss_init) {
-        /* All parameters in @cparams are allowed to be updated during MT compression.
-         * This must be signaled, so that MT compression picks up the changes */
-        cctx->cParamsChanged = 1;
-    }
-    /* only update if parameters are valid */
+    /* only update if all parameters are valid */
     FORWARD_IF_ERROR(ZSTD_checkCParams(cparams), "");
-    cctx->requestedParams.cParams = cparams;
+    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_windowLog, cparams.windowLog), "");
+    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_chainLog, cparams.chainLog), "");
+    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_hashLog, cparams.hashLog), "");
+    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_searchLog, cparams.searchLog), "");
+    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_minMatch, cparams.minMatch), "");
+    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_targetLength, cparams.targetLength), "");
+    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_strategy, cparams.strategy), "");
+    return 0;
+}
+
+size_t ZSTD_CCtx_setFParams(ZSTD_CCtx* cctx, ZSTD_frameParameters fparams)
+{
+    ZSTD_STATIC_ASSERT(sizeof(fparams) == 3 * 4 /* all params are listed below */);
+    DEBUGLOG(4, "ZSTD_CCtx_setFParams");
+    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_contentSizeFlag, fparams.contentSizeFlag != 0), "");
+    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_checksumFlag, fparams.checksumFlag != 0), "");
+    FORWARD_IF_ERROR(ZSTD_CCtx_setParameter(cctx, ZSTD_c_dictIDFlag, fparams.noDictIDFlag == 0), "");
+    return 0;
+}
+
+size_t ZSTD_CCtx_setParams(ZSTD_CCtx* cctx, ZSTD_parameters params)
+{
+    DEBUGLOG(4, "ZSTD_CCtx_setParams");
+    /* First check cParams, because we want to update all or none. */
+    FORWARD_IF_ERROR(ZSTD_checkCParams(params.cParams), "");
+    /* Next set fParams, because this could fail if the cctx isn't in init stage. */
+    FORWARD_IF_ERROR(ZSTD_CCtx_setFParams(cctx, params.fParams), "");
+    /* Finally set cParams, which should succeed. */
+    FORWARD_IF_ERROR(ZSTD_CCtx_setCParams(cctx, params.cParams), "");
     return 0;
 }
 
@@ -1592,7 +1616,7 @@ ZSTD_sizeof_matchState(const ZSTD_compressionParameters* const cParams,
       + ZSTD_cwksp_aligned_alloc_size((ZSTD_OPT_NUM+1) * sizeof(ZSTD_match_t))
       + ZSTD_cwksp_aligned_alloc_size((ZSTD_OPT_NUM+1) * sizeof(ZSTD_optimal_t));
     size_t const lazyAdditionalSpace = ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)
-                                            ? ZSTD_cwksp_aligned_alloc_size(hSize*sizeof(U16))
+                                            ? ZSTD_cwksp_aligned_alloc_size(hSize)
                                             : 0;
     size_t const optSpace = (forCCtx && (cParams->strategy >= ZSTD_btopt))
                                 ? optPotentialSpace
@@ -1883,6 +1907,19 @@ typedef enum {
     ZSTD_resetTarget_CCtx
 } ZSTD_resetTarget_e;
 
+/* Mixes bits in a 64 bits in a value, based on XXH3_rrmxmx */
+static U64 ZSTD_bitmix(U64 val, U64 len) {
+    val ^= ZSTD_rotateRight_U64(val, 49) ^ ZSTD_rotateRight_U64(val, 24);
+    val *= 0x9FB21C651E98DF25ULL;
+    val ^= (val >> 35) + len ;
+    val *= 0x9FB21C651E98DF25ULL;
+    return val ^ (val >> 28);
+}
+
+/* Mixes in the hashSalt and hashSaltEntropy to create a new hashSalt */
+static void ZSTD_advanceHashSalt(ZSTD_matchState_t* ms) {
+    ms->hashSalt = ZSTD_bitmix(ms->hashSalt, 8) ^ ZSTD_bitmix((U64) ms->hashSaltEntropy, 4);
+}
 
 static size_t
 ZSTD_reset_matchState(ZSTD_matchState_t* ms,
@@ -1910,6 +1947,7 @@ ZSTD_reset_matchState(ZSTD_matchState_t* ms,
     }
 
     ms->hashLog3 = hashLog3;
+    ms->lazySkipping = 0;
 
     ZSTD_invalidateMatchState(ms);
 
@@ -1931,6 +1969,27 @@ ZSTD_reset_matchState(ZSTD_matchState_t* ms,
         ZSTD_cwksp_clean_tables(ws);
     }
 
+    if (ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)) {
+        /* Row match finder needs an additional table of hashes ("tags") */
+        size_t const tagTableSize = hSize;
+        /* We want to generate a new salt in case we reset a Cctx, but we always want to use
+         * 0 when we reset a Cdict */
+        if(forWho == ZSTD_resetTarget_CCtx) {
+            ms->tagTable = (BYTE*) ZSTD_cwksp_reserve_aligned_init_once(ws, tagTableSize);
+            ZSTD_advanceHashSalt(ms);
+        } else {
+            /* When we are not salting we want to always memset the memory */
+            ms->tagTable = (BYTE*) ZSTD_cwksp_reserve_aligned(ws, tagTableSize);
+            ZSTD_memset(ms->tagTable, 0, tagTableSize);
+            ms->hashSalt = 0;
+        }
+        {   /* Switch to 32-entry rows if searchLog is 5 (or more) */
+            U32 const rowLog = BOUNDED(4, cParams->searchLog, 6);
+            assert(cParams->hashLog >= rowLog);
+            ms->rowHashLog = cParams->hashLog - rowLog;
+        }
+    }
+
     /* opt parser space */
     if ((forWho == ZSTD_resetTarget_CCtx) && (cParams->strategy >= ZSTD_btopt)) {
         DEBUGLOG(4, "reserving optimal parser space");
@@ -1942,19 +2001,6 @@ ZSTD_reset_matchState(ZSTD_matchState_t* ms,
         ms->opt.priceTable = (ZSTD_optimal_t*)ZSTD_cwksp_reserve_aligned(ws, (ZSTD_OPT_NUM+1) * sizeof(ZSTD_optimal_t));
     }
 
-    if (ZSTD_rowMatchFinderUsed(cParams->strategy, useRowMatchFinder)) {
-        {   /* Row match finder needs an additional table of hashes ("tags") */
-            size_t const tagTableSize = hSize*sizeof(U16);
-            ms->tagTable = (U16*)ZSTD_cwksp_reserve_aligned(ws, tagTableSize);
-            if (ms->tagTable) ZSTD_memset(ms->tagTable, 0, tagTableSize);
-        }
-        {   /* Switch to 32-entry rows if searchLog is 5 (or more) */
-            U32 const rowLog = BOUNDED(4, cParams->searchLog, 6);
-            assert(cParams->hashLog >= rowLog);
-            ms->rowHashLog = cParams->hashLog - rowLog;
-        }
-    }
-
     ms->cParams = *cParams;
 
     RETURN_ERROR_IF(ZSTD_cwksp_reserve_failed(ws), memory_allocation,
@@ -2101,13 +2147,46 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
 
         ZSTD_reset_compressedBlockState(zc->blockState.prevCBlock);
 
+        FORWARD_IF_ERROR(ZSTD_reset_matchState(
+                &zc->blockState.matchState,
+                ws,
+                &params->cParams,
+                params->useRowMatchFinder,
+                crp,
+                needsIndexReset,
+                ZSTD_resetTarget_CCtx), "");
+
+        zc->seqStore.sequencesStart = (seqDef*)ZSTD_cwksp_reserve_aligned(ws, maxNbSeq * sizeof(seqDef));
+
+        /* ldm hash table */
+        if (params->ldmParams.enableLdm == ZSTD_ps_enable) {
+            /* TODO: avoid memset? */
+            size_t const ldmHSize = ((size_t)1) << params->ldmParams.hashLog;
+            zc->ldmState.hashTable = (ldmEntry_t*)ZSTD_cwksp_reserve_aligned(ws, ldmHSize * sizeof(ldmEntry_t));
+            ZSTD_memset(zc->ldmState.hashTable, 0, ldmHSize * sizeof(ldmEntry_t));
+            zc->ldmSequences = (rawSeq*)ZSTD_cwksp_reserve_aligned(ws, maxNbLdmSeq * sizeof(rawSeq));
+            zc->maxNbLdmSequences = maxNbLdmSeq;
+
+            ZSTD_window_init(&zc->ldmState.window);
+            zc->ldmState.loadedDictEnd = 0;
+        }
+
+        /* reserve space for block-level external sequences */
+        if (params->useSequenceProducer) {
+            size_t const maxNbExternalSeq = ZSTD_sequenceBound(blockSize);
+            zc->externalMatchCtx.seqBufferCapacity = maxNbExternalSeq;
+            zc->externalMatchCtx.seqBuffer =
+                (ZSTD_Sequence*)ZSTD_cwksp_reserve_aligned(ws, maxNbExternalSeq * sizeof(ZSTD_Sequence));
+        }
+
+        /* buffers */
+
         /* ZSTD_wildcopy() is used to copy into the literals buffer,
          * so we have to oversize the buffer by WILDCOPY_OVERLENGTH bytes.
          */
         zc->seqStore.litStart = ZSTD_cwksp_reserve_buffer(ws, blockSize + WILDCOPY_OVERLENGTH);
         zc->seqStore.maxNbLit = blockSize;
 
-        /* buffers */
         zc->bufferedPolicy = zbuff;
         zc->inBuffSize = buffInSize;
         zc->inBuff = (char*)ZSTD_cwksp_reserve_buffer(ws, buffInSize);
@@ -2130,40 +2209,9 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
         zc->seqStore.llCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));
         zc->seqStore.mlCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));
         zc->seqStore.ofCode = ZSTD_cwksp_reserve_buffer(ws, maxNbSeq * sizeof(BYTE));
-        zc->seqStore.sequencesStart = (seqDef*)ZSTD_cwksp_reserve_aligned(ws, maxNbSeq * sizeof(seqDef));
-
-        FORWARD_IF_ERROR(ZSTD_reset_matchState(
-            &zc->blockState.matchState,
-            ws,
-            &params->cParams,
-            params->useRowMatchFinder,
-            crp,
-            needsIndexReset,
-            ZSTD_resetTarget_CCtx), "");
-
-        /* ldm hash table */
-        if (params->ldmParams.enableLdm == ZSTD_ps_enable) {
-            /* TODO: avoid memset? */
-            size_t const ldmHSize = ((size_t)1) << params->ldmParams.hashLog;
-            zc->ldmState.hashTable = (ldmEntry_t*)ZSTD_cwksp_reserve_aligned(ws, ldmHSize * sizeof(ldmEntry_t));
-            ZSTD_memset(zc->ldmState.hashTable, 0, ldmHSize * sizeof(ldmEntry_t));
-            zc->ldmSequences = (rawSeq*)ZSTD_cwksp_reserve_aligned(ws, maxNbLdmSeq * sizeof(rawSeq));
-            zc->maxNbLdmSequences = maxNbLdmSeq;
-
-            ZSTD_window_init(&zc->ldmState.window);
-            zc->ldmState.loadedDictEnd = 0;
-        }
-
-        /* reserve space for block-level external sequences */
-        if (params->useSequenceProducer) {
-            size_t const maxNbExternalSeq = ZSTD_sequenceBound(blockSize);
-            zc->externalMatchCtx.seqBufferCapacity = maxNbExternalSeq;
-            zc->externalMatchCtx.seqBuffer =
-                (ZSTD_Sequence*)ZSTD_cwksp_reserve_aligned(ws, maxNbExternalSeq * sizeof(ZSTD_Sequence));
-        }
 
         DEBUGLOG(3, "wksp: finished allocating, %zd bytes remain available", ZSTD_cwksp_available_space(ws));
-        assert(ZSTD_cwksp_estimated_space_within_bounds(ws, neededSpace, resizeWorkspace));
+        assert(ZSTD_cwksp_estimated_space_within_bounds(ws, neededSpace));
 
         zc->initialized = 1;
 
@@ -2338,10 +2386,11 @@ static size_t ZSTD_resetCCtx_byCopyingCDict(ZSTD_CCtx* cctx,
         }
         /* copy tag table */
         if (ZSTD_rowMatchFinderUsed(cdict_cParams->strategy, cdict->useRowMatchFinder)) {
-            size_t const tagTableSize = hSize*sizeof(U16);
+            size_t const tagTableSize = hSize;
             ZSTD_memcpy(cctx->blockState.matchState.tagTable,
-                cdict->matchState.tagTable,
-                tagTableSize);
+                        cdict->matchState.tagTable,
+                        tagTableSize);
+            cctx->blockState.matchState.hashSalt = cdict->matchState.hashSalt;
         }
     }
 
@@ -3858,9 +3907,10 @@ ZSTD_seqStore_resolveOffCodes(repcodes_t* const dRepcodes, repcodes_t* const cRe
                         const seqStore_t* const seqStore, U32 const nbSeq)
 {
     U32 idx = 0;
+    U32 const longLitLenIdx = seqStore->longLengthType == ZSTD_llt_literalLength ? seqStore->longLengthPos : nbSeq;
     for (; idx < nbSeq; ++idx) {
         seqDef* const seq = seqStore->sequencesStart + idx;
-        U32 const ll0 = (seq->litLength == 0);
+        U32 const ll0 = (seq->litLength == 0) && (idx != longLitLenIdx);
         U32 const offBase = seq->offBase;
         assert(offBase > 0);
         if (OFFBASE_IS_REPCODE(offBase)) {
@@ -4576,31 +4626,51 @@ static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
     }
 }
 
-size_t ZSTD_compressContinue (ZSTD_CCtx* cctx,
-                              void* dst, size_t dstCapacity,
-                        const void* src, size_t srcSize)
+size_t ZSTD_compressContinue_public(ZSTD_CCtx* cctx,
+                                        void* dst, size_t dstCapacity,
+                                  const void* src, size_t srcSize)
 {
     DEBUGLOG(5, "ZSTD_compressContinue (srcSize=%u)", (unsigned)srcSize);
     return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 1 /* frame mode */, 0 /* last chunk */);
 }
 
+/* NOTE: Must just wrap ZSTD_compressContinue_public() */
+size_t ZSTD_compressContinue(ZSTD_CCtx* cctx,
+                             void* dst, size_t dstCapacity,
+                       const void* src, size_t srcSize)
+{
+    return ZSTD_compressContinue_public(cctx, dst, dstCapacity, src, srcSize);
+}
 
-size_t ZSTD_getBlockSize(const ZSTD_CCtx* cctx)
+static size_t ZSTD_getBlockSize_deprecated(const ZSTD_CCtx* cctx)
 {
     ZSTD_compressionParameters const cParams = cctx->appliedParams.cParams;
     assert(!ZSTD_checkCParams(cParams));
     return MIN(cctx->appliedParams.maxBlockSize, (size_t)1 << cParams.windowLog);
 }
 
-size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+/* NOTE: Must just wrap ZSTD_getBlockSize_deprecated() */
+size_t ZSTD_getBlockSize(const ZSTD_CCtx* cctx)
+{
+    return ZSTD_getBlockSize_deprecated(cctx);
+}
+
+/* NOTE: Must just wrap ZSTD_compressBlock_deprecated() */
+size_t ZSTD_compressBlock_deprecated(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
 {
     DEBUGLOG(5, "ZSTD_compressBlock: srcSize = %u", (unsigned)srcSize);
-    { size_t const blockSizeMax = ZSTD_getBlockSize(cctx);
+    { size_t const blockSizeMax = ZSTD_getBlockSize_deprecated(cctx);
       RETURN_ERROR_IF(srcSize > blockSizeMax, srcSize_wrong, "input is larger than a block"); }
 
     return ZSTD_compressContinue_internal(cctx, dst, dstCapacity, src, srcSize, 0 /* frame mode */, 0 /* last chunk */);
 }
 
+/* NOTE: Must just wrap ZSTD_compressBlock_deprecated() */
+size_t ZSTD_compressBlock(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize)
+{
+    return ZSTD_compressBlock_deprecated(cctx, dst, dstCapacity, src, srcSize);
+}
+
 /*! ZSTD_loadDictionaryContent() :
  *  @return : 0, or an error code
  */
@@ -4644,31 +4714,42 @@ static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms,
             ip = iend - maxDictSize;
             src = ip;
             srcSize = maxDictSize;
-    }   }
+        }
+    }
 
     if (srcSize > ZSTD_CHUNKSIZE_MAX) {
         /* We must have cleared our windows when our source is this large. */
         assert(ZSTD_window_isEmpty(ms->window));
         if (loadLdmDict) assert(ZSTD_window_isEmpty(ls->window));
     }
+    ZSTD_window_update(&ms->window, src, srcSize, /* forceNonContiguous */ 0);
 
     DEBUGLOG(4, "ZSTD_loadDictionaryContent(): useRowMatchFinder=%d", (int)params->useRowMatchFinder);
-    ZSTD_window_update(&ms->window, src, srcSize, /* forceNonContiguous */ 0);
-    ms->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ms->window.base);
-    ms->forceNonContiguous = params->deterministicRefPrefix;
 
-    if (loadLdmDict) {
+    if (loadLdmDict) { /* Load the entire dict into LDM matchfinders. */
         ZSTD_window_update(&ls->window, src, srcSize, /* forceNonContiguous */ 0);
         ls->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ls->window.base);
+        ZSTD_ldm_fillHashTable(ls, ip, iend, &params->ldmParams);
     }
 
+    /* If the dict is larger than we can reasonably index in our tables, only load the suffix. */
+    if (params->cParams.strategy < ZSTD_btultra) {
+        U32 maxDictSize = 8U << MIN(MAX(params->cParams.hashLog, params->cParams.chainLog), 28);
+        if (srcSize > maxDictSize) {
+            ip = iend - maxDictSize;
+            src = ip;
+            srcSize = maxDictSize;
+        }
+    }
+
+    ms->nextToUpdate = (U32)(ip - ms->window.base);
+    ms->loadedDictEnd = params->forceWindow ? 0 : (U32)(iend - ms->window.base);
+    ms->forceNonContiguous = params->deterministicRefPrefix;
+
     if (srcSize <= HASH_READ_SIZE) return 0;
 
     ZSTD_overflowCorrectIfNeeded(ms, ws, params, ip, iend);
 
-    if (loadLdmDict)
-        ZSTD_ldm_fillHashTable(ls, ip, iend, &params->ldmParams);
-
     switch(params->cParams.strategy)
     {
     case ZSTD_fast:
@@ -4688,7 +4769,7 @@ static size_t ZSTD_loadDictionaryContent(ZSTD_matchState_t* ms,
         } else {
             assert(params->useRowMatchFinder != ZSTD_ps_auto);
             if (params->useRowMatchFinder == ZSTD_ps_enable) {
-                size_t const tagTableSize = ((size_t)1 << params->cParams.hashLog) * sizeof(U16);
+                size_t const tagTableSize = ((size_t)1 << params->cParams.hashLog);
                 ZSTD_memset(ms->tagTable, 0, tagTableSize);
                 ZSTD_row_update(ms, iend-HASH_READ_SIZE);
                 DEBUGLOG(4, "Using row-based hash table for lazy dict");
@@ -4991,8 +5072,8 @@ size_t ZSTD_compressBegin_advanced(ZSTD_CCtx* cctx,
                                             &cctxParams, pledgedSrcSize);
 }
 
-size_t
-ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)
+static size_t
+ZSTD_compressBegin_usingDict_deprecated(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)
 {
     ZSTD_CCtx_params cctxParams;
     {   ZSTD_parameters const params = ZSTD_getParams_internal(compressionLevel, ZSTD_CONTENTSIZE_UNKNOWN, dictSize, ZSTD_cpm_noAttachDict);
@@ -5003,9 +5084,15 @@ ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize,
                                        &cctxParams, ZSTD_CONTENTSIZE_UNKNOWN, ZSTDb_not_buffered);
 }
 
+size_t
+ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel)
+{
+    return ZSTD_compressBegin_usingDict_deprecated(cctx, dict, dictSize, compressionLevel);
+}
+
 size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel)
 {
-    return ZSTD_compressBegin_usingDict(cctx, NULL, 0, compressionLevel);
+    return ZSTD_compressBegin_usingDict_deprecated(cctx, NULL, 0, compressionLevel);
 }
 
 
@@ -5075,9 +5162,9 @@ void ZSTD_CCtx_trace(ZSTD_CCtx* cctx, size_t extraCSize)
 #endif
 }
 
-size_t ZSTD_compressEnd (ZSTD_CCtx* cctx,
-                         void* dst, size_t dstCapacity,
-                   const void* src, size_t srcSize)
+size_t ZSTD_compressEnd_public(ZSTD_CCtx* cctx,
+                               void* dst, size_t dstCapacity,
+                         const void* src, size_t srcSize)
 {
     size_t endResult;
     size_t const cSize = ZSTD_compressContinue_internal(cctx,
@@ -5101,6 +5188,14 @@ size_t ZSTD_compressEnd (ZSTD_CCtx* cctx,
     return cSize + endResult;
 }
 
+/* NOTE: Must just wrap ZSTD_compressEnd_public() */
+size_t ZSTD_compressEnd(ZSTD_CCtx* cctx,
+                        void* dst, size_t dstCapacity,
+                  const void* src, size_t srcSize)
+{
+    return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);
+}
+
 size_t ZSTD_compress_advanced (ZSTD_CCtx* cctx,
                                void* dst, size_t dstCapacity,
                          const void* src, size_t srcSize,
@@ -5129,7 +5224,7 @@ size_t ZSTD_compress_advanced_internal(
     FORWARD_IF_ERROR( ZSTD_compressBegin_internal(cctx,
                          dict, dictSize, ZSTD_dct_auto, ZSTD_dtlm_fast, NULL,
                          params, srcSize, ZSTDb_not_buffered) , "");
-    return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
+    return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);
 }
 
 size_t ZSTD_compress_usingDict(ZSTD_CCtx* cctx,
@@ -5451,6 +5546,7 @@ const ZSTD_CDict* ZSTD_initStaticCDict(
     params.cParams = cParams;
     params.useRowMatchFinder = useRowMatchFinder;
     cdict->useRowMatchFinder = useRowMatchFinder;
+    cdict->compressionLevel = ZSTD_NO_CLEVEL;
 
     if (ZSTD_isError( ZSTD_initCDict_internal(cdict,
                                               dict, dictSize,
@@ -5530,12 +5626,17 @@ size_t ZSTD_compressBegin_usingCDict_advanced(
 
 /* ZSTD_compressBegin_usingCDict() :
  * cdict must be != NULL */
-size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
+size_t ZSTD_compressBegin_usingCDict_deprecated(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
 {
     ZSTD_frameParameters const fParams = { 0 /*content*/, 0 /*checksum*/, 0 /*noDictID*/ };
     return ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, ZSTD_CONTENTSIZE_UNKNOWN);
 }
 
+size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict)
+{
+    return ZSTD_compressBegin_usingCDict_deprecated(cctx, cdict);
+}
+
 /*! ZSTD_compress_usingCDict_internal():
  * Implementation of various ZSTD_compress_usingCDict* functions.
  */
@@ -5545,7 +5646,7 @@ static size_t ZSTD_compress_usingCDict_internal(ZSTD_CCtx* cctx,
                                 const ZSTD_CDict* cdict, ZSTD_frameParameters fParams)
 {
     FORWARD_IF_ERROR(ZSTD_compressBegin_usingCDict_internal(cctx, cdict, fParams, srcSize), ""); /* will check if cdict != NULL */
-    return ZSTD_compressEnd(cctx, dst, dstCapacity, src, srcSize);
+    return ZSTD_compressEnd_public(cctx, dst, dstCapacity, src, srcSize);
 }
 
 /*! ZSTD_compress_usingCDict_advanced():
@@ -5803,7 +5904,7 @@ static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
                 || zcs->appliedParams.outBufferMode == ZSTD_bm_stable)  /* OR we are allowed to return dstSizeTooSmall */
               && (zcs->inBuffPos == 0) ) {
                 /* shortcut to compression pass directly into output buffer */
-                size_t const cSize = ZSTD_compressEnd(zcs,
+                size_t const cSize = ZSTD_compressEnd_public(zcs,
                                                 op, oend-op, ip, iend-ip);
                 DEBUGLOG(4, "ZSTD_compressEnd : cSize=%u", (unsigned)cSize);
                 FORWARD_IF_ERROR(cSize, "ZSTD_compressEnd failed");
@@ -5861,9 +5962,9 @@ static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
                 if (inputBuffered) {
                     unsigned const lastBlock = (flushMode == ZSTD_e_end) && (ip==iend);
                     cSize = lastBlock ?
-                            ZSTD_compressEnd(zcs, cDst, oSize,
+                            ZSTD_compressEnd_public(zcs, cDst, oSize,
                                         zcs->inBuff + zcs->inToCompress, iSize) :
-                            ZSTD_compressContinue(zcs, cDst, oSize,
+                            ZSTD_compressContinue_public(zcs, cDst, oSize,
                                         zcs->inBuff + zcs->inToCompress, iSize);
                     FORWARD_IF_ERROR(cSize, "%s", lastBlock ? "ZSTD_compressEnd failed" : "ZSTD_compressContinue failed");
                     zcs->frameEnded = lastBlock;
@@ -5879,8 +5980,8 @@ static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
                 } else { /* !inputBuffered, hence ZSTD_bm_stable */
                     unsigned const lastBlock = (flushMode == ZSTD_e_end) && (ip + iSize == iend);
                     cSize = lastBlock ?
-                            ZSTD_compressEnd(zcs, cDst, oSize, ip, iSize) :
-                            ZSTD_compressContinue(zcs, cDst, oSize, ip, iSize);
+                            ZSTD_compressEnd_public(zcs, cDst, oSize, ip, iSize) :
+                            ZSTD_compressContinue_public(zcs, cDst, oSize, ip, iSize);
                     /* Consume the input prior to error checking to mirror buffered mode. */
                     if (ip) ip += iSize;
                     FORWARD_IF_ERROR(cSize, "%s", lastBlock ? "ZSTD_compressEnd failed" : "ZSTD_compressContinue failed");
diff --git a/libfenrir/src/main/jni/compress/zstd/compress/zstd_compress_internal.h b/libfenrir/src/main/jni/compress/zstd/compress/zstd_compress_internal.h
index cbb85e527..10f68d010 100644
--- a/libfenrir/src/main/jni/compress/zstd/compress/zstd_compress_internal.h
+++ b/libfenrir/src/main/jni/compress/zstd/compress/zstd_compress_internal.h
@@ -226,8 +226,10 @@ struct ZSTD_matchState_t {
     U32 hashLog3;           /* dispatch table for matches of len==3 : larger == faster, more memory */
 
     U32 rowHashLog;                          /* For row-based matchfinder: Hashlog based on nb of rows in the hashTable.*/
-    U16* tagTable;                           /* For row-based matchFinder: A row-based table containing the hashes and head index. */
+    BYTE* tagTable;                          /* For row-based matchFinder: A row-based table containing the hashes and head index. */
     U32 hashCache[ZSTD_ROW_HASH_CACHE_SIZE]; /* For row-based matchFinder: a cache of hashes to improve speed */
+    U64 hashSalt;                            /* For row-based matchFinder: salts the hash for re-use of tag table */
+    U32 hashSaltEntropy;                     /* For row-based matchFinder: collects entropy for salt generation */
 
     U32* hashTable;
     U32* hashTable3;
@@ -247,6 +249,13 @@ struct ZSTD_matchState_t {
      * This behavior is controlled from the cctx ms.
      * This parameter has no effect in the cdict ms. */
     int prefetchCDictTables;
+
+    /* When == 0, lazy match finders insert every position.
+     * When != 0, lazy match finders only insert positions they search.
+     * This allows them to skip much faster over incompressible data,
+     * at a small cost to compression ratio.
+     */
+    int lazySkipping;
 };
 
 typedef struct {
@@ -787,28 +796,35 @@ ZSTD_count_2segments(const BYTE* ip, const BYTE* match,
  *  Hashes
  ***************************************/
 static const U32 prime3bytes = 506832829U;
-static U32    ZSTD_hash3(U32 u, U32 h) { assert(h <= 32); return ((u << (32-24)) * prime3bytes)  >> (32-h) ; }
-MEM_STATIC size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h); } /* only in zstd_opt.h */
+static U32    ZSTD_hash3(U32 u, U32 h, U32 s) { assert(h <= 32); return (((u << (32-24)) * prime3bytes) ^ s)  >> (32-h) ; }
+MEM_STATIC size_t ZSTD_hash3Ptr(const void* ptr, U32 h) { return ZSTD_hash3(MEM_readLE32(ptr), h, 0); } /* only in zstd_opt.h */
+MEM_STATIC size_t ZSTD_hash3PtrS(const void* ptr, U32 h, U32 s) { return ZSTD_hash3(MEM_readLE32(ptr), h, s); }
 
 static const U32 prime4bytes = 2654435761U;
-static U32    ZSTD_hash4(U32 u, U32 h) { assert(h <= 32); return (u * prime4bytes) >> (32-h) ; }
-static size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_readLE32(ptr), h); }
+static U32    ZSTD_hash4(U32 u, U32 h, U32 s) { assert(h <= 32); return ((u * prime4bytes) ^ s) >> (32-h) ; }
+static size_t ZSTD_hash4Ptr(const void* ptr, U32 h) { return ZSTD_hash4(MEM_readLE32(ptr), h, 0); }
+static size_t ZSTD_hash4PtrS(const void* ptr, U32 h, U32 s) { return ZSTD_hash4(MEM_readLE32(ptr), h, s); }
 
 static const U64 prime5bytes = 889523592379ULL;
-static size_t ZSTD_hash5(U64 u, U32 h) { assert(h <= 64); return (size_t)(((u  << (64-40)) * prime5bytes) >> (64-h)) ; }
-static size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h); }
+static size_t ZSTD_hash5(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u  << (64-40)) * prime5bytes) ^ s) >> (64-h)) ; }
+static size_t ZSTD_hash5Ptr(const void* p, U32 h) { return ZSTD_hash5(MEM_readLE64(p), h, 0); }
+static size_t ZSTD_hash5PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash5(MEM_readLE64(p), h, s); }
 
 static const U64 prime6bytes = 227718039650203ULL;
-static size_t ZSTD_hash6(U64 u, U32 h) { assert(h <= 64); return (size_t)(((u  << (64-48)) * prime6bytes) >> (64-h)) ; }
-static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h); }
+static size_t ZSTD_hash6(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u  << (64-48)) * prime6bytes) ^ s) >> (64-h)) ; }
+static size_t ZSTD_hash6Ptr(const void* p, U32 h) { return ZSTD_hash6(MEM_readLE64(p), h, 0); }
+static size_t ZSTD_hash6PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash6(MEM_readLE64(p), h, s); }
 
 static const U64 prime7bytes = 58295818150454627ULL;
-static size_t ZSTD_hash7(U64 u, U32 h) { assert(h <= 64); return (size_t)(((u  << (64-56)) * prime7bytes) >> (64-h)) ; }
-static size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h); }
+static size_t ZSTD_hash7(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u  << (64-56)) * prime7bytes) ^ s) >> (64-h)) ; }
+static size_t ZSTD_hash7Ptr(const void* p, U32 h) { return ZSTD_hash7(MEM_readLE64(p), h, 0); }
+static size_t ZSTD_hash7PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash7(MEM_readLE64(p), h, s); }
 
 static const U64 prime8bytes = 0xCF1BBCDCB7A56463ULL;
-static size_t ZSTD_hash8(U64 u, U32 h) { assert(h <= 64); return (size_t)(((u) * prime8bytes) >> (64-h)) ; }
-static size_t ZSTD_hash8Ptr(const void* p, U32 h) { return ZSTD_hash8(MEM_readLE64(p), h); }
+static size_t ZSTD_hash8(U64 u, U32 h, U64 s) { assert(h <= 64); return (size_t)((((u) * prime8bytes)  ^ s) >> (64-h)) ; }
+static size_t ZSTD_hash8Ptr(const void* p, U32 h) { return ZSTD_hash8(MEM_readLE64(p), h, 0); }
+static size_t ZSTD_hash8PtrS(const void* p, U32 h, U64 s) { return ZSTD_hash8(MEM_readLE64(p), h, s); }
+
 
 MEM_STATIC FORCE_INLINE_ATTR
 size_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls)
@@ -828,6 +844,24 @@ size_t ZSTD_hashPtr(const void* p, U32 hBits, U32 mls)
     }
 }
 
+MEM_STATIC FORCE_INLINE_ATTR
+size_t ZSTD_hashPtrSalted(const void* p, U32 hBits, U32 mls, const U64 hashSalt) {
+    /* Although some of these hashes do support hBits up to 64, some do not.
+     * To be on the safe side, always avoid hBits > 32. */
+    assert(hBits <= 32);
+
+    switch(mls)
+    {
+        default:
+        case 4: return ZSTD_hash4PtrS(p, hBits, (U32)hashSalt);
+        case 5: return ZSTD_hash5PtrS(p, hBits, hashSalt);
+        case 6: return ZSTD_hash6PtrS(p, hBits, hashSalt);
+        case 7: return ZSTD_hash7PtrS(p, hBits, hashSalt);
+        case 8: return ZSTD_hash8PtrS(p, hBits, hashSalt);
+    }
+}
+
+
 /** ZSTD_ipow() :
  * Return base^exponent.
  */
@@ -1475,4 +1509,24 @@ ZSTD_copySequencesToSeqStoreNoBlockDelim(ZSTD_CCtx* cctx, ZSTD_sequencePosition*
                                    const ZSTD_Sequence* const inSeqs, size_t inSeqsSize,
                                    const void* src, size_t blockSize, ZSTD_paramSwitch_e externalRepSearch);
 
+
+/* ===============================================================
+ * Deprecated definitions that are still used internally to avoid
+ * deprecation warnings. These functions are exactly equivalent to
+ * their public variants, but avoid the deprecation warnings.
+ * =============================================================== */
+
+size_t ZSTD_compressBegin_usingCDict_deprecated(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);
+
+size_t ZSTD_compressContinue_public(ZSTD_CCtx* cctx,
+                                    void* dst, size_t dstCapacity,
+                              const void* src, size_t srcSize);
+
+size_t ZSTD_compressEnd_public(ZSTD_CCtx* cctx,
+                               void* dst, size_t dstCapacity,
+                         const void* src, size_t srcSize);
+
+size_t ZSTD_compressBlock_deprecated(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+
+
 #endif /* ZSTD_COMPRESS_H */
diff --git a/libfenrir/src/main/jni/compress/zstd/compress/zstd_cwksp.h b/libfenrir/src/main/jni/compress/zstd/compress/zstd_cwksp.h
index 97676693b..cc7fb1c71 100644
--- a/libfenrir/src/main/jni/compress/zstd/compress/zstd_cwksp.h
+++ b/libfenrir/src/main/jni/compress/zstd/compress/zstd_cwksp.h
@@ -14,7 +14,9 @@
 /*-*************************************
 *  Dependencies
 ***************************************/
+#include "../common/allocations.h"  /* ZSTD_customMalloc, ZSTD_customFree */
 #include "../common/zstd_internal.h"
+#include "../common/portability_macros.h"
 
 #if defined (__cplusplus)
 extern "C" {
@@ -44,8 +46,9 @@ extern "C" {
 ***************************************/
 typedef enum {
     ZSTD_cwksp_alloc_objects,
-    ZSTD_cwksp_alloc_buffers,
-    ZSTD_cwksp_alloc_aligned
+    ZSTD_cwksp_alloc_aligned_init_once,
+    ZSTD_cwksp_alloc_aligned,
+    ZSTD_cwksp_alloc_buffers
 } ZSTD_cwksp_alloc_phase_e;
 
 /**
@@ -98,8 +101,8 @@ typedef enum {
  *
  * Workspace Layout:
  *
- * [                        ... workspace ...                         ]
- * [objects][tables ... ->] free space [<- ... aligned][<- ... buffers]
+ * [                        ... workspace ...                           ]
+ * [objects][tables ->] free space [<- buffers][<- aligned][<- init once]
  *
  * The various objects that live in the workspace are divided into the
  * following categories, and are allocated separately:
@@ -123,9 +126,18 @@ typedef enum {
  *   uint32_t arrays, all of whose values are between 0 and (nextSrc - base).
  *   Their sizes depend on the cparams. These tables are 64-byte aligned.
  *
- * - Aligned: these buffers are used for various purposes that require 4 byte
- *   alignment, but don't require any initialization before they're used. These
- *   buffers are each aligned to 64 bytes.
+ * - Init once: these buffers require to be initialized at least once before
+ *   use. They should be used when we want to skip memory initialization
+ *   while not triggering memory checkers (like Valgrind) when reading from
+ *   from this memory without writing to it first.
+ *   These buffers should be used carefully as they might contain data
+ *   from previous compressions.
+ *   Buffers are aligned to 64 bytes.
+ *
+ * - Aligned: these buffers don't require any initialization before they're
+ *   used. The user of the buffer should make sure they write into a buffer
+ *   location before reading from it.
+ *   Buffers are aligned to 64 bytes.
  *
  * - Buffers: these buffers are used for various purposes that don't require
  *   any alignment or initialization before they're used. This means they can
@@ -137,8 +149,9 @@ typedef enum {
  * correctly packed into the workspace buffer. That order is:
  *
  * 1. Objects
- * 2. Buffers
- * 3. Aligned/Tables
+ * 2. Init once / Tables
+ * 3. Aligned / Tables
+ * 4. Buffers / Tables
  *
  * Attempts to reserve objects of different types out of order will fail.
  */
@@ -150,6 +163,7 @@ typedef struct {
     void* tableEnd;
     void* tableValidEnd;
     void* allocStart;
+    void* initOnceStart;
 
     BYTE allocFailed;
     int workspaceOversizedDuration;
@@ -162,6 +176,7 @@ typedef struct {
 ***************************************/
 
 MEM_STATIC size_t ZSTD_cwksp_available_space(ZSTD_cwksp* ws);
+MEM_STATIC void*  ZSTD_cwksp_initialAllocStart(ZSTD_cwksp* ws);
 
 MEM_STATIC void ZSTD_cwksp_assert_internal_consistency(ZSTD_cwksp* ws) {
     (void)ws;
@@ -171,6 +186,20 @@ MEM_STATIC void ZSTD_cwksp_assert_internal_consistency(ZSTD_cwksp* ws) {
     assert(ws->tableEnd <= ws->allocStart);
     assert(ws->tableValidEnd <= ws->allocStart);
     assert(ws->allocStart <= ws->workspaceEnd);
+    assert(ws->initOnceStart <= ZSTD_cwksp_initialAllocStart(ws));
+    assert(ws->workspace <= ws->initOnceStart);
+#if ZSTD_MEMORY_SANITIZER
+    {
+        intptr_t const offset = __msan_test_shadow(ws->initOnceStart,
+            (U8*)ZSTD_cwksp_initialAllocStart(ws) - (U8*)ws->initOnceStart);
+#if defined(ZSTD_MSAN_PRINT)
+        if(offset!=-1) {
+            __msan_print_shadow((U8*)ws->initOnceStart + offset - 8, 32);
+        }
+#endif
+        assert(offset==-1);
+    };
+#endif
 }
 
 /**
@@ -217,14 +246,10 @@ MEM_STATIC size_t ZSTD_cwksp_aligned_alloc_size(size_t size) {
  * for internal purposes (currently only alignment).
  */
 MEM_STATIC size_t ZSTD_cwksp_slack_space_required(void) {
-    /* For alignment, the wksp will always allocate an additional n_1=[1, 64] bytes
-     * to align the beginning of tables section, as well as another n_2=[0, 63] bytes
-     * to align the beginning of the aligned section.
-     *
-     * n_1 + n_2 == 64 bytes if the cwksp is freshly allocated, due to tables and
-     * aligneds being sized in multiples of 64 bytes.
+    /* For alignment, the wksp will always allocate an additional 2*ZSTD_CWKSP_ALIGNMENT_BYTES
+     * bytes to align the beginning of tables section and end of buffers;
      */
-    size_t const slackSpace = ZSTD_CWKSP_ALIGNMENT_BYTES;
+    size_t const slackSpace = ZSTD_CWKSP_ALIGNMENT_BYTES * 2;
     return slackSpace;
 }
 
@@ -237,10 +262,18 @@ MEM_STATIC size_t ZSTD_cwksp_bytes_to_align_ptr(void* ptr, const size_t alignByt
     size_t const alignBytesMask = alignBytes - 1;
     size_t const bytes = (alignBytes - ((size_t)ptr & (alignBytesMask))) & alignBytesMask;
     assert((alignBytes & alignBytesMask) == 0);
-    assert(bytes != ZSTD_CWKSP_ALIGNMENT_BYTES);
+    assert(bytes < alignBytes);
     return bytes;
 }
 
+/**
+ * Returns the initial value for allocStart which is used to determine the position from
+ * which we can allocate from the end of the workspace.
+ */
+MEM_STATIC void*  ZSTD_cwksp_initialAllocStart(ZSTD_cwksp* ws) {
+    return (void*)((size_t)ws->workspaceEnd & ~(ZSTD_CWKSP_ALIGNMENT_BYTES-1));
+}
+
 /**
  * Internal function. Do not use directly.
  * Reserves the given number of bytes within the aligned/buffer segment of the wksp,
@@ -281,27 +314,16 @@ ZSTD_cwksp_internal_advance_phase(ZSTD_cwksp* ws, ZSTD_cwksp_alloc_phase_e phase
 {
     assert(phase >= ws->phase);
     if (phase > ws->phase) {
-        /* Going from allocating objects to allocating buffers */
-        if (ws->phase < ZSTD_cwksp_alloc_buffers &&
-                phase >= ZSTD_cwksp_alloc_buffers) {
+        /* Going from allocating objects to allocating initOnce / tables */
+        if (ws->phase < ZSTD_cwksp_alloc_aligned_init_once &&
+            phase >= ZSTD_cwksp_alloc_aligned_init_once) {
             ws->tableValidEnd = ws->objectEnd;
-        }
+            ws->initOnceStart = ZSTD_cwksp_initialAllocStart(ws);
 
-        /* Going from allocating buffers to allocating aligneds/tables */
-        if (ws->phase < ZSTD_cwksp_alloc_aligned &&
-                phase >= ZSTD_cwksp_alloc_aligned) {
-            {   /* Align the start of the "aligned" to 64 bytes. Use [1, 64] bytes. */
-                size_t const bytesToAlign =
-                    ZSTD_CWKSP_ALIGNMENT_BYTES - ZSTD_cwksp_bytes_to_align_ptr(ws->allocStart, ZSTD_CWKSP_ALIGNMENT_BYTES);
-                DEBUGLOG(5, "reserving aligned alignment addtl space: %zu", bytesToAlign);
-                ZSTD_STATIC_ASSERT((ZSTD_CWKSP_ALIGNMENT_BYTES & (ZSTD_CWKSP_ALIGNMENT_BYTES - 1)) == 0); /* power of 2 */
-                RETURN_ERROR_IF(!ZSTD_cwksp_reserve_internal_buffer_space(ws, bytesToAlign),
-                                memory_allocation, "aligned phase - alignment initial allocation failed!");
-            }
             {   /* Align the start of the tables to 64 bytes. Use [0, 63] bytes */
-                void* const alloc = ws->objectEnd;
+                void *const alloc = ws->objectEnd;
                 size_t const bytesToAlign = ZSTD_cwksp_bytes_to_align_ptr(alloc, ZSTD_CWKSP_ALIGNMENT_BYTES);
-                void* const objectEnd = (BYTE*)alloc + bytesToAlign;
+                void *const objectEnd = (BYTE *) alloc + bytesToAlign;
                 DEBUGLOG(5, "reserving table alignment addtl space: %zu", bytesToAlign);
                 RETURN_ERROR_IF(objectEnd > ws->workspaceEnd, memory_allocation,
                                 "table phase - alignment initial allocation failed!");
@@ -309,7 +331,9 @@ ZSTD_cwksp_internal_advance_phase(ZSTD_cwksp* ws, ZSTD_cwksp_alloc_phase_e phase
                 ws->tableEnd = objectEnd;  /* table area starts being empty */
                 if (ws->tableValidEnd < ws->tableEnd) {
                     ws->tableValidEnd = ws->tableEnd;
-        }   }   }
+                }
+            }
+        }
         ws->phase = phase;
         ZSTD_cwksp_assert_internal_consistency(ws);
     }
@@ -321,7 +345,7 @@ ZSTD_cwksp_internal_advance_phase(ZSTD_cwksp* ws, ZSTD_cwksp_alloc_phase_e phase
  */
 MEM_STATIC int ZSTD_cwksp_owns_buffer(const ZSTD_cwksp* ws, const void* ptr)
 {
-    return (ptr != NULL) && (ws->workspace <= ptr) && (ptr <= ws->workspaceEnd);
+    return (ptr != NULL) && (ws->workspace <= ptr) && (ptr < ws->workspaceEnd);
 }
 
 /**
@@ -366,6 +390,36 @@ MEM_STATIC BYTE* ZSTD_cwksp_reserve_buffer(ZSTD_cwksp* ws, size_t bytes)
     return (BYTE*)ZSTD_cwksp_reserve_internal(ws, bytes, ZSTD_cwksp_alloc_buffers);
 }
 
+/**
+ * Reserves and returns memory sized on and aligned on ZSTD_CWKSP_ALIGNMENT_BYTES (64 bytes).
+ * This memory has been initialized at least once in the past.
+ * This doesn't mean it has been initialized this time, and it might contain data from previous
+ * operations.
+ * The main usage is for algorithms that might need read access into uninitialized memory.
+ * The algorithm must maintain safety under these conditions and must make sure it doesn't
+ * leak any of the past data (directly or in side channels).
+ */
+MEM_STATIC void* ZSTD_cwksp_reserve_aligned_init_once(ZSTD_cwksp* ws, size_t bytes)
+{
+    size_t const alignedBytes = ZSTD_cwksp_align(bytes, ZSTD_CWKSP_ALIGNMENT_BYTES);
+    void* ptr = ZSTD_cwksp_reserve_internal(ws, alignedBytes, ZSTD_cwksp_alloc_aligned_init_once);
+    assert(((size_t)ptr & (ZSTD_CWKSP_ALIGNMENT_BYTES-1))== 0);
+    if(ptr && ptr < ws->initOnceStart) {
+        /* We assume the memory following the current allocation is either:
+         * 1. Not usable as initOnce memory (end of workspace)
+         * 2. Another initOnce buffer that has been allocated before (and so was previously memset)
+         * 3. An ASAN redzone, in which case we don't want to write on it
+         * For these reasons it should be fine to not explicitly zero every byte up to ws->initOnceStart.
+         * Note that we assume here that MSAN and ASAN cannot run in the same time. */
+        ZSTD_memset(ptr, 0, MIN((size_t)((U8*)ws->initOnceStart - (U8*)ptr), alignedBytes));
+        ws->initOnceStart = ptr;
+    }
+#if ZSTD_MEMORY_SANITIZER
+    assert(__msan_test_shadow(ptr, bytes) == -1);
+#endif
+    return ptr;
+}
+
 /**
  * Reserves and returns memory sized on and aligned on ZSTD_CWKSP_ALIGNMENT_BYTES (64 bytes).
  */
@@ -384,13 +438,17 @@ MEM_STATIC void* ZSTD_cwksp_reserve_aligned(ZSTD_cwksp* ws, size_t bytes)
  */
 MEM_STATIC void* ZSTD_cwksp_reserve_table(ZSTD_cwksp* ws, size_t bytes)
 {
-    const ZSTD_cwksp_alloc_phase_e phase = ZSTD_cwksp_alloc_aligned;
+    const ZSTD_cwksp_alloc_phase_e phase = ZSTD_cwksp_alloc_aligned_init_once;
     void* alloc;
     void* end;
     void* top;
 
-    if (ZSTD_isError(ZSTD_cwksp_internal_advance_phase(ws, phase))) {
-        return NULL;
+    /* We can only start allocating tables after we are done reserving space for objects at the
+     * start of the workspace */
+    if(ws->phase < phase) {
+        if (ZSTD_isError(ZSTD_cwksp_internal_advance_phase(ws, phase))) {
+            return NULL;
+        }
     }
     alloc = ws->tableEnd;
     end = (BYTE *)alloc + bytes;
@@ -469,11 +527,19 @@ MEM_STATIC void ZSTD_cwksp_mark_tables_dirty(ZSTD_cwksp* ws)
 #if ZSTD_MEMORY_SANITIZER && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)
     /* To validate that the table re-use logic is sound, and that we don't
      * access table space that we haven't cleaned, we re-"poison" the table
-     * space every time we mark it dirty. */
+     * space every time we mark it dirty.
+     * Since tableValidEnd space and initOnce space may overlap we don't poison
+     * the initOnce portion as it break its promise. This means that this poisoning
+     * check isn't always applied fully. */
     {
         size_t size = (BYTE*)ws->tableValidEnd - (BYTE*)ws->objectEnd;
         assert(__msan_test_shadow(ws->objectEnd, size) == -1);
-        __msan_poison(ws->objectEnd, size);
+        if((BYTE*)ws->tableValidEnd < (BYTE*)ws->initOnceStart) {
+            __msan_poison(ws->objectEnd, size);
+        } else {
+            assert(ws->initOnceStart >= ws->objectEnd);
+            __msan_poison(ws->objectEnd, (BYTE*)ws->initOnceStart - (BYTE*)ws->objectEnd);
+        }
     }
 #endif
 
@@ -538,11 +604,14 @@ MEM_STATIC void ZSTD_cwksp_clear(ZSTD_cwksp* ws) {
 #if ZSTD_MEMORY_SANITIZER && !defined (ZSTD_MSAN_DONT_POISON_WORKSPACE)
     /* To validate that the context re-use logic is sound, and that we don't
      * access stuff that this compression hasn't initialized, we re-"poison"
-     * the workspace (or at least the non-static, non-table parts of it)
-     * every time we start a new compression. */
+     * the workspace except for the areas in which we expect memory re-use
+     * without initialization (objects, valid tables area and init once
+     * memory). */
     {
-        size_t size = (BYTE*)ws->workspaceEnd - (BYTE*)ws->tableValidEnd;
-        __msan_poison(ws->tableValidEnd, size);
+        if((BYTE*)ws->tableValidEnd < (BYTE*)ws->initOnceStart) {
+            size_t size = (BYTE*)ws->initOnceStart - (BYTE*)ws->tableValidEnd;
+            __msan_poison(ws->tableValidEnd, size);
+        }
     }
 #endif
 
@@ -558,10 +627,10 @@ MEM_STATIC void ZSTD_cwksp_clear(ZSTD_cwksp* ws) {
 #endif
 
     ws->tableEnd = ws->objectEnd;
-    ws->allocStart = ws->workspaceEnd;
+    ws->allocStart = ZSTD_cwksp_initialAllocStart(ws);
     ws->allocFailed = 0;
-    if (ws->phase > ZSTD_cwksp_alloc_buffers) {
-        ws->phase = ZSTD_cwksp_alloc_buffers;
+    if (ws->phase > ZSTD_cwksp_alloc_aligned_init_once) {
+        ws->phase = ZSTD_cwksp_alloc_aligned_init_once;
     }
     ZSTD_cwksp_assert_internal_consistency(ws);
 }
@@ -578,6 +647,7 @@ MEM_STATIC void ZSTD_cwksp_init(ZSTD_cwksp* ws, void* start, size_t size, ZSTD_c
     ws->workspaceEnd = (BYTE*)start + size;
     ws->objectEnd = ws->workspace;
     ws->tableValidEnd = ws->objectEnd;
+    ws->initOnceStart = ZSTD_cwksp_initialAllocStart(ws);
     ws->phase = ZSTD_cwksp_alloc_objects;
     ws->isStatic = isStatic;
     ZSTD_cwksp_clear(ws);
@@ -630,17 +700,11 @@ MEM_STATIC int ZSTD_cwksp_reserve_failed(const ZSTD_cwksp* ws) {
  * Returns if the estimated space needed for a wksp is within an acceptable limit of the
  * actual amount of space used.
  */
-MEM_STATIC int ZSTD_cwksp_estimated_space_within_bounds(const ZSTD_cwksp* const ws,
-                                                        size_t const estimatedSpace, int resizedWorkspace) {
-    if (resizedWorkspace) {
-        /* Resized/newly allocated wksp should have exact bounds */
-        return ZSTD_cwksp_used(ws) == estimatedSpace;
-    } else {
-        /* Due to alignment, when reusing a workspace, we can actually consume 63 fewer or more bytes
-         * than estimatedSpace. See the comments in zstd_cwksp.h for details.
-         */
-        return (ZSTD_cwksp_used(ws) >= estimatedSpace - 63) && (ZSTD_cwksp_used(ws) <= estimatedSpace + 63);
-    }
+MEM_STATIC int ZSTD_cwksp_estimated_space_within_bounds(const ZSTD_cwksp *const ws, size_t const estimatedSpace) {
+    /* We have an alignment space between objects and tables between tables and buffers, so we can have up to twice
+     * the alignment bytes difference between estimation and actual usage */
+    return (estimatedSpace - ZSTD_cwksp_slack_space_required()) <= ZSTD_cwksp_used(ws) &&
+           ZSTD_cwksp_used(ws) <= estimatedSpace;
 }
 
 
diff --git a/libfenrir/src/main/jni/compress/zstd/compress/zstd_lazy.c b/libfenrir/src/main/jni/compress/zstd/compress/zstd_lazy.c
index a24734272..5ba88e867 100644
--- a/libfenrir/src/main/jni/compress/zstd/compress/zstd_lazy.c
+++ b/libfenrir/src/main/jni/compress/zstd/compress/zstd_lazy.c
@@ -12,6 +12,8 @@
 #include "zstd_lazy.h"
 #include "../common/bits.h" /* ZSTD_countTrailingZeros64 */
 
+#define kLazySkippingStep 8
+
 
 /*-*************************************
 *  Binary Tree search
@@ -618,7 +620,7 @@ size_t ZSTD_dedicatedDictSearch_lazy_search(size_t* offsetPtr, size_t ml, U32 nb
 FORCE_INLINE_TEMPLATE U32 ZSTD_insertAndFindFirstIndex_internal(
                         ZSTD_matchState_t* ms,
                         const ZSTD_compressionParameters* const cParams,
-                        const BYTE* ip, U32 const mls)
+                        const BYTE* ip, U32 const mls, U32 const lazySkipping)
 {
     U32* const hashTable  = ms->hashTable;
     const U32 hashLog = cParams->hashLog;
@@ -633,6 +635,9 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_insertAndFindFirstIndex_internal(
         NEXT_IN_CHAIN(idx, chainMask) = hashTable[h];
         hashTable[h] = idx;
         idx++;
+        /* Stop inserting every position when in the lazy skipping mode. */
+        if (lazySkipping)
+            break;
     }
 
     ms->nextToUpdate = target;
@@ -641,7 +646,7 @@ FORCE_INLINE_TEMPLATE U32 ZSTD_insertAndFindFirstIndex_internal(
 
 U32 ZSTD_insertAndFindFirstIndex(ZSTD_matchState_t* ms, const BYTE* ip) {
     const ZSTD_compressionParameters* const cParams = &ms->cParams;
-    return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.minMatch);
+    return ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, ms->cParams.minMatch, /* lazySkipping*/ 0);
 }
 
 /* inlining is important to hardwire a hot branch (template emulation) */
@@ -685,7 +690,7 @@ size_t ZSTD_HcFindBestMatch(
     }
 
     /* HC4 match finder */
-    matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls);
+    matchIndex = ZSTD_insertAndFindFirstIndex_internal(ms, cParams, ip, mls, ms->lazySkipping);
 
     for ( ; (matchIndex>=lowLimit) & (nbAttempts>0) ; nbAttempts--) {
         size_t currentMl=0;
@@ -758,7 +763,6 @@ size_t ZSTD_HcFindBestMatch(
 * (SIMD) Row-based matchfinder
 ***********************************/
 /* Constants for row-based hash */
-#define ZSTD_ROW_HASH_TAG_OFFSET 16     /* byte offset of hashes in the match state's tagTable from the beginning of a row */
 #define ZSTD_ROW_HASH_TAG_MASK ((1u << ZSTD_ROW_HASH_TAG_BITS) - 1)
 #define ZSTD_ROW_HASH_MAX_ENTRIES 64    /* absolute maximum number of entries per row, for all configurations */
 
@@ -774,39 +778,15 @@ MEM_STATIC U32 ZSTD_VecMask_next(ZSTD_VecMask val) {
     return ZSTD_countTrailingZeros64(val);
 }
 
-/* ZSTD_rotateRight_*():
- * Rotates a bitfield to the right by "count" bits.
- * https://en.wikipedia.org/w/index.php?title=Circular_shift&oldid=991635599#Implementing_circular_shifts
- */
-FORCE_INLINE_TEMPLATE
-U64 ZSTD_rotateRight_U64(U64 const value, U32 count) {
-    assert(count < 64);
-    count &= 0x3F; /* for fickle pattern recognition */
-    return (value >> count) | (U64)(value << ((0U - count) & 0x3F));
-}
-
-FORCE_INLINE_TEMPLATE
-U32 ZSTD_rotateRight_U32(U32 const value, U32 count) {
-    assert(count < 32);
-    count &= 0x1F; /* for fickle pattern recognition */
-    return (value >> count) | (U32)(value << ((0U - count) & 0x1F));
-}
-
-FORCE_INLINE_TEMPLATE
-U16 ZSTD_rotateRight_U16(U16 const value, U32 count) {
-    assert(count < 16);
-    count &= 0x0F; /* for fickle pattern recognition */
-    return (value >> count) | (U16)(value << ((0U - count) & 0x0F));
-}
-
 /* ZSTD_row_nextIndex():
  * Returns the next index to insert at within a tagTable row, and updates the "head"
- * value to reflect the update. Essentially cycles backwards from [0, {entries per row})
+ * value to reflect the update. Essentially cycles backwards from [1, {entries per row})
  */
 FORCE_INLINE_TEMPLATE U32 ZSTD_row_nextIndex(BYTE* const tagRow, U32 const rowMask) {
-  U32 const next = (*tagRow - 1) & rowMask;
-  *tagRow = (BYTE)next;
-  return next;
+    U32 next = (*tagRow-1) & rowMask;
+    next += (next == 0) ? rowMask : 0; /* skip first position */
+    *tagRow = (BYTE)next;
+    return next;
 }
 
 /* ZSTD_isAligned():
@@ -820,7 +800,7 @@ MEM_STATIC int ZSTD_isAligned(void const* ptr, size_t align) {
 /* ZSTD_row_prefetch():
  * Performs prefetching for the hashTable and tagTable at a given row.
  */
-FORCE_INLINE_TEMPLATE void ZSTD_row_prefetch(U32 const* hashTable, U16 const* tagTable, U32 const relRow, U32 const rowLog) {
+FORCE_INLINE_TEMPLATE void ZSTD_row_prefetch(U32 const* hashTable, BYTE const* tagTable, U32 const relRow, U32 const rowLog) {
     PREFETCH_L1(hashTable + relRow);
     if (rowLog >= 5) {
         PREFETCH_L1(hashTable + relRow + 16);
@@ -844,13 +824,13 @@ FORCE_INLINE_TEMPLATE void ZSTD_row_fillHashCache(ZSTD_matchState_t* ms, const B
                                    U32 idx, const BYTE* const iLimit)
 {
     U32 const* const hashTable = ms->hashTable;
-    U16 const* const tagTable = ms->tagTable;
+    BYTE const* const tagTable = ms->tagTable;
     U32 const hashLog = ms->rowHashLog;
     U32 const maxElemsToPrefetch = (base + idx) > iLimit ? 0 : (U32)(iLimit - (base + idx) + 1);
     U32 const lim = idx + MIN(ZSTD_ROW_HASH_CACHE_SIZE, maxElemsToPrefetch);
 
     for (; idx < lim; ++idx) {
-        U32 const hash = (U32)ZSTD_hashPtr(base + idx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls);
+        U32 const hash = (U32)ZSTD_hashPtrSalted(base + idx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, ms->hashSalt);
         U32 const row = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;
         ZSTD_row_prefetch(hashTable, tagTable, row, rowLog);
         ms->hashCache[idx & ZSTD_ROW_HASH_CACHE_MASK] = hash;
@@ -866,11 +846,12 @@ FORCE_INLINE_TEMPLATE void ZSTD_row_fillHashCache(ZSTD_matchState_t* ms, const B
  * base + idx + ZSTD_ROW_HASH_CACHE_SIZE. Also prefetches the appropriate rows from hashTable and tagTable.
  */
 FORCE_INLINE_TEMPLATE U32 ZSTD_row_nextCachedHash(U32* cache, U32 const* hashTable,
-                                                  U16 const* tagTable, BYTE const* base,
+                                                  BYTE const* tagTable, BYTE const* base,
                                                   U32 idx, U32 const hashLog,
-                                                  U32 const rowLog, U32 const mls)
+                                                  U32 const rowLog, U32 const mls,
+                                                  U64 const hashSalt)
 {
-    U32 const newHash = (U32)ZSTD_hashPtr(base+idx+ZSTD_ROW_HASH_CACHE_SIZE, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls);
+    U32 const newHash = (U32)ZSTD_hashPtrSalted(base+idx+ZSTD_ROW_HASH_CACHE_SIZE, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, hashSalt);
     U32 const row = (newHash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;
     ZSTD_row_prefetch(hashTable, tagTable, row, rowLog);
     {   U32 const hash = cache[idx & ZSTD_ROW_HASH_CACHE_MASK];
@@ -888,22 +869,21 @@ FORCE_INLINE_TEMPLATE void ZSTD_row_update_internalImpl(ZSTD_matchState_t* ms,
                                                         U32 const rowMask, U32 const useCache)
 {
     U32* const hashTable = ms->hashTable;
-    U16* const tagTable = ms->tagTable;
+    BYTE* const tagTable = ms->tagTable;
     U32 const hashLog = ms->rowHashLog;
     const BYTE* const base = ms->window.base;
 
     DEBUGLOG(6, "ZSTD_row_update_internalImpl(): updateStartIdx=%u, updateEndIdx=%u", updateStartIdx, updateEndIdx);
     for (; updateStartIdx < updateEndIdx; ++updateStartIdx) {
-        U32 const hash = useCache ? ZSTD_row_nextCachedHash(ms->hashCache, hashTable, tagTable, base, updateStartIdx, hashLog, rowLog, mls)
-                                  : (U32)ZSTD_hashPtr(base + updateStartIdx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls);
+        U32 const hash = useCache ? ZSTD_row_nextCachedHash(ms->hashCache, hashTable, tagTable, base, updateStartIdx, hashLog, rowLog, mls, ms->hashSalt)
+                                  : (U32)ZSTD_hashPtrSalted(base + updateStartIdx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, ms->hashSalt);
         U32 const relRow = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;
         U32* const row = hashTable + relRow;
-        BYTE* tagRow = (BYTE*)(tagTable + relRow);  /* Though tagTable is laid out as a table of U16, each tag is only 1 byte.
-                                                       Explicit cast allows us to get exact desired position within each row */
+        BYTE* tagRow = tagTable + relRow;
         U32 const pos = ZSTD_row_nextIndex(tagRow, rowMask);
 
-        assert(hash == ZSTD_hashPtr(base + updateStartIdx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls));
-        ((BYTE*)tagRow)[pos + ZSTD_ROW_HASH_TAG_OFFSET] = hash & ZSTD_ROW_HASH_TAG_MASK;
+        assert(hash == ZSTD_hashPtrSalted(base + updateStartIdx, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, ms->hashSalt));
+        tagRow[pos] = hash & ZSTD_ROW_HASH_TAG_MASK;
         row[pos] = updateStartIdx;
     }
 }
@@ -1059,7 +1039,7 @@ ZSTD_row_getNEONMask(const U32 rowEntries, const BYTE* const src, const BYTE tag
 FORCE_INLINE_TEMPLATE ZSTD_VecMask
 ZSTD_row_getMatchMask(const BYTE* const tagRow, const BYTE tag, const U32 headGrouped, const U32 rowEntries)
 {
-    const BYTE* const src = tagRow + ZSTD_ROW_HASH_TAG_OFFSET;
+    const BYTE* const src = tagRow;
     assert((rowEntries == 16) || (rowEntries == 32) || rowEntries == 64);
     assert(rowEntries <= ZSTD_ROW_HASH_MAX_ENTRIES);
     assert(ZSTD_row_matchMaskGroupWidth(rowEntries) * rowEntries <= sizeof(ZSTD_VecMask) * 8);
@@ -1144,7 +1124,7 @@ size_t ZSTD_RowFindBestMatch(
                         const U32 rowLog)
 {
     U32* const hashTable = ms->hashTable;
-    U16* const tagTable = ms->tagTable;
+    BYTE* const tagTable = ms->tagTable;
     U32* const hashCache = ms->hashCache;
     const U32 hashLog = ms->rowHashLog;
     const ZSTD_compressionParameters* const cParams = &ms->cParams;
@@ -1163,8 +1143,10 @@ size_t ZSTD_RowFindBestMatch(
     const U32 rowMask = rowEntries - 1;
     const U32 cappedSearchLog = MIN(cParams->searchLog, rowLog); /* nb of searches is capped at nb entries per row */
     const U32 groupWidth = ZSTD_row_matchMaskGroupWidth(rowEntries);
+    const U64 hashSalt = ms->hashSalt;
     U32 nbAttempts = 1U << cappedSearchLog;
     size_t ml=4-1;
+    U32 hash;
 
     /* DMS/DDS variables that may be referenced laster */
     const ZSTD_matchState_t* const dms = ms->dictMatchState;
@@ -1188,7 +1170,7 @@ size_t ZSTD_RowFindBestMatch(
     if (dictMode == ZSTD_dictMatchState) {
         /* Prefetch DMS rows */
         U32* const dmsHashTable = dms->hashTable;
-        U16* const dmsTagTable = dms->tagTable;
+        BYTE* const dmsTagTable = dms->tagTable;
         U32 const dmsHash = (U32)ZSTD_hashPtr(ip, dms->rowHashLog + ZSTD_ROW_HASH_TAG_BITS, mls);
         U32 const dmsRelRow = (dmsHash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;
         dmsTag = dmsHash & ZSTD_ROW_HASH_TAG_MASK;
@@ -1198,9 +1180,19 @@ size_t ZSTD_RowFindBestMatch(
     }
 
     /* Update the hashTable and tagTable up to (but not including) ip */
-    ZSTD_row_update_internal(ms, ip, mls, rowLog, rowMask, 1 /* useCache */);
+    if (!ms->lazySkipping) {
+        ZSTD_row_update_internal(ms, ip, mls, rowLog, rowMask, 1 /* useCache */);
+        hash = ZSTD_row_nextCachedHash(hashCache, hashTable, tagTable, base, curr, hashLog, rowLog, mls, hashSalt);
+    } else {
+        /* Stop inserting every position when in the lazy skipping mode.
+         * The hash cache is also not kept up to date in this mode.
+         */
+        hash = (U32)ZSTD_hashPtrSalted(ip, hashLog + ZSTD_ROW_HASH_TAG_BITS, mls, hashSalt);
+        ms->nextToUpdate = curr;
+    }
+    ms->hashSaltEntropy += hash; /* collect salt entropy */
+
     {   /* Get the hash for ip, compute the appropriate row */
-        U32 const hash = ZSTD_row_nextCachedHash(hashCache, hashTable, tagTable, base, curr, hashLog, rowLog, mls);
         U32 const relRow = (hash >> ZSTD_ROW_HASH_TAG_BITS) << rowLog;
         U32 const tag = hash & ZSTD_ROW_HASH_TAG_MASK;
         U32* const row = hashTable + relRow;
@@ -1212,9 +1204,10 @@ size_t ZSTD_RowFindBestMatch(
         ZSTD_VecMask matches = ZSTD_row_getMatchMask(tagRow, (BYTE)tag, headGrouped, rowEntries);
 
         /* Cycle through the matches and prefetch */
-        for (; (matches > 0) && (nbAttempts > 0); --nbAttempts, matches &= (matches - 1)) {
+        for (; (matches > 0) && (nbAttempts > 0); matches &= (matches - 1)) {
             U32 const matchPos = ((headGrouped + ZSTD_VecMask_next(matches)) / groupWidth) & rowMask;
             U32 const matchIndex = row[matchPos];
+            if(matchPos == 0) continue;
             assert(numMatches < rowEntries);
             if (matchIndex < lowLimit)
                 break;
@@ -1224,13 +1217,14 @@ size_t ZSTD_RowFindBestMatch(
                 PREFETCH_L1(dictBase + matchIndex);
             }
             matchBuffer[numMatches++] = matchIndex;
+            --nbAttempts;
         }
 
         /* Speed opt: insert current byte into hashtable too. This allows us to avoid one iteration of the loop
            in ZSTD_row_update_internal() at the next search. */
         {
             U32 const pos = ZSTD_row_nextIndex(tagRow, rowMask);
-            tagRow[pos + ZSTD_ROW_HASH_TAG_OFFSET] = (BYTE)tag;
+            tagRow[pos] = (BYTE)tag;
             row[pos] = ms->nextToUpdate++;
         }
 
@@ -1281,13 +1275,15 @@ size_t ZSTD_RowFindBestMatch(
             size_t currMatch = 0;
             ZSTD_VecMask matches = ZSTD_row_getMatchMask(dmsTagRow, (BYTE)dmsTag, headGrouped, rowEntries);
 
-            for (; (matches > 0) && (nbAttempts > 0); --nbAttempts, matches &= (matches - 1)) {
+            for (; (matches > 0) && (nbAttempts > 0); matches &= (matches - 1)) {
                 U32 const matchPos = ((headGrouped + ZSTD_VecMask_next(matches)) / groupWidth) & rowMask;
                 U32 const matchIndex = dmsRow[matchPos];
+                if(matchPos == 0) continue;
                 if (matchIndex < dmsLowestIndex)
                     break;
                 PREFETCH_L1(dmsBase + matchIndex);
                 matchBuffer[numMatches++] = matchIndex;
+                --nbAttempts;
             }
 
             /* Return the longest match */
@@ -1544,10 +1540,11 @@ ZSTD_compressBlock_lazy_generic(
         assert(offset_2 <= dictAndPrefixLength);
     }
 
+    /* Reset the lazy skipping state */
+    ms->lazySkipping = 0;
+
     if (searchMethod == search_rowHash) {
-        ZSTD_row_fillHashCache(ms, base, rowLog,
-                            MIN(ms->cParams.minMatch, 6 /* mls caps out at 6 */),
-                            ms->nextToUpdate, ilimit);
+        ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);
     }
 
     /* Match Loop */
@@ -1591,7 +1588,16 @@ ZSTD_compressBlock_lazy_generic(
         }
 
         if (matchLength < 4) {
-            ip += ((ip-anchor) >> kSearchStrength) + 1;   /* jump faster over incompressible sections */
+            size_t const step = ((size_t)(ip-anchor) >> kSearchStrength) + 1;   /* jump faster over incompressible sections */;
+            ip += step;
+            /* Enter the lazy skipping mode once we are skipping more than 8 bytes at a time.
+             * In this mode we stop inserting every position into our tables, and only insert
+             * positions that we search, which is one in step positions.
+             * The exact cutoff is flexible, I've just chosen a number that is reasonably high,
+             * so we minimize the compression ratio loss in "normal" scenarios. This mode gets
+             * triggered once we've gone 2KB without finding any matches.
+             */
+            ms->lazySkipping = step > kLazySkippingStep;
             continue;
         }
 
@@ -1695,6 +1701,13 @@ ZSTD_compressBlock_lazy_generic(
             ZSTD_storeSeq(seqStore, litLength, anchor, iend, (U32)offBase, matchLength);
             anchor = ip = start + matchLength;
         }
+        if (ms->lazySkipping) {
+            /* We've found a match, disable lazy skipping mode, and refill the hash cache. */
+            if (searchMethod == search_rowHash) {
+                ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);
+            }
+            ms->lazySkipping = 0;
+        }
 
         /* check immediate repcode */
         if (isDxS) {
@@ -1912,12 +1925,13 @@ size_t ZSTD_compressBlock_lazy_extDict_generic(
 
     DEBUGLOG(5, "ZSTD_compressBlock_lazy_extDict_generic (searchFunc=%u)", (U32)searchMethod);
 
+    /* Reset the lazy skipping state */
+    ms->lazySkipping = 0;
+
     /* init */
     ip += (ip == prefixStart);
     if (searchMethod == search_rowHash) {
-        ZSTD_row_fillHashCache(ms, base, rowLog,
-                               MIN(ms->cParams.minMatch, 6 /* mls caps out at 6 */),
-                               ms->nextToUpdate, ilimit);
+        ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);
     }
 
     /* Match Loop */
@@ -1955,7 +1969,16 @@ size_t ZSTD_compressBlock_lazy_extDict_generic(
         }
 
         if (matchLength < 4) {
-            ip += ((ip-anchor) >> kSearchStrength) + 1;   /* jump faster over incompressible sections */
+            size_t const step = ((size_t)(ip-anchor) >> kSearchStrength);
+            ip += step + 1;   /* jump faster over incompressible sections */
+            /* Enter the lazy skipping mode once we are skipping more than 8 bytes at a time.
+             * In this mode we stop inserting every position into our tables, and only insert
+             * positions that we search, which is one in step positions.
+             * The exact cutoff is flexible, I've just chosen a number that is reasonably high,
+             * so we minimize the compression ratio loss in "normal" scenarios. This mode gets
+             * triggered once we've gone 2KB without finding any matches.
+             */
+            ms->lazySkipping = step > kLazySkippingStep;
             continue;
         }
 
@@ -2041,6 +2064,13 @@ size_t ZSTD_compressBlock_lazy_extDict_generic(
             ZSTD_storeSeq(seqStore, litLength, anchor, iend, (U32)offBase, matchLength);
             anchor = ip = start + matchLength;
         }
+        if (ms->lazySkipping) {
+            /* We've found a match, disable lazy skipping mode, and refill the hash cache. */
+            if (searchMethod == search_rowHash) {
+                ZSTD_row_fillHashCache(ms, base, rowLog, mls, ms->nextToUpdate, ilimit);
+            }
+            ms->lazySkipping = 0;
+        }
 
         /* check immediate repcode */
         while (ip <= ilimit) {
diff --git a/libfenrir/src/main/jni/compress/zstd/compress/zstd_opt.c b/libfenrir/src/main/jni/compress/zstd/compress/zstd_opt.c
index fdd7f9d8b..f02a76094 100644
--- a/libfenrir/src/main/jni/compress/zstd/compress/zstd_opt.c
+++ b/libfenrir/src/main/jni/compress/zstd/compress/zstd_opt.c
@@ -1086,6 +1086,8 @@ ZSTD_compressBlock_opt_generic(ZSTD_matchState_t* ms,
     ZSTD_optimal_t lastSequence;
     ZSTD_optLdm_t optLdm;
 
+    ZSTD_memset(&lastSequence, 0, sizeof(ZSTD_optimal_t));
+
     optLdm.seqStore = ms->ldmSeqStore ? *ms->ldmSeqStore : kNullRawSeqStore;
     optLdm.endPosInBlock = optLdm.startPosInBlock = optLdm.offset = 0;
     ZSTD_opt_getNextMatchAndUpdateSeqStore(&optLdm, (U32)(ip-istart), (U32)(iend-ip));
diff --git a/libfenrir/src/main/jni/compress/zstd/compress/zstdmt_compress.c b/libfenrir/src/main/jni/compress/zstd/compress/zstdmt_compress.c
index 7a2c71720..678607556 100644
--- a/libfenrir/src/main/jni/compress/zstd/compress/zstdmt_compress.c
+++ b/libfenrir/src/main/jni/compress/zstd/compress/zstdmt_compress.c
@@ -20,6 +20,7 @@
 
 
 /* ======   Dependencies   ====== */
+#include "../common/allocations.h"  /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */
 #include "../common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memset, INT_MAX, UINT_MAX */
 #include "../common/mem.h"         /* MEM_STATIC */
 #include "../common/pool.h"        /* threadpool */
@@ -719,7 +720,7 @@ static void ZSTDMT_compressionJob(void* jobDescription)
     ZSTDMT_serialState_update(job->serial, cctx, rawSeqStore, job->src, job->jobID);
 
     if (!job->firstJob) {  /* flush and overwrite frame header when it's not first job */
-        size_t const hSize = ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.capacity, job->src.start, 0);
+        size_t const hSize = ZSTD_compressContinue_public(cctx, dstBuff.start, dstBuff.capacity, job->src.start, 0);
         if (ZSTD_isError(hSize)) JOB_ERROR(hSize);
         DEBUGLOG(5, "ZSTDMT_compressionJob: flush and overwrite %u bytes of frame header (not first job)", (U32)hSize);
         ZSTD_invalidateRepCodes(cctx);
@@ -737,7 +738,7 @@ static void ZSTDMT_compressionJob(void* jobDescription)
         DEBUGLOG(5, "ZSTDMT_compressionJob: compress %u bytes in %i blocks", (U32)job->src.size, nbChunks);
         assert(job->cSize == 0);
         for (chunkNb = 1; chunkNb < nbChunks; chunkNb++) {
-            size_t const cSize = ZSTD_compressContinue(cctx, op, oend-op, ip, chunkSize);
+            size_t const cSize = ZSTD_compressContinue_public(cctx, op, oend-op, ip, chunkSize);
             if (ZSTD_isError(cSize)) JOB_ERROR(cSize);
             ip += chunkSize;
             op += cSize; assert(op < oend);
@@ -757,8 +758,8 @@ static void ZSTDMT_compressionJob(void* jobDescription)
             size_t const lastBlockSize1 = job->src.size & (chunkSize-1);
             size_t const lastBlockSize = ((lastBlockSize1==0) & (job->src.size>=chunkSize)) ? chunkSize : lastBlockSize1;
             size_t const cSize = (job->lastJob) ?
-                 ZSTD_compressEnd     (cctx, op, oend-op, ip, lastBlockSize) :
-                 ZSTD_compressContinue(cctx, op, oend-op, ip, lastBlockSize);
+                 ZSTD_compressEnd_public(cctx, op, oend-op, ip, lastBlockSize) :
+                 ZSTD_compressContinue_public(cctx, op, oend-op, ip, lastBlockSize);
             if (ZSTD_isError(cSize)) JOB_ERROR(cSize);
             lastCBlockSize = cSize;
     }   }
diff --git a/libfenrir/src/main/jni/compress/zstd/decompress/huf_decompress.c b/libfenrir/src/main/jni/compress/zstd/decompress/huf_decompress.c
index c2d1f633a..5b217ac58 100644
--- a/libfenrir/src/main/jni/compress/zstd/decompress/huf_decompress.c
+++ b/libfenrir/src/main/jni/compress/zstd/decompress/huf_decompress.c
@@ -696,7 +696,7 @@ void HUF_decompress4X1_usingDTable_internal_fast_c_loop(HUF_DecompressFastArgs*
 
     /* Copy the arguments to local variables */
     ZSTD_memcpy(&bits, &args->bits, sizeof(bits));
-    ZSTD_memcpy(&ip, &args->ip, sizeof(ip));
+    ZSTD_memcpy((void*)(&ip), &args->ip, sizeof(ip));
     ZSTD_memcpy(&op, &args->op, sizeof(op));
 
     assert(MEM_isLittleEndian());
@@ -779,7 +779,7 @@ void HUF_decompress4X1_usingDTable_internal_fast_c_loop(HUF_DecompressFastArgs*
 
     /* Save the final values of each of the state variables back to args. */
     ZSTD_memcpy(&args->bits, &bits, sizeof(bits));
-    ZSTD_memcpy(&args->ip, &ip, sizeof(ip));
+    ZSTD_memcpy((void*)(&args->ip), &ip, sizeof(ip));
     ZSTD_memcpy(&args->op, &op, sizeof(op));
 }
 
@@ -1476,7 +1476,7 @@ void HUF_decompress4X2_usingDTable_internal_fast_c_loop(HUF_DecompressFastArgs*
 
     /* Copy the arguments to local registers. */
     ZSTD_memcpy(&bits, &args->bits, sizeof(bits));
-    ZSTD_memcpy(&ip, &args->ip, sizeof(ip));
+    ZSTD_memcpy((void*)(&ip), &args->ip, sizeof(ip));
     ZSTD_memcpy(&op, &args->op, sizeof(op));
 
     oend[0] = op[1];
@@ -1599,7 +1599,7 @@ void HUF_decompress4X2_usingDTable_internal_fast_c_loop(HUF_DecompressFastArgs*
 
     /* Save the final values of each of the state variables back to args. */
     ZSTD_memcpy(&args->bits, &bits, sizeof(bits));
-    ZSTD_memcpy(&args->ip, &ip, sizeof(ip));
+    ZSTD_memcpy((void*)(&args->ip), &ip, sizeof(ip));
     ZSTD_memcpy(&args->op, &op, sizeof(op));
 }
 
diff --git a/libfenrir/src/main/jni/compress/zstd/decompress/zstd_ddict.c b/libfenrir/src/main/jni/compress/zstd/decompress/zstd_ddict.c
index ad5c34a7f..309ec0d03 100644
--- a/libfenrir/src/main/jni/compress/zstd/decompress/zstd_ddict.c
+++ b/libfenrir/src/main/jni/compress/zstd/decompress/zstd_ddict.c
@@ -14,6 +14,7 @@
 /*-*******************************************************
 *  Dependencies
 *********************************************************/
+#include "../common/allocations.h"  /* ZSTD_customMalloc, ZSTD_customFree */
 #include "../common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */
 #include "../common/cpu.h"         /* bmi2 */
 #include "../common/mem.h"         /* low level memory routines */
diff --git a/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress.c b/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress.c
index d487966cc..3f3ca57c0 100644
--- a/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress.c
+++ b/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress.c
@@ -55,6 +55,7 @@
 /*-*******************************************************
 *  Dependencies
 *********************************************************/
+#include "../common/allocations.h"  /* ZSTD_customMalloc, ZSTD_customCalloc, ZSTD_customFree */
 #include "../common/zstd_deps.h"   /* ZSTD_memcpy, ZSTD_memmove, ZSTD_memset */
 #include "../common/mem.h"         /* low level memory routines */
 #define FSE_STATIC_LINKING_ONLY
diff --git a/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress_block.c b/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress_block.c
index 0a06a021e..09896a931 100644
--- a/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress_block.c
+++ b/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress_block.c
@@ -1232,11 +1232,7 @@ ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
 
         /* sequence */
         {   size_t offset;
-    #if defined(__clang__)
-            if (LIKELY(ofBits > 1)) {
-    #else
             if (ofBits > 1) {
-    #endif
                 ZSTD_STATIC_ASSERT(ZSTD_lo_isLongOffset == 1);
                 ZSTD_STATIC_ASSERT(LONG_OFFSETS_MAX_EXTRA_BITS_32 == 5);
                 ZSTD_STATIC_ASSERT(STREAM_ACCUMULATOR_MIN_32 > LONG_OFFSETS_MAX_EXTRA_BITS_32);
@@ -1273,11 +1269,7 @@ ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
             seq.offset = offset;
         }
 
-    #if defined(__clang__)
-        if (UNLIKELY(mlBits > 0))
-    #else
         if (mlBits > 0)
-    #endif
             seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/);
 
         if (MEM_32bits() && (mlBits+llBits >= STREAM_ACCUMULATOR_MIN_32-LONG_OFFSETS_MAX_EXTRA_BITS_32))
@@ -1287,11 +1279,7 @@ ZSTD_decodeSequence(seqState_t* seqState, const ZSTD_longOffset_e longOffsets)
         /* Ensure there are enough bits to read the rest of data in 64-bit mode. */
         ZSTD_STATIC_ASSERT(16+LLFSELog+MLFSELog+OffFSELog < STREAM_ACCUMULATOR_MIN_64);
 
-    #if defined(__clang__)
-        if (UNLIKELY(llBits > 0))
-    #else
         if (llBits > 0)
-    #endif
             seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/);
 
         if (MEM_32bits())
@@ -1987,7 +1975,7 @@ ZSTD_decompressSequencesLong(ZSTD_DCtx* dctx,
 
 
 /**
- * @returns The total size of the history referencable by zstd, including
+ * @returns The total size of the history referenceable by zstd, including
  * both the prefix and the extDict. At @p op any offset larger than this
  * is invalid.
  */
@@ -2124,7 +2112,9 @@ ZSTD_decompressBlock_internal(ZSTD_DCtx* dctx,
         ip += seqHSize;
         srcSize -= seqHSize;
 
-        RETURN_ERROR_IF(dst == NULL && nbSeq > 0, dstSize_tooSmall, "NULL not handled");
+        RETURN_ERROR_IF((dst == NULL || dstCapacity == 0) && nbSeq > 0, dstSize_tooSmall, "NULL not handled");
+        RETURN_ERROR_IF(MEM_64bits() && sizeof(size_t) == sizeof(void*) && (size_t)(-1) - (size_t)dst < (size_t)(1 << 20), dstSize_tooSmall,
+                "invalid dst");
 
         /* If we could potentially have long offsets, or we might want to use the prefetch decoder,
          * compute information about the share of long offsets, and the maximum nbAdditionalBits.
@@ -2181,9 +2171,9 @@ void ZSTD_checkContinuity(ZSTD_DCtx* dctx, const void* dst, size_t dstSize)
 }
 
 
-size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
-                            void* dst, size_t dstCapacity,
-                      const void* src, size_t srcSize)
+size_t ZSTD_decompressBlock_deprecated(ZSTD_DCtx* dctx,
+                                       void* dst, size_t dstCapacity,
+                                 const void* src, size_t srcSize)
 {
     size_t dSize;
     ZSTD_checkContinuity(dctx, dst, dstCapacity);
@@ -2191,3 +2181,12 @@ size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
     dctx->previousDstEnd = (char*)dst + dSize;
     return dSize;
 }
+
+
+/* NOTE: Must just wrap ZSTD_decompressBlock_deprecated() */
+size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx,
+                            void* dst, size_t dstCapacity,
+                      const void* src, size_t srcSize)
+{
+    return ZSTD_decompressBlock_deprecated(dctx, dst, dstCapacity, src, srcSize);
+}
diff --git a/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress_block.h b/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress_block.h
index 67791dbc3..9d1318882 100644
--- a/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress_block.h
+++ b/libfenrir/src/main/jni/compress/zstd/decompress/zstd_decompress_block.h
@@ -64,5 +64,10 @@ void ZSTD_buildFSETable(ZSTD_seqSymbol* dt,
                    unsigned tableLog, void* wksp, size_t wkspSize,
                    int bmi2);
 
+/* Internal definition of ZSTD_decompressBlock() to avoid deprecation warnings. */
+size_t ZSTD_decompressBlock_deprecated(ZSTD_DCtx* dctx,
+                            void* dst, size_t dstCapacity,
+                      const void* src, size_t srcSize);
+
 
 #endif /* ZSTD_DEC_BLOCK_H */
diff --git a/libfenrir/src/main/jni/compress/zstd/dictBuilder/zdict.c b/libfenrir/src/main/jni/compress/zstd/dictBuilder/zdict.c
index f22e04df2..58290f450 100644
--- a/libfenrir/src/main/jni/compress/zstd/dictBuilder/zdict.c
+++ b/libfenrir/src/main/jni/compress/zstd/dictBuilder/zdict.c
@@ -566,11 +566,11 @@ static void ZDICT_countEStats(EStats_ress_t esr, const ZSTD_parameters* params,
     size_t cSize;
 
     if (srcSize > blockSizeMax) srcSize = blockSizeMax;   /* protection vs large samples */
-    {   size_t const errorCode = ZSTD_compressBegin_usingCDict(esr.zc, esr.dict);
+    {   size_t const errorCode = ZSTD_compressBegin_usingCDict_deprecated(esr.zc, esr.dict);
         if (ZSTD_isError(errorCode)) { DISPLAYLEVEL(1, "warning : ZSTD_compressBegin_usingCDict failed \n"); return; }
 
     }
-    cSize = ZSTD_compressBlock(esr.zc, esr.workPlace, ZSTD_BLOCKSIZE_MAX, src, srcSize);
+    cSize = ZSTD_compressBlock_deprecated(esr.zc, esr.workPlace, ZSTD_BLOCKSIZE_MAX, src, srcSize);
     if (ZSTD_isError(cSize)) { DISPLAYLEVEL(3, "warning : could not compress sample size %u \n", (unsigned)srcSize); return; }
 
     if (cSize) {  /* if == 0; block is not compressible */
diff --git a/libfenrir/src/main/jni/compress/zstd/zstd.h b/libfenrir/src/main/jni/compress/zstd/zstd.h
index 95aac0737..e5c3f8b68 100644
--- a/libfenrir/src/main/jni/compress/zstd/zstd.h
+++ b/libfenrir/src/main/jni/compress/zstd/zstd.h
@@ -106,7 +106,7 @@ extern "C" {
 /*------   Version   ------*/
 #define ZSTD_VERSION_MAJOR    1
 #define ZSTD_VERSION_MINOR    5
-#define ZSTD_VERSION_RELEASE  4
+#define ZSTD_VERSION_RELEASE  5
 #define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
 
 /*! ZSTD_versionNumber() :
@@ -148,7 +148,8 @@ ZSTDLIB_API const char* ZSTD_versionString(void);
 ***************************************/
 /*! ZSTD_compress() :
  *  Compresses `src` content as a single zstd compressed frame into already allocated `dst`.
- *  Hint : compression runs faster if `dstCapacity` >=  `ZSTD_compressBound(srcSize)`.
+ *  NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have
+ *        enough space to successfully compress the data.
  *  @return : compressed size written into `dst` (<= `dstCapacity),
  *            or an error code if it fails (which can be tested using ZSTD_isError()). */
 ZSTDLIB_API size_t ZSTD_compress( void* dst, size_t dstCapacity,
@@ -578,7 +579,8 @@ ZSTDLIB_API size_t ZSTD_CCtx_reset(ZSTD_CCtx* cctx, ZSTD_ResetDirective reset);
  *  Should cctx hold data from a previously unfinished frame, everything about it is forgotten.
  *  - Compression parameters are pushed into CCtx before starting compression, using ZSTD_CCtx_set*()
  *  - The function is always blocking, returns when compression is completed.
- *  Hint : compression runs faster if `dstCapacity` >=  `ZSTD_compressBound(srcSize)`.
+ *  NOTE: Providing `dstCapacity >= ZSTD_compressBound(srcSize)` guarantees that zstd will have
+ *        enough space to successfully compress the data, though it is possible it fails for other reasons.
  * @return : compressed size written into `dst` (<= `dstCapacity),
  *           or an error code if it fails (which can be tested using ZSTD_isError()).
  */
@@ -1018,9 +1020,11 @@ ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize);
  * Advanced dictionary and prefix API (Requires v1.4.0+)
  *
  * This API allows dictionaries to be used with ZSTD_compress2(),
- * ZSTD_compressStream2(), and ZSTD_decompressDCtx(). Dictionaries are sticky, and
- * only reset with the context is reset with ZSTD_reset_parameters or
- * ZSTD_reset_session_and_parameters. Prefixes are single-use.
+ * ZSTD_compressStream2(), and ZSTD_decompressDCtx().
+ * Dictionaries are sticky, they remain valid when same context is re-used,
+ * they only reset when the context is reset
+ * with ZSTD_reset_parameters or ZSTD_reset_session_and_parameters.
+ * In contrast, Prefixes are single-use.
  ******************************************************************************/
 
 
@@ -1041,7 +1045,11 @@ ZSTDLIB_API unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize);
  *           Use experimental ZSTD_CCtx_loadDictionary_byReference() to reference content instead.
  *           In such a case, dictionary buffer must outlive its users.
  *  Note 4 : Use ZSTD_CCtx_loadDictionary_advanced()
- *           to precisely select how dictionary content must be interpreted. */
+ *           to precisely select how dictionary content must be interpreted.
+ *  Note 5 : This method does not benefit from LDM (long distance mode).
+ *           If you want to employ LDM on some large dictionary content,
+ *           prefer employing ZSTD_CCtx_refPrefix() described below.
+ */
 ZSTDLIB_API size_t ZSTD_CCtx_loadDictionary(ZSTD_CCtx* cctx, const void* dict, size_t dictSize);
 
 /*! ZSTD_CCtx_refCDict() : Requires v1.4.0+
@@ -1064,6 +1072,7 @@ ZSTDLIB_API size_t ZSTD_CCtx_refCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict);
  *  Decompression will need same prefix to properly regenerate data.
  *  Compressing with a prefix is similar in outcome as performing a diff and compressing it,
  *  but performs much faster, especially during decompression (compression speed is tunable with compression level).
+ *  This method is compatible with LDM (long distance mode).
  * @result : 0, or an error code (which can be tested with ZSTD_isError()).
  *  Special: Adding any prefix (including NULL) invalidates any previous prefix or dictionary
  *  Note 1 : Prefix buffer is referenced. It **must** outlive compression.
@@ -1387,7 +1396,7 @@ typedef enum {
 } ZSTD_paramSwitch_e;
 
 /***************************************
-*  Frame size functions
+*  Frame header and size functions
 ***************************************/
 
 /*! ZSTD_findDecompressedSize() :
@@ -1434,6 +1443,30 @@ ZSTDLIB_STATIC_API unsigned long long ZSTD_decompressBound(const void* src, size
  *           or an error code (if srcSize is too small) */
 ZSTDLIB_STATIC_API size_t ZSTD_frameHeaderSize(const void* src, size_t srcSize);
 
+typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e;
+typedef struct {
+    unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" */
+    unsigned long long windowSize;       /* can be very large, up to <= frameContentSize */
+    unsigned blockSizeMax;
+    ZSTD_frameType_e frameType;          /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */
+    unsigned headerSize;
+    unsigned dictID;
+    unsigned checksumFlag;
+    unsigned _reserved1;
+    unsigned _reserved2;
+} ZSTD_frameHeader;
+
+/*! ZSTD_getFrameHeader() :
+ *  decode Frame Header, or requires larger `srcSize`.
+ * @return : 0, `zfhPtr` is correctly filled,
+ *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
+ *           or an error code, which can be tested using ZSTD_isError() */
+ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize);   /**< doesn't consume input */
+/*! ZSTD_getFrameHeader_advanced() :
+ *  same as ZSTD_getFrameHeader(),
+ *  with added capability to select a format (like ZSTD_f_zstd1_magicless) */
+ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format);
+
 /*! ZSTD_decompressionMargin() :
  * Zstd supports in-place decompression, where the input and output buffers overlap.
  * In this case, the output buffer must be at least (Margin + Output_Size) bytes large,
@@ -1803,12 +1836,26 @@ ZSTDLIB_STATIC_API size_t ZSTD_checkCParams(ZSTD_compressionParameters params);
 ZSTDLIB_STATIC_API ZSTD_compressionParameters ZSTD_adjustCParams(ZSTD_compressionParameters cPar, unsigned long long srcSize, size_t dictSize);
 
 /*! ZSTD_CCtx_setCParams() :
- *  Set all parameters provided within @cparams into the working @cctx.
+ *  Set all parameters provided within @p cparams into the working @p cctx.
  *  Note : if modifying parameters during compression (MT mode only),
  *         note that changes to the .windowLog parameter will be ignored.
- * @return 0 on success, or an error code (can be checked with ZSTD_isError()) */
+ * @return 0 on success, or an error code (can be checked with ZSTD_isError()).
+ *         On failure, no parameters are updated.
+ */
 ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setCParams(ZSTD_CCtx* cctx, ZSTD_compressionParameters cparams);
 
+/*! ZSTD_CCtx_setFParams() :
+ *  Set all parameters provided within @p fparams into the working @p cctx.
+ * @return 0 on success, or an error code (can be checked with ZSTD_isError()).
+ */
+ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setFParams(ZSTD_CCtx* cctx, ZSTD_frameParameters fparams);
+
+/*! ZSTD_CCtx_setParams() :
+ *  Set all parameters provided within @p params into the working @p cctx.
+ * @return 0 on success, or an error code (can be checked with ZSTD_isError()).
+ */
+ZSTDLIB_STATIC_API size_t ZSTD_CCtx_setParams(ZSTD_CCtx* cctx, ZSTD_parameters params);
+
 /*! ZSTD_compress_advanced() :
  *  Note : this function is now DEPRECATED.
  *         It can be replaced by ZSTD_compress2(), in combination with ZSTD_CCtx_setParameter() and other parameter setters.
@@ -2134,7 +2181,7 @@ ZSTDLIB_STATIC_API size_t ZSTD_CCtx_refPrefix_advanced(ZSTD_CCtx* cctx, const vo
  * This parameter can be used to set an upper bound on the blocksize
  * that overrides the default ZSTD_BLOCKSIZE_MAX. It cannot be used to set upper
  * bounds greater than ZSTD_BLOCKSIZE_MAX or bounds lower than 1KB (will make
- * compressBound() innacurate). Only currently meant to be used for testing.
+ * compressBound() inaccurate). Only currently meant to be used for testing.
  *
  */
 #define ZSTD_c_maxBlockSize ZSTD_c_experimentalParam18
@@ -2452,12 +2499,9 @@ size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs,
                            int compressionLevel);
 
 /*! ZSTD_initCStream_advanced() :
- * This function is DEPRECATED, and is approximately equivalent to:
+ * This function is DEPRECATED, and is equivalent to:
  *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
- *     // Pseudocode: Set each zstd parameter and leave the rest as-is.
- *     for ((param, value) : params) {
- *         ZSTD_CCtx_setParameter(zcs, param, value);
- *     }
+ *     ZSTD_CCtx_setParams(zcs, params);
  *     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
  *     ZSTD_CCtx_loadDictionary(zcs, dict, dictSize);
  *
@@ -2486,12 +2530,9 @@ ZSTDLIB_STATIC_API
 size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);
 
 /*! ZSTD_initCStream_usingCDict_advanced() :
- *   This function is DEPRECATED, and is approximately equivalent to:
+ *   This function is DEPRECATED, and is equivalent to:
  *     ZSTD_CCtx_reset(zcs, ZSTD_reset_session_only);
- *     // Pseudocode: Set each zstd frame parameter and leave the rest as-is.
- *     for ((fParam, value) : fParams) {
- *         ZSTD_CCtx_setParameter(zcs, fParam, value);
- *     }
+ *     ZSTD_CCtx_setFParams(zcs, fParams);
  *     ZSTD_CCtx_setPledgedSrcSize(zcs, pledgedSrcSize);
  *     ZSTD_CCtx_refCDict(zcs, cdict);
  *
@@ -2598,12 +2639,180 @@ ZSTD_DEPRECATED("use ZSTD_DCtx_reset, see zstd.h for detailed instructions")
 ZSTDLIB_STATIC_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
 
 
+/* ********************* BLOCK-LEVEL SEQUENCE PRODUCER API *********************
+ *
+ * *** OVERVIEW ***
+ * The Block-Level Sequence Producer API allows users to provide their own custom
+ * sequence producer which libzstd invokes to process each block. The produced list
+ * of sequences (literals and matches) is then post-processed by libzstd to produce
+ * valid compressed blocks.
+ *
+ * This block-level offload API is a more granular complement of the existing
+ * frame-level offload API compressSequences() (introduced in v1.5.1). It offers
+ * an easier migration story for applications already integrated with libzstd: the
+ * user application continues to invoke the same compression functions
+ * ZSTD_compress2() or ZSTD_compressStream2() as usual, and transparently benefits
+ * from the specific advantages of the external sequence producer. For example,
+ * the sequence producer could be tuned to take advantage of known characteristics
+ * of the input, to offer better speed / ratio, or could leverage hardware
+ * acceleration not available within libzstd itself.
+ *
+ * See contrib/externalSequenceProducer for an example program employing the
+ * Block-Level Sequence Producer API.
+ *
+ * *** USAGE ***
+ * The user is responsible for implementing a function of type
+ * ZSTD_sequenceProducer_F. For each block, zstd will pass the following
+ * arguments to the user-provided function:
+ *
+ *   - sequenceProducerState: a pointer to a user-managed state for the sequence
+ *     producer.
+ *
+ *   - outSeqs, outSeqsCapacity: an output buffer for the sequence producer.
+ *     outSeqsCapacity is guaranteed >= ZSTD_sequenceBound(srcSize). The memory
+ *     backing outSeqs is managed by the CCtx.
+ *
+ *   - src, srcSize: an input buffer for the sequence producer to parse.
+ *     srcSize is guaranteed to be <= ZSTD_BLOCKSIZE_MAX.
+ *
+ *   - dict, dictSize: a history buffer, which may be empty, which the sequence
+ *     producer may reference as it parses the src buffer. Currently, zstd will
+ *     always pass dictSize == 0 into external sequence producers, but this will
+ *     change in the future.
+ *
+ *   - compressionLevel: a signed integer representing the zstd compression level
+ *     set by the user for the current operation. The sequence producer may choose
+ *     to use this information to change its compression strategy and speed/ratio
+ *     tradeoff. Note: the compression level does not reflect zstd parameters set
+ *     through the advanced API.
+ *
+ *   - windowSize: a size_t representing the maximum allowed offset for external
+ *     sequences. Note that sequence offsets are sometimes allowed to exceed the
+ *     windowSize if a dictionary is present, see doc/zstd_compression_format.md
+ *     for details.
+ *
+ * The user-provided function shall return a size_t representing the number of
+ * sequences written to outSeqs. This return value will be treated as an error
+ * code if it is greater than outSeqsCapacity. The return value must be non-zero
+ * if srcSize is non-zero. The ZSTD_SEQUENCE_PRODUCER_ERROR macro is provided
+ * for convenience, but any value greater than outSeqsCapacity will be treated as
+ * an error code.
+ *
+ * If the user-provided function does not return an error code, the sequences
+ * written to outSeqs must be a valid parse of the src buffer. Data corruption may
+ * occur if the parse is not valid. A parse is defined to be valid if the
+ * following conditions hold:
+ *   - The sum of matchLengths and literalLengths must equal srcSize.
+ *   - All sequences in the parse, except for the final sequence, must have
+ *     matchLength >= ZSTD_MINMATCH_MIN. The final sequence must have
+ *     matchLength >= ZSTD_MINMATCH_MIN or matchLength == 0.
+ *   - All offsets must respect the windowSize parameter as specified in
+ *     doc/zstd_compression_format.md.
+ *   - If the final sequence has matchLength == 0, it must also have offset == 0.
+ *
+ * zstd will only validate these conditions (and fail compression if they do not
+ * hold) if the ZSTD_c_validateSequences cParam is enabled. Note that sequence
+ * validation has a performance cost.
+ *
+ * If the user-provided function returns an error, zstd will either fall back
+ * to an internal sequence producer or fail the compression operation. The user can
+ * choose between the two behaviors by setting the ZSTD_c_enableSeqProducerFallback
+ * cParam. Fallback compression will follow any other cParam settings, such as
+ * compression level, the same as in a normal compression operation.
+ *
+ * The user shall instruct zstd to use a particular ZSTD_sequenceProducer_F
+ * function by calling
+ *         ZSTD_registerSequenceProducer(cctx,
+ *                                       sequenceProducerState,
+ *                                       sequenceProducer)
+ * This setting will persist until the next parameter reset of the CCtx.
+ *
+ * The sequenceProducerState must be initialized by the user before calling
+ * ZSTD_registerSequenceProducer(). The user is responsible for destroying the
+ * sequenceProducerState.
+ *
+ * *** LIMITATIONS ***
+ * This API is compatible with all zstd compression APIs which respect advanced parameters.
+ * However, there are three limitations:
+ *
+ * First, the ZSTD_c_enableLongDistanceMatching cParam is not currently supported.
+ * COMPRESSION WILL FAIL if it is enabled and the user tries to compress with a block-level
+ * external sequence producer.
+ *   - Note that ZSTD_c_enableLongDistanceMatching is auto-enabled by default in some
+ *     cases (see its documentation for details). Users must explicitly set
+ *     ZSTD_c_enableLongDistanceMatching to ZSTD_ps_disable in such cases if an external
+ *     sequence producer is registered.
+ *   - As of this writing, ZSTD_c_enableLongDistanceMatching is disabled by default
+ *     whenever ZSTD_c_windowLog < 128MB, but that's subject to change. Users should
+ *     check the docs on ZSTD_c_enableLongDistanceMatching whenever the Block-Level Sequence
+ *     Producer API is used in conjunction with advanced settings (like ZSTD_c_windowLog).
+ *
+ * Second, history buffers are not currently supported. Concretely, zstd will always pass
+ * dictSize == 0 to the external sequence producer (for now). This has two implications:
+ *   - Dictionaries are not currently supported. Compression will *not* fail if the user
+ *     references a dictionary, but the dictionary won't have any effect.
+ *   - Stream history is not currently supported. All advanced compression APIs, including
+ *     streaming APIs, work with external sequence producers, but each block is treated as
+ *     an independent chunk without history from previous blocks.
+ *
+ * Third, multi-threading within a single compression is not currently supported. In other words,
+ * COMPRESSION WILL FAIL if ZSTD_c_nbWorkers > 0 and an external sequence producer is registered.
+ * Multi-threading across compressions is fine: simply create one CCtx per thread.
+ *
+ * Long-term, we plan to overcome all three limitations. There is no technical blocker to
+ * overcoming them. It is purely a question of engineering effort.
+ */
+
+#define ZSTD_SEQUENCE_PRODUCER_ERROR ((size_t)(-1))
+
+typedef size_t ZSTD_sequenceProducer_F (
+  void* sequenceProducerState,
+  ZSTD_Sequence* outSeqs, size_t outSeqsCapacity,
+  const void* src, size_t srcSize,
+  const void* dict, size_t dictSize,
+  int compressionLevel,
+  size_t windowSize
+);
+
+/*! ZSTD_registerSequenceProducer() :
+ * Instruct zstd to use a block-level external sequence producer function.
+ *
+ * The sequenceProducerState must be initialized by the caller, and the caller is
+ * responsible for managing its lifetime. This parameter is sticky across
+ * compressions. It will remain set until the user explicitly resets compression
+ * parameters.
+ *
+ * Sequence producer registration is considered to be an "advanced parameter",
+ * part of the "advanced API". This means it will only have an effect on compression
+ * APIs which respect advanced parameters, such as compress2() and compressStream2().
+ * Older compression APIs such as compressCCtx(), which predate the introduction of
+ * "advanced parameters", will ignore any external sequence producer setting.
+ *
+ * The sequence producer can be "cleared" by registering a NULL function pointer. This
+ * removes all limitations described above in the "LIMITATIONS" section of the API docs.
+ *
+ * The user is strongly encouraged to read the full API documentation (above) before
+ * calling this function. */
+ZSTDLIB_STATIC_API void
+ZSTD_registerSequenceProducer(
+  ZSTD_CCtx* cctx,
+  void* sequenceProducerState,
+  ZSTD_sequenceProducer_F* sequenceProducer
+);
+
+
 /*********************************************************************
-*  Buffer-less and synchronous inner streaming functions
+*  Buffer-less and synchronous inner streaming functions (DEPRECATED)
 *
-*  This is an advanced API, giving full control over buffer management, for users which need direct control over memory.
-*  But it's also a complex one, with several restrictions, documented below.
-*  Prefer normal streaming API for an easier experience.
+*  This API is deprecated, and will be removed in a future version.
+*  It allows streaming (de)compression with user allocated buffers.
+*  However, it is hard to use, and not as well tested as the rest of
+*  our API.
+*
+*  Please use the normal streaming API instead: ZSTD_compressStream2,
+*  and ZSTD_decompressStream.
+*  If there is functionality that you need, but it doesn't provide,
+*  please open an issue on our GitHub.
 ********************************************************************* */
 
 /**
@@ -2636,15 +2845,20 @@ ZSTDLIB_STATIC_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
 */
 
 /*=====   Buffer-less streaming compression functions  =====*/
+ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.")
 ZSTDLIB_STATIC_API size_t ZSTD_compressBegin(ZSTD_CCtx* cctx, int compressionLevel);
+ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.")
 ZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingDict(ZSTD_CCtx* cctx, const void* dict, size_t dictSize, int compressionLevel);
+ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.")
 ZSTDLIB_STATIC_API size_t ZSTD_compressBegin_usingCDict(ZSTD_CCtx* cctx, const ZSTD_CDict* cdict); /**< note: fails if cdict==NULL */
 
 ZSTD_DEPRECATED("This function will likely be removed in a future release. It is misleading and has very limited utility.")
 ZSTDLIB_STATIC_API
 size_t ZSTD_copyCCtx(ZSTD_CCtx* cctx, const ZSTD_CCtx* preparedCCtx, unsigned long long pledgedSrcSize); /**<  note: if pledgedSrcSize is not known, use ZSTD_CONTENTSIZE_UNKNOWN */
 
+ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.")
 ZSTDLIB_STATIC_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+ZSTD_DEPRECATED("The buffer-less API is deprecated in favor of the normal streaming API. See docs.")
 ZSTDLIB_STATIC_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
 
 /* The ZSTD_compressBegin_advanced() and ZSTD_compressBegin_usingCDict_advanced() are now DEPRECATED and will generate a compiler warning */
@@ -2728,29 +2942,7 @@ size_t ZSTD_compressBegin_usingCDict_advanced(ZSTD_CCtx* const cctx, const ZSTD_
 */
 
 /*=====   Buffer-less streaming decompression functions  =====*/
-typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e;
-typedef struct {
-    unsigned long long frameContentSize; /* if == ZSTD_CONTENTSIZE_UNKNOWN, it means this field is not available. 0 means "empty" */
-    unsigned long long windowSize;       /* can be very large, up to <= frameContentSize */
-    unsigned blockSizeMax;
-    ZSTD_frameType_e frameType;          /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */
-    unsigned headerSize;
-    unsigned dictID;
-    unsigned checksumFlag;
-    unsigned _reserved1;
-    unsigned _reserved2;
-} ZSTD_frameHeader;
 
-/*! ZSTD_getFrameHeader() :
- *  decode Frame Header, or requires larger `srcSize`.
- * @return : 0, `zfhPtr` is correctly filled,
- *          >0, `srcSize` is too small, value is wanted `srcSize` amount,
- *           or an error code, which can be tested using ZSTD_isError() */
-ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize);   /**< doesn't consume input */
-/*! ZSTD_getFrameHeader_advanced() :
- *  same as ZSTD_getFrameHeader(),
- *  with added capability to select a format (like ZSTD_f_zstd1_magicless) */
-ZSTDLIB_STATIC_API size_t ZSTD_getFrameHeader_advanced(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize, ZSTD_format_e format);
 ZSTDLIB_STATIC_API size_t ZSTD_decodingBufferSize_min(unsigned long long windowSize, unsigned long long frameContentSize);  /**< when frame content size is not known, pass in frameContentSize == ZSTD_CONTENTSIZE_UNKNOWN */
 
 ZSTDLIB_STATIC_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx);
@@ -2769,11 +2961,23 @@ ZSTDLIB_STATIC_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
 
 
 
-/* ============================ */
-/**       Block level API       */
-/* ============================ */
+/* ========================================= */
+/**       Block level API (DEPRECATED)       */
+/* ========================================= */
 
 /*!
+
+    This API is deprecated in favor of the regular compression API.
+    You can get the frame header down to 2 bytes by setting:
+      - ZSTD_c_format = ZSTD_f_zstd1_magicless
+      - ZSTD_c_contentSizeFlag = 0
+      - ZSTD_c_checksumFlag = 0
+      - ZSTD_c_dictIDFlag = 0
+
+    This API is not as well tested as our normal API, so we recommend not using it.
+    We will be removing it in a future version. If the normal API doesn't provide
+    the functionality you need, please open a GitHub issue.
+
     Block functions produce and decode raw zstd blocks, without frame metadata.
     Frame metadata cost is typically ~12 bytes, which can be non-negligible for very small blocks (< 100 bytes).
     But users will have to take in charge needed metadata to regenerate data, such as compressed and content sizes.
@@ -2800,173 +3004,15 @@ ZSTDLIB_STATIC_API ZSTD_nextInputType_e ZSTD_nextInputType(ZSTD_DCtx* dctx);
 */
 
 /*=====   Raw zstd block functions  =====*/
+ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.")
 ZSTDLIB_STATIC_API size_t ZSTD_getBlockSize   (const ZSTD_CCtx* cctx);
+ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.")
 ZSTDLIB_STATIC_API size_t ZSTD_compressBlock  (ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.")
 ZSTDLIB_STATIC_API size_t ZSTD_decompressBlock(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
+ZSTD_DEPRECATED("The block API is deprecated in favor of the normal compression API. See docs.")
 ZSTDLIB_STATIC_API size_t ZSTD_insertBlock    (ZSTD_DCtx* dctx, const void* blockStart, size_t blockSize);  /**< insert uncompressed block into `dctx` history. Useful for multi-blocks decompression. */
 
-
-/* ********************* BLOCK-LEVEL SEQUENCE PRODUCER API *********************
- *
- * *** OVERVIEW ***
- * The Block-Level Sequence Producer API allows users to provide their own custom
- * sequence producer which libzstd invokes to process each block. The produced list
- * of sequences (literals and matches) is then post-processed by libzstd to produce
- * valid compressed blocks.
- *
- * This block-level offload API is a more granular complement of the existing
- * frame-level offload API compressSequences() (introduced in v1.5.1). It offers
- * an easier migration story for applications already integrated with libzstd: the
- * user application continues to invoke the same compression functions
- * ZSTD_compress2() or ZSTD_compressStream2() as usual, and transparently benefits
- * from the specific advantages of the external sequence producer. For example,
- * the sequence producer could be tuned to take advantage of known characteristics
- * of the input, to offer better speed / ratio, or could leverage hardware
- * acceleration not available within libzstd itself.
- *
- * See contrib/externalSequenceProducer for an example program employing the
- * Block-Level Sequence Producer API.
- *
- * *** USAGE ***
- * The user is responsible for implementing a function of type
- * ZSTD_sequenceProducer_F. For each block, zstd will pass the following
- * arguments to the user-provided function:
- *
- *   - sequenceProducerState: a pointer to a user-managed state for the sequence
- *     producer.
- *
- *   - outSeqs, outSeqsCapacity: an output buffer for the sequence producer.
- *     outSeqsCapacity is guaranteed >= ZSTD_sequenceBound(srcSize). The memory
- *     backing outSeqs is managed by the CCtx.
- *
- *   - src, srcSize: an input buffer for the sequence producer to parse.
- *     srcSize is guaranteed to be <= ZSTD_BLOCKSIZE_MAX.
- *
- *   - dict, dictSize: a history buffer, which may be empty, which the sequence
- *     producer may reference as it parses the src buffer. Currently, zstd will
- *     always pass dictSize == 0 into external sequence producers, but this will
- *     change in the future.
- *
- *   - compressionLevel: a signed integer representing the zstd compression level
- *     set by the user for the current operation. The sequence producer may choose
- *     to use this information to change its compression strategy and speed/ratio
- *     tradeoff. Note: the compression level does not reflect zstd parameters set
- *     through the advanced API.
- *
- *   - windowSize: a size_t representing the maximum allowed offset for external
- *     sequences. Note that sequence offsets are sometimes allowed to exceed the
- *     windowSize if a dictionary is present, see doc/zstd_compression_format.md
- *     for details.
- *
- * The user-provided function shall return a size_t representing the number of
- * sequences written to outSeqs. This return value will be treated as an error
- * code if it is greater than outSeqsCapacity. The return value must be non-zero
- * if srcSize is non-zero. The ZSTD_SEQUENCE_PRODUCER_ERROR macro is provided
- * for convenience, but any value greater than outSeqsCapacity will be treated as
- * an error code.
- *
- * If the user-provided function does not return an error code, the sequences
- * written to outSeqs must be a valid parse of the src buffer. Data corruption may
- * occur if the parse is not valid. A parse is defined to be valid if the
- * following conditions hold:
- *   - The sum of matchLengths and literalLengths must equal srcSize.
- *   - All sequences in the parse, except for the final sequence, must have
- *     matchLength >= ZSTD_MINMATCH_MIN. The final sequence must have
- *     matchLength >= ZSTD_MINMATCH_MIN or matchLength == 0.
- *   - All offsets must respect the windowSize parameter as specified in
- *     doc/zstd_compression_format.md.
- *   - If the final sequence has matchLength == 0, it must also have offset == 0.
- *
- * zstd will only validate these conditions (and fail compression if they do not
- * hold) if the ZSTD_c_validateSequences cParam is enabled. Note that sequence
- * validation has a performance cost.
- *
- * If the user-provided function returns an error, zstd will either fall back
- * to an internal sequence producer or fail the compression operation. The user can
- * choose between the two behaviors by setting the ZSTD_c_enableSeqProducerFallback
- * cParam. Fallback compression will follow any other cParam settings, such as
- * compression level, the same as in a normal compression operation.
- *
- * The user shall instruct zstd to use a particular ZSTD_sequenceProducer_F
- * function by calling
- *         ZSTD_registerSequenceProducer(cctx,
- *                                       sequenceProducerState,
- *                                       sequenceProducer)
- * This setting will persist until the next parameter reset of the CCtx.
- *
- * The sequenceProducerState must be initialized by the user before calling
- * ZSTD_registerSequenceProducer(). The user is responsible for destroying the
- * sequenceProducerState.
- *
- * *** LIMITATIONS ***
- * This API is compatible with all zstd compression APIs which respect advanced parameters.
- * However, there are three limitations:
- *
- * First, the ZSTD_c_enableLongDistanceMatching cParam is not currently supported.
- * COMPRESSION WILL FAIL if it is enabled and the user tries to compress with a block-level
- * external sequence producer.
- *   - Note that ZSTD_c_enableLongDistanceMatching is auto-enabled by default in some
- *     cases (see its documentation for details). Users must explicitly set
- *     ZSTD_c_enableLongDistanceMatching to ZSTD_ps_disable in such cases if an external
- *     sequence producer is registered.
- *   - As of this writing, ZSTD_c_enableLongDistanceMatching is disabled by default
- *     whenever ZSTD_c_windowLog < 128MB, but that's subject to change. Users should
- *     check the docs on ZSTD_c_enableLongDistanceMatching whenever the Block-Level Sequence
- *     Producer API is used in conjunction with advanced settings (like ZSTD_c_windowLog).
- *
- * Second, history buffers are not currently supported. Concretely, zstd will always pass
- * dictSize == 0 to the external sequence producer (for now). This has two implications:
- *   - Dictionaries are not currently supported. Compression will *not* fail if the user
- *     references a dictionary, but the dictionary won't have any effect.
- *   - Stream history is not currently supported. All advanced compression APIs, including
- *     streaming APIs, work with external sequence producers, but each block is treated as
- *     an independent chunk without history from previous blocks.
- *
- * Third, multi-threading within a single compression is not currently supported. In other words,
- * COMPRESSION WILL FAIL if ZSTD_c_nbWorkers > 0 and an external sequence producer is registered.
- * Multi-threading across compressions is fine: simply create one CCtx per thread.
- *
- * Long-term, we plan to overcome all three limitations. There is no technical blocker to
- * overcoming them. It is purely a question of engineering effort.
- */
-
-#define ZSTD_SEQUENCE_PRODUCER_ERROR ((size_t)(-1))
-
-typedef size_t ZSTD_sequenceProducer_F (
-  void* sequenceProducerState,
-  ZSTD_Sequence* outSeqs, size_t outSeqsCapacity,
-  const void* src, size_t srcSize,
-  const void* dict, size_t dictSize,
-  int compressionLevel,
-  size_t windowSize
-);
-
-/*! ZSTD_registerSequenceProducer() :
- * Instruct zstd to use a block-level external sequence producer function.
- *
- * The sequenceProducerState must be initialized by the caller, and the caller is
- * responsible for managing its lifetime. This parameter is sticky across
- * compressions. It will remain set until the user explicitly resets compression
- * parameters.
- *
- * Sequence producer registration is considered to be an "advanced parameter",
- * part of the "advanced API". This means it will only have an effect on compression
- * APIs which respect advanced parameters, such as compress2() and compressStream2().
- * Older compression APIs such as compressCCtx(), which predate the introduction of
- * "advanced parameters", will ignore any external sequence producer setting.
- *
- * The sequence producer can be "cleared" by registering a NULL function pointer. This
- * removes all limitations described above in the "LIMITATIONS" section of the API docs.
- *
- * The user is strongly encouraged to read the full API documentation (above) before
- * calling this function. */
-ZSTDLIB_STATIC_API void
-ZSTD_registerSequenceProducer(
-  ZSTD_CCtx* cctx,
-  void* sequenceProducerState,
-  ZSTD_sequenceProducer_F* sequenceProducer
-);
-
 #endif   /* ZSTD_H_ZSTD_STATIC_LINKING_ONLY */
 
 #if defined (__cplusplus)
diff --git a/libfenrir/src/main/jni/thorvg/src/lib/sw_engine/tvgSwRasterTexmap.h b/libfenrir/src/main/jni/thorvg/src/lib/sw_engine/tvgSwRasterTexmap.h
index 40d4037be..b01c8c358 100644
--- a/libfenrir/src/main/jni/thorvg/src/lib/sw_engine/tvgSwRasterTexmap.h
+++ b/libfenrir/src/main/jni/thorvg/src/lib/sw_engine/tvgSwRasterTexmap.h
@@ -548,7 +548,7 @@ static bool _apply(SwSurface* surface, AASpans* aaSpans)
 static bool _rasterTexmapPolygon(SwSurface* surface, const SwImage* image, const Matrix* transform, const SwBBox* region, uint32_t opacity, uint32_t (*blendMethod)(uint32_t))
 {
     //Exceptions: No dedicated drawing area?
-    if (!image->rle || (!region && image->rle->size == 0)) return false;
+    if ((!image->rle && !region) || (image->rle && image->rle->size == 0)) return false;
 
    /* Prepare vertices.
       shift XY coordinates to match the sub-pixeling technique. */
@@ -605,7 +605,7 @@ static bool _rasterTexmapPolygon(SwSurface* surface, const SwImage* image, const
 static bool _rasterTexmapPolygonMesh(SwSurface* surface, const SwImage* image, const Polygon* triangles, const uint32_t triangleCount, const Matrix* transform, const SwBBox* region, uint32_t opacity, uint32_t (*blendMethod)(uint32_t))
 {
     //Exceptions: No dedicated drawing area?
-    if (!image->rle || (!region && image->rle->size == 0)) return false;
+    if ((!image->rle && !region) || (image->rle && image->rle->size == 0)) return false;
 
     // Step polygons once to transform
     auto transformedTris = (Polygon*)malloc(sizeof(Polygon) * triangleCount);
diff --git a/libfenrir/src/main/jni/thorvg/src/lib/tvgAccessor.cpp b/libfenrir/src/main/jni/thorvg/src/lib/tvgAccessor.cpp
index 0add72130..753315c56 100644
--- a/libfenrir/src/main/jni/thorvg/src/lib/tvgAccessor.cpp
+++ b/libfenrir/src/main/jni/thorvg/src/lib/tvgAccessor.cpp
@@ -74,7 +74,7 @@ Accessor::~Accessor()
 }
 
 
-Accessor::Accessor()
+Accessor::Accessor() : pImpl(nullptr)
 {
 
 }
diff --git a/libfenrir/src/main/jni/thorvg/src/lib/tvgPictureImpl.h b/libfenrir/src/main/jni/thorvg/src/lib/tvgPictureImpl.h
index 6ef231322..781e72a6c 100644
--- a/libfenrir/src/main/jni/thorvg/src/lib/tvgPictureImpl.h
+++ b/libfenrir/src/main/jni/thorvg/src/lib/tvgPictureImpl.h
@@ -98,6 +98,10 @@ struct Picture::Impl
                     paint = p.release();
                     loader->close();
                     if (w != loader->w || h != loader->h) {
+                        if (!resizing) {
+                            w = loader->w;
+                            h = loader->h;
+                        }
                         loader->resize(paint, w, h);
                         resizing = false;
                     }
@@ -155,7 +159,7 @@ struct Picture::Impl
         return false;
     }
 
-    bool viewbox(float* x, float* y, float* w, float* h) const
+    bool viewbox(float* x, float* y, float* w, float* h)
     {
         if (!loader) return false;
         if (x) *x = loader->vx;
diff --git a/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoader.cpp b/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoader.cpp
index 5cea9d80d..a07472a85 100644
--- a/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoader.cpp
+++ b/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoader.cpp
@@ -834,20 +834,32 @@ static bool _attrParseSvgNode(void* data, const char* key, const char* value)
 
     if (!strcmp(key, "width")) {
         doc->w = _toFloat(loader->svgParse, value, SvgParserLengthType::Horizontal);
+        doc->viewFlag = (SvgViewFlag)((uint32_t)doc->viewFlag | (uint32_t)SvgViewFlag::Width);
     } else if (!strcmp(key, "height")) {
         doc->h = _toFloat(loader->svgParse, value, SvgParserLengthType::Vertical);
+        doc->viewFlag = (SvgViewFlag)((uint32_t)doc->viewFlag | (uint32_t)SvgViewFlag::Height);
     } else if (!strcmp(key, "viewBox")) {
         if (_parseNumber(&value, &doc->vx)) {
             if (_parseNumber(&value, &doc->vy)) {
                 if (_parseNumber(&value, &doc->vw)) {
-                    _parseNumber(&value, &doc->vh);
-                    loader->svgParse->global.h = doc->vh;
+                    if (_parseNumber(&value, &doc->vh)) {
+                        doc->viewFlag = (SvgViewFlag)((uint32_t)doc->viewFlag | (uint32_t)SvgViewFlag::Viewbox);
+                        loader->svgParse->global.h = doc->vh;
+                    }
+                    loader->svgParse->global.w = doc->vw;
                 }
-                loader->svgParse->global.w = doc->vw;
+                loader->svgParse->global.y = doc->vy;
             }
-            loader->svgParse->global.y = doc->vy;
+            loader->svgParse->global.x = doc->vx;
+        }
+        if (((uint32_t)doc->viewFlag & (uint32_t)SvgViewFlag::Viewbox) && (doc->vw < 0.0f || doc->vh < 0.0f)) {
+            doc->viewFlag = (SvgViewFlag)((uint32_t)doc->viewFlag & ~(uint32_t)SvgViewFlag::Viewbox);
+            TVGLOG("SVG", "Negative values of the <viewBox> width and/or height - the attribute invalidated.");
+        }
+        if (!((uint32_t)doc->viewFlag & (uint32_t)SvgViewFlag::Viewbox)) {
+            loader->svgParse->global.x = loader->svgParse->global.y = 0.0f;
+            loader->svgParse->global.w = loader->svgParse->global.h = 1.0f;
         }
-        loader->svgParse->global.x = doc->vx;
     } else if (!strcmp(key, "preserveAspectRatio")) {
         _parseAspectRatio(&value, &doc->align, &doc->meetOrSlice);
     } else if (!strcmp(key, "style")) {
@@ -1292,22 +1304,22 @@ static SvgNode* _createSvgNode(SvgLoaderData* loader, SvgNode* parent, const cha
     if (!loader->svgParse->node) return nullptr;
     SvgDocNode* doc = &(loader->svgParse->node->node.doc);
 
-    loader->svgParse->global.w = 0;
-    loader->svgParse->global.h = 0;
+    loader->svgParse->global.w = 1.0f;
+    loader->svgParse->global.h = 1.0f;
 
     doc->align = AspectRatioAlign::XMidYMid;
     doc->meetOrSlice = AspectRatioMeetOrSlice::Meet;
+    doc->viewFlag = SvgViewFlag::None;
     func(buf, bufLength, _attrParseSvgNode, loader);
 
-    if (loader->svgParse->global.w == 0) {
-        if (doc->w < FLT_EPSILON) loader->svgParse->global.w = 1;
-        else loader->svgParse->global.w = doc->w;
-    }
-    if (loader->svgParse->global.h == 0) {
-        if (doc->h < FLT_EPSILON) loader->svgParse->global.h = 1;
-        else loader->svgParse->global.h = doc->h;
+    if (!((uint32_t)doc->viewFlag & (uint32_t)SvgViewFlag::Viewbox)) {
+        if ((uint32_t)doc->viewFlag & (uint32_t)SvgViewFlag::Width) {
+            loader->svgParse->global.w = doc->w;
+        }
+        if ((uint32_t)doc->viewFlag & (uint32_t)SvgViewFlag::Height) {
+            loader->svgParse->global.h = doc->h;
+        }
     }
-
     return loader->svgParse->node;
 }
 
@@ -3177,6 +3189,12 @@ SvgLoader::~SvgLoader()
 
 void SvgLoader::run(unsigned tid)
 {
+    //According to the SVG standard the value of the width/height of the viewbox set to 0 disables rendering
+    if (renderingDisabled) {
+        root = Scene::gen();
+        return;
+    }
+
     if (!simpleXmlParse(content, size, true, _svgLoaderParser, &(loaderData))) return;
 
     if (loaderData.doc) {
@@ -3195,7 +3213,7 @@ void SvgLoader::run(unsigned tid)
 
         _updateStyle(loaderData.doc, nullptr);
     }
-    root = svgSceneBuild(loaderData.doc, vx, vy, vw, vh, w, h, align, meetOrSlice, svgPath);
+    root = svgSceneBuild(loaderData.doc, vx, vy, vw, vh, w, h, align, meetOrSlice, svgPath, viewFlag);
 }
 
 
@@ -3208,28 +3226,37 @@ bool SvgLoader::header()
     if (!loaderData.svgParse) return false;
 
     loaderData.svgParse->flags = SvgStopStyleFlags::StopDefault;
+    viewFlag = SvgViewFlag::None;
 
     simpleXmlParse(content, size, true, _svgLoaderParserForValidCheck, &(loaderData));
 
     if (loaderData.doc && loaderData.doc->type == SvgNodeType::Doc) {
-        //Return the brief resource info such as viewbox:
-        vx = loaderData.doc->node.doc.vx;
-        vy = loaderData.doc->node.doc.vy;
-        w = vw = loaderData.doc->node.doc.vw;
-        h = vh = loaderData.doc->node.doc.vh;
+        viewFlag = loaderData.doc->node.doc.viewFlag;
+        align = loaderData.doc->node.doc.align;
+        meetOrSlice = loaderData.doc->node.doc.meetOrSlice;
+        w = 1.0f;
+        h = 1.0f;
 
-        //Override size
-        if (loaderData.doc->node.doc.w > 0) {
+        //Return the brief resource info such as viewbox:
+        if ((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Width) {
             w = loaderData.doc->node.doc.w;
-            if (vw < FLT_EPSILON) vw = w;
         }
-        if (loaderData.doc->node.doc.h > 0) {
+        if ((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Height) {
             h = loaderData.doc->node.doc.h;
-            if (vh < FLT_EPSILON) vh = h;
         }
-
-        align = loaderData.doc->node.doc.align;
-        meetOrSlice = loaderData.doc->node.doc.meetOrSlice;
+        //Override size
+        if ((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Viewbox) {
+            vx = loaderData.doc->node.doc.vx;
+            vy = loaderData.doc->node.doc.vy;
+            vw = loaderData.doc->node.doc.vw;
+            vh = loaderData.doc->node.doc.vh;
+
+            if (!((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Width)) w = vw;
+            if (!((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Height)) h = vh;
+        } else {
+            vw = w;
+            vh = h;
+        }
     } else {
         TVGLOG("SVG", "No SVG File. There is no <svg/>");
         return false;
@@ -3295,8 +3322,20 @@ bool SvgLoader::read()
 {
     if (!content || size == 0) return false;
 
+    if (((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Viewbox) &&
+        (fabsf(vw) <= FLT_EPSILON || fabsf(vh) <= FLT_EPSILON)) {
+        TVGLOG("SVG", "The <viewBox> width and/or height set to 0 - rendering disabled.");
+        renderingDisabled = true;
+    }
+
     TaskScheduler::request(this);
 
+    //In case no viewbox and width/height data is provided the completion of loading
+    //has to be forced, in order to establish this data based on the whole picture bounding box.
+    if (!((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Viewbox) &&
+        (!((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Width) || !((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Height)))
+        this->done();
+
     return true;
 }
 
diff --git a/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoader.h b/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoader.h
index fc42e5bd7..43882b7fb 100644
--- a/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoader.h
+++ b/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoader.h
@@ -51,8 +51,10 @@ class SvgLoader : public LoadModule, public Task
     unique_ptr<Paint> paint() override;
 
 private:
+    SvgViewFlag viewFlag = SvgViewFlag::None;
     AspectRatioAlign align = AspectRatioAlign::XMidYMid;
     AspectRatioMeetOrSlice meetOrSlice = AspectRatioMeetOrSlice::Meet;
+    bool renderingDisabled = false;
 
     bool header();
     void clear();
diff --git a/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoaderCommon.h b/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoaderCommon.h
index 9cb78deaa..ebcbf018e 100644
--- a/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoaderCommon.h
+++ b/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgLoaderCommon.h
@@ -146,6 +146,14 @@ enum class SvgParserLengthType
     Other
 };
 
+enum class SvgViewFlag
+{
+    None = 0x0,
+    Width = 0x01,   //viewPort width
+    Height = 0x02,  //viewPort height
+    Viewbox = 0x04  //viewBox x,y,w,h - used only if all 4 are correctly set
+};
+
 enum class AspectRatioAlign
 {
     None,
@@ -174,6 +182,7 @@ struct SvgDocNode
     float vy;
     float vw;
     float vh;
+    SvgViewFlag viewFlag;
     SvgNode* defs;
     SvgNode* style;
     AspectRatioAlign align;
diff --git a/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgSceneBuilder.cpp b/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgSceneBuilder.cpp
index 5e97b7410..50097e427 100644
--- a/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgSceneBuilder.cpp
+++ b/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgSceneBuilder.cpp
@@ -66,7 +66,6 @@ struct Box
     float x, y, w, h;
 };
 
-
 static bool _appendShape(SvgNode* node, Shape* shape, const Box& vBox, const string& svgPath);
 static unique_ptr<Scene> _sceneBuildHelper(const SvgNode* node, const Box& vBox, const string& svgPath, bool mask, int depth, bool* isMaskWhite = nullptr);
 
@@ -347,7 +346,7 @@ static void _applyProperty(SvgNode* node, Shape* vg, const Box& vBox, const stri
 
     //If stroke property is nullptr then do nothing
     if (style->stroke.paint.none) {
-        //Do nothing
+        vg->stroke(0.0f);
     } else if (style->stroke.paint.gradient) {
         Box bBox = vBox;
         if (!style->stroke.paint.gradient->userSpace) bBox = _boundingBox(vg);
@@ -755,11 +754,24 @@ static unique_ptr<Scene> _sceneBuildHelper(const SvgNode* node, const Box& vBox,
 }
 
 
+static void _applySvgViewFlag(const Scene* scene, float& vx, float& vy, float& vw, float& vh, float& w, float& h, SvgViewFlag viewFlag)
+{
+    if (!((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Viewbox)) {
+        scene->bounds(nullptr, nullptr, &vw, &vh, false);
+        vx = 0.0f;
+        vy = 0.0f;
+        if ((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Width) vw = w;
+        if ((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Height) vh = h;
+    }
+    if (!((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Width)) w = vw;
+    if (!((uint32_t)viewFlag & (uint32_t)SvgViewFlag::Height)) h = vh;
+}
+
 /************************************************************************/
 /* External Class Implementation                                        */
 /************************************************************************/
 
-unique_ptr<Scene> svgSceneBuild(SvgNode* node, float vx, float vy, float vw, float vh, float w, float h, AspectRatioAlign align, AspectRatioMeetOrSlice meetOrSlice, const string& svgPath)
+unique_ptr<Scene> svgSceneBuild(SvgNode* node, float& vx, float& vy, float& vw, float& vh, float& w, float& h, AspectRatioAlign align, AspectRatioMeetOrSlice meetOrSlice, const string& svgPath, SvgViewFlag viewFlag)
 {
     //TODO: aspect ratio is valid only if viewBox was set
 
@@ -767,9 +779,10 @@ unique_ptr<Scene> svgSceneBuild(SvgNode* node, float vx, float vy, float vw, flo
 
     Box vBox = {vx, vy, vw, vh};
     auto docNode = _sceneBuildHelper(node, vBox, svgPath, false, 0);
+    _applySvgViewFlag(docNode.get(), vx, vy, vw, vh, w, h, viewFlag);
 
     if (!mathEqual(w, vw) || !mathEqual(h, vh)) {
-        Matrix m = _calculateAspectRatioMatrix(align, meetOrSlice, w, h, vBox);
+        Matrix m = _calculateAspectRatioMatrix(align, meetOrSlice, w, h, {vx, vy, vw, vh});
         docNode->transform(m);
     } else if (!mathZero(vx) || !mathZero(vy)) {
         docNode->translate(-vx, -vy);
diff --git a/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgSceneBuilder.h b/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgSceneBuilder.h
index b4fbcf163..0de8c9a7d 100644
--- a/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgSceneBuilder.h
+++ b/libfenrir/src/main/jni/thorvg/src/loaders/svg/tvgSvgSceneBuilder.h
@@ -25,6 +25,6 @@
 
 #include "tvgCommon.h"
 
-unique_ptr<Scene> svgSceneBuild(SvgNode* node, float vx, float vy, float vw, float vh, float w, float h, AspectRatioAlign align, AspectRatioMeetOrSlice meetOrSlice, const string& svgPath);
+unique_ptr<Scene> svgSceneBuild(SvgNode* node, float& vx, float& vy, float& vw, float& vh, float& w, float& h, AspectRatioAlign align, AspectRatioMeetOrSlice meetOrSlice, const string& svgPath, SvgViewFlag viewFlag);
 
 #endif //_TVG_SVG_SCENE_BUILDER_H_
diff --git a/picasso3/src/main/kotlin/com/squareup/picasso3/BitmapSafeResize.kt b/picasso3/src/main/kotlin/com/squareup/picasso3/BitmapSafeResize.kt
index 2dce5ca7e..4b8d67f40 100644
--- a/picasso3/src/main/kotlin/com/squareup/picasso3/BitmapSafeResize.kt
+++ b/picasso3/src/main/kotlin/com/squareup/picasso3/BitmapSafeResize.kt
@@ -52,4 +52,28 @@ object BitmapSafeResize {
         bitmap.recycle()
         return tmp
     }
+
+    interface ResizeBitmap {
+        fun doResize(resizedWidth: Int, resizedHeight: Int)
+    }
+
+    fun checkSizeOfBitmapP(sourceWidth: Int, sourceHeight: Int, callback: ResizeBitmap) {
+        if (maxResolution < 0 || sourceWidth <= 0 || sourceHeight <= 0 || sourceWidth <= maxResolution && sourceHeight <= maxResolution) {
+            return
+        }
+        var mWidth = sourceWidth
+        var mHeight = sourceHeight
+        val mCo = mHeight.coerceAtMost(mWidth).toFloat() / mHeight.coerceAtLeast(mWidth)
+        if (mWidth > mHeight) {
+            mWidth = maxResolution
+            mHeight = (maxResolution * mCo).toInt()
+        } else {
+            mHeight = maxResolution
+            mWidth = (maxResolution * mCo).toInt()
+        }
+        if (mWidth <= 0 || mHeight <= 0) {
+            return
+        }
+        callback.doResize(mWidth, mHeight)
+    }
 }
\ No newline at end of file
diff --git a/picasso3/src/main/kotlin/com/squareup/picasso3/BitmapUtils.kt b/picasso3/src/main/kotlin/com/squareup/picasso3/BitmapUtils.kt
index 33a2ffca4..b6c80e2bd 100644
--- a/picasso3/src/main/kotlin/com/squareup/picasso3/BitmapUtils.kt
+++ b/picasso3/src/main/kotlin/com/squareup/picasso3/BitmapUtils.kt
@@ -191,6 +191,8 @@ object BitmapUtils {
                     ImageDecoder.ALLOCATOR_SOFTWARE
                 }
             }
+            var resWidth = imageInfo.size.width
+            var resHeight = imageInfo.size.height
             if (request.hasSize()) {
                 val size = imageInfo.size
                 val width = size.width
@@ -200,8 +202,16 @@ object BitmapUtils {
                 if (shouldResize(request.onlyScaleDown, width, height, targetWidth, targetHeight)) {
                     val ratio = ratio(targetWidth, targetHeight, width, height, request)
                     imageDecoder.setTargetSize(width / ratio, height / ratio)
+                    resWidth = width / ratio
+                    resHeight = height / ratio
                 }
             }
+            BitmapSafeResize.checkSizeOfBitmapP(resWidth, resHeight, object :
+                BitmapSafeResize.ResizeBitmap {
+                override fun doResize(resizedWidth: Int, resizedHeight: Int) {
+                    imageDecoder.setTargetSize(resizedWidth, resizedHeight)
+                }
+            })
         }
     }