private static boolean isEnumArray(Exprent exprent) {
    if (exprent instanceof ArrayExprent) {
      ArrayExprent arr = (ArrayExprent) exprent;
      Exprent tmp = arr.getArray();
      if (tmp instanceof FieldExprent) {
        FieldExprent field = (FieldExprent)tmp;
        Exprent index = arr.getIndex();
        ClassesProcessor.ClassNode classNode = DecompilerContext.getClassProcessor().getMapRootClasses().get(field.getClassname());
        
        if (classNode == null || !"[I".equals(field.getDescriptor().descriptorString)) {
          // TODO: tighten up this check to avoid false positives
          return field.getName().startsWith("$SwitchMap") || //This is non-standard but we don't have any more information so..
            (index instanceof InvocationExprent && ((InvocationExprent) index).getName().equals("ordinal")) && field.isStatic();
        }

        StructField stField;
        if (classNode.getWrapper() == null) { // I have no idea why this happens, according to debug tests it doesn't even return null
          stField = classNode.classStruct.getField(field.getName(), field.getDescriptor().descriptorString);
        } else {
          stField = classNode.getWrapper().getClassStruct().getField(field.getName(), field.getDescriptor().descriptorString);
        }

        if ((stField.getAccessFlags() & STATIC_FINAL_SYNTHETIC) != STATIC_FINAL_SYNTHETIC) {
          return false;
        }

        boolean isSyntheticClass;
        if (classNode.getWrapper() == null) {
          isSyntheticClass = (classNode.classStruct.getAccessFlags() & CodeConstants.ACC_SYNTHETIC) == CodeConstants.ACC_SYNTHETIC;
        } else {
          isSyntheticClass = (classNode.getWrapper().getClassStruct().getAccessFlags() & CodeConstants.ACC_SYNTHETIC) == CodeConstants.ACC_SYNTHETIC;
        }

        if (isSyntheticClass) {
          return true; //TODO: Find a way to check the structure of the initalizer?
          //Exprent init = classNode.getWrapper().getStaticFieldInitializers().getWithKey(InterpreterUtil.makeUniqueKey(field.getName(), field.getDescriptor().descriptorString));
          //Above is null because we haven't preocess the class yet?
        }
      } else if (tmp instanceof InvocationExprent) {
        InvocationExprent inv = (InvocationExprent) tmp;
        if (inv.getName().startsWith("$SWITCH_TABLE$")) { // More nonstandard behavior. Seems like eclipse compiler stuff: https://bugs.eclipse.org/bugs/show_bug.cgi?id=544521 TODO: needs tests!
          return true;
        }
      }
    }
    return false;
  }
When Java introduced Enums they added the ability to use them in Switch statements.
This was done in a purely syntax sugar way using the old switch on int methods.
The compiler creates a synthetic class with a static int array field.
To support enums changing post compile, It initializes this field with a length of the current enum length.
And then for every referenced enum value it adds a mapping in the form of:
  try {
    field[Enum.VALUE.ordinal()] = 1;
  } catch (FieldNotFoundException e) {}

If a class has multiple switches on multiple enums, the compiler adds the init and try list to the BEGINNING of the static initalizer.
But they add the field to the END of the fields list.

Note: SOME compilers name the field starting with $SwitchMap, so if we do not have full context this can be a guess.
But Obfuscated/renamed code could cause issues
src/org/jetbrains/java/decompiler/modules/decompiler/SwitchHelper.java