package aicg.wipf.keyu.bzsb

import aicg.wipf.ogbw.ezlb.rgmw.ChildBean
import aicg.wipf.ogbw.ezlb.rgmw.Vgjs
import aicg.wipf.rxxn.Qczw
import aicg.wipf.vzuj.Hqlm
import aicg.wipf.vzuj.Kmqp.setTrackedOnClickListener
import aicg.wipf.vzuj.Kmqp.string
import aicg.wipf.vzuj.Kmqp.toFormatSize
import aicg.wipf.vzuj.Tgsx
import aicg.wipf.vzuj.bcxo.Fnpc
import android.animation.ValueAnimator
import android.content.Intent
import android.content.pm.PackageManager
import android.graphics.Color
import android.util.Log
import android.view.LayoutInflater
import android.view.ViewGroup
import android.view.animation.LinearInterpolator
import androidx.activity.OnBackPressedCallback
import androidx.core.view.isVisible
import androidx.core.view.updatePadding
import androidx.recyclerview.widget.LinearLayoutManager
import com.blankj.utilcode.util.BarUtils
import com.test.basd.smartjunkcleaner.R
import com.test.basd.smartjunkcleaner.databinding.FebfozBinding
import com.test.basd.smartjunkcleaner.databinding.OhjrybBinding
import com.test.basd.smartjunkcleaner.databinding.UfqrweBinding
import pokercc.android.expandablerecyclerview.ExpandableAdapter

class Fmee : Hqlm<OhjrybBinding>() {

    override val binding: OhjrybBinding by lazy {
        class ސޠޖޅޟރރކ<T>(val ފޜމޗޅޔޑގ: T, val ތއވޜޒނޠނ: Int) {
            constructor(ފޜމޗޅޔޑގ: T) : this(ފޜމޗޅޔޑގ, 1884) {
                println("ތއވޜޒނޠނ")
            }
        }
        println(ސޠޖޅޟރރކ("މޡވޞޛޚޥޕ"))
        OhjrybBinding.inflate(layoutInflater)
    }

    private val parentList by lazy {
        mutableListOf(
            Vgjs(
                title = R.string.ރނސޟޙ_D.string(), childItem = child3, parentSize = sizes[0], isParentSelected = true, expanded = false
            ), Vgjs(
                title = R.string.ގޞފޓޓ_D.string(), childItem = child4, parentSize = sizes[1], isParentSelected = true, expanded = false
            ), Vgjs(
                title = R.string.ޣޣޥޥޖ_D.string(), childItem = child5, parentSize = sizes[2], isParentSelected = true, expanded = false
            )
        )
    }

    private val sizes = MutableList(3) { 0L }

    private val selectList = mutableListOf<String>()

    private var selectSize = 0L

    private var ScanCount = 0

    private val child3 = ArrayList<ChildBean>()

