com.crashlytics.tools.android_2.1.0

    if (statusStack.size() == 0) {
      return -1;
    }
    Integer status = (Integer)statusStack.getFirst();
    return status.intValue();
  }
  
  public void reset()
  {
    token = null;
    status = 0;
    handlerStatusStack = null;
  }
  
  public void reset(Reader in)
  {
    lexer.yyreset(in);
    reset();
  }
  
  public int getPosition()
  {
    return lexer.getPosition();
  }
  
  public Object parse(String s)
    throws ParseException
  {
    return parse(s, (ContainerFactory)null);
  }
  
  public Object parse(String s, ContainerFactory containerFactory)
    throws ParseException
  {
    StringReader in = new StringReader(s);
    try
    {
      return parse(in, containerFactory);
    }
    catch (IOException ie)
    {
      throw new ParseException(-1, 2, ie);
    }
  }
  
  public Object parse(Reader in)
    throws IOException, ParseException
  {
    return parse(in, (ContainerFactory)null);
  }
  
  public Object parse(Reader in, ContainerFactory containerFactory)
    throws IOException, ParseException
  {
    reset(in);
    LinkedList statusStack = new LinkedList();
    LinkedList valueStack = new LinkedList();
    try
    {
      do
      {
        nextToken();
        switch (status)
        {
        case 0: 
          switch (token.type)
          {
          case 0: 
            status = 1;
            statusStack.addFirst(new Integer(status));
            valueStack.addFirst(token.value);
            break;
          case 1: 
            status = 2;
            statusStack.addFirst(new Integer(status));
            valueStack.addFirst(createObjectContainer(containerFactory));
            break;
          case 3: 
            status = 3;
            statusStack.addFirst(new Integer(status));
            valueStack.addFirst(createArrayContainer(containerFactory));
            break;
          case 2: 
          default: 
            status = -1;
          }
          break;
        case 1: 
          if (token.type == -1) {
            return valueStack.removeFirst();
          }
          throw new ParseException(getPosition(), 1, token);
        case 2: 
          switch (token.type)
          {
          case 5: 
            break;
          case 0: 
            if ((token.value instanceof String))
            {
              String key = (String)token.value;
              valueStack.addFirst(key);
              status = 4;
              statusStack.addFirst(new Integer(status));
            }
            else
            {
              status = -1;
            }
            break;
          case 2: 
            if (valueStack.size() > 1)
            {
              statusStack.removeFirst();
              valueStack.removeFirst();
              status = peekStatus(statusStack);
            }
            else
            {
              status = 1;
            }
            break;
          default: 
            status = -1;
          }
          break;
        case 4: 
          String key;
          Map parent;
          switch (token.type)
          {
          case 6: 
            break;
          case 0: 
            statusStack.removeFirst();
            key = (String)valueStack.removeFirst();
            parent = (Map)valueStack.getFirst();
            parent.put(key, token.value);
            status = peekStatus(statusStack);
            break;
          case 3: 
            statusStack.removeFirst();
            key = (String)valueStack.removeFirst();
            parent = (Map)valueStack.getFirst();
            List newArray = createArrayContainer(containerFactory);
            parent.put(key, newArray);
            status = 3;
            statusStack.addFirst(new Integer(status));
            valueStack.addFirst(newArray);
            break;
          case 1: 
            statusStack.removeFirst();
            key = (String)valueStack.removeFirst();
            parent = (Map)valueStack.getFirst();
            Map newObject = createObjectContainer(containerFactory);
            parent.put(key, newObject);
            status = 2;
            statusStack.addFirst(new Integer(status));
            valueStack.addFirst(newObject);
            break;
          case 2: 
          case 4: 
          case 5: 
          default: 
            status = -1;
          }
          break;
        case 3: 
          List val;
          switch (token.type)
          {
          case 5: 
            break;
          case 0: 
            val = (List)valueStack.getFirst();
            val.add(token.value);
            break;
          case 4: 
            if (valueStack.size() > 1)
            {
              statusStack.removeFirst();
              valueStack.removeFirst();
              status = peekStatus(statusStack);
            }
            else
            {
              status = 1;
            }
            break;
          case 1: 
            val = (List)valueStack.getFirst();
            Map newObject = createObjectContainer(containerFactory);
            val.add(newObject);
            status = 2;
            statusStack.addFirst(new Integer(status));
            valueStack.addFirst(newObject);
            break;
          case 3: 
            val = (List)valueStack.getFirst();
            List newArray = createArrayContainer(containerFactory);
            val.add(newArray);
            status = 3;
            statusStack.addFirst(new Integer(status));
            valueStack.addFirst(newArray);
            break;
          case 2: 
          default: 
            status = -1;
          }
          break;
        case -1: 
          throw new ParseException(getPosition(), 1, token);
        }
        if (status == -1) {
          throw new ParseException(getPosition(), 1, token);
        }
      } while (token.type != -1);
    }
    catch (IOException ie)
    {
      throw ie;
    }
    throw new ParseException(getPosition(), 1, token);
  }
  
  private void nextToken()
    throws ParseException, IOException
  {
    token = lexer.yylex();
    if (token == null) {
      token = new Yytoken(-1, null);
    }
  }
  
  private Map createObjectContainer(ContainerFactory containerFactory)
  {
    if (containerFactory == null) {
      return new JSONObject();
    }
    Map m = containerFactory.createObjectContainer();
    if (m == null) {
      return new JSONObject();
    }
    return m;
  }
  
  private List createArrayContainer(ContainerFactory containerFactory)
  {
    if (containerFactory == null) {
      return new JSONArray();
    }
    List l = containerFactory.creatArrayContainer();
    if (l == null) {
      return new JSONArray();
    }
    return l;
  }
  
  public void parse(String s, ContentHandler contentHandler)
    throws ParseException
  {
    parse(s, contentHandler, false);
  }
  
  public void parse(String s, ContentHandler contentHandler, boolean isResume)
    throws ParseException
  {
    StringReader in = new StringReader(s);
    try
    {
      parse(in, contentHandler, isResume);
    }
    catch (IOException ie)
    {
      throw new ParseException(-1, 2, ie);
    }
  }
  
  public void parse(Reader in, ContentHandler contentHandler)
    throws IOException, ParseException
  {
    parse(in, contentHandler, false);
  }
  
  public void parse(Reader in, ContentHandler contentHandler, boolean isResume)
    throws IOException, ParseException
  {
    if (!isResume)
    {
      reset(in);
      handlerStatusStack = new LinkedList();
    }
    else if (handlerStatusStack == null)
    {
      isResume = false;
      reset(in);
      handlerStatusStack = new LinkedList();
    }
    LinkedList statusStack = handlerStatusStack;
    try
    {
      do
      {
        switch (status)
        {
        case 0: 
          contentHandler.startJSON();
          nextToken();
          switch (token.type)
          {
          case 0: 
            status = 1;
            statusStack.addFirst(new Integer(status));
            if (!contentHandler.primitive(token.value)) {
              return;
            }
            break;
          case 1: 
            status = 2;
            statusStack.addFirst(new Integer(status));
            if (!contentHandler.startObject()) {
              return;
            }
            break;
          case 3: 
            status = 3;
            statusStack.addFirst(new Integer(status));
            if (!contentHandler.startArray()) {
              return;
            }
            break;
          case 2: 
          default: 
            status = -1;
          }
          break;
        case 1: 
          nextToken();
          if (token.type == -1)
          {
            contentHandler.endJSON();
            status = 6;
            return;
          }
          status = -1;
          throw new ParseException(getPosition(), 1, token);
        case 2: 
          nextToken();
          switch (token.type)
          {
          case 5: 
            break;
          case 0: 
            if ((token.value instanceof String))
            {
              String key = (String)token.value;
              status = 4;
              statusStack.addFirst(new Integer(status));
              if (!contentHandler.startObjectEntry(key)) {
                return;
              }
            }
            else
            {
              status = -1;
            }
            break;
          case 2: 
            if (statusStack.size() > 1)
            {
              statusStack.removeFirst();
              status = peekStatus(statusStack);
            }
            else
            {
              status = 1;
            }
            if (!contentHandler.endObject()) {
              return;
            }
            break;
          default: 
            status = -1;
          }
          break;
        case 4: 
          nextToken();
          switch (token.type)
          {
          case 6: 
            break;
          case 0: 
            statusStack.removeFirst();
            status = peekStatus(statusStack);
            if (!contentHandler.primitive(token.value)) {
              return;
            }
            if (!contentHandler.endObjectEntry()) {
              return;
            }
            break;
          case 3: 
            statusStack.removeFirst();
            statusStack.addFirst(new Integer(5));
            status = 3;
            statusStack.addFirst(new Integer(status));
            if (!contentHandler.startArray()) {
              return;
            }
            break;
          case 1: 
            statusStack.removeFirst();
            statusStack.addFirst(new Integer(5));
            status = 2;
            statusStack.addFirst(new Integer(status));
            if (!contentHandler.startObject()) {
              return;
            }
            break;
          case 2: 
          case 4: 
          case 5: 
          default: 
            status = -1;
          }
          break;
        case 5: 
          statusStack.removeFirst();
          status = peekStatus(statusStack);
          if (!contentHandler.endObjectEntry()) {
            return;
          }
          break;
        case 3: 
          nextToken();
          switch (token.type)
          {
          case 5: 
            break;
          case 0: 
            if (!contentHandler.primitive(token.value)) {
              return;
            }
            break;
          case 4: 
            if (statusStack.size() > 1)
            {
              statusStack.removeFirst();
              status = peekStatus(statusStack);
            }
            else
            {
              status = 1;
            }
            if (!contentHandler.endArray()) {
              return;
            }
            break;
          case 1: 
            status = 2;
            statusStack.addFirst(new Integer(status));
            if (!contentHandler.startObject()) {
              return;
            }
            break;
          case 3: 
            status = 3;
            statusStack.addFirst(new Integer(status));
            if (!contentHandler.startArray()) {
              return;
            }
            break;
          case 2: 
          default: 
            status = -1;
          }
          break;
        case 6: 
          return;
        case -1: 
          throw new ParseException(getPosition(), 1, token);
        }
        if (status == -1) {
          throw new ParseException(getPosition(), 1, token);
        }
      } while (token.type != -1);
    }
    catch (IOException ie)
    {
      status = -1;
      throw ie;
    }
    catch (ParseException pe)
    {
      status = -1;
      throw pe;
    }
    catch (RuntimeException re)
    {
      status = -1;
      throw re;
    }
    catch (Error e)
    {
      status = -1;
      throw e;
    }
    status = -1;
    throw new ParseException(getPosition(), 1, token);
  }
}

