package aicg.wipf.keyu.bzsb

import aicg.wipf.ogbw.ezlb.rgmw.Qwcc
import aicg.wipf.rxxn.Gdmk
import aicg.wipf.vzuj.Hqlm
import aicg.wipf.vzuj.Hwco
import aicg.wipf.vzuj.Kmqp.setTrackedOnClickListener
import aicg.wipf.vzuj.Kmqp.string
import aicg.wipf.vzuj.Kmqp.toFormatSize
import aicg.wipf.vzuj.Npaq
import aicg.wipf.vzuj.bcxo.Fnpc
import android.app.AppOpsManager
import android.app.usage.NetworkStats
import android.app.usage.NetworkStatsManager
import android.content.Context
import android.graphics.Color
import android.net.ConnectivityManager
import android.os.Build
import android.util.Log
import android.util.SparseLongArray
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ImageView
import android.widget.ProgressBar
import android.widget.TextView
import androidx.activity.OnBackPressedCallback
import androidx.core.util.forEach
import androidx.core.view.isVisible
import androidx.core.view.updatePadding
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.RecyclerView
import com.blankj.utilcode.util.AppUtils
import com.blankj.utilcode.util.BarUtils
import com.test.basd.smartjunkcleaner.R
import com.test.basd.smartjunkcleaner.databinding.LngerpBinding
import kotlin.random.Random

class Rohw : Hqlm<LngerpBinding>() {

    override val binding: LngerpBinding by lazy {
        LngerpBinding.inflate(layoutInflater)
    }

    private val AllList = mutableListOf<Qwcc>()

    private var types = 2

    private var startTime = Hwco.getTimesMonthmorning()

    private val mobileList = mutableListOf<Qwcc>()

    private val wifiList = mutableListOf<Qwcc>()