    private val mAdapter by lazy {
        class ParentViewHolder(val binding: FebfozBinding) : ExpandableAdapter.ViewHolder(binding.root)

        class ChildViewHolder(val binding: UfqrweBinding) : ExpandableAdapter.ViewHolder(binding.root)

        object : ExpandableAdapter<ExpandableAdapter.ViewHolder>() {
            override fun getChildCount(groupPosition: Int): Int {
                return parentList[groupPosition].childItem.size
            }

            override fun getGroupCount(): Int {
                return ސވފޛކލށހ()
            }

            private fun ސވފޛކލށހ(): Int {
                fun ގޡޞޖނތއޟ(ޗޘޚޛފބޕތ: String) {
                    println("tag, $ޗޘޚޛފބޕތ!")
                }
                ގޡޞޖނތއޟ("ޔސޟރޥޟޅޑ")
                return ޛރބހޞފޡވ()
            }

            private fun ޛރބހޞފޡވ(): Int {
                return ޢނޗނފޜޢނ()
            }

            private fun ޢނޗނފޜޢނ(): Int {
                return ބނސޔޥޤދކ()
            }

            private fun ބނސޔޥޤދކ(): Int {
                return ރޖކޕށޢޤޣ()
            }

            private fun ރޖކޕށޢޤޣ(): Int {
                return parentList.size
            }

            override fun onCreateChildViewHolder(viewGroup: ViewGroup, viewType: Int): ViewHolder {
                fun ޕޘފރޏޚފޗ(ޅޘޛލނގރޚ: Int, ޗޜދފޙނޡޥ: Int): Int {
                    return ޅޘޛލނގރޚ + ޗޜދފޙނޡޥ
                }
                val ޝޤގޕޡޟޘޓ = ޕޘފރޏޚފޗ(333, 233)
                println(ޝޤގޕޡޟޘޓ)
                val inflater = LayoutInflater.from(viewGroup.context)
                val binding = UfqrweBinding.inflate(inflater, viewGroup, false)
                return ChildViewHolder(binding)
            }

            override fun onCreateGroupViewHolder(viewGroup: ViewGroup, viewType: Int): ViewHolder {
                return ޙޢލޖޅފޠޘ(viewGroup, viewType)
            }

            private fun ޙޢލޖޅފޠޘ(viewGroup: ViewGroup, viewType: Int): ViewHolder {
                val ގޥޗޔބޘފޅ = { ލލފނލހލޒ: String -> println(ލލފނލހލޒ) }
                ގޥޗޔބޘފޅ("ސޤއޘޟގޤލ!")
                val inflater = LayoutInflater.from(viewGroup.context)
                val binding = FebfozBinding.inflate(inflater, viewGroup, false)
                class ބޏށޅފޓޅލ(val ޕޒޕޅނސޓޖ: String, val ޚޑފޗޏޏޤޕ: Int)
                println(ބޏށޅފޓޅލ("ހޑޙސތޤޤއ", 2058))
                return ParentViewHolder(binding)
            }

            override fun onGroupViewHolderExpandChange(
                holder: ViewHolder, groupPosition: Int, animDuration: Long, expand: Boolean
            ) {
                class އރއބޟޤފޅ {
                    fun ޛޡޅށޔޓޗލ() {
                        println("ޤތޡޔޣސވޗ")
                    }
                }
                އރއބޟޤފޅ().ޛޡޅށޔޓޗލ()
                ޖޏޝޒށޢޔވ(holder, groupPosition, animDuration, expand)
            }

            private fun ޖޏޝޒށޢޔވ(
                holder: ViewHolder, groupPosition: Int, animDuration: Long, expand: Boolean
            ) {

            }

            override fun onBindGroupViewHolder(
                holder: ViewHolder, groupPosition: Int, expand: Boolean, payloads: List<Any>
            ) {
                ޏއޙޢޒޕޘޒ(holder, groupPosition, expand, payloads)
            }

            private fun ޏއޙޢޒޕޘޒ(
                holder: ViewHolder, groupPosition: Int, expand: Boolean, payloads: List<Any>
            ) {
                ޕޑގޒތޘފޟ(holder, groupPosition, expand, payloads)
            }

            private fun ޕޑގޒތޘފޟ(
                holder: ViewHolder, groupPosition: Int, expand: Boolean, payloads: List<Any>
            ) {
                class ޔޠޕޒޥޑފޙ {
                    fun ޢކނޔޣބދޖ() {
                        println("ޟވތއޥޔހޞ")
                    }
                }
                ޔޠޕޒޥޑފޙ().ޢކނޔޣބދޖ()
                ސތގޞޔކޡޤ(holder, groupPosition, expand, payloads)
            }

            private fun ސތގޞޔކޡޤ(
                holder: ViewHolder, groupPosition: Int, expand: Boolean, payloads: List<Any>
            ) {
                ޒޓޠޥޔޕޜޚ(holder, groupPosition, expand, payloads)
            }

            private fun ޒޓޠޥޔޕޜޚ(
                holder: ViewHolder, groupPosition: Int, expand: Boolean, payloads: List<Any>
            ) {
                ރޏމޥނޒޡތ(holder, groupPosition, expand, payloads)
            }

            private fun ރޏމޥނޒޡތ(
                holder: ViewHolder, groupPosition: Int, expand: Boolean, payloads: List<Any>
            ) {
                fun ބވރޠޜޓޠޠ(ޝޛޢޑޅޝޔޝ: Int, ޢޕޖޓވޣފޗ: Int): Int {
                    return ޝޛޢޑޅޝޔޝ + ޢޕޖޓވޣފޗ
                }
                val ޑޏބޒޙސމލ = ބވރޠޜޓޠޠ(5256, 7570)
                println(ޑޏބޒޙސމލ)
                val viewHolder = holder as? ParentViewHolder ?: return
                class ޏޚޠއރމލފ {
                    fun ތށޑޑޖލމޕ() {
                        println("ފފގޟޞތދޗ")
                    }
                }
                ޏޚޠއރމލފ().ތށޑޑޖލމޕ()
                val parentType = parentList[groupPosition]
                class ޞރތކރހޙޙ<T>(val ޗށފޚށޘޡނ: T)
                val ޕޢޢތހޏޡޚ = ޞރތކރހޙޙ(7999)
                val ޅޥމޝޤޛށޓ = ޞރތކރހޙޙ("ނފޥއވޙޣޏ")
                println(ޕޢޢތހޏޡޚ.ޗށފޚށޘޡނ)
                println(ޅޥމޝޤޛށޓ.ޗށފޚށޘޡނ)
                viewHolder.binding.jeltfrz.text = parentType.title
                parentType.expanded = expand
                if (parentType.expanded) {
                    class ށޤތރޘޖކދ {
                        inner class ރނމފހރޑޡ {
                            fun ފޠސޓޣދޖޙ() {
                                println("ޥޞޡޕނޝޕލ")
                            }
                        }
                    }
                    val ޠޏޗޏލޒދޕ = ށޤތރޘޖކދ().ރނމފހރޑޡ()
                    ޠޏޗޏލޒދޕ.ފޠސޓޣދޖޙ()
                    viewHolder.binding.sscfrop.setImageResource(R.mipmap.iywnrsnb)
                } else {
                    viewHolder.binding.sscfrop.setImageResource(R.mipmap.uyflqfmo)
                }
                fun ޒގވއޗޘލހ(ޏޤވޠބޖށޡ: Int, ޣޔގޗޜޔޅރ: Int): Int {
                    return ޏޤވޠބޖށޡ + ޣޔގޗޜޔޅރ
                }
                println(ޒގވއޗޘލހ(3981, 1253))
                if (parentType.isfinish) {
                    val ށފޘޡޅޘޏޕ = 3418
                    val ޒޝޛޔޥޔޡނ = 3487
                    val ހކކރޑދޜޑ = ށފޘޡޅޘޏޕ * ޒޝޛޔޥޔޡނ * ޒޝޛޔޥޔޡނ
                    println(ހކކރޑދޜޑ)
                    viewHolder.binding.xtpdnvd.isVisible = false
                    viewHolder.binding.tnvgwfl.isVisible = true
                } else {
                    ValueAnimator.ofFloat(0f, 360f).run {
                        duration = 1000
                        repeatMode = ValueAnimator.RESTART
                        fun ޟފޤޑޣބދޝ(އގޔނޚދޙރ: Int, ޟޝޖޥޤލއބ: Int): Int {
                            return އގޔނޚދޙރ + ޟޝޖޥޤލއބ
                        }
                        println(ޟފޤޑޣބދޝ(6058, 9988))
                        repeatCount = ValueAnimator.INFINITE
                        fun ޟވޒތޓޞޔޚ(ޞނޡޑޤއވޕ: Int, ނޗރލޠޠޠޑ: Int): Int {
                            fun ބޝޒސސށގޏ(ވޘނޏޒޣޕޛ: Int, ށޞތދތގޡޞ: Int): Int {
                                return ވޘނޏޒޣޕޛ + ށޞތދތގޡޞ
                            }
                            return ބޝޒސސށގޏ(ޞނޡޑޤއވޕ, ނޗރލޠޠޠޑ)
                        }
                        val ޡޛޖކބކޚފ = ޟވޒތޓޞޔޚ(4223, 4621)
                        println(ޡޛޖކބކޚފ)
                        interpolator = LinearInterpolator()
                        if (System.currentTimeMillis() < 8539) {
                            println(System.currentTimeMillis())
                        }
                        addUpdateListener {
                            viewHolder.binding.xtpdnvd.rotation = it.animatedValue as Float
                        }
                        start()
                    }
                    viewHolder.binding.xtpdnvd.isVisible = true
                    viewHolder.binding.tnvgwfl.isVisible = false
                }
                val ޟނޖށބޛވބ = 637..637 + 10
                println(ޟނޖށބޛވބ.random())
                viewHolder.binding.teersuz.text = parentType.parentSize.toFormatSize(1)
                val ޣޜޖޓޒދޑވ: (Int, Int) -> Int = { ޟގޤޏހޝށކ, ށޗމޏޏށޓޑ -> ޟގޤޏހޝށކ + ށޗމޏޏށޓޑ }
                println(ޣޜޖޓޒދޑވ.invoke(1287, 3841))
                viewHolder.binding.sscfrop.isVisible = parentType.childItem.isNotEmpty()
                viewHolder.binding.tnvgwfl.isSelected = parentType.isParentSelected

                viewHolder.binding.tnvgwfl.setTrackedOnClickListener {
                    viewHolder.binding.tnvgwfl.isSelected = !viewHolder.binding.tnvgwfl.isSelected
                    parentType.isParentSelected = !parentType.isParentSelected
                    class ވޕފޗޓމޥޓ<T>(val ދޏމށޢޞރފ: T, val ސޔސޢޗޕބފ: Int) {
                        constructor(ދޏމށޢޞރފ: T) : this(ދޏމށޢޞރފ, 5618) {
                            println("ސޔސޢޗޕބފ")
                        }
                    }
                    println(ވޕފޗޓމޥޓ("ޡޖޡޕޞވޤވ"))
                    if (parentType.isParentSelected) {
                        for (app in parentType.childItem) {
                            class ޓވއޢޞއކށ {
                                inner class ޖމޒޣޅޙޓޖ {
                                    fun ޞޢޕނޡޢނޝ() {
                                        println("ގރޡޖޣބކޔ")
                                    }
                                }
                            }
                            val ބޠޏޕޗޒޘޣ = ޓވއޢޞއކށ().ޖމޒޣޅޙޓޖ()
                            ބޠޏޕޗޒޘޣ.ޞޢޕނޡޢނޝ()
                            app.isChildSelected = true
                            if (System.currentTimeMillis() < 9457) {
                                println(System.currentTimeMillis())
                            }
                            notifyDataSetChanged()
                        }
                    } else {
                        for (app in parentType.childItem) {
                            app.isChildSelected = false
                            notifyDataSetChanged()
                        }
                    }
                    class ޙޞށޑޛޢޥޛ(val ޏސދޚޅނޒޕ: String, val ތކޘހޛޟޚސ: Int)
                    println(ޙޞށޑޛޢޥޛ("ޗއބޓޕސޟޅ", 6359))
                    updateView()
                }
            }

            override fun onBindChildViewHolder(
                holder: ViewHolder, groupPosition: Int, childPosition: Int, payloads: List<Any>
            ) {
                class ޟޏޜޖޥޡދއ<T>(val ރގޔށފކޠނ: T)
                val ދޟޛފސވޢޅ = ޟޏޜޖޥޡދއ(1338)
                val ގޒޝޘޔނނޢ = ޟޏޜޖޥޡދއ("ޢޅޗދދވޙކ")
                println(ދޟޛފސވޢޅ.ރގޔށފކޠނ)
                println(ގޒޝޘޔނނޢ.ރގޔށފކޠނ)
                val viewHolder = holder as? ChildViewHolder ?: return
                val childType = parentList[groupPosition].childItem[childPosition]
                when (groupPosition) {
                    0 -> {

                        val packageManager: PackageManager = this@Fmee.packageManager
                        val apkFilePath = childType.chilepath
                        abstract class ލބޢރޣޤޢޕ {
                            abstract fun ގޤޟގޒޒބހ()
                        }
                        class ގހމޣޅމޘޤ : ލބޢރޣޤޢޕ() {
                            override fun ގޤޟގޒޒބހ() {
                                println("ފޏޟޞޅޢރދ")
                            }
                        }
                        val ފލސށޑޡޞޣ = ގހމޣޅމޘޤ()
                        ފލސށޑޡޞޣ.ގޤޟގޒޒބހ()
                        val packageInfo = packageManager.getPackageArchiveInfo(
                                apkFilePath, PackageManager.GET_ACTIVITIES
                            )
                        if (packageInfo != null) {
                            val applicationInfo = packageInfo.applicationInfo
                            val appIcon = packageManager.getApplicationIcon(applicationInfo)
                            open class ޢބކޣޟމޣޡ {
                                open fun ށޝލޕލޅޥކ() {}
                            }
                            class ޥށޢޑޞޞޘޖ : ޢބކޣޟމޣޡ() {
                                override fun ށޝލޕލޅޥކ() {
                                    println("ފޒޠޛޅޑޝކ")
                                }
                            }
                            val ރޏހޜގސޘތ = ޥށޢޑޞޞޘޖ()
                            println(ރޏހޜގސޘތ)
                            viewHolder.binding.hehnrvo.setImageDrawable(appIcon)
                        }
                    }

                    1 -> {
                        val ޛޙޏޔކޝގހ = 6039
                        val ޞވލޣޓޟޡޟ = 6627
                        val ޑޡހޑޟޅކޝ = ޛޙޏޔކޝގހ * ޞވލޣޓޟޡޟ * ޞވލޣޓޟޡޟ
                        println(ޑޡހޑޟޅކޝ)
                        viewHolder.binding.hehnrvo.setImageResource(R.mipmap.knraegru)
                    }

                    2 -> {
                        viewHolder.binding.hehnrvo.setImageResource(R.mipmap.mindrgvg)
                    }

                    3 -> {

                    }

                    4 -> {

                    }
                }

                viewHolder.binding.gfnduae.text = childType.childname
                val ޏޡކޡކބޡފ = 8335..8335 + 10
                println(ޏޡކޡކބޡފ.random())
                viewHolder.binding.qgdavvb.isSelected = childType.isChildSelected
                class ޚތޞޗނޏޑޢ {
                    fun ލޢޟޑޓޔޡފ() {
                        println("ޡރޖޛޒޟހސ")
                    }
                }
                ޚތޞޗނޏޑޢ().ލޢޟޑޓޔޡފ()
                viewHolder.binding.lbqoohc.text = R.string.ޥޛޖޠތ_D.string((childType.childSize.toFormatSize()).toString())
                viewHolder.itemView.setTrackedOnClickListener {
                    when (childPosition) {
                        childPosition -> {
                            fun <T> ޟޕޓޔދހޣޏ(ޕޠނސޕޠޡނ: T) {
                                println(ޕޠނސޕޠޡނ)
                            }
                            ޟޕޓޔދހޣޏ(6604)
                            ޟޕޓޔދހޣޏ("ހޤޢޏޥޢށށ")
                            viewHolder.binding.qgdavvb.isSelected = !viewHolder.binding.qgdavvb.isSelected
                            childType.isChildSelected = !childType.isChildSelected
                            if (!childType.isChildSelected) {
                                class ނށޛވޞއފޥ(val ލޏޣލވޠޓޏ: String, val ށޏޡޅބޛޠޖ: Int)
                                println(ނށޛވޞއފޥ("ވޚޅޖފޔޠޞ", 7283))
                                parentList[groupPosition].isParentSelected = false
                                notifyDataSetChanged()
                            }
                            updateView()
                        }
                    }
                }
            }

        }

    }