/* Location:
 * Qualified Name:     org.json.simple.parser.JSONParser
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.json.simple.parser;

public class ParseException
  extends Exception
{
  private static final long serialVersionUID = -7880698968187728548L;
  public static final int ERROR_UNEXPECTED_CHAR = 0;
  public static final int ERROR_UNEXPECTED_TOKEN = 1;
  public static final int ERROR_UNEXPECTED_EXCEPTION = 2;
  private int errorType;
  private Object unexpectedObject;
  private int position;
  
  public ParseException(int errorType)
  {
    this(-1, errorType, null);
  }
  
  public ParseException(int errorType, Object unexpectedObject)
  {
    this(-1, errorType, unexpectedObject);
  }
  
  public ParseException(int position, int errorType, Object unexpectedObject)
  {
    this.position = position;
    this.errorType = errorType;
    this.unexpectedObject = unexpectedObject;
  }
  
  public int getErrorType()
  {
    return errorType;
  }
  
  public void setErrorType(int errorType)
  {
    this.errorType = errorType;
  }
  
  public int getPosition()
  {
    return position;
  }
  
  public void setPosition(int position)
  {
    this.position = position;
  }
  
  public Object getUnexpectedObject()
  {
    return unexpectedObject;
  }
  
  public void setUnexpectedObject(Object unexpectedObject)
  {
    this.unexpectedObject = unexpectedObject;
  }
  
  public String toString()
  {
    StringBuffer sb = new StringBuffer();
    switch (errorType)
    {
    case 0: 
      sb.append("Unexpected character (").append(unexpectedObject).append(") at position ").append(position).append(".");
      break;
    case 1: 
      sb.append("Unexpected token ").append(unexpectedObject).append(" at position ").append(position).append(".");
      break;
    case 2: 
      sb.append("Unexpected exception at position ").append(position).append(": ").append(unexpectedObject);
      break;
    default: 
      sb.append("Unkown error at position ").append(position).append(".");
    }
    return sb.toString();
  }
}

/* Location:
 * Qualified Name:     org.json.simple.parser.ParseException
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.json.simple.parser;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;

class Yylex
{
  public static final int YYEOF = -1;
  private static final int ZZ_BUFFERSIZE = 16384;
  public static final int YYINITIAL = 0;
  public static final int STRING_BEGIN = 2;
  private static final int[] ZZ_LEXSTATE = { 0, 0, 1, 1 };
  private static final String ZZ_CMAP_PACKED = "\t\000\001\007\001\007\002\000\001\007\022\000\001\007\001\000\001\t\b\000\001\006\001\031\001\002\001\004\001\n\n\003\001\032\006\000\004\001\001\005\001\001\024\000\001\027\001\b\001\030\003\000\001\022\001\013\002\001\001\021\001\f\005\000\001\023\001\000\001\r\003\000\001\016\001\024\001\017\001\020\005\000\001\025\001\000\001\026?\000";
  private static final char[] ZZ_CMAP = zzUnpackCMap("\t\000\001\007\001\007\002\000\001\007\022\000\001\007\001\000\001\t\b\000\001\006\001\031\001\002\001\004\001\n\n\003\001\032\006\000\004\001\001\005\001\001\024\000\001\027\001\b\001\030\003\000\001\022\001\013\002\001\001\021\001\f\005\000\001\023\001\000\001\r\003\000\001\016\001\024\001\017\001\020\005\000\001\025\001\000\001\026?\000");
  private static final int[] ZZ_ACTION = zzUnpackAction();
  private static final String ZZ_ACTION_PACKED_0 = "\002\000\002\001\001\002\001\003\001\004\003\001\001\005\001\006\001\007\001\b\001\t\001\n\001\013\001\f\001\r\005\000\001\f\001\016\001\017\001\020\001\021\001\022\001\023\001\024\001\000\001\025\001\000\001\025\004\000\001\026\001\027\002\000\001\030";
  
  private static int[] zzUnpackAction()
  {
    int[] result = new int[45];
    int offset = 0;
    offset = zzUnpackAction("\002\000\002\001\001\002\001\003\001\004\003\001\001\005\001\006\001\007\001\b\001\t\001\n\001\013\001\f\001\r\005\000\001\f\001\016\001\017\001\020\001\021\001\022\001\023\001\024\001\000\001\025\001\000\001\025\004\000\001\026\001\027\002\000\001\030", offset, result);
    return result;
  }
  
  private static int zzUnpackAction(String packed, int offset, int[] result)
  {
    int i = 0;
    int j = offset;
    int l = packed.length();
    int count;
    for (; i < l; count > 0)
    {
      count = packed.charAt(i++);
      int value = packed.charAt(i++);
      result[(j++)] = value;count--;
    }
    return j;
  }
  
  private static final int[] ZZ_ROWMAP = zzUnpackRowMap();
  private static final String ZZ_ROWMAP_PACKED_0 = "\000\000\000\033\0006\000Q\000l\000?\0006\000�\000�\000�\0006\0006\0006\0006\0006\0006\000�\000?\0006\000?\000?\000?\000?\000?\0006\0006\0006\0006\0006\0006\0006\0006\000?\000?\000?\000?\000?\000?\000?\000?\0006\0006\000?\000?\0006";
  
  private static int[] zzUnpackRowMap()
  {
    int[] result = new int[45];
    int offset = 0;
    offset = zzUnpackRowMap("\000\000\000\033\0006\000Q\000l\000?\0006\000�\000�\000�\0006\0006\0006\0006\0006\0006\000�\000?\0006\000?\000?\000?\000?\000?\0006\0006\0006\0006\0006\0006\0006\0006\000?\000?\000?\000?\000?\000?\000?\000?\0006\0006\000?\000?\0006", offset, result);
    return result;
  }
  
  private static int zzUnpackRowMap(String packed, int offset, int[] result)
  {
    int i = 0;
    int j = offset;
    int l = packed.length();
    while (i < l)
    {
      int high = packed.charAt(i++) << '\020';
      result[(j++)] = (high | packed.charAt(i++));
    }
    return j;
  }
  
  private static final int[] ZZ_TRANS = { 2, 2, 3, 4, 2, 2, 2, 5, 2, 6, 2, 2, 7, 8, 2, 9, 2, 2, 2, 2, 2, 10, 11, 12, 13, 14, 15, 16, 16, 16, 16, 16, 16, 16, 16, 17, 18, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 4, 19, 20, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 20, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 21, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 22, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 23, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 16, 16, 16, 16, 16, 16, 16, 16, -1, -1, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, -1, -1, -1, -1, -1, -1, -1, -1, 24, 25, 26, 27, 28, 29, 30, 31, 32, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 33, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 34, 35, -1, -1, 34, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 36, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 37, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 39, -1, 39, -1, 39, -1, -1, -1, -1, -1, 39, 39, -1, -1, -1, -1, 39, 39, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 33, -1, 20, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 20, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 35, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 38, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 40, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 41, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 42, -1, 42, -1, 42, -1, -1, -1, -1, -1, 42, 42, -1, -1, -1, -1, 42, 42, -1, -1, -1, -1, -1, -1, -1, -1, -1, 43, -1, 43, -1, 43, -1, -1, -1, -1, -1, 43, 43, -1, -1, -1, -1, 43, 43, -1, -1, -1, -1, -1, -1, -1, -1, -1, 44, -1, 44, -1, 44, -1, -1, -1, -1, -1, 44, 44, -1, -1, -1, -1, 44, 44, -1, -1, -1, -1, -1, -1, -1, -1 };
  private static final int ZZ_UNKNOWN_ERROR = 0;
  private static final int ZZ_NO_MATCH = 1;
  private static final int ZZ_PUSHBACK_2BIG = 2;
  private static final String[] ZZ_ERROR_MSG = { "Unkown internal scanner error", "Error: could not match input", "Error: pushback value was too large" };
  private static final int[] ZZ_ATTRIBUTE = zzUnpackAttribute();
  private static final String ZZ_ATTRIBUTE_PACKED_0 = "\002\000\001\t\003\001\001\t\003\001\006\t\002\001\001\t\005\000\b\t\001\000\001\001\001\000\001\001\004\000\002\t\002\000\001\t";
  private Reader zzReader;
  private int zzState;
  
  private static int[] zzUnpackAttribute()
  {
    int[] result = new int[45];
    int offset = 0;
    offset = zzUnpackAttribute("\002\000\001\t\003\001\001\t\003\001\006\t\002\001\001\t\005\000\b\t\001\000\001\001\001\000\001\001\004\000\002\t\002\000\001\t", offset, result);
    return result;
  }
  
  private static int zzUnpackAttribute(String packed, int offset, int[] result)
  {
    int i = 0;
    int j = offset;
    int l = packed.length();
    int count;
    for (; i < l; count > 0)
    {
      count = packed.charAt(i++);
      int value = packed.charAt(i++);
      result[(j++)] = value;count--;
    }
    return j;
  }
  
  private int zzLexicalState = 0;
  private char[] zzBuffer = new char['?'];
  private int zzMarkedPos;
  private int zzCurrentPos;
  private int zzStartRead;
  private int zzEndRead;
  private int yyline;
  private int yychar;
  private int yycolumn;
  private boolean zzAtBOL = true;
  private boolean zzAtEOF;
  private StringBuffer sb = new StringBuffer();
  
  int getPosition()
  {
    return yychar;
  }
  
  Yylex(Reader in)
  {
    zzReader = in;
  }
  
  Yylex(InputStream in)
  {
    this(new InputStreamReader(in));
  }
  
  private static char[] zzUnpackCMap(String packed)
  {
    char[] map = new char[65536];
    int i = 0;
    int j = 0;
    int count;
    for (; i < 90; count > 0)
    {
      count = packed.charAt(i++);
      char value = packed.charAt(i++);
      map[(j++)] = value;count--;
    }
    return map;
  }
  
  private boolean zzRefill()
    throws IOException
  {
    if (zzStartRead > 0)
    {
      System.arraycopy(zzBuffer, zzStartRead, zzBuffer, 0, zzEndRead - zzStartRead);
      
      zzEndRead -= zzStartRead;
      zzCurrentPos -= zzStartRead;
      zzMarkedPos -= zzStartRead;
      zzStartRead = 0;
    }
    if (zzCurrentPos >= zzBuffer.length)
    {
      char[] newBuffer = new char[zzCurrentPos * 2];
      System.arraycopy(zzBuffer, 0, newBuffer, 0, zzBuffer.length);
      zzBuffer = newBuffer;
    }
    int numRead = zzReader.read(zzBuffer, zzEndRead, zzBuffer.length - zzEndRead);
    if (numRead > 0)
    {
      zzEndRead += numRead;
      return false;
    }
    if (numRead == 0)
    {
      int c = zzReader.read();
      if (c == -1) {
        return true;
      }
      zzBuffer[(zzEndRead++)] = ((char)c);
      return false;
    }
    return true;
  }
  
  public final void yyclose()
    throws IOException
  {
    zzAtEOF = true;
    zzEndRead = zzStartRead;
    if (zzReader != null) {
      zzReader.close();
    }
  }
  
  public final void yyreset(Reader reader)
  {
    zzReader = reader;
    zzAtBOL = true;
    zzAtEOF = false;
    zzEndRead = (zzStartRead = 0);
    zzCurrentPos = (zzMarkedPos = 0);
    yyline = (yychar = yycolumn = 0);
    zzLexicalState = 0;
  }
  
  public final int yystate()
  {
    return zzLexicalState;
  }
  
  public final void yybegin(int newState)
  {
    zzLexicalState = newState;
  }
  
  public final String yytext()
  {
    return new String(zzBuffer, zzStartRead, zzMarkedPos - zzStartRead);
  }
  
  public final char yycharat(int pos)
  {
    return zzBuffer[(zzStartRead + pos)];
  }
  
  public final int yylength()
  {
    return zzMarkedPos - zzStartRead;
  }
  
  private void zzScanError(int errorCode)
  {
    String message;
    try
    {
      message = ZZ_ERROR_MSG[errorCode];
    }
    catch (ArrayIndexOutOfBoundsException e)
    {
      message = ZZ_ERROR_MSG[0];
    }
    throw new Error(message);
  }
  
  public void yypushback(int number)
  {
    if (number > yylength()) {
      zzScanError(2);
    }
    zzMarkedPos -= number;
  }
  
  public Yytoken yylex()
    throws IOException, ParseException
  {
    int zzEndReadL = zzEndRead;
    char[] zzBufferL = zzBuffer;
    char[] zzCMapL = ZZ_CMAP;
    
    int[] zzTransL = ZZ_TRANS;
    int[] zzRowMapL = ZZ_ROWMAP;
    int[] zzAttrL = ZZ_ATTRIBUTE;
    for (;;)
    {
      int zzMarkedPosL = zzMarkedPos;
      
      yychar += zzMarkedPosL - zzStartRead;
      
      int zzAction = -1;
      
      int zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
      
      zzState = ZZ_LEXSTATE[zzLexicalState];
      int zzInput;
      for (;;)
      {
        int zzInput;
        if (zzCurrentPosL < zzEndReadL)
        {
          zzInput = zzBufferL[(zzCurrentPosL++)];
        }
        else
        {
          if (zzAtEOF)
          {
            int zzInput = -1;
            break;
          }
          zzCurrentPos = zzCurrentPosL;
          zzMarkedPos = zzMarkedPosL;
          boolean eof = zzRefill();
          
          zzCurrentPosL = zzCurrentPos;
          zzMarkedPosL = zzMarkedPos;
          zzBufferL = zzBuffer;
          zzEndReadL = zzEndRead;
          if (eof)
          {
            int zzInput = -1;
            break;
          }
          zzInput = zzBufferL[(zzCurrentPosL++)];
        }
        int zzNext = zzTransL[(zzRowMapL[zzState] + zzCMapL[zzInput])];
        if (zzNext == -1) {
          break;
        }
        zzState = zzNext;
        
        int zzAttributes = zzAttrL[zzState];
        if ((zzAttributes & 0x1) == 1)
        {
          zzAction = zzState;
          zzMarkedPosL = zzCurrentPosL;
          if ((zzAttributes & 0x8) == 8) {
            break;
          }
        }
      }
      zzMarkedPos = zzMarkedPosL;
      switch (zzAction < 0 ? zzAction : ZZ_ACTION[zzAction])
      {
      case 11: 
        sb.append(yytext());
      case 25: 
        break;
      case 4: 
        sb.delete(0, sb.length());yybegin(2);
      case 26: 
        break;
      case 16: 
        sb.append('\b');
      case 27: 
        break;
      case 6: 
        return new Yytoken(2, null);
      case 28: 
        break;
      case 23: 
        Boolean val = Boolean.valueOf(yytext());return new Yytoken(0, val);
      case 29: 
        break;
      case 22: 
        return new Yytoken(0, null);
      case 30: 
        break;
      case 13: 
        yybegin(0);return new Yytoken(0, sb.toString());
      case 31: 
        break;
      case 12: 
        sb.append('\\');
      case 32: 
        break;
      case 21: 
        Double val = Double.valueOf(yytext());return new Yytoken(0, val);
      case 33: 
        break;
      case 1: 
        throw new ParseException(yychar, 0, new Character(yycharat(0)));
      case 34: 
        break;
      case 8: 
        return new Yytoken(4, null);
      case 35: 
        break;
      case 19: 
        sb.append('\r');
      case 36: 
        break;
      case 15: 
        sb.append('/');
      case 37: 
        break;
      case 10: 
        return new Yytoken(6, null);
      case 38: 
        break;
      case 14: 
        sb.append('"');
      case 39: 
        break;
      case 5: 
        return new Yytoken(1, null);
      case 40: 
        break;
      case 17: 
        sb.append('\f');
      case 41: 
        break;
      case 24: 
        try
        {
          int ch = Integer.parseInt(yytext().substring(2), 16);
          sb.append((char)ch);
        }
        catch (Exception e)
        {
          throw new ParseException(yychar, 2, e);
        }
      case 42: 
        break;
      case 20: 
        sb.append('\t');
      case 43: 
        break;
      case 7: 
        return new Yytoken(3, null);
      case 44: 
        break;
      case 2: 
        Long val = Long.valueOf(yytext());return new Yytoken(0, val);
      case 45: 
        break;
      case 18: 
        sb.append('\n');
      case 46: 
        break;
      case 9: 
        return new Yytoken(5, null);
      case 47: 
        break;
      case 3: 
      case 48: 
        break;
      default: 
        if ((zzInput == -1) && (zzStartRead == zzCurrentPos))
        {
          zzAtEOF = true;
          return null;
        }
        zzScanError(1);
      }
    }
  }
}

/* Location:
 * Qualified Name:     org.json.simple.parser.Yylex
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package org.json.simple.parser;

public class Yytoken
{
  public static final int TYPE_VALUE = 0;
  public static final int TYPE_LEFT_BRACE = 1;
  public static final int TYPE_RIGHT_BRACE = 2;
  public static final int TYPE_LEFT_SQUARE = 3;
  public static final int TYPE_RIGHT_SQUARE = 4;
  public static final int TYPE_COMMA = 5;
  public static final int TYPE_COLON = 6;
  public static final int TYPE_EOF = -1;
  public int type = 0;
  public Object value = null;
  
  public Yytoken(int type, Object value)
  {
    this.type = type;
    this.value = value;
  }
  
  public String toString()
  {
    StringBuffer sb = new StringBuffer();
    switch (type)
    {
    case 0: 
      sb.append("VALUE(").append(value).append(")");
      break;
    case 1: 
      sb.append("LEFT BRACE({)");
      break;
    case 2: 
      sb.append("RIGHT BRACE(})");
      break;
    case 3: 
      sb.append("LEFT SQUARE([)");
      break;
    case 4: 
      sb.append("RIGHT SQUARE(])");
      break;
    case 5: 
      sb.append("COMMA(,)");
      break;
    case 6: 
      sb.append("COLON(:)");
      break;
    case -1: 
      sb.append("END OF FILE");
    }
    return sb.toString();
  }
}

/* Location:
 * Qualified Name:     org.json.simple.parser.Yytoken
 * Java Class Version: 1.2 (46.0)
 * JD-Core Version:    0.7.1
 */
