/*
 * Decompiled with CFR 0.152.
 * 
 * Could not load the following classes:
 *  com.l7tech.gateway.common.audit.AssertionMessages
 *  com.l7tech.gateway.common.audit.AuditDetailMessage
 *  com.l7tech.message.Message
 *  com.l7tech.message.TcpKnob
 *  com.l7tech.policy.assertion.AssertionStatus
 *  com.l7tech.policy.assertion.credential.LoginCredentials
 *  com.l7tech.policy.assertion.xmlsec.HasOptionalSamlSignature
 *  com.l7tech.policy.assertion.xmlsec.RequireSaml
 *  com.l7tech.policy.assertion.xmlsec.RequireWssSaml
 *  com.l7tech.security.saml.SamlConstants
 *  com.l7tech.security.token.SamlSecurityToken
 *  com.l7tech.security.token.SecurityToken
 *  com.l7tech.security.xml.SecurityTokenResolver
 *  com.l7tech.security.xml.processor.ProcessorResult
 *  com.l7tech.util.Config
 *  com.l7tech.util.ExceptionUtils
 *  com.l7tech.util.Pair
 *  com.l7tech.util.TimeUnit
 *  com.l7tech.util.Triple
 *  jakarta.inject.Inject
 *  jakarta.inject.Named
 *  org.jetbrains.annotations.NotNull
 */
package com.l7tech.server.policy.assertion.xmlsec;

import com.l7tech.gateway.common.audit.AssertionMessages;
import com.l7tech.gateway.common.audit.AuditDetailMessage;
import com.l7tech.message.Message;
import com.l7tech.message.TcpKnob;
import com.l7tech.policy.assertion.AssertionStatus;
import com.l7tech.policy.assertion.credential.LoginCredentials;
import com.l7tech.policy.assertion.xmlsec.HasOptionalSamlSignature;
import com.l7tech.policy.assertion.xmlsec.RequireSaml;
import com.l7tech.policy.assertion.xmlsec.RequireWssSaml;
import com.l7tech.security.saml.SamlConstants;
import com.l7tech.security.token.SamlSecurityToken;
import com.l7tech.security.token.SecurityToken;
import com.l7tech.security.xml.SecurityTokenResolver;
import com.l7tech.security.xml.processor.ProcessorResult;
import com.l7tech.server.extension.provider.sharedstate.SharedStateProviderLowMemoryException;
import com.l7tech.server.message.AuthenticationContext;
import com.l7tech.server.message.PolicyEnforcementContext;
import com.l7tech.server.policy.assertion.AbstractMessageTargetableServerAssertion;
import com.l7tech.server.policy.assertion.xmlsec.SamlAssertionValidate;
import com.l7tech.server.util.MessageId;
import com.l7tech.server.util.MessageIdManager;
import com.l7tech.util.Config;
import com.l7tech.util.ExceptionUtils;
import com.l7tech.util.Pair;
import com.l7tech.util.TimeUnit;
import com.l7tech.util.Triple;
import jakarta.inject.Inject;
import jakarta.inject.Named;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import org.jetbrains.annotations.NotNull;