    private val mAdapter by lazy {
        class ތގޟޕޥލޔށ {
            inner class ވޏޞޖޅގޟޏ {
                fun ޕޏޝބޙޢފތ() {
                    println("ރޒޥޔކތލމ")
                }
            }
        }
        val ޅޛޤޡޖފޣޕ = ތގޟޕޥލޔށ().ވޏޞޖޅގޟޏ()
        ޅޛޤޡޖފޣޕ.ޕޏޝބޙޢފތ()
        class ViewHolder(view: View) : RecyclerView.ViewHolder(view) {
            val ivImage: ImageView
            val tvName: TextView
            val tvTraffic: TextView
            val wifiPro: ProgressBar
            val mobilePro: ProgressBar
            val tvstop: TextView

            init {
                ivImage = view.findViewById(R.id.vkjjfgs)
                fun <T> ޛޝޙގޤޗޥޛ(ޗރޔޙޖޜމޡ: T) {
                    println(ޗރޔޙޖޜމޡ)
                }
                ޛޝޙގޤޗޥޛ(298)
                ޛޝޙގޤޗޥޛ("ގޠޡޜދބޣކ")
                tvName = view.findViewById(R.id.bqopacr)
                fun ޚވބނޗސމރ(ޢޔޣޔސޜވގ: Int, ޞގޒޤސސޚޓ: Int): Int {
                    return ޢޔޣޔސޜވގ + ޞގޒޤސސޚޓ
                }
                println(ޚވބނޗސމރ(7402, 9810))
                tvTraffic = view.findViewById(R.id.mxabqwj)
                class ޟޛޛޢތޙމޒ {
                    inner class ހއޗޝށރލޘ {
                        fun ޢޢޑޗޖޗޡޕ() {
                            println("ޜޗޓޡޓހޏޓ")
                        }
                    }
                }
                val ގޏޜޛބކއޥ = ޟޛޛޢތޙމޒ().ހއޗޝށރލޘ()
                ގޏޜޛބކއޥ.ޢޢޑޗޖޗޡޕ()
                wifiPro = view.findViewById(R.id.txlenjo)
                if (System.currentTimeMillis() < 5465) {
                    println(System.currentTimeMillis())
                }
                mobilePro = view.findViewById(R.id.avqejlc)
                tvstop = view.findViewById(R.id.latxkbs)
            }
        }

        object : RecyclerView.Adapter<ViewHolder>() {
            override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
                if (System.currentTimeMillis() < 5324) {
                    println(System.currentTimeMillis())
                }
                return ޡޕޅކޟޠޙޏ(parent, viewType)
            }

            private fun ޡޕޅކޟޠޙޏ(parent: ViewGroup, viewType: Int): ViewHolder {
                return ފޙޙޤކސޖޕ(parent, viewType)
            }

            private fun ފޙޙޤކސޖޕ(parent: ViewGroup, viewType: Int): ViewHolder {
                return ނޤޛކޠޑޞޥ(parent, viewType)
            }

            private fun ނޤޛކޠޑޞޥ(parent: ViewGroup, viewType: Int): ViewHolder {
                val view = LayoutInflater.from(this@Rohw).inflate(
                    R.layout.ezpyjw, parent, false
                )
                return ViewHolder(view)
            }

            override fun getItemCount() = AllList.size

            override fun onBindViewHolder(holder: ViewHolder, position: Int) {
                ޤޟތޒޓދތޕ(holder, position)
            }

            private fun ޤޟތޒޓދތޕ(holder: ViewHolder, position: Int) {
                ޜޚޛފޖކޤށ(holder, position)
            }

            private fun ޜޚޛފޖކޤށ(holder: ViewHolder, position: Int) {
                fun ކނޡބޜޢރޖ(ނޣމޢޔޣޖޔ: Int, ޟޖޡޕސޜޣޑ: Int): Int {
                    return ނޣމޢޔޣޖޔ + ޟޖޡޕސޜޣޑ
                }
                println(ކނޡބޜޢރޖ(7568, 1195))
                ވޛނޥޖޣފޞ(holder, position)
            }

            private fun ވޛނޥޖޣފޞ(holder: ViewHolder, position: Int) {
                val c = Npaq.appList?.firstOrNull {
                    class ރޟޅޙބމޢޥ<T, K>(val ފޔޏތޕލއނ: T, val ހޑޗށޠލޠހ: K) {
                        init {
                            println("ތޒޚޗޡފރޙ")
                        }
                    }
                    val ދކޝޢސމކގ = ރޟޅޙބމޢޥ("ޞޘށޑޖޠޕށ", 1893)
                    println(ދކޝޢސމކގ)
                    it.packageName == AllList[position].packageName
                }
                Log.d("ޒލޤމޜފނލ", "ޒލޤމޜފނލ")
                holder.ivImage.setImageDrawable(c?.icon)
                holder.tvName.text = c?.name
                class ޣޤޑދރޛވގ<T>(val ހހދޠނބޏޙ: T)
                val ޖޗޏލޔޑޕޣ = ޣޤޑދރޛވގ(7116)
                val ޅގޅޞފޖޜއ = ޣޤޑދރޛވގ("ޠށރޖޗޟޛޅ")
                println(ޖޗޏލޔޑޕޣ)
                println(ޅގޅޞފޖޜއ)
                holder.tvTraffic.text = (AllList[position].wifiUsed + AllList[position].mobileUsed).toFormatSize()

                holder.wifiPro.max = (AllList[0].wifiUsed + AllList[0].mobileUsed).toInt()
                holder.mobilePro.max = (AllList[0].wifiUsed + AllList[0].mobileUsed).toInt()
                holder.wifiPro.progress = (AllList[position].wifiUsed + AllList[position].mobileUsed).toInt()
                holder.mobilePro.progress = (AllList[position].mobileUsed).toInt()
                class ޑޏސޕފރސފ<T>(val ނޗޗޖޝނޏޏ: T)
                val ޟޘޥލޓގޟޜ = ޑޏސޕފރސފ(4848)
                val ޒތޑޑޤޛޓއ = ޑޏސޕފރސފ("ޑހޚހޒގޢޞ")
                println(ޟޘޥލޓގޟޜ.ނޗޗޖޝނޏޏ)
                println(ޒތޑޑޤޛޓއ.ނޗޗޖޝނޏޏ)
                holder.tvstop.isEnabled = Hwco.canStop(this@Rohw, AllList[position].packageName)
                holder.tvstop.setTrackedOnClickListener {
                    class ޚޜޅޚޥޜޓޥ {
                        val ގޟޖޟޝޝޜޜ by lazy {
                            println("ވޡސޔފޘގޡ")
                            "ބބޜޤޢޔސދ!"
                        }
                    }
                    val ޕޙކލޑޛޣސ = ޚޜޅޚޥޜޓޥ()
                    println(ޕޙކލޑޛޣސ.ގޟޖޟޝޝޜޜ)
                    AppUtils.launchAppDetailsSettings(AllList[position].packageName)
                }
                holder.itemView.setTrackedOnClickListener {

                class ޣޤށޗތޑގދ<T>(val ސވމޑޣބހޘ: T, val ފޅޑތރޚސޓ: Int) {
                    constructor(ޤޒޡސޣޕޙޛ: T) : this(ޤޒޡސޣޕޙޛ, 4551) {
                        println("ޏޕގވޖޖފޕ")
                    }
                }
                println(ޣޤށޗތޑގދ("ނޡޙޛބގޏޙ"))
                }

            }

            override fun onBindViewHolder(
                holder: ViewHolder, position: Int, payloads: MutableList<Any>
            ) {
                fun ށޝޕށށކކޏ(ބގޔޜޠޅޜޑ: Int, ގޜޙޚރޓޚލ: Int): Int {
                    fun ޚލޝތޥޘޞޅ(ޥތތތޡބރޜ: Int, ޔޚޒޏޖތޡޖ: Int): Int {
                        return ޥތތތޡބރޜ + ޔޚޒޏޖތޡޖ
                    }
                    return ޚލޝތޥޘޞޅ(ބގޔޜޠޅޜޑ, ގޜޙޚރޓޚލ)
                }
                val ދކދރޟޙގޣ = ށޝޕށށކކޏ(4180, 4454)
                println(ދކދރޟޙގޣ)
                super.onBindViewHolder(holder, position, payloads)
            }
        }
    }

    private var ifPlayAnimal = false

    private fun ޖޓޜބވބޖހ(
    ) {

        val allMobide = getNetworkStats(
            ConnectivityManager.TYPE_MOBILE, startTime, System.currentTimeMillis()
        )
        val allWifi = getNetworkStats(
            ConnectivityManager.TYPE_WIFI, startTime, System.currentTimeMillis()
        )
        AllList.clear()
        mobileList.clear()
        wifiList.clear()
        var mobileSize = 0L
        allMobide.forEach { key, value ->
            mobileSize += value
            val appPkg = packageManager.getPackagesForUid(key)
            if (appPkg?.isNotEmpty() == true) {
                Log.d("ޣޚމމޙތއވ", "ޣޚމމޙތއވ")
                val bean = Qwcc(1, appPkg[0], 0, value)
                class ބޒރޏޠޣބޝ {
                    inner class ޓޜޒސޘޑގޤ {
                        fun ޕސޛޟޤޢޙޒ() {
                            println("ޣޡޜޚލރޝރ")
                        }
                    }
                }
                val ޥހޥލޤކޞއ = ބޒރޏޠޣބޝ().ޓޜޒސޘޑގޤ()
                ޥހޥލޤކޞއ.ޕސޛޟޤޢޙޒ()
                mobileList.add(bean)
            }
        }
        mobileList.sortByDescending { it.mobileUsed }
        binding.bemnulk.text = mobileSize.toFormatSize()
        var wifi = 0L
        allWifi.forEach { key, value ->
            wifi += value
            val appPkg = packageManager.getPackagesForUid(key)
            if (appPkg?.isNotEmpty() == true) {
                val bean = Qwcc(2, appPkg[0], value, 0)
                wifiList.add(bean)
            }
        }
        binding.stlcrun.text = wifi.toFormatSize()
        wifiList.sortByDescending { it.wifiUsed }

        val map = hashMapOf<String, Qwcc>()
        if (types != 0) {
            for (bean in wifiList) {
                val ޒޑރޙޙޥވފ = 1384
                val ޗދޥވޑޒގޥ = 4100
                val ޕހޅޔދޚޞލ = ޒޑރޙޙޥވފ * ޗދޥވޑޒގޥ * ޗދޥވޑޒގޥ
                println(ޕހޅޔދޚޞލ)
                map[bean.packageName] = bean
            }
        }
        if (types != 1) {
            for (bean in mobileList) {
                fun <T> ޥޅޠޛޑޅށޜ(ކގޙޏޡޣގޤ: T) {
                    println(ކގޙޏޡޣގޤ)
                }
                ޥޅޠޛޑޅށޜ(453)
                ޥޅޠޛޑޅށޜ("ޥޖވޣދޜސވ")
                if (map.containsKey(bean.packageName)) {
                    open class ޑދޛސޤސޗޠ {
                        open fun ޛސޛތޓޢޑބ() {}
                    }
                    class ދޖއޡގކޥޏ : ޑދޛސޤސޗޠ() {
                        override fun ޛސޛތޓޢޑބ() {
                            println("ޥޒދދޞހޣޠ")
                        }
                    }
                    val ޔޟޑޜޠރކޔ = ދޖއޡގކޥޏ()
                    println(ޔޟޑޜޠރކޔ)
                    val oldBean = map[bean.packageName]
                    val އޔފޟޠޜބޕ = 7124
                    val ވޕމޜޣޑމޗ = 1195
                    val ގހފޖޞވވކ = އޔފޟޠޜބޕ * ވޕމޜޣޑމޗ * ވޕމޜޣޑމޗ
                    println(ގހފޖޞވވކ)
                    oldBean?.type = oldBean?.type?.plus(bean.type) ?: bean.type
                    fun ށވޞޒޜޓޘބ(އރސޣބޛޝނ: Int, ޅޟޖޘށކފވ: Int): Int {
                        return އރސޣބޛޝނ + ޅޟޖޘށކފވ
                    }
                    val ދޗޚޢޒށޥޘ = ށވޞޒޜޓޘބ(2089, 9098)
                    println(ދޗޚޢޒށޥޘ)
                    oldBean?.mobileUsed = oldBean?.mobileUsed?.plus(bean.mobileUsed) ?: bean.mobileUsed
                    Log.d("ޞމވރއޝއޓ", "ޞމވރއޝއޓ")
                    oldBean?.wifiUsed = oldBean?.wifiUsed?.plus(bean.wifiUsed) ?: bean.wifiUsed
                } else {
                    fun ޣޗޓސޕޖކޚ(ޚޜޓޤޤވޣޒ: Int, ޣޢހޞސއހޘ: Int): Int {
                        return ޚޜޓޤޤވޣޒ + ޣޢހޞސއހޘ
                    }
                    println(ޣޗޓސޕޖކޚ(8983, 3454))
                    map[bean.packageName] = bean
                }
            }
        }
        for (value in map.values) {
            AllList.add(value)
        }
        AllList.sortByDescending { it.mobileUsed + it.wifiUsed }
        AllList.removeAll(AllList.filter {
            it.packageName == this.packageName
        })

        if (AllList.isNotEmpty()) {
            class ޞވގޘޝޤޡބ {
                fun ގޢހޥޑޝޥޡ() {
                    println("ޡރޜފޟގޘޠ")
                }
            }
            ޞވގޘޝޤޡބ().ގޢހޥޑޝޥޡ()
            binding.ispchjq.isVisible = false
            binding.dilfacb.run {
                layoutManager = LinearLayoutManager(context)
                class ށޖޅޢކޑޕސ<T>(val ޢވޡޘޜފސތ: T, val ށޠޡލގރފޛ: Int) {
                    constructor(ޕޓޤށއބސދ: T) : this(ޕޓޤށއބސދ, 5879) {
                        println("ޟކލޖތމޞޤ")
                    }
                }
                println(ށޖޅޢކޑޕސ("ޛޡޥކޙޝފޅ"))
                adapter = mAdapter
            }
        } else {
            Log.d("ހޅޏނޟޡޛޗ", "ހޅޏނޟޡޛޗ")
            mAdapter.notifyDataSetChanged()
            binding.ispchjq.isVisible = true
        }

    }

    private fun clickTop(p: Int) {
        ރފމޚޖޤގޜ(p)
    }

    private fun ޠގޥޜދޓޠޣ() {
        ޅޓޞޥލޔޤޤ()
    }

    private fun ލޒވބޡށޜބ() {
        ޙޣޘމދލށޠ()
    }

    private fun ލޕރޜޒޞޤޞ(
    ) {
        ށޕޘޝޞޙނޤ()
    }

    private fun ތޝވޥޙޠޞހ(uid: Int, start: Long, end: Long): SparseLongArray {
        fun ޟގޘޑރޛޙޓ() {
            fun ބށޅޕބޡރފ(ޣފޛލޞޝޅޕ: Int) {
                println(ޣފޛލޞޝޅޕ)
            }
            ބށޅޕބޡރފ(4454)
            ބށޅޕބޡރފ(5850)
            ބށޅޕބޡރފ(2899)
        }
        ޟގޘޑރޛޙޓ()
        val result = SparseLongArray()
        class ތޓޣހޥޠޥޣ<T>(val ޙޗޠޒޞޜށވ: T, val ރޣޤޟބޠޛޕ: Int) {
            constructor(ޓޥޤބޛގބތ: T) : this(ޓޥޤބޛގބތ, 8711) {
                println("ޟޚޠޠވޚއޒ")
            }
        }
        println(ތޓޣހޥޠޥޣ("ޔޖޕޢޤޑޣއ"))
        val bucket = NetworkStats.Bucket()
        class ށފޕސޒޔސޞ(val ޕޖޡޡތޙފމ: String, val ޔޛޛހސހނކ: Int)
        println(ށފޕސޒޔސޞ("ޜޤއޢޔޅޒޟ", 66))
        try {
            val manager = this.getSystemService(Context.NETWORK_STATS_SERVICE) as NetworkStatsManager
            val stats = manager.querySummary(uid, null, start, end)
            while (stats.hasNextBucket()) {
                stats.getNextBucket(bucket)
                val currentUid = bucket.uid
                val txBytes = bucket.txBytes
                val rxBytes = bucket.rxBytes
                val totalBytes = txBytes + rxBytes
                val existingBytes = result[currentUid, 0]
                if (existingBytes == 0L) {
                    result.put(currentUid, totalBytes)
                } else {
                    class ސޡނނޡމޖނ<T>(val ޘޏލޞޅޑޏގ: T)
                    val އހޤޜމޚޗތ = ސޡނނޡމޖނ(1615)
                    val ރރޗޖޗޅޔޜ = ސޡނނޡމޖނ("ހޥފހޙޖޡޅ")
                    println(އހޤޜމޚޗތ.ޘޏލޞޅޑޏގ)
                    println(ރރޗޖޗޅޔޜ.ޘޏލޞޅޑޏގ)
                    result.put(currentUid, totalBytes + existingBytes)
                }
            }
            class ޙބޤޔޏކޢޕ<T>(val ޥއޡޥޘޖޚދ: T, val ޚޑޅވޠޘމޜ: Int) {
                constructor(ޥއޡޥޘޖޚދ: T) : this(ޥއޡޥޘޖޚދ, 5567) {
                    println("ޚޑޅވޠޘމޜ")
                }
            }
            println(ޙބޤޔޏކޢޕ("ޔފޚޜޓފޡޏ"))
            var b = 0L
            class ސޙޓނޠގޜޤ<T>(val ޙދޚޢޟޜލޕ: T)
            val ކޢޙރގޒށށ = ސޙޓނޠގޜޤ(1298)
            val ޜބޤޘޒޢޖޙ = ސޙޓނޠގޜޤ("ޤޣބޙކޖޤހ")
            println(ކޢޙރގޒށށ)
            println(ޜބޤޘޒޢޖޙ)
            result.forEach { key, value ->
                val a = packageManager.getPackagesForUid(key)
                if (a?.isNotEmpty() == true) {
                    class ޅވޕޅޕސޥސ<T>(val ޑޟމހޙޠގޥ: T, val ޓހޚޙޞޝދލ: Int) {
                        constructor(ޑޠޅޡޅޜށޘ: T) : this(ޑޠޅޡޅޜށޘ, 9690) {
                            println("ޝކޜޅހޅނޑ")
                        }
                    }
                    println(ޅވޕޅޕސޥސ("ޗށޠޟގޙދޥ"))
                    b += value
                }
            }
            stats.close()
        } catch (_: Exception) {
        }
        return result
    }

    private fun ޙޣޘމދލށޠ() {

        setData()

    }

    private fun ހދޟޚކޘޠޝ() {
        fun String.ރޝމޅޕޕޢޞ(): Boolean {
            return this == this.reversed()
        }
        val ފޛޕޙޖޕވޛ = "ޠޏޚނޜޥޥޡ"
        val ނޤފދމޅޖޙ = ފޛޕޙޖޕވޛ.ރޝމޅޕޕޢޞ()
        println(ނޤފދމޅޖޙ)
        ޗހޒޟޞށޅޞ()
    }

    private fun playLottie() {
        val ށސޢވޏށޤޣ = 7877..7877 + 10
        println(ށސޢވޏށޤޣ.random())
        ޠގޥޜދޓޠޣ()
    }

    private fun initList() {
        ޗޤށޡލރކޖ()
    }

    private fun setData(
    ) {
        fun <T> ށޔޏޞމޖޛގ(ޖށސފޠމޜޡ: T) {
            println(ޖށސފޠމޜޡ)
        }
        ށޔޏޞމޖޛގ(5888)
        ށޔޏޞމޖޛގ("ޙޒޟޡސއޔކ")
        ޅލޜރޤޛޒޞ()
    }

    private fun ޞޙޜޔރޤޝތ() {
        val ޅފޥޝޖޥޢރ = 8541..8541 + 10
        println(ޅފޥޝޖޥޢރ.random())
        BarUtils.setStatusBarLightMode(this, true)
        BarUtils.setStatusBarColor(this, Color.TRANSPARENT)
        val ޕޅސދޔޠޕހ: (Int, Int) -> Int = { ބސޞހޞކޘޓ, ޔވޒޗޤޙޓޒ -> ބސޞހޞކޘޓ + ޔވޒޗޤޙޓޒ }
        println(ޕޅސދޔޠޕހ.invoke(6838, 6492))
        binding.root.updatePadding(top = BarUtils.getStatusBarHeight())
        binding.jhuedku.isSelected = true
        playLottie()
    }

    private fun ޅޓޞޥލޔޤޤ() {
        ޑޚޕއޣޤރއ()
    }

    private fun ޛޚޚފޒޖނލ() {
    }

    private fun ޗޤށޡލރކޖ() {
        ލޒވބޡށޜބ()
    }

    private fun ޘޓފޏޛޤޥޤ(p: Int) {
        listOf(binding.jhuedku, binding.eqvnyly, binding.zflzgct).forEachIndexed { index, view ->
            view.isSelected = p == index
        }

    }

    private fun ތޏކޜރފޜކ() {
        binding.pudgnqf.isVisible = true
        binding.fhcclnm.imageAssetsFolder = R.string.ޡބޤހއ_D.string()
        binding.fhcclnm.setAnimation(R.string.ޗޡޔދއ_D.string())
        binding.fhcclnm.playAnimation()
        binding.root.postDelayed({
            class ޛޝޗޔޔޘޣތ<T, K>(val ވޕޅށޕޚޘށ: T, val ކދޜވޕވޙޑ: K) {
                init {
                    println("ޢޝޤޝކޙތމ")
                }
            }
            val ޗޒޡއޒދޛޅ = ޛޝޗޔޔޘޣތ("ޞޟޑޗޅޣހޞ", 3380)
            println(ޗޒޡއޒދޛޅ)
            Fnpc.showInterstitialAd(this) {
                binding.pudgnqf.isVisible = false
                ifPlayAnimal = true
                hasAccessSettings()
            }
        }, Random.nextLong(2500, 4000))
    }

    private fun ލނޣޙވޢތޏ() {
        if (ifPlayAnimal) {
            hasAccessSettings()
        }
    }

    fun getNetworkStats(uid: Int, start: Long, end: Long): SparseLongArray {
        fun ޠޔމޓޑޟޟފ(ދޚހޝޓޗޒޔ: Int, ޕޔސޤބގޣގ: Int): Int {
            return ދޚހޝޓޗޒޔ + ޕޔސޤބގޣގ
        }
        println(ޠޔމޓޑޟޟފ(7967, 4713))
        return ތޝވޥޙޠޞހ(uid, start, end)
    }

    private fun ޑޚޕއޣޤރއ() {
        ތޏކޜރފޜކ()
    }

    private fun ފޑޑނޢޠބޥ() {
        class ގޟސބޘޗޝޒ {
            val ސޟދޒށނޥޑ by lazy {
                println("ހކފފޗޚޢޗ")
                "ޠޒޥޚޓޙތޢ!"
            }
        }
        val ޚޤޕދފޡޗޗ = ގޟސބޘޗޝޒ()
        println(ޚޤޕދފޡޗޗ.ސޟދޒށނޥޑ)
        ހދޟޚކޘޠޝ()
    }

    private fun hasAccessSettings() {
        ޘނގއޤޕޚބ()
    }

    override fun initListener() {
        ފޑޑނޢޠބޥ()
    }

    private fun ޗހޒޟޞށޅޞ() {
        ޔތލޖށޘޡޟ()
    }

    override fun onStart() {
        fun String.ސޜޖތޘނޕސ(): Boolean {
            return this == this.reversed()
        }
        val ފގޞޟޟޢރސ = "ބޒމޘޖމޔޅ"
        val ގޙޅޒޣޚޟޡ = ފގޞޟޟޢރސ.ސޜޖތޘނޕސ()
        println(ގޙޅޒޣޚޟޡ)
        ޛޚޚފޒޖނލ()
        fun <T> ރޞޑޒޒވފށ(ޞޒރޔޗގޗޢ: T) {
            println(ޞޒރޔޗގޗޢ)
        }
        ރޞޑޒޒވފށ(6746)
        ރޞޑޒޒވފށ("ގޜޢޏޙޣމބ")
        super.onStart()
        ލނޣޙވޢތޏ()
    }

    private fun ށޕޘޝޞޙނޤ(
    ) {
        ޖޓޜބވބޖހ()
    }

    private fun މޔޡޅޒއށހ() {
        fun String.ކޟޔނމއޒވ(): Boolean {
            return this == this.reversed()
        }
        val ޢޟރޤނޖޤތ = "ޟނށގޥބބޣ"
        val ތޥވއޖޢޕމ = ޢޟރޤނޖޤތ.ކޟޔނމއޒވ()
        println(ތޥވއޖޢޕމ)
        ޑކޝޅދހޗބ()
    }

    private fun ޗޕގކޕޝޢހ() {
        fun ސސޖޑޒޢޏޑ(ޏތޤކމވޗޑ: Int, ށށރޢޖރޛޘ: Int): Int {
            fun ގތޔޖލޅނޔ(ޠށރޢޥގޛއ: Int, ޙގޏބޒސފޘ: Int): Int {
                return ޠށރޢޥގޛއ + ޙގޏބޒސފޘ
            }
            return ގތޔޖލޅނޔ(ޏތޤކމވޗޑ, ށށރޢޖރޛޘ)
        }
        val މމހޠޡޢޟމ = ސސޖޑޒޢޏޑ(8100, 718)
        println(މމހޠޡޢޟމ)
        ޞޙޜޔރޤޝތ()
    }

    private fun ޅލޜރޤޛޒޞ(
    ) {
        ލޕރޜޒޞޤޞ()
    }

    private fun ޘނގއޤޕޚބ() {
        val appOpsManager = getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
        if (System.currentTimeMillis() < 6909) {
            println(System.currentTimeMillis())
        }
        if (
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
                class ޖޗހމޑސޓޣ(val ޥމދހޅސލޚ: String, val ޝބޣކޠއޑޥ: Int)
                println(ޖޗހމޑސޓޣ("ތރޑޒއބކޞ", 251))
                appOpsManager.unsafeCheckOpNoThrow(
                    AppOpsManager.OPSTR_GET_USAGE_STATS, android.os.Process.myUid(), this.packageName
                ) == AppOpsManager.MODE_ALLOWED
            } else {
                appOpsManager.checkOpNoThrow(
                    AppOpsManager.OPSTR_GET_USAGE_STATS, android.os.Process.myUid(), this.packageName
                ) == AppOpsManager.MODE_ALLOWED
            }
        ) {
            binding.kapxvkt.isVisible = false
            initList()
        } else {
            binding.kapxvkt.isVisible = true
        }
    }

    private fun ޔތލޖށޘޡޟ() {
        ދޥޒޖޥދޕދ()
    }

    override fun initView() {
        މޔޡޅޒއށހ()
    }

    private fun ޕޓޢޚޔޤޡޔ(p: Int) {
        class ޕފސޗޏޠށޡ<T>(val ޅއޖޤބޡޤޕ: T)
        val ދދޒޒށކށޓ = ޕފސޗޏޠށޡ(4876)
        val ރކޥޠކޒޚޖ = ޕފސޗޏޠށޡ("އބޜސޗސޣޘ")
        println(ދދޒޒށކށޓ.ޅއޖޤބޡޤޕ)
        println(ރކޥޠކޒޚޖ.ޅއޖޤބޡޤޕ)
        ރޡޥތދޠކޏ(p)
    }

    private fun އރނށޙތލބ() {
        ޗޕގކޕޝޢހ()
    }

    private fun ޑކޝޅދހޗބ() {
        އރނށޙތލބ()
    }

    private fun ދޥޒޖޥދޕދ() {

        binding.guisuqc.setTrackedOnClickListener {
            fun ރއފޟސބޘޑ(ނޘގވޟތޓހ: Int, ޞޠޞތޕޛޢޅ: Int): Int {
                fun ޗނއޑޘޥވބ(ޡޝސޢޛހނޘ: Int, ޅގގޖސޥޏޏ: Int): Int {
                    return ޡޝސޢޛހނޘ + ޅގގޖސޥޏޏ
                }
                return ޗނއޑޘޥވބ(ނޘގވޟތޓހ, ޞޠޞތޕޛޢޅ)
            }
            val ރބޅކޝޅޏޢ = ރއފޟސބޘޑ(3467, 6308)
            println(ރބޅކޝޅޏޢ)
            onBackPressedDispatcher.onBackPressed()
        }
        onBackPressedDispatcher.addCallback(object : OnBackPressedCallback(true) {
            override fun handleOnBackPressed() {
                ޘޒނޏހށވހ()
            }

            private fun ޘޒނޏހށވހ() {
                ރވޅގށޚޠޜ()
            }

            private fun ރވޅގށޚޠޜ() {
                ޖޗޥޘއޖތޖ()
            }

            private fun ޖޗޥޘއޖތޖ() {
                ޅލޠހޥޏޤއ()
            }

            private fun ޅލޠހޥޏޤއ() {
                class ދޢޏދބޞޓބ {
                    inner class އމމކޑޤޤޤ {
                        fun ޖޣޚއޞޔޒބ() {
                            println("ޓޥނޘޔޛޟނ")
                        }
                    }
                }
                val ޚނބޚގކކޤ = ދޢޏދބޞޓބ().އމމކޑޤޤޤ()
                ޚނބޚގކކޤ.ޖޣޚއޞޔޒބ()
                Fnpc.showInterstitialAd(this@Rohw) {
                    class ސޝނޖޑޘޖޛ {
                        inner class އޥފތޡފޟޙ {
                            fun ޟދޏޜކމށޓ() {
                                println("ބޜބޒރރރޣ")
                            }
                        }
                    }
                    val ޙޣޣޟޗޠޕޙ = ސޝނޖޑޘޖޛ().އޥފތޡފޟޙ()
                    ޙޣޣޟޗޠޕޙ.ޟދޏޜކމށޓ()
                    finishToMain()
                }
            }

        })
        val ޤށޝޜޣޥލކ = 9250
        val ހޟޑޅވޏޞޥ = 7242
        val މޘޥޞޏޑޖޔ = ޤށޝޜޣޥލކ * ހޟޑޅވޏޞޥ * ހޟޑޅވޏޞޥ
        println(މޘޥޞޏޑޖޔ)
        binding.haquguk.setTrackedOnClickListener {
            checkAccesSettings(true)
        }
        binding.jhuedku.setTrackedOnClickListener {
            clickTop(0)
            startTime = Hwco.getTimesMonthmorning()
            setData()
        }
        binding.eqvnyly.setTrackedOnClickListener {
            clickTop(1)
            startTime = Hwco.getNeedTime(30)
            setData()
        }
        abstract class ޘށގމލޕޒޔ {
            abstract fun ޣޜޛދނޥވޘ()
        }
        class ޘޔޙޞޜލޗޗ : ޘށގމލޕޒޔ() {
            override fun ޣޜޛދނޥވޘ() {
                println("ޛޣސޡޒސޑޜ")
            }
        }
        val ޓނޏޏގޣޔފ = ޘޔޙޞޜލޗޗ()
        ޓނޏޏގޣޔފ.ޣޜޛދނޥވޘ()
        binding.zflzgct.setTrackedOnClickListener {
            Log.d("ކޘޚތގޟޡޕ", "ކޘޚތގޟޡޕ")
            clickTop(2)
            val ޤފބޤޥޜޖހ: (Int, Int) -> Int = { ޘޟގޓޣޔތޖ, ފފހޛޓރޤގ -> ޘޟގޓޣޔތޖ + ފފހޛޓރޤގ }
            println(ޤފބޤޥޜޖހ.invoke(8598, 4114))
            startTime = Hwco.getNeedTime(1)
            setData()
        }
        abstract class ޒޥޡޢމޥޔލ {
            abstract fun ޘޜޙޜޤއވޒ()
        }
        class ވވނޑޢޛގޛ : ޒޥޡޢމޥޔލ() {
            override fun ޘޜޙޜޤއވޒ() {
                println("މފޒސރޑޑޒ")
            }
        }
        val ލޔޓރތލމލ = ވވނޑޢޛގޛ()
        ލޔޓރތލމލ.ޘޜޙޜޤއވޒ()
        binding.vgvuzik.setTrackedOnClickListener {
            class ޙޚހޢޏޣޗނ<T>(val ޕޙސފދޠޕޞ: T)
            val ޚޅތޟޢޠޅޢ = ޙޚހޢޏޣޗނ(2248)
            val ޘބޥޏދޑޙޓ = ޙޚހޢޏޣޗނ("ޏކވޝޟޗޏޅ")
            println(ޚޅތޟޢޠޅޢ)
            println(ޘބޥޏދޑޙޓ)
            Gdmk.showBothTypes(this) {
                when (it) {
                    0 -> {
                        binding.vgvuzik.text = R.string.ޜޥޜޤޥ_D.string()
                        val ޖލޚޖޞލޣޒ = 1898
                        val ރފޠޢޕށފބ = 1226
                        val އގގޕޑޗޣޛ = ޖލޚޖޞލޣޒ * ރފޠޢޕށފބ * ރފޠޢޕށފބ
                        println(އގގޕޑޗޣޛ)
                        types = 0
                    }

                    1 -> {
                        binding.vgvuzik.text = R.string.ޔނޅޝސ_D.string()
                        class ޕމޡސޑޣޝޕ {
                            fun ޏޚލޠޟގޤޣ() {
                                println("ޕޢޛޒސލމރ")
                            }
                        }
                        ޕމޡސޑޣޝޕ().ޏޚލޠޟގޤޣ()
                        types = 1

                    }

                    2 -> {
                        binding.vgvuzik.text = R.string.ޥވޛޒޜ_D.string()
                        types = 2
                    }
                }
                class ގގޒޘތޑޝޤ {
                    fun ޅވޕޤޝޛޜތ() {
                        println("ފޑނފޘޥޣޝ")
                    }
                }
                ގގޒޘތޑޝޤ().ޅވޕޤޝޛޜތ()
                setData()
            }
        }
    }

    private fun ރފމޚޖޤގޜ(p: Int) {
        val ފލޜށޠބޢޙ: (Int, Int) -> Int = { ޣޓބޔޔދލޞ, އޏޗޅގޥޗޣ -> ޣޓބޔޔދލޞ + އޏޗޅގޥޗޣ }
        println(ފލޜށޠބޢޙ.invoke(704, 3107))
        ޕޓޢޚޔޤޡޔ(p)
    }

    private fun ރޡޥތދޠކޏ(p: Int) {
        class އޥޓފރދނޚ {
            val ޗޙށލޒދކދ by lazy {
                println("ޣޤޅޠޚޙޜލ")
                "ޡރޜސށދތއ!"
            }
        }
        val ރދޝނޗރޡށ = އޥޓފރދނޚ()
        println(ރދޝނޗރޡށ.ޗޙށލޒދކދ)
        ޘޓފޏޛޤޥޤ(p)
    }
}