package com.crashlytics.api;

import java.util.Date;

public class ApiUtils
{
  public static Date dateFromEpochSeconds(long secondsSinceEpoch)
  {
    return new Date(secondsSinceEpoch * 1000L);
  }
}

/* Location:
 * Qualified Name:     com.crashlytics.api.ApiUtils
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.crashlytics.api;

public enum App$Status
{
  ACTIVATED,  BUILT,  CONFIGURED,  NEW,  DELETED,  UNKNOWN;
  
  private App$Status() {}
}

/* Location:
 * Qualified Name:     com.crashlytics.api.App.Status
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.crashlytics.api;

import com.crashlytics.tools.android.DeveloperTools;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.URL;
import javax.imageio.ImageIO;
import org.json.simple.JSONObject;

public class App
{
  public static enum Status
  {
    ACTIVATED,  BUILT,  CONFIGURED,  NEW,  DELETED,  UNKNOWN;
    
    private Status() {}
  }
  
  private static final Object JSON_ID = "id";
  private static final String JSON_NAME = "name";
  private static final String JSON_BUNDLE_ID = "bundle_identifier";
  private static final String JSON_PLATFORM = "platform";
  private static final String JSON_STATUS = "status";
  private static final String JSON_IMPACTED_DEVICE_COUNT = "impacted_devices_count";
  private static final String JSON_UNRESOLVED_ISSUE_COUNT = "unresolved_issues_count";
  private static final String JSON_ICON64_URL = "icon_url";
  private final String _id;
  private final String _name;
  private final String _bundleId;
  private final String _platform;
  private final String _icon64_url;
  private final int _impactedDeviceCount;
  private final int _unresolvedIssueCount;
  private final Organization _org;
  private final Status _status;
  
  private static Status statusFromString(String statusStr)
  {
    try
    {
      return Status.valueOf(statusStr.toUpperCase());
    }
    catch (Exception e)
    {
      DeveloperTools.logE("Unknown status string: " + statusStr, e);
    }
    return Status.UNKNOWN;
  }
  
  public App(String id, String name, String bundleId, String platform, String icon64_url, int impactedDeviceCount, int unresolvedIssueCount, Organization org, Status status)
  {
    if ((bundleId == null) || (bundleId.isEmpty())) {
      throw new IllegalArgumentException("Invalid bundleId: " + bundleId);
    }
    _id = id;
    _name = name;
    _bundleId = bundleId;
    _platform = platform;
    _icon64_url = icon64_url;
    _org = org;
    _status = status;
    _impactedDeviceCount = impactedDeviceCount;
    _unresolvedIssueCount = unresolvedIssueCount;
  }
  
  public App(JSONObject json, Organization org)
  {
    this((String)json.get(JSON_ID), (String)json.get("name"), (String)json.get("bundle_identifier"), (String)json.get("platform"), (String)json.get("icon_url"), ((Long)json.get("impacted_devices_count")).intValue(), ((Long)json.get("unresolved_issues_count")).intValue(), org, statusFromString((String)json.get("status")));
  }
  
  public String getId()
  {
    return _id;
  }
  
  public String getName()
  {
    return _name;
  }
  
  public String getBundleIdForDisplay()
  {
    return _bundleId;
  }
  
  public boolean bundleIdEquals(String bundleId)
  {
    return _bundleId.equalsIgnoreCase(bundleId);
  }
  
  public String getPlatform()
  {
    return _platform;
  }
  
  public String getIcon64URL()
  {
    return _icon64_url;
  }
  
  public int getImpactedDeviceCount()
  {
    return _impactedDeviceCount;
  }
  
  public int getUnresolvedIssueCount()
  {
    return _unresolvedIssueCount;
  }
  
  public Organization getOrganization()
  {
    return _org;
  }
  
  public Status getStatus()
  {
    return _status;
  }
  
  public int hashCode()
  {
    return _bundleId.hashCode();
  }
  
  public boolean equals(Object obj)
  {
    if (this == obj) {
      return true;
    }
    if ((obj == null) || (obj.getClass() != getClass())) {
      return false;
    }
    App other = (App)obj;
    
    return (_org.equals(_org)) && (_bundleId.equals(_bundleId));
  }
  
  public String toString()
  {
    return _bundleId + ":" + _name;
  }
  
  public BufferedImage getIconImageOrNull()
  {
    BufferedImage returnIconImage = null;
    String iconURL = getIcon64URL();
    try
    {
      if (!iconURL.startsWith("http")) {
        iconURL = DeveloperTools.getWebApi().getBaseApiUrl() + iconURL;
      }
      returnIconImage = ImageIO.read(new URL(iconURL));
    }
    catch (IOException e)
    {
      DeveloperTools.logE("Could not get image from " + iconURL, e);
    }
    return returnIconImage;
  }
}

/* Location:
 * Qualified Name:     com.crashlytics.api.App
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.crashlytics.api;

public class AppRelease
{
  public final String appName;
  public final String packageName;
  public final String instanceIdentifier;
  public final String displayVersion;
  public final String buildVersion;
  
  public AppRelease(String appName, String packageName, String instanceIdentifier, String displayVersion, String buildVersion)
  {
    this.appName = appName;
    this.packageName = packageName;
    this.instanceIdentifier = instanceIdentifier;
    this.displayVersion = displayVersion;
    this.buildVersion = buildVersion;
  }
  
  public String toString()
  {
    return "AppRelease [name: " + appName + "; package: " + packageName + "; instanceIdentifier: " + instanceIdentifier + "; displayVersion: " + displayVersion + "; buildVersion: " + buildVersion + "]";
  }
}

/* Location:
 * Qualified Name:     com.crashlytics.api.AppRelease
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.crashlytics.api;

public class AuthenticationException
  extends Exception
{
  public AuthenticationException(String msg)
  {
    super(msg);
  }
}

/* Location:
 * Qualified Name:     com.crashlytics.api.AuthenticationException
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.crashlytics.api;

import java.io.File;

public class DistributionData
{
  public final File distributionFile;
  public final long builtAtSeconds;
  
  public DistributionData(File distributionFile, long builtAtSeconds)
  {
    this.distributionFile = distributionFile;
    this.builtAtSeconds = builtAtSeconds;
  }
}

/* Location:
 * Qualified Name:     com.crashlytics.api.DistributionData
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.crashlytics.api;

public enum Issue$EventType
{
  CRASH,  NONFATAL;
  
  private Issue$EventType() {}
  
  private static EventType parseEventType(Long eventType)
  {
    EventType returnEventType = null;
    if (Issue.access$000() == eventType) {
      returnEventType = CRASH;
    } else if (Issue.access$100() == eventType) {
      returnEventType = NONFATAL;
    }
    return returnEventType;
  }
}

/* Location:
 * Qualified Name:     com.crashlytics.api.Issue.EventType
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.crashlytics.api;

import org.json.simple.JSONObject;

public class Issue
{
  private static final Long CRASH_EVENT = Long.valueOf(1L);
  private static final Long NONFATAL_EVENT = Long.valueOf(2L);
  
  public static enum EventType
  {
    CRASH,  NONFATAL;
    
    private EventType() {}
    
    private static EventType parseEventType(Long eventType)
    {
      EventType returnEventType = null;
      if (Issue.CRASH_EVENT == eventType) {
        returnEventType = CRASH;
      } else if (Issue.NONFATAL_EVENT == eventType) {
        returnEventType = NONFATAL;
      }
      return returnEventType;
    }
  }
  
  public static String JSON_ISSUE_DISPLAY_ID = "display_id";
  public static String JSON_ISSUE_IMPACT_LEVEL = "impact_level";
  public static String JSON_ISSUE_TITLE = "title";
  public static String JSON_ISSUE_SUBTITLE = "subtitle";
  public static String JSON_ISSUE_CRASH_COUNT = "crashes_count";
  public static String JSON_ISSUE_IMPACTED_DEVICES_COUNT = "impacted_devices_count";
  public static String JSON_ISSUE_BUILD = "build";
  public static String JSON_ISSUE_URL = "url";
  public static String JSON_EVENT_TYPE = "event_type";
  private final App _application;
  private int _impactLevel;
  private final String _title;
  private String _subtitle;
  private int _count;
  private int _impactedDeviceCount;
  private final int _displayId;
  private final String _build;
  private final String _url;
  private String _shortSubTitle;
  private EventType _eventType;
  
  public Issue(App app, int impactLevel, String title, String subtitle, int count, int impactedDeviceCount, int displayId, String build, String url, EventType eventType)
  {
    _application = app;
    _impactLevel = impactLevel;
    _title = title;
    _subtitle = subtitle;
    _count = count;
    _impactedDeviceCount = impactedDeviceCount;
    _displayId = displayId;
    _build = build;
    _url = url;
    _eventType = eventType;
    
    _shortSubTitle = _subtitle.substring(subtitle.substring(0, Math.max(0, subtitle
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2019. Infinite Loop Ltd