APKiD icon indicating copy to clipboard operation
APKiD copied to clipboard

[DETECTION] Add rule for BlackObfuscator

Open enovella opened this issue 2 years ago • 1 comments

Samples

https://twitter.com/0xabc0/status/1541758420424048640

Info

https://twitter.com/0xabc0/status/1541858325188468736?t=JhRtm9qnRi_tKqRGd5JbCQ&s=03

Protector

https://github.com/CodingGay/BlackObfuscator

package com.plus.currencyconverter;

import android.content.Context;
import android.content.res.Configuration;
import android.text.TextUtils;
import android.util.Log;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.j;
import androidx.lifecycle.r;
import androidx.lifecycle.s;
import com.akexorcist.localizationactivity.ui.LocalizationApplication;
import com.download.library.DownloadTask;
import com.google.android.gms.ads.initialization.b;
import com.google.android.gms.ads.l;
import com.google.gson.d;
import com.plus.currencyconverter.b.b.h;
import com.plus.currencyconverter.config.bean.Configs;
import e.a.a.a.e;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Locale;
import org.mozilla.javascript.Token;

/* loaded from: classes.dex */
public class CurrencyConverterApplication extends LocalizationApplication {
    private static Context o;
    private static Locale p;
    public static boolean q;

    /* JADX INFO: Access modifiers changed from: package-private */
    /* loaded from: classes.dex */
    public class a implements b {
        a(CurrencyConverterApplication currencyConverterApplication) {
        }

        @Override // com.google.android.gms.ads.initialization.b
        public void a(com.google.android.gms.ads.initialization.a aVar) {
            String str = "ۙۘۥۘۦۥۦۦۥۤ";
            while (true) {
                switch ((((str.hashCode() ^ 684) ^ 21) ^ 300) ^ 646544754) {
                    case -2034338196:
                        return;
                    case -254200937:
                        str = "ۦۥۘۘۚۥۦۦ";
                        break;
                    case 1799948907:
                        str = "";
                        break;
                }
            }
        }
    }

    public static Context c() {
        while (true) {
            switch (((("ۗۜۥۦۨۥۛۦۚ".hashCode() ^ 852) ^ 67) ^ 405) ^ 952543665) {
                case -1942815505:
                    return e.a.c(o);
            }
        }
    }

    private void d() {
        String str = "ۦۥۢۥۖۤۗۥ";
        while (true) {
            switch ((((str.hashCode() ^ 247) ^ 588) ^ 194) ^ (-1931583582)) {
                case -2127899235:
                    k();
                    str = "ۦۥ";
                    break;
                case -1503555289:
                    e();
                    str = "ۥۥۦۦۥۦ";
                    break;
                case -1307179346:
                    return;
                case -312149553:
                    str = "ۘۨۦۥۦۦۢ";
                    break;
                case 747253380:
                    b();
                    str = "ۨۡۦۘۤۛۦۚ۠ۚۦۥ۬ۥۥۥۚۤ";
                    break;
                case 1820016888:
                    j();
                    str = "ۥۥۙۤۢۦۦۢۧ";
                    break;
                case 1964861057:
                    g();
                    str = "ۦۖۦۘ۠ۨۦۥۦۘۥۡۛ";
                    break;
            }
        }
    }

    private void e() {
        try {
            Log.i("myc", "initAdmob, DEBUG = false");
            l.a(this, new a(this));
            com.plus.currencyconverter.a.a.a p2 = com.plus.currencyconverter.a.a.a.p();
            p2.o(this);
            p2.n("ca-app-pub-8334353967662764/1835113892");
            p2.n("ca-app-pub-8334353967662764/8906938643");
            p2.n("ca-app-pub-8334353967662764/9773313661");
        } catch (Exception e2) {
            com.plus.currencyconverter.b.b.b.a(e2);
        }
    }

