CrackMe.apk
Download file
package org.apache.commons.codec.language.bm;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.TreeMap;
import org.apache.commons.codec.language.bm.Languages;
import org.apache.commons.codec.language.bm.Rule;
public class PhoneticEngine {
private static final int DEFAULT_MAX_PHONEMES = 20;
private static final Map<NameType, Set<String>> NAME_PREFIXES;
private final boolean concat;
private final Lang lang;
private final int maxPhonemes;
private final NameType nameType;
private final RuleType ruleType;
static final class PhonemeBuilder {
private final Set<Rule.Phoneme> phonemes;
/* synthetic */ PhonemeBuilder(Set set, AnonymousClass1 r2) {
this((Set<Rule.Phoneme>) set);
}
public static PhonemeBuilder empty(Languages.LanguageSet languageSet) {
return new PhonemeBuilder(new Rule.Phoneme((CharSequence) "", languageSet));
}
private PhonemeBuilder(Rule.Phoneme phoneme) {
LinkedHashSet linkedHashSet = new LinkedHashSet();
this.phonemes = linkedHashSet;
linkedHashSet.add(phoneme);
}
private PhonemeBuilder(Set<Rule.Phoneme> set) {
this.phonemes = set;
}
public void append(CharSequence charSequence) {
for (Rule.Phoneme append : this.phonemes) {
append.append(charSequence);
}
}
public void apply(Rule.PhonemeExpr phonemeExpr, int i) {
LinkedHashSet linkedHashSet = new LinkedHashSet(i);
loop0:
for (Rule.Phoneme next : this.phonemes) {
Iterator<Rule.Phoneme> it = phonemeExpr.getPhonemes().iterator();
while (true) {
if (it.hasNext()) {
Rule.Phoneme next2 = it.next();
Languages.LanguageSet restrictTo = next.getLanguages().restrictTo(next2.getLanguages());
if (!restrictTo.isEmpty()) {
Rule.Phoneme phoneme = new Rule.Phoneme(next, next2, restrictTo);
if (linkedHashSet.size() < i) {
linkedHashSet.add(phoneme);
if (linkedHashSet.size() >= i) {
break loop0;
}
} else {
continue;
}
}
}
}
}
this.phonemes.clear();
this.phonemes.addAll(linkedHashSet);
}
public Set<Rule.Phoneme> getPhonemes() {
return this.phonemes;
}
public String makeString() {
StringBuilder sb = new StringBuilder();
for (Rule.Phoneme next : this.phonemes) {
if (sb.length() > 0) {
sb.append("|");
}
sb.append(next.getPhonemeText());
}
return sb.toString();
}
}
private static final class RulesApplication {
private final Map<String, List<Rule>> finalRules;
private boolean found;
private int i;
private final CharSequence input;
private final int maxPhonemes;
private PhonemeBuilder phonemeBuilder;
public RulesApplication(Map<String, List<Rule>> map, CharSequence charSequence, PhonemeBuilder phonemeBuilder2, int i2, int i3) {
Objects.requireNonNull(map, "The finalRules argument must not be null");
this.finalRules = map;
this.phonemeBuilder = phonemeBuilder2;
this.input = charSequence;
this.i = i2;
this.maxPhonemes = i3;
}
public int getI() {
return this.i;
}
public PhonemeBuilder getPhonemeBuilder() {
return this.phonemeBuilder;
}
public RulesApplication invoke() {
int i2;
this.found = false;
Map<String, List<Rule>> map = this.finalRules;
CharSequence charSequence = this.input;
int i3 = this.i;
List list = map.get(charSequence.subSequence(i3, i3 + 1));
int i4 = 1;
if (list != null) {
Iterator it = list.iterator();
i2 = 1;
while (true) {
if (!it.hasNext()) {
break;
}
Rule rule = (Rule) it.next();
int length = rule.getPattern().length();
if (rule.patternAndContextMatches(this.input, this.i)) {
this.phonemeBuilder.apply(rule.getPhoneme(), this.maxPhonemes);
this.found = true;
i2 = length;
break;
}
i2 = length;
}
} else {
i2 = 1;
}
if (this.found) {
i4 = i2;
}
this.i += i4;
return this;
}
public boolean isFound() {
return this.found;
}
}
static {
EnumMap enumMap = new EnumMap(NameType.class);
NAME_PREFIXES = enumMap;
enumMap.put(NameType.ASHKENAZI, Collections.unmodifiableSet(new HashSet(Arrays.asList(new String[]{"bar", "ben", "da", "de", "van", "von"}))));
enumMap.put(NameType.SEPHARDIC, Collections.unmodifiableSet(new HashSet(Arrays.asList(new String[]{"al", "el", "da", "dal", "de", "del", "dela", "de la", "della", "des", "di", "do", "dos", "du", "van", "von"}))));
enumMap.put(NameType.GENERIC, Collections.unmodifiableSet(new HashSet(Arrays.asList(new String[]{"da", "dal", "de", "del", "dela", "de la", "della", "des", "di", "do", "dos", "du", "van", "von"}))));
}
private static String join(Iterable<String> iterable, String str) {
StringBuilder sb = new StringBuilder();
Iterator<String> it = iterable.iterator();
if (it.hasNext()) {
sb.append(it.next());
}
while (it.hasNext()) {
sb.append(str);
sb.append(it.next());
}
return sb.toString();
}
public PhoneticEngine(NameType nameType2, RuleType ruleType2, boolean z) {
this(nameType2, ruleType2, z, 20);
}
public PhoneticEngine(NameType nameType2, RuleType ruleType2, boolean z, int i) {
if (ruleType2 != RuleType.RULES) {
this.nameType = nameType2;
this.ruleType = ruleType2;
this.concat = z;
this.lang = Lang.instance(nameType2);
this.maxPhonemes = i;
return;
}
throw new IllegalArgumentException("ruleType must not be " + RuleType.RULES);
}
private PhonemeBuilder applyFinalRules(PhonemeBuilder phonemeBuilder, Map<String, List<Rule>> map) {
Objects.requireNonNull(map, "finalRules can not be null");
if (map.isEmpty()) {
return phonemeBuilder;
}
TreeMap treeMap = new TreeMap(Rule.Phoneme.COMPARATOR);
for (Rule.Phoneme next : phonemeBuilder.getPhonemes()) {
PhonemeBuilder empty = PhonemeBuilder.empty(next.getLanguages());
String charSequence = next.getPhonemeText().toString();
PhonemeBuilder phonemeBuilder2 = empty;
int i = 0;
while (i < charSequence.length()) {
RulesApplication invoke = new RulesApplication(map, charSequence, phonemeBuilder2, i, this.maxPhonemes).invoke();
boolean isFound = invoke.isFound();
phonemeBuilder2 = invoke.getPhonemeBuilder();
if (!isFound) {
phonemeBuilder2.append(charSequence.subSequence(i, i + 1));
}
i = invoke.getI();
}
for (Rule.Phoneme next2 : phonemeBuilder2.getPhonemes()) {
if (treeMap.containsKey(next2)) {
Rule.Phoneme mergeWithLanguage = ((Rule.Phoneme) treeMap.remove(next2)).mergeWithLanguage(next2.getLanguages());
treeMap.put(mergeWithLanguage, mergeWithLanguage);
} else {
treeMap.put(next2, next2);
}
}
}
return new PhonemeBuilder(treeMap.keySet(), (AnonymousClass1) null);
}
public String encode(String str) {
return encode(str, this.lang.guessLanguages(str));
}
public String encode(String str, Languages.LanguageSet languageSet) {
String str2;
Map<String, List<Rule>> instanceMap = Rule.getInstanceMap(this.nameType, RuleType.RULES, languageSet);
Map<String, List<Rule>> instanceMap2 = Rule.getInstanceMap(this.nameType, this.ruleType, "common");
Map<String, List<Rule>> instanceMap3 = Rule.getInstanceMap(this.nameType, this.ruleType, languageSet);
String trim = str.toLowerCase(Locale.ENGLISH).replace('-', ' ').trim();
if (this.nameType == NameType.GENERIC) {
if (trim.length() < 2 || !trim.substring(0, 2).equals("d'")) {
for (String str3 : NAME_PREFIXES.get(this.nameType)) {
if (trim.startsWith(str3 + " ")) {
String substring = trim.substring(str3.length() + 1);
String str4 = str3 + substring;
return "(" + encode(substring) + ")-(" + encode(str4) + ")";
}
}
} else {
String substring2 = trim.substring(2);
String str5 = "d" + substring2;
return "(" + encode(substring2) + ")-(" + encode(str5) + ")";
}
}
List<String> asList = Arrays.asList(trim.split("\\s+"));
ArrayList<String> arrayList = new ArrayList<>();
int i = AnonymousClass1.$SwitchMap$org$apache$commons$codec$language$bm$NameType[this.nameType.ordinal()];
if (i == 1) {
for (String split : asList) {
String[] split2 = split.split("'");
arrayList.add(split2[split2.length - 1]);
}
arrayList.removeAll(NAME_PREFIXES.get(this.nameType));
} else if (i == 2) {
arrayList.addAll(asList);
arrayList.removeAll(NAME_PREFIXES.get(this.nameType));
} else if (i == 3) {
arrayList.addAll(asList);
} else {
throw new IllegalStateException("Unreachable case: " + this.nameType);
}
if (this.concat) {
str2 = join(arrayList, " ");
} else if (arrayList.size() == 1) {
str2 = (String) asList.iterator().next();
} else {
StringBuilder sb = new StringBuilder();
for (String encode : arrayList) {
sb.append("-");
sb.append(encode(encode));
}
return sb.substring(1);
}
PhonemeBuilder empty = PhonemeBuilder.empty(languageSet);
int i2 = 0;
while (i2 < str2.length()) {
RulesApplication invoke = new RulesApplication(instanceMap, str2, empty, i2, this.maxPhonemes).invoke();
i2 = invoke.getI();
empty = invoke.getPhonemeBuilder();
}
return applyFinalRules(applyFinalRules(empty, instanceMap2), instanceMap3).makeString();
}
/* renamed from: org.apache.commons.codec.language.bm.PhoneticEngine$1 reason: invalid class name */
static /* synthetic */ class AnonymousClass1 {
static final /* synthetic */ int[] $SwitchMap$org$apache$commons$codec$language$bm$NameType;
/* JADX WARNING: Can't wrap try/catch for region: R(6:0|1|2|3|4|(3:5|6|8)) */
/* JADX WARNING: Failed to process nested try/catch */
/* JADX WARNING: Missing exception handler attribute for start block: B:3:0x0012 */
/* JADX WARNING: Missing exception handler attribute for start block: B:5:0x001d */
static {
/*
org.apache.commons.codec.language.bm.NameType[] r0 = org.apache.commons.codec.language.bm.NameType.values()
int r0 = r0.length
int[] r0 = new int[r0]
$SwitchMap$org$apache$commons$codec$language$bm$NameType = r0
org.apache.commons.codec.language.bm.NameType r1 = org.apache.commons.codec.language.bm.NameType.SEPHARDIC // Catch:{ NoSuchFieldError -> 0x0012 }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x0012 }
r2 = 1
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x0012 }
L_0x0012:
int[] r0 = $SwitchMap$org$apache$commons$codec$language$bm$NameType // Catch:{ NoSuchFieldError -> 0x001d }
org.apache.commons.codec.language.bm.NameType r1 = org.apache.commons.codec.language.bm.NameType.ASHKENAZI // Catch:{ NoSuchFieldError -> 0x001d }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x001d }
r2 = 2
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x001d }
L_0x001d:
int[] r0 = $SwitchMap$org$apache$commons$codec$language$bm$NameType // Catch:{ NoSuchFieldError -> 0x0028 }
org.apache.commons.codec.language.bm.NameType r1 = org.apache.commons.codec.language.bm.NameType.GENERIC // Catch:{ NoSuchFieldError -> 0x0028 }
int r1 = r1.ordinal() // Catch:{ NoSuchFieldError -> 0x0028 }
r2 = 3
r0[r1] = r2 // Catch:{ NoSuchFieldError -> 0x0028 }
L_0x0028:
return
*/
throw new UnsupportedOperationException("Method not decompiled: org.apache.commons.codec.language.bm.PhoneticEngine.AnonymousClass1.<clinit>():void");
}
}
public Lang getLang() {
return this.lang;
}
public NameType getNameType() {
return this.nameType;
}
public RuleType getRuleType() {
return this.ruleType;
}
public boolean isConcat() {
return this.concat;
}
public int getMaxPhonemes() {
return this.maxPhonemes;
}
}
Download file