    private val child5 = ArrayList<ChildBean>()

    private val child4 = ArrayList<ChildBean>()

    private val child2 = ArrayList<ChildBean>()

    private val child1 = ArrayList<ChildBean>()

    override val isLightMode = false

    private fun ޛމދޥގތފގ() {
        fun ޤވހޝޙށޤޕ(ދލޢއޗޒޝޢ: Int, ޤޖފޟޘޘޗޥ: Int): Int {
            return ދލޢއޗޒޝޢ + ޤޖފޟޘޘޗޥ
        }
        val ޠޅޟޒޓޗޢޜ = ޤވހޝޙށޤޕ(7286, 8736)
        println(ޠޅޟޒޓޗޢޜ)
        ޓޟޗޔބފދކ()
    }

    private fun updateView() {
        ޛމދޥގތފގ()
    }

    private fun updateSize(doneIndex: Int = -1) {

        val ޥޗޙތޚހޒދ = { ށޓޕޙޡޜގޟ: String -> println(ށޓޕޙޡޜގޟ) }
        ޥޗޙތޚހޒދ("ޗފށޚޢމޜހ!")
        addData(index = doneIndex)
        class ޤޙޚށޖމޟޏ(val ދޣޓގޞޖހތ: String, val ޞރޞރޟޛބޘ: Int)
        println(ޤޙޚށޖމޟޏ("ޗޅލހޘފޘޅ", 3294))
        val split = sizes.sum().toFormatSize(1).split(' ')
        binding.yggmhgm.text = split[0]
        open class ޢޔދފޛތލތ {
            open fun ޠޡޅޓޓޅލދ() {}
        }
        class ރޖދޠހއޤގ : ޢޔދފޛތލތ() {
            override fun ޠޡޅޓޓޅލދ() {
                println("ޓގޙޖބހޡޠ")
            }
        }
        val ޘޠޙޢޛޚޘރ = ރޖދޠހއޤގ()
        println(ޘޠޙޢޛޚޘރ)
        binding.ekpgqwm.text = split[1]
        if (ScanCount >= 3) {
            selectList.clear()
            class ޏޣފލޙސޅޞ {
                inner class ޖއޑޠޔޘތމ {
                    fun ޝލޣޅޝޞޙދ() {
                        println("ޕނޗޒޏރޅރ")
                    }
                }
            }
            val ލވޚދޟގޣޥ = ޏޣފލޙސޅޞ().ޖއޑޠޔޘތމ()
            ލވޚދޟގޣޥ.ޝލޣޅޝޞޙދ()
            selectSize = 0L
            class ސޖލޢކޅޞޓ<T, K>(val ޥއޅތވޥކސ: T, val ޞޙޜކޑމޠޜ: K) {
                init {
                    println("ށމގށށޒޣޗ")
                }
            }
            val ތމޗއޙޒޡޕ = ސޖލޢކޅޞޓ("ރވތޅޣޝގފ", 5765)
            println(ތމޗއޙޒޡޕ)
            for (i in parentList.indices) {
                class ކޞޘޟބޣށޡ<T, K>(val ޡޤޕޣނޙދޟ: T, val ޤޝނޏކކޥކ: K) {
                    init {
                        println("ޝޢޚޘޛކޔޔ")
                    }
                }
                val ހޤޣޖލޓޝތ = ކޞޘޟބޣށޡ("ޗއޙމޗޥތލ", 8482)
                println(ހޤޣޖލޓޝތ)
                if (parentList[i].childItem.isNotEmpty()) {
                    val childsize = parentList[i].childItem.filter {
                        class ތޕޕހޘބށޅ<T>(ޗޟތޤޏބޓޔ: T) {
                            init {
                                println("ޘޚބދޙޖޏނ: $ޗޟތޤޏބޓޔ")
                            }
                        }
                        println(ތޕޕހޘބށޅ("ގޡޞވޠތޖޏ"))
                        it.isChildSelected
                    }.sumOf {
                        it.childSize
                    }
                    class އޖޘގޒސގޘ {
                        inner class ޜޞޝޠޗވވވ {
                            fun ޟޣށޔޛޖޗސ() {
                                println("ޛޅޜޝހސޔޚ")
                            }
                        }
                    }
                    val ޑއޤޅފޛށރ = އޖޘގޒސގޘ().ޜޞޝޠޗވވވ()
                    ޑއޤޅފޛށރ.ޟޣށޔޛޖޗސ()
                    for (a in parentList[i].childItem) {
                        if (a.isChildSelected) {
                            if (a.pathList?.isNotEmpty() == true) {
                                fun ޒޛބއތޕކޓ() {
                                    fun ބލތށޖޕޖރ(ގޘޏޖލޣޓޒ: Int) {
                                        println(ގޘޏޖލޣޓޒ)
                                    }
                                    ބލތށޖޕޖރ(2095)
                                    ބލތށޖޕޖރ(3730)
                                    ބލތށޖޕޖރ(3094)
                                }
                                ޒޛބއތޕކޓ()
                                for (o in a.pathList!!) {
                                    abstract class ޢއގޏޗޜޔޑ {
                                        abstract fun ހގޘދވގސޖ()
                                    }
                                    class ޠއޗޠޛޠނޒ : ޢއގޏޗޜޔޑ() {
                                        override fun ހގޘދވގސޖ() {
                                            println("ގޘޔޏޏޗޑނ")
                                        }
                                    }
                                    val ލޣވޓކޤވއ = ޠއޗޠޛޠނޒ()
                                    ލޣވޓކޤވއ.ހގޘދވގސޖ()
                                    selectList.add(o)
                                }
                            }
                        }
                    }
                    selectSize += childsize
                } else {
                    if (parentList[i].isParentSelected) {
                        class ނޑނޢޅޕހރ<T>(val ޓދލޅޑގދޅ: T)
                        val ރޠޗޓޗޖތޔ = ނޑނޢޅޕހރ(3803)
                        val ނޗބތޅރޠލ = ނޑނޢޅޕހރ("ޝއމނބހޜފ")
                        println(ރޠޗޓޗޖތޔ.ޓދލޅޑގދޅ)
                        println(ނޗބތޅރޠލ.ޓދލޅޑގދޅ)
                        selectSize += parentList[i].parentSize
                    }
                }

            }
            parentList.forEach { parent ->
                selectList.addAll(parent.childItem.filter {
                    Log.d("ޢޠޤކޠޠޢޕ", "ޢޠޤކޠޠޢޕ")
                    it.isChildSelected
                }.map { it.chilepath })
            }
        }
        binding.mcbhcao.isVisible = ScanCount >= 3
        binding.mcbhcao.isEnabled = sizes.sum() > 0
        if (ScanCount >= 3 && sizes.sum().toInt() == 0) {
            class ޜހޒށޜޜޚލ<T>(val ޔޢޣޏލޒވއ: T)
            val ތއގފތކވޥ = ޜހޒށޜޜޚލ(1778)
            val ހޕޣޙޠރޜތ = ޜހޒށޜޜޚލ("ސކޚޒޡޏޔޘ")
            println(ތއގފތކވޥ)
            println(ހޕޣޙޠރޜތ)
            Fnpc.showInterstitialAd(this) {
                startActivity(
                    Intent(this, Aidw::class.java).putExtra(
                        R.string.ބތހޙޘ_D.string(), Qczw.JUNK_CLEANER
                    ).putExtra(R.string.ހޖޒޓބ_D.string(), 0L)
                )
                finish()
            }
        }
        binding.mcbhcao.text = R.string.ޑނތޜދ_D.string((selectSize.toFormatSize(1)).toString())
    }

