/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.l7tech.common.mime.ContentTypeHeader
 *  com.l7tech.gateway.common.audit.Audit
 *  com.l7tech.gateway.common.audit.AuditDetailMessage
 *  com.l7tech.gateway.common.audit.SystemMessages
 *  com.l7tech.util.ExceptionUtils
 *  com.l7tech.util.TimeSource
 *  com.l7tech.util.TimeUnit
 */
package com.l7tech.server.url;

import com.l7tech.common.mime.ContentTypeHeader;
import com.l7tech.gateway.common.audit.Audit;
import com.l7tech.gateway.common.audit.AuditDetailMessage;
import com.l7tech.gateway.common.audit.SystemMessages;
import com.l7tech.server.url.UrlResolver;
import com.l7tech.server.url.a;
import com.l7tech.util.ExceptionUtils;
import com.l7tech.util.TimeSource;
import com.l7tech.util.TimeUnit;
import java.io.IOException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.concurrent.Executor;
import java.util.concurrent.locks.Lock;
import java.util.logging.Level;
import java.util.logging.Logger;

public abstract class AbstractUrlObjectCache<UT>
implements UrlResolver<UT> {
    private final Logger a = Logger.getLogger(this.getClass().getName());
    public static final WaitMode WAIT_NEVER;
    public static final WaitMode WAIT_INITIAL;
    public static final WaitMode WAIT_LATEST;
    public static final long STALE_CACHE_NO_EXPIRY = -1L;
    protected TimeSource clock = new TimeSource();
    protected final String resourceDescription;
    protected long maxCacheAge;
    protected final long maxStaleCacheAge;
    protected final WaitMode defaultWaitMode;
    public static final int RESULT_DOWNLOAD_FAILED = 0;
    public static final int RESULT_DOWNLOADING_NOW = 1;
    public static final int RESULT_DOWNLOAD_SUCCESS = 2;
    public static final int RESULT_USED_CACHED = 3;
    static final /* synthetic */ boolean b;
    private static final String[] k;

    protected AbstractUrlObjectCache(String string, long l2, WaitMode waitMode) {
        this(string, l2, -1L, waitMode);
    }

    protected AbstractUrlObjectCache(String string, long l2, long l3, WaitMode waitMode) {
        this.resourceDescription = string;
        this.maxCacheAge = l2;
        this.maxStaleCacheAge = l3;
        this.defaultWaitMode = waitMode == null ? WAIT_INITIAL : waitMode;
    }

    protected abstract Lock getReadLock();

    protected abstract Lock getWriteLock();

    protected AbstractCacheEntry<UT> newCacheEntry(String string) {
        return new AbstractCacheEntry(string);
    }

    public void setMaxCacheAge(long l2) {
        this.maxCacheAge = l2;
    }

    protected abstract AbstractCacheEntry<UT> cacheGet(String var1);

    protected abstract Iterator<AbstractCacheEntry<UT>> cacheIterator();

    protected abstract void cachePut(String var1, AbstractCacheEntry<UT> var2);

    protected abstract AbstractCacheEntry<UT> cacheRemove(String var1);

    protected void onStaleEntryAboutToBeReplaced(AbstractCacheEntry<UT> abstractCacheEntry, String string) {
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     * Unable to fully structure code
     */
    public FetchResult<UT> fetchCached(String var1_1, WaitMode var2_2) {
        block69: {
            block63: {
                block61: {
                    block62: {
                        block60: {
                            block59: {
                                var3_3 = Thread.currentThread().getId();
                                if (var2_2 == null) {
                                    var2_2 = this.defaultWaitMode;
                                }
                                var6_4 = false;
                                var7_5 = this.getWriteLock();
                                var7_5.lock();
                                try {
                                    var5_6 = this.cacheGet(var1_1);
                                    if (var5_6 == null) {
                                        var5_6 = this.newCacheEntry(var1_1);
                                        var5_6.b = var3_3;
                                        this.cachePut(var1_1, var5_6);
                                        var6_4 = true;
                                    } else if (var5_6.b == var3_3) {
                                        var5_6 = this.newCacheEntry(var1_1);
                                        var11_7 = AbstractUrlObjectCache.k;
                                        var5_6.i = new IOException(var11_7[10] + var1_1);
                                        var5_6.j = this.clock.currentTimeMillis();
                                        var8_9 = new FetchResult<UT>(500, var5_6);
                                        return var8_9;
                                    }
                                }
                                finally {
                                    var7_5.unlock();
                                }
                                if (AbstractUrlObjectCache.b) break block59;
                                try {
                                    block70: {
                                        if (var5_6 != null) break block59;
                                        break block70;
                                        catch (InterruptedException v0) {
                                            throw AbstractUrlObjectCache.a(v0);
                                        }
                                    }
                                    throw new AssertionError();
                                }
                                catch (InterruptedException v1) {
                                    throw AbstractUrlObjectCache.a(v1);
                                }
                            }
                            if (AbstractUrlObjectCache.b) break block60;
                            try {
                                block71: {
                                    if (!Thread.holdsLock(var5_6)) break block60;
                                    break block71;
                                    catch (InterruptedException v2) {
                                        throw AbstractUrlObjectCache.a(v2);
                                    }
                                }
                                throw new AssertionError();
                            }
                            catch (InterruptedException v3) {
                                throw AbstractUrlObjectCache.a(v3);
                            }
                        }
                        if (!var6_4) break block61;
                        try {
                            block72: {
                                if (!this.a.isLoggable(Level.FINE)) break block62;
                                break block72;
                                catch (InterruptedException v4) {
                                    throw AbstractUrlObjectCache.a(v4);
                                }
                            }
                            this.a.fine(AbstractUrlObjectCache.k[4] + var1_1 + AbstractUrlObjectCache.k[2]);
                        }
                        catch (InterruptedException v5) {
                            throw AbstractUrlObjectCache.a(v5);
                        }
                    }
                    return this.a(var5_6, var1_1);
                }
                if (AbstractUrlObjectCache.b) break block63;
                try {
                    block73: {
                        if (var5_6.b != var3_3) break block63;
                        break block73;
                        catch (InterruptedException v6) {
                            throw AbstractUrlObjectCache.a(v6);
                        }
                    }
                    throw new AssertionError();
                }
                catch (InterruptedException v7) {
                    throw AbstractUrlObjectCache.a(v7);
                }
            }
            var8_10 = var5_6;
            synchronized (var8_10) {
                block67: {
                    block68: {
                        block74: {
                            block64: {
                                block66: {
                                    block65: {
                                        block76: {
                                            block75: {
                                                if (var5_6.b == 0L) break block74;
                                                if (var2_2 == AbstractUrlObjectCache.WAIT_LATEST) ** GOTO lbl101
                                                if (var2_2 != AbstractUrlObjectCache.WAIT_INITIAL) break block64;
                                                break block75;
                                                catch (InterruptedException v8) {
                                                    throw AbstractUrlObjectCache.a(v8);
                                                }
                                            }
                                            if (var5_6.g != null) break block64;
                                            break block76;
                                            catch (InterruptedException v9) {
                                                throw AbstractUrlObjectCache.a(v9);
                                            }
                                        }
                                        try {
                                            block77: {
                                                if (var5_6.i != null) break block64;
                                                break block77;
                                                catch (InterruptedException v10) {
                                                    throw AbstractUrlObjectCache.a(v10);
                                                }
                                            }
lbl102:
                                            // 2 sources

                                            while (var5_6.b != 0L) {
                                                break block65;
                                            }
                                            break block66;
                                        }
                                        catch (InterruptedException v11) {
                                            throw AbstractUrlObjectCache.a(v11);
                                        }
                                    }
                                    try {
                                        try {
                                            if (this.a.isLoggable(Level.FINER)) {
                                                this.a.finer(AbstractUrlObjectCache.k[13] + var1_1 + "'");
                                            }
                                        }
                                        catch (InterruptedException v12) {
                                            throw AbstractUrlObjectCache.a(v12);
                                        }
                                        var5_6.wait();
                                        ** GOTO lbl102
                                    }
                                    catch (InterruptedException var9_12) {
                                        Thread.currentThread().interrupt();
                                        var11_8 = AbstractUrlObjectCache.k;
                                        throw new RuntimeException(var11_8[1] + var1_1 + "'", var9_12);
                                    }
                                }
                                try {
                                    v13 = v14;
                                    v15 = v14;
                                    v16 = null == var5_6.i ? 2 : 0;
                                }
                                catch (InterruptedException v17) {
                                    throw AbstractUrlObjectCache.a(v17);
                                }
                                v13(v16, var5_6);
                                return v15;
                            }
                            try {
                                if (this.a.isLoggable(Level.FINER)) {
                                    this.a.finer(AbstractUrlObjectCache.k[14] + var1_1 + AbstractUrlObjectCache.k[15]);
                                }
                            }
                            catch (InterruptedException v18) {
                                throw AbstractUrlObjectCache.a(v18);
                            }
                            return new FetchResult<UT>(1, var5_6);
                        }
                        if (this.a(var5_6, this.clock.currentTimeMillis())) break block67;
                        try {
                            block78: {
                                if (!this.a.isLoggable(Level.FINE)) break block68;
                                break block78;
                                catch (InterruptedException v19) {
                                    throw AbstractUrlObjectCache.a(v19);
                                }
                            }
                            this.a.fine(AbstractUrlObjectCache.k[0] + var1_1 + "'");
                        }
                        catch (InterruptedException v20) {
                            throw AbstractUrlObjectCache.a(v20);
                        }
                    }
                    try {
                        var5_6.a();
                        v21 = v22;
                        v23 = v22;
                        v24 = null == var5_6.i ? 3 : 0;
                    }
                    catch (InterruptedException v25) {
                        throw AbstractUrlObjectCache.a(v25);
                    }
                    v21(v24, var5_6);
                    return v23;
                }
                var5_6.b = var3_3;
                var6_4 = true;
            }
            try {
                try {
                    if (AbstractUrlObjectCache.b || var6_4) break block69;
                }
                catch (InterruptedException v26) {
                    throw AbstractUrlObjectCache.a(v26);
                }
                throw new AssertionError();
            }
            catch (InterruptedException v27) {
                throw AbstractUrlObjectCache.a(v27);
            }
        }
        try {
            if (this.a.isLoggable(Level.FINE)) {
                this.a.fine(AbstractUrlObjectCache.k[11] + var1_1 + AbstractUrlObjectCache.k[6]);
            }
        }
        catch (InterruptedException v28) {
            throw AbstractUrlObjectCache.a(v28);
        }
        return this.a(var1_1, var5_6);
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     * Enabled force condition propagation
     * Lifted jumps to return sites
     */
    private FetchResult<UT> a(String string, AbstractCacheEntry<UT> abstractCacheEntry) {
        boolean bl2 = false;
        try {
            this.onStaleEntryAboutToBeReplaced(abstractCacheEntry, string);
            bl2 = true;
        }
        catch (Throwable throwable) {
            try {
                if (bl2) throw throwable;
                this.b(abstractCacheEntry, string);
                throw throwable;
            }
            catch (RuntimeException runtimeException) {
                throw AbstractUrlObjectCache.a(runtimeException);
            }
        }
        try {
            if (bl2) return this.a(abstractCacheEntry, string);
            this.b(abstractCacheEntry, string);
            return this.a(abstractCacheEntry, string);
        }
        catch (RuntimeException runtimeException) {
            throw AbstractUrlObjectCache.a(runtimeException);
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     * Could not resolve type clashes
     * Unable to fully structure code
     */
    public void serviceCache(Executor var1_1, long var2_2) {
        block14: {
            this.a.log(Level.FINEST, AbstractUrlObjectCache.k[12]);
            var4_3 = Thread.currentThread().getId();
            var6_4 = this.getReadLock();
            var7_5 = this.clock.currentTimeMillis() + var2_2;
            var9_6 = new ArrayList<AbstractCacheEntry<UT>>();
            var6_4.lock();
            try {
                block15: {
                    var10_7 = this.cacheIterator();
                    try {
                        if (var10_7 == null) break block14;
lbl11:
                        // 3 sources

                        while (var10_7.hasNext()) {
                            break block15;
                        }
                        break block14;
                    }
                    catch (RuntimeException v0) {
                        throw AbstractUrlObjectCache.a(v0);
                    }
                }
                var11_9 = var10_7.next();
                if (var11_9 == null) ** GOTO lbl11
                var12_10 = var11_9;
                synchronized (var12_10) {
                    block16: {
                        if (var11_9.b != 0L) break block16;
                        if (var11_9.c <= 0) break block16;
                        try {
                            block17: {
                                if (!this.a(var11_9, var7_5)) break block16;
                                break block17;
                                catch (RuntimeException v1) {
                                    throw AbstractUrlObjectCache.a(v1);
                                }
                            }
                            var9_6.add(var11_9);
                        }
                        catch (RuntimeException v2) {
                            throw AbstractUrlObjectCache.a(v2);
                        }
                    }
                    ** GOTO lbl11
                }
            }
            finally {
                var6_4.unlock();
            }
        }
        var10_8 = var7_5 - TimeUnit.SECONDS.toMillis(30L);
        for (AbstractCacheEntry var13_12 : var9_6) {
            var1_1.execute(new a(this, var10_8, var13_12, var4_3));
        }
    }

    @Override
    public UT resolveUrl(Audit audit, String string) throws IOException, ParseException {
        IOException iOException;
        FetchResult<UT> fetchResult;
        block13: {
            fetchResult = this.fetchCached(string, this.defaultWaitMode);
            UT UT = fetchResult.getUserObject();
            if (UT != null) {
                block11: {
                    iOException = fetchResult.getException();
                    try {
                        block12: {
                            try {
                                try {
                                    if (iOException == null) break block11;
                                    if (this.maxStaleCacheAge == -1L) break block12;
                                }
                                catch (IOException iOException2) {
                                    throw AbstractUrlObjectCache.a(iOException2);
                                }
                                if (this.clock.currentTimeMillis() - fetchResult.getUserObjectCreated() > this.maxStaleCacheAge) break block13;
                            }
                            catch (IOException iOException3) {
                                throw AbstractUrlObjectCache.a(iOException3);
                            }
                        }
                        audit.logAndAudit((AuditDetailMessage)SystemMessages.URL_OBJECT_CACHE_REUSE, new String[]{this.resourceDescription, string, ExceptionUtils.getMessage((Throwable)iOException)}, ExceptionUtils.getDebugException((Throwable)iOException));
                        return UT;
                    }
                    catch (IOException iOException4) {
                        throw AbstractUrlObjectCache.a(iOException4);
                    }
                }
                return UT;
            }
        }
        if ((iOException = fetchResult.getException()) != null) {
            ParseException parseException = (ParseException)ExceptionUtils.getCauseIfCausedBy((Throwable)iOException, ParseException.class);
            try {
                if (parseException != null) {
                    throw parseException;
                }
            }
            catch (IOException iOException5) {
                throw AbstractUrlObjectCache.a(iOException5);
            }
            throw iOException;
        }
        throw new IOException(k[9] + string);
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    public UT evict(String string) {
        Lock lock = this.getWriteLock();
        lock.lock();
        try {
            UT UT;
            AbstractCacheEntry<UT> abstractCacheEntry = this.cacheRemove(string);
            try {
                UT = abstractCacheEntry == null ? null : (UT)abstractCacheEntry.g;
            }
            catch (RuntimeException runtimeException) {
                throw AbstractUrlObjectCache.a(runtimeException);
            }
            UT UT2 = UT;
            return UT2;
        }
        finally {
            lock.unlock();
        }
    }

    private boolean a(AbstractCacheEntry<UT> abstractCacheEntry, long l2) {
        boolean bl2;
        block26: {
            block25: {
                boolean bl3;
                boolean bl4;
                block24: {
                    block23: {
                        boolean bl5;
                        boolean bl6;
                        block22: {
                            block21: {
                                boolean bl7;
                                block20: {
                                    boolean bl8;
                                    boolean bl9;
                                    try {
                                        bl9 = abstractCacheEntry.g != null;
                                    }
                                    catch (RuntimeException runtimeException) {
                                        throw AbstractUrlObjectCache.a(runtimeException);
                                    }
                                    bl7 = bl9;
                                    try {
                                        bl8 = abstractCacheEntry.i != null;
                                    }
                                    catch (RuntimeException runtimeException) {
                                        throw AbstractUrlObjectCache.a(runtimeException);
                                    }
                                    bl6 = bl8;
                                    try {
                                        try {
                                            if (bl7 || bl6) break block20;
                                        }
                                        catch (RuntimeException runtimeException) {
                                            throw AbstractUrlObjectCache.a(runtimeException);
                                        }
                                        return true;
                                    }
                                    catch (RuntimeException runtimeException) {
                                        throw AbstractUrlObjectCache.a(runtimeException);
                                    }
                                }
                                try {
                                    try {
                                        if (bl7 && l2 - abstractCacheEntry.h < this.maxCacheAge) break block21;
                                    }
                                    catch (RuntimeException runtimeException) {
                                        throw AbstractUrlObjectCache.a(runtimeException);
                                    }
                                    bl5 = true;
                                    break block22;
                                }
                                catch (RuntimeException runtimeException) {
                                    throw AbstractUrlObjectCache.a(runtimeException);
                                }
                            }
                            bl5 = false;
                        }
                        bl4 = bl5;
                        try {
                            try {
                                if (bl6 && l2 - abstractCacheEntry.j < this.maxCacheAge) break block23;
                            }
                            catch (RuntimeException runtimeException) {
                                throw AbstractUrlObjectCache.a(runtimeException);
                            }
                            bl3 = true;
                            break block24;
                        }
                        catch (RuntimeException runtimeException) {
                            throw AbstractUrlObjectCache.a(runtimeException);
                        }
                    }
                    bl3 = false;
                }
                boolean bl10 = bl3;
                try {
                    try {
                        if (!bl10 || !bl4) break block25;
                    }
                    catch (RuntimeException runtimeException) {
                        throw AbstractUrlObjectCache.a(runtimeException);
                    }
                    bl2 = true;
                    break block26;
                }
                catch (RuntimeException runtimeException) {
                    throw AbstractUrlObjectCache.a(runtimeException);
                }
            }
            bl2 = false;
        }
        return bl2;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     * Loose catch block
     */
    private FetchResult<UT> a(AbstractCacheEntry<UT> abstractCacheEntry, String string) {
        UT UT;
        String string2;
        String string3;
        long l2;
        boolean bl2;
        long l3;
        block20: {
            String string4;
            long l4;
            String string5;
            Object UT2;
            this.a.log(Level.FINER, () -> k[8] + string);
            l3 = this.clock.currentTimeMillis();
            AbstractCacheEntry<UT> abstractCacheEntry2 = abstractCacheEntry;
            synchronized (abstractCacheEntry2) {
                UT2 = abstractCacheEntry.g;
                string5 = abstractCacheEntry.e;
                l4 = abstractCacheEntry.d;
                string4 = abstractCacheEntry.f;
            }
            bl2 = false;
            DatedUserObject<UT> datedUserObject = this.doGet(string, string5, l4, string4);
            l2 = l3;
            string3 = datedUserObject.getLastModified();
            string2 = datedUserObject.getETag();
            UT = datedUserObject.getUserObject();
            if (UT != null) break block20;
            UT = UT2;
            if (string5 == null) break block20;
            try {
                block21: {
                    if (string3 == null) break block20;
                    break block21;
                    catch (IOException iOException) {
                        throw AbstractUrlObjectCache.a(iOException);
                    }
                }
                if (string5.equals(string3)) break block20;
            }
            catch (IOException iOException) {
                throw AbstractUrlObjectCache.a(iOException);
            }
            l2 = 0L;
            string3 = null;
        }
        FetchResult<UT> fetchResult = this.a(abstractCacheEntry, l3, l2, string3, string2, UT);
        bl2 = true;
        Date date = new Date(l3);
        this.a.log(Level.FINE, () -> {
            String[] stringArray = k;
            return stringArray[3] + abstractCacheEntry.a + stringArray[7] + String.valueOf(date);
        });
        FetchResult<UT> fetchResult2 = fetchResult;
        try {
            if (!bl2) {
                this.b(abstractCacheEntry, string);
            }
        }
        catch (IOException iOException) {
            throw AbstractUrlObjectCache.a(iOException);
        }
        return fetchResult2;
        catch (IOException iOException) {
            FetchResult<UT> fetchResult3;
            try {
                FetchResult<UT> fetchResult4 = this.a(abstractCacheEntry, iOException);
                bl2 = true;
                fetchResult3 = fetchResult4;
            }
            catch (Throwable throwable) {
                try {
                    if (!bl2) {
                        this.b(abstractCacheEntry, string);
                    }
                }
                catch (IOException iOException2) {
                    throw AbstractUrlObjectCache.a(iOException2);
                }
                throw throwable;
            }
            try {
                if (!bl2) {
                    this.b(abstractCacheEntry, string);
                }
            }
            catch (IOException iOException3) {
                throw AbstractUrlObjectCache.a(iOException3);
            }
            return fetchResult3;
        }
    }

    protected abstract DatedUserObject<UT> doGet(String var1, String var2, long var3, String var5) throws IOException;

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private FetchResult<UT> a(AbstractCacheEntry<UT> abstractCacheEntry, IOException iOException) {
        AbstractCacheEntry<UT> abstractCacheEntry2 = abstractCacheEntry;
        synchronized (abstractCacheEntry2) {
            abstractCacheEntry.c = 0;
            abstractCacheEntry.i = iOException;
            abstractCacheEntry.j = this.clock.currentTimeMillis();
            abstractCacheEntry.b = 0L;
            abstractCacheEntry.notifyAll();
            return new FetchResult<UT>(0, abstractCacheEntry);
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private void b(AbstractCacheEntry<UT> abstractCacheEntry, String string) {
        AbstractCacheEntry<UT> abstractCacheEntry2 = abstractCacheEntry;
        synchronized (abstractCacheEntry2) {
            abstractCacheEntry.c = 0;
            if (abstractCacheEntry.i == null) {
                abstractCacheEntry.i = new IOException(k[5] + string);
                abstractCacheEntry.j = this.clock.currentTimeMillis();
            }
            abstractCacheEntry.b = 0L;
            abstractCacheEntry.notifyAll();
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    private FetchResult<UT> a(AbstractCacheEntry<UT> abstractCacheEntry, long l2, long l3, String string, String string2, UT UT) {
        AbstractCacheEntry<UT> abstractCacheEntry2 = abstractCacheEntry;
        synchronized (abstractCacheEntry2) {
            abstractCacheEntry.c = 0;
            abstractCacheEntry.d = l3;
            abstractCacheEntry.e = string;
            abstractCacheEntry.f = string2;
            abstractCacheEntry.i = null;
            abstractCacheEntry.j = 0L;
            abstractCacheEntry.g = UT;
            abstractCacheEntry.h = l2;
            abstractCacheEntry.b = 0L;
            abstractCacheEntry.notifyAll();
            return new FetchResult<UT>(2, abstractCacheEntry);
        }
    }

    /*
     * Unable to fully structure code
     */
    static {
        block12: {
            block11: {
                var5 = new String[16];
                var3_1 = 0;
                var2_2 = "y]ZL?/\u0001E_\u000eZ,\"\u0000N\\\u000e\\#5\u001aR\u0018HV?a=yt\u000e\u001eFbVZ\\?3\u001d[LK]m6\u0000BTK\u0019: \u0001_Q@^m'\u0007Y\u0018AM%$\u001a\u000bLFK( \f\u000bLA\u0019+(\u0006BKF\u0019).\u001fETAX)(\u0006L\u0018{k\u0001aO(\f\u0018GJm/\u0007_\u0018GWm5\u0000N\u0018MX.)\r\u0010\u0018MV#5\tHLGW*a\u001bNJX\\?\u001dy]HK(2\u0000N\\\u000eM%$HHYMQ(%HNVZK4aR\u000b\u0005~jb\u0019jJ~VKA=$\u000b_]J\u0019$/\u001cNJ@X!a\rYJAKm6\u0000BTK\u0019,5\u001cNU^M$/\u000f\u000bLA\u0019).\u001fETAX)a\rSLKK# \u0004\u000bJKJ\"4\u001aH]\u0014\u0019\u001f\f\u0018GJm5\u0007D\u0018AU)zHHW@M,\"\u001cBVI\u0019>$\u001a]]\\\u0004\u000bYZ\u0019\u0012{WBU$/\u000f\u000bLF\\m\u0014:g\u0018\u0014\u0019!eW\u000eL>$\u001a\u000bWLS(\"\u001c\u000bYXX$-\tITK\u0019+.\u001a\u000bM\\Um$y]ML?2\u0001]]\u000eV?a\u000bBJML! \u001a\u000b^KM.)HD^\u000el\u001f\rR\u000b\u0015hYMQ(a\rEL\\@m'\u0007Y\u0018{k\u0001aO\u001c{JAZ(2\u001bBVI\u00199)\r\u000b[OZ%$HY]HK(2\u00004|YGM$/\u000f\u000b^AKm.\u001cC]\\\u00199)\u001aNYJ\u00199.HHW@M,\"\u001c\u000bKKK;$\u001a\u000b^AKm\u0014:g\u0018\t";
                var4_3 = "y]ZL?/\u0001E_\u000eZ,\"\u0000N\\\u000e\\#5\u001aR\u0018HV?a=yt\u000e\u001eFbVZ\\?3\u001d[LK]m6\u0000BTK\u0019: \u0001_Q@^m'\u0007Y\u0018AM%$\u001a\u000bLFK( \f\u000bLA\u0019+(\u0006BKF\u0019).\u001fETAX)(\u0006L\u0018{k\u0001aO(\f\u0018GJm/\u0007_\u0018GWm5\u0000N\u0018MX.)\r\u0010\u0018MV#5\tHLGW*a\u001bNJX\\?\u001dy]HK(2\u0000N\\\u000eM%$HHYMQ(%HNVZK4aR\u000b\u0005~jb\u0019jJ~VKA=$\u000b_]J\u0019$/\u001cNJ@X!a\rYJAKm6\u0000BTK\u0019,5\u001cNU^M$/\u000f\u000bLA\u0019).\u001fETAX)a\rSLKK# \u0004\u000bJKJ\"4\u001aH]\u0014\u0019\u001f\f\u0018GJm5\u0007D\u0018AU)zHHW@M,\"\u001cBVI\u0019>$\u001a]]\\\u0004\u000bYZ\u0019\u0012{WBU$/\u000f\u000bLF\\m\u0014:g\u0018\u0014\u0019!eW\u000eL>$\u001a\u000bWLS(\"\u001c\u000bYXX$-\tITK\u0019+.\u001a\u000bM\\Um$y]ML?2\u0001]]\u000eV?a\u000bBJML! \u001a\u000b^KM.)HD^\u000el\u001f\rR\u000b\u0015hYMQ(a\rEL\\@m'\u0007Y\u0018{k\u0001aO\u001c{JAZ(2\u001bBVI\u00199)\r\u000b[OZ%$HY]HK(2\u00004|YGM$/\u000f\u000b^AKm.\u001cC]\\\u00199)\u001aNYJ\u00199.HHW@M,\"\u001c\u000bKKK;$\u001a\u000b^AKm\u0014:g\u0018\t".length();
                var1_4 = 32;
                var0_5 = -1;
lbl7:
                // 2 sources

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

                while (true) {
                    var5[var3_1++] = AbstractUrlObjectCache.a(v0, AbstractUrlObjectCache.a(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    var2_2 = "Njm{\b\u00186rh9m\u001b\u00157yk9k\u0014\u0002-e/\u007fa\bV\nNC9)\";/ng\u000e\u001e0i{9y\u001b\u001f+ua~.\u001c\u0019-<`mf\u001f\u0004\u007fhgkk\u001b\u0012";
                    var4_3 = "Njm{\b\u00186rh9m\u001b\u00157yk9k\u0014\u0002-e/\u007fa\bV\nNC9)\";/ng\u000e\u001e0i{9y\u001b\u001f+ua~.\u001c\u0019-<`mf\u001f\u0004\u007fhgkk\u001b\u0012".length();
                    var1_4 = 32;
                    var0_5 = -1;
lbl22:
                    // 2 sources

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

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

                ** continue;
            }
        }
        AbstractUrlObjectCache.k = var5;
        try {
            v5 = AbstractUrlObjectCache.class.desiredAssertionStatus() == false;
        }
        catch (RuntimeException v6) {
            throw AbstractUrlObjectCache.a(v6);
        }
        AbstractUrlObjectCache.b = v5;
        AbstractUrlObjectCache.WAIT_NEVER = new WaitMode();
        AbstractUrlObjectCache.WAIT_INITIAL = new WaitMode();
        AbstractUrlObjectCache.WAIT_LATEST = new WaitMode();
    }

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

    private static char[] a(String string) {
        char[] cArray = string.toCharArray();
        if (cArray.length < 2) {
            cArray = cArray;
            cArray[0] = (char)(cArray[0] ^ 0x10);
        }
        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 -> 83;
                    case 1 -> 64;
                    case 2 -> 86;
                    case 3 -> 65;
                    case 4 -> 53;
                    case 5 -> 57;
                    default -> 16;
                })));
                ++n3;
                n4 = n4;
            } while (n4 > n3);
        }
        return new String(cArray2).intern();
    }

    public static class WaitMode {
        private WaitMode() {
        }
    }

    protected static class AbstractCacheEntry<UT> {
        private final String a;
        private long b;
        private int c;
        private long d;
        private String e;
        private String f;
        private UT g;
        private long h;
        private IOException i;
        private long j;

        private AbstractCacheEntry(String string) {
            this.a = string;
        }

        public UT getUserObject() {
            return this.g;
        }

        private void a() {
            if (this.c < Integer.MAX_VALUE) {
                ++this.c;
            }
        }
    }

    public static class FetchResult<UT> {
        private final int a;
        private final UT b;
        private final long c;
        private final IOException d;
        private final long e;

        public FetchResult(int n2, AbstractCacheEntry<UT> abstractCacheEntry) {
            this.a = n2;
            this.b = abstractCacheEntry.g;
            this.c = abstractCacheEntry.h;
            this.d = abstractCacheEntry.i;
            this.e = abstractCacheEntry.j;
        }

        public int getResult() {
            return this.a;
        }

        public UT getUserObject() {
            return this.b;
        }

        public long getUserObjectCreated() {
            return this.c;
        }

        public IOException getException() {
            return this.d;
        }

        public long getExceptionCreated() {
            return this.e;
        }
    }

    protected static final class DatedUserObject<UT> {
        private final String a;
        private final String b;
        private final UT c;

        public DatedUserObject(UT UT, String string, String string2) {
            this.a = string;
            this.c = UT;
            this.b = string2;
        }

        public String getLastModified() {
            return this.a;
        }

        public String getETag() {
            return this.b;
        }

        public UT getUserObject() {
            return this.c;
        }
    }

    public static interface UserObjectFactory<UT> {
        public UT createUserObject(String var1, UserObjectSource var2) throws IOException;
    }

    public static interface UserObjectSource {
        public ContentTypeHeader getContentType();

        public String getString(boolean var1) throws IOException;

        public byte[] getBytes() throws IOException;
    }
}