    private void f() {
        try {
            StringBuilder sb = new StringBuilder();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(getAssets().open("configs.json")));
            while (true) {
                String readLine = bufferedReader.readLine();
                String str = "ۦۥۤ";
                while (true) {
                    switch (str.hashCode() ^ 1912146468) {
                        case -1329821599:
                            String str2 = "ۛۦۥۡۚۥۦۥ";
                            while (true) {
                                switch (str2.hashCode() ^ (-891883517)) {
                                    case -905228217:
                                        str = "ۦۦۦ";
                                        break;
                                    case -605780079:
                                        str2 = "ۥۥۦ";
                                    case 93986897:
                                        str2 = readLine != null ? "ۦۥۥۘۦۜۚۥۥۥۘۤۛۦ" : "ۥۥ";
                                    case 197297997:
                                        str = "ۦۥۥۗۦۥۥ۠ۡۢۦۘۛۦۘۥۦ";
                                        break;
                                }
                            }
                            break;
                        case -492779986:
                            break;
                        case 154917427:
                            String sb2 = sb.toString();
                            String str3 = "ۥۦۥۦۦ۟ۦۥ";
                            while (true) {
                                switch (str3.hashCode() ^ (-1455112189)) {
                                    case -1700086397:
                                        String str4 = "ۖۦۦۦۦۥۦۤ۟ۖۦۨۜ";
                                        while (true) {
                                            switch (str4.hashCode() ^ (-261955935)) {
                                                case -536194445:
                                                    str3 = "ۥۦۥۦ";
                                                    continue;
                                                case 568578167:
                                                    str3 = "ۜۥۦۥۦۥۘۦۥۘۙ";
                                                    continue;
                                                case 1064727282:
                                                    str4 = "ۥ۟ۚۡۦۦۦۦۦ";
                                                case 1170308294:
                                                    str4 = !TextUtils.isEmpty(sb2) ? "ۥۦۥۨۦۘۦ" : "ۦۥۦ";
                                            }
                                        }
                                        break;
                                    case -845252069:
                                        str3 = "ۥۥۡۘۥۖ۫۟ۥۦ۠ۢۡۦۦۦۘۗۜۦۘ۬ۚۦۘۦۨۦ";
                                        break;
                                    case 604758149:
                                        return;
                                    case 1329779887:
                                        Configs configs = (Configs) new d().i(sb2, Configs.class);
                                        h.t().K(configs.c());
                                        h.t().w(configs.a());
                                        h.t().I(new d().r(configs.b()));
                                        return;
                                }
                            }
                            break;
                        case 1091034394:
                            str = "ۡۥ۟ۥۦۤۦۦۦۦۥۦۡۘ";
                    }
                }
                sb.append(readLine);
            }
        } catch (Throwable th) {
            com.plus.currencyconverter.b.b.b.a(th);
        }
    }

    private void g() {
        String str = "۟ۥۥۦۦۙ";
        long j = 0;
        while (true) {
            switch ((((str.hashCode() ^ 800) ^ 815) ^ 857) ^ 1453277713) {
                case -2132628818:
                    f();
                    str = "ۦۥۥۦۦۦۦۘ";
                    continue;
                case -1358136186:
                    break;
                case -1357753417:
                    h.t().A(j);
                    str = "ۦۥۥۦۚۙۥۘ";
                    continue;
                case -1312132702:
                    l();
                    str = "ۥۥۗۨ۫ۥ";
                    continue;
                case -1127847475:
                    m();
                    str = "ۦۥۘۜۦۗۖۦۦۥ";
                    continue;
                case -1057767520:
                    h();
                    str = "ۦۦۨۧۢۦ";
                    continue;
                case -1021269237:
                    str = "ۖۦۘۘ۟ۥ۠ۜۦۗ۠۟ۦ";
                    continue;
                case -960287720:
                    String str2 = "ۥۥۦۦۦۜۥۢۘۦ۠ۜۥۘۦۢۨۘ";
                    while (true) {
                        switch (str2.hashCode() ^ 363551959) {
                            case -1381858646:
                                str = "۬ۦۦۥۥۦۥۘۥۦ";
                                continue;
                            case -883748282:
                                str2 = "ۥۥۥۜۢ";
                            case 1597200017:
                                break;
                            case 1941565813:
                                String str3 = "ۥۢۦۦ";
                                while (true) {
                                    switch (str3.hashCode() ^ (-1420810984)) {
                                        case -1607463183:
                                            str2 = "ۛۦۗۜۤۦۥۦۘۛۤۥ۫ۡۗۦۥۜۥۘ";
                                            break;
                                        case -709828707:
                                            str3 = j > h.t().e() ? "ۗ۫ۥۥ" : "ۦۥۥۥۢۧۥۘ";
                                        case -274875367:
                                            str3 = "ۦۥ";
                                        case 1669147228:
                                            str2 = "ۦ۟۬۟ۦۥۥۘۦ۬ۖۘ";
                                            break;
                                    }
                                }
                                break;
                        }
                    }
                    break;
                case -792897881:
                    n();
                    str = "ۥۦۥۦۘۧ۠ۥۘ";
                    continue;
                case -637157170:
                    l();
                    str = "ۦۦۥ";
                    continue;
                case -559966192:
                    return;
                case 294158082:
                    String str4 = "ۥۛۧۖۥۦۢۗۧۥ";
                    while (true) {
                        switch (str4.hashCode() ^ (-1166726993)) {
                            case -2032498421:
                                str = "ۦۘ۫ۤۥۥ";
                                continue;
                            case 1540260816:
                                String str5 = "ۥ۠ۦۦۥ";
                                while (true) {
                                    switch (str5.hashCode() ^ 590965793) {
                                        case -796832582:
                                            str4 = "ۦۥۥۥۘۦ";
                                            break;
                                        case 304194404:
                                            str5 = j > 0 ? "ۦۦۥۦۦ" : "ۦۥۦۥۦ۠ۥۧۥ";
                                        case 1639749687:
                                            str4 = "ۥۢۚۥۧۘۥۥۦۘۚۥۦۦۦ";
                                            break;
                                        case 1834498483:
                                            str5 = "ۦۥۨۦۦۥۥۧ";
                                    }
                                }
                                break;
                            case 1889512049:
                                str = "ۦۦۦۗۥ";
                                continue;
                                continue;
                            case 1971825743:
                                str4 = "ۥۜۦۦۘۛۛۦۥۦ";
                        }
                    }
                    break;
                case 316211799:
                    String str6 = "ۤۦۥ۟ۥۥۥۘۥۗ۫ۦ";
                    while (true) {
                        switch (str6.hashCode() ^ 2059210953) {
                            case -1183559419:
                                String str7 = "ۦۦۦۘ";
                                while (true) {
                                    switch (str7.hashCode() ^ 1733461089) {
                                        case -1684175226:
                                            str7 = "ۗۤۦۦۥۤۦۦۘۦۧۥۦ";
                                        case -1025288492:
                                            str6 = "ۥۥۦۦۦۥۦۦۘ";
                                            break;
                                        case -1012145350:
                                            str7 = h.t().o() <= 0 ? "ۖۦ" : "ۚۥۡ۬ۥۦۧۦ";
                                        case 1968458317:
                                            str6 = "ۥۦۦۦ";
                                            break;
                                    }
                                }
                                break;
                            case -141766098:
                                str = "ۥۦۥۦۘۧ۠ۥۘ";
                                continue;
                            case 1338601704:
                                str = "ۦۥ";
                                continue;
                                continue;
                            case 1656020325:
                                str6 = "ۦۥۥۦۦۘۥ";
                        }
                    }
                    break;
                case 793929475:
                    m();
                    str = "ۦۦۦ";
                    continue;
                case 1502096025:
                    h();
                    str = "ۛۥۦۦۛۦۗ۫ۜۦۥ";
                    continue;
                case 1521482099:
                    j = com.plus.currencyconverter.b.b.a.a();
                    str = "ۜۦۦۥۥۙۡ";
                    continue;
                case 1556502822:
                    i();
                    str = "ۧ۠ۡۦۥ";
                    continue;
            }
            str = "ۦۦۦ";
        }
    }

    private void h() {
        try {
            StringBuilder sb = new StringBuilder();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(getAssets().open("real_currencies.json")));
            while (true) {
                String readLine = bufferedReader.readLine();
                String str = "ۜ۟ۦۘۡۗۦۦۥ۠ۥ";
                while (true) {
                    switch (str.hashCode() ^ (-1798204882)) {
                        case -2072015343:
                            str = "ۥۥۦۘۡۦۥۥۘۜۘۦ";
                        case -758382319:
                            String sb2 = sb.toString();
                            String str2 = "ۦۥۥۦۥ";
                            while (true) {
                                switch (str2.hashCode() ^ 782484381) {
                                    case -1592821614:
                                        return;
                                    case -1448518425:
                                        String str3 = "۬ۥۦۥۥ";
                                        while (true) {
                                            switch (str3.hashCode() ^ 508414609) {
                                                case -1740372404:
                                                    str3 = "ۥۥۥۦ";
                                                case -1007896126:
                                                    str2 = "ۦۥۦ۬ۦ";
                                                    continue;
                                                case -421366434:
                                                    str3 = !TextUtils.isEmpty(sb2) ? "" : "ۦۦۦۥۦۢۖۘۥۥۥ";
                                                case 35417894:
                                                    str2 = "۫ۗۘۦۦۥۦۦۗۦۧۤۥ";
                                                    continue;
                                            }
                                        }
                                        break;
                                    case -1358395544:
                                        String str4 = "ۥۦۥۥ";
                                        while (true) {
                                            switch (str4.hashCode() ^ 1862299161) {
                                                case -1937371215:
                                                    h.t().G(sb2);
                                                    return;
                                                case -1357181007:
                                                    String str5 = "ۦۥ۟ۨۥۥۦۘۧۦۦۦۘۦۦ۠ۥۙۗۦ";
                                                    while (true) {
                                                        switch (str5.hashCode() ^ (-867854879)) {
                                                            case -855142083:
                                                                str5 = "ۥۥۘۘۥۗۥۦۗۙۦۥ";
                                                            case -788294122:
                                                                str5 = !sb2.equals(h.t().k()) ? "ۦ" : "ۥۥۨۦۘۦۦۙ";
                                                            case -675787283:
                                                                str4 = "ۥۦۧۥ";
                                                                continue;
                                                            case -430171909:
                                                                str4 = "ۥۥۧۘۦۥۜۜۦۥۖۖۦۦ";
                                                                continue;
                                                        }
                                                    }
                                                    break;
                                                case -905402048:
                                                    return;
                                                case 152159230:
                                                    str4 = "ۦۖۦۥ۬ۥۦۥۥۥۚ۟ۡ";
                                                    break;
                                            }
                                        }
                                        break;
                                    case 1734901330:
                                        str2 = "ۦۥۦۥۦۘۗۜۦ";
                                        break;
                                }
                            }
                            break;
                        case -442156497:
                            break;
                        case 1183148495:
                            String str6 = "ۤ۫ۥۦۥۘۘۥۨۦۘۡۛۥۦۘۥ";
                            while (true) {
                                switch (str6.hashCode() ^ (-429644520)) {
                                    case -1443599846:
                                        str6 = "ۦۦۛۦۥۥۨۛۛۥ";
                                    case -775034402:
                                        str = "ۢۜۦۘۚ۠ۦۥۚۥۥۦۢۥ";
                                        break;
                                    case -129875023:
                                        str6 = readLine != null ? "۟ۦ۠ۦۦ" : "۫۟ۦۗ۬ۦۦۦ۫ۨۢۦۦ";
                                    case 1807760691:
                                        str = "ۦۦۖ";
                                        break;
                                }
                            }
                            break;
                    }
                }
                sb.append(readLine);
            }
        } catch (Exception e2) {
            com.plus.currencyconverter.b.b.b.a(e2);
        }
    }

    private void i() {
        try {
            StringBuilder sb = new StringBuilder();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(getAssets().open("real_rates.json")));
            while (true) {
                String readLine = bufferedReader.readLine();
                String str = "ۗ۟ۥۢۖۦۘ۫ۜۥۦۢۥۘۘۦۘۗۦۦۦ";
                while (true) {
                    switch (str.hashCode() ^ (-1972543483)) {
                        case -1495063120:
                            String sb2 = sb.toString();
                            String str2 = "ۖۦۥ۫۟ۜۦۥۦۘۛۦۧۘ۟ۥ";
                            while (true) {
                                switch (str2.hashCode() ^ 1298953673) {
                                    case -817536688:
                                        h.t().H(sb2);
                                        return;
                                    case 142067915:
                                        str2 = "ۥۥۢۦۚۦۥ";
                                        break;
                                    case 217097102:
                                        return;
                                    case 1125560685:
                                        String str3 = "ۥۥۦۦ";
                                        while (true) {
                                            switch (str3.hashCode() ^ 1854236171) {
                                                case -1736686368:
                                                    str3 = !TextUtils.isEmpty(sb2) ? "ۚۢۗۥۥۦۨۙ" : "ۦۦۥ";
                                                case 370391560:
                                                    str3 = "۠ۦۦۥۤۧۦ";
                                                case 881953920:
                                                    str2 = "ۚۨۦۦۡۡۥۘۡۗۦۥۦۘۨۗۥ";
                                                    continue;
                                                case 1602514487:
                                                    str2 = "ۧۥۦۥ";
                                                    continue;
                                            }
                                        }
                                        break;
                                }
                            }
                            break;
                        case -1447254758:
                            str = "ۦۦۦۦۦ";
                        case -460397140:
                            break;
                        case 817096511:
                            String str4 = "ۦۥۥۘۘۥ";
                            while (true) {
                                switch (str4.hashCode() ^ 1670336994) {
                                    case -1839300453:
                                        str4 = "ۥۤۡۦۘۤۧۦۥۥۡ۬ۥ";
                                    case -1574340705:
                                        str4 = readLine != null ? "ۥۛۤۥۦۦۧۥۘۛ۟ۦ" : "ۥۦۦۦ";
                                    case -285997044:
                                        str = "ۨۦۦۦۦۦۢۜۘ";
                                        break;
                                    case 716605325:
                                        str = "ۦۥۘۥۥ";
                                        break;
                                }
                            }
                            break;
                    }
                }
                sb.append(readLine);
            }
        } catch (Exception e2) {
            com.plus.currencyconverter.b.b.b.a(e2);
        }
    }

    private void j() {
        String str = "ۛ۠ۦۘۥۦۦۦۦ";
        while (true) {
            switch ((((str.hashCode() ^ 904) ^ Token.SETCONST) ^ 117) ^ (-314798437)) {
                case -1826352940:
                    str = "۫۬ۦۦۦۦ";
                    break;
                case 921333008:
                    return;
                case 1285483965:
                    com.plus.currencyconverter.f.a.e();
                    str = "ۙۤ۬ۥۥۦۥۥ۠ۘۨ";
                    break;
            }
        }
    }

    private void k() {
        String str = "ۦۥۥۘۖۗۥۜۘۥۥ۟ۚۦ";
        while (true) {
            switch ((((str.hashCode() ^ 875) ^ 32) ^ 692) ^ 818325050) {
                case -264276591:
                    return;
                case -69099667:
                    androidx.appcompat.app.b.A(true);
                    str = "۬ۥۥۥۥ";
                    break;
                case 1241510331:
                    str = "ۦۥۥ";
                    break;
            }
        }
    }

    private void l() {
        try {
            StringBuilder sb = new StringBuilder();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(getAssets().open("virtual_currencies.json")));
            while (true) {
                String readLine = bufferedReader.readLine();
                String str = "ۥۦۥۘۙۦۦ";
                while (true) {
                    switch (str.hashCode() ^ 486709897) {
                        case -1906316555:
                            str = "۟۟ۦۥۘۡۛۥۤۥۦۙۛۥ۠۫ۜۦۥۘۥۦۘ";
                        case -1742897308:
                            break;
                        case 699828132:
                            String str2 = "ۨۥۦۦۥۦۦۘ";
                            while (true) {
                                switch (str2.hashCode() ^ 788120924) {
                                    case -1809738083:
                                        str2 = readLine != null ? "ۥۦۥۥ" : "ۦۦۥۥۜ۫ۙۥۖۘ";
                                    case -1754268581:
                                        str = "ۥOۦۘۖۦۧۘ";
                                        break;
                                    case -474495054:
                                        str = "ۜۜۥۦۦۦۥۦۢۦ";
                                        break;
                                    case 604700872:
                                        str2 = "ۦۦۥۦۥۘۘ";
                                }
                            }
                            break;
                        case 1772991194:
                            String sb2 = sb.toString();
                            String str3 = "ۦۦۥۦۡ";
                            while (true) {
                                switch (str3.hashCode() ^ 347308214) {
                                    case -1686372515:
                                        String str4 = "ۦۘۙۢۦۥۘ۫ۘۦۦۦ";
                                        while (true) {
                                            switch (str4.hashCode() ^ (-307470919)) {
                                                case -1607352232:
                                                    String str5 = "ۦۚۤۦۥۥۦۚ۠ۘۥۘ۠ۤۦۦۡ";
                                                    while (true) {
                                                        switch (str5.hashCode() ^ 1824349392) {
                                                            case -1400035469:
                                                                str5 = !sb2.equals(h.t().p()) ? "ۦۦۖۘۦۦۥۡۦۥۘ" : "ۦۢۦۦۥۥۦۥ";
                                                            case 669755378:
                                                                str4 = "ۖۙۛۥۥۦۥۦ";
                                                                continue;
                                                            case 983045561:
                                                                str4 = "ۥۦ";
                                                                continue;
                                                            case 1218161546:
                                                                str5 = "ۥۥۥ۫";
                                                        }
                                                    }
                                                    break;
                                                case -389028172:
                                                    return;
                                                case 6300563:
                                                    str4 = "ۘ۠ۧۥۦۦۜۖۦ";
                                                    break;
                                                case 2093489469:
                                                    h.t().L(sb2);
                                                    return;
                                            }
                                        }
                                        break;
                                    case -1606748152:
                                        str3 = "ۦ";
                                        break;
                                    case -1487410905:
                                        String str6 = "ۦۥۘۦۦۜۧ۠ۦۥۥۖۛۘۦ";
                                        while (true) {
                                            switch (str6.hashCode() ^ 645305982) {
                                                case -1739284751:
                                                    str6 = "ۦ";
                                                case -1008361986:
                                                    str3 = "ۦۦۦۥ۟ۦۡۤۥۥ";
                                                    continue;
                                                case -528828782:
                                                    str6 = !TextUtils.isEmpty(sb2) ? "ۦۦۥۥۥۥۥۦۧۘۧۥۥ" : "ۦۦۦۥۥۡۘۢۥ";
                                                case -11156426:
                                                    str3 = "ۥۥۛۦۦۥۖۡۙۦۘۥ";
                                                    continue;
                                            }
                                        }
                                        break;
                                    case -1386039994:
                                        return;
                                }
                            }
                            break;
                    }
                }
                sb.append(readLine);
            }
        } catch (Exception e2) {
            com.plus.currencyconverter.b.b.b.a(e2);
        }
    }

    private void m() {
        try {
            StringBuilder sb = new StringBuilder();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(getAssets().open("virtual_ids.json")));
            while (true) {
                String readLine = bufferedReader.readLine();
                String str = "ۜۗ۫ۦۥ۬ۥۥۘۥۥۤ";
                while (true) {
                    switch (str.hashCode() ^ (-118556561)) {
                        case -2058830264:
                            break;
                        case -1789646277:
                            String str2 = "ۜۚۡۦۦۥۘ۬ۥۥۦۛ۠ۥۦۘ";
                            while (true) {
                                switch (str2.hashCode() ^ 23455539) {
                                    case -1857823589:
                                        str = "۠ۥۦۦۥۜۥۥ";
                                        break;
                                    case 147347357:
                                        str = "ۢۦۦۥۙۙۥۨۦۘۥۜۡۥۥۦۥ";
                                        break;
                                    case 642713506:
                                        str2 = "ۙۤۥۦۘۦۗۥۦۦۧۚ۫ۥۚۥۘۚۦ۬ۥ";
                                    case 1308543635:
                                        str2 = readLine != null ? "ۦۦۦ" : "ۥۡ۟ۦ۠ۦ۬ۥۘۙۢۦۘ";
                                }
                            }
                            break;
                        case -616820:
                            String sb2 = sb.toString();
                            String str3 = "ۛ۟ۡۦ۫۟ۦۦۦۘ۟ۥ";
                            while (true) {
                                switch (str3.hashCode() ^ (-1740175347)) {
                                    case -1869461020:
                                        return;
                                    case -749593718:
                                        String str4 = "ۥۦۥۦۘۤۥۡۥۜۖ";
                                        while (true) {
                                            switch (str4.hashCode() ^ 804972500) {
                                                case -1153825521:
                                                    h.t().M(sb2);
                                                    return;
                                                case 132588799:
                                                    return;
                                                case 334074684:
                                                    String str5 = "ۘ۫ۦۦ";
                                                    while (true) {
                                                        switch (str5.hashCode() ^ (-2021497479)) {
                                                            case -537344825:
                                                                str4 = "ۦۥۘۗۥ";
                                                                continue;
                                                            case -474298349:
                                                                str4 = "ۦۦۦۥۥۘ۬ۥ";
                                                                continue;
                                                            case -50113239:
                                                                str5 = "ۦۦۥۦۦ";
                                                            case 1242923722:
                                                                str5 = !sb2.equals(h.t().q()) ? "ۦۥۦۛۡۦۦ" : "ۥۦ";
                                                        }
                                                    }
                                                    break;
                                                case 1240670437:
                                                    str4 = "ۦ۫ۚ۠ۥۘۥۗ۫ۥ";
                                                    break;
                                            }
                                        }
                                        break;
                                    case 116001812:
                                        String str6 = "۬ۡۥۦۘۥۦۦۥۘۛ۬ۥ";
                                        while (true) {
                                            switch (str6.hashCode() ^ (-668133645)) {
                                                case -976459320:
                                                    str6 = "ۦۥۥۦۘۛۡۥ";
                                                case 903041585:
                                                    str3 = "ۡۥۥۘۥۦ۠ۥۦ";
                                                    continue;
                                                case 1172016911:
                                                    str6 = !TextUtils.isEmpty(sb2) ? "ۦۥۥۙ" : "ۥۥۥۥۦۧۨۥ";
                                                case 1741691825:
                                                    str3 = "ۦۥۥۙ";
                                                    continue;
                                            }
                                        }
                                        break;
                                    case 1728188821:
                                        str3 = "ۚۙۥۥۘ۫ۦۦۦ۠ۥۘ۫ۙۥۦ";
                                        break;
                                }
                            }
                            break;
                        case 508767653:
                            str = "ۦۨۥۨۥۦۦۦۦ";
                    }
                }
                sb.append(readLine);
            }
        } catch (Exception e2) {
            com.plus.currencyconverter.b.b.b.a(e2);
        }
    }

    private void n() {
        try {
            StringBuilder sb = new StringBuilder();
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(getAssets().open("virtual_rates.json")));
            while (true) {
                String readLine = bufferedReader.readLine();
                String str = "۬ۖۢۥۥۡۖۦۦۥ";
                while (true) {
                    switch (str.hashCode() ^ (-367978105)) {
                        case -554600301:
                            String sb2 = sb.toString();
                            String str2 = "ۥۦ۫ۚ";
                            while (true) {
                                switch (str2.hashCode() ^ 1823052129) {
                                    case -1074840000:
                                        return;
                                    case -999156847:
                                        h.t().N(sb2);
                                        return;
                                    case -254974143:
                                        String str3 = "ۙۢۙۦ۟ۗ۟ۥۦۦۦۘۦۦ";
                                        while (true) {
                                            switch (str3.hashCode() ^ (-1286983755)) {
                                                case -678011838:
                                                    str3 = "ۦۥۥۦۦۦۘۥۦۘۦ";
                                                case -587422989:
                                                    str3 = !TextUtils.isEmpty(sb2) ? "ۥ۫ۙۗۥۥۥۘ۬ۛ" : "ۥۥۥۗۤ۬ۦۦ";
                                                case -23512624:
                                                    str2 = "ۥۘ۠ۦۥ";
                                                    continue;
                                                case 1328104871:
                                                    str2 = "ۤ۫ۥۥۦۘۨۥۦۥۘۥۦۤ";
                                                    continue;
                                            }
                                        }
                                        break;
                                    case 38764403:
                                        str2 = "ۦ";
                                        break;
                                }
                            }
                            break;
                        case -265404543:
                            String str4 = "ۦۦ";
                            while (true) {
                                switch (str4.hashCode() ^ (-1493690932)) {
                                    case -1772881775:
                                        str = "ۥۥۡۚ۠ۦۙ۬ۥ";
                                        break;
                                    case -1086229725:
                                        str = "۟۟ۦۥۖ۠۟ۥۘۗۥ۠ۦۥۡۥۦۥۥۘۢۜۦۘۙۦۦۤۦ۟ۡ";
                                        break;
                                    case -242618485:
                                        str4 = readLine != null ? "ۥۦۙۦ" : "ۦۦۥۥۥۦۘۧۦۥ";
                                    case -178308325:
                                        str4 = "ۦۦۥۦ۬ۜۦ";
                                }
                            }
                            break;
                        case -70310037:
                            str = "ۥۦۥ";
                        case 1622956590:
                            break;
                    }
                }
                sb.append(readLine);
            }
        } catch (Exception e2) {
            com.plus.currencyconverter.b.b.b.a(e2);
        }
    }

    public static Locale o() {
        while (true) {
            switch (((("ۡۢۥۧۥۥ".hashCode() ^ 869) ^ 733) ^ 431) ^ (-329505277)) {
                case -305314503:
                    return p;
            }
        }
    }

    @Override // com.akexorcist.localizationactivity.ui.LocalizationApplication
    public Locale a(Context context) {
        String str = "ۤۥۦۡۜۡۥۚۨۨۦۗۥۥۧۥۦۛۨ۟ۥۦۦ";
        String str2 = null;
        String str3 = null;
        String str4 = null;
        while (true) {
            switch ((((str.hashCode() ^ 63) ^ 456) ^ 480) ^ 1465738299) {
                case -2020963111:
                    str = "ۥۛۖۡۦۥۥۦ";
                    break;
                case -1462219879:
                    str2 = String.valueOf(p);
                    str = "ۙ۟ۡۦۥۦ۬ۦۥۘۦۥۥۦ";
                    break;
                case -679451416:
                    str = "۫ۖۥۘۛ۬ۥ۬ۧۥۥۥۥۦۖۥۚۦۥ";
                    str3 = str4;
                    break;
                case -608553547:
                    str = "ۦۚۦۥۡۘ۫ۦ";
                    break;
                case -219311635:
                    str = "ۦۘۙۜۥ";
                    str3 = str2;
                    break;
                case -74860171:
                    String str5 = "ۥۦۥۥۥۦۚۥۧ";
                    while (true) {
                        switch (str5.hashCode() ^ 1900972540) {
                            case -28659552:
                                str5 = "ۦۦۥۥ۫ۦۥۥۦۡۘ";
                            case 529637094:
                                str = "۟۫ۖۥۦۥۢۚۦۥۘۦ۫ۖۘ";
                                continue;
                            case 943353442:
                                String str6 = "ۜ۟ۦۥۧۘۜۦۦۥۦۥۥ";
                                while (true) {
                                    switch (str6.hashCode() ^ 1259986897) {
                                        case -1777206123:
                                            str6 = TextUtils.isEmpty(str4) ? "ۦۦۦۥۥۘ" : "ۦۥۥۥ";
                                        case -1575928240:
                                            str5 = "ۗ۫ۥۥۘ۠ۦۧۘۥ";
                                            break;
                                        case -594519099:
                                            str6 = "ۜۛۦۦۤۚ۬ۥۚۨۦۥ۫ۖۦ۫ۥۘ";
                                        case 151777792:
                                            str5 = "ۖۜۦۧۢۦۦۥۥ";
                                            break;
                                    }
                                }
                                break;
                            case 1001284648:
                                str = "ۦۘۙۜۥ";
                                continue;
                        }
                    }
                    break;
                case 246340164:
                    return new Locale(str3);
                case 487898474:
                    str4 = h.t().d();
                    str = "۠۬ۥۥۥۥۥ";
                    break;
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: protected */
    @Override // com.akexorcist.localizationactivity.ui.LocalizationApplication, android.content.ContextWrapper
    public void attachBaseContext(Context context) {
        String str = "ۥۦۥۘۘۥۡۥۦۥۘۦۡۦ";
        while (true) {
            switch ((((str.hashCode() ^ 945) ^ DownloadTask.STATUS_PAUSING) ^ 487) ^ 2044500684) {
                case -1999146284:
                    p = Locale.getDefault();
                    str = "ۥۥۧۘۚۦۘۗۥۨۤۥۥۦۨۜۘ";
                    break;
                case -1693228062:
                    o = context;
                    str = "۠۫ۦۦۦۦۥۥ";
                    break;
                case -1546200131:
                    super.attachBaseContext(context);
                    str = "ۦۦۧۦۥۦۦۖۦۡ";
                    break;
                case -1169960656:
                    str = "ۦۧۦۛۦۘ۠ۥۥۦۢۥ";
                    break;
                case 47439425:
                    str = "ۦۤۦۦۡۡۛۦۘۛۥۖۥۦۦۦ";
                    break;
                case 840667328:
                    return;
            }
        }
    }

    public void b() {
        String str = "ۥۘۜۢۦۥۨۘۙۦۥۥۘۦۥ";
        while (true) {
            switch ((((str.hashCode() ^ 888) ^ 336) ^ 7) ^ 1363503460) {
                case -118643595:
                    str = "ۥ";
                    break;
                case 395642743:
                    s.h().K().a(new j(this) { // from class: com.plus.currencyconverter.CurrencyConverterApplication.2
                        @r(Lifecycle.Event.ON_STOP)
                        private void onAppBackground() {
                            String str2 = "ۥۦۦۥۦۥۚۥۡ";
                            while (true) {
                                switch ((((str2.hashCode() ^ 272) ^ 408) ^ 4) ^ 671279645) {
                                    case -1623569695:
                                        new com.plus.currencyconverter.b.a.a().a();
                                        str2 = "ۦۥۚۦۦ۬ۧ";
                                        break;
                                    case -609839010:
                                        str2 = "ۚۢۥۦۗۦۦۥۥۙۤ";
                                        break;
                                    case 1704977718:
                                        return;
                                }
                            }
                        }

                        @r(Lifecycle.Event.ON_START)
                        private void onAppForeground() {
                            String str2 = "ۥۧ۬۬ۦۖۤۥۦۡۘ";
                            while (true) {
                                switch ((((str2.hashCode() ^ 457) ^ 201) ^ 32) ^ (-494269071)) {
                                    case -1121435261:
                                        new com.plus.currencyconverter.b.a.b().a();
                                        str2 = "ۦۘۙۚۦۦۘۧۥۦۘۗۥۢۢۜۦۦۦۦ";
                                        break;
                                    case -207409921:
                                        str2 = "ۦ۟ۥۥ۠۬ۥۥۘ";
                                        break;
                                    case 1354706327:
                                        return;
                                }
                            }
                        }
                    });
                    str = "ۖۦۦۦۦۘۤۗۥۦۜۥۥ";
                    break;
                case 1321509567:
                    return;
            }
        }
    }

    @Override // com.akexorcist.localizationactivity.ui.LocalizationApplication, android.app.Application, android.content.ComponentCallbacks
    public void onConfigurationChanged(Configuration configuration) {
        String str = "ۥۦۥۦ";
        while (true) {
            switch ((((str.hashCode() ^ 22) ^ 875) ^ 191) ^ 1060996132) {
                case -1978964162:
                    return;
                case -1599868534:
                    q = true;
                    str = "ۦۥۦۖۥۚۡ۬";
                    break;
                case -1204791095:
                    new com.plus.currencyconverter.language.b.b().a();
                    str = "ۚۢۦۥۦ";
                    break;
                case 96277838:
                    str = "ۥۦۥۢۥۚۥۡۛۢۥۥۦ";
                    break;
                case 293216667:
                    str = "ۗۤۙۥۥۘۦۥۦ";
                    break;
                case 704567663:
                    p = configuration.locale;
                    str = "";
                    break;
                case 897981113:
                    super.onConfigurationChanged(configuration);
                    str = "ۥۥۦ";
                    break;
            }
        }
    }

    @Override // android.app.Application
    public void onCreate() {
        String str = "ۥۥۘۦ";
        while (true) {
            switch ((((str.hashCode() ^ 724) ^ 710) ^ 570) ^ (-857744400)) {
                case -1432290987:
                    String str2 = "ۘۨۥۚۛۥۦ";
                    while (true) {
                        switch (str2.hashCode() ^ (-55165343)) {
                            case -2108817026:
                                str2 = "ۦۜۦۦۘۨۥ۠ۦۥۦۦ";
                            case -1361315560:
                                str = "ۡۗۥۦ۫ۦۖۥۦۥۗۥ";
                                continue;
                            case -1283124497:
                                str = "ۦۖ۫۬ۥۥۖۦۥ";
                                continue;
                            case -722340920:
                                String str3 = "ۛۗۦۥۥۥ";
                                while (true) {
                                    switch (str3.hashCode() ^ (-1622281702)) {
                                        case -465062765:
                                            str2 = "ۦۦۦ";
                                            break;
                                        case -89773551:
                                            str3 = "com.plus.currencyconverter".equals(c().getPackageName()) ? "ۦۘۜ۫ۦۦۦۛۚۦۢۡۜ" : "ۗۧۥۦ";
                                        case 100919559:
                                            str2 = "ۥۥۦۥۥۥ";
                                            break;
                                        case 1891209174:
                                            str3 = "ۦۦۥۙۦۥ";
                                    }
                                }
                                break;
                        }
                    }
                    break;
                case -1213660492:
                    throw new RuntimeException();
                case -336361414:
                    super.onCreate();
                    str = "ۦۥۥ۫ۤۥۥۦۥ";
                    break;
                case 985835758:
                    d();
                    str = "ۥۦۘ۠ۦۡۦۥۥ";
                    break;
                case 1884723502:
                    str = "ۥۦۡۛۦۥۜۢ۬ۥۦۖۜۦۥ";
                    break;
                case 2087474449:
                    return;
            }
        }
    }
}

@abc0 @eybisi

enovella avatar Jul 01 '22 16:07 enovella

242da7c595ae33780c85d8e916d62a5c9743478b7421b9b026abd56fbdaa56cb 92ae23580c83642ad0e50f19979b9d2122f28d8b3a9d4b17539ce125ae8d93eb I'm sure I've seen this obfuscator more on bankers but couldn't find more samples :(

eybisi avatar Jul 01 '22 22:07 eybisi