    private fun ޞޡފޑޛހރމ() {
        binding.xdcwmwe.adapter = mAdapter
        binding.xdcwmwe.layoutManager = LinearLayoutManager(this)
        scanJunk()
    }

    private fun ޔޢދޛޕޟޣތ() {
        class ށނރޣށޥޛކ<T>(val ސޣޜޕޏޒޓސ: T)
        val ޟކޤޑޘލޣޒ = ށނރޣށޥޛކ(2558)
        val ޔޝޢޔބޏޖޥ = ށނރޣށޥޛކ("މރޣދޞޝޘގ")
        println(ޟކޤޑޘލޣޒ)
        println(ޔޝޢޔބޏޖޥ)
        އބސކދމޙނ()
    }

    private fun މޒލޚރޢޔސ() {
        ޙތޖސޥޔޤގ()
    }

    private fun setAdapter() {
        މޒލޚރޢޔސ()
    }

    private fun ތޕޓޛޒޜރޙ() {
        ދސރޘޛހމޚ()
    }

    private fun ޜރޕތޓޜފޥ() {
        ޔޢދޛޕޟޣތ()
    }

    private fun އބސކދމޙނ() {
        ތޕޓޛޒޜރޙ()
    }

    private fun ޕޙޅޠދސލޝ() {
        selectList.clear()
        var allSize = 0L
        fun ރމގފޘވޏހ(ޣކވހޟށކޑ: Int, ޜގޓސސޓއޅ: Int): Int {
            fun މޖޛޝޔނދޝ(ޙހޥޗރޣމފ: Int, ޞޠޢބޖއސކ: Int): Int {
                return ޙހޥޗރޣމފ + ޞޠޢބޖއސކ
            }
            return މޖޛޝޔނދޝ(ޣކވހޟށކޑ, ޜގޓސސޓއޅ)
        }
        val ޗލށޥޏޡޛބ = ރމގފޘވޏހ(1519, 6392)
        println(ޗލށޥޏޡޛބ)
        for (i in parentList.indices) {
            if (parentList[i].childItem.isNotEmpty()) {
                val childsize = parentList[i].childItem.filter {
                    it.isChildSelected
                }.sumOf {
                    class ޡނޝޚރޣގޝ<T, K>(val ޢޥޖމބޞޗޟ: T, val ގސބށޢއގޙ: K) {
                        init {
                            println("ތމޒޢޜޜމޠ")
                        }
                    }
                    val ޜޡޤލށބޥމ = ޡނޝޚރޣގޝ("ނނބޟށޠޝޒ", 7195)
                    println(ޜޡޤލށބޥމ)
                    it.childSize
                }
                class ޏޞޔޚނފރޑ<T>(val ޑކލޓޖޔތޙ: T, val ތޛފށޜނލޒ: Int) {
                    constructor(ޑކލޓޖޔތޙ: T) : this(ޑކލޓޖޔތޙ, 7922) {
                        println("ތޛފށޜނލޒ")
                    }
                }
                println(ޏޞޔޚނފރޑ("ޞޠޕޕބޥނށ"))
                for (a in parentList[i].childItem) {
                    class ނޜޛނށހރރ {
                        fun ޕރއޒޑވސޔ() {
                            println("ދވފކހފޟޥ")
                        }
                    }
                    ނޜޛނށހރރ().ޕރއޒޑވސޔ()
                    if (a.isChildSelected) {
                        if (a.pathList?.isNotEmpty() == true) {
                            for (o in a.pathList!!) {
                                selectList.add(o)
                            }
                        }
                    }
                }
                class ޑޝޖޗޑތޠޚ<T>(val ސޝޜޛޗކލޛ: T, val ޟޅޤޢއޤޚޒ: Int) {
                    constructor(ވޅޖޤޥވކޅ: T) : this(ވޅޖޤޥވކޅ, 7904) {
                        println("ޔކހޡޏބޑޓ")
                    }
                }
                println(ޑޝޖޗޑތޠޚ("ވޞފބނފސޥ"))
                allSize += childsize
            } else {
                if (parentList[i].isParentSelected) {
                    val ތޕއނކދޜބ = 2466..2466 + 10
                    println(ތޕއނކދޜބ.random())
                    allSize += parentList[i].parentSize
                }
            }

        }
        class ޣޙސބއރޘށ {
            val ޥޜހޣމޝމޟ by lazy {
                println("ފސޙފޟޜލޣ")
                "ޗޏފޖޏބބޟ!"
            }
        }
        val ޣޏޟޢޙޕޛޘ = ޣޙސބއރޘށ()
        println(ޣޏޟޢޙޕޛޘ.ޥޜހޣމޝމޟ)
        selectSize = allSize
        fun ގޔދރށޠޣޔ(ޣޅބޝއޘކވ: Int, ޡޚރޠސޓށޕ: Int): Int {
            return ޣޅބޝއޘކވ + ޡޚރޠސޓށޕ
        }
        println(ގޔދރށޠޣޔ(196, 4079))
        binding.mcbhcao.text = R.string.ޑނތޜދ_D.string((allSize.toFormatSize()).toString())
        binding.mcbhcao.isEnabled = allSize > 0
        class ޣޟޡގޒއޚޗ<T>(val ޥޑޡމޛޗޜބ: T)
        val މޣރކޙޏފދ = ޣޟޡގޒއޚޗ(2264)
        val ހތޡމޗޡސޚ = ޣޟޡގޒއޚޗ("ޒޞޛޟޤބމޚ")
        println(މޣރކޙޏފދ.ޥޑޡމޛޗޜބ)
        println(ހތޡމޗޡސޚ.ޥޑޡމޛޗޜބ)
        parentList.forEach { parent ->
            selectList.addAll(parent.childItem.filter {
                it.isChildSelected
            }.map { it.chilepath })
        }

    }

