/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.l7tech.common.io.CertGenParams
 *  com.l7tech.common.io.CertUtils
 *  com.l7tech.common.io.KeyGenParams
 *  com.l7tech.common.io.SingleCertX509KeyManager
 *  com.l7tech.gateway.common.security.keystore.SsgKeyEntry
 *  com.l7tech.objectmodel.EntityType
 *  com.l7tech.objectmodel.FindException
 *  com.l7tech.objectmodel.Goid
 *  com.l7tech.objectmodel.ObjectNotFoundException
 *  com.l7tech.objectmodel.PersistentEntity
 *  com.l7tech.objectmodel.SaveException
 *  com.l7tech.objectmodel.UpdateException
 *  com.l7tech.security.cert.TrustedCert
 *  com.l7tech.security.cert.TrustedCert$PolicyUsageType
 *  com.l7tech.security.cert.TrustedCert$TrustedFor
 *  com.l7tech.security.cert.TrustedCertManager
 *  com.l7tech.util.ConfigFactory
 *  com.l7tech.util.ConfigFactory$ConfigurationListener
 *  com.l7tech.util.ExceptionUtils
 *  com.l7tech.util.GoidUpgradeMapper
 *  com.l7tech.util.HexUtils
 *  com.l7tech.util.MasterPasswordManager
 *  com.l7tech.util.Pair
 *  com.l7tech.util.SyspropUtil
 *  jakarta.inject.Inject
 *  jakarta.inject.Named
 *  org.apache.commons.lang3.StringUtils
 *  org.springframework.context.SmartLifecycle
 *  org.springframework.transaction.PlatformTransactionManager
 *  org.springframework.transaction.support.TransactionCallback
 *  org.springframework.transaction.support.TransactionTemplate
 */
package com.l7tech.server;

import com.l7tech.common.io.CertGenParams;
import com.l7tech.common.io.CertUtils;
import com.l7tech.common.io.KeyGenParams;
import com.l7tech.common.io.SingleCertX509KeyManager;
import com.l7tech.gateway.common.security.keystore.SsgKeyEntry;
import com.l7tech.objectmodel.EntityType;
import com.l7tech.objectmodel.FindException;
import com.l7tech.objectmodel.Goid;
import com.l7tech.objectmodel.ObjectNotFoundException;
import com.l7tech.objectmodel.PersistentEntity;
import com.l7tech.objectmodel.SaveException;
import com.l7tech.objectmodel.UpdateException;
import com.l7tech.security.cert.TrustedCert;
import com.l7tech.security.cert.TrustedCertManager;
import com.l7tech.server.DefaultKey;
import com.l7tech.server.ServerConfig;
import com.l7tech.server.audit.AuditContextUtils;
import com.l7tech.server.c;
import com.l7tech.server.cluster.ClusterPropertyCache;
import com.l7tech.server.cluster.ClusterPropertyManager;
import com.l7tech.server.i;
import com.l7tech.server.security.keystore.SsgKeyFinder;
import com.l7tech.server.security.keystore.SsgKeyStore;
import com.l7tech.server.security.keystore.SsgKeyStoreManager;
import com.l7tech.util.ConfigFactory;
import com.l7tech.util.ExceptionUtils;
import com.l7tech.util.GoidUpgradeMapper;
import com.l7tech.util.HexUtils;
import com.l7tech.util.MasterPasswordManager;
import com.l7tech.util.Pair;
import com.l7tech.util.SyspropUtil;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
import java.security.cert.CertificateEncodingException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.net.ssl.KeyManager;
import javax.security.auth.x500.X500Principal;
import org.apache.commons.lang3.StringUtils;
import org.springframework.context.SmartLifecycle;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;