public abstract class ServerRequireSaml<AT extends RequireSaml>
extends AbstractMessageTargetableServerAssertion<AT> {
    protected static final long CACHE_ID_EXTRA_TIME_MILLIS = 300000L;
    protected static final long DEFAULT_EXPIRY = 300000L;
    protected final SamlAssertionValidate assertionValidate;
    @Inject
    protected Config config;
    @Inject
    @Named(value="securityTokenResolver")
    protected SecurityTokenResolver securityTokenResolver;
    @Inject
    protected MessageIdManager messageIdManager;
    protected final String[] variablesUsed;
    private static final String[] d;

    public ServerRequireSaml(AT AT) {
        super(AT);
        this.assertionValidate = new SamlAssertionValidate((RequireSaml)AT);
        this.variablesUsed = AT.getVariablesUsed();
    }

    @NotNull
    protected abstract Triple<AssertionStatus, ProcessorResult, SamlSecurityToken> getSamlSecurityTokenAndContext(Message var1, String var2, AuthenticationContext var3) throws IOException;

    /*
     * Could not resolve type clashes
     * Unable to fully structure code
     */
    @Override
    protected AssertionStatus doCheckRequest(PolicyEnforcementContext var1_1, Message var2_2, String var3_3, AuthenticationContext var4_4) throws IOException {
        block98: {
            block100: {
                block99: {
                    block97: {
                        block96: {
                            block95: {
                                block94: {
                                    block93: {
                                        block109: {
                                            block92: {
                                                block110: {
                                                    block90: {
                                                        block91: {
                                                            block88: {
                                                                block89: {
                                                                    block87: {
                                                                        block86: {
                                                                            block85: {
                                                                                block84: {
                                                                                    block83: {
                                                                                        block82: {
                                                                                            block81: {
                                                                                                block80: {
                                                                                                    block78: {
                                                                                                        block79: {
                                                                                                            block101: {
                                                                                                                var5_5 = this.getSamlSecurityTokenAndContext(var2_2, var3_3, var4_4);
                                                                                                                if (var5_5.left == AssertionStatus.NONE) break block78;
                                                                                                                if (!this.isRequest()) break block79;
                                                                                                                break block101;
                                                                                                                catch (MessageIdManager.DuplicateMessageIdException v0) {
                                                                                                                    throw ServerRequireSaml.a(v0);
                                                                                                                }
                                                                                                            }
                                                                                                            try {
                                                                                                                block102: {
                                                                                                                    if (!AssertionStatus.AUTH_REQUIRED.equals(var5_5.left)) break block79;
                                                                                                                    break block102;
                                                                                                                    catch (MessageIdManager.DuplicateMessageIdException v1) {
                                                                                                                        throw ServerRequireSaml.a(v1);
                                                                                                                    }
                                                                                                                }
                                                                                                                var1_1.setAuthenticationMissing();
                                                                                                            }
                                                                                                            catch (MessageIdManager.DuplicateMessageIdException v2) {
                                                                                                                throw ServerRequireSaml.a(v2);
                                                                                                            }
                                                                                                        }
                                                                                                        return (AssertionStatus)var5_5.left;
                                                                                                    }
                                                                                                    var6_6 = (ProcessorResult)var5_5.middle;
                                                                                                    var7_7 = (SamlSecurityToken)var5_5.right;
                                                                                                    var8_8 = false;
                                                                                                    if (var7_7 == null) break block80;
                                                                                                    try {
                                                                                                        block103: {
                                                                                                            if (var7_7.getVersionId() != 1) break block80;
                                                                                                            break block103;
                                                                                                            catch (MessageIdManager.DuplicateMessageIdException v3) {
                                                                                                                throw ServerRequireSaml.a(v3);
                                                                                                            }
                                                                                                        }
                                                                                                        v4 = true;
                                                                                                        break block81;
                                                                                                    }
                                                                                                    catch (MessageIdManager.DuplicateMessageIdException v5) {
                                                                                                        throw ServerRequireSaml.a(v5);
                                                                                                    }
                                                                                                }
                                                                                                v4 = false;
                                                                                            }
                                                                                            var9_9 = v4;
                                                                                            if (((RequireSaml)this.assertion).getVersion() == null) break block82;
                                                                                            try {
                                                                                                block104: {
                                                                                                    if (((RequireSaml)this.assertion).getVersion() != 0) break block82;
                                                                                                    break block104;
                                                                                                    catch (MessageIdManager.DuplicateMessageIdException v6) {
                                                                                                        throw ServerRequireSaml.a(v6);
                                                                                                    }
                                                                                                }
                                                                                                v7 = true;
                                                                                                break block83;
                                                                                            }
                                                                                            catch (MessageIdManager.DuplicateMessageIdException v8) {
                                                                                                throw ServerRequireSaml.a(v8);
                                                                                            }
                                                                                        }
                                                                                        v7 = false;
                                                                                    }
                                                                                    var10_10 = v7;
                                                                                    if (((RequireSaml)this.assertion).getVersion() == null) ** GOTO lbl65
                                                                                    try {
                                                                                        block105: {
                                                                                            if (((RequireSaml)this.assertion).getVersion() != 1) break block84;
                                                                                            break block105;
                                                                                            catch (MessageIdManager.DuplicateMessageIdException v9) {
                                                                                                throw ServerRequireSaml.a(v9);
                                                                                            }
                                                                                        }
                                                                                        v10 = true;
                                                                                        break block85;
                                                                                    }
                                                                                    catch (MessageIdManager.DuplicateMessageIdException v11) {
                                                                                        throw ServerRequireSaml.a(v11);
                                                                                    }
                                                                                }
                                                                                v10 = false;
                                                                            }
                                                                            var11_11 = v10;
                                                                            if (((RequireSaml)this.assertion).getVersion() == null) break block86;
                                                                            try {
                                                                                block106: {
                                                                                    if (((RequireSaml)this.assertion).getVersion() != 2) break block86;
                                                                                    break block106;
                                                                                    catch (MessageIdManager.DuplicateMessageIdException v12) {
                                                                                        throw ServerRequireSaml.a(v12);
                                                                                    }
                                                                                }
                                                                                v13 = true;
                                                                                break block87;
                                                                            }
                                                                            catch (MessageIdManager.DuplicateMessageIdException v14) {
                                                                                throw ServerRequireSaml.a(v14);
                                                                            }
                                                                        }
                                                                        v13 = false;
                                                                    }
                                                                    var12_12 = v13;
                                                                    if (!var9_9) break block88;
                                                                    try {
                                                                        block107: {
                                                                            if (var10_10) break block89;
                                                                            break block107;
                                                                            catch (MessageIdManager.DuplicateMessageIdException v15) {
                                                                                throw ServerRequireSaml.a(v15);
                                                                            }
                                                                        }
                                                                        if (!var11_11) break block88;
                                                                    }
                                                                    catch (MessageIdManager.DuplicateMessageIdException v16) {
                                                                        throw ServerRequireSaml.a(v16);
                                                                    }
                                                                }
                                                                var8_8 = true;
                                                                break block90;
                                                            }
                                                            if (var9_9) break block90;
                                                            try {
                                                                block108: {
                                                                    if (var10_10) break block91;
                                                                    break block108;
                                                                    catch (MessageIdManager.DuplicateMessageIdException v17) {
                                                                        throw ServerRequireSaml.a(v17);
                                                                    }
                                                                }
                                                                if (!var12_12) break block90;
                                                            }
                                                            catch (MessageIdManager.DuplicateMessageIdException v18) {
                                                                throw ServerRequireSaml.a(v18);
                                                            }
                                                        }
                                                        var8_8 = true;
                                                    }
                                                    if (var7_7 == null) ** GOTO lbl128
                                                    if (var8_8) break block109;
                                                    break block110;
                                                    catch (MessageIdManager.DuplicateMessageIdException v19) {
                                                        throw ServerRequireSaml.a(v19);
                                                    }
                                                }
                                                try {
                                                    block111: {
                                                        this.logAndAudit((AuditDetailMessage)AssertionMessages.SAML_AUTHN_STMT_NO_ACCEPTABLE_SAML_ASSERTION);
                                                        if (!this.isRequest()) break block92;
                                                        break block111;
                                                        catch (MessageIdManager.DuplicateMessageIdException v20) {
                                                            throw ServerRequireSaml.a(v20);
                                                        }
                                                    }
                                                    var1_1.setAuthenticationMissing();
                                                }
                                                catch (MessageIdManager.DuplicateMessageIdException v21) {
                                                    throw ServerRequireSaml.a(v21);
                                                }
                                            }
                                            return AssertionStatus.AUTH_REQUIRED;
                                        }
                                        var13_13 = new ArrayList<SamlAssertionValidate.Error>();
                                        var14_14 = new ArrayList<Pair<String, String[]>>();
                                        var15_15 = var4_4.getLastCredentials();
                                        if (var2_2.getKnob(TcpKnob.class) == null) break block93;
                                        try {
                                            block112: {
                                                if (var2_2.getTcpKnob().getRemoteAddress() == null) break block93;
                                                break block112;
                                                catch (MessageIdManager.DuplicateMessageIdException v22) {
                                                    throw ServerRequireSaml.a(v22);
                                                }
                                            }
                                            v23 = Collections.singleton(var2_2.getTcpKnob().getRemoteAddress());
                                            break block94;
                                        }
                                        catch (MessageIdManager.DuplicateMessageIdException v24) {
                                            throw ServerRequireSaml.a(v24);
                                        }
                                    }
                                    v23 = null;
                                }
                                var16_16 = v23;
                                var17_17 = var1_1.getVariableMap(this.variablesUsed, this.getAudit());
                                v25 = this.getAudit();
                                if (!(this.assertion instanceof HasOptionalSamlSignature)) ** GOTO lbl171
                                try {
                                    block113: {
                                        if (!((HasOptionalSamlSignature)this.assertion).isRequireDigitalSignature()) break block95;
                                        break block113;
                                        catch (MessageIdManager.DuplicateMessageIdException v26) {
                                            throw ServerRequireSaml.a(v26);
                                        }
                                    }
                                    v27 = true;
                                    break block96;
                                }
                                catch (MessageIdManager.DuplicateMessageIdException v28) {
                                    throw ServerRequireSaml.a(v28);
                                }
                            }
                            v27 = false;
                        }
                        this.assertionValidate.validate(var15_15, var6_6, var13_13, var14_14, var16_16, var17_17, v25, v27);
                        if (var13_13.size() <= 0) break block97;
                        var18_18 = new StringBuilder();
                        var19_20 = true;
                        for (E var21_25 : var13_13) {
                            try {
                                if (!var19_20) {
                                    var18_18.append(ServerRequireSaml.d[3]);
                                }
                            }
                            catch (MessageIdManager.DuplicateMessageIdException v29) {
                                throw ServerRequireSaml.a(v29);
                            }
                            var22_27 = (SamlAssertionValidate.Error)var21_25;
                            var18_18.append(var22_27.toString());
                            var19_20 = false;
                        }
                        this.logAndAudit((AuditDetailMessage)AssertionMessages.SAML_STMT_VALIDATE_FAILED, new String[]{var18_18.toString()});
                        return AssertionStatus.FALSIFIED;
                    }
                    var18_19 = ((RequireSaml)this.assertion).getMaxExpiry();
                    if (var18_19 != 0L) {
                        var20_22 = Calendar.getInstance(SamlAssertionValidate.UTC_TIME_ZONE);
                        var21_26 = var7_7.getIssueInstant();
                        try {
                            if (var21_26 == null) {
                                this.logAndAudit((AuditDetailMessage)AssertionMessages.SAML_STMT_VALIDATE_FAILED, new String[]{ServerRequireSaml.d[4]});
                                return AssertionStatus.FALSIFIED;
                            }
                        }
                        catch (MessageIdManager.DuplicateMessageIdException v30) {
                            throw ServerRequireSaml.a(v30);
                        }
                        var22_28 /* !! */  = SamlAssertionValidate.b((Calendar)var21_26);
                        try {
                            if (var20_22.before(var22_28 /* !! */ )) {
                                this.logAndAudit((AuditDetailMessage)AssertionMessages.SAML_STMT_VALIDATE_FAILED, new String[]{ServerRequireSaml.d[2]});
                                return AssertionStatus.FALSIFIED;
                            }
                        }
                        catch (MessageIdManager.DuplicateMessageIdException v31) {
                            throw ServerRequireSaml.a(v31);
                        }
                        var23_29 = var21_26;
                        if (var18_19 > (long)TimeUnit.MINUTES.getMultiplier()) {
                            var24_32 = (int)(var18_19 / (long)TimeUnit.MINUTES.getMultiplier());
                            var23_29.add(12, var24_32);
                            var25_34 = (int)(var18_19 % (long)TimeUnit.MINUTES.getMultiplier());
                            var23_29.add(14, var25_34);
                        } else {
                            var23_29.add(14, (int)var18_19);
                        }
                        var24_33 = SamlAssertionValidate.a((Calendar)var23_29);
                        try {
                            if (var20_22.after(var24_33)) {
                                this.logAndAudit((AuditDetailMessage)AssertionMessages.SAML_TOKEN_EXPIRATION_WARNING);
                                return AssertionStatus.FALSIFIED;
                            }
                        }
                        catch (MessageIdManager.DuplicateMessageIdException v32) {
                            throw ServerRequireSaml.a(v32);
                        }
                    }
                    if (!var7_7.isOneTimeUse()) break block98;
                    try {
                        block114: {
                            if (var7_7.getExpires() != null) break block99;
                            break block114;
                            catch (MessageIdManager.DuplicateMessageIdException v33) {
                                throw ServerRequireSaml.a(v33);
                            }
                        }
                        v34 = System.currentTimeMillis() + 300000L;
                        break block100;
                    }
                    catch (MessageIdManager.DuplicateMessageIdException v35) {
                        throw ServerRequireSaml.a(v35);
                    }
                }
                v34 = var7_7.getExpires().getTimeInMillis();
            }
            var20_23 = v34;
            var22_28 /* !! */  = new MessageId(this.a(SamlConstants.NS_SAML_PREFIX + "-" + var7_7.getUniqueId()), var20_23 + 300000L);
            try {
                this.messageIdManager.assertMessageIdIsUnique((MessageId)var22_28 /* !! */ );
            }
            catch (MessageIdManager.DuplicateMessageIdException var23_30) {
                v36 = new String[1];
                var26_35 = ServerRequireSaml.d;
                v36[0] = var26_35[0];
                this.logAndAudit((AuditDetailMessage)AssertionMessages.SAML_STMT_VALIDATE_FAILED, v36);
                return AssertionStatus.FALSIFIED;
            }
            catch (MessageIdManager.MessageIdCheckException var23_31) {
                try {
                    if (var23_31.getCause() instanceof SharedStateProviderLowMemoryException) {
                        this.logger.log(Level.WARNING, ServerRequireSaml.d[7] + ExceptionUtils.getMessage((Throwable)var23_31));
                        var1_1.setVariable(RequireSaml.VARIABLE_REASON_CODE, AssertionStatus.INSUFFICIENT_STORAGE.getNumeric());
                        return AssertionStatus.FAILED;
                    }
                }
                catch (MessageIdManager.DuplicateMessageIdException v37) {
                    throw ServerRequireSaml.a(v37);
                }
                v38 = new String[1];
                var26_36 = ServerRequireSaml.d;
                v38[0] = var26_36[6];
                this.logAndAudit((AuditDetailMessage)AssertionMessages.SAML_STMT_VALIDATE_FAILED, v38, var23_31);
                return AssertionStatus.FAILED;
            }
        }
        try {
            var4_4.addCredentials(LoginCredentials.makeLoginCredentials((SecurityToken)var7_7, RequireWssSaml.class));
        }
        catch (IllegalArgumentException var20_24) {
            var21_26 = ExceptionUtils.getMessage((Throwable)var20_24);
            try {
                if (var21_26.startsWith(ServerRequireSaml.d[5])) {
                    this.logAndAudit((AuditDetailMessage)AssertionMessages.SAML_NAME_IDENTIFIER_INVALID_DN, ExceptionUtils.getDebugException((Throwable)var20_24));
                    return AssertionStatus.FALSIFIED;
                }
            }
            catch (MessageIdManager.DuplicateMessageIdException v39) {
                throw ServerRequireSaml.a(v39);
            }
            throw var20_24;
        }
        try {
            if (!var14_14.isEmpty()) {
                this.a(var1_1, var14_14);
            }
        }
        catch (MessageIdManager.DuplicateMessageIdException v40) {
            throw ServerRequireSaml.a(v40);
        }
        return AssertionStatus.NONE;
    }

    void a(PolicyEnforcementContext policyEnforcementContext, Collection<Pair<String, String[]>> collection) {
        Map<String, List<String>> map = ServerRequireSaml.a(collection);
        ServerRequireSaml.a(policyEnforcementContext, map);
    }

    private static Map<String, List<String>> a(Collection<Pair<String, String[]>> collection) {
        LinkedHashMap<String, List<String>> linkedHashMap = new LinkedHashMap<String, List<String>>();
        for (Pair<String, String[]> pair : collection) {
            String string = d[1] + RequireWssSaml.toContextVariableName((String)((String)pair.left).toLowerCase());
            ArrayList<String> arrayList = (ArrayList<String>)linkedHashMap.get(string);
            if (arrayList == null) {
                arrayList = new ArrayList<String>();
            }
            arrayList.addAll(Arrays.asList((String[])pair.right));
            linkedHashMap.put(string, arrayList);
        }
        return linkedHashMap;
    }

    private static void a(PolicyEnforcementContext policyEnforcementContext, Map<String, List<String>> map) {
        for (Map.Entry<String, List<String>> entry : map.entrySet()) {
            String string = entry.getKey();
            List<String> list = entry.getValue();
            policyEnforcementContext.setVariable(string, list.toArray(new String[entry.getValue().size()]));
        }
    }

    private String a(String string) {
        return string.replace('/', '-').replace('+', '_');
    }

    private static MessageIdManager.DuplicateMessageIdException a(MessageIdManager.DuplicateMessageIdException duplicateMessageIdException) {
        return duplicateMessageIdException;
    }

    /*
     * Unable to fully structure code
     */
    static {
        block10: {
            block9: {
                var5 = new String[8];
                var3_1 = 0;
                var2_2 = "\u007f\b`w1<YB\u000b0z#6\u001c_\u0019yt>e\rE\fd;96YK\u0002b;\u001f+\u001cy\u0004}~\u00056\u001c\u0003\n^\f}w~$\rY\u001f>F~,]Wp\u0004\n^\bbo9*\u0017\r;qw9!\u0018Y\u0004\u007fup\u0000\u000b_\u0002b!p\u0011\u0011HMyh#0\u001c\r\u0004~h$$\u0017YMyhp+\u0016YMyup1\u0011HM`z#1W\u0002\u0001MD~,]Wp\u0004\n^\bbo9*\u0017\r;qw9!\u0018Y\u0004\u007fup\u0000\u000b_\u0002b!p\u0011\u0011HMyh#0\u001c\r\u0004~h$$\u0017YMyhp+\u0016YMck5&\u0010K\u0004u\u007f~\nd\u0003fz<,\u001d\r)^";
                var4_3 = "\u007f\b`w1<YB\u000b0z#6\u001c_\u0019yt>e\rE\fd;96YK\u0002b;\u001f+\u001cy\u0004}~\u00056\u001c\u0003\n^\f}w~$\rY\u001f>F~,]Wp\u0004\n^\bbo9*\u0017\r;qw9!\u0018Y\u0004\u007fup\u0000\u000b_\u0002b!p\u0011\u0011HMyh#0\u001c\r\u0004~h$$\u0017YMyhp+\u0016YMyup1\u0011HM`z#1W\u0002\u0001MD~,]Wp\u0004\n^\bbo9*\u0017\r;qw9!\u0018Y\u0004\u007fup\u0000\u000b_\u0002b!p\u0011\u0011HMyh#0\u001c\r\u0004~h$$\u0017YMyhp+\u0016YMck5&\u0010K\u0004u\u007f~\nd\u0003fz<,\u001d\r)^".length();
                var1_4 = 43;
                var0_5 = -1;
lbl7:
                // 2 sources

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

                while (true) {
                    var5[var3_1++] = ServerRequireSaml.c(v0, ServerRequireSaml.b(v2));
                    if ((var0_5 += var1_4) < var4_3) {
                        var1_4 = var2_2.charAt(var0_5);
                        ** continue;
                    }
                    var2_2 = ")^#5c$[\u0004I21xj_LJ>(1v]\u001c@0#1k^LM\")tvL\u0005C?zelY\u0018\f8)1bW\u001e\f\u001e4tPQ\u0001I\u0004)t\"?D0(t`\u0018\u001fX0.t$H\u001eC'3uaJL@>-1i]\u0001C##+$";
                    var4_3 = ")^#5c$[\u0004I21xj_LJ>(1v]\u001c@0#1k^LM\")tvL\u0005C?zelY\u0018\f8)1bW\u001e\f\u001e4tPQ\u0001I\u0004)t\"?D0(t`\u0018\u001fX0.t$H\u001eC'3uaJL@>-1i]\u0001C##+$".length();
                    var1_4 = 61;
                    var0_5 = -1;
lbl22:
                    // 2 sources

                    while (true) {
                        v0 = 54;
                        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++] = ServerRequireSaml.c(v0, ServerRequireSaml.b(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;
            }
        }
        ServerRequireSaml.d = var5;
    }

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

    /*
     * Handled impossible loop by duplicating code
     * Enabled aggressive block sorting
     */
    private static String c(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 -> 90;
                    case 1 -> 26;
                    case 2 -> 103;
                    case 3 -> 108;
                    case 4 -> 39;
                    case 5 -> 50;
                    default -> 14;
                })));
                ++n3;
                n4 = n4;
            } while (n4 > n3);
        }
        return new String(cArray2).intern();
    }
}