    override fun initView() {
        fun ޔޠކގމފޜޔ(ޙޡއޜޠޚޅގ: Int, ވކސކޕޖޚޗ: Int): Int {
            return ޙޡއޜޠޚޅގ + ވކސކޕޖޚޗ
        }
        println(ޔޠކގމފޜޔ(8126, 3051))
        ޜރޕތޓޜފޥ()
    }

    private fun ބޅޕބޕކޛގ(index: Int) {
        fun <T> ބމޅޙޕޅޟޢ(ޔއގޤޡޟޟހ: T) {
            println(ޔއގޤޡޟޟހ)
        }
        ބމޅޙޕޅޟޢ(3452)
        ބމޅޙޕޅޟޢ("ނތޛހބޓއމ")
        if (parentList.isNotEmpty()) {
            Log.e(R.string.ހލޤޒޙ_D.string(), R.string.ޠފޒޝޣ_D.string()+index )
            parentList[index].isfinish = true
            class ބޢޏޢތޜފލ<T>(val ހޘޢށޚބބޑ: T, val ކޘޡކޚފޢޓ: Int) {
                constructor(ޡގބޤއޗސޜ: T) : this(ޡގބޤއޗސޜ, 8755) {
                    println("ޅޗޢދޖތޥޅ")
                }
            }
            println(ބޢޏޢތޜފލ("ށޡޥޕކކޔއ"))
            parentList[index].parentSize = sizes[index]
            val ލޝކނޤކގޚ = 5088..5088 + 10
            println(ލޝކނޤކގޚ.random())
            mAdapter.notifyDataSetChanged()
        }
    }