public class DefaultKeyImpl
implements DefaultKey,
PropertyChangeListener,
SmartLifecycle {
    private static final Logger a;
    static final SsgKeyEntry b;
    private static final Pattern c;
    private static final String d;
    private static final String e;
    private static final String f;
    private static final String g;
    private static final String h;
    private final ServerConfig i;
    private final ClusterPropertyManager j;
    private final SsgKeyStoreManager k;
    private final PlatformTransactionManager l;
    private final ClusterPropertyCache m;
    private final AtomicReference<SsgKeyEntry> n = new AtomicReference();
    private final AtomicReference<SsgKeyEntry> o = new AtomicReference();
    private final AtomicReference<SsgKeyEntry> p = new AtomicReference();
    private final AtomicBoolean q = new AtomicBoolean(false);
    private volatile boolean r = false;
    private final AtomicReference<SsgKeyEntry> s = new AtomicReference();
    private final AtomicReference<SsgKeyEntry> t = new AtomicReference();
    private final List<DefaultKey.KeyInfoListener> u = new LinkedList<DefaultKey.KeyInfoListener>();
    @Inject
    @Named(value="masterPasswordManager")
    private MasterPasswordManager masterPasswordManager;
    @Inject
    @Named(value="trustedCertManager")
    private TrustedCertManager trustedCertManager;
    private static final String[] v;

    public static boolean isNullEntry(SsgKeyEntry ssgKeyEntry) {
        boolean bl2;
        try {
            bl2 = ssgKeyEntry == b;
        }
        catch (RuntimeException runtimeException) {
            throw DefaultKeyImpl.a(runtimeException);
        }
        return bl2;
    }

    public DefaultKeyImpl(ServerConfig serverConfig, ClusterPropertyManager clusterPropertyManager, SsgKeyStoreManager ssgKeyStoreManager, PlatformTransactionManager platformTransactionManager, ClusterPropertyCache clusterPropertyCache) {
        this.i = serverConfig;
        this.j = clusterPropertyManager;
        this.k = ssgKeyStoreManager;
        this.l = platformTransactionManager;
        this.m = clusterPropertyCache;
        String[] stringArray = v;
        ConfigFactory.addListener((ConfigFactory.ConfigurationListener)new c(this, Set.of(stringArray[87], stringArray[29], stringArray[56])), (String[])new String[0]);
    }

    void a(TrustedCertManager trustedCertManager) {
        this.trustedCertManager = trustedCertManager;
    }

    public void start() {
        this.a();
        this.r = true;
    }

    public void stop() {
        this.r = false;
    }

    public boolean isRunning() {
        return this.r;
    }

    public int getPhase() {
        return -2147483548;
    }

    /*
     * Loose catch block
     */
    private void a() {
        block21: {
            try {
                block22: {
                    boolean bl2;
                    String string;
                    block20: {
                        String string2;
                        String string3;
                        String[] stringArray;
                        block19: {
                            String string4;
                            block18: {
                                block17: {
                                    block16: {
                                        stringArray = v;
                                        string3 = this.i.getClusterPropertyName(stringArray[78]);
                                        string4 = this.i.getClusterPropertyName(stringArray[56]);
                                        string2 = this.i.getClusterPropertyName(stringArray[29]);
                                        if (string3 == null) break block16;
                                        try {
                                            block23: {
                                                if (string4 == null) break block16;
                                                break block23;
                                                catch (Exception exception) {
                                                    throw DefaultKeyImpl.a(exception);
                                                }
                                            }
                                            if (string2 != null) break block17;
                                        }
                                        catch (Exception exception) {
                                            throw DefaultKeyImpl.a(exception);
                                        }
                                    }
                                    return;
                                }
                                string = this.j.getProperty(string3);
                                try {
                                    if (string != null && !string.isEmpty()) break block18;
                                }
                                catch (Exception exception) {
                                    throw DefaultKeyImpl.a(exception);
                                }
                                return;
                            }
                            bl2 = false;
                            String string5 = this.j.getProperty(string4);
                            try {
                                if (string5 != null && !string5.isEmpty()) break block19;
                            }
                            catch (Exception exception) {
                                throw DefaultKeyImpl.a(exception);
                            }
                            stringArray = v;
                            a.log(Level.INFO, stringArray[26] + string3 + stringArray[39] + string4);
                            this.b(string4, string);
                            bl2 = true;
                        }
                        String string6 = this.j.getProperty(string2);
                        try {
                            if (string6 != null && !string6.isEmpty()) break block20;
                        }
                        catch (Exception exception) {
                            throw DefaultKeyImpl.a(exception);
                        }
                        stringArray = v;
                        a.log(Level.INFO, stringArray[52] + string3 + stringArray[49] + string2);
                        this.b(string2, string);
                        bl2 = true;
                    }
                    if (!bl2) break block21;
                    try {
                        block24: {
                            this.q.set(true);
                            if (this.m == null) break block22;
                            break block24;
                            catch (Exception exception) {
                                throw DefaultKeyImpl.a(exception);
                            }
                        }
                        this.m.refreshFromDatabase();
                        a.log(Level.INFO, v[61] + string);
                    }
                    catch (Exception exception) {
                        throw DefaultKeyImpl.a(exception);
                    }
                }
                this.f();
            }
            catch (Exception exception) {
                a.log(Level.WARNING, v[69] + ExceptionUtils.getMessageWithCause((Throwable)exception), exception);
            }
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private SsgKeyEntry a(String string) throws IOException {
        String[] stringArray = v;
        AtomicReference<SsgKeyEntry> atomicReference = string.equals(stringArray[29]) ? this.o : this.n;
        try {
            return this.a(atomicReference, string, true);
        }
        catch (ObjectNotFoundException objectNotFoundException) {
            DefaultKeyImpl defaultKeyImpl = this;
            synchronized (defaultKeyImpl) {
                try {
                    return this.a(atomicReference, string, true);
                }
                catch (ObjectNotFoundException objectNotFoundException2) {
                    if (!string.equals(v[29])) {
                        return this.b();
                    }
                    return b;
                }
            }
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private SsgKeyEntry b() throws IOException {
        SsgKeyEntry ssgKeyEntry;
        TransactionTemplate transactionTemplate = new TransactionTemplate(this.l);
        transactionTemplate.setPropagationBehavior(3);
        IOException[] iOExceptionArray = new IOException[1];
        boolean bl2 = AuditContextUtils.isSystem();
        AuditContextUtils.setSystem(true);
        try {
            ssgKeyEntry = (SsgKeyEntry)transactionTemplate.execute((TransactionCallback)new i(this, iOExceptionArray));
        }
        finally {
            AuditContextUtils.setSystem(bl2);
        }
        try {
            if (iOExceptionArray[0] != null) {
                throw iOExceptionArray[0];
            }
        }
        catch (IOException iOException) {
            throw DefaultKeyImpl.a(iOException);
        }
        return ssgKeyEntry;
    }

    @Override
    public void addKeyInfoListener(DefaultKey.KeyInfoListener keyInfoListener) {
        this.u.add(keyInfoListener);
    }

    @Override
    public void removeKeyInfoListener(DefaultKey.KeyInfoListener keyInfoListener) {
        this.u.remove(keyInfoListener);
    }

    @Override
    public SsgKeyEntry getSslInfo() throws IOException {
        return this.getServerSslInfo();
    }

    @Override
    public SsgKeyEntry getServerSslInfo() throws IOException {
        try {
            String[] stringArray = v;
            return this.a(stringArray[56]);
        }
        catch (IOException | RuntimeException exception) {
            a.log(Level.SEVERE, v[28] + ExceptionUtils.getMessage((Throwable)exception), exception);
            throw exception;
        }
    }

    @Override
    public SsgKeyEntry getClientSslInfo() throws IOException {
        try {
            String[] stringArray = v;
            return this.a(stringArray[29]);
        }
        catch (IOException | RuntimeException exception) {
            a.log(Level.SEVERE, v[11] + ExceptionUtils.getMessage((Throwable)exception), exception);
            throw exception;
        }
    }

    @Override
    public SsgKeyEntry getLatestSslInfo() throws IOException {
        return this.getLatestServerSslInfo();
    }

    @Override
    public SsgKeyEntry getLatestServerSslInfo() throws IOException {
        try {
            String[] stringArray = v;
            return this.e(stringArray[37]);
        }
        catch (KeyStoreException keyStoreException) {
            String[] stringArray = v;
            throw new IOException(stringArray[96] + ExceptionUtils.getMessage((Throwable)keyStoreException), keyStoreException);
        }
        catch (FindException findException) {
            return this.a(v[56]);
        }
    }

    @Override
    public SsgKeyEntry getLatestClientSslInfo() throws IOException {
        try {
            String[] stringArray = v;
            return this.e(stringArray[29]);
        }
        catch (KeyStoreException keyStoreException) {
            String[] stringArray = v;
            throw new IOException(stringArray[86] + ExceptionUtils.getMessage((Throwable)keyStoreException), keyStoreException);
        }
        catch (FindException findException) {
            return this.a(v[29]);
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private SsgKeyEntry c() throws IOException {
        String[] stringArray = v;
        a.log(Level.INFO, stringArray[3]);
        boolean bl2 = AuditContextUtils.isSystem();
        AuditContextUtils.setSystem(true);
        try {
            String string = this.a(stringArray[56], stringArray[20]);
            SsgKeyStore ssgKeyStore = this.e();
            this.b(ssgKeyStore, string);
            SsgKeyEntry ssgKeyEntry = this.a(ssgKeyStore, string);
            return ssgKeyEntry;
        }
        finally {
            AuditContextUtils.setSystem(bl2);
        }
    }

    private SsgKeyEntry a(SsgKeyStore ssgKeyStore, String string) throws IOException {
        try {
            SsgKeyEntry ssgKeyEntry = ssgKeyStore.getCertificateChain(string);
            String[] stringArray = v;
            String string2 = this.i.getClusterPropertyName(stringArray[87]);
            try {
                if (string2 == null) {
                    throw new IOException(stringArray[66]);
                }
            }
            catch (ObjectNotFoundException objectNotFoundException) {
                throw DefaultKeyImpl.a((Exception)((Object)objectNotFoundException));
            }
            String string3 = String.valueOf(ssgKeyEntry.getKeystoreId()) + ":" + ssgKeyEntry.getAlias();
            this.j.putProperty(string2, string3);
            stringArray = v;
            String string4 = this.i.getClusterPropertyName(stringArray[56]);
            try {
                if (string4 == null) {
                    throw new IOException(stringArray[16]);
                }
            }
            catch (ObjectNotFoundException objectNotFoundException) {
                throw DefaultKeyImpl.a((Exception)((Object)objectNotFoundException));
            }
            this.j.putProperty(string4, string3);
            stringArray = v;
            String string5 = this.i.getClusterPropertyName(stringArray[29]);
            try {
                if (string5 == null) {
                    throw new IOException(stringArray[88]);
                }
            }
            catch (ObjectNotFoundException objectNotFoundException) {
                throw DefaultKeyImpl.a((Exception)((Object)objectNotFoundException));
            }
            this.j.putProperty(string5, string3);
            this.f();
            return ssgKeyEntry;
        }
        catch (ObjectNotFoundException objectNotFoundException) {
            String[] stringArray = v;
            throw new IOException(stringArray[73] + ExceptionUtils.getMessage((Throwable)objectNotFoundException), ExceptionUtils.getDebugException((Throwable)objectNotFoundException));
        }
        catch (KeyStoreException keyStoreException) {
            String[] stringArray = v;
            throw new IOException(stringArray[58] + ExceptionUtils.getMessage((Throwable)keyStoreException), keyStoreException);
        }
        catch (FindException findException) {
            String[] stringArray = v;
            throw new IOException(stringArray[90] + ExceptionUtils.getMessage((Throwable)findException), findException);
        }
        catch (UpdateException updateException) {
            String[] stringArray = v;
            throw new IOException(stringArray[6] + ExceptionUtils.getMessage((Throwable)updateException), updateException);
        }
        catch (SaveException saveException) {
            throw new IOException(v[6] + ExceptionUtils.getMessage((Throwable)saveException), saveException);
        }
    }

    /*
     * Loose catch block
     */
    private void b(SsgKeyStore ssgKeyStore, String string) throws IOException {
        block12: {
            String string2;
            String[] stringArray;
            block13: {
                stringArray = v;
                string2 = this.getenv(stringArray[4]);
                String string3 = this.getenv(stringArray[47]);
                String string4 = this.getenv(stringArray[36]);
                if (!Boolean.getBoolean(stringArray[92])) break block12;
                try {
                    block14: {
                        if (!StringUtils.isNotBlank((CharSequence)string3)) break block13;
                        break block14;
                        catch (Exception exception) {
                            throw DefaultKeyImpl.a(exception);
                        }
                    }
                    if (!StringUtils.isNotBlank((CharSequence)string4)) break block13;
                }
                catch (Exception exception) {
                    throw DefaultKeyImpl.a(exception);
                }
                try {
                    this.a(ssgKeyStore, string4, string, string3);
                    return;
                }
                catch (Exception exception) {
                    stringArray = v;
                    a.log(Level.WARNING, stringArray[12] + ExceptionUtils.getMessage((Throwable)exception), exception);
                }
                break block12;
            }
            try {
                if (string2 == null || string2.trim().length() <= 0) break block12;
            }
            catch (Exception exception) {
                throw DefaultKeyImpl.a(exception);
            }
            stringArray = v;
            a.info(stringArray[85]);
            String string5 = this.getenv(stringArray[83]);
            if (string5 == null) {
                a.info(stringArray[32]);
                string5 = stringArray[25];
            }
            if (this.masterPasswordManager != null) {
                string5 = new String(this.masterPasswordManager.decryptPasswordIfEncrypted(string5));
            }
            try {
                this.b(ssgKeyStore, string5, string, string2);
                return;
            }
            catch (Exception exception) {
                a.log(Level.WARNING, v[70] + ExceptionUtils.getMessage((Throwable)exception), exception);
            }
        }
        this.c(ssgKeyStore, string);
    }

    private void a(SsgKeyStore ssgKeyStore, String string, String string2, String string3) throws KeyStoreException, IOException, CertificateException, InterruptedException, ExecutionException {
        PrivateKey privateKey = CertUtils.decodeKeyFromPEM((String)string3);
        try {
            if (null == privateKey) {
                throw new IOException(v[35]);
            }
        }
        catch (KeyStoreException keyStoreException) {
            throw DefaultKeyImpl.a(keyStoreException);
        }
        String[] stringArray = string.split(CertUtils.PEM_CERT_BEGIN_MARKER);
        ArrayList<X509Certificate> arrayList = new ArrayList<X509Certificate>();
        for (String string4 : stringArray) {
            try {
                if (!StringUtils.isNotBlank((CharSequence)string4)) continue;
                arrayList.add(CertUtils.decodeFromPEM((String)(CertUtils.PEM_CERT_BEGIN_MARKER + string4)));
            }
            catch (KeyStoreException keyStoreException) {
                throw DefaultKeyImpl.a(keyStoreException);
            }
        }
        try {
            if (arrayList.isEmpty()) {
                throw new IOException(v[19]);
            }
        }
        catch (KeyStoreException keyStoreException) {
            throw DefaultKeyImpl.a(keyStoreException);
        }
        Object[] objectArray = new X509Certificate[arrayList.size()];
        objectArray = (X509Certificate[])arrayList.toArray(objectArray);
        this.a(ssgKeyStore, (X509Certificate[])objectArray, string2, privateKey);
        a.info(v[5]);
    }

    private void b(SsgKeyStore ssgKeyStore, String string, String string2, String string3) throws KeyStoreException, IOException, NoSuchAlgorithmException, CertificateException, UnrecoverableKeyException, InterruptedException, ExecutionException {
        byte[] byArray = HexUtils.decodeBase64((String)string3);
        String[] stringArray = v;
        KeyStore keyStore = KeyStore.getInstance(stringArray[98]);
        keyStore.load(new ByteArrayInputStream(byArray), string.toCharArray());
        Enumeration<String> enumeration = keyStore.aliases();
        PrivateKey privateKey = null;
        X509Certificate[] x509CertificateArray = null;
        while (enumeration.hasMoreElements()) {
            String string4 = enumeration.nextElement();
            if (!keyStore.isKeyEntry(string4)) continue;
            privateKey = (PrivateKey)keyStore.getKey(string4, string.toCharArray());
            Certificate[] certificateArray = keyStore.getCertificateChain(string4);
            x509CertificateArray = new X509Certificate[certificateArray.length];
            try {
                for (int i2 = 0; i2 < certificateArray.length; ++i2) {
                    x509CertificateArray[i2] = (X509Certificate)certificateArray[i2];
                }
                break;
            }
            catch (KeyStoreException keyStoreException) {
                throw DefaultKeyImpl.a(keyStoreException);
            }
        }
        try {
            if (null == privateKey) {
                throw new IOException(v[38]);
            }
        }
        catch (KeyStoreException keyStoreException) {
            throw DefaultKeyImpl.a(keyStoreException);
        }
        this.a(ssgKeyStore, x509CertificateArray, string2, privateKey);
        a.info(v[24]);
    }

    private void a(SsgKeyStore ssgKeyStore, X509Certificate[] x509CertificateArray, String string, PrivateKey privateKey) throws KeyStoreException, InterruptedException, ExecutionException {
        SsgKeyEntry ssgKeyEntry = new SsgKeyEntry(ssgKeyStore.getGoid(), string, x509CertificateArray, privateKey);
        Future<Boolean> future = ssgKeyStore.storePrivateKeyEntry(true, null, ssgKeyEntry, false);
        future.get();
        this.a(x509CertificateArray[0]);
    }

    protected String getenv(String string) {
        return System.getenv(string);
    }

    private void c(SsgKeyStore ssgKeyStore, String string) throws IOException {
        String string2;
        X500Principal x500Principal = this.d();
        try {
            string2 = v[15].equals(h) ? v[44] : null;
        }
        catch (GeneralSecurityException generalSecurityException) {
            throw DefaultKeyImpl.a(generalSecurityException);
        }
        String string3 = string2;
        try {
            Future<X509Certificate> future = ssgKeyStore.generateKeyPair(null, string, new KeyGenParams(), new CertGenParams(x500Principal, 3650, false, string3), null);
            X509Certificate x509Certificate = future.get();
            this.a(x509Certificate);
        }
        catch (GeneralSecurityException generalSecurityException) {
            String[] stringArray = v;
            throw new IOException(stringArray[46] + ExceptionUtils.getMessage((Throwable)generalSecurityException), generalSecurityException);
        }
        catch (ExecutionException executionException) {
            String[] stringArray = v;
            throw new IOException(stringArray[13] + ExceptionUtils.getMessage((Throwable)executionException), executionException);
        }
        catch (InterruptedException interruptedException) {
            throw new IOException(v[13] + ExceptionUtils.getMessage((Throwable)interruptedException), interruptedException);
        }
    }

    /*
     * Loose catch block
     * Enabled force condition propagation
     * Lifted jumps to return sites
     */
    private void a(X509Certificate x509Certificate) {
        String string;
        String[] stringArray;
        block16: {
            stringArray = v;
            string = SyspropUtil.getString((String)stringArray[84], null);
            if (string == null) return;
            try {
                if (string.trim().length() >= 1) break block16;
                return;
                catch (CertificateEncodingException certificateEncodingException) {
                    throw DefaultKeyImpl.a(certificateEncodingException);
                }
            }
            catch (CertificateEncodingException certificateEncodingException) {
                throw DefaultKeyImpl.a(certificateEncodingException);
            }
        }
        try {
            a.fine(v[80]);
            if (this.trustedCertManager == null) {
                throw new IllegalStateException(v[94]);
            }
        }
        catch (CertificateEncodingException certificateEncodingException) {
            throw DefaultKeyImpl.a(certificateEncodingException);
        }
        try {
            block17: {
                String string2 = CertUtils.getThumbprintSHA1((X509Certificate)x509Certificate);
                List list = this.trustedCertManager.findByThumbprint(string2);
                try {
                    if (list == null || list.isEmpty()) break block17;
                }
                catch (CertificateEncodingException certificateEncodingException) {
                    throw DefaultKeyImpl.a(certificateEncodingException);
                }
                stringArray = v;
                a.fine(stringArray[93]);
                return;
            }
            stringArray = v;
            a.info(stringArray[2]);
            TrustedCert trustedCert = new TrustedCert();
            trustedCert.setCertificate(x509Certificate);
            trustedCert.setName(stringArray[60]);
            trustedCert.setTrustAnchor(string.contains(stringArray[65]));
            trustedCert.setVerifyHostname(string.contains(stringArray[57]));
            trustedCert.setRevocationCheckPolicyType(TrustedCert.PolicyUsageType.USE_DEFAULT);
            for (TrustedCert.TrustedFor trustedFor : TrustedCert.TrustedFor.values()) {
                try {
                    if (!string.contains(v[1] + trustedFor.name())) continue;
                    trustedCert.setTrustedFor(trustedFor, true);
                }
                catch (CertificateEncodingException certificateEncodingException) {
                    throw DefaultKeyImpl.a(certificateEncodingException);
                }
            }
            Goid goid = this.trustedCertManager.save((PersistentEntity)trustedCert);
            stringArray = v;
            a.info(stringArray[75] + String.valueOf(goid));
            return;
        }
        catch (CertificateEncodingException certificateEncodingException) {
            stringArray = v;
            throw new RuntimeException(stringArray[55] + ExceptionUtils.getMessage((Throwable)certificateEncodingException), certificateEncodingException);
        }
        catch (FindException findException) {
            stringArray = v;
            throw new RuntimeException(stringArray[76] + ExceptionUtils.getMessage((Throwable)findException), findException);
        }
        catch (SaveException saveException) {
            throw new RuntimeException(v[82] + ExceptionUtils.getMessage((Throwable)saveException), saveException);
        }
    }

    private X500Principal d() {
        String string;
        block2: {
            String[] stringArray = v;
            string = this.i.getProperty(stringArray[48]);
            try {
                if (string != null && string.trim().length() != 0) break block2;
            }
            catch (RuntimeException runtimeException) {
                throw DefaultKeyImpl.a(runtimeException);
            }
            string = this.i.getHostname();
        }
        return new X500Principal(v[68] + string);
    }

    private SsgKeyStore e() throws IOException {
        SsgKeyStore ssgKeyStore = null;
        try {
            List<SsgKeyFinder> list = this.k.findAll();
            for (SsgKeyFinder ssgKeyFinder : list) {
                if (!ssgKeyFinder.isMutable()) continue;
                ssgKeyStore = ssgKeyFinder.getKeyStore();
                break;
            }
            try {
                if (ssgKeyStore == null) {
                    throw new IOException(v[27]);
                }
            }
            catch (FindException findException) {
                throw DefaultKeyImpl.a((Exception)((Object)findException));
            }
        }
        catch (FindException findException) {
            String[] stringArray = v;
            throw new IOException(stringArray[50] + ExceptionUtils.getMessage((Throwable)findException), findException);
        }
        catch (KeyStoreException keyStoreException) {
            throw new IOException(v[8] + ExceptionUtils.getMessage((Throwable)keyStoreException), keyStoreException);
        }
        return ssgKeyStore;
    }

    private String a(String string, String string2) throws IOException {
        String string3;
        block5: {
            String string4;
            Pair<Goid, String> pair = this.d(string);
            try {
                string4 = pair == null ? null : (String)pair.right;
            }
            catch (IOException iOException) {
                throw DefaultKeyImpl.a(iOException);
            }
            string3 = string4;
            try {
                if (string3 != null && string3.trim().length() >= 1) break block5;
            }
            catch (IOException iOException) {
                throw DefaultKeyImpl.a(iOException);
            }
            string3 = string2;
        }
        Object object = string3;
        int n2 = 1;
        while (this.b((String)object)) {
            object = string3 + n2++;
        }
        return object;
    }

    private boolean b(String string) throws IOException {
        try {
            this.k.lookupKeyByKeyAlias(string, PersistentEntity.DEFAULT_GOID);
            return true;
        }
        catch (ObjectNotFoundException objectNotFoundException) {
            return false;
        }
        catch (FindException findException) {
            String[] stringArray = v;
            throw new IOException(stringArray[72] + string + stringArray[14] + ExceptionUtils.getMessage((Throwable)findException), findException);
        }
        catch (KeyStoreException keyStoreException) {
            String[] stringArray = v;
            throw new IOException(stringArray[9] + string + stringArray[91] + ExceptionUtils.getMessage((Throwable)keyStoreException), keyStoreException);
        }
    }

    @Override
    public SsgKeyEntry getCaInfo() {
        try {
            String[] stringArray = v;
            return this.a(this.p, stringArray[54], false);
        }
        catch (IOException iOException) {
            String[] stringArray = v;
            throw new RuntimeException(stringArray[34] + ExceptionUtils.getMessage((Throwable)iOException), iOException);
        }
        catch (ObjectNotFoundException objectNotFoundException) {
            throw new RuntimeException(v[51] + ExceptionUtils.getMessage((Throwable)objectNotFoundException), objectNotFoundException);
        }
    }

    @Override
    public SsgKeyEntry getAuditSigningInfo() {
        try {
            String[] stringArray = v;
            return this.a(this.t, stringArray[23], false);
        }
        catch (IOException iOException) {
            String[] stringArray = v;
            throw new RuntimeException(stringArray[30] + ExceptionUtils.getMessage((Throwable)iOException), iOException);
        }
        catch (ObjectNotFoundException objectNotFoundException) {
            throw new RuntimeException(v[63] + ExceptionUtils.getMessage((Throwable)objectNotFoundException), objectNotFoundException);
        }
    }

    @Override
    public SsgKeyEntry getAuditViewerInfo() {
        try {
            String[] stringArray = v;
            return this.a(this.s, stringArray[77], false);
        }
        catch (IOException iOException) {
            String[] stringArray = v;
            throw new RuntimeException(stringArray[71] + ExceptionUtils.getMessage((Throwable)iOException), iOException);
        }
        catch (ObjectNotFoundException objectNotFoundException) {
            throw new RuntimeException(v[22] + ExceptionUtils.getMessage((Throwable)objectNotFoundException), objectNotFoundException);
        }
    }

    @Override
    public Pair<Goid, String> getAuditViewerAlias() {
        SsgKeyEntry ssgKeyEntry = this.s.get();
        try {
            if (ssgKeyEntry != null) {
                return new Pair((Object)ssgKeyEntry.getKeystoreId(), (Object)ssgKeyEntry.getAlias());
            }
        }
        catch (IOException iOException) {
            throw DefaultKeyImpl.a(iOException);
        }
        try {
            String[] stringArray = v;
            return this.d(stringArray[79]);
        }
        catch (IOException iOException) {
            throw new RuntimeException(v[42] + ExceptionUtils.getMessage((Throwable)iOException), iOException);
        }
    }

    @Override
    public KeyManager[] getSslKeyManagers() {
        try {
            SsgKeyEntry ssgKeyEntry = this.getSslInfo();
            X509Certificate[] x509CertificateArray = ssgKeyEntry.getCertificateChain();
            PrivateKey privateKey = ssgKeyEntry.getPrivate();
            String string = ssgKeyEntry.getAlias();
            return new KeyManager[]{new SingleCertX509KeyManager(x509CertificateArray, privateKey, string)};
        }
        catch (IOException iOException) {
            String[] stringArray = v;
            throw new RuntimeException(stringArray[95] + ExceptionUtils.getMessage((Throwable)iOException), iOException);
        }
        catch (UnrecoverableKeyException unrecoverableKeyException) {
            throw new RuntimeException(v[99] + ExceptionUtils.getMessage((Throwable)unrecoverableKeyException), unrecoverableKeyException);
        }
    }

    @Override
    public KeyManager[] getServerSslKeyManagers() {
        try {
            SsgKeyEntry ssgKeyEntry = this.getServerSslInfo();
            X509Certificate[] x509CertificateArray = ssgKeyEntry.getCertificateChain();
            PrivateKey privateKey = ssgKeyEntry.getPrivate();
            String string = ssgKeyEntry.getAlias();
            return new KeyManager[]{new SingleCertX509KeyManager(x509CertificateArray, privateKey, string)};
        }
        catch (IOException iOException) {
            String[] stringArray = v;
            throw new RuntimeException(stringArray[18] + ExceptionUtils.getMessage((Throwable)iOException), iOException);
        }
        catch (UnrecoverableKeyException unrecoverableKeyException) {
            throw new RuntimeException(v[89] + ExceptionUtils.getMessage((Throwable)unrecoverableKeyException), unrecoverableKeyException);
        }
    }

    /*
     * Loose catch block
     */
    @Override
    public KeyManager[] getClientSslKeyManagers() {
        try {
            SsgKeyEntry ssgKeyEntry;
            block10: {
                block9: {
                    block11: {
                        ssgKeyEntry = this.getClientSslInfo();
                        if (DefaultKeyImpl.isNullEntry(ssgKeyEntry)) break block9;
                        if (ssgKeyEntry == null) break block9;
                        break block11;
                        catch (IOException iOException) {
                            throw DefaultKeyImpl.a(iOException);
                        }
                    }
                    try {
                        block12: {
                            if (ssgKeyEntry.getCertificateChain() == null) break block9;
                            break block12;
                            catch (IOException iOException) {
                                throw DefaultKeyImpl.a(iOException);
                            }
                        }
                        if (ssgKeyEntry.getPrivate() != null) break block10;
                    }
                    catch (IOException iOException) {
                        throw DefaultKeyImpl.a(iOException);
                    }
                }
                String[] stringArray = v;
                a.log(Level.FINE, stringArray[53]);
                return new KeyManager[0];
            }
            X509Certificate[] x509CertificateArray = ssgKeyEntry.getCertificateChain();
            PrivateKey privateKey = ssgKeyEntry.getPrivate();
            String string = ssgKeyEntry.getAlias();
            return new KeyManager[]{new SingleCertX509KeyManager(x509CertificateArray, privateKey, string)};
        }
        catch (IOException iOException) {
            String[] stringArray = v;
            throw new RuntimeException(stringArray[43] + ExceptionUtils.getMessage((Throwable)iOException), iOException);
        }
        catch (UnrecoverableKeyException unrecoverableKeyException) {
            throw new RuntimeException(v[100] + ExceptionUtils.getMessage((Throwable)unrecoverableKeyException), unrecoverableKeyException);
        }
    }

    @Override
    public SsgKeyEntry lookupKeyByKeyAlias(String string, Goid goid) throws FindException, KeyStoreException, IOException {
        SsgKeyEntry ssgKeyEntry;
        try {
            ssgKeyEntry = string == null ? this.getSslInfo() : this.k.lookupKeyByKeyAlias(string, goid);
        }
        catch (FindException findException) {
            throw DefaultKeyImpl.a((Exception)((Object)findException));
        }
        return ssgKeyEntry;
    }

    @Override
    public void propertyChange(PropertyChangeEvent propertyChangeEvent) {
        this.f();
    }

    private void f() {
        this.n.set(null);
        this.o.set(null);
        this.p.set(null);
        this.s.set(null);
        this.t.set(null);
    }

    private void c(String string) {
        this.u.forEach(keyInfoListener -> {
            try {
                keyInfoListener.notifyKeyChanged(string);
            }
            catch (Exception exception) {
                a.log(Level.WARNING, v[10], ExceptionUtils.getMessageWithCause((Throwable)exception));
            }
        });
    }

    private SsgKeyEntry a(AtomicReference<SsgKeyEntry> atomicReference, String string, boolean bl2) throws IOException, ObjectNotFoundException {
        SsgKeyEntry ssgKeyEntry;
        SsgKeyEntry ssgKeyEntry2;
        block17: {
            while ((ssgKeyEntry2 = atomicReference.get()) == null) {
                block16: {
                    String[] stringArray;
                    try {
                        ssgKeyEntry2 = this.e(string);
                        try {
                            if (ssgKeyEntry2 != null && !DefaultKeyImpl.isNullEntry(ssgKeyEntry2)) break block16;
                        }
                        catch (KeyStoreException keyStoreException) {
                            throw DefaultKeyImpl.a(keyStoreException);
                        }
                        ssgKeyEntry2 = this.a(string, ssgKeyEntry2);
                    }
                    catch (KeyStoreException keyStoreException) {
                        stringArray = v;
                        throw new IOException(stringArray[81] + string + stringArray[17] + ExceptionUtils.getMessage((Throwable)keyStoreException), keyStoreException);
                    }
                    catch (FindException findException) {
                        Level level;
                        Logger logger;
                        String string2 = ExceptionUtils.getMessage((Throwable)findException);
                        try {
                            logger = a;
                            level = bl2 ? Level.WARNING : Level.INFO;
                        }
                        catch (KeyStoreException keyStoreException) {
                            throw DefaultKeyImpl.a(keyStoreException);
                        }
                        stringArray = v;
                        logger.log(level, stringArray[45] + string + stringArray[40] + string2);
                        ssgKeyEntry2 = b;
                    }
                }
                if (!atomicReference.compareAndSet(null, ssgKeyEntry2)) continue;
            }
            try {
                block18: {
                    try {
                        try {
                            if (!bl2) break block17;
                            if (ssgKeyEntry2 == null) break block18;
                        }
                        catch (KeyStoreException keyStoreException) {
                            throw DefaultKeyImpl.a(keyStoreException);
                        }
                        if (!DefaultKeyImpl.isNullEntry(ssgKeyEntry2)) break block17;
                    }
                    catch (KeyStoreException keyStoreException) {
                        throw DefaultKeyImpl.a(keyStoreException);
                    }
                }
                throw new ObjectNotFoundException(v[74] + string);
            }
            catch (KeyStoreException keyStoreException) {
                throw DefaultKeyImpl.a(keyStoreException);
            }
        }
        try {
            ssgKeyEntry = DefaultKeyImpl.isNullEntry(ssgKeyEntry2) ? null : ssgKeyEntry2;
        }
        catch (KeyStoreException keyStoreException) {
            throw DefaultKeyImpl.a(keyStoreException);
        }
        return ssgKeyEntry;
    }

    /*
     * Loose catch block
     */
    private SsgKeyEntry a(String string, SsgKeyEntry ssgKeyEntry) {
        block13: {
            block12: {
                if (v[56].equals(string)) break block12;
                try {
                    block15: {
                        if (v[29].equals(string)) break block12;
                        break block15;
                        catch (IOException iOException) {
                            throw DefaultKeyImpl.a(iOException);
                        }
                    }
                    return ssgKeyEntry;
                }
                catch (IOException iOException) {
                    throw DefaultKeyImpl.a(iOException);
                }
            }
            try {
                SsgKeyEntry ssgKeyEntry2;
                block14: {
                    block16: {
                        String[] stringArray = v;
                        ssgKeyEntry2 = this.e(stringArray[87]);
                        if (ssgKeyEntry2 == null) break block13;
                        if (DefaultKeyImpl.isNullEntry(ssgKeyEntry2)) break block13;
                        break block16;
                        catch (IOException iOException) {
                            throw DefaultKeyImpl.a(iOException);
                        }
                    }
                    try {
                        block17: {
                            if (!this.q.compareAndSet(false, true)) break block14;
                            break block17;
                            catch (IOException iOException) {
                                throw DefaultKeyImpl.a(iOException);
                            }
                        }
                        a.log(Level.INFO, v[41] + string + v[64]);
                        this.a(ssgKeyEntry2);
                    }
                    catch (IOException iOException) {
                        throw DefaultKeyImpl.a(iOException);
                    }
                }
                return ssgKeyEntry2;
            }
            catch (FindException | IOException | KeyStoreException throwable) {
                a.log(Level.WARNING, v[59] + ExceptionUtils.getMessage((Throwable)throwable));
            }
        }
        return ssgKeyEntry;
    }

    private void a(SsgKeyEntry ssgKeyEntry) {
        try {
            String string = String.valueOf(ssgKeyEntry.getKeystoreId()) + ":" + ssgKeyEntry.getAlias();
            String[] stringArray = v;
            String string2 = this.i.getClusterPropertyName(stringArray[56]);
            try {
                if (string2 != null) {
                    this.b(string2, string);
                }
            }
            catch (RuntimeException runtimeException) {
                throw DefaultKeyImpl.a(runtimeException);
            }
            stringArray = v;
            String string3 = this.i.getClusterPropertyName(stringArray[67]);
            try {
                if (string3 != null) {
                    this.b(string3, string);
                }
            }
            catch (RuntimeException runtimeException) {
                throw DefaultKeyImpl.a(runtimeException);
            }
            try {
                if (this.m != null) {
                    this.m.refreshFromDatabase();
                }
            }
            catch (RuntimeException runtimeException) {
                throw DefaultKeyImpl.a(runtimeException);
            }
            this.f();
        }
        catch (RuntimeException runtimeException) {
            a.log(Level.WARNING, v[7] + ExceptionUtils.getMessageWithCause((Throwable)runtimeException), runtimeException);
        }
    }

    private void b(String string, String string2) {
        TransactionTemplate transactionTemplate = new TransactionTemplate(this.l);
        transactionTemplate.setPropagationBehavior(3);
        transactionTemplate.execute(transactionStatus -> {
            try {
                this.j.putProperty(string, string2);
            }
            catch (FindException | SaveException | UpdateException throwable) {
                throw new RuntimeException(ExceptionUtils.getMessage((Throwable)throwable), throwable);
            }
            return null;
        });
    }

    /*
     * Loose catch block
     * Enabled force condition propagation
     * Lifted jumps to return sites
     */
    private Pair<Goid, String> d(String string) throws IOException {
        String string2;
        block9: {
            string2 = ConfigFactory.getUncachedConfig().getProperty(string);
            if (string2 == null) return null;
            try {
                if (string2.trim().length() >= 1) break block9;
                return null;
                catch (IllegalArgumentException illegalArgumentException) {
                    throw DefaultKeyImpl.a(illegalArgumentException);
                }
            }
            catch (IllegalArgumentException illegalArgumentException) {
                throw DefaultKeyImpl.a(illegalArgumentException);
            }
        }
        Matcher matcher = c.matcher(string2);
        try {
            if (!matcher.matches()) {
                a.log(Level.WARNING, v[97] + string + v[0] + string2 + "\"");
                return null;
            }
        }
        catch (IllegalArgumentException illegalArgumentException) {
            throw DefaultKeyImpl.a(illegalArgumentException);
        }
        try {
            Goid goid = GoidUpgradeMapper.mapId((EntityType)EntityType.SSG_KEYSTORE, (String)matcher.group(1));
            String string3 = matcher.group(2);
            return new Pair((Object)goid, (Object)string3);
        }
        catch (IllegalArgumentException illegalArgumentException) {
            String[] stringArray = v;
            a.log(Level.WARNING, stringArray[31] + string + stringArray[21] + string2);
            return null;
        }
    }

    private SsgKeyEntry e(String string) throws IOException, FindException, KeyStoreException {
        Pair<Goid, String> pair = this.d(string);
        try {
            if (pair == null) {
                return b;
            }
        }
        catch (ObjectNotFoundException objectNotFoundException) {
            throw DefaultKeyImpl.a((Exception)((Object)objectNotFoundException));
        }
        try {
            return this.k.lookupKeyByKeyAlias((String)pair.right, (Goid)pair.left);
        }
        catch (ObjectNotFoundException objectNotFoundException) {
            return b;
        }
    }

    /*
     * Unable to fully structure code
     */
    static {
        block10: {
            block9: {
                var5 = new String[101];
                var3_1 = 0;
                var2_2 = "\u0014\r\u001d\u000bz_J^?R\u001bhBM\u0003%}HKY\"Y\u0018\u000eXO\r*B\u000bA@^Y\"T_Z_J^?\u0017\u0010H\rl~\u0007\u0017\u0014KT\u0098`B\u001fI.Q\u001e[AK\r\u0018d3\u000e]MD=V\u000bK\rTH2\u0017\u0016]\r[H8^\u0018@LKH/\u001b_A_\u001fY#R_JHLD,Y\u001eZH[\r\u0018d3\u000e]MD=V\u000bK\rTH2\u0017\u0016]\rQB?\u0017\u0019AXQIp\u0017\u001c\\H^Y\"Y\u0018\u000eCZZkD\u001aBK\u0012^\"P\u0011KI\u001f~\u0018{_^_V[*C\u001a\u000eFZTkV\u0011J\r\\H9C\u0016HD\\L?R_ME^D%\u000b}~xr\u0018d3qfztNjHYL>[\u000b\u000e~lak\\\u001aW\rLX(T\u001a]^YX'[\u0006\u000eNMH*C\u001aJ\rY_$Z_}~xr\u0018d3qfzt\u0014g:c\rZC=^\rACRH%C_XLMD*U\u0013K%{C^O'R_ZB\u001fN$Y\u0019GJJ_.\u0017\u001bKK^X'C_}~s\r R\u0006\u0014\rO{C^O'R_ZB\u001f@\"P\rOYZ\r'R\u0018ONF\r\u0018d3\u000eFZTkG\rA]Z_?N_ZB\u001fC.@_}HM[.EPmAVH%C_}~s\r;E\u0010^HMY\"R\f\u0014\rD{C^O'R_ZB\u001fK\"Y\u001b\u000eFZT8C\u0010\\H\u001fD%\u0017\bFD\\EkC\u0010\u000eNMH*C\u001a\u000eDQD?^\u001eB\r[H-V\nBY\u001f~\u0018{_EHF\u0017k\u001a{C^O'R_ZB\u001fN#R\u001cE\rVKkV\u0013GLL\riDk_MB9\u0017\u001a@NPX%C\u001a\\H[\r<_\u0016BH\u001fC$C\u0016HTVC,\u0017\u000bFH\u001fi.Q\u001e[AK\r R\u0006\u000eDQK$\u0017\u0013G^KH%R\r]\rD\u001d6*{C^O'R_ZB\u001f]9R\u000fO_Z\r/R\u0019OXSYkt\u0013GHQYkd,b\rTH2\r_LhLVA.S_ZB\u001fN9R\u001eZH\u001fI.Q\u001e[AK\r\u0018d3\u000eFZTkQ\rA@\u001f~\u0018p }~sr\u0000r&q}z`kR\u0011XDMB%Z\u001a@Y\u001f[*E\u0016OOSHq\u0017*{C^O'R_ZB\u001fN9R\u001eZH\u001fD%^\u000bGLS\r/R\u0019OXSYkd,b\rTH2\r_\u0013\f\rV^kV\u0013\\H^I2\u0017\n]H[\u0017k\n|~~~\u0018vR~~l}{C^O'R_ZB\u001fN$Y\u0019GJJ_.\u0017\u001bKK^X'C_}HM[.E_}~s\r R\u0006\u0014\rQBkT\u0013[^KH9\u0017\u000f\\BOH9C\u0006\u000eIZK\"Y\u001aJ\rYB9\u0017,K_IH9t\u0010@KVJkG\rA]Z_?N_EHF~?X\rKiZK*B\u0013Z~Z_=R\r}^Sf.N\u0002\u0014\r%`B\u001fI.Q\u001e[AK\r\u0018R\rXHM\r\u0018d3\u000eFZTkV\tODSL)[\u001a\u0014\r-`B\u001fN.E\u000bGKVN*C\u001a\u000eKPX%S_GC\u001f~\u0018p }~sr\u0000r&q}z`\u0014t:|yl\u0003}~s\u0002\u0014\r${C^O'R_ZB\u001fA$X\u0014\u000eXO\r*B\u001bGY\u001f[\"R\bK_\u001fF.NE\u000e\u0017EHF~?X\rKlJI\"C,GJQD%P4KTJjHYL>[\u000b\u000e~lak\\\u001aW\rLX(T\u001a]^YX'[\u0006\u000eNMH*C\u001aJ\rY_$Z_}~xr\u0018d3qfztkR\u0011XDMB%Z\u001a@Y\u001f[*E\u0016OOSH\b^LL^<X\rJ\u0011cDX_*C\u0016@J\u001fA.P\u001eMT\u001fE`B\u001f@>C\u001eLAZ\r R\u0006]YP_.D_HBJC/\u0017\u0016@\rHE\"T\u0017\u000eYP\r(E\u001aOYZ\r\"Y\u0016ZD^AkS\u001aHLJA?\u0017,}a\u001fF.N*{C^O'R_ZB\u001f]9R\u000fO_Z\r/R\u0019OXSYkd\u001a\\[Z_kd,b\rTH2\r_\u001bEHF~?X\rKiZK*B\u0013ZnSD.Y\u000b}^Sf.N%{C^O'R_ZB\u001fA$X\u0014\u000eXO\r*B\u001bGY\u001f^\"P\u0011GCX\r R\u0006\u0014\r0lL[A2\u0017\u0019A_RL?C\u001aJ\rIL'B\u001a\u000eKP_kD\u001a\\[Z_(X\u0011HDX\r;E\u0010^HMY2\u0017e}~xr\u0018d3qfzt\u0014g>}~\u001fH%A\u0016\\BQ@.Y\u000b\u000e[^_\"V\u001dBH\u001fC$C_]HK\rf\u001a_IXZ^8^\u0011I\r[H-V\nBY\u001fF.N\fZBMHkG\u001e]^OE9V\fK\rYB9\u0017,}j`~\u0018{ ehf:MBR\u0003'\u0000\u000bKNW\u00038R\u001c[_VY2\u0019\u0014KTLY$E\u001a\u0000IZK*B\u0013ZfZTeD\u0016IC^Y>E\u001aoAXB9^\u000bF@\"{C^O'R_ZB\u001fA$X\u0014\u000eXO\r/R\u0019OXSYkt>\u000eFZTq\u0017-`B\u001f]9^\tOYZ\r R\u0006\u000eHQY9N_HBJC/\u0017\u0016@\rl~\fh,}a`f\u000en ~hr\u0015}~xr\u0018d3qfzt\u0014g:cr|h\u0019c,\u001bEHF~?X\rKiZK*B\u0013Z~Z_=R\r}^Sf.N2`B\u001f]9^\tOYZ\r R\u0006\u000eHQY9N_HBJC/\u0017\u0016@\rl~\fh,}a`f\u000en_EHF^?X\rK\u0004\u000eYP\r\u0010\u000eCPYkV\tODSL)[\u001a\u0014\r\t~_P].E\u000bW\r*{C^O'R_ZB\u001fA$X\u0014\u000eXO\r*B\u001bGY\u001f[\"R\bK_\u001fF.N_OAVL8\r_%`B\u001fI.Q\u001e[AK\r\b[\u0016KCK\r\u0018d3\u000eFZTkV\tODSL)[\u001a\u0014\r\n|~~~\u0018vR~~l\u0010~_V[*C\u001a\u000eFZTkQ\u0010\\\r*{C^O'R_ZB\u001fN9R\u001eZH\u001fD%^\u000bGLS\r/R\u0019OXSYkd,b\rTH2\r_\u000f}~xr\u0018d3qfzt\u0014g:c\u000bMAJ^?R\rfBLY\u0004\u000eYP\rD{C^O'R_ZB\u001fK\"Y\u001b\u000eFZT8C\u0010\\H\u001fD%\u0017\bFD\\EkC\u0010\u000eNMH*C\u001a\u000eDQD?^\u001eB\r[H-V\nBY\u001f~\u0018{_EHF\u0017k\"{C^O'R_ZB\u001fA$X\u0014\u000eXO\r/R\u0019OXSYkt>\u000eFZTq\u0017\u0011cDX_*C\u0016@J\u001fA.P\u001eMT\u001fF`B\u001fI.Q\u001e[AK\r\b[\u0016KCK\r\u0018d3\u000eFZTkT\u0010@KVJ>E\u001aJ\u0001\u001f_.C\n\\CVC,\u0017\u001aC]KTk|\u001aW`^C*P\u001a\\\r^_9V\u0006\u0014EHF~?X\rKiZK*B\u0013Zn^f.N2{C^O'R_ZB\u001f^.C_[]\u001f~\u0018{_EHF\r*B\u000bAYMX8CE\u000eNZ_?\u0017\u0016@[^A\"SE\u000e\u001bEHF~?X\rKiZK*B\u0013Z~Z_=R\r}^Sf.N\u000eXHMD-N7A^KC*Z\u001a {C^O'R_ZB\u001fK\"Y\u001b\u000eIZK*B\u0013Z\rl~\u0007\u0017\u0014KT\u0005\r0{C^O'R_ZB\u001fK*[\u0013\u000eO^N \u0017\u000bA\rSH,V\u001cW\rl~\u0007\u0017\u0014KT\u001f]9X\u000fK_KTq\u0017\u000foXKB\u001fE\n]Yl^'|\u001aWB|HY_.D\u0017KI\u001fN'B\fZHM\r;E\u0010^HMY2\u0017\u001cONWHkV\u0019ZHM\r&^\u0018\\LKD%P_JHYL>[\u000b\u000e~lak\\\u001aW\u0017\u001f#p\u0005d\u001df\u000e\u001e\u0003K~\u0000\rj\u0004\u001d\u001fBQf\b#JV\u000e\u0001y\u0007\u0002\u0007\u0017\u0017\u0003a\u001e[%{C^O'R_ZB\u001fA$X\u0014\u000eXO\r*B\u001bGY\u001f^\"P\u0011GCX\r R\u0006\u0014\rc\u000eCPYkT\u0010@KVJ>E\u001aJ\u0016\u001fK*[\u0013GCX\r)V\u001cE\rKBk[\u001aIL\\Tk\\\u001aW~KB9R;KK^X'C,]AtH2\u0017\u001e@I\u001f@\"P\rOYVC,\u0017\tOAJHkC\u0010\u000eCZZkG\rA]Z_?^\u001a]\u000bZ_J^?v\u0011MEP_p{C^O'R_ZB\u001fN$Y\u0019GJJ_.\u0017\u001bKK^X'C_}~s\r R\u0006\u0014\rQBkT\u0013[^KH9\u0017\u000f\\BOH9C\u0006\u000eIZK\"Y\u001aJ\rYB9\u0017,K_IH9t\u0010@KVJkG\rA]Z_?N_EHF~?X\rKiZK*B\u0013Z~LA\u0000R\u0006\u001bEHF~?X\rKiZK*B\u0013ZnSD.Y\u000b}^Sf.N\u0003MC\u0002C{C^O'R_ZB\u001f@\"P\rOYZ\r'R\u0018ONF\r\u0018d3\u000eFZTkG\rA]Z_?^\u001a]\r[X9^\u0011I\rVC\"C\u0016OAVW*C\u0016AC\u0005\rHhLVA.S_ZB\u001fN9R\u001eZH\u001fI.Q\u001e[AK\r\u0018d3\u000eFZTkQ\rA@\u001f~\u0018p }~sr\u0000r&\u000eHQ[\"E\u0010@@ZC?\u0017\tO_VL)[\u001a\u0014\r${C^O'R_ZB\u001fA$X\u0014\u000eXO\r*B\u001bGY\u001f[\"R\bK_\u001fF.NE\u000e\u001a{C^O'R_ZB\u001fN#R\u001cE\rVKkV\u0013GLL\ri {C^O'R_ZB\u001fK\"Y\u001b\u000eIZK*B\u0013Z\rl~\u0007\u0017\u0014KT\u0005\r\u001a|HNX\"E\u001aJ\rTH2\u0017\n@LIL\"[\u001eLAZ\u0017k9OXKB\u001fE\n]Yl^'|\u001aW\u0017\u001fC.@_Z_J^?R\u001b\u000eNZ_?^\u0019GN^Y.\u0017\fO[ZIk@\u0016ZE\u001fJ$^\u001b\u0013D{C^O'R_ZB\u001f^.C_[]\u001f~\u0018{_EHF\r*B\u000bAYMX8CE\u000eXQL)[\u001a\u000eYP\r'X\u0010E\rJ]kC\r[^KH/\u0017\u001cK_K\u0017k\u0016EHF~?X\rKlJI\"C)GHHH9|\u001aW\u0015EHF~?X\rKiZK*B\u0013Z~LA\u0000R\u0006\u0016EHF~?X\rKlJI\"C)GHHH9|\u001aW$OXKB\u001fE\n]Yl^'|\u001aW\u0017\u001fN#R\u001cEDQJkT\u001a\\Y\u001f^?X\rK\u001b{C^O'R_ZB\u001f_.C\rGHIHk\\\u001aW\rYB9\u0017E{C^O'R_ZB\u001f^.C_[]\u001f~\u0018{_EHF\r*B\u000bAYMX8CE\u000eXQL)[\u001a\u000eYP\r8V\tK\rQH<\u0017\u000b\\XLY.S_MHMYq\u0017\u0010}~xr\u0018d3qfzt\u0014g>}~$MBR\u0003'\u0000\u000bKNW\u0003)X\u0010Z^K_*GQOXKB\u001fE\n]Yl^'|\u001aWJz_FD%P_ZB\u001fN9R\u001eZH\u001fI.Q\u001e[AK\r\u0018d3\u000eFZTkQ\rA@\u001fY#R_}~xr\u0018d3qfztkR\u0011XDMB%Z\u001a@Y\u001f[*E\u0016OOSH8{C^O'R_ZB\u001f_.C\rGHIHk\\\u001aW\rYB9\u0017\u0014KTlY$E\u001ajHYL>[\u000bmAVH%C,]AtH2\r_\u0015EHF~?X\rKiZK*B\u0013Z~LA\u0000R\u0006}{C^O'R_ZB\u001fN$Y\u0019GJJ_.\u0017\u001bKK^X'C_mAVH%C_}~s\r R\u0006\u0014\rQBkT\u0013[^KH9\u0017\u000f\\BOH9C\u0006\u000eIZK\"Y\u001aJ\rYB9\u0017,K_IH9t\u0010@KVJkG\rA]Z_?N_EHF~?X\rKiZK*B\u0013ZnSD.Y\u000b}^Sf.N){C^O'R_ZB\u001fL(T\u001a]^\u001fI.Q\u001e[AK\r\u0018R\rXHM\r\u0018d3\u000eFZTq\u0017%{C^O'R_ZB\u001fN$Y\u0019GJJ_.\u0017\u001bKK^X'C_}~s\r R\u0006\u0014\r\u0013\f\rV^kV\u0013\\H^I2\u0017\n]H[\u0017k&MBR\u0003'\u0000\u000bKNW\u0003)X\u0010Z^K_*GQKCI\u00038D\u0013EHF\u0003.Y\u001eLAZ+OXKB\u001fE\n]Yl^'|\u001aW\u0017\u001f~\u0018{_EHF\r\"D_OAMH*S\u0006\u000eYMX8C\u001aJ9{C^O'R_ZB\u001f^.C_[]\u001f~\u0018{_EHF\r*B\u000bAYMX8CE\u000eCP\r?E\n]YZI\bR\rZ`^C*P\u001a\\\u001e`B\u001fI.Q\u001e[AK\r\u0018d3\u000eFZTkV\tODSL)[\u001a\u0014\r8{C^O'R_ZB\u001f_.C\rGHIHk\\\u001aW\rYB9\u0017\u0014KTlY$E\u001ajHYL>[\u000b}HM[.E,]AtH2\r_0lL[A2\u0017\u0019A_RL?C\u001aJ\rIL'B\u001a\u000eKP_kD\u001a\\[Z_(X\u0011HDX\r;E\u0010^HMY2\u0017\u0006~f|~z\u0005";
                var4_3 = "\u0014\r\u001d\u000bz_J^?R\u001bhBM\u0003%}HKY\"Y\u0018\u000eXO\r*B\u000bA@^Y\"T_Z_J^?\u0017\u0010H\rl~\u0007\u0017\u0014KT\u0098`B\u001fI.Q\u001e[AK\r\u0018d3\u000e]MD=V\u000bK\rTH2\u0017\u0016]\r[H8^\u0018@LKH/\u001b_A_\u001fY#R_JHLD,Y\u001eZH[\r\u0018d3\u000e]MD=V\u000bK\rTH2\u0017\u0016]\rQB?\u0017\u0019AXQIp\u0017\u001c\\H^Y\"Y\u0018\u000eCZZkD\u001aBK\u0012^\"P\u0011KI\u001f~\u0018{_^_V[*C\u001a\u000eFZTkV\u0011J\r\\H9C\u0016HD\\L?R_ME^D%\u000b}~xr\u0018d3qfztNjHYL>[\u000b\u000e~lak\\\u001aW\rLX(T\u001a]^YX'[\u0006\u000eNMH*C\u001aJ\rY_$Z_}~xr\u0018d3qfzt\u0014g:c\rZC=^\rACRH%C_XLMD*U\u0013K%{C^O'R_ZB\u001fN$Y\u0019GJJ_.\u0017\u001bKK^X'C_}~s\r R\u0006\u0014\rO{C^O'R_ZB\u001f@\"P\rOYZ\r'R\u0018ONF\r\u0018d3\u000eFZTkG\rA]Z_?N_ZB\u001fC.@_}HM[.EPmAVH%C_}~s\r;E\u0010^HMY\"R\f\u0014\rD{C^O'R_ZB\u001fK\"Y\u001b\u000eFZT8C\u0010\\H\u001fD%\u0017\bFD\\EkC\u0010\u000eNMH*C\u001a\u000eDQD?^\u001eB\r[H-V\nBY\u001f~\u0018{_EHF\u0017k\u001a{C^O'R_ZB\u001fN#R\u001cE\rVKkV\u0013GLL\riDk_MB9\u0017\u001a@NPX%C\u001a\\H[\r<_\u0016BH\u001fC$C\u0016HTVC,\u0017\u000bFH\u001fi.Q\u001e[AK\r R\u0006\u000eDQK$\u0017\u0013G^KH%R\r]\rD\u001d6*{C^O'R_ZB\u001f]9R\u000fO_Z\r/R\u0019OXSYkt\u0013GHQYkd,b\rTH2\r_LhLVA.S_ZB\u001fN9R\u001eZH\u001fI.Q\u001e[AK\r\u0018d3\u000eFZTkQ\rA@\u001f~\u0018p }~sr\u0000r&q}z`kR\u0011XDMB%Z\u001a@Y\u001f[*E\u0016OOSHq\u0017*{C^O'R_ZB\u001fN9R\u001eZH\u001fD%^\u000bGLS\r/R\u0019OXSYkd,b\rTH2\r_\u0013\f\rV^kV\u0013\\H^I2\u0017\n]H[\u0017k\n|~~~\u0018vR~~l}{C^O'R_ZB\u001fN$Y\u0019GJJ_.\u0017\u001bKK^X'C_}HM[.E_}~s\r R\u0006\u0014\rQBkT\u0013[^KH9\u0017\u000f\\BOH9C\u0006\u000eIZK\"Y\u001aJ\rYB9\u0017,K_IH9t\u0010@KVJkG\rA]Z_?N_EHF~?X\rKiZK*B\u0013Z~Z_=R\r}^Sf.N\u0002\u0014\r%`B\u001fI.Q\u001e[AK\r\u0018R\rXHM\r\u0018d3\u000eFZTkV\tODSL)[\u001a\u0014\r-`B\u001fN.E\u000bGKVN*C\u001a\u000eKPX%S_GC\u001f~\u0018p }~sr\u0000r&q}z`\u0014t:|yl\u0003}~s\u0002\u0014\r${C^O'R_ZB\u001fA$X\u0014\u000eXO\r*B\u001bGY\u001f[\"R\bK_\u001fF.NE\u000e\u0017EHF~?X\rKlJI\"C,GJQD%P4KTJjHYL>[\u000b\u000e~lak\\\u001aW\rLX(T\u001a]^YX'[\u0006\u000eNMH*C\u001aJ\rY_$Z_}~xr\u0018d3qfztkR\u0011XDMB%Z\u001a@Y\u001f[*E\u0016OOSH\b^LL^<X\rJ\u0011cDX_*C\u0016@J\u001fA.P\u001eMT\u001fE`B\u001f@>C\u001eLAZ\r R\u0006]YP_.D_HBJC/\u0017\u0016@\rHE\"T\u0017\u000eYP\r(E\u001aOYZ\r\"Y\u0016ZD^AkS\u001aHLJA?\u0017,}a\u001fF.N*{C^O'R_ZB\u001f]9R\u000fO_Z\r/R\u0019OXSYkd\u001a\\[Z_kd,b\rTH2\r_\u001bEHF~?X\rKiZK*B\u0013ZnSD.Y\u000b}^Sf.N%{C^O'R_ZB\u001fA$X\u0014\u000eXO\r*B\u001bGY\u001f^\"P\u0011GCX\r R\u0006\u0014\r0lL[A2\u0017\u0019A_RL?C\u001aJ\rIL'B\u001a\u000eKP_kD\u001a\\[Z_(X\u0011HDX\r;E\u0010^HMY2\u0017e}~xr\u0018d3qfzt\u0014g>}~\u001fH%A\u0016\\BQ@.Y\u000b\u000e[^_\"V\u001dBH\u001fC$C_]HK\rf\u001a_IXZ^8^\u0011I\r[H-V\nBY\u001fF.N\fZBMHkG\u001e]^OE9V\fK\rYB9\u0017,}j`~\u0018{ ehf:MBR\u0003'\u0000\u000bKNW\u00038R\u001c[_VY2\u0019\u0014KTLY$E\u001a\u0000IZK*B\u0013ZfZTeD\u0016IC^Y>E\u001aoAXB9^\u000bF@\"{C^O'R_ZB\u001fA$X\u0014\u000eXO\r/R\u0019OXSYkt>\u000eFZTq\u0017-`B\u001f]9^\tOYZ\r R\u0006\u000eHQY9N_HBJC/\u0017\u0016@\rl~\fh,}a`f\u000en ~hr\u0015}~xr\u0018d3qfzt\u0014g:cr|h\u0019c,\u001bEHF~?X\rKiZK*B\u0013Z~Z_=R\r}^Sf.N2`B\u001f]9^\tOYZ\r R\u0006\u000eHQY9N_HBJC/\u0017\u0016@\rl~\fh,}a`f\u000en_EHF^?X\rK\u0004\u000eYP\r\u0010\u000eCPYkV\tODSL)[\u001a\u0014\r\t~_P].E\u000bW\r*{C^O'R_ZB\u001fA$X\u0014\u000eXO\r*B\u001bGY\u001f[\"R\bK_\u001fF.N_OAVL8\r_%`B\u001fI.Q\u001e[AK\r\b[\u0016KCK\r\u0018d3\u000eFZTkV\tODSL)[\u001a\u0014\r\n|~~~\u0018vR~~l\u0010~_V[*C\u001a\u000eFZTkQ\u0010\\\r*{C^O'R_ZB\u001fN9R\u001eZH\u001fD%^\u000bGLS\r/R\u0019OXSYkd,b\rTH2\r_\u000f}~xr\u0018d3qfzt\u0014g:c\u000bMAJ^?R\rfBLY\u0004\u000eYP\rD{C^O'R_ZB\u001fK\"Y\u001b\u000eFZT8C\u0010\\H\u001fD%\u0017\bFD\\EkC\u0010\u000eNMH*C\u001a\u000eDQD?^\u001eB\r[H-V\nBY\u001f~\u0018{_EHF\u0017k\"{C^O'R_ZB\u001fA$X\u0014\u000eXO\r/R\u0019OXSYkt>\u000eFZTq\u0017\u0011cDX_*C\u0016@J\u001fA.P\u001eMT\u001fF`B\u001fI.Q\u001e[AK\r\b[\u0016KCK\r\u0018d3\u000eFZTkT\u0010@KVJ>E\u001aJ\u0001\u001f_.C\n\\CVC,\u0017\u001aC]KTk|\u001aW`^C*P\u001a\\\r^_9V\u0006\u0014EHF~?X\rKiZK*B\u0013Zn^f.N2{C^O'R_ZB\u001f^.C_[]\u001f~\u0018{_EHF\r*B\u000bAYMX8CE\u000eNZ_?\u0017\u0016@[^A\"SE\u000e\u001bEHF~?X\rKiZK*B\u0013Z~Z_=R\r}^Sf.N\u000eXHMD-N7A^KC*Z\u001a {C^O'R_ZB\u001fK\"Y\u001b\u000eIZK*B\u0013Z\rl~\u0007\u0017\u0014KT\u0005\r0{C^O'R_ZB\u001fK*[\u0013\u000eO^N \u0017\u000bA\rSH,V\u001cW\rl~\u0007\u0017\u0014KT\u001f]9X\u000fK_KTq\u0017\u000foXKB\u001fE\n]Yl^'|\u001aWB|HY_.D\u0017KI\u001fN'B\fZHM\r;E\u0010^HMY2\u0017\u001cONWHkV\u0019ZHM\r&^\u0018\\LKD%P_JHYL>[\u000b\u000e~lak\\\u001aW\u0017\u001f#p\u0005d\u001df\u000e\u001e\u0003K~\u0000\rj\u0004\u001d\u001fBQf\b#JV\u000e\u0001y\u0007\u0002\u0007\u0017\u0017\u0003a\u001e[%{C^O'R_ZB\u001fA$X\u0014\u000eXO\r*B\u001bGY\u001f^\"P\u0011GCX\r R\u0006\u0014\rc\u000eCPYkT\u0010@KVJ>E\u001aJ\u0016\u001fK*[\u0013GCX\r)V\u001cE\rKBk[\u001aIL\\Tk\\\u001aW~KB9R;KK^X'C,]AtH2\u0017\u001e@I\u001f@\"P\rOYVC,\u0017\tOAJHkC\u0010\u000eCZZkG\rA]Z_?^\u001a]\u000bZ_J^?v\u0011MEP_p{C^O'R_ZB\u001fN$Y\u0019GJJ_.\u0017\u001bKK^X'C_}~s\r R\u0006\u0014\rQBkT\u0013[^KH9\u0017\u000f\\BOH9C\u0006\u000eIZK\"Y\u001aJ\rYB9\u0017,K_IH9t\u0010@KVJkG\rA]Z_?N_EHF~?X\rKiZK*B\u0013Z~LA\u0000R\u0006\u001bEHF~?X\rKiZK*B\u0013ZnSD.Y\u000b}^Sf.N\u0003MC\u0002C{C^O'R_ZB\u001f@\"P\rOYZ\r'R\u0018ONF\r\u0018d3\u000eFZTkG\rA]Z_?^\u001a]\r[X9^\u0011I\rVC\"C\u0016OAVW*C\u0016AC\u0005\rHhLVA.S_ZB\u001fN9R\u001eZH\u001fI.Q\u001e[AK\r\u0018d3\u000eFZTkQ\rA@\u001f~\u0018p }~sr\u0000r&\u000eHQ[\"E\u0010@@ZC?\u0017\tO_VL)[\u001a\u0014\r${C^O'R_ZB\u001fA$X\u0014\u000eXO\r*B\u001bGY\u001f[\"R\bK_\u001fF.NE\u000e\u001a{C^O'R_ZB\u001fN#R\u001cE\rVKkV\u0013GLL\ri {C^O'R_ZB\u001fK\"Y\u001b\u000eIZK*B\u0013Z\rl~\u0007\u0017\u0014KT\u0005\r\u001a|HNX\"E\u001aJ\rTH2\u0017\n@LIL\"[\u001eLAZ\u0017k9OXKB\u001fE\n]Yl^'|\u001aW\u0017\u001fC.@_Z_J^?R\u001b\u000eNZ_?^\u0019GN^Y.\u0017\fO[ZIk@\u0016ZE\u001fJ$^\u001b\u0013D{C^O'R_ZB\u001f^.C_[]\u001f~\u0018{_EHF\r*B\u000bAYMX8CE\u000eXQL)[\u001a\u000eYP\r'X\u0010E\rJ]kC\r[^KH/\u0017\u001cK_K\u0017k\u0016EHF~?X\rKlJI\"C)GHHH9|\u001aW\u0015EHF~?X\rKiZK*B\u0013Z~LA\u0000R\u0006\u0016EHF~?X\rKlJI\"C)GHHH9|\u001aW$OXKB\u001fE\n]Yl^'|\u001aW\u0017\u001fN#R\u001cEDQJkT\u001a\\Y\u001f^?X\rK\u001b{C^O'R_ZB\u001f_.C\rGHIHk\\\u001aW\rYB9\u0017E{C^O'R_ZB\u001f^.C_[]\u001f~\u0018{_EHF\r*B\u000bAYMX8CE\u000eXQL)[\u001a\u000eYP\r8V\tK\rQH<\u0017\u000b\\XLY.S_MHMYq\u0017\u0010}~xr\u0018d3qfzt\u0014g>}~$MBR\u0003'\u0000\u000bKNW\u0003)X\u0010Z^K_*GQOXKB\u001fE\n]Yl^'|\u001aWJz_FD%P_ZB\u001fN9R\u001eZH\u001fI.Q\u001e[AK\r\u0018d3\u000eFZTkQ\rA@\u001fY#R_}~xr\u0018d3qfztkR\u0011XDMB%Z\u001a@Y\u001f[*E\u0016OOSH8{C^O'R_ZB\u001f_.C\rGHIHk\\\u001aW\rYB9\u0017\u0014KTlY$E\u001ajHYL>[\u000bmAVH%C,]AtH2\r_\u0015EHF~?X\rKiZK*B\u0013Z~LA\u0000R\u0006}{C^O'R_ZB\u001fN$Y\u0019GJJ_.\u0017\u001bKK^X'C_mAVH%C_}~s\r R\u0006\u0014\rQBkT\u0013[^KH9\u0017\u000f\\BOH9C\u0006\u000eIZK\"Y\u001aJ\rYB9\u0017,K_IH9t\u0010@KVJkG\rA]Z_?N_EHF~?X\rKiZK*B\u0013ZnSD.Y\u000b}^Sf.N){C^O'R_ZB\u001fL(T\u001a]^\u001fI.Q\u001e[AK\r\u0018R\rXHM\r\u0018d3\u000eFZTq\u0017%{C^O'R_ZB\u001fN$Y\u0019GJJ_.\u0017\u001bKK^X'C_}~s\r R\u0006\u0014\r\u0013\f\rV^kV\u0013\\H^I2\u0017\n]H[\u0017k&MBR\u0003'\u0000\u000bKNW\u0003)X\u0010Z^K_*GQKCI\u00038D\u0013EHF\u0003.Y\u001eLAZ+OXKB\u001fE\n]Yl^'|\u001aW\u0017\u001f~\u0018{_EHF\r\"D_OAMH*S\u0006\u000eYMX8C\u001aJ9{C^O'R_ZB\u001f^.C_[]\u001f~\u0018{_EHF\r*B\u000bAYMX8CE\u000eCP\r?E\n]YZI\bR\rZ`^C*P\u001a\\\u001e`B\u001fI.Q\u001e[AK\r\u0018d3\u000eFZTkV\tODSL)[\u001a\u0014\r8{C^O'R_ZB\u001f_.C\rGHIHk\\\u001aW\rYB9\u0017\u0014KTlY$E\u001ajHYL>[\u000b}HM[.E,]AtH2\r_0lL[A2\u0017\u0019A_RL?C\u001aJ\rIL'B\u001a\u000eKP_kD\u001a\\[Z_(X\u0011HDX\r;E\u0010^HMY2\u0017\u0006~f|~z\u0005".length();
                var1_4 = 3;
                var0_5 = -1;
lbl7:
                // 2 sources

                while (true) {
                    v0 = 115;
                    v1 = ++var0_5;
                    v2 = var2_2.substring(v1, v1 + var1_4);
                    v3 = -1;
                    break block9;
                    break;
                }
lbl13:
                // 1 sources

                while (true) {
                    var5[var3_1++] = DefaultKeyImpl.a(v0, DefaultKeyImpl.f(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    var2_2 = ".\u0016\u000b\u001ar\u0007\n\u000f\u0017J\u0019}\u0001O\b\u000bJ\u001c{\u0004K\u000e\u0014\u001eXM1f[\u0013\u000f\u0001$B).\u0016\u000b\u001ar\u0007\n\u000f\u0017J\u0019}\u0001O\b\u000bJ\u001c{\u0004K\u000e\u0014\u001eX]\u000eC\u001e\u0016\u001eXM1f[\u0013\u000f\u0001$B";
                    var4_3 = ".\u0016\u000b\u001ar\u0007\n\u000f\u0017J\u0019}\u0001O\b\u000bJ\u001c{\u0004K\u000e\u0014\u001eXM1f[\u0013\u000f\u0001$B).\u0016\u000b\u001ar\u0007\n\u000f\u0017J\u0019}\u0001O\b\u000bJ\u001c{\u0004K\u000e\u0014\u001eX]\u000eC\u001e\u0016\u001eXM1f[\u0013\u000f\u0001$B".length();
                    var1_4 = 34;
                    var0_5 = -1;
lbl22:
                    // 2 sources

                    while (true) {
                        v0 = 38;
                        v4 = ++var0_5;
                        v2 = var2_2.substring(v4, v4 + var1_4);
                        v3 = 0;
                        break block9;
                        break;
                    }
                    break;
                }
lbl28:
                // 1 sources

                while (true) {
                    var5[var3_1++] = DefaultKeyImpl.a(v0, DefaultKeyImpl.f(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    break block10;
                    break;
                }
            }
            switch (v3) {
                default: {
                    ** continue;
                }
                ** case 0:
lbl39:
                // 1 sources

                ** continue;
            }
        }
        DefaultKeyImpl.v = var5;
        DefaultKeyImpl.d = DefaultKeyImpl.v[44];
        DefaultKeyImpl.f = DefaultKeyImpl.v[56];
        DefaultKeyImpl.e = DefaultKeyImpl.v[87];
        DefaultKeyImpl.g = DefaultKeyImpl.v[29];
        DefaultKeyImpl.a = Logger.getLogger(DefaultKeyImpl.class.getName());
        DefaultKeyImpl.b = new SsgKeyEntry(new Goid(0L, -9223372036854775808L), null, null, null);
        var0_6 = DefaultKeyImpl.v;
        DefaultKeyImpl.c = Pattern.compile(var0_6[62]);
        DefaultKeyImpl.h = ConfigFactory.getProperty((String)var0_6[33], null);
    }

    private static Exception a(Exception exception) {
        return exception;
    }

    private static char[] f(String string) {
        char[] cArray = string.toCharArray();
        if (cArray.length < 2) {
            cArray = cArray;
            cArray[0] = (char)(cArray[0] ^ 0xC);
        }
        return cArray;
    }

    /*
     * Handled impossible loop by duplicating code
     * Enabled aggressive block sorting
     */
    private static String a(int n2, char[] cArray) {
        char[] cArray2;
        block11: {
            int n3;
            int n4;
            int n5;
            block10: {
                n5 = n2;
                cArray2 = cArray;
                n4 = cArray.length;
                n3 = 0;
                if (!true) break block10;
                n4 = n4;
                if (n4 <= n3) break block11;
            }
            do {
                n5 = n5;
                cArray2 = cArray2;
                int n6 = n3;
                cArray2[n6] = (char)(cArray2[n6] ^ (n5 ^ (switch (n3 % 7) {
                    case 0 -> 93;
                    case 1 -> 94;
                    case 2 -> 76;
                    case 3 -> 94;
                    case 4 -> 56;
                    case 5 -> 68;
                    default -> 12;
                })));
                ++n3;
                n4 = n4;
            } while (n4 > n3);
        }
        return new String(cArray2).intern();
    }
}

