AHE16: Android Hacking Events 2017 (Strange Calculator)

				
					package de.ecspride.demoversion;  
  
import android.util.Log;  
  
/* loaded from: classes.dex */  
public class Parser {  
    /* JADX WARN: Type inference failed for: r0v0, types: [de.ecspride.demoversion.Parser$1InternalParser] */  
    public static double eval(final String str) {  
        return new Object() { // from class: de.ecspride.demoversion.Parser.1InternalParser  
            int c;  
            int pos = -1;  
  
            void eatChar() {  
                int i = this.pos + 1;  
                this.pos = i;  
                this.c = i < str.length() ? str.charAt(this.pos) : (char) 65535;  
            }  
  
            void eatSpace() {  
                while (Character.isWhitespace(this.c)) {  
                    eatChar();  
                }  
            }  
  
            double parse() {  
                eatChar();  
                double v = parseExpression();  
                if (this.c != -1) {  
                    throw new RuntimeException("Unexpected: " + ((char) this.c));  
                }  
                return v;  
            }  
  
            double parseExpression() {  
                double v = parseTerm();  
                while (true) {  
                    eatSpace();  
                    if (this.c == 43) {  
                        eatChar();  
                        v += parseTerm();  
                    } else {  
                        if (this.c != 45) {  
                            break;  
                        }  
                        eatChar();  
                        v -= parseTerm();  
                    }  
                }  
                if (v > 100.0d) {  
                    throw new RuntimeException("The number is too large. Please buy the full version!");  
                }  
                if (v > 100.0d) {  
                    int[] flarry = {1400, 1393, 1404, 1288, 1295, 1346, 1395, 1368, 1359, 1368, 1382, 1293, 1367, 1368, 1365, 1344, 1354, 1288, 1354, 1382, 1288, 1354, 1382, 1355, 1293, 1357, 1361, 1290, 1355, 1382, 1290, 1368, 1354, 1344, 1382, 1288, 1354, 1367, 1357, 1382, 1288, 1357, 1348};  
                    for (int i : flarry) {  
                        Log.d("SUPER OUTPUT", Integer.toString(i ^ 1337));  
                    }  
                }  
                return v;  
            }  
  
            double parseTerm() {  
                double v = parseFactor();  
                while (true) {  
                    eatSpace();  
                    if (this.c == 47) {  
                        eatChar();  
                        v /= parseFactor();  
                    } else if (this.c == 42 || this.c == 40) {  
                        if (this.c == 42) {  
                            eatChar();  
                        }  
                        v *= parseFactor();  
                    } else {  
                        return v;  
                    }  
                }  
            }  
  
            double parseFactor() {  
                double v;  
                boolean negate = false;  
                eatSpace();  
                if (this.c == 40) {  
                    eatChar();  
                    v = parseExpression();  
                    if (this.c == 41) {  
                        eatChar();  
                    }  
                } else {  
                    if (this.c == 43 || this.c == 45) {  
                        negate = this.c == 45;  
                        eatChar();  
                        eatSpace();  
                    }  
                    StringBuilder sb = new StringBuilder();  
                    while (true) {  
                        if ((this.c < 48 || this.c > 57) && this.c != 46) {  
                            break;  
                        }  
                        sb.append((char) this.c);  
                        eatChar();  
                    }  
                    if (sb.length() == 0) {  
                        throw new RuntimeException("Unexpected: " + ((char) this.c));  
                    }  
                    v = Double.parseDouble(sb.toString());  
                }  
                eatSpace();  
                if (this.c == 94) {  
                    eatChar();  
                    v = Math.pow(v, parseFactor());  
                }  
                return negate ? -v : v;  
            }  
        }.parse();  
    }