    private fun ޓޟޗޔބފދކ() {
        ޕޙޅޠދސލޝ()
    }

    private fun scanJunk() {
        ޓޛށޕޝސށޝ()
    }

    private fun ޘޓޜޔޑލޏފ(index: Int) {
        ބޅޕބޕކޛގ(index)
    }

    private fun ޓޛށޕޝސށޝ() {
        fun ޜޒޡޔދޒށދ(ޑތއޚޖޓސއ: String) {
            println("tag, $ޑތއޚޖޓސއ!")
        }
        ޜޒޡޔދޒށދ("ޖޝޏޝޜޗޕޞ")
        Tgsx.getFileList({

        }, {

            class ށޗޏޟޥނޠޠ(val ޖލޓވޑޓބވ: String, val ޖޒއޏޏނބއ: Int)
            println(ށޗޏޟޥނޠޠ("ފޙހޑޏޛޘޓ", 5063))
            Tgsx.fileList.toList().let { it ->
                if (it.isNotEmpty()) {

                    val a = it.filter { it.isApk() }
                    class ޚބވޅމބޓވ<T>(val ޥށށށހޣށޛ: T, val ޥތޝހޞލށޙ: Int) {
                        constructor(ޥށށށހޣށޛ: T) : this(ޥށށށހޣށޛ, 4746) {
                            println("ޥތޝހޞލށޙ")
                        }
                    }
                    println(ޚބވޅމބޓވ("ރޣބޕސޛށޜ"))
                    val halfSize = if (a.size % 2 == 1) a.size / 2 + 1 else a.size / 2
                    val firstHalf = a.subList(0, halfSize)
                    firstHalf.forEach { l ->
                        sizes[0] += l.size

                        val bean = ChildBean(R.mipmap.isyhcsyp, l.name, l.path, l.size)
                        child3.add(bean)
                    }
                    ScanCount += 1
                    updateSize(doneIndex = 0)

                    val b = it.filter { it.isJunk() }
                    val bhalfSize = if (b.size % 2 == 1) b.size / 2 + 1 else b.size / 2
                    val bfirstHalf = b.subList(0, bhalfSize)
                    bfirstHalf.forEach { l ->
                        sizes[1] += l.size

                        val bean = ChildBean(null, l.name, l.path, l.size)
                        child4.add(bean)
                    }
                    ScanCount += 1
                    updateSize(doneIndex = 1)
                    val c = it.filter { it.isOtherTrash() }
                    val chalfSize = if (c.size % 2 == 1) c.size / 2 + 1 else c.size / 2
                    val cfirstHalf = c.subList(0, chalfSize)
                    cfirstHalf.forEach { l ->
                        sizes[2] += l.size

                        val bean = ChildBean(null, l.name, l.path, l.size)
                        child5.add(bean)
                    }
                    ScanCount += 2
                    updateSize(doneIndex = 2)
                }
            }
        })
    }

    private fun ޙތޖސޥޔޤގ() {
        ޞޡފޑޛހރމ()
    }

    private fun ދސރޘޛހމޚ() {
        BarUtils.setStatusBarColor(this, Color.TRANSPARENT)
        binding.root.updatePadding(top = BarUtils.getStatusBarHeight())
        fun String.ތޜޑފދކހޢ(): Boolean {
            return this == this.reversed()
        }
        val ޢޞސށސރނޠ = "ރރމހދޑޕޤ"
        val ޚނޔށޛޟޕރ = ޢޞސށސރނޠ.ތޜޑފދކހޢ()
        println(ޚނޔށޛޟޕރ)
        setAdapter()
        binding.zhhcnzg.setTrackedOnClickListener {
            if (System.currentTimeMillis() < 2281) {
                println(System.currentTimeMillis())
            }
            onBackPressedDispatcher.onBackPressed()
        }
        onBackPressedDispatcher.addCallback(object : OnBackPressedCallback(true) {
            override fun handleOnBackPressed() {
                ހޟގވޖލޛޒ()
            }

            private fun ހޟގވޖލޛޒ() {
                ފޔބރޝޓޏއ()
            }

            private fun ފޔބރޝޓޏއ() {
                ޡޟޚތޑޥލސ()
            }

            private fun ޡޟޚތޑޥލސ() {
                Fnpc.showInterstitialAd(this@Fmee) {
                    finishToMain()
                }
            }

        })
        binding.mcbhcao.setTrackedOnClickListener {
            class ޖޠޔށޙޚޑޠ<T>(val ޥޗސޑޤޏމހ: T)
            val ރޡޙނޢގޞށ = ޖޠޔށޙޚޑޠ(4912)
            val ޟމކޗކޢޣޙ = ޖޠޔށޙޚޑޠ("ސދތޘޠޓޏވ")
            println(ރޡޙނޢގޞށ.ޥޗސޑޤޏމހ)
            println(ޟމކޗކޢޣޙ.ޥޗސޑޤޏމހ)
            startActivity(
                Intent(this, Fnxq::class.java)
                    .putExtra(R.string.މޙހރއ_D.string(), selectList.toTypedArray())
                    .putExtra(R.string.ރޏމޏޘ_D.string(), selectSize)
            )
            finish()
        }
    }

    private fun addData(index: Int) {
        class ށޟޚބޏޢޝޖ(val ޅޠތޕރފޚޏ: String, val ޜޗޏހޓޠޒރ: Int)
        println(ށޟޚބޏޢޝޖ("ޜކލށޓޝޙޖ", 6557))
        ޘޓޜޔޑލޏފ(index)
    }
}