feat(build): use semantic-release for automatic release publishing

Solve unreplaced fields names when deobfuscation is on (#241)

.codecov.yml

@@ -0,0 +1,14 @@
+coverage:
+  precision: 2
+  round: down
+  range: "50...100"
+
+  status:
+    project:
+      default: on
+    patch:
+      default: on
+    changes:
+      default: off
+
+comment: false

.gitignore

@@ -10,13 +10,17 @@ out/
 *.ipr
 *.iws
 
+**/.DS_Store
+
 bin/
 target/
 build/
+classes/
 idea/
 .gradle/
-gradle.properties
+node_modules/
 
+jadx-output/
 *-tmp/
 
 *.dex
@@ -24,4 +28,3 @@ gradle.properties
 *.dump
 *.log
 *.cfg
-

.gitlab-ci.yml

@@ -0,0 +1,24 @@
+image: java:8
+
+variables:
+    GRADLE_OPTS: "-Dorg.gradle.daemon=false"
+    TERM: "dumb"
+
+before_script:
+    - chmod +x gradlew
+
+stages:
+  - build
+
+build:
+  stage: build
+  script:
+    - sed -i " 1 s/.*/&-glb$(git rev-list --count HEAD)-$(git rev-parse --short HEAD)/" version
+    - cat version
+    - ./gradlew -g /cache/.gradle clean build jacocoTestReport
+    - ./gradlew -g /cache/.gradle clean sonarqube -Dsonar.host.url=$SONAR_HOST -Dsonar.organization=$SONAR_ORG -Dsonar.login=$SONAR_TOKEN
+    - ./gradlew -g /cache/.gradle clean dist
+  artifacts:
+    paths:
+    - build/jadx*.zip
+    - build/jadx*.exe

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "jadx-test-app/test-app"]
+	path = jadx-test-app/test-app
+	url = git://github.com/skylot/jadx-test-app.git

.releaserc.yml

@@ -0,0 +1,16 @@
+branch: release
+verifyConditions:
+  - '@semantic-release/github'
+prepare:
+  - path: '@semantic-release/exec'
+    cmd: "JADX_VERSION=${nextRelease.version} ./gradlew clean dist"
+publish:
+  - path: '@semantic-release/exec'
+    cmd: "JADX_VERSION=${nextRelease.version} BINTRAY_PACKAGE=releases bash scripts/bintray-upload.sh"
+  - path: '@semantic-release/github'
+    assets:
+      - path: 'build/*.zip'
+        label: 'zip bundle'
+      - path: 'build/*.exe'
+        label: 'jadx-gui windows'
+

.travis.yml

@@ -1,22 +1,50 @@
 language: java
-jdk:
-    - oraclejdk7
-    - openjdk7
-    - openjdk6
+sudo: false
+dist: trusty
+
+# don't build on tag push
+if: tag IS blank
+
+git:
+  depth: false
 
 before_install:
-    - chmod +x gradlew
+  - wget https://github.com/sormuras/bach/raw/master/install-jdk.sh
+  - chmod +x gradlew
+
+env:
+  global:
+    - TERM=dumb
+    - JADX_VERSION="$(git describe --abbrev=0 --tags)-b$TRAVIS_BUILD_NUMBER-$(git rev-parse --short HEAD)"
+
+matrix:
+  include:
+    - env: JDK=oracle-8
+      jdk: oraclejdk8
+    - env: JDK=oracle-10
+      install: . ./install-jdk.sh -F 10 -L BCL
 
 script:
-    - TERM=dumb ./gradlew clean build dist
+  - java -version
+  - ./gradlew clean build
 
-after_success:
-    - TERM=dumb ./gradlew jacocoTestReport coveralls
+deploy:
+  - provider: script
+    skip_cleanup: true
+    on:
+      branch: master
+      tags: false
+      condition: $JDK = oracle-8
+    script: bash scripts/travis-master.sh
 
-cache:
-    directories:
-        - $HOME/.gradle
+  - provider: script
+    skip_cleanup: true
+    on:
+      branch: release
+      tags: false
+      condition: $JDK = oracle-8
+    script: bash scripts/travis-release.sh
 
 notifications:
-    email:
-        - skylot@gmail.com
+  email:
+    - skylot@gmail.com

CONTRIBUTING.md

@@ -0,0 +1,7 @@
+# Contribution
+
+To support this project you can:
+  - Post thoughts about new features/optimizations that important to you
+  - Submit bug using one of following patterns:
+    * Java code examples which decompiles incorrectly
+    * Error log and link to _public available_ apk file or app page on Google play

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -1,8 +1,8 @@
 The majority of jadx is written and copyrighted by me (Skylot)
-and released under the Apache 2.0 license:
+and released under the Apache 2.0 license (see LICENSE file for full license text):
 
 *******************************************************************************
-Copyright 2013, Skylot
+Copyright 2015, Skylot
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -18,8 +18,8 @@ limitations under the License.
 *******************************************************************************
 
 
-Various portions of the code including dx library are taken from 
-the Android Open Source Project, and are used in accordance with 
+Various portions of the code including dx library are taken from
+the Android Open Source Project, and are used in accordance with
 the following license:
 
 *******************************************************************************
@@ -74,10 +74,10 @@ Copyright (c) 2004-2011 QOS.ch
  distribute,  sublicense, and/or sell  copies of  the Software,  and to
  permit persons to whom the Software  is furnished to do so, subject to
  the following conditions:
- 
+
  The  above  copyright  notice  and  this permission  notice  shall  be
  included in all copies or substantial portions of the Software.
- 
+
  THE  SOFTWARE IS  PROVIDED  "AS  IS", WITHOUT  WARRANTY  OF ANY  KIND,
  EXPRESS OR  IMPLIED, INCLUDING  BUT NOT LIMITED  TO THE  WARRANTIES OF
  MERCHANTABILITY,    FITNESS    FOR    A   PARTICULAR    PURPOSE    AND
@@ -92,14 +92,14 @@ Logback source code and binaries are dual-licensed under the EPL v1.0 and the LG
 
 *******************************************************************************
 Logback: the reliable, generic, fast and flexible logging framework.
-Copyright (C) 1999-2012, QOS.ch. All rights reserved. 
+Copyright (C) 1999-2012, QOS.ch. All rights reserved.
 
 This program and the accompanying materials are dual-licensed under
 either the terms of the Eclipse Public License v1.0 as published by
 the Eclipse Foundation
- 
+
   or (per the licensee's choosing)
- 
+
 under the terms of the GNU Lesser General Public License version 2.1
 as published by the Free Software Foundation.
 *******************************************************************************
@@ -144,7 +144,8 @@ THE POSSIBILITY OF SUCH DAMAGE.
 Jadx-gui components
 ===================
 
-RSyntaxTextArea library licensed under modified BSD liense:
+RSyntaxTextArea library (https://github.com/bobbylight/RSyntaxTextArea)
+licensed under modified BSD license:
 
 *******************************************************************************
 Copyright (c) 2012, Robert Futrell
@@ -174,7 +175,39 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *******************************************************************************
 
 
+Concurrent Trees (https://code.google.com/p/concurrent-trees/)
+licenced under Apache License 2.0:
+
+*******************************************************************************
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*******************************************************************************
+
+
+Image Viewer (https://github.com/kazocsaba/imageviewer)
+
+*******************************************************************************
+Copyright (c) 2008-2012 Kazó Csaba
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*******************************************************************************
+
+JFontChooser Component - http://sourceforge.jp/projects/jfontchooser/
+
 Icons copied from several places:
  - Eclipse Project (JDT UI) - licensed under EPL v1.0 (http://www.eclipse.org/legal/epl-v10.html)
- - famfamfam silk icon set (http://www.famfamfam.com/lab/icons/silk/) - licensed under Creative Commons Attribution 2.5 License (http://creativecommons.org/licenses/by/2.5/)
-
+ - famfamfam silk icon set (http://www.famfamfam.com/lab/icons/silk/) - licensed
+     under Creative Commons Attribution 2.5 License (http://creativecommons.org/licenses/by/2.5/)

README.md

@@ -1,23 +1,33 @@
 ## JADX
 
 [![Build Status](https://travis-ci.org/skylot/jadx.png?branch=master)](https://travis-ci.org/skylot/jadx)
-[![Build Status](https://drone.io/github.com/skylot/jadx/status.png)](https://drone.io/github.com/skylot/jadx/latest)
-[![Coverage Status](https://coveralls.io/repos/skylot/jadx/badge.png)](https://coveralls.io/r/skylot/jadx)
-[![Coverity Scan Build Status](https://scan.coverity.com/projects/2166/badge.svg)](https://scan.coverity.com/projects/2166)
+[![Code Coverage](https://codecov.io/gh/skylot/jadx/branch/master/graph/badge.svg)](https://codecov.io/gh/skylot/jadx)
+[![SonarQube Bugs](https://sonarcloud.io/api/project_badges/measure?project=jadx&metric=bugs)](https://sonarcloud.io/dashboard?id=jadx)
+[![License](http://img.shields.io/:license-apache-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.html)
+[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
 
 **jadx** - Dex to Java decompiler
 
 Command line and GUI tools for produce Java source code from Android Dex and Apk files
 
-![jadx-gui screenshot](http://skylot.github.io/jadx/jadx-gui.png)
+![jadx-gui screenshot](https://i.imgur.com/h917IBZ.png)
+
 
 ### Downloads
-- [unstable](https://drone.io/github.com/skylot/jadx/files)
-- from [github](https://github.com/skylot/jadx/releases)
-- from [sourceforge](http://sourceforge.net/projects/jadx/files/)
+- latest [unstable build: ![Download](https://api.bintray.com/packages/skylot/jadx/unstable/images/download.svg) ](https://bintray.com/skylot/jadx/unstable/_latestVersion#files)
+- release from [github: ![Latest release](https://img.shields.io/github/release/skylot/jadx.svg)](https://github.com/skylot/jadx/releases/latest)
+- release from [bintray: ![Download](https://api.bintray.com/packages/skylot/jadx/releases/images/download.svg) ](https://bintray.com/skylot/jadx/releases/_latestVersion#files)
 
+After download unpack zip file go to `bin` directory and run:
+- `jadx` - command line version
+- `jadx-gui` - graphical version
+
+On Windows run `.bat` files with double-click\
+**Note:** ensure you have installed Java 8 64-bit version
 
 ### Building from source
+Java 8 JDK or higher must be installed:
+
     git clone https://github.com/skylot/jadx.git
     cd jadx
     ./gradlew dist
@@ -33,7 +43,7 @@ Run **jadx** on itself:
 
     cd build/jadx/
     bin/jadx -d out lib/jadx-core-*.jar
-    #or
+    # or
     bin/jadx-gui lib/jadx-core-*.jar
 
 
@@ -41,22 +51,37 @@ Run **jadx** on itself:
 ```
 jadx[-gui] [options] <input file> (.dex, .apk, .jar or .class)
 options:
- -d, --output-dir    - output directory
- -j, --threads-count - processing threads count
- -f, --fallback      - make simple dump (using goto instead of 'if', 'for', etc)
-     --cfg           - save methods control flow graph to dot file
-     --raw-cfg       - save methods control flow graph (use raw instructions)
- -v, --verbose       - verbose output
- -h, --help          - print this help
+ -d,  --output-dir           - output directory
+ -ds, --output-dir-src       - output directory for sources
+ -dr, --output-dir-res       - output directory for resources
+ -j,  --threads-count        - processing threads count
+ -r,  --no-res               - do not decode resources
+ -s,  --no-src               - do not decompile source code
+ -e,  --export-gradle        - save as android gradle project
+      --show-bad-code        - show inconsistent code (incorrectly decompiled)
+      --no-imports           - disable use of imports, always write entire package name
+      --no-replace-consts    - don't replace constant value with matching constant field
+      --escape-unicode       - escape non latin characters in strings (with \u)
+      --deobf                - activate deobfuscation
+      --deobf-min            - min length of name
+      --deobf-max            - max length of name
+      --deobf-rewrite-cfg    - force to save deobfuscation map
+      --deobf-use-sourcename - use source file name as class name alias
+      --cfg                  - save methods control flow graph to dot file
+      --raw-cfg              - save methods control flow graph (use raw instructions)
+ -f,  --fallback             - make simple dump (using goto instead of 'if', 'for', etc)
+ -v,  --verbose              - verbose output
+ -h,  --help                 - print this help
 Example:
  jadx -d out classes.dex
 ```
+These options also worked on jadx-gui running from command line and override options from preferences dialog
 
 ### Troubleshooting
 ##### Out of memory error:
-  - Reduce processing threads count (`-j` option) 
+  - Reduce processing threads count (`-j` option)
   - Increase maximum java heap size:
-    * command line (example for linux): 
+    * command line (example for linux):
       `JAVA_OPTS="-Xmx4G" jadx -j 1 some.apk`
     * edit 'jadx' script (jadx.bat on Windows) and setup bigger heap size:
       `DEFAULT_JVM_OPTS="-Xmx2500M"`
@@ -64,4 +89,4 @@ Example:
 ---------------------------------------
 *Licensed under the Apache 2.0 License*
 
-*Copyright 2014 by Skylot*
+*Copyright 2018 by Skylot*

build.gradle

@@ -1,25 +1,34 @@
-ext.jadxVersion = file('version').readLines().get(0)
+plugins {
+    id 'com.github.ksoichiro.console.reporter' version '0.5.0'
+    id 'org.sonarqube' version '2.6.2'
+    id 'com.github.ben-manes.versions' version '0.20.0'
+}
+
+ext.jadxVersion = System.getenv('JADX_VERSION') ?: "dev"
 version = jadxVersion
+println("jadx version: ${jadxVersion}")
 
-apply plugin: 'sonar-runner'
-
-subprojects {
+allprojects {
     apply plugin: 'java'
     apply plugin: 'groovy'
     apply plugin: 'jacoco'
-    apply plugin: 'coveralls'
+    apply plugin: 'com.github.ksoichiro.console.reporter'
 
     version = jadxVersion
 
     tasks.withType(JavaCompile) {
-        sourceCompatibility = JavaVersion.VERSION_1_6
-        targetCompatibility = JavaVersion.VERSION_1_6
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
 
         if (!"$it".contains(':jadx-samples:')) {
             options.compilerArgs << '-Xlint' << '-Xlint:unchecked' << '-Xlint:deprecation'
         }
     }
 
+    compileJava {
+        options.encoding = "UTF-8"
+    }
+
     jar {
         version = jadxVersion
         manifest {
@@ -28,42 +37,57 @@ subprojects {
     }
 
     dependencies {
-        compile 'org.slf4j:slf4j-api:1.7.7'
+        compile 'org.slf4j:slf4j-api:1.7.25'
 
-        testCompile 'ch.qos.logback:logback-classic:1.1.2'
-        testCompile 'junit:junit:4.11'
-        testCompile 'org.mockito:mockito-core:1.9.5'
-        testCompile 'org.spockframework:spock-core:0.7-groovy-2.0'
-        testCompile 'cglib:cglib-nodep:3.1'
+        testCompile 'ch.qos.logback:logback-classic:1.2.3'
+        testCompile 'junit:junit:4.12'
+        testCompile 'org.hamcrest:hamcrest-library:1.3'
+        testCompile 'org.mockito:mockito-core:2.20.1'
+        testCompile 'org.spockframework:spock-core:1.1-groovy-2.4'
+        testCompile 'cglib:cglib-nodep:3.2.7'
     }
 
     repositories {
+        mavenLocal()
         mavenCentral()
+        jcenter()
     }
 
+    jacoco {
+        toolVersion = "0.8.1"
+    }
     jacocoTestReport {
         reports {
-            xml.enabled = true // coveralls plugin depends on xml format report
+            xml.enabled = true
             html.enabled = true
         }
     }
 }
 
-buildscript {
-    repositories {
-        mavenCentral()
-    }
-
-    dependencies {
-        // setup coveralls (http://coveralls.io/) see http://github.com/kt3k/coveralls-gradle-plugin
-        classpath 'org.kt3k.gradle.plugin:coveralls-gradle-plugin:0.6.1'
+sonarqube {
+    properties {
+        property 'sonar.exclusions', '**/jadx/samples/**/*,**/test-app/**/*'
+        property 'sonar.coverage.exclusions', '**/jadx/gui/**/*'
     }
 }
 
-task copyArtifacts(type: Sync, dependsOn: ['jadx-cli:installApp', 'jadx-gui:installApp']) {
+dependencyUpdates.resolutionStrategy = {
+    componentSelection { rules ->
+        rules.all { ComponentSelection selection ->
+            boolean rejected = ['alpha', 'beta', 'rc', 'cr', 'm', 'atlassian'].any { qualifier ->
+                selection.candidate.version ==~ /(?i).*[.-]${qualifier}[.\d-]*/
+            }
+            if (rejected) {
+                selection.reject('Release candidate')
+            }
+        }
+    }
+}
+
+task copyArtifacts(type: Sync, dependsOn: ['jadx-cli:installDist', 'jadx-gui:installDist']) {
     destinationDir file("$buildDir/jadx")
     ['jadx-cli', 'jadx-gui'].each {
-        from tasks.getByPath(":${it}:installApp").destinationDir
+        from tasks.getByPath(":${it}:installDist").destinationDir
     }
 }
 
@@ -73,20 +97,33 @@ task pack(type: Zip, dependsOn: copyArtifacts) {
     from copyArtifacts.destinationDir
 }
 
-task dist(dependsOn: pack) {
+task copyExe(type: Copy, dependsOn: 'jadx-gui:createExe') {
+    group 'jadx'
+    description = 'Copy exe to build dir'
+    destinationDir buildDir
+    from tasks.getByPath('jadx-gui:createExe').outputs
+    include '*.exe'
+}
+
+task dist(dependsOn: [pack, copyExe]) {
+    group 'jadx'
     description = 'Build jadx distribution zip'
 }
 
 task samples(dependsOn: 'jadx-samples:samples') {
+    group 'jadx'
 }
 
-task build(dependsOn: [dist, samples]) {
+task testAppCheck(dependsOn: 'jadx-test-app:testAppCheck') {
+    group 'jadx'
 }
 
-task clean(type: Delete) {
+task cleanBuildDir(type: Delete) {
+    group 'jadx'
     delete buildDir
 }
 
-task wrapper(type: Wrapper) {
-    gradleVersion = '2.0'
-}
+build.dependsOn(dist, samples)
+
+clean.dependsOn(cleanBuildDir)
+

gradle.properties

@@ -0,0 +1 @@
+org.gradle.daemon=false

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.9-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.0-bin.zip

gradlew

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
 
 ##############################################################################
 ##
@@ -6,47 +6,6 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-esac
-
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
 # Attempt to set APP_HOME
 # Resolve links: $0 may be a link
 PRG="$0"
@@ -61,9 +20,49 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
+cd "`dirname \"$PRG\"`/" >/dev/null
 APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
+cd "$SAVED" >/dev/null
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
@@ -90,7 +89,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -114,6 +113,7 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
@@ -154,11 +154,19 @@ if $cygwin ; then
     esac
 fi
 
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
-function splitJvmOpts() {
-    JVM_OPTS=("$@")
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
 }
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+APP_ARGS=$(save "$@")
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -8,14 +8,14 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
@@ -46,10 +46,9 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windowz variants
+@rem Get command-line arguments, handling Windows variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
 
 :win9xME_args
 @rem Slurp the command line arguments.
@@ -60,11 +59,6 @@ set _SKIP=2
 if "x%~1" == "x" goto execute
 
 set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
 
 :execute
 @rem Setup the command line

jadx-cli/build.gradle

@@ -5,8 +5,8 @@ applicationName = 'jadx'
 
 dependencies {
     compile(project(':jadx-core'))
-    compile 'com.beust:jcommander:1.35'
-    compile 'ch.qos.logback:logback-classic:1.1.2'
+    compile 'com.beust:jcommander:1.74'
+    compile 'ch.qos.logback:logback-classic:1.2.3'
 }
 
 applicationDistribution.with {
@@ -14,6 +14,10 @@ applicationDistribution.with {
         from '../.'
         include 'README.md'
         include 'NOTICE'
+        include 'LICENSE'
     }
 }
 
+startScripts {
+    defaultJvmOpts = ['-Xms128M', '-Xmx4g']
+}

jadx-cli/src/main/java/jadx/cli/JadxCLI.java

@@ -1,68 +1,45 @@
 package jadx.cli;
 
-import jadx.api.JadxDecompiler;
-import jadx.core.utils.exceptions.JadxException;
-
-import java.io.File;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.JadxDecompiler;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+
 public class JadxCLI {
 	private static final Logger LOG = LoggerFactory.getLogger(JadxCLI.class);
 
-	public static void main(String[] args) throws JadxException {
+	public static void main(String[] args) {
+		int result = 0;
 		try {
 			JadxCLIArgs jadxArgs = new JadxCLIArgs();
-			if (processArgs(jadxArgs, args)) {
-				processAndSave(jadxArgs);
+			if (jadxArgs.processArgs(args)) {
+				result = processAndSave(jadxArgs);
 			}
-		} catch (Throwable e) {
-			LOG.error("jadx error: " + e.getMessage(), e);
-			System.exit(1);
+		} catch (Exception e) {
+			LOG.error("jadx error: {}", e.getMessage(), e);
+			result = 1;
+		} finally {
+			System.exit(result);
 		}
 	}
 
-	static void processAndSave(JadxCLIArgs jadxArgs) throws JadxException {
-		JadxDecompiler jadx = new JadxDecompiler(jadxArgs);
-		jadx.setOutputDir(jadxArgs.getOutDir());
-		jadx.loadFiles(jadxArgs.getInput());
+	static int processAndSave(JadxCLIArgs inputArgs) {
+		JadxDecompiler jadx = new JadxDecompiler(inputArgs.toJadxArgs());
+		try {
+			jadx.load();
+		} catch (JadxArgsValidateException e) {
+			LOG.error("Incorrect arguments: {}", e.getMessage());
+			return 1;
+		}
 		jadx.save();
-		if (jadx.getErrorsCount() != 0) {
+		int errorsCount = jadx.getErrorsCount();
+		if (errorsCount != 0) {
 			jadx.printErrorsReport();
 			LOG.error("finished with errors");
 		} else {
 			LOG.info("done");
 		}
-	}
-
-	static boolean processArgs(JadxCLIArgs jadxArgs, String[] args) throws JadxException {
-		if (!jadxArgs.processArgs(args)) {
-			return false;
-		}
-		if (jadxArgs.getInput().isEmpty()) {
-			LOG.error("Please specify input file");
-			jadxArgs.printUsage();
-			return false;
-		}
-		File outputDir = jadxArgs.getOutDir();
-		if (outputDir == null) {
-			String outDirName;
-			File file = jadxArgs.getInput().get(0);
-			String name = file.getName();
-			int pos = name.lastIndexOf('.');
-			if (pos != -1) {
-				outDirName = name.substring(0, pos);
-			} else {
-				outDirName = name + "-jadx-out";
-			}
-			LOG.info("output directory: " + outDirName);
-			outputDir = new File(outDirName);
-			jadxArgs.setOutputDir(outputDir);
-		}
-		if (outputDir.exists() && !outputDir.isDirectory()) {
-			throw new JadxException("Output directory exists as file " + outputDir);
-		}
-		return true;
+		return errorsCount;
 	}
 }

jadx-cli/src/main/java/jadx/cli/JadxCLIArgs.java

@@ -1,36 +1,79 @@
 package jadx.cli;
 
-import jadx.api.IJadxArgs;
-import jadx.api.JadxDecompiler;
-import jadx.core.utils.exceptions.JadxException;
-
-import java.io.File;
 import java.io.PrintStream;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.Appender;
 import com.beust.jcommander.JCommander;
 import com.beust.jcommander.Parameter;
 import com.beust.jcommander.ParameterDescription;
 import com.beust.jcommander.ParameterException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-public final class JadxCLIArgs implements IJadxArgs {
+import jadx.api.JadxArgs;
+import jadx.api.JadxDecompiler;
+import jadx.core.utils.exceptions.JadxException;
+import jadx.core.utils.files.FileUtils;
 
-	@Parameter(description = "<input file> (.dex, .apk, .jar or .class)")
-	protected List<String> files;
+public class JadxCLIArgs {
+
+	@Parameter(description = "<input file> (.apk, .dex, .jar or .class)")
+	protected List<String> files = new ArrayList<>(1);
 
 	@Parameter(names = {"-d", "--output-dir"}, description = "output directory")
-	protected String outDirName;
+	protected String outDir;
+
+	@Parameter(names = {"-ds", "--output-dir-src"}, description = "output directory for sources")
+	protected String outDirSrc;
+
+	@Parameter(names = {"-dr", "--output-dir-res"}, description = "output directory for resources")
+	protected String outDirRes;
+
+	@Parameter(names = {"-r", "--no-res"}, description = "do not decode resources")
+	protected boolean skipResources = false;
+
+	@Parameter(names = {"-s", "--no-src"}, description = "do not decompile source code")
+	protected boolean skipSources = false;
+
+	@Parameter(names = {"-e", "--export-gradle"}, description = "save as android gradle project")
+	protected boolean exportAsGradleProject = false;
 
 	@Parameter(names = {"-j", "--threads-count"}, description = "processing threads count")
-	protected int threadsCount = Runtime.getRuntime().availableProcessors();
+	protected int threadsCount = JadxArgs.DEFAULT_THREADS_COUNT;
 
-	@Parameter(names = {"-f", "--fallback"}, description = "make simple dump (using goto instead of 'if', 'for', etc)", help = true)
-	protected boolean fallbackMode = false;
+	@Parameter(names = {"--show-bad-code"}, description = "show inconsistent code (incorrectly decompiled)")
+	protected boolean showInconsistentCode = false;
+
+	@Parameter(names = {"--no-imports"}, description = "disable use of imports, always write entire package name")
+	protected boolean useImports = true;
+
+	@Parameter(names = "--no-replace-consts", description = "don't replace constant value with matching constant field")
+	protected boolean replaceConsts = true;
+
+	@Parameter(names = {"--escape-unicode"}, description = "escape non latin characters in strings (with \\u)")
+	protected boolean escapeUnicode = false;
+
+	@Parameter(names = {"--deobf"}, description = "activate deobfuscation")
+	protected boolean deobfuscationOn = false;
+
+	@Parameter(names = {"--deobf-min"}, description = "min length of name, renamed if shorter")
+	protected int deobfuscationMinLength = 3;
+
+	@Parameter(names = {"--deobf-max"}, description = "max length of name, renamed if longer")
+	protected int deobfuscationMaxLength = 64;
+
+	@Parameter(names = {"--deobf-rewrite-cfg"}, description = "force to save deobfuscation map")
+	protected boolean deobfuscationForceSave = false;
+
+	@Parameter(names = {"--deobf-use-sourcename"}, description = "use source file name as class name alias")
+	protected boolean deobfuscationUseSourceNameAsAlias = true;
 
 	@Parameter(names = {"--cfg"}, description = "save methods control flow graph to dot file")
 	protected boolean cfgOutput = false;
@@ -38,22 +81,25 @@ public final class JadxCLIArgs implements IJadxArgs {
 	@Parameter(names = {"--raw-cfg"}, description = "save methods control flow graph (use raw instructions)")
 	protected boolean rawCfgOutput = false;
 
+	@Parameter(names = {"-f", "--fallback"}, description = "make simple dump (using goto instead of 'if', 'for', etc)")
+	protected boolean fallbackMode = false;
+
 	@Parameter(names = {"-v", "--verbose"}, description = "verbose output")
 	protected boolean verbose = false;
 
+	@Parameter(names = {"--version"}, description = "print jadx version")
+	protected boolean printVersion = false;
+
 	@Parameter(names = {"-h", "--help"}, description = "print this help", help = true)
 	protected boolean printHelp = false;
 
-	private final List<File> input = new ArrayList<File>(1);
-	private File outputDir;
-
 	public boolean processArgs(String[] args) {
 		return parse(args) && process();
 	}
 
 	private boolean parse(String[] args) {
 		try {
-			new JCommander(this, args);
+			makeJCommander().parse(args);
 			return true;
 		} catch (ParameterException e) {
 			System.err.println("Arguments parse error: " + e.getMessage());
@@ -62,35 +108,31 @@ public final class JadxCLIArgs implements IJadxArgs {
 		}
 	}
 
+	private JCommander makeJCommander() {
+		return JCommander.newBuilder().addObject(this).build();
+	}
+
 	private boolean process() {
-		if (isPrintHelp()) {
+		if (printHelp) {
 			printUsage();
 			return false;
 		}
+		if (printVersion) {
+			System.out.println(JadxDecompiler.getVersion());
+			return false;
+		}
 		try {
 			if (threadsCount <= 0) {
-				throw new JadxException("Threads count must be positive");
+				throw new JadxException("Threads count must be positive, got: " + threadsCount);
 			}
-			if (files != null) {
-				for (String fileName : files) {
-					File file = new File(fileName);
-					if (file.exists()) {
-						input.add(file);
-					} else {
-						throw new JadxException("File not found: " + file);
-					}
-				}
-			}
-			if (input.size() > 1) {
-				throw new JadxException("Only one input file is supported");
-			}
-			if (outDirName != null) {
-				outputDir = new File(outDirName);
-			}
-			if (isVerbose()) {
+			if (verbose) {
 				ch.qos.logback.classic.Logger rootLogger =
 						(ch.qos.logback.classic.Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
-				rootLogger.setLevel(ch.qos.logback.classic.Level.DEBUG);
+				// remove INFO ThresholdFilter
+				Appender<ILoggingEvent> appender = rootLogger.getAppender("STDOUT");
+				if (appender != null) {
+					appender.clearAllFilters();
+				}
 			}
 		} catch (JadxException e) {
 			System.err.println("ERROR: " + e.getMessage());
@@ -101,7 +143,7 @@ public final class JadxCLIArgs implements IJadxArgs {
 	}
 
 	public void printUsage() {
-		JCommander jc = new JCommander(this);
+		JCommander jc = makeJCommander();
 		// print usage in not sorted fields order (by default its sorted by description)
 		PrintStream out = System.out;
 		out.println();
@@ -111,31 +153,44 @@ public final class JadxCLIArgs implements IJadxArgs {
 		out.println("options:");
 
 		List<ParameterDescription> params = jc.getParameters();
-
+		Map<String, ParameterDescription> paramsMap = new LinkedHashMap<>(params.size());
 		int maxNamesLen = 0;
 		for (ParameterDescription p : params) {
+			paramsMap.put(p.getParameterized().getName(), p);
 			int len = p.getNames().length();
 			if (len > maxNamesLen) {
 				maxNamesLen = len;
 			}
 		}
-
-		Field[] fields = this.getClass().getDeclaredFields();
+		JadxCLIArgs args = new JadxCLIArgs();
+		Field[] fields = args.getClass().getDeclaredFields();
 		for (Field f : fields) {
-			for (ParameterDescription p : params) {
-				String name = f.getName();
-				if (name.equals(p.getParameterized().getName())) {
-					StringBuilder opt = new StringBuilder();
-					opt.append(' ').append(p.getNames());
-					addSpaces(opt, maxNamesLen - opt.length() + 2);
-					opt.append("- ").append(p.getDescription());
-					out.println(opt.toString());
-					break;
-				}
+			String name = f.getName();
+			ParameterDescription p = paramsMap.get(name);
+			if (p == null) {
+				continue;
 			}
+			StringBuilder opt = new StringBuilder();
+			opt.append("  ").append(p.getNames());
+			addSpaces(opt, maxNamesLen - opt.length() + 3);
+			opt.append("- ").append(p.getDescription());
+			addDefaultValue(args, f, opt);
+			out.println(opt);
 		}
 		out.println("Example:");
-		out.println(" jadx -d out classes.dex");
+		out.println("  jadx -d out classes.dex");
+	}
+
+	private void addDefaultValue(JadxCLIArgs args, Field f, StringBuilder opt) {
+		Class<?> fieldType = f.getType();
+		if (fieldType == int.class) {
+			try {
+				int val = f.getInt(args);
+				opt.append(" (default: ").append(val).append(")");
+			} catch (Exception e) {
+				// ignore
+			}
+		}
 	}
 
 	private static void addSpaces(StringBuilder str, int count) {
@@ -144,45 +199,112 @@ public final class JadxCLIArgs implements IJadxArgs {
 		}
 	}
 
-	public List<File> getInput() {
-		return input;
+	public JadxArgs toJadxArgs() {
+		JadxArgs args = new JadxArgs();
+		args.setInputFiles(files.stream().map(FileUtils::toFile).collect(Collectors.toList()));
+		args.setOutDir(FileUtils.toFile(outDir));
+		args.setOutDirSrc(FileUtils.toFile(outDirSrc));
+		args.setOutDirRes(FileUtils.toFile(outDirRes));
+		args.setThreadsCount(threadsCount);
+		args.setSkipSources(skipSources);
+		args.setSkipResources(skipResources);
+		args.setFallbackMode(fallbackMode);
+		args.setShowInconsistentCode(showInconsistentCode);
+		args.setCfgOutput(cfgOutput);
+		args.setRawCFGOutput(rawCfgOutput);
+		args.setReplaceConsts(replaceConsts);
+		args.setDeobfuscationOn(deobfuscationOn);
+		args.setDeobfuscationForceSave(deobfuscationForceSave);
+		args.setDeobfuscationMinLength(deobfuscationMinLength);
+		args.setDeobfuscationMaxLength(deobfuscationMaxLength);
+		args.setUseSourceNameAsClassAlias(deobfuscationUseSourceNameAsAlias);
+		args.setEscapeUnicode(escapeUnicode);
+		args.setExportAsGradleProject(exportAsGradleProject);
+		args.setUseImports(useImports);
+		return args;
 	}
 
-	@Override
-	public File getOutDir() {
-		return outputDir;
+	public List<String> getFiles() {
+		return files;
 	}
 
-	public void setOutputDir(File outputDir) {
-		this.outputDir = outputDir;
+	public String getOutDir() {
+		return outDir;
 	}
 
-	public boolean isPrintHelp() {
-		return printHelp;
+	public String getOutDirSrc() {
+		return outDirSrc;
+	}
+
+	public String getOutDirRes() {
+		return outDirRes;
+	}
+
+	public boolean isSkipResources() {
+		return skipResources;
+	}
+
+	public boolean isSkipSources() {
+		return skipSources;
 	}
 
-	@Override
 	public int getThreadsCount() {
 		return threadsCount;
 	}
 
-	@Override
-	public boolean isCFGOutput() {
-		return cfgOutput;
-	}
-
-	@Override
-	public boolean isRawCFGOutput() {
-		return rawCfgOutput;
-	}
-
-	@Override
 	public boolean isFallbackMode() {
 		return fallbackMode;
 	}
 
-	@Override
-	public boolean isVerbose() {
-		return verbose;
+	public boolean isShowInconsistentCode() {
+		return showInconsistentCode;
+	}
+
+	public boolean isUseImports() {
+		return useImports;
+	}
+
+	public boolean isDeobfuscationOn() {
+		return deobfuscationOn;
+	}
+
+	public int getDeobfuscationMinLength() {
+		return deobfuscationMinLength;
+	}
+
+	public int getDeobfuscationMaxLength() {
+		return deobfuscationMaxLength;
+	}
+
+	public boolean isDeobfuscationForceSave() {
+		return deobfuscationForceSave;
+	}
+
+	public boolean isDeobfuscationUseSourceNameAsAlias() {
+		return deobfuscationUseSourceNameAsAlias;
+	}
+
+	public boolean escapeUnicode() {
+		return escapeUnicode;
+	}
+
+	public boolean isEscapeUnicode() {
+		return escapeUnicode;
+	}
+
+	public boolean isCfgOutput() {
+		return cfgOutput;
+	}
+
+	public boolean isRawCfgOutput() {
+		return rawCfgOutput;
+	}
+
+	public boolean isReplaceConsts() {
+		return replaceConsts;
+	}
+
+	public boolean isExportAsGradleProject() {
+		return exportAsGradleProject;
 	}
 }

jadx-cli/src/main/resources/logback.xml

@@ -1,12 +1,15 @@
 <configuration>
 
     <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+            <level>INFO</level>
+        </filter>
         <encoder>
             <pattern>%-5level - %msg%n</pattern>
         </encoder>
     </appender>
 
-    <root level="INFO">
+    <root level="DEBUG">
         <appender-ref ref="STDOUT"/>
     </root>
 

jadx-cli/src/test/java/jadx/cli/JadxCLIArgsTest.java

@@ -0,0 +1,40 @@
+package jadx.cli;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.hamcrest.Matchers.is;
+import static org.junit.Assert.assertThat;
+
+public class JadxCLIArgsTest {
+
+	private static final Logger LOG = LoggerFactory.getLogger(JadxCLIArgsTest.class);
+
+	@Test
+	public void testInvertedBooleanOption() {
+		assertThat(parse("--no-replace-consts").isReplaceConsts(), is(false));
+		assertThat(parse("").isReplaceConsts(), is(true));
+	}
+
+	@Test
+	public void testEscapeUnicodeOption() {
+		assertThat(parse("--escape-unicode").isEscapeUnicode(), is(true));
+		assertThat(parse("").isEscapeUnicode(), is(false));
+	}
+
+	@Test
+	public void testSrcOption() {
+		assertThat(parse("--no-src").isSkipSources(), is(true));
+		assertThat(parse("-s").isSkipSources(), is(true));
+		assertThat(parse("").isSkipSources(), is(false));
+	}
+
+	private JadxCLIArgs parse(String... args) {
+		JadxCLIArgs jadxArgs = new JadxCLIArgs();
+		boolean res = jadxArgs.processArgs(args);
+		assertThat(res, is(true));
+		LOG.info("Jadx args: {}", jadxArgs.toJadxArgs());
+		return jadxArgs;
+	}
+}

jadx-core/build.gradle

@@ -1,13 +1,17 @@
-ext.jadxClasspath = 'clsp-data/android-4.3.jar'
+ext.jadxClasspath = 'clsp-data/android-5.1.jar'
 
 dependencies {
-    compile files('lib/dx-1.8.jar')
-    compile 'org.ow2.asm:asm:5.0.3'
     runtime files(jadxClasspath)
-}
-
-task packTests(type: Jar) {
-    classifier = 'tests'
-    from sourceSets.test.output
+
+    compile files('lib/dx-1.14.jar')
+    compile 'commons-io:commons-io:2.6'
+    compile 'org.ow2.asm:asm:6.2'
+    compile 'org.jetbrains:annotations:16.0.2'
+    compile 'uk.com.robust-it:cloning:1.9.10'
+
+    testCompile 'org.smali:smali:2.2.4'
+    testCompile 'org.smali:baksmali:2.2.4'
+
+    testCompile 'org.apache.commons:commons-lang3:3.7'
 }
 

jadx-core/src/main/java/jadx/api/CodePosition.java

@@ -2,24 +2,32 @@ package jadx.api;
 
 public final class CodePosition {
 
-	private final JavaClass cls;
+	private final JavaNode node;
 	private final int line;
 	private final int offset;
 
-	public CodePosition(JavaClass cls, int line, int offset) {
-		this.cls = cls;
+	public CodePosition(JavaNode node, int line, int offset) {
+		this.node = node;
 		this.line = line;
 		this.offset = offset;
 	}
 
 	public CodePosition(int line, int offset) {
-		this.cls = null;
+		this.node = null;
 		this.line = line;
 		this.offset = offset;
 	}
 
+	public JavaNode getNode() {
+		return node;
+	}
+
 	public JavaClass getJavaClass() {
-		return cls;
+		JavaClass parent = node.getDeclaringClass();
+		if (parent == null && node instanceof JavaClass) {
+			return (JavaClass) node;
+		}
+		return parent;
 	}
 
 	public int getLine() {
@@ -30,10 +38,6 @@ public final class CodePosition {
 		return offset;
 	}
 
-	public boolean isSet() {
-		return line != 0 || offset != 0;
-	}
-
 	@Override
 	public boolean equals(Object o) {
 		if (this == o) {
@@ -53,6 +57,6 @@ public final class CodePosition {
 
 	@Override
 	public String toString() {
-		return line + ":" + offset + (cls != null ? " " + cls : "");
+		return line + ":" + offset + (node != null ? " " + node : "");
 	}
 }

jadx-core/src/main/java/jadx/api/DefaultJadxArgs.java

@@ -1,36 +0,0 @@
-package jadx.api;
-
-import java.io.File;
-
-public class DefaultJadxArgs implements IJadxArgs {
-
-	@Override
-	public File getOutDir() {
-		return new File("jadx-output");
-	}
-
-	@Override
-	public int getThreadsCount() {
-		return Runtime.getRuntime().availableProcessors();
-	}
-
-	@Override
-	public boolean isCFGOutput() {
-		return false;
-	}
-
-	@Override
-	public boolean isRawCFGOutput() {
-		return false;
-	}
-
-	@Override
-	public boolean isFallbackMode() {
-		return false;
-	}
-
-	@Override
-	public boolean isVerbose() {
-		return false;
-	}
-}

jadx-core/src/main/java/jadx/api/IJadxArgs.java

@@ -1,17 +0,0 @@
-package jadx.api;
-
-import java.io.File;
-
-public interface IJadxArgs {
-	File getOutDir();
-
-	int getThreadsCount();
-
-	boolean isCFGOutput();
-
-	boolean isRawCFGOutput();
-
-	boolean isFallbackMode();
-
-	boolean isVerbose();
-}

jadx-core/src/main/java/jadx/api/JadxArgs.java

@@ -0,0 +1,241 @@
+package jadx.api;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+public class JadxArgs {
+
+	public static final int DEFAULT_THREADS_COUNT = Math.max(1, Runtime.getRuntime().availableProcessors() / 2);
+
+	public static final String DEFAULT_OUT_DIR = "jadx-output";
+	public static final String DEFAULT_SRC_DIR = "sources";
+	public static final String DEFAULT_RES_DIR = "resources";
+
+	private List<File> inputFiles = new ArrayList<>(1);
+
+	private File outDir;
+	private File outDirSrc;
+	private File outDirRes;
+
+	private int threadsCount = DEFAULT_THREADS_COUNT;
+
+	private boolean cfgOutput = false;
+	private boolean rawCFGOutput = false;
+
+	private boolean fallbackMode = false;
+	private boolean showInconsistentCode = false;
+
+	private boolean useImports = true;
+
+	private boolean isSkipResources = false;
+	private boolean isSkipSources = false;
+
+	private boolean isDeobfuscationOn = false;
+	private boolean isDeobfuscationForceSave = false;
+	private boolean useSourceNameAsClassAlias = false;
+
+	private int deobfuscationMinLength = 0;
+	private int deobfuscationMaxLength = Integer.MAX_VALUE;
+
+	private boolean escapeUnicode = false;
+	private boolean replaceConsts = true;
+	private boolean exportAsGradleProject = false;
+
+	public JadxArgs() {
+		// use default options
+	}
+
+	public void setRootDir(File rootDir) {
+		setOutDir(rootDir);
+		setOutDirSrc(new File(rootDir, DEFAULT_SRC_DIR));
+		setOutDirRes(new File(rootDir, DEFAULT_RES_DIR));
+	}
+
+	public List<File> getInputFiles() {
+		return inputFiles;
+	}
+
+	public void setInputFiles(List<File> inputFiles) {
+		this.inputFiles = inputFiles;
+	}
+
+	public File getOutDir() {
+		return outDir;
+	}
+
+	public void setOutDir(File outDir) {
+		this.outDir = outDir;
+	}
+
+	public File getOutDirSrc() {
+		return outDirSrc;
+	}
+
+	public void setOutDirSrc(File outDirSrc) {
+		this.outDirSrc = outDirSrc;
+	}
+
+	public File getOutDirRes() {
+		return outDirRes;
+	}
+
+	public void setOutDirRes(File outDirRes) {
+		this.outDirRes = outDirRes;
+	}
+
+	public int getThreadsCount() {
+		return threadsCount;
+	}
+
+	public void setThreadsCount(int threadsCount) {
+		this.threadsCount = threadsCount;
+	}
+
+	public boolean isCfgOutput() {
+		return cfgOutput;
+	}
+
+	public void setCfgOutput(boolean cfgOutput) {
+		this.cfgOutput = cfgOutput;
+	}
+
+	public boolean isRawCFGOutput() {
+		return rawCFGOutput;
+	}
+
+	public void setRawCFGOutput(boolean rawCFGOutput) {
+		this.rawCFGOutput = rawCFGOutput;
+	}
+
+	public boolean isFallbackMode() {
+		return fallbackMode;
+	}
+
+	public void setFallbackMode(boolean fallbackMode) {
+		this.fallbackMode = fallbackMode;
+	}
+
+	public boolean isShowInconsistentCode() {
+		return showInconsistentCode;
+	}
+
+	public void setShowInconsistentCode(boolean showInconsistentCode) {
+		this.showInconsistentCode = showInconsistentCode;
+	}
+
+	public boolean isUseImports() {
+		return useImports;
+	}
+
+	public void setUseImports(boolean useImports) {
+		this.useImports = useImports;
+	}
+
+	public boolean isSkipResources() {
+		return isSkipResources;
+	}
+
+	public void setSkipResources(boolean skipResources) {
+		isSkipResources = skipResources;
+	}
+
+	public boolean isSkipSources() {
+		return isSkipSources;
+	}
+
+	public void setSkipSources(boolean skipSources) {
+		isSkipSources = skipSources;
+	}
+
+	public boolean isDeobfuscationOn() {
+		return isDeobfuscationOn;
+	}
+
+	public void setDeobfuscationOn(boolean deobfuscationOn) {
+		isDeobfuscationOn = deobfuscationOn;
+	}
+
+	public boolean isDeobfuscationForceSave() {
+		return isDeobfuscationForceSave;
+	}
+
+	public void setDeobfuscationForceSave(boolean deobfuscationForceSave) {
+		isDeobfuscationForceSave = deobfuscationForceSave;
+	}
+
+	public boolean isUseSourceNameAsClassAlias() {
+		return useSourceNameAsClassAlias;
+	}
+
+	public void setUseSourceNameAsClassAlias(boolean useSourceNameAsClassAlias) {
+		this.useSourceNameAsClassAlias = useSourceNameAsClassAlias;
+	}
+
+	public int getDeobfuscationMinLength() {
+		return deobfuscationMinLength;
+	}
+
+	public void setDeobfuscationMinLength(int deobfuscationMinLength) {
+		this.deobfuscationMinLength = deobfuscationMinLength;
+	}
+
+	public int getDeobfuscationMaxLength() {
+		return deobfuscationMaxLength;
+	}
+
+	public void setDeobfuscationMaxLength(int deobfuscationMaxLength) {
+		this.deobfuscationMaxLength = deobfuscationMaxLength;
+	}
+
+	public boolean isEscapeUnicode() {
+		return escapeUnicode;
+	}
+
+	public void setEscapeUnicode(boolean escapeUnicode) {
+		this.escapeUnicode = escapeUnicode;
+	}
+
+	public boolean isReplaceConsts() {
+		return replaceConsts;
+	}
+
+	public void setReplaceConsts(boolean replaceConsts) {
+		this.replaceConsts = replaceConsts;
+	}
+
+	public boolean isExportAsGradleProject() {
+		return exportAsGradleProject;
+	}
+
+	public void setExportAsGradleProject(boolean exportAsGradleProject) {
+		this.exportAsGradleProject = exportAsGradleProject;
+	}
+
+	@Override
+	public String toString() {
+		final StringBuilder sb = new StringBuilder("JadxArgs{");
+		sb.append("inputFiles=").append(inputFiles);
+		sb.append(", outDir=").append(outDir);
+		sb.append(", outDirSrc=").append(outDirSrc);
+		sb.append(", outDirRes=").append(outDirRes);
+		sb.append(", threadsCount=").append(threadsCount);
+		sb.append(", cfgOutput=").append(cfgOutput);
+		sb.append(", rawCFGOutput=").append(rawCFGOutput);
+		sb.append(", fallbackMode=").append(fallbackMode);
+		sb.append(", showInconsistentCode=").append(showInconsistentCode);
+		sb.append(", useImports=").append(useImports);
+		sb.append(", isSkipResources=").append(isSkipResources);
+		sb.append(", isSkipSources=").append(isSkipSources);
+		sb.append(", isDeobfuscationOn=").append(isDeobfuscationOn);
+		sb.append(", isDeobfuscationForceSave=").append(isDeobfuscationForceSave);
+		sb.append(", useSourceNameAsClassAlias=").append(useSourceNameAsClassAlias);
+		sb.append(", deobfuscationMinLength=").append(deobfuscationMinLength);
+		sb.append(", deobfuscationMaxLength=").append(deobfuscationMaxLength);
+		sb.append(", escapeUnicode=").append(escapeUnicode);
+		sb.append(", replaceConsts=").append(replaceConsts);
+		sb.append(", exportAsGradleProject=").append(exportAsGradleProject);
+		sb.append('}');
+		return sb.toString();
+	}
+}

jadx-core/src/main/java/jadx/api/JadxArgsValidator.java

@@ -0,0 +1,108 @@
+package jadx.api;
+
+import java.io.File;
+import java.util.List;
+
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+
+public class JadxArgsValidator {
+
+	private static final Logger LOG = LoggerFactory.getLogger(JadxArgsValidator.class);
+
+	public static void validate(JadxArgs args) {
+		checkInputFiles(args);
+		validateOutDirs(args);
+
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Effective jadx args: {}", args);
+		}
+	}
+
+	private static void checkInputFiles(JadxArgs args) {
+		List<File> inputFiles = args.getInputFiles();
+		if (inputFiles.isEmpty()) {
+			throw new JadxArgsValidateException("Please specify input file");
+		}
+		if (inputFiles.size() > 1) {
+			for (File inputFile : inputFiles) {
+				String fileName = inputFile.getName();
+				if (fileName.startsWith("--")) {
+					throw new JadxArgsValidateException("Unknown argument: " + fileName);
+				}
+			}
+			throw new JadxArgsValidateException("Only one input file supported");
+		}
+		for (File file : inputFiles) {
+			checkFile(file);
+		}
+	}
+
+	private static void validateOutDirs(JadxArgs args) {
+		File outDir = args.getOutDir();
+		File srcDir = args.getOutDirSrc();
+		File resDir = args.getOutDirRes();
+		if (outDir == null) {
+			if (srcDir != null) {
+				outDir = srcDir;
+			} else if (resDir != null) {
+				outDir = resDir;
+			} else {
+				outDir = makeDirFromInput(args);
+			}
+		}
+		args.setOutDir(outDir);
+		setFromOut(args);
+
+		checkDir(args.getOutDir());
+		checkDir(args.getOutDirSrc());
+		checkDir(args.getOutDirRes());
+	}
+
+	@NotNull
+	private static File makeDirFromInput(JadxArgs args) {
+		File outDir;
+		String outDirName;
+		File file = args.getInputFiles().get(0);
+		String name = file.getName();
+		int pos = name.lastIndexOf('.');
+		if (pos != -1) {
+			outDirName = name.substring(0, pos);
+		} else {
+			outDirName = name + "-" + JadxArgs.DEFAULT_OUT_DIR;
+		}
+		LOG.info("output directory: {}", outDirName);
+		outDir = new File(outDirName);
+		return outDir;
+	}
+
+	private static void setFromOut(JadxArgs args) {
+		if (args.getOutDirSrc() == null) {
+			args.setOutDirSrc(new File(args.getOutDir(), JadxArgs.DEFAULT_SRC_DIR));
+		}
+		if (args.getOutDirRes() == null) {
+			args.setOutDirRes(new File(args.getOutDir(), JadxArgs.DEFAULT_RES_DIR));
+		}
+	}
+
+	private static void checkFile(File file) {
+		if (!file.exists()) {
+			throw new JadxArgsValidateException("File not found " + file.getAbsolutePath());
+		}
+		if (file.isDirectory()) {
+			throw new JadxArgsValidateException("Expected file but found directory instead: " + file.getAbsolutePath());
+		}
+	}
+
+	private static void checkDir(File dir) {
+		if (dir != null && dir.exists() && !dir.isDirectory()) {
+			throw new JadxArgsValidateException("Output directory exists as file " + dir);
+		}
+	}
+
+	private JadxArgsValidator() {
+	}
+}

jadx-core/src/main/java/jadx/api/JadxDecompiler.java

@@ -1,25 +1,13 @@
 package jadx.api;
 
-import jadx.core.Jadx;
-import jadx.core.ProcessClass;
-import jadx.core.dex.info.ClassInfo;
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.nodes.RootNode;
-import jadx.core.dex.visitors.IDexTreeVisitor;
-import jadx.core.dex.visitors.SaveCode;
-import jadx.core.utils.exceptions.DecodeException;
-import jadx.core.utils.exceptions.JadxException;
-import jadx.core.utils.exceptions.JadxRuntimeException;
-import jadx.core.utils.files.InputFile;
-
 import java.io.File;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
@@ -27,16 +15,35 @@ import java.util.concurrent.TimeUnit;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.core.Jadx;
+import jadx.core.ProcessClass;
+import jadx.core.codegen.CodeGen;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.dex.visitors.IDexTreeVisitor;
+import jadx.core.dex.visitors.SaveCode;
+import jadx.core.export.ExportGradleProject;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.InputFile;
+import jadx.core.xmlgen.BinaryXMLParser;
+import jadx.core.xmlgen.ResourcesSaver;
+
 /**
  * Jadx API usage example:
  * <pre><code>
- *  JadxDecompiler jadx = new JadxDecompiler();
- *  jadx.loadFile(new File("classes.dex"));
- *  jadx.setOutputDir(new File("out"));
- *  jadx.save();
+ * JadxArgs args = new JadxArgs();
+ * args.getInputFiles().add(new File("test.apk"));
+ * args.setOutDir(new File("jadx-test-output"));
+ *
+ * JadxDecompiler jadx = new JadxDecompiler(args);
+ * jadx.load();
+ * jadx.save();
  * </code></pre>
- * <p/>
- * Instead of 'save()' you can get list of decompiled classes:
+ *
+ * Instead of 'save()' you can iterate over decompiled classes:
  * <pre><code>
  *  for(JavaClass cls : jadx.getClasses()) {
  *      System.out.println(cls.getCode());
@@ -46,78 +53,109 @@ import org.slf4j.LoggerFactory;
 public final class JadxDecompiler {
 	private static final Logger LOG = LoggerFactory.getLogger(JadxDecompiler.class);
 
-	private final IJadxArgs args;
-	private final List<InputFile> inputFiles = new ArrayList<InputFile>();
+	private JadxArgs args;
 
-	private File outDir;
+	private final List<InputFile> inputFiles = new ArrayList<>();
 
 	private RootNode root;
 	private List<IDexTreeVisitor> passes;
+	private CodeGen codeGen;
+
 	private List<JavaClass> classes;
+	private List<ResourceFile> resources;
+
+	private BinaryXMLParser xmlParser;
+
+	private Map<ClassNode, JavaClass> classesMap = new ConcurrentHashMap<>();
+	private Map<MethodNode, JavaMethod> methodsMap = new ConcurrentHashMap<>();
+	private Map<FieldNode, JavaField> fieldsMap = new ConcurrentHashMap<>();
 
 	public JadxDecompiler() {
-		this(new DefaultJadxArgs());
+		this(new JadxArgs());
 	}
 
-	public JadxDecompiler(IJadxArgs jadxArgs) {
-		this.args = jadxArgs;
-		this.outDir = jadxArgs.getOutDir();
+	public JadxDecompiler(JadxArgs args) {
+		this.args = args;
+	}
+
+	public void load() {
 		reset();
+		JadxArgsValidator.validate(args);
 		init();
-	}
+		LOG.info("loading ...");
 
-	public void setOutputDir(File outDir) {
-		this.outDir = outDir;
-		init();
+		loadFiles(args.getInputFiles());
+
+		root = new RootNode(args);
+		root.load(inputFiles);
+
+		root.initClassPath();
+		root.loadResources(getResources());
+		root.initAppResClass();
+
+		initVisitors();
 	}
 
 	void init() {
-		if (outDir == null) {
-			outDir = new DefaultJadxArgs().getOutDir();
-		}
-		this.passes = Jadx.getPassesList(args, outDir);
+		this.passes = Jadx.getPassesList(args);
+		this.codeGen = new CodeGen();
 	}
 
 	void reset() {
-		ClassInfo.clearCache();
 		classes = null;
+		resources = null;
+		xmlParser = null;
 		root = null;
+		passes = null;
+		codeGen = null;
 	}
 
 	public static String getVersion() {
 		return Jadx.getVersion();
 	}
 
-	public void loadFile(File file) throws JadxException {
-		loadFiles(Collections.singletonList(file));
-	}
-
-	public void loadFiles(List<File> files) throws JadxException {
+	private void loadFiles(List<File> files) {
 		if (files.isEmpty()) {
-			throw new JadxException("Empty file list");
+			throw new JadxRuntimeException("Empty file list");
 		}
 		inputFiles.clear();
 		for (File file : files) {
 			try {
-				inputFiles.add(new InputFile(file));
-			} catch (IOException e) {
-				throw new JadxException("Error load file: " + file, e);
+				InputFile.addFilesFrom(file, inputFiles, args.isSkipSources());
+			} catch (Exception e) {
+				throw new JadxRuntimeException("Error load file: " + file, e);
 			}
 		}
-		parse();
 	}
 
 	public void save() {
+		save(!args.isSkipSources(), !args.isSkipResources());
+	}
+
+	public void saveSources() {
+		save(true, false);
+	}
+
+	public void saveResources() {
+		save(false, true);
+	}
+
+	private void save(boolean saveSources, boolean saveResources) {
+		ExecutorService ex = getSaveExecutor(saveSources, saveResources);
+		ex.shutdown();
 		try {
-			ExecutorService ex = getSaveExecutor();
-			ex.shutdown();
 			ex.awaitTermination(1, TimeUnit.DAYS);
 		} catch (InterruptedException e) {
-			throw new JadxRuntimeException("Save interrupted", e);
+			LOG.error("Save interrupted", e);
+			Thread.currentThread().interrupt();
 		}
 	}
 
 	public ExecutorService getSaveExecutor() {
+		return getSaveExecutor(!args.isSkipSources(), !args.isSkipResources());
+	}
+
+	private ExecutorService getSaveExecutor(boolean saveSources, boolean saveResources) {
 		if (root == null) {
 			throw new JadxRuntimeException("No loaded files");
 		}
@@ -126,16 +164,47 @@ public final class JadxDecompiler {
 
 		LOG.info("processing ...");
 		ExecutorService executor = Executors.newFixedThreadPool(threadsCount);
-		for (final JavaClass cls : getClasses()) {
-			executor.execute(new Runnable() {
-				@Override
-				public void run() {
+
+		File sourcesOutDir;
+		File resOutDir;
+		if (args.isExportAsGradleProject()) {
+			ExportGradleProject export = new ExportGradleProject(root, args.getOutDir());
+			export.init();
+			sourcesOutDir = export.getSrcOutDir();
+			resOutDir = export.getResOutDir();
+		} else {
+			sourcesOutDir = args.getOutDirSrc();
+			resOutDir = args.getOutDirRes();
+		}
+		if (saveSources) {
+			appendSourcesSave(executor, sourcesOutDir);
+		}
+		if (saveResources) {
+			appendResourcesSave(executor, resOutDir);
+		}
+		return executor;
+	}
+
+	private void appendResourcesSave(ExecutorService executor, File outDir) {
+		for (ResourceFile resourceFile : getResources()) {
+			executor.execute(new ResourcesSaver(outDir, resourceFile));
+		}
+	}
+
+	private void appendSourcesSave(ExecutorService executor, File outDir) {
+		for (JavaClass cls : getClasses()) {
+			if (cls.getClassNode().contains(AFlag.DONT_GENERATE)) {
+				continue;
+			}
+			executor.execute(() -> {
+				try {
 					cls.decompile();
 					SaveCode.save(outDir, args, cls.getClassNode());
+				} catch (Exception e) {
+					LOG.error("Error saving class: {}", cls.getFullName(), e);
 				}
 			});
 		}
-		return executor;
 	}
 
 	public List<JavaClass> getClasses() {
@@ -144,42 +213,46 @@ public final class JadxDecompiler {
 		}
 		if (classes == null) {
 			List<ClassNode> classNodeList = root.getClasses(false);
-			List<JavaClass> clsList = new ArrayList<JavaClass>(classNodeList.size());
+			List<JavaClass> clsList = new ArrayList<>(classNodeList.size());
+			classesMap.clear();
 			for (ClassNode classNode : classNodeList) {
-				clsList.add(new JavaClass(classNode, this));
+				JavaClass javaClass = new JavaClass(classNode, this);
+				clsList.add(javaClass);
+				classesMap.put(classNode, javaClass);
 			}
 			classes = Collections.unmodifiableList(clsList);
 		}
 		return classes;
 	}
 
+	public List<ResourceFile> getResources() {
+		if (resources == null) {
+			if (root == null) {
+				return Collections.emptyList();
+			}
+			resources = new ResourcesLoader(this).load(inputFiles);
+		}
+		return resources;
+	}
+
 	public List<JavaPackage> getPackages() {
 		List<JavaClass> classList = getClasses();
 		if (classList.isEmpty()) {
 			return Collections.emptyList();
 		}
-		Map<String, List<JavaClass>> map = new HashMap<String, List<JavaClass>>();
+		Map<String, List<JavaClass>> map = new HashMap<>();
 		for (JavaClass javaClass : classList) {
 			String pkg = javaClass.getPackage();
-			List<JavaClass> clsList = map.get(pkg);
-			if (clsList == null) {
-				clsList = new ArrayList<JavaClass>();
-				map.put(pkg, clsList);
-			}
+			List<JavaClass> clsList = map.computeIfAbsent(pkg, k -> new ArrayList<>());
 			clsList.add(javaClass);
 		}
-		List<JavaPackage> packages = new ArrayList<JavaPackage>(map.size());
+		List<JavaPackage> packages = new ArrayList<>(map.size());
 		for (Map.Entry<String, List<JavaClass>> entry : map.entrySet()) {
 			packages.add(new JavaPackage(entry.getKey(), entry.getValue()));
 		}
 		Collections.sort(packages);
 		for (JavaPackage pkg : packages) {
-			Collections.sort(pkg.getClasses(), new Comparator<JavaClass>() {
-				@Override
-				public int compare(JavaClass o1, JavaClass o2) {
-					return o1.getName().compareTo(o2.getName());
-				}
-			});
+			pkg.getClasses().sort(Comparator.comparing(JavaClass::getName));
 		}
 		return Collections.unmodifiableList(packages);
 	}
@@ -191,38 +264,60 @@ public final class JadxDecompiler {
 		return root.getErrorsCounter().getErrorCount();
 	}
 
+	public int getWarnsCount() {
+		if (root == null) {
+			return 0;
+		}
+		return root.getErrorsCounter().getWarnsCount();
+	}
+
 	public void printErrorsReport() {
 		if (root == null) {
 			return;
 		}
+		root.getClsp().printMissingClasses();
 		root.getErrorsCounter().printReport();
 	}
 
-	void parse() throws DecodeException {
-		reset();
-		root = new RootNode();
-		LOG.info("loading ...");
-		root.load(inputFiles);
+	private void initVisitors() {
+		for (IDexTreeVisitor pass : passes) {
+			try {
+				pass.init(root);
+			} catch (Exception e) {
+				LOG.error("Visitor init failed: {}", pass.getClass().getSimpleName(), e);
+			}
+		}
 	}
 
 	void processClass(ClassNode cls) {
-		ProcessClass.process(cls, passes);
+		ProcessClass.process(cls, passes, codeGen);
 	}
 
 	RootNode getRoot() {
 		return root;
 	}
 
-	JavaClass findJavaClass(ClassNode cls) {
-		if (cls == null) {
-			return null;
+	synchronized BinaryXMLParser getXmlParser() {
+		if (xmlParser == null) {
+			xmlParser = new BinaryXMLParser(root);
 		}
-		for (JavaClass javaClass : getClasses()) {
-			if (javaClass.getClassNode().equals(cls)) {
-				return javaClass;
-			}
-		}
-		return null;
+		return xmlParser;
+	}
+
+	Map<ClassNode, JavaClass> getClassesMap() {
+		return classesMap;
+	}
+
+	Map<MethodNode, JavaMethod> getMethodsMap() {
+		return methodsMap;
+	}
+
+	Map<FieldNode, JavaField> getFieldsMap() {
+		return fieldsMap;
+	}
+
+	public JadxArgs getArgs() {
+		return args;
 	}
 
 	@Override

jadx-core/src/main/java/jadx/api/JavaClass.java

@@ -1,5 +1,14 @@
 package jadx.api;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.jetbrains.annotations.Nullable;
+
 import jadx.core.codegen.CodeWriter;
 import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.nodes.LineAttrNode;
@@ -8,12 +17,6 @@ import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.FieldNode;
 import jadx.core.dex.nodes.MethodNode;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-
 public final class JavaClass implements JavaNode {
 
 	private final JadxDecompiler decompiler;
@@ -44,14 +47,14 @@ public final class JavaClass implements JavaNode {
 		if (code == null) {
 			decompile();
 			code = cls.getCode();
+			if (code == null) {
+				return "";
+			}
 		}
-		if (code == null) {
-			return "";
-		}
-		return code.toString();
+		return code.getCodeStr();
 	}
 
-	public void decompile() {
+	public synchronized void decompile() {
 		if (decompiler == null) {
 			return;
 		}
@@ -61,19 +64,25 @@ public final class JavaClass implements JavaNode {
 		}
 	}
 
+	public synchronized void unload() {
+		cls.unload();
+	}
+
 	ClassNode getClassNode() {
 		return cls;
 	}
 
 	private void load() {
+		JadxDecompiler rootDecompiler = getRootDecompiler();
 		int inClsCount = cls.getInnerClasses().size();
 		if (inClsCount != 0) {
-			List<JavaClass> list = new ArrayList<JavaClass>(inClsCount);
+			List<JavaClass> list = new ArrayList<>(inClsCount);
 			for (ClassNode inner : cls.getInnerClasses()) {
 				if (!inner.contains(AFlag.DONT_GENERATE)) {
 					JavaClass javaClass = new JavaClass(inner, this);
 					javaClass.load();
 					list.add(javaClass);
+					rootDecompiler.getClassesMap().put(inner, javaClass);
 				}
 			}
 			this.innerClasses = Collections.unmodifiableList(list);
@@ -81,10 +90,12 @@ public final class JavaClass implements JavaNode {
 
 		int fieldsCount = cls.getFields().size();
 		if (fieldsCount != 0) {
-			List<JavaField> flds = new ArrayList<JavaField>(fieldsCount);
+			List<JavaField> flds = new ArrayList<>(fieldsCount);
 			for (FieldNode f : cls.getFields()) {
 				if (!f.contains(AFlag.DONT_GENERATE)) {
-					flds.add(new JavaField(f, this));
+					JavaField javaField = new JavaField(f, this);
+					flds.add(javaField);
+					rootDecompiler.getFieldsMap().put(f, javaField);
 				}
 			}
 			this.fields = Collections.unmodifiableList(flds);
@@ -92,54 +103,104 @@ public final class JavaClass implements JavaNode {
 
 		int methodsCount = cls.getMethods().size();
 		if (methodsCount != 0) {
-			List<JavaMethod> mths = new ArrayList<JavaMethod>(methodsCount);
+			List<JavaMethod> mths = new ArrayList<>(methodsCount);
 			for (MethodNode m : cls.getMethods()) {
 				if (!m.contains(AFlag.DONT_GENERATE)) {
-					mths.add(new JavaMethod(this, m));
+					JavaMethod javaMethod = new JavaMethod(this, m);
+					mths.add(javaMethod);
+					rootDecompiler.getMethodsMap().put(m, javaMethod);
 				}
 			}
-			Collections.sort(mths, new Comparator<JavaMethod>() {
-				@Override
-				public int compare(JavaMethod o1, JavaMethod o2) {
-					return o1.getName().compareTo(o2.getName());
-				}
-			});
+			mths.sort(Comparator.comparing(JavaMethod::getName));
 			this.methods = Collections.unmodifiableList(mths);
 		}
 	}
 
-	private Map<CodePosition, Object> getCodeAnnotations() {
-		decompile();
-		return cls.getCode().getAnnotations();
+	private JadxDecompiler getRootDecompiler() {
+		if (parent != null) {
+			return parent.getRootDecompiler();
+		}
+		return decompiler;
 	}
 
-	public CodePosition getDefinitionPosition(int line, int offset) {
+	private Map<CodePosition, Object> getCodeAnnotations() {
+		decompile();
+		CodeWriter code = cls.getCode();
+		if (code == null) {
+			return Collections.emptyMap();
+		}
+		return code.getAnnotations();
+	}
+
+	public Map<CodePosition, JavaNode> getUsageMap() {
 		Map<CodePosition, Object> map = getCodeAnnotations();
-		Object obj = map.get(new CodePosition(line, offset));
-		if (obj instanceof LineAttrNode) {
-			ClassNode clsNode = null;
-			if (obj instanceof ClassNode) {
-				clsNode = (ClassNode) obj;
-			} else if (obj instanceof MethodNode) {
-				clsNode = ((MethodNode) obj).getParentClass();
-			} else if (obj instanceof FieldNode) {
-				clsNode = ((FieldNode) obj).getParentClass();
+		if (map.isEmpty() || decompiler == null) {
+			return Collections.emptyMap();
+		}
+		Map<CodePosition, JavaNode> resultMap = new HashMap<>(map.size());
+		for (Map.Entry<CodePosition, Object> entry : map.entrySet()) {
+			CodePosition codePosition = entry.getKey();
+			Object obj = entry.getValue();
+			if (obj instanceof LineAttrNode) {
+				JavaNode node = convertNode(obj);
+				if (node != null) {
+					resultMap.put(codePosition, node);
+				}
 			}
-			if (clsNode == null) {
-				return null;
-			}
-			clsNode = clsNode.getParentClass();
-			JavaClass jCls = decompiler.findJavaClass(clsNode);
-			if (jCls == null) {
-				return null;
-			}
-			jCls.decompile();
-			int defLine = ((LineAttrNode) obj).getDecompiledLine();
-			return new CodePosition(jCls, defLine, 0);
+		}
+		return resultMap;
+	}
+
+	@Nullable
+	private JavaNode convertNode(Object obj) {
+		if (!(obj instanceof LineAttrNode)) {
+			return null;
+		}
+		if (obj instanceof ClassNode) {
+			return getRootDecompiler().getClassesMap().get(obj);
+		}
+		if (obj instanceof MethodNode) {
+			return getRootDecompiler().getMethodsMap().get(obj);
+		}
+		if (obj instanceof FieldNode) {
+			return getRootDecompiler().getFieldsMap().get(obj);
 		}
 		return null;
 	}
 
+	@Nullable
+	public JavaNode getJavaNodeAtPosition(int line, int offset) {
+		Map<CodePosition, Object> map = getCodeAnnotations();
+		if (map.isEmpty()) {
+			return null;
+		}
+		Object obj = map.get(new CodePosition(line, offset));
+		if (obj == null) {
+			return null;
+		}
+		return convertNode(obj);
+	}
+
+	@Nullable
+	public CodePosition getDefinitionPosition(int line, int offset) {
+		JavaNode javaNode = getJavaNodeAtPosition(line, offset);
+		if (javaNode == null) {
+			return null;
+		}
+		return getDefinitionPosition(javaNode);
+	}
+
+	@Nullable
+	public CodePosition getDefinitionPosition(JavaNode javaNode) {
+		JavaClass jCls = javaNode.getTopParentClass();
+		jCls.decompile();
+		int defLine = javaNode.getDecompiledLine();
+		if (defLine == 0) {
+			return null;
+		}
+		return new CodePosition(jCls, defLine, 0);
+	}
+
 	public Integer getSourceLine(int decompiledLine) {
 		decompile();
 		return cls.getCode().getLineMapping().get(decompiledLine);
@@ -164,6 +225,11 @@ public final class JavaClass implements JavaNode {
 		return parent;
 	}
 
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent == null ? this : parent.getTopParentClass();
+	}
+
 	public AccessInfo getAccessInfo() {
 		return cls.getAccessFlags();
 	}
@@ -199,6 +265,6 @@ public final class JavaClass implements JavaNode {
 
 	@Override
 	public String toString() {
-		return getFullName();
+		return cls.getFullName() + "[ " + getFullName() + " ]";
 	}
 }

jadx-core/src/main/java/jadx/api/JavaField.java

@@ -16,12 +16,12 @@ public final class JavaField implements JavaNode {
 
 	@Override
 	public String getName() {
-		return field.getName();
+		return field.getAlias();
 	}
 
 	@Override
 	public String getFullName() {
-		return parent.getFullName() + "." + field.getName();
+		return parent.getFullName() + "." + getName();
 	}
 
 	@Override
@@ -29,6 +29,11 @@ public final class JavaField implements JavaNode {
 		return parent;
 	}
 
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent.getTopParentClass();
+	}
+
 	public AccessInfo getAccessFlags() {
 		return field.getAccessFlags();
 	}
@@ -40,4 +45,19 @@ public final class JavaField implements JavaNode {
 	public int getDecompiledLine() {
 		return field.getDecompiledLine();
 	}
+
+	@Override
+	public int hashCode() {
+		return field.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		return this == o || o instanceof JavaField && field.equals(((JavaField) o).field);
+	}
+
+	@Override
+	public String toString() {
+		return field.toString();
+	}
 }

jadx-core/src/main/java/jadx/api/JavaMethod.java

@@ -1,11 +1,11 @@
 package jadx.api;
 
+import java.util.List;
+
 import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.MethodNode;
 
-import java.util.List;
-
 public final class JavaMethod implements JavaNode {
 	private final MethodNode mth;
 	private final JavaClass parent;
@@ -17,7 +17,7 @@ public final class JavaMethod implements JavaNode {
 
 	@Override
 	public String getName() {
-		return mth.getName();
+		return mth.getAlias();
 	}
 
 	@Override
@@ -30,6 +30,11 @@ public final class JavaMethod implements JavaNode {
 		return parent;
 	}
 
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent.getTopParentClass();
+	}
+
 	public AccessInfo getAccessFlags() {
 		return mth.getAccessFlags();
 	}
@@ -53,4 +58,19 @@ public final class JavaMethod implements JavaNode {
 	public int getDecompiledLine() {
 		return mth.getDecompiledLine();
 	}
+
+	@Override
+	public int hashCode() {
+		return mth.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		return this == o || o instanceof JavaMethod && mth.equals(((JavaMethod) o).mth);
+	}
+
+	@Override
+	public String toString() {
+		return mth.toString();
+	}
 }

jadx-core/src/main/java/jadx/api/JavaNode.java

@@ -7,4 +7,8 @@ public interface JavaNode {
 	String getFullName();
 
 	JavaClass getDeclaringClass();
+
+	JavaClass getTopParentClass();
+
+	int getDecompiledLine();
 }

jadx-core/src/main/java/jadx/api/JavaPackage.java

@@ -2,6 +2,8 @@ package jadx.api;
 
 import java.util.List;
 
+import org.jetbrains.annotations.NotNull;
+
 public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
 	private final String name;
 	private final List<JavaClass> classes;
@@ -32,7 +34,17 @@ public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
 	}
 
 	@Override
-	public int compareTo(JavaPackage o) {
+	public JavaClass getTopParentClass() {
+		return null;
+	}
+
+	@Override
+	public int getDecompiledLine() {
+		return 0;
+	}
+
+	@Override
+	public int compareTo(@NotNull JavaPackage o) {
 		return name.compareTo(o.name);
 	}
 

jadx-core/src/main/java/jadx/api/ResourceFile.java

@@ -0,0 +1,75 @@
+package jadx.api;
+
+import java.io.File;
+
+import jadx.core.utils.files.ZipSecurity;
+import jadx.core.xmlgen.ResContainer;
+
+public class ResourceFile {
+
+	public static final class ZipRef {
+		private final File zipFile;
+		private final String entryName;
+
+		public ZipRef(File zipFile, String entryName) {
+			this.zipFile = zipFile;
+			this.entryName = entryName;
+		}
+
+		public File getZipFile() {
+			return zipFile;
+		}
+
+		public String getEntryName() {
+			return entryName;
+		}
+
+		@Override
+		public String toString() {
+			return "ZipRef{" + zipFile + ", '" + entryName + "'}";
+		}
+	}
+
+	private final JadxDecompiler decompiler;
+	private final String name;
+	private final ResourceType type;
+	private ZipRef zipRef;
+
+	protected ResourceFile(JadxDecompiler decompiler, String name, ResourceType type) {
+		this.decompiler = decompiler;
+		this.name = name;
+		this.type = type;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public ResourceType getType() {
+		return type;
+	}
+
+	public ResContainer loadContent() {
+		return ResourcesLoader.loadContent(decompiler, this);
+	}
+
+	void setZipRef(ZipRef zipRef) {
+		this.zipRef = zipRef;
+	}
+
+	public ZipRef getZipRef() {
+		return zipRef;
+	}
+
+	@Override
+	public String toString() {
+		return "ResourceFile{name='" + name + '\'' + ", type=" + type + "}";
+	}
+	
+	public static ResourceFile createResourceFileInstance(JadxDecompiler decompiler, String name, ResourceType type) {
+		if(!ZipSecurity.isValidZipEntryName(name)) {
+			return null;
+		}
+		return new ResourceFile(decompiler, name, type);
+	}
+}

jadx-core/src/main/java/jadx/api/ResourceFileContent.java

@@ -0,0 +1,27 @@
+package jadx.api;
+
+import jadx.core.codegen.CodeWriter;
+import jadx.core.utils.files.ZipSecurity;
+import jadx.core.xmlgen.ResContainer;
+
+public class ResourceFileContent extends ResourceFile {
+
+	private final CodeWriter content;
+
+	private ResourceFileContent(String name, ResourceType type, CodeWriter content) {
+		super(null, name, type);
+		this.content = content;
+	}
+
+	@Override
+	public ResContainer loadContent() {
+		return ResContainer.singleFile(getName(), content);
+	}
+	
+	public static ResourceFileContent createResourceFileContentInstance(String name, ResourceType type, CodeWriter content) {
+		if(!ZipSecurity.isValidZipEntryName(name)) {
+			return null;
+		}
+		return new ResourceFileContent(name, type, content);
+	}
+}

jadx-core/src/main/java/jadx/api/ResourceType.java

@@ -0,0 +1,50 @@
+package jadx.api;
+
+public enum ResourceType {
+	CODE(".dex", ".jar", ".class"),
+	MANIFEST("AndroidManifest.xml"),
+	XML(".xml"),
+	ARSC(".arsc"),
+	FONT(".ttf"),
+	IMG(".png", ".gif", ".jpg"),
+	LIB(".so"),
+	UNKNOWN;
+
+	private final String[] exts;
+
+	ResourceType(String... exts) {
+		this.exts = exts;
+	}
+
+	public String[] getExts() {
+		return exts;
+	}
+
+	public static ResourceType getFileType(String fileName) {
+		for (ResourceType type : ResourceType.values()) {
+			for (String ext : type.getExts()) {
+				if (fileName.endsWith(ext)) {
+					return type;
+				}
+			}
+		}
+		return UNKNOWN;
+	}
+
+	public static boolean isSupportedForUnpack(ResourceType type) {
+		switch (type) {
+			case CODE:
+			case LIB:
+			case FONT:
+			case UNKNOWN:
+				return false;
+
+			case MANIFEST:
+			case XML:
+			case ARSC:
+			case IMG:
+				return true;
+		}
+		return false;
+	}
+}

jadx-core/src/main/java/jadx/api/ResourcesLoader.java

@@ -0,0 +1,164 @@
+package jadx.api;
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.ResourceFile.ZipRef;
+import jadx.core.codegen.CodeWriter;
+import jadx.core.utils.Utils;
+import jadx.core.utils.exceptions.JadxException;
+import jadx.core.utils.files.InputFile;
+import jadx.core.utils.files.ZipSecurity;
+import jadx.core.xmlgen.ResContainer;
+import jadx.core.xmlgen.ResTableParser;
+
+import static jadx.core.utils.files.FileUtils.READ_BUFFER_SIZE;
+import static jadx.core.utils.files.FileUtils.copyStream;
+
+// TODO: move to core package
+public final class ResourcesLoader {
+	private static final Logger LOG = LoggerFactory.getLogger(ResourcesLoader.class);
+
+	private static final int LOAD_SIZE_LIMIT = 10 * 1024 * 1024;
+
+	private final JadxDecompiler jadxRef;
+
+	ResourcesLoader(JadxDecompiler jadxRef) {
+		this.jadxRef = jadxRef;
+	}
+
+	List<ResourceFile> load(List<InputFile> inputFiles) {
+		List<ResourceFile> list = new ArrayList<>(inputFiles.size());
+		for (InputFile file : inputFiles) {
+			loadFile(list, file.getFile());
+		}
+		return list;
+	}
+
+	public interface ResourceDecoder {
+		ResContainer decode(long size, InputStream is) throws IOException;
+	}
+
+	public static ResContainer decodeStream(ResourceFile rf, ResourceDecoder decoder) throws JadxException {
+		try {
+			ZipRef zipRef = rf.getZipRef();
+			if (zipRef == null) {
+				File file = new File(rf.getName());
+				try (InputStream inputStream = new BufferedInputStream(new FileInputStream(file))) {
+					return decoder.decode(file.length(), inputStream);
+				}
+			} else {
+				try (ZipFile zipFile = new ZipFile(zipRef.getZipFile())) {
+					ZipEntry entry = zipFile.getEntry(zipRef.getEntryName());
+					if (entry == null) {
+						throw new IOException("Zip entry not found: " + zipRef);
+					}
+					if (!ZipSecurity.isValidZipEntry(entry)) {
+						return null;
+					}
+					try (InputStream inputStream = new BufferedInputStream(zipFile.getInputStream(entry))) {
+						return decoder.decode(entry.getSize(), inputStream);
+					}
+				}
+			}
+		} catch (Exception e) {
+			throw new JadxException("Error decode: " + rf.getName(), e);
+		}
+	}
+
+	static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf) {
+		try {
+			return decodeStream(rf, (size, is) -> loadContent(jadxRef, rf, is, size));
+		} catch (JadxException e) {
+			LOG.error("Decode error", e);
+			CodeWriter cw = new CodeWriter();
+			cw.add("Error decode ").add(rf.getType().toString().toLowerCase());
+			cw.startLine(Utils.getStackTrace(e.getCause()));
+			return ResContainer.singleFile(rf.getName(), cw);
+		}
+	}
+
+	private static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf,
+	                                        InputStream inputStream, long size) throws IOException {
+		switch (rf.getType()) {
+			case MANIFEST:
+			case XML:
+				return ResContainer.singleFile(rf.getName(),
+						jadxRef.getXmlParser().parse(inputStream));
+
+			case ARSC:
+				return new ResTableParser()
+					.decodeFiles(inputStream);
+
+			case IMG:
+				return ResContainer.singleImageFile(rf.getName(), inputStream);
+
+			default:
+				if (size > LOAD_SIZE_LIMIT) {
+					return ResContainer.singleFile(rf.getName(),
+							new CodeWriter().add("File too big, size: " + String.format("%.2f KB", size / 1024.)));
+				}
+				return ResContainer.singleFile(rf.getName(), loadToCodeWriter(inputStream));
+		}
+	}
+
+	private void loadFile(List<ResourceFile> list, File file) {
+		if (file == null) {
+			return;
+		}
+		try (ZipFile zip = new ZipFile(file)) {
+			Enumeration<? extends ZipEntry> entries = zip.entries();
+			while (entries.hasMoreElements()) {
+				ZipEntry entry = entries.nextElement();
+				if (ZipSecurity.isValidZipEntry(entry)) {
+					addEntry(list, file, entry);
+				}
+			}
+		} catch (Exception e) {
+			LOG.debug("Not a zip file: {}", file.getAbsolutePath());
+			addResourceFile(list, file);
+		}
+	}
+
+	private void addResourceFile(List<ResourceFile> list, File file) {
+		String name = file.getAbsolutePath();
+		ResourceType type = ResourceType.getFileType(name);
+		ResourceFile rf = ResourceFile.createResourceFileInstance(jadxRef, name, type);
+		if (rf != null) {
+			list.add(rf);
+		}
+	}
+
+	private void addEntry(List<ResourceFile> list, File zipFile, ZipEntry entry) {
+		if (entry.isDirectory()) {
+			return;
+		}
+		String name = entry.getName();
+		ResourceType type = ResourceType.getFileType(name);
+		ResourceFile rf = ResourceFile.createResourceFileInstance(jadxRef, name, type);
+		if (rf != null) {
+			rf.setZipRef(new ZipRef(zipFile, name));
+			list.add(rf);
+		}
+	}
+
+	public static CodeWriter loadToCodeWriter(InputStream is) throws IOException {
+		CodeWriter cw = new CodeWriter();
+		ByteArrayOutputStream baos = new ByteArrayOutputStream(READ_BUFFER_SIZE);
+		copyStream(is, baos);
+		cw.add(baos.toString("UTF-8"));
+		return cw;
+	}
+}

jadx-core/src/main/java/jadx/core/Consts.java

@@ -18,7 +18,10 @@ public class Consts {
 	public static final String DALVIK_ANNOTATION_DEFAULT = "dalvik.annotation.AnnotationDefault";
 
 	public static final String DEFAULT_PACKAGE_NAME = "defpackage";
-	public static final String ANONYMOUS_CLASS_PREFIX = "AnonymousClass_";
+	public static final String ANONYMOUS_CLASS_PREFIX = "AnonymousClass";
 
 	public static final String MTH_TOSTRING_SIGNATURE = "toString()Ljava/lang/String;";
+
+	private Consts() {
+	}
 }

jadx-core/src/main/java/jadx/core/Jadx.java

@@ -1,33 +1,5 @@
 package jadx.core;
 
-import jadx.api.IJadxArgs;
-import jadx.core.codegen.CodeGen;
-import jadx.core.dex.visitors.BlockMakerVisitor;
-import jadx.core.dex.visitors.ClassModifier;
-import jadx.core.dex.visitors.CodeShrinker;
-import jadx.core.dex.visitors.ConstInlinerVisitor;
-import jadx.core.dex.visitors.DebugInfoVisitor;
-import jadx.core.dex.visitors.DotGraphVisitor;
-import jadx.core.dex.visitors.EnumVisitor;
-import jadx.core.dex.visitors.FallbackModeVisitor;
-import jadx.core.dex.visitors.IDexTreeVisitor;
-import jadx.core.dex.visitors.MethodInlineVisitor;
-import jadx.core.dex.visitors.ModVisitor;
-import jadx.core.dex.visitors.PrepareForCodeGen;
-import jadx.core.dex.visitors.ReSugarCode;
-import jadx.core.dex.visitors.SimplifyVisitor;
-import jadx.core.dex.visitors.regions.CheckRegions;
-import jadx.core.dex.visitors.regions.IfRegionVisitor;
-import jadx.core.dex.visitors.regions.ProcessVariables;
-import jadx.core.dex.visitors.regions.RegionMakerVisitor;
-import jadx.core.dex.visitors.regions.ReturnVisitor;
-import jadx.core.dex.visitors.ssa.EliminatePhiNodes;
-import jadx.core.dex.visitors.ssa.SSATransform;
-import jadx.core.dex.visitors.typeinference.FinishTypeInference;
-import jadx.core.dex.visitors.typeinference.TypeInference;
-import jadx.core.utils.Utils;
-
-import java.io.File;
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Enumeration;
@@ -37,42 +9,81 @@ import java.util.jar.Manifest;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.JadxArgs;
+import jadx.core.dex.visitors.ClassModifier;
+import jadx.core.dex.visitors.CodeShrinker;
+import jadx.core.dex.visitors.ConstInlineVisitor;
+import jadx.core.dex.visitors.DebugInfoVisitor;
+import jadx.core.dex.visitors.DependencyCollector;
+import jadx.core.dex.visitors.DotGraphVisitor;
+import jadx.core.dex.visitors.EnumVisitor;
+import jadx.core.dex.visitors.ExtractFieldInit;
+import jadx.core.dex.visitors.FallbackModeVisitor;
+import jadx.core.dex.visitors.IDexTreeVisitor;
+import jadx.core.dex.visitors.MethodInlineVisitor;
+import jadx.core.dex.visitors.ModVisitor;
+import jadx.core.dex.visitors.PrepareForCodeGen;
+import jadx.core.dex.visitors.ReSugarCode;
+import jadx.core.dex.visitors.RenameVisitor;
+import jadx.core.dex.visitors.SimplifyVisitor;
+import jadx.core.dex.visitors.blocksmaker.BlockExceptionHandler;
+import jadx.core.dex.visitors.blocksmaker.BlockFinallyExtract;
+import jadx.core.dex.visitors.blocksmaker.BlockFinish;
+import jadx.core.dex.visitors.blocksmaker.BlockProcessor;
+import jadx.core.dex.visitors.blocksmaker.BlockSplitter;
+import jadx.core.dex.visitors.regions.CheckRegions;
+import jadx.core.dex.visitors.regions.IfRegionVisitor;
+import jadx.core.dex.visitors.regions.LoopRegionVisitor;
+import jadx.core.dex.visitors.regions.ProcessVariables;
+import jadx.core.dex.visitors.regions.RegionMakerVisitor;
+import jadx.core.dex.visitors.regions.ReturnVisitor;
+import jadx.core.dex.visitors.ssa.EliminatePhiNodes;
+import jadx.core.dex.visitors.ssa.SSATransform;
+import jadx.core.dex.visitors.typeinference.FinishTypeInference;
+import jadx.core.dex.visitors.typeinference.TypeInference;
+
 public class Jadx {
 	private static final Logger LOG = LoggerFactory.getLogger(Jadx.class);
 
+	private Jadx() {
+	}
+
 	static {
 		if (Consts.DEBUG) {
 			LOG.info("debug enabled");
 		}
-		if (Jadx.class.desiredAssertionStatus()) {
-			LOG.info("assertions enabled");
-		}
 	}
 
-	public static List<IDexTreeVisitor> getPassesList(IJadxArgs args, File outDir) {
-		List<IDexTreeVisitor> passes = new ArrayList<IDexTreeVisitor>();
+	public static List<IDexTreeVisitor> getPassesList(JadxArgs args) {
+		List<IDexTreeVisitor> passes = new ArrayList<>();
 		if (args.isFallbackMode()) {
 			passes.add(new FallbackModeVisitor());
 		} else {
-			passes.add(new BlockMakerVisitor());
+			passes.add(new BlockSplitter());
+			passes.add(new BlockProcessor());
+			passes.add(new BlockExceptionHandler());
+			passes.add(new BlockFinallyExtract());
+			passes.add(new BlockFinish());
+
 			passes.add(new SSATransform());
 			passes.add(new DebugInfoVisitor());
 			passes.add(new TypeInference());
+
 			if (args.isRawCFGOutput()) {
-				passes.add(new DotGraphVisitor(outDir, false, true));
+				passes.add(DotGraphVisitor.dumpRaw());
 			}
 
-			passes.add(new ConstInlinerVisitor());
+			passes.add(new ConstInlineVisitor());
 			passes.add(new FinishTypeInference());
 			passes.add(new EliminatePhiNodes());
 
 			passes.add(new ModVisitor());
-			passes.add(new EnumVisitor());
 
 			passes.add(new CodeShrinker());
 			passes.add(new ReSugarCode());
-			if (args.isCFGOutput()) {
-				passes.add(new DotGraphVisitor(outDir, false));
+
+			if (args.isCfgOutput()) {
+				passes.add(DotGraphVisitor.dump());
 			}
 
 			passes.add(new RegionMakerVisitor());
@@ -81,24 +92,30 @@ public class Jadx {
 
 			passes.add(new CodeShrinker());
 			passes.add(new SimplifyVisitor());
-			passes.add(new ProcessVariables());
 			passes.add(new CheckRegions());
 
-			if (args.isCFGOutput()) {
-				passes.add(new DotGraphVisitor(outDir, true));
+			passes.add(new MethodInlineVisitor());
+			passes.add(new ExtractFieldInit());
+			passes.add(new ClassModifier());
+			passes.add(new EnumVisitor());
+			passes.add(new PrepareForCodeGen());
+			passes.add(new LoopRegionVisitor());
+			passes.add(new ProcessVariables());
+
+			if (args.isCfgOutput()) {
+				passes.add(DotGraphVisitor.dumpRegions());
 			}
 
-			passes.add(new MethodInlineVisitor());
-			passes.add(new ClassModifier());
-			passes.add(new PrepareForCodeGen());
+			passes.add(new DependencyCollector());
+
+			passes.add(new RenameVisitor());
 		}
-		passes.add(new CodeGen(args));
 		return passes;
 	}
 
 	public static String getVersion() {
 		try {
-			ClassLoader classLoader = Utils.class.getClassLoader();
+			ClassLoader classLoader = Jadx.class.getClassLoader();
 			if (classLoader != null) {
 				Enumeration<URL> resources = classLoader.getResources("META-INF/MANIFEST.MF");
 				while (resources.hasMoreElements()) {

jadx-core/src/main/java/jadx/core/ProcessClass.java

@@ -1,30 +1,53 @@
 package jadx.core;
 
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.visitors.DepthTraversal;
-import jadx.core.dex.visitors.IDexTreeVisitor;
-
 import java.util.List;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.core.codegen.CodeGen;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.visitors.DepthTraversal;
+import jadx.core.dex.visitors.IDexTreeVisitor;
+import jadx.core.utils.ErrorsCounter;
+
+import static jadx.core.dex.nodes.ProcessState.NOT_LOADED;
+import static jadx.core.dex.nodes.ProcessState.PROCESSED;
+import static jadx.core.dex.nodes.ProcessState.STARTED;
 
 public final class ProcessClass {
-	private static final Logger LOG = LoggerFactory.getLogger(ProcessClass.class);
 
 	private ProcessClass() {
 	}
 
-	public static void process(ClassNode cls, List<IDexTreeVisitor> passes) {
-		try {
-			cls.load();
-			for (IDexTreeVisitor visitor : passes) {
-				DepthTraversal.visit(visitor, cls);
+	public static void process(ClassNode cls, List<IDexTreeVisitor> passes, @Nullable CodeGen codeGen) {
+		if (codeGen == null && cls.getState() == PROCESSED) {
+			return;
+		}
+		synchronized (getSyncObj(cls)) {
+			try {
+				if (cls.getState() == NOT_LOADED) {
+					cls.load();
+					cls.setState(STARTED);
+					for (IDexTreeVisitor visitor : passes) {
+						DepthTraversal.visit(visitor, cls);
+					}
+					cls.setState(PROCESSED);
+				}
+				if (cls.getState() == PROCESSED && codeGen != null) {
+					processDependencies(cls, passes);
+					codeGen.visit(cls);
+				}
+			} catch (Exception e) {
+				ErrorsCounter.classError(cls, e.getClass().getSimpleName(), e);
 			}
-		} catch (Exception e) {
-			LOG.error("Class process exception: " + cls, e);
-		} finally {
-			cls.unload();
 		}
 	}
+
+	public static Object getSyncObj(ClassNode cls) {
+		return cls.getClassInfo();
+	}
+
+	private static void processDependencies(ClassNode cls, List<IDexTreeVisitor> passes) {
+		cls.getDependencies().forEach(depCls -> process(depCls, passes, null));
+	}
 }

jadx-core/src/main/java/jadx/core/clsp/ClsSet.java

@@ -1,12 +1,5 @@
 package jadx.core.clsp;
 
-import jadx.core.dex.info.ClassInfo;
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.nodes.RootNode;
-import jadx.core.utils.Utils;
-import jadx.core.utils.exceptions.DecodeException;
-import jadx.core.utils.exceptions.JadxRuntimeException;
-
 import java.io.BufferedOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
@@ -27,6 +20,16 @@ import java.util.zip.ZipOutputStream;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.exceptions.DecodeException;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.FileUtils;
+import jadx.core.utils.files.ZipSecurity;
+
+import static jadx.core.utils.files.FileUtils.close;
+
 /**
  * Classes list for import into classpath graph
  */
@@ -46,7 +49,7 @@ public class ClsSet {
 
 	public void load(RootNode root) {
 		List<ClassNode> list = root.getClasses(true);
-		Map<String, NClass> names = new HashMap<String, NClass>(list.size());
+		Map<String, NClass> names = new HashMap<>(list.size());
 		int k = 0;
 		for (ClassNode cls : list) {
 			String clsRawName = cls.getRawName();
@@ -76,16 +79,16 @@ public class ClsSet {
 	}
 
 	public static NClass[] makeParentsArray(ClassNode cls, Map<String, NClass> names) {
-		List<NClass> parents = new ArrayList<NClass>(1 + cls.getInterfaces().size());
-		ClassInfo superClass = cls.getSuperClass();
+		List<NClass> parents = new ArrayList<>(1 + cls.getInterfaces().size());
+		ArgType superClass = cls.getSuperClass();
 		if (superClass != null) {
-			NClass c = getCls(superClass.getRawName(), names);
+			NClass c = getCls(superClass.getObject(), names);
 			if (c != null) {
 				parents.add(c);
 			}
 		}
-		for (ClassInfo iface : cls.getInterfaces()) {
-			NClass c = getCls(iface.getRawName(), names);
+		for (ArgType iface : cls.getInterfaces()) {
+			NClass c = getCls(iface.getObject(), names);
 			if (c != null) {
 				parents.add(c);
 			}
@@ -96,16 +99,14 @@ public class ClsSet {
 	private static NClass getCls(String fullName, Map<String, NClass> names) {
 		NClass id = names.get(fullName);
 		if (id == null && !names.containsKey(fullName)) {
-			LOG.warn("Class not found: " + fullName);
+			LOG.debug("Class not found: {}", fullName);
 		}
 		return id;
 	}
 
 	void save(File output) throws IOException {
-		Utils.makeDirsForFile(output);
-
-		BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(output));
-		try {
+		FileUtils.makeDirsForFile(output);
+		try (BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(output))) {
 			String outputName = output.getName();
 			if (outputName.endsWith(CLST_EXTENSION)) {
 				save(outputStream);
@@ -114,25 +115,21 @@ public class ClsSet {
 				try {
 					out.putNextEntry(new ZipEntry(CLST_PKG_PATH + "/" + CLST_FILENAME));
 					save(out);
-					out.closeEntry();
 				} finally {
-					out.close();
+					close(out);
 				}
 			} else {
 				throw new JadxRuntimeException("Unknown file format: " + outputName);
 			}
-		} finally {
-			outputStream.close();
 		}
 	}
 
 	public void save(OutputStream output) throws IOException {
-		DataOutputStream out = new DataOutputStream(output);
-		try {
+		try (DataOutputStream out = new DataOutputStream(output)) {
 			out.writeBytes(JADX_CLS_SET_HEADER);
 			out.writeByte(VERSION);
 
-			LOG.info("Classes count: " + classes.length);
+			LOG.info("Classes count: {}", classes.length);
 			out.writeInt(classes.length);
 			for (NClass cls : classes) {
 				writeString(out, cls.getName());
@@ -144,53 +141,41 @@ public class ClsSet {
 					out.writeInt(parent.getId());
 				}
 			}
-		} finally {
-			out.close();
 		}
 	}
 
 	public void load() throws IOException, DecodeException {
-		InputStream input = getClass().getResourceAsStream(CLST_FILENAME);
-		if (input == null) {
-			throw new JadxRuntimeException("Can't load classpath file: " + CLST_FILENAME);
-		}
-		try {
+		try (InputStream input = getClass().getResourceAsStream(CLST_FILENAME)) {
+			if (input == null) {
+				throw new JadxRuntimeException("Can't load classpath file: " + CLST_FILENAME);
+			}
 			load(input);
-		} finally {
-			input.close();
 		}
 	}
 
 	public void load(File input) throws IOException, DecodeException {
 		String name = input.getName();
-		InputStream inputStream = new FileInputStream(input);
-		try {
+		try (InputStream inputStream = new FileInputStream(input)) {
 			if (name.endsWith(CLST_EXTENSION)) {
 				load(inputStream);
 			} else if (name.endsWith(".jar")) {
-				ZipInputStream in = new ZipInputStream(inputStream);
-				try {
+				try (ZipInputStream in = new ZipInputStream(inputStream)) {
 					ZipEntry entry = in.getNextEntry();
 					while (entry != null) {
-						if (entry.getName().endsWith(CLST_EXTENSION)) {
+						if (entry.getName().endsWith(CLST_EXTENSION) && ZipSecurity.isValidZipEntry(entry)) {
 							load(in);
 						}
 						entry = in.getNextEntry();
 					}
-				} finally {
-					in.close();
 				}
 			} else {
 				throw new JadxRuntimeException("Unknown file format: " + name);
 			}
-		} finally {
-			inputStream.close();
 		}
 	}
 
 	public void load(InputStream input) throws IOException, DecodeException {
-		DataInputStream in = new DataInputStream(input);
-		try {
+		try (DataInputStream in = new DataInputStream(input)) {
 			byte[] header = new byte[JADX_CLS_SET_HEADER.length()];
 			int readHeaderLength = in.read(header);
 			int version = in.readByte();
@@ -213,8 +198,6 @@ public class ClsSet {
 				}
 				classes[i].setParents(parents);
 			}
-		} finally {
-			in.close();
 		}
 	}
 

jadx-core/src/main/java/jadx/core/clsp/ClspGraph.java

@@ -1,10 +1,7 @@
 package jadx.core.clsp;
 
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.utils.exceptions.DecodeException;
-import jadx.core.utils.exceptions.JadxRuntimeException;
-
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -16,15 +13,21 @@ import java.util.WeakHashMap;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.utils.exceptions.DecodeException;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+
 /**
  * Classes hierarchy graph
  */
 public class ClspGraph {
 	private static final Logger LOG = LoggerFactory.getLogger(ClspGraph.class);
 
-	private final Map<String, Set<String>> ancestorCache = new WeakHashMap<String, Set<String>>();
+	private final Map<String, Set<String>> ancestorCache = Collections.synchronizedMap(new WeakHashMap<String, Set<String>>());
 	private Map<String, NClass> nameMap;
 
+	private final Set<String> missingClasses = new HashSet<>();
+
 	public void load() throws IOException, DecodeException {
 		ClsSet set = new ClsSet();
 		set.load();
@@ -33,7 +36,7 @@ public class ClspGraph {
 
 	public void addClasspath(ClsSet set) {
 		if (nameMap == null) {
-			nameMap = new HashMap<String, NClass>(set.getClassesCount());
+			nameMap = new HashMap<>(set.getClassesCount());
 			set.addToMap(nameMap);
 		} else {
 			throw new JadxRuntimeException("Classpath already loaded");
@@ -45,16 +48,10 @@ public class ClspGraph {
 			throw new JadxRuntimeException("Classpath must be loaded first");
 		}
 		int size = classes.size();
-		for (ClassNode cls : classes) {
-			size += cls.getInnerClasses().size();
-		}
 		NClass[] nClasses = new NClass[size];
 		int k = 0;
 		for (ClassNode cls : classes) {
 			nClasses[k++] = addClass(cls);
-			for (ClassNode inner : cls.getInnerClasses()) {
-				nClasses[k++] = addClass(inner);
-			}
 		}
 		for (int i = 0; i < size; i++) {
 			nClasses[i].setParents(ClsSet.makeParentsArray(classes.get(i), nameMap));
@@ -62,8 +59,9 @@ public class ClspGraph {
 	}
 
 	private NClass addClass(ClassNode cls) {
-		NClass nClass = new NClass(cls.getRawName(), -1);
-		nameMap.put(cls.getRawName(), nClass);
+		String rawName = cls.getRawName();
+		NClass nClass = new NClass(rawName, -1);
+		nameMap.put(rawName, nClass);
 		return nClass;
 	}
 
@@ -78,7 +76,7 @@ public class ClspGraph {
 		}
 		NClass cls = nameMap.get(implClsName);
 		if (cls == null) {
-			LOG.debug("Missing class: {}", implClsName);
+			missingClasses.add(clsName);
 			return null;
 		}
 		if (isImplements(clsName, implClsName)) {
@@ -109,10 +107,10 @@ public class ClspGraph {
 		}
 		NClass cls = nameMap.get(clsName);
 		if (cls == null) {
-			LOG.debug("Missing class: {}", clsName);
+			missingClasses.add(clsName);
 			return Collections.emptySet();
 		}
-		result = new HashSet<String>();
+		result = new HashSet<>();
 		addAncestorsNames(cls, result);
 		if (result.isEmpty()) {
 			result = Collections.emptySet();
@@ -122,9 +120,26 @@ public class ClspGraph {
 	}
 
 	private void addAncestorsNames(NClass cls, Set<String> result) {
-		result.add(cls.getName());
-		for (NClass p : cls.getParents()) {
-			addAncestorsNames(p, result);
+		boolean isNew = result.add(cls.getName());
+		if (isNew) {
+			for (NClass p : cls.getParents()) {
+				addAncestorsNames(p, result);
+			}
+		}
+	}
+
+	public void printMissingClasses() {
+		int count = missingClasses.size();
+		if (count == 0) {
+			return;
+		}
+		LOG.warn("Found {} references to unknown classes", count);
+		if (LOG.isDebugEnabled()) {
+			List<String> clsNames = new ArrayList<>(missingClasses);
+			Collections.sort(clsNames);
+			for (String cls : clsNames) {
+				LOG.debug("  {}", cls);
+			}
 		}
 	}
 }

jadx-core/src/main/java/jadx/core/clsp/ConvertToClsSet.java

@@ -1,9 +1,5 @@
 package jadx.core.clsp;
 
-import jadx.core.dex.nodes.RootNode;
-import jadx.core.utils.exceptions.DecodeException;
-import jadx.core.utils.files.InputFile;
-
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -12,6 +8,11 @@ import java.util.List;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.JadxArgs;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.exceptions.DecodeException;
+import jadx.core.utils.files.InputFile;
+
 /**
  * Utility class for convert dex or jar to jadx classes set (.jcst)
  */
@@ -29,30 +30,30 @@ public class ConvertToClsSet {
 		}
 		File output = new File(args[0]);
 
-		List<InputFile> inputFiles = new ArrayList<InputFile>(args.length - 1);
+		List<InputFile> inputFiles = new ArrayList<>(args.length - 1);
 		for (int i = 1; i < args.length; i++) {
 			File f = new File(args[i]);
 			if (f.isDirectory()) {
 				addFilesFromDirectory(f, inputFiles);
 			} else {
-				inputFiles.add(new InputFile(f));
+				InputFile.addFilesFrom(f, inputFiles);
 			}
 		}
 		for (InputFile inputFile : inputFiles) {
-			LOG.info("Loaded: " + inputFile.getFile());
+			LOG.info("Loaded: {}", inputFile.getFile());
 		}
 
-		RootNode root = new RootNode();
+		RootNode root = new RootNode(new JadxArgs());
 		root.load(inputFiles);
 
 		ClsSet set = new ClsSet();
 		set.load(root);
 		set.save(output);
-		LOG.info("Output: " + output);
+		LOG.info("Output: {}", output);
 		LOG.info("done");
 	}
 
-	private static void addFilesFromDirectory(File dir, List<InputFile> inputFiles) throws IOException, DecodeException {
+	private static void addFilesFromDirectory(File dir, List<InputFile> inputFiles) {
 		File[] files = dir.listFiles();
 		if (files == null) {
 			return;
@@ -60,11 +61,13 @@ public class ConvertToClsSet {
 		for (File file : files) {
 			if (file.isDirectory()) {
 				addFilesFromDirectory(file, inputFiles);
-			}
-			if (file.getName().endsWith(".dex")) {
-				inputFiles.add(new InputFile(file));
+			} else {
+				try {
+					InputFile.addFilesFrom(file, inputFiles);
+				} catch (Exception e) {
+					LOG.warn("Skip file: {}, load error: {}", file, e.getMessage());
+				}
 			}
 		}
 	}
-
 }

jadx-core/src/main/java/jadx/core/codegen/AnnotationGen.java

@@ -1,5 +1,10 @@
 package jadx.core.codegen;
 
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
 import jadx.core.Consts;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttributeNode;
@@ -14,11 +19,6 @@ import jadx.core.dex.nodes.MethodNode;
 import jadx.core.utils.StringUtils;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
 public class AnnotationGen {
 
 	private final ClassNode cls;
@@ -42,8 +42,12 @@ public class AnnotationGen {
 	}
 
 	public void addForParameter(CodeWriter code, MethodParameters paramsAnnotations, int n) {
-		AnnotationsList aList = paramsAnnotations.getParamList().get(n);
-		if (aList == null || aList.size() == 0) {
+		List<AnnotationsList> paramList = paramsAnnotations.getParamList();
+		if (n >= paramList.size()) {
+			return;
+		}
+		AnnotationsList aList = paramList.get(n);
+		if (aList == null || aList.isEmpty()) {
 			return;
 		}
 		for (Annotation a : aList.getAll()) {
@@ -54,7 +58,7 @@ public class AnnotationGen {
 
 	private void add(IAttributeNode node, CodeWriter code) {
 		AnnotationsList aList = node.get(AType.ANNOTATION_LIST);
-		if (aList == null || aList.size() == 0) {
+		if (aList == null || aList.isEmpty()) {
 			return;
 		}
 		for (Annotation a : aList.getAll()) {
@@ -126,11 +130,11 @@ public class AnnotationGen {
 			return;
 		}
 		if (val instanceof String) {
-			code.add(StringUtils.unescapeString((String) val));
+			code.add(getStringUtils().unescapeString((String) val));
 		} else if (val instanceof Integer) {
 			code.add(TypeGen.formatInteger((Integer) val));
 		} else if (val instanceof Character) {
-			code.add(StringUtils.unescapeChar((Character) val));
+			code.add(getStringUtils().unescapeChar((Character) val));
 		} else if (val instanceof Boolean) {
 			code.add(Boolean.TRUE.equals(val) ? "true" : "false");
 		} else if (val instanceof Float) {
@@ -150,9 +154,9 @@ public class AnnotationGen {
 			// must be a static field
 			FieldInfo field = (FieldInfo) val;
 			InsnGen.makeStaticFieldAccess(code, field, classGen);
-		} else if (val instanceof List) {
+		} else if (val instanceof Iterable) {
 			code.add('{');
-			Iterator<?> it = ((List) val).iterator();
+			Iterator<?> it = ((Iterable) val).iterator();
 			while (it.hasNext()) {
 				Object obj = it.next();
 				encodeValue(code, obj);
@@ -168,4 +172,8 @@ public class AnnotationGen {
 			throw new JadxRuntimeException("Can't decode value: " + val + " (" + val.getClass() + ")");
 		}
 	}
+
+	private StringUtils getStringUtils() {
+		return cls.dex().root().getStringUtils();
+	}
 }

jadx-core/src/main/java/jadx/core/codegen/ClassGen.java

@@ -1,28 +1,8 @@
 package jadx.core.codegen;
 
-import jadx.core.Consts;
-import jadx.core.dex.attributes.AFlag;
-import jadx.core.dex.attributes.AType;
-import jadx.core.dex.attributes.AttrNode;
-import jadx.core.dex.attributes.nodes.EnumClassAttr;
-import jadx.core.dex.attributes.nodes.EnumClassAttr.EnumField;
-import jadx.core.dex.attributes.nodes.SourceFileAttr;
-import jadx.core.dex.info.AccessInfo;
-import jadx.core.dex.info.ClassInfo;
-import jadx.core.dex.instructions.args.ArgType;
-import jadx.core.dex.instructions.args.InsnArg;
-import jadx.core.dex.instructions.args.PrimitiveType;
-import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.nodes.DexNode;
-import jadx.core.dex.nodes.FieldNode;
-import jadx.core.dex.nodes.MethodNode;
-import jadx.core.dex.nodes.parser.FieldValueAttr;
-import jadx.core.utils.ErrorsCounter;
-import jadx.core.utils.Utils;
-import jadx.core.utils.exceptions.CodegenException;
-
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
@@ -30,26 +10,60 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.android.dx.rop.code.AccessFlags;
 
+import jadx.api.JadxArgs;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.AttrNode;
+import jadx.core.dex.attributes.nodes.EnumClassAttr;
+import jadx.core.dex.attributes.nodes.EnumClassAttr.EnumField;
+import jadx.core.dex.attributes.nodes.JadxError;
+import jadx.core.dex.attributes.nodes.JadxWarn;
+import jadx.core.dex.attributes.nodes.LineAttrNode;
+import jadx.core.dex.attributes.nodes.SourceFileAttr;
+import jadx.core.dex.info.AccessInfo;
+import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.instructions.args.PrimitiveType;
+import jadx.core.dex.instructions.mods.ConstructorInsn;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.DexNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.InsnNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.dex.nodes.parser.FieldInitAttr;
+import jadx.core.dex.nodes.parser.FieldInitAttr.InitType;
+import jadx.core.utils.ErrorsCounter;
+import jadx.core.utils.Utils;
+import jadx.core.utils.exceptions.CodegenException;
+
 public class ClassGen {
-	private static final Logger LOG = LoggerFactory.getLogger(ClassGen.class);
 
 	private final ClassNode cls;
 	private final ClassGen parentGen;
 	private final AnnotationGen annotationGen;
 	private final boolean fallback;
+	private final boolean useImports;
+	private final boolean showInconsistentCode;
 
-	private final Set<ClassInfo> imports = new HashSet<ClassInfo>();
+	private final Set<ClassInfo> imports = new HashSet<>();
 	private int clsDeclLine;
 
-	public ClassGen(ClassNode cls, ClassGen parentClsGen, boolean fallback) {
+	public ClassGen(ClassNode cls, JadxArgs jadxArgs) {
+		this(cls, null, jadxArgs.isUseImports(), jadxArgs.isFallbackMode(), jadxArgs.isShowInconsistentCode());
+	}
+
+	public ClassGen(ClassNode cls, ClassGen parentClsGen) {
+		this(cls, parentClsGen, parentClsGen.useImports, parentClsGen.fallback, parentClsGen.showInconsistentCode);
+	}
+
+	public ClassGen(ClassNode cls, ClassGen parentClsGen, boolean useImports, boolean fallback, boolean showBadCode) {
 		this.cls = cls;
 		this.parentGen = parentClsGen;
 		this.fallback = fallback;
+		this.useImports = useImports;
+		this.showInconsistentCode = showBadCode;
 
 		this.annotationGen = new AnnotationGen(cls, this);
 	}
@@ -69,9 +83,9 @@ public class ClassGen {
 		}
 		int importsCount = imports.size();
 		if (importsCount != 0) {
-			List<String> sortImports = new ArrayList<String>(importsCount);
+			List<String> sortImports = new ArrayList<>(importsCount);
 			for (ClassInfo ic : imports) {
-				sortImports.add(ic.getFullName());
+				sortImports.add(ic.getAlias().getFullName());
 			}
 			Collections.sort(sortImports);
 
@@ -101,15 +115,22 @@ public class ClassGen {
 	public void addClassDeclaration(CodeWriter clsCode) {
 		AccessInfo af = cls.getAccessFlags();
 		if (af.isInterface()) {
-			af = af.remove(AccessFlags.ACC_ABSTRACT);
+			af = af.remove(AccessFlags.ACC_ABSTRACT)
+					.remove(AccessFlags.ACC_STATIC);
 		} else if (af.isEnum()) {
 			af = af.remove(AccessFlags.ACC_FINAL)
 					.remove(AccessFlags.ACC_ABSTRACT)
 					.remove(AccessFlags.ACC_STATIC);
 		}
 
+		// 'static' and 'private' modifier not allowed for top classes (not inner)
+		if (!cls.getAlias().isInner()) {
+			af = af.remove(AccessFlags.ACC_STATIC).remove(AccessFlags.ACC_PRIVATE);
+		}
+
 		annotationGen.addForClass(clsCode);
 		insertSourceFileInfo(clsCode, cls);
+		insertRenameInfo(clsCode, cls);
 		clsCode.startLine(af.makeString());
 		if (af.isInterface()) {
 			if (af.isAnnotation()) {
@@ -121,28 +142,29 @@ public class ClassGen {
 		} else {
 			clsCode.add("class ");
 		}
+		clsCode.attachDefinition(cls);
 		clsCode.add(cls.getShortName());
 
 		addGenericMap(clsCode, cls.getGenericMap());
 		clsCode.add(' ');
 
-		ClassInfo sup = cls.getSuperClass();
+		ArgType sup = cls.getSuperClass();
 		if (sup != null
-				&& !sup.getFullName().equals(Consts.CLASS_OBJECT)
-				&& !sup.getFullName().equals(Consts.CLASS_ENUM)) {
+				&& !sup.equals(ArgType.OBJECT)
+				&& !sup.getObject().equals(ArgType.ENUM.getObject())) {
 			clsCode.add("extends ");
 			useClass(clsCode, sup);
 			clsCode.add(' ');
 		}
 
-		if (cls.getInterfaces().size() > 0 && !af.isAnnotation()) {
+		if (!cls.getInterfaces().isEmpty() && !af.isAnnotation()) {
 			if (cls.getAccessFlags().isInterface()) {
 				clsCode.add("extends ");
 			} else {
 				clsCode.add("implements ");
 			}
-			for (Iterator<ClassInfo> it = cls.getInterfaces().iterator(); it.hasNext(); ) {
-				ClassInfo interf = it.next();
+			for (Iterator<ArgType> it = cls.getInterfaces().iterator(); it.hasNext(); ) {
+				ArgType interf = it.next();
 				useClass(clsCode, interf);
 				if (it.hasNext()) {
 					clsCode.add(", ");
@@ -152,7 +174,6 @@ public class ClassGen {
 				clsCode.add(' ');
 			}
 		}
-		clsCode.attachDefinition(cls);
 	}
 
 	public boolean addGenericMap(CodeWriter code, Map<ArgType, List<ArgType>> gmap) {
@@ -170,7 +191,7 @@ public class ClassGen {
 			if (type.isGenericType()) {
 				code.add(type.getObject());
 			} else {
-				useClass(code, ClassInfo.fromType(type));
+				useClass(code, type);
 			}
 			if (list != null && !list.isEmpty()) {
 				code.add(" extends ");
@@ -179,7 +200,7 @@ public class ClassGen {
 					if (g.isGenericType()) {
 						code.add(g.getObject());
 					} else {
-						useClass(code, ClassInfo.fromType(g));
+						useClass(code, g);
 					}
 					if (it.hasNext()) {
 						code.add(" & ");
@@ -206,10 +227,10 @@ public class ClassGen {
 	private void addInnerClasses(CodeWriter code, ClassNode cls) throws CodegenException {
 		for (ClassNode innerCls : cls.getInnerClasses()) {
 			if (innerCls.contains(AFlag.DONT_GENERATE)
-					|| innerCls.isAnonymous()) {
+					|| innerCls.contains(AFlag.ANONYMOUS_CLASS)) {
 				continue;
 			}
-			ClassGen inClGen = new ClassGen(innerCls, getParentGen(), fallback);
+			ClassGen inClGen = new ClassGen(innerCls, getParentGen());
 			code.newLine();
 			inClGen.addClassCode(code);
 			imports.addAll(inClGen.getImports());
@@ -218,7 +239,7 @@ public class ClassGen {
 
 	private boolean isInnerClassesPresents() {
 		for (ClassNode innerCls : cls.getInnerClasses()) {
-			if (!innerCls.isAnonymous()) {
+			if (!innerCls.contains(AFlag.ANONYMOUS_CLASS)) {
 				return true;
 			}
 		}
@@ -226,22 +247,33 @@ public class ClassGen {
 	}
 
 	private void addMethods(CodeWriter code) {
-		for (MethodNode mth : cls.getMethods()) {
+		List<MethodNode> methods = sortMethodsByLine(cls.getMethods());
+		for (MethodNode mth : methods) {
 			if (mth.contains(AFlag.DONT_GENERATE)) {
 				continue;
 			}
 			if (code.getLine() != clsDeclLine) {
 				code.newLine();
 			}
+			int savedIndent = code.getIndent();
 			try {
 				addMethod(code, mth);
 			} catch (Exception e) {
-				String msg = ErrorsCounter.methodError(mth, "Method generation error", e);
-				code.startLine("/* " + msg + CodeWriter.NL + Utils.getStackTrace(e) + " */");
+				code.newLine().add("/*");
+				code.newLine().add(ErrorsCounter.methodError(mth, "Method generation error", e));
+				code.newLine().add(Utils.getStackTrace(e));
+				code.newLine().add("*/");
+				code.setIndent(savedIndent);
 			}
 		}
 	}
 
+	private static List<MethodNode> sortMethodsByLine(List<MethodNode> methods) {
+		List<MethodNode> out = new ArrayList<>(methods);
+		out.sort(Comparator.comparingInt(LineAttrNode::getSourceLine));
+		return out;
+	}
+
 	private boolean isMethodsPresents() {
 		for (MethodNode mth : cls.getMethods()) {
 			if (!mth.contains(AFlag.DONT_GENERATE)) {
@@ -264,14 +296,17 @@ public class ClassGen {
 			}
 			code.add(';');
 		} else {
+			insertDecompilationProblems(code, mth);
 			boolean badCode = mth.contains(AFlag.INCONSISTENT_CODE);
 			if (badCode) {
-				code.startLine("/* JADX WARNING: inconsistent code. */");
-				code.startLine("/* Code decompiled incorrectly, please refer to instructions dump. */");
-				ErrorsCounter.methodError(mth, "Inconsistent code");
+				if (showInconsistentCode) {
+					code.startLine("/* Code decompiled incorrectly, please refer to instructions dump. */");
+					mth.remove(AFlag.INCONSISTENT_CODE);
+					badCode = false;
+				}
 			}
 			MethodGen mthGen;
-			if (badCode || mth.contains(AType.JADX_ERROR)) {
+			if (badCode || mth.contains(AType.JADX_ERROR) || fallback) {
 				mthGen = MethodGen.getFallbackMethodGen(mth);
 			} else {
 				mthGen = new MethodGen(this, mth);
@@ -282,12 +317,36 @@ public class ClassGen {
 			code.add('{');
 			code.incIndent();
 			insertSourceFileInfo(code, mth);
-			mthGen.addInstructions(code);
+			if (fallback) {
+				mthGen.addFallbackMethodCode(code);
+			} else {
+				mthGen.addInstructions(code);
+			}
 			code.decIndent();
 			code.startLine('}');
 		}
 	}
 
+	private void insertDecompilationProblems(CodeWriter code, MethodNode mth) {
+		List<JadxError> errors = mth.getAll(AType.JADX_ERROR);
+		List<JadxWarn> warns = mth.getAll(AType.JADX_WARN);
+		if (!errors.isEmpty()) {
+			errors.forEach(err -> {
+				code.startLine("/*  JADX ERROR: ").add(err.getError());
+				Throwable cause = err.getCause();
+				if (cause != null) {
+					code.incIndent();
+					Utils.appendStackTrace(code, cause);
+					code.decIndent();
+				}
+				code.add("*/");
+			});
+		}
+		if (!warns.isEmpty()) {
+			warns.forEach(warn -> code.startLine("/* JADX WARNING: ").add(warn.getWarn()).add(" */"));
+		}
+	}
+
 	private void addFields(CodeWriter code) throws CodegenException {
 		addEnumFields(code);
 		for (FieldNode f : cls.getFields()) {
@@ -295,21 +354,30 @@ public class ClassGen {
 				continue;
 			}
 			annotationGen.addForField(code, f);
+
+			if (f.getFieldInfo().isRenamed()) {
+				code.startLine("/* renamed from: ").add(f.getName()).add(" */");
+			}
 			code.startLine(f.getAccessFlags().makeString());
 			useType(code, f.getType());
 			code.add(' ');
-			code.add(f.getName());
-			FieldValueAttr fv = f.get(AType.FIELD_VALUE);
+			code.attachDefinition(f);
+			code.add(f.getAlias());
+			FieldInitAttr fv = f.get(AType.FIELD_INIT);
 			if (fv != null) {
 				code.add(" = ");
 				if (fv.getValue() == null) {
-					code.add(TypeGen.literalToString(0, f.getType()));
+					code.add(TypeGen.literalToString(0, f.getType(), cls));
 				} else {
-					annotationGen.encodeValue(code, fv.getValue());
+					if (fv.getValueType() == InitType.CONST) {
+						annotationGen.encodeValue(code, fv.getValue());
+					} else if (fv.getValueType() == InitType.INSN) {
+						InsnGen insnGen = makeInsnGen(fv.getInsnMth());
+						addInsnBody(insnGen, code, fv.getInsn());
+					}
 				}
 			}
 			code.add(';');
-			code.attachDefinition(f);
 		}
 	}
 
@@ -330,26 +398,18 @@ public class ClassGen {
 		InsnGen igen = null;
 		for (Iterator<EnumField> it = enumFields.getFields().iterator(); it.hasNext(); ) {
 			EnumField f = it.next();
-			code.startLine(f.getName());
-			if (f.getArgs().size() != 0) {
-				code.add('(');
-				for (Iterator<InsnArg> aIt = f.getArgs().iterator(); aIt.hasNext(); ) {
-					InsnArg arg = aIt.next();
-					if (igen == null) {
-						// don't init mth gen if this is simple enum
-						MethodGen mthGen = new MethodGen(this, enumFields.getStaticMethod());
-						igen = new InsnGen(mthGen, false);
-					}
-					igen.addArg(code, arg);
-					if (aIt.hasNext()) {
-						code.add(", ");
-					}
+			code.startLine(f.getField().getAlias());
+			ConstructorInsn constrInsn = f.getConstrInsn();
+			if (constrInsn.getArgsCount() > f.getStartArg()) {
+				if (igen == null) {
+					igen = makeInsnGen(enumFields.getStaticMethod());
 				}
-				code.add(')');
+				MethodNode callMth = cls.dex().resolveMethod(constrInsn.getCallMth());
+				igen.generateMethodArguments(code, constrInsn, f.getStartArg(), callMth);
 			}
 			if (f.getCls() != null) {
 				code.add(' ');
-				new ClassGen(f.getCls(), this, fallback).addClassBody(code);
+				new ClassGen(f.getCls(), this).addClassBody(code);
 			}
 			if (it.hasNext()) {
 				code.add(',');
@@ -360,6 +420,22 @@ public class ClassGen {
 				code.startLine();
 			}
 			code.add(';');
+			if (isFieldsPresents()) {
+				code.startLine();
+			}
+		}
+	}
+
+	private InsnGen makeInsnGen(MethodNode mth) {
+		MethodGen mthGen = new MethodGen(this, mth);
+		return new InsnGen(mthGen, false);
+	}
+
+	private void addInsnBody(InsnGen insnGen, CodeWriter code, InsnNode insn) {
+		try {
+			insnGen.makeInsn(insn, code, InsnGen.Flags.BODY_ONLY_NOWRAP);
+		} catch (Exception e) {
+			ErrorsCounter.classError(cls, "Failed to generate init code", e);
 		}
 	}
 
@@ -371,7 +447,7 @@ public class ClassGen {
 			if (type.isGenericType()) {
 				code.add(type.getObject());
 			} else {
-				useClass(code, ClassInfo.fromType(type));
+				useClass(code, type);
 			}
 		} else if (stype == PrimitiveType.ARRAY) {
 			useType(code, type.getArrayElement());
@@ -381,14 +457,9 @@ public class ClassGen {
 		}
 	}
 
-	public void useClass(CodeWriter code, ClassInfo classInfo) {
-		ClassNode classNode = cls.dex().resolveClass(classInfo);
-		if (classNode != null) {
-			code.attachAnnotation(classNode);
-		}
-		String baseClass = useClassInternal(cls.getClassInfo(), classInfo);
-		ArgType[] generics = classInfo.getType().getGenericTypes();
-		code.add(baseClass);
+	public void useClass(CodeWriter code, ArgType type) {
+		useClass(code, ClassInfo.extCls(cls.root(), type));
+		ArgType[] generics = type.getGenericTypes();
 		if (generics != null) {
 			code.add('<');
 			int len = generics.length;
@@ -413,53 +484,67 @@ public class ClassGen {
 		}
 	}
 
-	private String useClassInternal(ClassInfo useCls, ClassInfo classInfo) {
-		String fullName = classInfo.getFullName();
-		if (fallback) {
+	public void useClass(CodeWriter code, ClassInfo classInfo) {
+		ClassNode classNode = cls.dex().resolveClass(classInfo);
+		if (classNode != null) {
+			code.attachAnnotation(classNode);
+		}
+		String baseClass = useClassInternal(cls.getAlias(), classInfo.getAlias());
+		code.add(baseClass);
+	}
+
+	private String useClassInternal(ClassInfo useCls, ClassInfo extClsInfo) {
+		String fullName = extClsInfo.getFullName();
+		if (fallback || !useImports) {
 			return fullName;
 		}
-		String shortName = classInfo.getShortName();
-		if (classInfo.getPackage().equals("java.lang") && classInfo.getParentClass() == null) {
-			return shortName;
-		} else {
-			// don't add import if this class inner for current class
-			if (isClassInnerFor(classInfo, useCls)) {
-				return shortName;
-			}
-			// don't add import if this class from same package
-			if (classInfo.getPackage().equals(useCls.getPackage()) && !classInfo.isInner()) {
-				return shortName;
-			}
-			// don't add import if class not public (must be accessed using inheritance)
-			ClassNode classNode = cls.dex().resolveClass(classInfo);
-			if (classNode != null && !classNode.getAccessFlags().isPublic()) {
-				return shortName;
-			}
-			if (searchCollision(cls.dex(), useCls, shortName)) {
-				return fullName;
-			}
-			if (classInfo.getPackage().equals(useCls.getPackage())) {
-				fullName = classInfo.getNameWithoutPackage();
-			}
-			for (ClassInfo importCls : getImports()) {
-				if (!importCls.equals(classInfo)
-						&& importCls.getShortName().equals(shortName)) {
-					if (classInfo.isInner()) {
-						String parent = useClassInternal(useCls, classInfo.getParentClass());
-						return parent + "." + shortName;
-					} else {
-						return fullName;
-					}
-				}
-			}
-			addImport(classInfo);
+		String shortName = extClsInfo.getShortName();
+		if (extClsInfo.getPackage().equals("java.lang") && extClsInfo.getParentClass() == null) {
 			return shortName;
 		}
+		if (isClassInnerFor(useCls, extClsInfo)) {
+			return shortName;
+		}
+		if (isBothClassesInOneTopClass(useCls, extClsInfo)) {
+			return shortName;
+		}
+		// don't add import if this class from same package
+		if (extClsInfo.getPackage().equals(useCls.getPackage()) && !extClsInfo.isInner()) {
+			return shortName;
+		}
+		// don't add import if class not public (must be accessed using inheritance)
+		ClassNode classNode = cls.dex().resolveClass(extClsInfo);
+		if (classNode != null && !classNode.getAccessFlags().isPublic()) {
+			return shortName;
+		}
+		if (searchCollision(cls.dex(), useCls, extClsInfo)) {
+			return fullName;
+		}
+		// ignore classes from default package
+		if (extClsInfo.isDefaultPackage()) {
+			return shortName;
+		}
+		if (extClsInfo.getPackage().equals(useCls.getPackage())) {
+			fullName = extClsInfo.getNameWithoutPackage();
+		}
+		for (ClassInfo importCls : getImports()) {
+			if (!importCls.equals(extClsInfo)
+					&& importCls.getShortName().equals(shortName)) {
+				if (extClsInfo.isInner()) {
+					String parent = useClassInternal(useCls, extClsInfo.getParentClass().getAlias());
+					return parent + "." + shortName;
+				} else {
+					return fullName;
+				}
+			}
+		}
+		addImport(extClsInfo);
+		return shortName;
 	}
 
 	private void addImport(ClassInfo classInfo) {
 		if (parentGen != null) {
-			parentGen.addImport(classInfo);
+			parentGen.addImport(classInfo.getAlias());
 		} else {
 			imports.add(classInfo);
 		}
@@ -473,6 +558,16 @@ public class ClassGen {
 		}
 	}
 
+	private static boolean isBothClassesInOneTopClass(ClassInfo useCls, ClassInfo extClsInfo) {
+		ClassInfo a = useCls.getTopParentClass();
+		ClassInfo b = extClsInfo.getTopParentClass();
+		if (a != null) {
+			return a.equals(b);
+		}
+		// useCls - is a top class
+		return useCls.equals(b);
+	}
+
 	private static boolean isClassInnerFor(ClassInfo inner, ClassInfo parent) {
 		if (inner.isInner()) {
 			ClassInfo p = inner.getParentClass();
@@ -481,28 +576,37 @@ public class ClassGen {
 		return false;
 	}
 
-	private static boolean searchCollision(DexNode dex, ClassInfo useCls, String shortName) {
+	private static boolean searchCollision(DexNode dex, ClassInfo useCls, ClassInfo searchCls) {
 		if (useCls == null) {
 			return false;
 		}
+		String shortName = searchCls.getShortName();
 		if (useCls.getShortName().equals(shortName)) {
 			return true;
 		}
 		ClassNode classNode = dex.resolveClass(useCls);
 		if (classNode != null) {
 			for (ClassNode inner : classNode.getInnerClasses()) {
-				if (inner.getShortName().equals(shortName)) {
+				if (inner.getShortName().equals(shortName)
+						&& !inner.getAlias().equals(searchCls)) {
 					return true;
 				}
 			}
 		}
-		return searchCollision(dex, useCls.getParentClass(), shortName);
+		return searchCollision(dex, useCls.getParentClass(), searchCls);
 	}
 
 	private void insertSourceFileInfo(CodeWriter code, AttrNode node) {
 		SourceFileAttr sourceFileAttr = node.get(AType.SOURCE_FILE);
 		if (sourceFileAttr != null) {
-			code.startLine("// compiled from: ").add(sourceFileAttr.getFileName());
+			code.startLine("/* compiled from: ").add(sourceFileAttr.getFileName()).add(" */");
+		}
+	}
+
+	private void insertRenameInfo(CodeWriter code, ClassNode cls) {
+		ClassInfo classInfo = cls.getClassInfo();
+		if (classInfo.isRenamed()) {
+			code.startLine("/* renamed from: ").add(classInfo.getType().getObject()).add(" */");
 		}
 	}
 

jadx-core/src/main/java/jadx/core/codegen/CodeGen.java

@@ -1,29 +1,15 @@
 package jadx.core.codegen;
 
-import jadx.api.IJadxArgs;
 import jadx.core.dex.nodes.ClassNode;
-import jadx.core.dex.visitors.AbstractVisitor;
 import jadx.core.utils.exceptions.CodegenException;
 
-public class CodeGen extends AbstractVisitor {
+public class CodeGen {
 
-	private final IJadxArgs args;
-
-	public CodeGen(IJadxArgs args) {
-		this.args = args;
-	}
-
-	@Override
 	public boolean visit(ClassNode cls) throws CodegenException {
-		ClassGen clsGen = new ClassGen(cls, null, isFallbackMode());
+		ClassGen clsGen = new ClassGen(cls, cls.root().getArgs());
 		CodeWriter clsCode = clsGen.makeClass();
 		clsCode.finish();
 		cls.setCode(clsCode);
 		return false;
 	}
-
-	public boolean isFallbackMode() {
-		return args.isFallbackMode();
-	}
-
 }

jadx-core/src/main/java/jadx/core/codegen/CodeWriter.java

@@ -1,9 +1,5 @@
 package jadx.core.codegen;
 
-import jadx.api.CodePosition;
-import jadx.core.dex.attributes.nodes.LineAttrNode;
-import jadx.core.utils.Utils;
-
 import java.io.File;
 import java.io.PrintWriter;
 import java.util.Collections;
@@ -12,26 +8,36 @@ import java.util.Iterator;
 import java.util.Map;
 import java.util.TreeMap;
 
+import org.jetbrains.annotations.Nullable;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.CodePosition;
+import jadx.core.dex.attributes.nodes.LineAttrNode;
+import jadx.core.utils.StringUtils;
+import jadx.core.utils.files.FileUtils;
+import jadx.core.utils.files.ZipSecurity;
+
 public class CodeWriter {
 	private static final Logger LOG = LoggerFactory.getLogger(CodeWriter.class);
-	private static final int MAX_FILENAME_LENGTH = 128;
 
 	public static final String NL = System.getProperty("line.separator");
-	public static final String INDENT = "    ";
+	public static final String INDENT_STR = "    ";
+
+	private static final boolean ADD_LINE_NUMBERS = false;
 
 	private static final String[] INDENT_CACHE = {
 			"",
-			INDENT,
-			INDENT + INDENT,
-			INDENT + INDENT + INDENT,
-			INDENT + INDENT + INDENT + INDENT,
-			INDENT + INDENT + INDENT + INDENT + INDENT,
+			INDENT_STR,
+			INDENT_STR + INDENT_STR,
+			INDENT_STR + INDENT_STR + INDENT_STR,
+			INDENT_STR + INDENT_STR + INDENT_STR + INDENT_STR,
+			INDENT_STR + INDENT_STR + INDENT_STR + INDENT_STR + INDENT_STR,
 	};
 
-	private final StringBuilder buf = new StringBuilder();
+	private StringBuilder buf = new StringBuilder();
+	@Nullable
+	private String code;
 	private String indentStr;
 	private int indent;
 
@@ -43,6 +49,9 @@ public class CodeWriter {
 	public CodeWriter() {
 		this.indent = 0;
 		this.indentStr = "";
+		if (ADD_LINE_NUMBERS) {
+			incIndent(2);
+		}
 	}
 
 	public CodeWriter startLine() {
@@ -65,6 +74,35 @@ public class CodeWriter {
 		return this;
 	}
 
+	public CodeWriter startLineWithNum(int sourceLine) {
+		if (sourceLine == 0) {
+			startLine();
+			return this;
+		}
+		if (ADD_LINE_NUMBERS) {
+			newLine();
+			attachSourceLine(sourceLine);
+			String ln = "/* " + sourceLine + " */ ";
+			add(ln);
+			if (indentStr.length() > ln.length()) {
+				add(indentStr.substring(ln.length()));
+			}
+		} else {
+			startLine();
+			attachSourceLine(sourceLine);
+		}
+		return this;
+	}
+
+	public CodeWriter addMultiLine(String str) {
+		buf.append(str);
+		if (str.contains(NL)) {
+			line += StringUtils.countMatches(str, NL);
+			offset = 0;
+		}
+		return this;
+	}
+
 	public CodeWriter add(String str) {
 		buf.append(str);
 		offset += str.length();
@@ -88,7 +126,7 @@ public class CodeWriter {
 		}
 		line += code.line;
 		offset = code.offset;
-		buf.append(code);
+		buf.append(code.buf);
 		return this;
 	}
 
@@ -98,7 +136,7 @@ public class CodeWriter {
 	}
 
 	public CodeWriter addIndent() {
-		add(INDENT);
+		add(INDENT_STR);
 		return this;
 	}
 
@@ -119,9 +157,9 @@ public class CodeWriter {
 		if (curIndent < INDENT_CACHE.length) {
 			this.indentStr = INDENT_CACHE[curIndent];
 		} else {
-			StringBuilder s = new StringBuilder(curIndent * INDENT.length());
+			StringBuilder s = new StringBuilder(curIndent * INDENT_STR.length());
 			for (int i = 0; i < curIndent; i++) {
-				s.append(INDENT);
+				s.append(INDENT_STR);
 			}
 			this.indentStr = s.toString();
 		}
@@ -149,6 +187,15 @@ public class CodeWriter {
 		updateIndent();
 	}
 
+	public int getIndent() {
+		return indent;
+	}
+
+	public void setIndent(int indent) {
+		this.indent = indent;
+		updateIndent();
+	}
+
 	public int getLine() {
 		return line;
 	}
@@ -165,17 +212,18 @@ public class CodeWriter {
 		}
 	}
 
-	public Object attachDefinition(LineAttrNode obj) {
-		return attachAnnotation(new DefinitionWrapper(obj), new CodePosition(line, offset));
+	public void attachDefinition(LineAttrNode obj) {
+		attachAnnotation(obj);
+		attachAnnotation(new DefinitionWrapper(obj), new CodePosition(line, offset));
 	}
 
-	public Object attachAnnotation(Object obj) {
-		return attachAnnotation(obj, new CodePosition(line, offset + 1));
+	public void attachAnnotation(Object obj) {
+		attachAnnotation(obj, new CodePosition(line, offset + 1));
 	}
 
 	private Object attachAnnotation(Object obj, CodePosition pos) {
 		if (annotations.isEmpty()) {
-			annotations = new HashMap<CodePosition, Object>();
+			annotations = new HashMap<>();
 		}
 		return annotations.put(pos, obj);
 	}
@@ -193,7 +241,7 @@ public class CodeWriter {
 
 	private void attachSourceLine(int decompiledLine, int sourceLine) {
 		if (lineMap.isEmpty()) {
-			lineMap = new TreeMap<Integer, Integer>();
+			lineMap = new TreeMap<>();
 		}
 		lineMap.put(decompiledLine, sourceLine);
 	}
@@ -203,7 +251,11 @@ public class CodeWriter {
 	}
 
 	public void finish() {
+		removeFirstEmptyLine();
 		buf.trimToSize();
+		code = buf.toString();
+		buf = null;
+
 		Iterator<Map.Entry<CodePosition, Object>> it = annotations.entrySet().iterator();
 		while (it.hasNext()) {
 			Map.Entry<CodePosition, Object> entry = it.next();
@@ -216,81 +268,49 @@ public class CodeWriter {
 		}
 	}
 
-	private static String removeFirstEmptyLine(String str) {
-		if (str.startsWith(NL)) {
-			return str.substring(NL.length());
+	private void removeFirstEmptyLine() {
+		int len = NL.length();
+		if (buf.substring(0, len).equals(NL)) {
+			buf.delete(0, len);
 		}
-		return str;
 	}
 
-	public int length() {
+	public int bufLength() {
 		return buf.length();
 	}
 
-	public boolean isEmpty() {
-		return buf.length() == 0;
-	}
-
-	public boolean notEmpty() {
-		return buf.length() != 0;
+	public String getCodeStr() {
+		return code;
 	}
 
 	@Override
 	public String toString() {
-		return buf.toString();
+		return buf == null ? code : buf.toString();
 	}
 
 	public void save(File dir, String subDir, String fileName) {
+		if(!ZipSecurity.isValidZipEntryName(subDir) || !ZipSecurity.isValidZipEntryName(fileName)) {
+			return;
+		}
 		save(dir, new File(subDir, fileName).getPath());
 	}
 
 	public void save(File dir, String fileName) {
+		if(!ZipSecurity.isValidZipEntryName(fileName)) {
+			return;
+		}
 		save(new File(dir, fileName));
 	}
 
 	public void save(File file) {
-		String name = file.getName();
-		if (name.length() > MAX_FILENAME_LENGTH) {
-			int dotIndex = name.indexOf('.');
-			int cutAt = MAX_FILENAME_LENGTH - name.length() + dotIndex - 1;
-			if (cutAt <= 0) {
-				name = name.substring(0, MAX_FILENAME_LENGTH - 1);
-			} else {
-				name = name.substring(0, cutAt) + name.substring(dotIndex);
-			}
-			file = new File(file.getParentFile(), name);
+		if (code == null) {
+			finish();
 		}
-
-		PrintWriter out = null;
-		try {
-			Utils.makeDirsForFile(file);
-			out = new PrintWriter(file, "UTF-8");
-			String code = buf.toString();
-			code = removeFirstEmptyLine(code);
-			out.print(code);
+		File outFile = FileUtils.prepareFile(file);
+		try (PrintWriter out = new PrintWriter(outFile, "UTF-8")) {
+			out.println(code);
 		} catch (Exception e) {
 			LOG.error("Save file error", e);
-		} finally {
-			if (out != null) {
-				out.close();
-			}
 		}
 	}
-
-	@Override
-	public int hashCode() {
-		return buf.toString().hashCode();
-	}
-
-	@Override
-	public boolean equals(Object o) {
-		if (this == o) {
-			return true;
-		}
-		if (!(o instanceof CodeWriter)) {
-			return false;
-		}
-		CodeWriter that = (CodeWriter) o;
-		return buf.toString().equals(that.buf.toString());
-	}
 }

jadx-core/src/main/java/jadx/core/codegen/ConditionGen.java

@@ -1,5 +1,9 @@
 package jadx.core.codegen;
 
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.Queue;
+
 import jadx.core.dex.instructions.ArithNode;
 import jadx.core.dex.instructions.IfOp;
 import jadx.core.dex.instructions.InsnType;
@@ -8,57 +12,92 @@ import jadx.core.dex.instructions.args.InsnArg;
 import jadx.core.dex.instructions.args.InsnWrapArg;
 import jadx.core.dex.instructions.args.LiteralArg;
 import jadx.core.dex.nodes.InsnNode;
-import jadx.core.dex.regions.Compare;
-import jadx.core.dex.regions.IfCondition;
-import jadx.core.dex.regions.IfCondition.Mode;
+import jadx.core.dex.regions.conditions.Compare;
+import jadx.core.dex.regions.conditions.IfCondition;
+import jadx.core.dex.regions.conditions.IfCondition.Mode;
 import jadx.core.utils.ErrorsCounter;
 import jadx.core.utils.exceptions.CodegenException;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
-import java.util.Iterator;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 public class ConditionGen extends InsnGen {
-	private static final Logger LOG = LoggerFactory.getLogger(ConditionGen.class);
+
+	private static class CondStack {
+		private final Queue<IfCondition> stack = new LinkedList<>();
+
+		public Queue<IfCondition> getStack() {
+			return stack;
+		}
+
+		public void push(IfCondition cond) {
+			stack.add(cond);
+		}
+
+		public IfCondition pop() {
+			return stack.poll();
+		}
+	}
 
 	public ConditionGen(InsnGen insnGen) {
 		super(insnGen.mgen, insnGen.fallback);
 	}
 
 	void add(CodeWriter code, IfCondition condition) throws CodegenException {
+		add(code, new CondStack(), condition);
+	}
+
+	void wrap(CodeWriter code, IfCondition condition) throws CodegenException {
+		wrap(code, new CondStack(), condition);
+	}
+
+	private void add(CodeWriter code, CondStack stack, IfCondition condition) throws CodegenException {
+		stack.push(condition);
 		switch (condition.getMode()) {
 			case COMPARE:
-				addCompare(code, condition.getCompare());
+				addCompare(code, stack, condition.getCompare());
+				break;
+
+			case TERNARY:
+				addTernary(code, stack, condition);
 				break;
 
 			case NOT:
-				addNot(code, condition);
+				addNot(code, stack, condition);
 				break;
 
 			case AND:
 			case OR:
-				addAndOr(code, condition);
+				addAndOr(code, stack, condition);
 				break;
 
 			default:
-				throw new JadxRuntimeException("Unknown condition mode: " + condition);
+				throw new JadxRuntimeException("Unknown condition mode: " + condition.getMode());
 		}
+		stack.pop();
 	}
 
-	void wrap(CodeWriter code, IfCondition cond) throws CodegenException {
+	private void wrap(CodeWriter code, CondStack stack, IfCondition cond) throws CodegenException {
 		boolean wrap = isWrapNeeded(cond);
 		if (wrap) {
 			code.add('(');
 		}
-		add(code, cond);
+		add(code, stack, cond);
 		if (wrap) {
 			code.add(')');
 		}
 	}
 
-	private void addCompare(CodeWriter code, Compare compare) throws CodegenException {
+	private void wrap(CodeWriter code, InsnArg firstArg) throws CodegenException {
+		boolean wrap = isArgWrapNeeded(firstArg);
+		if (wrap) {
+			code.add('(');
+		}
+		addArg(code, firstArg, false);
+		if (wrap) {
+			code.add(')');
+		}
+	}
+
+	private void addCompare(CodeWriter code, CondStack stack, Compare compare) throws CodegenException {
 		IfOp op = compare.getOp();
 		InsnArg firstArg = compare.getA();
 		InsnArg secondArg = compare.getB();
@@ -71,22 +110,19 @@ public class ConditionGen extends InsnGen {
 			}
 			if (op == IfOp.EQ) {
 				// == true
-				addArg(code, firstArg, false);
+				if (stack.getStack().size() == 1) {
+					addArg(code, firstArg, false);
+				} else {
+					wrap(code, firstArg);
+				}
 				return;
 			} else if (op == IfOp.NE) {
 				// != true
 				code.add('!');
-				boolean wrap = isArgWrapNeeded(firstArg);
-				if (wrap) {
-					code.add('(');
-				}
-				addArg(code, firstArg, false);
-				if (wrap) {
-					code.add(')');
-				}
+				wrap(code, firstArg);
 				return;
 			}
-			LOG.warn(ErrorsCounter.formatErrorMsg(mth, "Unsupported boolean condition " + op.getSymbol()));
+			ErrorsCounter.methodWarn(mth, "Unsupported boolean condition " + op.getSymbol());
 		}
 
 		addArg(code, firstArg, isArgWrapNeeded(firstArg));
@@ -94,16 +130,24 @@ public class ConditionGen extends InsnGen {
 		addArg(code, secondArg, isArgWrapNeeded(secondArg));
 	}
 
-	private void addNot(CodeWriter code, IfCondition condition) throws CodegenException {
-		code.add('!');
-		wrap(code, condition.getArgs().get(0));
+	private void addTernary(CodeWriter code, CondStack stack, IfCondition condition) throws CodegenException {
+		add(code, stack, condition.first());
+		code.add(" ? ");
+		add(code, stack, condition.second());
+		code.add(" : ");
+		add(code, stack, condition.third());
 	}
 
-	private void addAndOr(CodeWriter code, IfCondition condition) throws CodegenException {
+	private void addNot(CodeWriter code, CondStack stack, IfCondition condition) throws CodegenException {
+		code.add('!');
+		wrap(code, stack, condition.getArgs().get(0));
+	}
+
+	private void addAndOr(CodeWriter code, CondStack stack, IfCondition condition) throws CodegenException {
 		String mode = condition.getMode() == Mode.AND ? " && " : " || ";
 		Iterator<IfCondition> it = condition.getArgs().iterator();
 		while (it.hasNext()) {
-			wrap(code, it.next());
+			wrap(code, stack, it.next());
 			if (it.hasNext()) {
 				code.add(mode);
 			}
@@ -111,7 +155,10 @@ public class ConditionGen extends InsnGen {
 	}
 
 	private boolean isWrapNeeded(IfCondition condition) {
-		return !condition.isCompare() && condition.getMode() != Mode.NOT;
+		if (condition.isCompare()) {
+			return false;
+		}
+		return condition.getMode() != Mode.NOT;
 	}
 
 	private static boolean isArgWrapNeeded(InsnArg arg) {
@@ -128,6 +175,9 @@ public class ConditionGen extends InsnGen {
 				case DIV:
 				case REM:
 					return false;
+
+				default:
+					return true;
 			}
 		} else {
 			switch (insnType) {
@@ -138,10 +188,10 @@ public class ConditionGen extends InsnGen {
 				case CONST:
 				case ARRAY_LENGTH:
 					return false;
+
 				default:
 					return true;
 			}
 		}
-		return true;
 	}
 }

jadx-core/src/main/java/jadx/core/codegen/InsnGen.java

@@ -1,8 +1,20 @@
 package jadx.core.codegen;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.nodes.FieldReplaceAttr;
+import jadx.core.dex.attributes.nodes.LoopLabelAttr;
 import jadx.core.dex.attributes.nodes.MethodInlineAttr;
 import jadx.core.dex.info.ClassInfo;
 import jadx.core.dex.info.FieldInfo;
@@ -12,19 +24,21 @@ import jadx.core.dex.instructions.ArithOp;
 import jadx.core.dex.instructions.ConstClassNode;
 import jadx.core.dex.instructions.ConstStringNode;
 import jadx.core.dex.instructions.FillArrayNode;
+import jadx.core.dex.instructions.FilledNewArrayNode;
 import jadx.core.dex.instructions.GotoNode;
 import jadx.core.dex.instructions.IfNode;
 import jadx.core.dex.instructions.IndexInsnNode;
 import jadx.core.dex.instructions.InsnType;
 import jadx.core.dex.instructions.InvokeNode;
 import jadx.core.dex.instructions.InvokeType;
+import jadx.core.dex.instructions.NewArrayNode;
 import jadx.core.dex.instructions.SwitchNode;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.instructions.args.FieldArg;
 import jadx.core.dex.instructions.args.InsnArg;
 import jadx.core.dex.instructions.args.InsnWrapArg;
 import jadx.core.dex.instructions.args.LiteralArg;
-import jadx.core.dex.instructions.args.NamedArg;
+import jadx.core.dex.instructions.args.Named;
 import jadx.core.dex.instructions.args.RegisterArg;
 import jadx.core.dex.instructions.mods.ConstructorInsn;
 import jadx.core.dex.instructions.mods.TernaryInsn;
@@ -34,21 +48,11 @@ import jadx.core.dex.nodes.InsnNode;
 import jadx.core.dex.nodes.MethodNode;
 import jadx.core.dex.nodes.RootNode;
 import jadx.core.utils.ErrorsCounter;
-import jadx.core.utils.InsnUtils;
 import jadx.core.utils.RegionUtils;
-import jadx.core.utils.StringUtils;
 import jadx.core.utils.exceptions.CodegenException;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
-import java.util.ArrayList;
-import java.util.EnumSet;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import static jadx.core.utils.android.AndroidResourcesUtils.handleAppResField;
 
 public class InsnGen {
 	private static final Logger LOG = LoggerFactory.getLogger(InsnGen.class);
@@ -58,9 +62,10 @@ public class InsnGen {
 	protected final RootNode root;
 	protected final boolean fallback;
 
-	private enum Flags {
+	protected enum Flags {
 		BODY_ONLY,
 		BODY_ONLY_NOWRAP,
+		INLINE
 	}
 
 	public InsnGen(MethodGen mgen, boolean fallback) {
@@ -75,9 +80,9 @@ public class InsnGen {
 	}
 
 	public void addArgDot(CodeWriter code, InsnArg arg) throws CodegenException {
-		int len = code.length();
+		int len = code.bufLength();
 		addArg(code, arg, true);
-		if (len != code.length()) {
+		if (len != code.bufLength()) {
 			code.add('.');
 		}
 	}
@@ -95,7 +100,7 @@ public class InsnGen {
 			Flags flag = wrap ? Flags.BODY_ONLY : Flags.BODY_ONLY_NOWRAP;
 			makeInsn(((InsnWrapArg) arg).getWrapInsn(), code, flag);
 		} else if (arg.isNamed()) {
-			code.add(((NamedArg) arg).getName());
+			code.add(((Named) arg).getName());
 		} else if (arg.isField()) {
 			FieldArg f = (FieldArg) arg;
 			if (f.isStatic()) {
@@ -118,67 +123,81 @@ public class InsnGen {
 	}
 
 	public void declareVar(CodeWriter code, RegisterArg arg) {
+		if (arg.getSVar().contains(AFlag.FINAL)) {
+			code.add("final ");
+		}
 		useType(code, arg.getType());
 		code.add(' ');
 		code.add(mgen.getNameGen().assignArg(arg));
 	}
 
-	private static String lit(LiteralArg arg) {
-		return TypeGen.literalToString(arg.getLiteral(), arg.getType());
+	private String lit(LiteralArg arg) {
+		return TypeGen.literalToString(arg.getLiteral(), arg.getType(), mth);
 	}
 
 	private void instanceField(CodeWriter code, FieldInfo field, InsnArg arg) throws CodegenException {
-		FieldNode fieldNode = mth.getParentClass().searchField(field);
+		ClassNode pCls = mth.getParentClass();
+		FieldNode fieldNode = pCls.dex().root().deepResolveField(field);
 		if (fieldNode != null) {
 			FieldReplaceAttr replace = fieldNode.get(AType.FIELD_REPLACE);
 			if (replace != null) {
-				FieldInfo info = replace.getFieldInfo();
-				if (replace.isOuterClass()) {
-					useClass(code, info.getDeclClass());
-					code.add(".this");
+				switch (replace.getReplaceType()) {
+					case CLASS_INSTANCE:
+						useClass(code, replace.getClsRef());
+						code.add(".this");
+						break;
+					case VAR:
+						addArg(code, replace.getVarRef());
+						break;
 				}
 				return;
 			}
 		}
 		addArgDot(code, arg);
-		fieldNode = mth.dex().resolveField(field);
 		if (fieldNode != null) {
 			code.attachAnnotation(fieldNode);
 		}
-		code.add(field.getName());
+		if (fieldNode == null) {
+			code.add(field.getAlias());
+		} else {
+			code.add(fieldNode.getAlias());
+		}
 	}
 
 	public static void makeStaticFieldAccess(CodeWriter code, FieldInfo field, ClassGen clsGen) {
 		ClassInfo declClass = field.getDeclClass();
-		boolean fieldFromThisClass = clsGen.getClassNode().getFullName().startsWith(declClass.getFullName());
+		boolean fieldFromThisClass = clsGen.getClassNode().getClassInfo().equals(declClass);
 		if (!fieldFromThisClass) {
 			// Android specific resources class handler
-			ClassInfo parentClass = declClass.getParentClass();
-			if (parentClass != null && parentClass.getShortName().equals("R")) {
-				clsGen.useClass(code, parentClass);
-				code.add('.');
-				code.add(declClass.getShortName());
-			} else {
+			if (!handleAppResField(code, clsGen, declClass)) {
 				clsGen.useClass(code, declClass);
 			}
 			code.add('.');
 		}
-		FieldNode fieldNode = clsGen.getClassNode().dex().resolveField(field);
+		FieldNode fieldNode = clsGen.getClassNode().dex().root().deepResolveField(field);
 		if (fieldNode != null) {
 			code.attachAnnotation(fieldNode);
 		}
-		code.add(field.getName());
+		if (fieldNode == null) {
+			code.add(field.getAlias());
+		} else {
+			code.add(fieldNode.getAlias());
+		}
 	}
 
 	protected void staticField(CodeWriter code, FieldInfo field) {
 		makeStaticFieldAccess(code, field, mgen.getClassGen());
 	}
 
+	public void useClass(CodeWriter code, ArgType type) {
+		mgen.getClassGen().useClass(code, type);
+	}
+
 	public void useClass(CodeWriter code, ClassInfo cls) {
 		mgen.getClassGen().useClass(code, cls);
 	}
 
-	private void useType(CodeWriter code, ArgType type) {
+	protected void useType(CodeWriter code, ArgType type) {
 		mgen.getClassGen().useType(code, type);
 	}
 
@@ -186,26 +205,24 @@ public class InsnGen {
 		return makeInsn(insn, code, null);
 	}
 
-	private boolean makeInsn(InsnNode insn, CodeWriter code, Flags flag) throws CodegenException {
+	protected boolean makeInsn(InsnNode insn, CodeWriter code, Flags flag) throws CodegenException {
 		try {
-			if (insn.getType() == InsnType.NOP) {
-				return false;
-			}
-			EnumSet<Flags> state = EnumSet.noneOf(Flags.class);
+			Set<Flags> state = EnumSet.noneOf(Flags.class);
 			if (flag == Flags.BODY_ONLY || flag == Flags.BODY_ONLY_NOWRAP) {
 				state.add(flag);
 				makeInsnBody(code, insn, state);
 			} else {
-				code.startLine();
-				if (insn.getSourceLine() != 0) {
-					code.attachSourceLine(insn.getSourceLine());
+				if (flag != Flags.INLINE) {
+					code.startLineWithNum(insn.getSourceLine());
 				}
-				if (insn.getResult() != null && insn.getType() != InsnType.ARITH_ONEARG) {
+				if (insn.getResult() != null && !insn.contains(AFlag.ARITH_ONEARG)) {
 					assignVar(code, insn);
 					code.add(" = ");
 				}
 				makeInsnBody(code, insn, state);
-				code.add(';');
+				if (flag != Flags.INLINE) {
+					code.add(';');
+				}
 			}
 		} catch (Throwable th) {
 			throw new CodegenException(mth, "Error generate insn: " + insn, th);
@@ -213,11 +230,11 @@ public class InsnGen {
 		return true;
 	}
 
-	private void makeInsnBody(CodeWriter code, InsnNode insn, EnumSet<Flags> state) throws CodegenException {
+	private void makeInsnBody(CodeWriter code, InsnNode insn, Set<Flags> state) throws CodegenException {
 		switch (insn.getType()) {
 			case CONST_STR:
 				String str = ((ConstStringNode) insn).getString();
-				code.add(StringUtils.unescapeString(str));
+				code.add(mth.dex().root().getStringUtils().unescapeString(str));
 				break;
 
 			case CONST_CLASS:
@@ -255,22 +272,13 @@ public class InsnGen {
 				makeArith((ArithNode) insn, code, state);
 				break;
 
-			case ARITH_ONEARG:
-				makeArithOneArg((ArithNode) insn, code);
+			case NEG:
+				oneArgInsn(code, insn, state, '-');
 				break;
 
-			case NEG: {
-				boolean wrap = state.contains(Flags.BODY_ONLY);
-				if (wrap) {
-					code.add('(');
-				}
-				code.add('-');
-				addArg(code, insn.getArg(0));
-				if (wrap) {
-					code.add(')');
-				}
+			case NOT:
+				oneArgInsn(code, insn, state, '~');
 				break;
-			}
 
 			case RETURN:
 				if (insn.getArgsCount() != 0) {
@@ -283,6 +291,10 @@ public class InsnGen {
 
 			case BREAK:
 				code.add("break");
+				LoopLabelAttr labelAttr = insn.get(AType.LOOP_LABEL);
+				if (labelAttr != null) {
+					code.add(' ').add(mgen.getNameGen().getLoopLabel(labelAttr));
+				}
 				break;
 
 			case CONTINUE:
@@ -304,7 +316,7 @@ public class InsnGen {
 				addArg(code, insn.getArg(0));
 				code.add(" == ");
 				addArg(code, insn.getArg(1));
-				code.add("? 0 : -1))");
+				code.add(" ? 0 : -1))");
 				break;
 
 			case INSTANCE_OF: {
@@ -329,7 +341,7 @@ public class InsnGen {
 				break;
 
 			case NEW_ARRAY: {
-				ArgType arrayType = insn.getResult().getType();
+				ArgType arrayType = ((NewArrayNode) insn).getArrayType();
 				code.add("new ");
 				useType(code, arrayType.getArrayRootElement());
 				code.add('[');
@@ -347,12 +359,8 @@ public class InsnGen {
 				code.add(".length");
 				break;
 
-			case FILL_ARRAY:
-				fillArray((FillArrayNode) insn, code);
-				break;
-
 			case FILLED_NEW_ARRAY:
-				filledNewArray(insn, code);
+				filledNewArray((FilledNewArrayNode) insn, code);
 				break;
 
 			case AGET:
@@ -425,28 +433,17 @@ public class InsnGen {
 				}
 				break;
 
-			case MOVE_EXCEPTION:
-				if (isFallback()) {
-					code.add("move-exception");
-				} else {
-					addArg(code, insn.getArg(0));
-				}
-				break;
-
 			case TERNARY:
 				makeTernary((TernaryInsn) insn, code, state);
 				break;
 
-			case ARGS:
+			case ONE_ARG:
 				addArg(code, insn.getArg(0));
 				break;
 
-			case PHI:
-				break;
-
 			/* fallback mode instructions */
 			case IF:
-				assert isFallback() : "if insn in not fallback mode";
+				fallbackOnlyInsn(insn);
 				IfNode ifInsn = (IfNode) insn;
 				code.add("if (");
 				addArg(code, insn.getArg(0));
@@ -457,12 +454,17 @@ public class InsnGen {
 				break;
 
 			case GOTO:
-				assert isFallback();
+				fallbackOnlyInsn(insn);
 				code.add("goto ").add(MethodGen.getLabelName(((GotoNode) insn).getTarget()));
 				break;
 
+			case MOVE_EXCEPTION:
+				fallbackOnlyInsn(insn);
+				code.add("move-exception");
+				break;
+
 			case SWITCH:
-				assert isFallback();
+				fallbackOnlyInsn(insn);
 				SwitchNode sw = (SwitchNode) insn;
 				code.add("switch(");
 				addArg(code, insn.getArg(0));
@@ -479,10 +481,40 @@ public class InsnGen {
 				code.startLine('}');
 				break;
 
+			case FILL_ARRAY:
+				fallbackOnlyInsn(insn);
+				FillArrayNode arrayNode = (FillArrayNode) insn;
+				Object data = arrayNode.getData();
+				String arrStr;
+				if (data instanceof int[]) {
+					arrStr = Arrays.toString((int[]) data);
+				} else if (data instanceof short[]) {
+					arrStr = Arrays.toString((short[]) data);
+				} else if (data instanceof byte[]) {
+					arrStr = Arrays.toString((byte[]) data);
+				} else if (data instanceof long[]) {
+					arrStr = Arrays.toString((long[]) data);
+				} else {
+					arrStr = "?";
+				}
+				code.add('{').add(arrStr.substring(1, arrStr.length() - 1)).add('}');
+				break;
+
 			case NEW_INSTANCE:
 				// only fallback - make new instance in constructor invoke
-				assert isFallback();
-				code.add("new " + insn.getResult().getType());
+				fallbackOnlyInsn(insn);
+				code.add("new ").add(insn.getResult().getType().toString());
+				break;
+
+			case PHI:
+			case MERGE:
+				fallbackOnlyInsn(insn);
+				code.add(insn.getType().toString()).add("(");
+				for (InsnArg insnArg : insn.getArguments()) {
+					addArg(code, insnArg);
+					code.add(' ');
+				}
+				code.add(")");
 				break;
 
 			default:
@@ -490,11 +522,29 @@ public class InsnGen {
 		}
 	}
 
-	private void filledNewArray(InsnNode insn, CodeWriter code) throws CodegenException {
-		int c = insn.getArgsCount();
+	private void oneArgInsn(CodeWriter code, InsnNode insn, Set<Flags> state, char op) throws CodegenException {
+		boolean wrap = state.contains(Flags.BODY_ONLY);
+		if (wrap) {
+			code.add('(');
+		}
+		code.add(op);
+		addArg(code, insn.getArg(0));
+		if (wrap) {
+			code.add(')');
+		}
+	}
+
+	private void fallbackOnlyInsn(InsnNode insn) throws CodegenException {
+		if (!fallback) {
+			throw new CodegenException(insn.getType() + " can be used only in fallback mode");
+		}
+	}
+
+	private void filledNewArray(FilledNewArrayNode insn, CodeWriter code) throws CodegenException {
 		code.add("new ");
-		useType(code, insn.getResult().getType());
+		useType(code, insn.getArrayType());
 		code.add('{');
+		int c = insn.getArgsCount();
 		for (int i = 0; i < c; i++) {
 			addArg(code, insn.getArg(i), false);
 			if (i + 1 < c) {
@@ -504,93 +554,11 @@ public class InsnGen {
 		code.add('}');
 	}
 
-	private void fillArray(FillArrayNode insn, CodeWriter code) throws CodegenException {
-		ArgType insnArrayType = insn.getResult().getType();
-		ArgType insnElementType = insnArrayType.getArrayElement();
-		ArgType elType = insn.getElementType();
-		if (!elType.equals(insnElementType) && !insnArrayType.equals(ArgType.OBJECT)) {
-			ErrorsCounter.methodError(mth,
-					"Incorrect type for fill-array insn " + InsnUtils.formatOffset(insn.getOffset())
-							+ ", element type: " + elType + ", insn element type: " + insnElementType
-			);
-			if (!elType.isTypeKnown()) {
-				elType = insnElementType.isTypeKnown() ? insnElementType : elType.selectFirst();
-			}
-		}
-		StringBuilder str = new StringBuilder();
-		Object data = insn.getData();
-		switch (elType.getPrimitiveType()) {
-			case BOOLEAN:
-			case BYTE:
-				byte[] array = (byte[]) data;
-				for (byte b : array) {
-					str.append(TypeGen.literalToString(b, elType));
-					str.append(", ");
-				}
-				break;
-			case SHORT:
-			case CHAR:
-				short[] sarray = (short[]) data;
-				for (short b : sarray) {
-					str.append(TypeGen.literalToString(b, elType));
-					str.append(", ");
-				}
-				break;
-			case INT:
-			case FLOAT:
-				int[] iarray = (int[]) data;
-				for (int b : iarray) {
-					str.append(TypeGen.literalToString(b, elType));
-					str.append(", ");
-				}
-				break;
-			case LONG:
-			case DOUBLE:
-				long[] larray = (long[]) data;
-				for (long b : larray) {
-					str.append(TypeGen.literalToString(b, elType));
-					str.append(", ");
-				}
-				break;
-
-			default:
-				throw new CodegenException(mth, "Unknown type: " + elType);
-		}
-		int len = str.length();
-		str.delete(len - 2, len);
-		code.add("new ");
-		useType(code, elType);
-		code.add("[]{").add(str.toString()).add('}');
-	}
-
 	private void makeConstructor(ConstructorInsn insn, CodeWriter code)
 			throws CodegenException {
 		ClassNode cls = mth.dex().resolveClass(insn.getClassType());
-		if (cls != null && cls.isAnonymous() && !fallback) {
-			// anonymous class construction
-			ClassInfo parent;
-			if (cls.getInterfaces().size() == 1) {
-				parent = cls.getInterfaces().get(0);
-			} else {
-				parent = cls.getSuperClass();
-			}
-			cls.add(AFlag.DONT_GENERATE);
-			MethodNode defCtr = cls.getDefaultConstructor();
-			if (defCtr != null) {
-				if (RegionUtils.notEmpty(defCtr.getRegion())) {
-					defCtr.add(AFlag.ANONYMOUS_CONSTRUCTOR);
-				} else {
-					defCtr.add(AFlag.DONT_GENERATE);
-				}
-			}
-			code.add("new ");
-			if (parent == null) {
-				code.add("Object");
-			} else {
-				useClass(code, parent);
-			}
-			code.add("() ");
-			new ClassGen(cls, mgen.getClassGen().getParentGen(), fallback).addClassBody(code);
+		if (cls != null && cls.contains(AFlag.ANONYMOUS_CLASS) && !fallback) {
+			inlineAnonymousConstr(code, cls, insn);
 			return;
 		}
 		if (insn.isSelf()) {
@@ -604,16 +572,54 @@ public class InsnGen {
 			code.add("new ");
 			useClass(code, insn.getClassType());
 		}
-		generateArguments(code, insn, 0, mth.dex().resolveMethod(insn.getCallMth()));
+		MethodNode callMth = mth.dex().resolveMethod(insn.getCallMth());
+		generateMethodArguments(code, insn, 0, callMth);
+	}
+
+	private void inlineAnonymousConstr(CodeWriter code, ClassNode cls, ConstructorInsn insn) throws CodegenException {
+		// anonymous class construction
+		if (cls.contains(AFlag.DONT_GENERATE)) {
+			code.add("/* anonymous class already generated */");
+			ErrorsCounter.methodWarn(mth, "Anonymous class already generated: " + cls);
+			return;
+		}
+		ArgType parent;
+		if (cls.getInterfaces().size() == 1) {
+			parent = cls.getInterfaces().get(0);
+		} else {
+			parent = cls.getSuperClass();
+		}
+		cls.add(AFlag.DONT_GENERATE);
+		MethodNode defCtr = cls.getDefaultConstructor();
+		if (defCtr != null) {
+			if (RegionUtils.notEmpty(defCtr.getRegion())) {
+				defCtr.add(AFlag.ANONYMOUS_CONSTRUCTOR);
+			} else {
+				defCtr.add(AFlag.DONT_GENERATE);
+			}
+		}
+		code.add("new ");
+		if (parent == null) {
+			code.add("Object");
+		} else {
+			useClass(code, parent);
+		}
+		MethodNode callMth = mth.dex().resolveMethod(insn.getCallMth());
+		generateMethodArguments(code, insn, 0, callMth);
+		code.add(' ');
+		new ClassGen(cls, mgen.getClassGen().getParentGen()).addClassBody(code);
 	}
 
 	private void makeInvoke(InvokeNode insn, CodeWriter code) throws CodegenException {
 		MethodInfo callMth = insn.getCallMth();
 
 		// inline method
-		MethodNode callMthNode = mth.dex().resolveMethod(callMth);
-		if (callMthNode != null && inlineMethod(callMthNode, insn, code)) {
-			return;
+		MethodNode callMthNode = mth.root().deepResolveMethod(callMth);
+		if (callMthNode != null) {
+			if (inlineMethod(callMthNode, insn, code)) {
+				return;
+			}
+			callMth = callMthNode.getMethodInfo();
 		}
 
 		int k = 0;
@@ -637,7 +643,7 @@ public class InsnGen {
 				break;
 
 			case STATIC:
-				ClassInfo insnCls = mth.getParentClass().getClassInfo();
+				ClassInfo insnCls = mth.getParentClass().getAlias();
 				ClassInfo declClass = callMth.getDeclClass();
 				if (!insnCls.equals(declClass)) {
 					useClass(code, declClass);
@@ -648,48 +654,92 @@ public class InsnGen {
 		if (callMthNode != null) {
 			code.attachAnnotation(callMthNode);
 		}
-		code.add(callMth.getName());
-		generateArguments(code, insn, k, callMthNode);
+		code.add(callMth.getAlias());
+		generateMethodArguments(code, insn, k, callMthNode);
 	}
 
-	private void generateArguments(CodeWriter code, InsnNode insn, int k, MethodNode callMth) throws CodegenException {
+	void generateMethodArguments(CodeWriter code, InsnNode insn, int startArgNum,
+			@Nullable MethodNode callMth) throws CodegenException {
+		int k = startArgNum;
 		if (callMth != null && callMth.contains(AFlag.SKIP_FIRST_ARG)) {
 			k++;
 		}
 		int argsCount = insn.getArgsCount();
-		if (callMth != null && callMth.isArgsOverload()) {
-			// add additional argument casts for overloaded methods
-			List<ArgType> originalType = callMth.getMethodInfo().getArgumentsTypes();
-			int origPos = 0;
-			code.add('(');
+		code.add('(');
+		boolean firstArg = true;
+		if (k < argsCount) {
+			boolean overloaded = callMth != null && callMth.isArgsOverload();
 			for (int i = k; i < argsCount; i++) {
 				InsnArg arg = insn.getArg(i);
-				ArgType origType = originalType.get(origPos);
-				if (!arg.getType().equals(origType)) {
-					code.add('(');
-					useType(code, origType);
-					code.add(')');
-					addArg(code, arg, true);
-				} else {
-					addArg(code, arg, false);
+				if (arg.contains(AFlag.SKIP_ARG)) {
+					continue;
 				}
-				if (i < argsCount - 1) {
+				RegisterArg callArg = getCallMthArg(callMth, i - startArgNum);
+				if (callArg != null && callArg.contains(AFlag.SKIP_ARG)) {
+					continue;
+				}
+				if (!firstArg) {
 					code.add(", ");
 				}
-				origPos++;
-			}
-			code.add(')');
-		} else {
-			code.add('(');
-			if (k < argsCount) {
-				addArg(code, insn.getArg(k), false);
-				for (int i = k + 1; i < argsCount; i++) {
-					code.add(", ");
-					addArg(code, insn.getArg(i), false);
+				boolean cast = overloaded && processOverloadedArg(code, callMth, arg, i - startArgNum);
+				if (!cast && i == argsCount - 1 && processVarArg(code, callMth, arg)) {
+					continue;
 				}
+				addArg(code, arg, false);
+				firstArg = false;
 			}
-			code.add(')');
 		}
+		code.add(')');
+	}
+
+	private static RegisterArg getCallMthArg(@Nullable MethodNode callMth, int num) {
+		if (callMth == null) {
+			return null;
+		}
+		List<RegisterArg> args = callMth.getArguments(false);
+		if (args != null && num < args.size()) {
+			return args.get(num);
+		}
+		return null;
+	}
+
+	/**
+	 * Add additional cast for overloaded method argument.
+	 */
+	private boolean processOverloadedArg(CodeWriter code, MethodNode callMth, InsnArg arg, int origPos) {
+		ArgType origType = callMth.getMethodInfo().getArgumentsTypes().get(origPos);
+		if (!arg.getType().equals(origType)) {
+			code.add('(');
+			useType(code, origType);
+			code.add(") ");
+			return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Expand varArgs from filled array.
+	 */
+	private boolean processVarArg(CodeWriter code, MethodNode callMth, InsnArg lastArg) throws CodegenException {
+		if (callMth == null || !callMth.getAccessFlags().isVarArgs()) {
+			return false;
+		}
+		if (!lastArg.getType().isArray() || !lastArg.isInsnWrap()) {
+			return false;
+		}
+		InsnNode insn = ((InsnWrapArg) lastArg).getWrapInsn();
+		if (insn.getType() == InsnType.FILLED_NEW_ARRAY) {
+			int count = insn.getArgsCount();
+			for (int i = 0; i < count; i++) {
+				InsnArg elemArg = insn.getArg(i);
+				addArg(code, elemArg, false);
+				if (i < count - 1) {
+					code.add(", ");
+				}
+			}
+			return true;
+		}
+		return false;
 	}
 
 	private boolean inlineMethod(MethodNode callMthNode, InvokeNode insn, CodeWriter code) throws CodegenException {
@@ -710,9 +760,9 @@ public class InsnGen {
 				regs[callArg.getRegNum()] = arg;
 			}
 			// replace args
-			List<RegisterArg> inlArgs = new ArrayList<RegisterArg>();
-			inl.getRegisterArgs(inlArgs);
-			Map<RegisterArg, InsnArg> toRevert = new HashMap<RegisterArg, InsnArg>();
+			InsnNode inlCopy = inl.copy();
+			List<RegisterArg> inlArgs = new ArrayList<>();
+			inlCopy.getRegisterArgs(inlArgs);
 			for (RegisterArg r : inlArgs) {
 				int regNum = r.getRegNum();
 				if (regNum >= regs.length) {
@@ -722,21 +772,16 @@ public class InsnGen {
 					if (repl == null) {
 						LOG.warn("Not passed register {} in method call: {} from {}", r, callMthNode, mth);
 					} else {
-						inl.replaceArg(r, repl);
-						toRevert.put(r, repl);
+						inlCopy.replaceArg(r, repl);
 					}
 				}
 			}
-			makeInsn(inl, code, Flags.BODY_ONLY);
-			// revert changes in 'MethodInlineAttr'
-			for (Map.Entry<RegisterArg, InsnArg> e : toRevert.entrySet()) {
-				inl.replaceArg(e.getValue(), e.getKey());
-			}
+			makeInsn(inlCopy, code, Flags.BODY_ONLY);
 		}
 		return true;
 	}
 
-	private void makeTernary(TernaryInsn insn, CodeWriter code, EnumSet<Flags> state) throws CodegenException {
+	private void makeTernary(TernaryInsn insn, CodeWriter code, Set<Flags> state) throws CodegenException {
 		boolean wrap = state.contains(Flags.BODY_ONLY);
 		if (wrap) {
 			code.add('(');
@@ -758,7 +803,11 @@ public class InsnGen {
 		}
 	}
 
-	private void makeArith(ArithNode insn, CodeWriter code, EnumSet<Flags> state) throws CodegenException {
+	private void makeArith(ArithNode insn, CodeWriter code, Set<Flags> state) throws CodegenException {
+		if (insn.contains(AFlag.ARITH_ONEARG)) {
+			makeArithOneArg(insn, code);
+			return;
+		}
 		// wrap insn in brackets for save correct operation order
 		boolean wrap = state.contains(Flags.BODY_ONLY) && !insn.contains(AFlag.DONT_WRAP);
 		if (wrap) {
@@ -776,7 +825,7 @@ public class InsnGen {
 
 	private void makeArithOneArg(ArithNode insn, CodeWriter code) throws CodegenException {
 		ArithOp op = insn.getOp();
-		InsnArg arg = insn.getArg(0);
+		InsnArg arg = insn.getArg(1);
 		// "++" or "--"
 		if (arg.isLiteral() && (op == ArithOp.ADD || op == ArithOp.SUB)) {
 			LiteralArg lit = (LiteralArg) arg;

jadx-core/src/main/java/jadx/core/codegen/MethodGen.java

@@ -1,12 +1,20 @@
 package jadx.core.codegen;
 
+import java.util.Iterator;
+import java.util.List;
+
+import com.android.dx.rop.code.AccessFlags;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.annotations.MethodParameters;
-import jadx.core.dex.attributes.nodes.JadxErrorAttr;
 import jadx.core.dex.info.AccessInfo;
+import jadx.core.dex.instructions.InsnType;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.instructions.args.RegisterArg;
+import jadx.core.dex.instructions.args.SSAVar;
 import jadx.core.dex.nodes.InsnNode;
 import jadx.core.dex.nodes.MethodNode;
 import jadx.core.dex.trycatch.CatchAttr;
@@ -14,18 +22,9 @@ import jadx.core.dex.visitors.DepthTraversal;
 import jadx.core.dex.visitors.FallbackModeVisitor;
 import jadx.core.utils.ErrorsCounter;
 import jadx.core.utils.InsnUtils;
-import jadx.core.utils.Utils;
 import jadx.core.utils.exceptions.CodegenException;
 import jadx.core.utils.exceptions.DecodeException;
 
-import java.util.Iterator;
-import java.util.List;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.android.dx.rop.code.AccessFlags;
-
 public class MethodGen {
 	private static final Logger LOG = LoggerFactory.getLogger(MethodGen.class);
 
@@ -38,7 +37,7 @@ public class MethodGen {
 		this.mth = mth;
 		this.classGen = classGen;
 		this.annotationGen = classGen.getAnnotationGen();
-		this.nameGen = new NameGen(classGen.isFallbackMode());
+		this.nameGen = new NameGen(mth, classGen.isFallbackMode());
 	}
 
 	public ClassGen getClassGen() {
@@ -55,8 +54,8 @@ public class MethodGen {
 
 	public boolean addDefinition(CodeWriter code) {
 		if (mth.getMethodInfo().isClassInit()) {
-			code.startLine("static");
 			code.attachDefinition(mth);
+			code.startLine("static");
 			return true;
 		}
 		if (mth.contains(AFlag.ANONYMOUS_CONSTRUCTOR)) {
@@ -78,18 +77,24 @@ public class MethodGen {
 		if (clsAccFlags.isAnnotation()) {
 			ai = ai.remove(AccessFlags.ACC_PUBLIC);
 		}
-		code.startLine(ai.makeString());
-		code.attachSourceLine(mth.getSourceLine());
+
+		if (mth.getMethodInfo().isRenamed()) {
+			code.startLine("/* renamed from: ").add(mth.getName()).add(" */");
+		}
+		code.startLineWithNum(mth.getSourceLine());
+		code.add(ai.makeString());
 
 		if (classGen.addGenericMap(code, mth.getGenericMap())) {
 			code.add(' ');
 		}
 		if (mth.getAccessFlags().isConstructor()) {
+			code.attachDefinition(mth);
 			code.add(classGen.getClassNode().getShortName()); // constructor
 		} else {
 			classGen.useType(code, mth.getReturnType());
 			code.add(' ');
-			code.add(mth.getName());
+			code.attachDefinition(mth);
+			code.add(mth.getAlias());
 		}
 		code.add('(');
 
@@ -101,7 +106,7 @@ public class MethodGen {
 			} else if (args.size() > 2) {
 				args = args.subList(2, args.size());
 			} else {
-				LOG.warn(ErrorsCounter.formatErrorMsg(mth,
+				LOG.warn(ErrorsCounter.formatMsg(mth,
 						"Incorrect number of args for enum constructor: " + args.size()
 								+ " (expected >= 2)"
 				));
@@ -111,7 +116,6 @@ public class MethodGen {
 		code.add(')');
 
 		annotationGen.addThrows(mth, code);
-		code.attachDefinition(mth);
 		return true;
 	}
 
@@ -125,6 +129,10 @@ public class MethodGen {
 			if (paramsAnnotation != null) {
 				annotationGen.addForParameter(argsCode, paramsAnnotation, i);
 			}
+			SSAVar argSVar = arg.getSVar();
+			if (argSVar != null && argSVar.contains(AFlag.FINAL)) {
+				argsCode.add("final ");
+			}
 			if (!it.hasNext() && mth.getAccessFlags().isVarArgs()) {
 				// change last array argument to varargs
 				ArgType type = arg.getType();
@@ -133,7 +141,7 @@ public class MethodGen {
 					classGen.useType(argsCode, elType);
 					argsCode.add("...");
 				} else {
-					LOG.warn(ErrorsCounter.formatErrorMsg(mth, "Last argument in varargs method not array"));
+					LOG.warn(ErrorsCounter.formatMsg(mth, "Last argument in varargs method not array"));
 					classGen.useType(argsCode, arg.getType());
 				}
 			} else {
@@ -153,24 +161,13 @@ public class MethodGen {
 		if (mth.contains(AType.JADX_ERROR)
 				|| mth.contains(AFlag.INCONSISTENT_CODE)
 				|| mth.getRegion() == null) {
-			code.startLine("throw new UnsupportedOperationException(\"Method not decompiled: ")
-					.add(mth.toString())
-					.add("\");");
-
-			if (mth.contains(AType.JADX_ERROR)) {
-				JadxErrorAttr err = mth.get(AType.JADX_ERROR);
-				code.startLine("/* JADX: method processing error */");
-				Throwable cause = err.getCause();
-				if (cause != null) {
-					code.newLine();
-					code.add("/*");
-					code.startLine("Error: ").add(Utils.getStackTrace(cause));
-					code.add("*/");
-				}
-			}
 			code.startLine("/*");
 			addFallbackMethodCode(code);
 			code.startLine("*/");
+
+			code.startLine("throw new UnsupportedOperationException(\"Method not decompiled: ")
+					.add(mth.toString())
+					.add("\");");
 		} else {
 			RegionGen regionGen = new RegionGen(this);
 			regionGen.makeRegion(code, mth.getRegion());
@@ -185,7 +182,7 @@ public class MethodGen {
 				DepthTraversal.visit(new FallbackModeVisitor(), mth);
 			} catch (DecodeException e) {
 				LOG.error("Error reload instructions in fallback mode:", e);
-				code.startLine("// Can't loadFile method instructions: " + e.getMessage());
+				code.startLine("// Can't load method instructions: " + e.getMessage());
 				return;
 			}
 		}
@@ -203,16 +200,13 @@ public class MethodGen {
 	public static void addFallbackInsns(CodeWriter code, MethodNode mth, InsnNode[] insnArr, boolean addLabels) {
 		InsnGen insnGen = new InsnGen(getFallbackMethodGen(mth), true);
 		for (InsnNode insn : insnArr) {
-			if (insn == null) {
+			if (insn == null || insn.getType() == InsnType.NOP) {
 				continue;
 			}
-			if (addLabels) {
-				if (insn.contains(AType.JUMP)
-						|| insn.contains(AType.EXC_HANDLER)) {
-					code.decIndent();
-					code.startLine(getLabelName(insn.getOffset()) + ":");
-					code.incIndent();
-				}
+			if (addLabels && (insn.contains(AType.JUMP) || insn.contains(AType.EXC_HANDLER))) {
+				code.decIndent();
+				code.startLine(getLabelName(insn.getOffset()) + ":");
+				code.incIndent();
 			}
 			try {
 				if (insnGen.makeInsn(insn, code)) {
@@ -231,13 +225,12 @@ public class MethodGen {
 	/**
 	 * Return fallback variant of method codegen
 	 */
-	static MethodGen getFallbackMethodGen(MethodNode mth) {
-		ClassGen clsGen = new ClassGen(mth.getParentClass(), null, true);
+	public static MethodGen getFallbackMethodGen(MethodNode mth) {
+		ClassGen clsGen = new ClassGen(mth.getParentClass(), null, true, true, true);
 		return new MethodGen(clsGen, mth);
 	}
 
 	public static String getLabelName(int offset) {
 		return "L_" + InsnUtils.formatOffset(offset);
 	}
-
 }

jadx-core/src/main/java/jadx/core/codegen/NameGen.java

@@ -1,8 +1,16 @@
 package jadx.core.codegen;
 
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
 import jadx.core.Consts;
 import jadx.core.deobf.NameMapper;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.attributes.nodes.LoopLabelAttr;
 import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.info.MethodInfo;
 import jadx.core.dex.instructions.InvokeNode;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.instructions.args.InsnArg;
@@ -12,22 +20,19 @@ import jadx.core.dex.instructions.args.RegisterArg;
 import jadx.core.dex.instructions.args.SSAVar;
 import jadx.core.dex.instructions.mods.ConstructorInsn;
 import jadx.core.dex.nodes.InsnNode;
-import jadx.core.utils.Utils;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.utils.StringUtils;
 
 public class NameGen {
 
 	private static final Map<String, String> OBJ_ALIAS;
 
-	private final Set<String> varNames = new HashSet<String>();
+	private final Set<String> varNames = new LinkedHashSet<>();
+	private final MethodNode mth;
 	private final boolean fallback;
 
 	static {
-		OBJ_ALIAS = new HashMap<String, String>();
+		OBJ_ALIAS = new HashMap<>();
 		OBJ_ALIAS.put(Consts.CLASS_STRING, "str");
 		OBJ_ALIAS.put(Consts.CLASS_CLASS, "cls");
 		OBJ_ALIAS.put(Consts.CLASS_THROWABLE, "th");
@@ -43,7 +48,8 @@ public class NameGen {
 		OBJ_ALIAS.put("java.lang.Double", "d");
 	}
 
-	public NameGen(boolean fallback) {
+	public NameGen(MethodNode mth, boolean fallback) {
+		this.mth = mth;
 		this.fallback = fallback;
 	}
 
@@ -53,10 +59,7 @@ public class NameGen {
 			return name;
 		}
 		name = getUniqueVarName(name);
-		SSAVar sVar = arg.getSVar();
-		if (sVar != null) {
-			sVar.setName(name);
-		}
+		arg.setName(name);
 		return name;
 	}
 
@@ -71,7 +74,16 @@ public class NameGen {
 	}
 
 	public String useArg(RegisterArg arg) {
-		String name = makeArgName(arg);
+		String name = arg.getName();
+		if (name == null || fallback) {
+			return getFallbackName(arg);
+		}
+		return name;
+	}
+
+	// TODO: avoid name collision with variables names
+	public String getLoopLabel(LoopLabelAttr attr) {
+		String name = "loop" + attr.getLoop().getId();
 		varNames.add(name);
 		return name;
 	}
@@ -88,57 +100,71 @@ public class NameGen {
 	}
 
 	private String makeArgName(RegisterArg arg) {
-		String name = arg.getName();
 		if (fallback) {
-			String base = "r" + arg.getRegNum();
-			if (name != null && !name.equals("this")) {
-				return base + "_" + name;
-			}
-			return base;
+			return getFallbackName(arg);
 		}
-		String varName;
-		if (name != null) {
-			if ("this".equals(name)) {
-				return name;
-			}
-			varName = name;
-		} else {
-			varName = makeNameForType(arg.getType());
+		if (arg.isThis()) {
+			return RegisterArg.THIS_ARG_NAME;
 		}
+		String name = arg.getName();
+		String varName = name != null ? name : guessName(arg);
 		if (NameMapper.isReserved(varName)) {
 			return varName + "R";
 		}
 		return varName;
 	}
 
-	private static String makeNameForType(ArgType type) {
+	private String getFallbackName(RegisterArg arg) {
+		return "r" + arg.getRegNum();
+	}
+
+	private String guessName(RegisterArg arg) {
+		SSAVar sVar = arg.getSVar();
+		if (sVar != null && sVar.getName() == null) {
+			RegisterArg assignArg = sVar.getAssign();
+			InsnNode assignInsn = assignArg.getParentInsn();
+			if (assignInsn != null) {
+				String name = makeNameFromInsn(assignInsn);
+				if (name != null && !NameMapper.isReserved(name)) {
+					assignArg.setName(name);
+					return name;
+				}
+			}
+		}
+		return makeNameForType(arg.getType());
+	}
+
+	private String makeNameForType(ArgType type) {
 		if (type.isPrimitive()) {
 			return makeNameForPrimitive(type);
-		} else if (type.isArray()) {
-			return makeNameForType(type.getArrayRootElement()) + "Arr";
-		} else {
-			return makeNameForObject(type);
 		}
+		if (type.isArray()) {
+			return makeNameForType(type.getArrayRootElement()) + "Arr";
+		}
+		return makeNameForObject(type);
 	}
 
 	private static String makeNameForPrimitive(ArgType type) {
 		return type.getPrimitiveType().getShortName().toLowerCase();
 	}
 
-	private static String makeNameForObject(ArgType type) {
+	private String makeNameForObject(ArgType type) {
 		if (type.isObject()) {
 			String alias = getAliasForObject(type.getObject());
 			if (alias != null) {
 				return alias;
 			}
-			ClassInfo clsInfo = ClassInfo.fromType(type);
-			String shortName = clsInfo.getShortName();
+			ClassInfo extClsInfo = ClassInfo.extCls(mth.root(), type);
+			String shortName = extClsInfo.getShortName();
 			String vName = fromName(shortName);
 			if (vName != null) {
 				return vName;
 			}
+			if (shortName != null) {
+				return StringUtils.escape(shortName.toLowerCase());
+			}
 		}
-		return Utils.escape(type.toString());
+		return StringUtils.escape(type.toString());
 	}
 
 	private static String fromName(String name) {
@@ -159,35 +185,15 @@ public class NameGen {
 		return null;
 	}
 
-	public static void guessName(RegisterArg arg) {
-		SSAVar sVar = arg.getSVar();
-		if (sVar == null || sVar.getName() != null) {
-			return;
-		}
-		RegisterArg assignArg = sVar.getAssign();
-		InsnNode assignInsn = assignArg.getParentInsn();
-		String name = makeNameFromInsn(assignInsn);
-		if (name != null && !NameMapper.isReserved(name)) {
-			assignArg.setName(name);
-		}
-	}
-
 	private static String getAliasForObject(String name) {
 		return OBJ_ALIAS.get(name);
 	}
 
-	private static String makeNameFromInsn(InsnNode insn) {
+	private String makeNameFromInsn(InsnNode insn) {
 		switch (insn.getType()) {
 			case INVOKE:
 				InvokeNode inv = (InvokeNode) insn;
-				String name = inv.getCallMth().getName();
-				if (name.startsWith("get") || name.startsWith("set")) {
-					return fromName(name.substring(3));
-				}
-				if ("iterator".equals(name)) {
-					return "it";
-				}
-				return name;
+				return makeNameFromInvoke(inv.getCallMth());
 
 			case CONSTRUCTOR:
 				ConstructorInsn co = (ConstructorInsn) insn;
@@ -215,4 +221,22 @@ public class NameGen {
 		}
 		return null;
 	}
+
+	private String makeNameFromInvoke(MethodInfo callMth) {
+		String name = callMth.getName();
+		if (name.startsWith("get") || name.startsWith("set")) {
+			return fromName(name.substring(3));
+		}
+		ArgType declType = callMth.getDeclClass().getAlias().getType();
+		if ("iterator".equals(name)) {
+			return "it";
+		}
+		if ("toString".equals(name)) {
+			return makeNameForType(declType);
+		}
+		if ("forName".equals(name) && declType.equals(ArgType.CLASS)) {
+			return OBJ_ALIAS.get(Consts.CLASS_CLASS);
+		}
+		return name;
+	}
 }

jadx-core/src/main/java/jadx/core/codegen/RegionGen.java

@@ -1,35 +1,42 @@
 package jadx.core.codegen;
 
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.nodes.DeclareVariablesAttr;
 import jadx.core.dex.attributes.nodes.ForceReturnAttr;
-import jadx.core.dex.info.FieldInfo;
-import jadx.core.dex.instructions.IndexInsnNode;
+import jadx.core.dex.attributes.nodes.LoopLabelAttr;
 import jadx.core.dex.instructions.SwitchNode;
 import jadx.core.dex.instructions.args.InsnArg;
+import jadx.core.dex.instructions.args.NamedArg;
 import jadx.core.dex.instructions.args.RegisterArg;
 import jadx.core.dex.nodes.BlockNode;
+import jadx.core.dex.nodes.FieldNode;
 import jadx.core.dex.nodes.IBlock;
 import jadx.core.dex.nodes.IContainer;
 import jadx.core.dex.nodes.IRegion;
 import jadx.core.dex.nodes.InsnNode;
-import jadx.core.dex.regions.IfCondition;
-import jadx.core.dex.regions.IfRegion;
-import jadx.core.dex.regions.LoopRegion;
+import jadx.core.dex.nodes.parser.FieldInitAttr;
 import jadx.core.dex.regions.Region;
 import jadx.core.dex.regions.SwitchRegion;
 import jadx.core.dex.regions.SynchronizedRegion;
-import jadx.core.dex.trycatch.CatchAttr;
+import jadx.core.dex.regions.TryCatchRegion;
+import jadx.core.dex.regions.conditions.IfCondition;
+import jadx.core.dex.regions.conditions.IfRegion;
+import jadx.core.dex.regions.loops.ForEachLoop;
+import jadx.core.dex.regions.loops.ForLoop;
+import jadx.core.dex.regions.loops.LoopRegion;
+import jadx.core.dex.regions.loops.LoopType;
 import jadx.core.dex.trycatch.ExceptionHandler;
-import jadx.core.dex.trycatch.TryCatchBlock;
+import jadx.core.utils.ErrorsCounter;
 import jadx.core.utils.RegionUtils;
 import jadx.core.utils.exceptions.CodegenException;
-
-import java.util.List;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import jadx.core.utils.exceptions.JadxRuntimeException;
 
 public class RegionGen extends InsnGen {
 	private static final Logger LOG = LoggerFactory.getLogger(RegionGen.class);
@@ -52,6 +59,8 @@ public class RegionGen extends InsnGen {
 					makeSwitch((SwitchRegion) cont, code);
 				} else if (cont instanceof LoopRegion) {
 					makeLoop((LoopRegion) cont, code);
+				} else if (cont instanceof TryCatchRegion) {
+					makeTryCatch((TryCatchRegion) cont, code);
 				} else if (cont instanceof SynchronizedRegion) {
 					makeSynchronizedRegion((SynchronizedRegion) cont, code);
 				}
@@ -73,14 +82,9 @@ public class RegionGen extends InsnGen {
 	}
 
 	private void makeSimpleRegion(CodeWriter code, Region region) throws CodegenException {
-		CatchAttr tc = region.get(AType.CATCH_BLOCK);
-		if (tc != null) {
-			makeTryCatch(region, tc.getTryBlock(), code);
-		} else {
-			declareVars(code, region);
-			for (IContainer c : region.getSubBlocks()) {
-				makeRegion(code, c);
-			}
+		declareVars(code, region);
+		for (IContainer c : region.getSubBlocks()) {
+			makeRegion(code, c);
 		}
 	}
 
@@ -92,7 +96,9 @@ public class RegionGen extends InsnGen {
 
 	private void makeSimpleBlock(IBlock block, CodeWriter code) throws CodegenException {
 		for (InsnNode insn : block.getInstructions()) {
-			makeInsn(insn, code);
+			if (!insn.contains(AFlag.SKIP)) {
+				makeInsn(insn, code);
+			}
 		}
 		ForceReturnAttr retAttr = block.get(AType.FORCE_RETURN);
 		if (retAttr != null) {
@@ -101,14 +107,11 @@ public class RegionGen extends InsnGen {
 	}
 
 	private void makeIf(IfRegion region, CodeWriter code, boolean newLine) throws CodegenException {
-		if (region.getTernRegion() != null) {
-			makeSimpleBlock(region.getTernRegion().getBlock(), code);
-			return;
-		}
 		if (newLine) {
-			code.startLine();
+			code.startLineWithNum(region.getSourceLine());
+		} else {
+			code.attachSourceLine(region.getSourceLine());
 		}
-		code.attachSourceLine(region.getSourceLine());
 		code.add("if (");
 		new ConditionGen(this).add(code, region.getCondition());
 		code.add(") {");
@@ -131,17 +134,16 @@ public class RegionGen extends InsnGen {
 	 * Connect if-else-if block
 	 */
 	private boolean connectElseIf(CodeWriter code, IContainer els) throws CodegenException {
-		if (!els.contains(AFlag.ELSE_IF_CHAIN)) {
-			return false;
-		}
-		if (!(els instanceof Region)) {
-			return false;
-		}
-		List<IContainer> subBlocks = ((Region) els).getSubBlocks();
-		if (subBlocks.size() == 1
-				&& subBlocks.get(0) instanceof IfRegion) {
-			makeIf((IfRegion) subBlocks.get(0), code, false);
-			return true;
+		if (els.contains(AFlag.ELSE_IF_CHAIN) && els instanceof Region) {
+			List<IContainer> subBlocks = ((Region) els).getSubBlocks();
+			if (subBlocks.size() == 1) {
+				IContainer elseBlock = subBlocks.get(0);
+				if (elseBlock instanceof IfRegion) {
+					declareVars(code, elseBlock);
+					makeIf((IfRegion) elseBlock, code, false);
+					return true;
+				}
+			}
 		}
 		return false;
 	}
@@ -151,8 +153,7 @@ public class RegionGen extends InsnGen {
 		if (header != null) {
 			List<InsnNode> headerInsns = header.getInstructions();
 			if (headerInsns.size() > 1) {
-				// write not inlined instructions from header
-				mth.add(AFlag.INCONSISTENT_CODE);
+				ErrorsCounter.methodWarn(mth, "Found not inlined instructions from loop header");
 				int last = headerInsns.size() - 1;
 				for (int i = 0; i < last; i++) {
 					InsnNode insn = headerInsns.get(i);
@@ -160,6 +161,10 @@ public class RegionGen extends InsnGen {
 				}
 			}
 		}
+		LoopLabelAttr labelAttr = region.getInfo().getStart().get(AType.LOOP_LABEL);
+		if (labelAttr != null) {
+			code.startLine(mgen.getNameGen().getLoopLabel(labelAttr)).add(':');
+		}
 
 		IfCondition condition = region.getCondition();
 		if (condition == null) {
@@ -169,16 +174,45 @@ public class RegionGen extends InsnGen {
 			code.startLine('}');
 			return code;
 		}
-
 		ConditionGen conditionGen = new ConditionGen(this);
+		LoopType type = region.getType();
+		if (type != null) {
+			if (type instanceof ForLoop) {
+				ForLoop forLoop = (ForLoop) type;
+				code.startLine("for (");
+				makeInsn(forLoop.getInitInsn(), code, Flags.INLINE);
+				code.add("; ");
+				conditionGen.add(code, condition);
+				code.add("; ");
+				makeInsn(forLoop.getIncrInsn(), code, Flags.INLINE);
+				code.add(") {");
+				makeRegionIndent(code, region.getBody());
+				code.startLine('}');
+				return code;
+			}
+			if (type instanceof ForEachLoop) {
+				ForEachLoop forEachLoop = (ForEachLoop) type;
+				code.startLine("for (");
+				declareVar(code, forEachLoop.getVarArg());
+				code.add(" : ");
+				addArg(code, forEachLoop.getIterableArg(), false);
+				code.add(") {");
+				makeRegionIndent(code, region.getBody());
+				code.startLine('}');
+				return code;
+			}
+			throw new JadxRuntimeException("Unknown loop type: " + type.getClass());
+		}
 		if (region.isConditionAtEnd()) {
 			code.startLine("do {");
 			makeRegionIndent(code, region.getBody());
-			code.startLine("} while (");
+			code.startLineWithNum(region.getConditionSourceLine());
+			code.add("} while (");
 			conditionGen.add(code, condition);
 			code.add(");");
 		} else {
-			code.startLine("while (");
+			code.startLineWithNum(region.getConditionSourceLine());
+			code.add("while (");
 			conditionGen.add(code, condition);
 			code.add(") {");
 			makeRegionIndent(code, region.getBody());
@@ -209,77 +243,82 @@ public class RegionGen extends InsnGen {
 			IContainer c = sw.getCases().get(i);
 			for (Object k : keys) {
 				code.startLine("case ");
-				if (k instanceof IndexInsnNode) {
-					staticField(code, (FieldInfo) ((IndexInsnNode) k).getIndex());
+				if (k instanceof FieldNode) {
+					FieldNode fn = (FieldNode) k;
+					if (fn.getParentClass().isEnum()) {
+						code.add(fn.getAlias());
+					} else {
+						staticField(code, fn.getFieldInfo());
+						// print original value, sometimes replace with incorrect field
+						FieldInitAttr valueAttr = fn.get(AType.FIELD_INIT);
+						if (valueAttr != null && valueAttr.getValue() != null) {
+							code.add(" /*").add(valueAttr.getValue().toString()).add("*/");
+						}
+					}
+				} else if (k instanceof Integer) {
+					code.add(TypeGen.literalToString((Integer) k, arg.getType(), mth));
 				} else {
-					code.add(TypeGen.literalToString((Integer) k, arg.getType()));
+					throw new JadxRuntimeException("Unexpected key in switch: " + (k != null ? k.getClass() : null));
 				}
 				code.add(':');
 			}
-			makeCaseBlock(c, code);
+			makeRegionIndent(code, c);
 		}
 		if (sw.getDefaultCase() != null) {
 			code.startLine("default:");
-			makeCaseBlock(sw.getDefaultCase(), code);
+			makeRegionIndent(code, sw.getDefaultCase());
 		}
 		code.decIndent();
 		code.startLine('}');
 		return code;
 	}
 
-	private void makeCaseBlock(IContainer c, CodeWriter code) throws CodegenException {
-		boolean addBreak = true;
-		if (RegionUtils.notEmpty(c)) {
-			makeRegionIndent(code, c);
-			if (!RegionUtils.hasExitEdge(c)) {
-				addBreak = false;
-			}
-		}
-		if (addBreak) {
-			code.startLine().addIndent().add("break;");
-		}
-	}
-
-	private void makeTryCatch(IContainer region, TryCatchBlock tryCatchBlock, CodeWriter code)
-			throws CodegenException {
+	private void makeTryCatch(TryCatchRegion region, CodeWriter code) throws CodegenException {
 		code.startLine("try {");
-		region.remove(AType.CATCH_BLOCK);
-		makeRegionIndent(code, region);
+		makeRegionIndent(code, region.getTryRegion());
+		// TODO: move search of 'allHandler' to 'TryCatchRegion'
 		ExceptionHandler allHandler = null;
-		for (ExceptionHandler handler : tryCatchBlock.getHandlers()) {
-			if (!handler.isCatchAll()) {
-				makeCatchBlock(code, handler);
-			} else {
+		for (Map.Entry<ExceptionHandler, IContainer> entry : region.getCatchRegions().entrySet()) {
+			ExceptionHandler handler = entry.getKey();
+			if (handler.isCatchAll()) {
 				if (allHandler != null) {
-					LOG.warn("Several 'all' handlers in try/catch block in " + mth);
+					LOG.warn("Several 'all' handlers in try/catch block in {}", mth);
 				}
 				allHandler = handler;
+			} else {
+				makeCatchBlock(code, handler);
 			}
 		}
 		if (allHandler != null) {
 			makeCatchBlock(code, allHandler);
 		}
-		if (tryCatchBlock.getFinalRegion() != null) {
+		IContainer finallyRegion = region.getFinallyRegion();
+		if (finallyRegion != null) {
 			code.startLine("} finally {");
-			makeRegionIndent(code, tryCatchBlock.getFinalRegion());
+			makeRegionIndent(code, finallyRegion);
 		}
 		code.startLine('}');
 	}
 
-	private void makeCatchBlock(CodeWriter code, ExceptionHandler handler)
-			throws CodegenException {
+	private void makeCatchBlock(CodeWriter code, ExceptionHandler handler) throws CodegenException {
 		IContainer region = handler.getHandlerRegion();
-		if (region != null) {
-			code.startLine("} catch (");
+		if (region == null) {
+			return;
+		}
+		code.startLine("} catch (");
+		InsnArg arg = handler.getArg();
+		if (arg instanceof RegisterArg) {
+			declareVar(code, (RegisterArg) arg);
+		} else if (arg instanceof NamedArg) {
 			if (handler.isCatchAll()) {
 				code.add("Throwable");
 			} else {
 				useClass(code, handler.getCatchType());
 			}
 			code.add(' ');
-			code.add(mgen.getNameGen().assignNamedArg(handler.getArg()));
-			code.add(") {");
-			makeRegionIndent(code, region);
+			code.add(mgen.getNameGen().assignNamedArg((NamedArg) arg));
 		}
+		code.add(") {");
+		makeRegionIndent(code, region);
 	}
 }

jadx-core/src/main/java/jadx/core/codegen/TypeGen.java

@@ -1,12 +1,22 @@
 package jadx.core.codegen;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.JadxArgs;
+import jadx.core.deobf.NameMapper;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.instructions.args.PrimitiveType;
+import jadx.core.dex.nodes.IDexNode;
 import jadx.core.utils.StringUtils;
 import jadx.core.utils.Utils;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
 public class TypeGen {
+	private static final Logger LOG = LoggerFactory.getLogger(TypeGen.class);
+
+	private TypeGen() {
+	}
 
 	public static String signature(ArgType type) {
 		PrimitiveType stype = type.getPrimitiveType();
@@ -24,7 +34,16 @@ public class TypeGen {
 	 *
 	 * @throws JadxRuntimeException for incorrect type or literal value
 	 */
+	public static String literalToString(long lit, ArgType type, IDexNode dexNode) {
+		return literalToString(lit, type, dexNode.root().getStringUtils());
+	}
+
+	@Deprecated
 	public static String literalToString(long lit, ArgType type) {
+		return literalToString(lit, type, new StringUtils(new JadxArgs()));
+	}
+
+	private static String literalToString(long lit, ArgType type, StringUtils stringUtils) {
 		if (type == null || !type.isTypeKnown()) {
 			String n = Long.toString(lit);
 			if (Math.abs(lit) > 100) {
@@ -39,7 +58,11 @@ public class TypeGen {
 			case BOOLEAN:
 				return lit == 0 ? "false" : "true";
 			case CHAR:
-				return StringUtils.unescapeChar((char) lit);
+				char ch = (char) lit;
+				if (!NameMapper.isPrintableChar(ch)) {
+					return Integer.toString(ch);
+				}
+				return stringUtils.unescapeChar(ch);
 			case BYTE:
 				return formatByte((byte) lit);
 			case SHORT:
@@ -56,7 +79,8 @@ public class TypeGen {
 			case OBJECT:
 			case ARRAY:
 				if (lit != 0) {
-					throw new JadxRuntimeException("Wrong object literal: " + type + " = " + lit);
+					LOG.warn("Wrong object literal: {} for type: {}", lit, type);
+					return Long.toString(lit);
 				}
 				return "null";
 
@@ -152,5 +176,4 @@ public class TypeGen {
 		}
 		return Float.toString(f) + "f";
 	}
-
 }

jadx-core/src/main/java/jadx/core/deobf/DeobfClsInfo.java

@@ -0,0 +1,50 @@
+package jadx.core.deobf;
+
+import jadx.core.dex.nodes.ClassNode;
+
+class DeobfClsInfo {
+	private final Deobfuscator deobfuscator;
+	private final ClassNode cls;
+	private final PackageNode pkg;
+	private final String alias;
+
+	public DeobfClsInfo(Deobfuscator deobfuscator, ClassNode cls, PackageNode pkg, String alias) {
+		this.deobfuscator = deobfuscator;
+		this.cls = cls;
+		this.pkg = pkg;
+		this.alias = alias;
+	}
+
+	public String makeNameWithoutPkg() {
+		String prefix;
+		ClassNode parentClass = cls.getParentClass();
+		if (parentClass != cls) {
+			DeobfClsInfo parentDeobfClsInfo = deobfuscator.getClsMap().get(parentClass.getClassInfo());
+			if (parentDeobfClsInfo != null) {
+				prefix = parentDeobfClsInfo.makeNameWithoutPkg();
+			} else {
+				prefix = deobfuscator.getNameWithoutPackage(parentClass.getClassInfo());
+			}
+			prefix += Deobfuscator.INNER_CLASS_SEPARATOR;
+		} else {
+			prefix = "";
+		}
+		return prefix + (this.alias != null ? this.alias : this.cls.getShortName());
+	}
+
+	public String getFullName() {
+		return pkg.getFullAlias() + Deobfuscator.CLASS_NAME_SEPARATOR + makeNameWithoutPkg();
+	}
+
+	public ClassNode getCls() {
+		return cls;
+	}
+
+	public PackageNode getPkg() {
+		return pkg;
+	}
+
+	public String getAlias() {
+		return alias;
+	}
+}

jadx-core/src/main/java/jadx/core/deobf/DeobfPresets.java

@@ -0,0 +1,167 @@
+package jadx.core.deobf;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.io.FileUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.info.FieldInfo;
+import jadx.core.dex.info.MethodInfo;
+
+class DeobfPresets {
+	private static final Logger LOG = LoggerFactory.getLogger(DeobfPresets.class);
+
+	private static final String MAP_FILE_CHARSET = "UTF-8";
+
+	private final Deobfuscator deobfuscator;
+	private final File deobfMapFile;
+
+	private final Map<String, String> clsPresetMap = new HashMap<>();
+	private final Map<String, String> fldPresetMap = new HashMap<>();
+	private final Map<String, String> mthPresetMap = new HashMap<>();
+
+	public DeobfPresets(Deobfuscator deobfuscator, File deobfMapFile) {
+		this.deobfuscator = deobfuscator;
+		this.deobfMapFile = deobfMapFile;
+	}
+
+	/**
+	 * Loads deobfuscator presets
+	 */
+	public void load() {
+		if (!deobfMapFile.exists()) {
+			return;
+		}
+		LOG.info("Loading obfuscation map from: {}", deobfMapFile.getAbsoluteFile());
+		try {
+			List<String> lines = FileUtils.readLines(deobfMapFile, MAP_FILE_CHARSET);
+			for (String l : lines) {
+				l = l.trim();
+				if (l.isEmpty() || l.startsWith("#")) {
+					continue;
+				}
+				String[] va = splitAndTrim(l);
+				if (va.length != 2) {
+					continue;
+				}
+				String origName = va[0];
+				String alias = va[1];
+				if (l.startsWith("p ")) {
+					deobfuscator.addPackagePreset(origName, alias);
+				} else if (l.startsWith("c ")) {
+					clsPresetMap.put(origName, alias);
+				} else if (l.startsWith("f ")) {
+					fldPresetMap.put(origName, alias);
+				} else if (l.startsWith("m ")) {
+					mthPresetMap.put(origName, alias);
+				}
+			}
+		} catch (IOException e) {
+			LOG.error("Failed to load deobfuscation map file '{}'", deobfMapFile.getAbsolutePath(), e);
+		}
+	}
+
+	private static String[] splitAndTrim(String str) {
+		String[] v = str.substring(2).split("=");
+		for (int i = 0; i < v.length; i++) {
+			v[i] = v[i].trim();
+		}
+		return v;
+	}
+
+	public void save(boolean forceSave) {
+		try {
+			if (deobfMapFile.exists()) {
+				if (forceSave) {
+					dumpMapping();
+				} else {
+					LOG.warn("Deobfuscation map file '{}' exists. Use command line option '--deobf-rewrite-cfg' to rewrite it",
+							deobfMapFile.getAbsolutePath());
+				}
+			} else {
+				dumpMapping();
+			}
+		} catch (IOException e) {
+			LOG.error("Failed to load deobfuscation map file '{}'", deobfMapFile.getAbsolutePath(), e);
+		}
+	}
+
+	/**
+	 * Saves DefaultDeobfuscator presets
+	 */
+	private void dumpMapping() throws IOException {
+		List<String> list = new ArrayList<>();
+		// packages
+		for (PackageNode p : deobfuscator.getRootPackage().getInnerPackages()) {
+			for (PackageNode pp : p.getInnerPackages()) {
+				dfsPackageName(list, p.getName(), pp);
+			}
+			if (p.hasAlias()) {
+				list.add(String.format("p %s = %s", p.getName(), p.getAlias()));
+			}
+		}
+		// classes
+		for (DeobfClsInfo deobfClsInfo : deobfuscator.getClsMap().values()) {
+			if (deobfClsInfo.getAlias() != null) {
+				list.add(String.format("c %s = %s",
+						deobfClsInfo.getCls().getClassInfo().getFullName(), deobfClsInfo.getAlias()));
+			}
+		}
+		for (FieldInfo fld : deobfuscator.getFldMap().keySet()) {
+			list.add(String.format("f %s = %s", fld.getFullId(), fld.getAlias()));
+		}
+		for (MethodInfo mth : deobfuscator.getMthMap().keySet()) {
+			list.add(String.format("m %s = %s", mth.getFullId(), mth.getAlias()));
+		}
+		Collections.sort(list);
+		FileUtils.writeLines(deobfMapFile, MAP_FILE_CHARSET, list);
+		list.clear();
+	}
+
+	private static void dfsPackageName(List<String> list, String prefix, PackageNode node) {
+		for (PackageNode pp : node.getInnerPackages()) {
+			dfsPackageName(list, prefix + '.' + node.getName(), pp);
+		}
+		if (node.hasAlias()) {
+			list.add(String.format("p %s.%s = %s", prefix, node.getName(), node.getAlias()));
+		}
+	}
+
+	public String getForCls(ClassInfo cls) {
+		return clsPresetMap.get(cls.getFullName());
+	}
+
+	public String getForFld(FieldInfo fld) {
+		return fldPresetMap.get(fld.getFullId());
+	}
+
+	public String getForMth(MethodInfo mth) {
+		return mthPresetMap.get(mth.getFullId());
+	}
+
+	public void clear() {
+		clsPresetMap.clear();
+		fldPresetMap.clear();
+		mthPresetMap.clear();
+	}
+
+	public Map<String, String> getClsPresetMap() {
+		return clsPresetMap;
+	}
+
+	public Map<String, String> getFldPresetMap() {
+		return fldPresetMap;
+	}
+
+	public Map<String, String> getMthPresetMap() {
+		return mthPresetMap;
+	}
+}

jadx-core/src/main/java/jadx/core/deobf/Deobfuscator.java

@@ -0,0 +1,556 @@
+package jadx.core.deobf;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.JadxArgs;
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.nodes.SourceFileAttr;
+import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.info.FieldInfo;
+import jadx.core.dex.info.MethodInfo;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.DexNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.MethodNode;
+
+public class Deobfuscator {
+	private static final Logger LOG = LoggerFactory.getLogger(Deobfuscator.class);
+
+	private static final boolean DEBUG = false;
+
+	public static final String CLASS_NAME_SEPARATOR = ".";
+	public static final String INNER_CLASS_SEPARATOR = "$";
+
+	private final JadxArgs args;
+	@NotNull
+	private final List<DexNode> dexNodes;
+	private final DeobfPresets deobfPresets;
+
+	private final Map<ClassInfo, DeobfClsInfo> clsMap = new HashMap<>();
+	private final Map<FieldInfo, String> fldMap = new HashMap<>();
+	private final Map<MethodInfo, String> mthMap = new HashMap<>();
+
+	private final Map<MethodInfo, OverridedMethodsNode> ovrdMap = new HashMap<>();
+	private final List<OverridedMethodsNode> ovrd = new ArrayList<>();
+
+	private final PackageNode rootPackage = new PackageNode("");
+	private final Set<String> pkgSet = new TreeSet<>();
+	private final Set<String> reservedClsNames = new HashSet<>();
+
+	private final int maxLength;
+	private final int minLength;
+	private final boolean useSourceNameAsAlias;
+
+	private int pkgIndex = 0;
+	private int clsIndex = 0;
+	private int fldIndex = 0;
+	private int mthIndex = 0;
+
+	public Deobfuscator(JadxArgs args, @NotNull List<DexNode> dexNodes, File deobfMapFile) {
+		this.args = args;
+		this.dexNodes = dexNodes;
+
+		this.minLength = args.getDeobfuscationMinLength();
+		this.maxLength = args.getDeobfuscationMaxLength();
+		this.useSourceNameAsAlias = args.isUseSourceNameAsClassAlias();
+
+		this.deobfPresets = new DeobfPresets(this, deobfMapFile);
+	}
+
+	public void execute() {
+		if (!args.isDeobfuscationForceSave()) {
+			deobfPresets.load();
+			initIndexes();
+		}
+		process();
+		deobfPresets.save(args.isDeobfuscationForceSave());
+		clear();
+	}
+
+	private void initIndexes() {
+		pkgIndex = pkgSet.size();
+		clsIndex = deobfPresets.getClsPresetMap().size();
+		fldIndex = deobfPresets.getFldPresetMap().size();
+		mthIndex = deobfPresets.getMthPresetMap().size();
+	}
+
+	private void preProcess() {
+		for (DexNode dexNode : dexNodes) {
+			for (ClassNode cls : dexNode.getClasses()) {
+				Collections.addAll(reservedClsNames, cls.getPackage().split("\\."));
+			}
+		}
+		for (DexNode dexNode : dexNodes) {
+			for (ClassNode cls : dexNode.getClasses()) {
+				preProcessClass(cls);
+			}
+		}
+	}
+
+	private void process() {
+		preProcess();
+		if (DEBUG) {
+			dumpAlias();
+		}
+		for (DexNode dexNode : dexNodes) {
+			for (ClassNode cls : dexNode.getClasses()) {
+				processClass(cls);
+			}
+		}
+		postProcess();
+	}
+
+	private void postProcess() {
+		int id = 1;
+		for (OverridedMethodsNode o : ovrd) {
+			boolean aliasFromPreset = false;
+			String aliasToUse = null;
+			for (MethodInfo mth : o.getMethods()) {
+				if (mth.isAliasFromPreset()) {
+					aliasToUse = mth.getAlias();
+					aliasFromPreset = true;
+				}
+			}
+			for (MethodInfo mth : o.getMethods()) {
+				if (aliasToUse == null) {
+					if (mth.isRenamed() && !mth.isAliasFromPreset()) {
+						mth.setAlias(String.format("mo%d%s", id, makeName(mth.getName())));
+					}
+					aliasToUse = mth.getAlias();
+				}
+				mth.setAlias(aliasToUse);
+				mth.setAliasFromPreset(aliasFromPreset);
+			}
+			id++;
+		}
+	}
+
+	void clear() {
+		deobfPresets.clear();
+		clsMap.clear();
+		fldMap.clear();
+		mthMap.clear();
+
+		ovrd.clear();
+		ovrdMap.clear();
+	}
+
+	private void resolveOverriding(MethodNode mth) {
+		Set<ClassNode> clsParents = new LinkedHashSet<>();
+		collectClassHierarchy(mth.getParentClass(), clsParents);
+
+		String mthSignature = mth.getMethodInfo().makeSignature(false);
+		Set<MethodInfo> overrideSet = new LinkedHashSet<>();
+		for (ClassNode classNode : clsParents) {
+			MethodInfo methodInfo = getMthOverride(classNode.getMethods(), mthSignature);
+			if (methodInfo != null) {
+				overrideSet.add(methodInfo);
+			}
+		}
+		if (overrideSet.isEmpty()) {
+			return;
+		}
+		OverridedMethodsNode overrideNode = getOverrideMethodsNode(overrideSet);
+		if (overrideNode == null) {
+			overrideNode = new OverridedMethodsNode(overrideSet);
+			ovrd.add(overrideNode);
+		}
+		for (MethodInfo overrideMth : overrideSet) {
+			if (!ovrdMap.containsKey(overrideMth)) {
+				ovrdMap.put(overrideMth, overrideNode);
+				overrideNode.add(overrideMth);
+			}
+		}
+	}
+
+	private OverridedMethodsNode getOverrideMethodsNode(Set<MethodInfo> overrideSet) {
+		for (MethodInfo overrideMth : overrideSet) {
+			OverridedMethodsNode node = ovrdMap.get(overrideMth);
+			if (node != null) {
+				return node;
+			}
+		}
+		return null;
+	}
+
+	private MethodInfo getMthOverride(List<MethodNode> methods, String mthSignature) {
+		for (MethodNode m : methods) {
+			MethodInfo mthInfo = m.getMethodInfo();
+			if (mthInfo.getShortId().startsWith(mthSignature)) {
+				return mthInfo;
+			}
+		}
+		return null;
+	}
+
+	private void collectClassHierarchy(ClassNode cls, Set<ClassNode> collected) {
+		boolean added = collected.add(cls);
+		if (added) {
+			ArgType superClass = cls.getSuperClass();
+			if (superClass != null) {
+				ClassNode superNode = cls.dex().resolveClass(superClass);
+				if (superNode != null) {
+					collectClassHierarchy(superNode, collected);
+				}
+			}
+
+			for (ArgType argType : cls.getInterfaces()) {
+				ClassNode interfaceNode = cls.dex().resolveClass(argType);
+				if (interfaceNode != null) {
+					collectClassHierarchy(interfaceNode, collected);
+				}
+			}
+		}
+	}
+
+	private void processClass(ClassNode cls) {
+		ClassInfo clsInfo = cls.getClassInfo();
+		String fullName = getClassFullName(clsInfo);
+		if (!fullName.equals(clsInfo.getFullName())) {
+			clsInfo.rename(cls.dex().root(), fullName);
+		}
+		for (FieldNode field : cls.getFields()) {
+			renameField(field);
+		}
+		for (MethodNode mth : cls.getMethods()) {
+			renameMethod(mth);
+		}
+		for (ClassNode innerCls : cls.getInnerClasses()) {
+			processClass(innerCls);
+		}
+	}
+
+	public void renameField(FieldNode field) {
+		FieldInfo fieldInfo = field.getFieldInfo();
+		String alias = getFieldAlias(field);
+		if (alias != null) {
+			fieldInfo.setAlias(alias);
+		}
+	}
+
+	public void renameMethod(MethodNode mth) {
+		String alias = getMethodAlias(mth);
+		if (alias != null) {
+			mth.getMethodInfo().setAlias(alias);
+		}
+		if (mth.isVirtual()) {
+			resolveOverriding(mth);
+		}
+	}
+
+	public void addPackagePreset(String origPkgName, String pkgAlias) {
+		PackageNode pkg = getPackageNode(origPkgName, true);
+		pkg.setAlias(pkgAlias);
+	}
+
+	/**
+	 * Gets package node for full package name
+	 *
+	 * @param fullPkgName full package name
+	 * @param create      if {@code true} then will create all absent objects
+	 * @return package node object or {@code null} if no package found and <b>create</b> set to {@code false}
+	 */
+	private PackageNode getPackageNode(String fullPkgName, boolean create) {
+		if (fullPkgName.isEmpty() || fullPkgName.equals(CLASS_NAME_SEPARATOR)) {
+			return rootPackage;
+		}
+		PackageNode result = rootPackage;
+		PackageNode parentNode;
+		do {
+			String pkgName;
+			int idx = fullPkgName.indexOf(CLASS_NAME_SEPARATOR);
+
+			if (idx > -1) {
+				pkgName = fullPkgName.substring(0, idx);
+				fullPkgName = fullPkgName.substring(idx + 1);
+			} else {
+				pkgName = fullPkgName;
+				fullPkgName = "";
+			}
+			parentNode = result;
+			result = result.getInnerPackageByName(pkgName);
+			if (result == null && create) {
+				result = new PackageNode(pkgName);
+				parentNode.addInnerPackage(result);
+			}
+		} while (!fullPkgName.isEmpty() && result != null);
+
+		return result;
+	}
+
+	String getNameWithoutPackage(ClassInfo clsInfo) {
+		String prefix;
+		ClassInfo parentClsInfo = clsInfo.getParentClass();
+		if (parentClsInfo != null) {
+			DeobfClsInfo parentDeobfClsInfo = clsMap.get(parentClsInfo);
+			if (parentDeobfClsInfo != null) {
+				prefix = parentDeobfClsInfo.makeNameWithoutPkg();
+			} else {
+				prefix = getNameWithoutPackage(parentClsInfo);
+			}
+			prefix += INNER_CLASS_SEPARATOR;
+		} else {
+			prefix = "";
+		}
+		return prefix + clsInfo.getShortName();
+	}
+
+	private void preProcessClass(ClassNode cls) {
+		ClassInfo classInfo = cls.getClassInfo();
+		String pkgFullName = classInfo.getPackage();
+		PackageNode pkg = getPackageNode(pkgFullName, true);
+		doPkg(pkg, pkgFullName);
+
+		String alias = deobfPresets.getForCls(classInfo);
+		if (alias != null) {
+			clsMap.put(classInfo, new DeobfClsInfo(this, cls, pkg, alias));
+		} else {
+			if (!clsMap.containsKey(classInfo)) {
+				String clsShortName = classInfo.getShortName();
+				if (shouldRename(clsShortName) || reservedClsNames.contains(clsShortName)) {
+					makeClsAlias(cls);
+				}
+			}
+		}
+		for (ClassNode innerCls : cls.getInnerClasses()) {
+			preProcessClass(innerCls);
+		}
+	}
+
+	public String getClsAlias(ClassNode cls) {
+		DeobfClsInfo deobfClsInfo = clsMap.get(cls.getClassInfo());
+		if (deobfClsInfo != null) {
+			return deobfClsInfo.getAlias();
+		}
+		return makeClsAlias(cls);
+	}
+
+	private String makeClsAlias(ClassNode cls) {
+		ClassInfo classInfo = cls.getClassInfo();
+		String alias = null;
+
+		if (this.useSourceNameAsAlias) {
+			alias = getAliasFromSourceFile(cls);
+		}
+
+		if (alias == null) {
+			String clsName = classInfo.getShortName();
+			alias = String.format("C%04d%s", clsIndex++, makeName(clsName));
+		}
+		PackageNode pkg = getPackageNode(classInfo.getPackage(), true);
+		clsMap.put(classInfo, new DeobfClsInfo(this, cls, pkg, alias));
+		return alias;
+	}
+
+	@Nullable
+	private String getAliasFromSourceFile(ClassNode cls) {
+		SourceFileAttr sourceFileAttr = cls.get(AType.SOURCE_FILE);
+		if (sourceFileAttr == null) {
+			return null;
+		}
+		if (cls.getClassInfo().isInner()) {
+			return null;
+		}
+		String name = sourceFileAttr.getFileName();
+		if (name.endsWith(".java")) {
+			name = name.substring(0, name.length() - ".java".length());
+		} else if (name.endsWith(".kt")) {
+			name = name.substring(0, name.length() - ".kt".length());
+		}
+		if (!NameMapper.isValidIdentifier(name) || NameMapper.isReserved(name)) {
+			return null;
+		}
+		for (DeobfClsInfo deobfClsInfo : clsMap.values()) {
+			if (deobfClsInfo.getAlias().equals(name)) {
+				return null;
+			}
+		}
+		ClassNode otherCls = cls.dex().root().searchClassByName(cls.getPackage() + "." + name);
+		if (otherCls != null) {
+			return null;
+		}
+		cls.remove(AType.SOURCE_FILE);
+		return name;
+	}
+
+	@Nullable
+	private String getFieldAlias(FieldNode field) {
+		FieldInfo fieldInfo = field.getFieldInfo();
+		String alias = fldMap.get(fieldInfo);
+		if (alias != null) {
+			return alias;
+		}
+		alias = deobfPresets.getForFld(fieldInfo);
+		if (alias != null) {
+			fldMap.put(fieldInfo, alias);
+			return alias;
+		}
+		if (shouldRename(field.getName())) {
+			return makeFieldAlias(field);
+		}
+		return null;
+	}
+
+	@Nullable
+	private String getMethodAlias(MethodNode mth) {
+		MethodInfo methodInfo = mth.getMethodInfo();
+		String alias = mthMap.get(methodInfo);
+		if (alias != null) {
+			return alias;
+		}
+		alias = deobfPresets.getForMth(methodInfo);
+		if (alias != null) {
+			mthMap.put(methodInfo, alias);
+			methodInfo.setAliasFromPreset(true);
+			return alias;
+		}
+		if (shouldRename(mth.getName())) {
+			return makeMethodAlias(mth);
+		}
+		return null;
+	}
+
+	public String makeFieldAlias(FieldNode field) {
+		String alias = String.format("f%d%s", fldIndex++, makeName(field.getName()));
+		fldMap.put(field.getFieldInfo(), alias);
+		return alias;
+	}
+
+	public String makeMethodAlias(MethodNode mth) {
+		String alias = String.format("m%d%s", mthIndex++, makeName(mth.getName()));
+		mthMap.put(mth.getMethodInfo(), alias);
+		return alias;
+	}
+
+	private void doPkg(PackageNode pkg, String fullName) {
+		if (pkgSet.contains(fullName)) {
+			return;
+		}
+		pkgSet.add(fullName);
+
+		// doPkg for all parent packages except root that not hasAliases
+		PackageNode parentPkg = pkg.getParentPackage();
+		while (!parentPkg.getName().isEmpty()) {
+			if (!parentPkg.hasAlias()) {
+				doPkg(parentPkg, parentPkg.getFullName());
+			}
+			parentPkg = parentPkg.getParentPackage();
+		}
+
+		String pkgName = pkg.getName();
+		if (!pkg.hasAlias() && shouldRename(pkgName)) {
+			String pkgAlias = String.format("p%03d%s", pkgIndex++, makeName(pkgName));
+			pkg.setAlias(pkgAlias);
+		}
+	}
+
+	private boolean shouldRename(String s) {
+		return s.length() > maxLength
+				|| s.length() < minLength
+				|| NameMapper.isReserved(s)
+				|| !NameMapper.isAllCharsPrintable(s);
+	}
+
+	private String makeName(String name) {
+		if (name.length() > maxLength) {
+			return "x" + Integer.toHexString(name.hashCode());
+		}
+		if (NameMapper.isReserved(name)) {
+			return name;
+		}
+		if (!NameMapper.isAllCharsPrintable(name)) {
+			return removeInvalidChars(name);
+		}
+		return name;
+	}
+
+	private String removeInvalidChars(String name) {
+		StringBuilder sb = new StringBuilder();
+		for (int i = 0; i < name.length(); i++) {
+			int ch = name.charAt(i);
+			if (NameMapper.isPrintableChar(ch)) {
+				sb.append((char) ch);
+			}
+		}
+		return sb.toString();
+	}
+
+	private void dumpClassAlias(ClassNode cls) {
+		PackageNode pkg = getPackageNode(cls.getPackage(), false);
+
+		if (pkg != null) {
+			if (!cls.getFullName().equals(getClassFullName(cls))) {
+				LOG.info("Alias name for class '{}' is '{}'", cls.getFullName(), getClassFullName(cls));
+			}
+		} else {
+			LOG.error("Can't find package node for '{}'", cls.getPackage());
+		}
+	}
+
+	private void dumpAlias() {
+		for (DexNode dexNode : dexNodes) {
+			for (ClassNode cls : dexNode.getClasses()) {
+				dumpClassAlias(cls);
+			}
+		}
+	}
+
+	private String getPackageName(String packageName) {
+		PackageNode pkg = getPackageNode(packageName, false);
+		if (pkg != null) {
+			return pkg.getFullAlias();
+		}
+		return packageName;
+	}
+
+	private String getClassName(ClassInfo clsInfo) {
+		DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
+		if (deobfClsInfo != null) {
+			return deobfClsInfo.makeNameWithoutPkg();
+		}
+		return getNameWithoutPackage(clsInfo);
+	}
+
+	private String getClassFullName(ClassNode cls) {
+		return getClassFullName(cls.getClassInfo());
+	}
+
+	private String getClassFullName(ClassInfo clsInfo) {
+		DeobfClsInfo deobfClsInfo = clsMap.get(clsInfo);
+		if (deobfClsInfo != null) {
+			return deobfClsInfo.getFullName();
+		}
+		return getPackageName(clsInfo.getPackage()) + CLASS_NAME_SEPARATOR + getClassName(clsInfo);
+	}
+
+	public Map<ClassInfo, DeobfClsInfo> getClsMap() {
+		return clsMap;
+	}
+
+	public Map<FieldInfo, String> getFldMap() {
+		return fldMap;
+	}
+
+	public Map<MethodInfo, String> getMthMap() {
+		return mthMap;
+	}
+
+	public PackageNode getRootPackage() {
+		return rootPackage;
+	}
+}

jadx-core/src/main/java/jadx/core/deobf/NameMapper.java

@@ -3,11 +3,20 @@ package jadx.core.deobf;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.regex.Pattern;
+
+import static jadx.core.utils.StringUtils.notEmpty;
 
 public class NameMapper {
 
-	private static final Set<String> RESERVED_NAMES = new HashSet<String>(
-			Arrays.asList(new String[]{
+	private static final Pattern VALID_JAVA_IDENTIFIER = Pattern.compile(
+			"\\p{javaJavaIdentifierStart}\\p{javaJavaIdentifierPart}*");
+
+	private static final Pattern VALID_JAVA_FULL_IDENTIFIER = Pattern.compile(
+			"(" + VALID_JAVA_IDENTIFIER + "\\.)*" + VALID_JAVA_IDENTIFIER);
+
+	private static final Set<String> RESERVED_NAMES = new HashSet<>(
+			Arrays.asList(
 					"abstract",
 					"assert",
 					"boolean",
@@ -60,12 +69,40 @@ public class NameMapper {
 					"try",
 					"void",
 					"volatile",
-					"while",
-			})
+					"while"
+			)
 	);
 
 	public static boolean isReserved(String str) {
 		return RESERVED_NAMES.contains(str);
 	}
 
+	public static boolean isValidIdentifier(String str) {
+		return notEmpty(str)
+				&& VALID_JAVA_IDENTIFIER.matcher(str).matches()
+				&& isAllCharsPrintable(str);
+	}
+
+	public static boolean isValidFullIdentifier(String str) {
+		return notEmpty(str)
+				&& VALID_JAVA_FULL_IDENTIFIER.matcher(str).matches()
+				&& isAllCharsPrintable(str);
+	}
+
+	public static boolean isPrintableChar(int c) {
+		return 32 <= c && c <= 126;
+	}
+
+	public static boolean isAllCharsPrintable(String str) {
+		int len = str.length();
+		for (int i = 0; i < len; i++) {
+			if (!isPrintableChar(str.charAt(i))) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private NameMapper() {
+	}
 }

jadx-core/src/main/java/jadx/core/deobf/OverridedMethodsNode.java

@@ -0,0 +1,26 @@
+package jadx.core.deobf;
+
+import java.util.Set;
+
+import jadx.core.dex.info.MethodInfo;
+
+class OverridedMethodsNode {
+
+	private Set<MethodInfo> methods;
+
+	public OverridedMethodsNode(Set<MethodInfo> methodsSet) {
+		methods = methodsSet;
+	}
+
+	public boolean contains(MethodInfo mth) {
+		return methods.contains(mth);
+	}
+
+	public void add(MethodInfo mth) {
+		methods.add(mth);
+	}
+
+	public Set<MethodInfo> getMethods() {
+		return methods;
+	}
+}

jadx-core/src/main/java/jadx/core/deobf/PackageNode.java

@@ -0,0 +1,130 @@
+package jadx.core.deobf;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.List;
+
+public class PackageNode {
+
+	private static final char SEPARATOR_CHAR = '.';
+
+	private PackageNode parentPackage;
+	private List<PackageNode> innerPackages = Collections.emptyList();
+
+	private final String packageName;
+	private String packageAlias;
+
+	private String cachedPackageFullName;
+	private String cachedPackageFullAlias;
+
+	public PackageNode(String packageName) {
+		this.packageName = packageName;
+		this.parentPackage = this;
+	}
+
+	public String getName() {
+		return packageName;
+	}
+
+	public String getFullName() {
+		if (cachedPackageFullName == null) {
+			Deque<PackageNode> pp = getParentPackages();
+
+			StringBuilder result = new StringBuilder();
+			result.append(pp.pop().getName());
+			while (!pp.isEmpty()) {
+				result.append(SEPARATOR_CHAR);
+				result.append(pp.pop().getName());
+			}
+			cachedPackageFullName = result.toString();
+		}
+		return cachedPackageFullName;
+	}
+
+	public String getAlias() {
+		if (packageAlias != null) {
+			return packageAlias;
+		}
+		return packageName;
+	}
+
+	public void setAlias(String alias) {
+		packageAlias = alias;
+	}
+
+	public boolean hasAlias() {
+		return packageAlias != null;
+	}
+
+	public String getFullAlias() {
+		if (cachedPackageFullAlias == null) {
+			Deque<PackageNode> pp = getParentPackages();
+			StringBuilder result = new StringBuilder();
+
+			if (!pp.isEmpty()) {
+				result.append(pp.pop().getAlias());
+				while (!pp.isEmpty()) {
+					result.append(SEPARATOR_CHAR);
+					result.append(pp.pop().getAlias());
+				}
+			} else {
+				result.append(this.getAlias());
+			}
+			cachedPackageFullAlias = result.toString();
+		}
+		return cachedPackageFullAlias;
+	}
+
+	public PackageNode getParentPackage() {
+		return parentPackage;
+	}
+
+	public List<PackageNode> getInnerPackages() {
+		return innerPackages;
+	}
+
+	public void addInnerPackage(PackageNode pkg) {
+		if (innerPackages.isEmpty()) {
+			innerPackages = new ArrayList<>();
+		}
+		innerPackages.add(pkg);
+		pkg.parentPackage = this;
+	}
+
+	/**
+	 * Gets inner package node by name
+	 *
+	 * @param name inner package name
+	 * @return package node or {@code null}
+	 */
+	public PackageNode getInnerPackageByName(String name) {
+		PackageNode result = null;
+		for (PackageNode p : innerPackages) {
+			if (p.getName().equals(name)) {
+				result = p;
+				break;
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Fills stack with parent packages exclude root node
+	 *
+	 * @return stack with parent packages
+	 */
+	private Deque<PackageNode> getParentPackages() {
+		Deque<PackageNode> pp = new ArrayDeque<>();
+
+		PackageNode currentPkg = this;
+		PackageNode parentPkg = currentPkg.getParentPackage();
+		while (currentPkg != parentPkg) {
+			pp.push(currentPkg);
+			currentPkg = parentPkg;
+			parentPkg = currentPkg.getParentPackage();
+		}
+		return pp;
+	}
+}

jadx-core/src/main/java/jadx/core/dex/attributes/AFlag.java

@@ -8,20 +8,32 @@ public enum AFlag {
 	LOOP_END,
 
 	SYNTHETIC,
+	FINAL, // SSAVar attribute for make var final
 
 	RETURN, // block contains only return instruction
+	ORIG_RETURN,
 
 	DECLARE_VAR,
 	DONT_WRAP,
 
 	DONT_SHRINK,
+	DONT_INLINE,
 	DONT_GENERATE,
 	SKIP,
+	REMOVE,
 
 	SKIP_FIRST_ARG,
+	SKIP_ARG, // skip argument in invoke call
 	ANONYMOUS_CONSTRUCTOR,
+	ANONYMOUS_CLASS,
+	THIS,
 
 	ELSE_IF_CHAIN,
 
+	WRAPPED,
+	ARITH_ONEARG,
+
+	FALL_THROUGH,
+
 	INCONSISTENT_CODE, // warning about incorrect decompilation
 }

jadx-core/src/main/java/jadx/core/dex/attributes/AType.java

@@ -3,46 +3,54 @@ package jadx.core.dex.attributes;
 import jadx.core.dex.attributes.annotations.AnnotationsList;
 import jadx.core.dex.attributes.annotations.MethodParameters;
 import jadx.core.dex.attributes.nodes.DeclareVariablesAttr;
+import jadx.core.dex.attributes.nodes.EdgeInsnAttr;
 import jadx.core.dex.attributes.nodes.EnumClassAttr;
+import jadx.core.dex.attributes.nodes.EnumMapAttr;
 import jadx.core.dex.attributes.nodes.FieldReplaceAttr;
 import jadx.core.dex.attributes.nodes.ForceReturnAttr;
-import jadx.core.dex.attributes.nodes.JadxErrorAttr;
+import jadx.core.dex.attributes.nodes.IgnoreEdgeAttr;
+import jadx.core.dex.attributes.nodes.JadxError;
+import jadx.core.dex.attributes.nodes.JadxWarn;
 import jadx.core.dex.attributes.nodes.JumpInfo;
 import jadx.core.dex.attributes.nodes.LoopInfo;
+import jadx.core.dex.attributes.nodes.LoopLabelAttr;
 import jadx.core.dex.attributes.nodes.MethodInlineAttr;
 import jadx.core.dex.attributes.nodes.PhiListAttr;
 import jadx.core.dex.attributes.nodes.SourceFileAttr;
-import jadx.core.dex.nodes.parser.FieldValueAttr;
+import jadx.core.dex.nodes.parser.FieldInitAttr;
 import jadx.core.dex.trycatch.CatchAttr;
 import jadx.core.dex.trycatch.ExcHandlerAttr;
 import jadx.core.dex.trycatch.SplitterBlockAttr;
 
 /**
  * Attribute types enumeration,
- * uses generic type for omit cast after in 'AttributeStorage.get' method
+ * uses generic type for omit cast after 'AttributeStorage.get' method
  *
  * @param <T> attribute class implementation
  */
 public class AType<T extends IAttribute> {
 
-	private AType() {
-	}
+	public static final AType<AttrList<JumpInfo>> JUMP = new AType<>();
+	public static final AType<AttrList<LoopInfo>> LOOP = new AType<>();
+	public static final AType<AttrList<EdgeInsnAttr>> EDGE_INSN = new AType<>();
 
-	public static final AType<AttrList<JumpInfo>> JUMP = new AType<AttrList<JumpInfo>>();
-	public static final AType<AttrList<LoopInfo>> LOOP = new AType<AttrList<LoopInfo>>();
+	public static final AType<AttrList<JadxError>> JADX_ERROR = new AType<>();
+	public static final AType<AttrList<JadxWarn>> JADX_WARN = new AType<>();
 
-	public static final AType<ExcHandlerAttr> EXC_HANDLER = new AType<ExcHandlerAttr>();
-	public static final AType<CatchAttr> CATCH_BLOCK = new AType<CatchAttr>();
-	public static final AType<SplitterBlockAttr> SPLITTER_BLOCK = new AType<SplitterBlockAttr>();
-	public static final AType<ForceReturnAttr> FORCE_RETURN = new AType<ForceReturnAttr>();
-	public static final AType<FieldValueAttr> FIELD_VALUE = new AType<FieldValueAttr>();
-	public static final AType<FieldReplaceAttr> FIELD_REPLACE = new AType<FieldReplaceAttr>();
-	public static final AType<JadxErrorAttr> JADX_ERROR = new AType<JadxErrorAttr>();
-	public static final AType<MethodInlineAttr> METHOD_INLINE = new AType<MethodInlineAttr>();
-	public static final AType<EnumClassAttr> ENUM_CLASS = new AType<EnumClassAttr>();
-	public static final AType<AnnotationsList> ANNOTATION_LIST = new AType<AnnotationsList>();
-	public static final AType<MethodParameters> ANNOTATION_MTH_PARAMETERS = new AType<MethodParameters>();
-	public static final AType<PhiListAttr> PHI_LIST = new AType<PhiListAttr>();
-	public static final AType<SourceFileAttr> SOURCE_FILE = new AType<SourceFileAttr>();
-	public static final AType<DeclareVariablesAttr> DECLARE_VARIABLES = new AType<DeclareVariablesAttr>();
+	public static final AType<ExcHandlerAttr> EXC_HANDLER = new AType<>();
+	public static final AType<CatchAttr> CATCH_BLOCK = new AType<>();
+	public static final AType<SplitterBlockAttr> SPLITTER_BLOCK = new AType<>();
+	public static final AType<ForceReturnAttr> FORCE_RETURN = new AType<>();
+	public static final AType<FieldInitAttr> FIELD_INIT = new AType<>();
+	public static final AType<FieldReplaceAttr> FIELD_REPLACE = new AType<>();
+	public static final AType<MethodInlineAttr> METHOD_INLINE = new AType<>();
+	public static final AType<EnumClassAttr> ENUM_CLASS = new AType<>();
+	public static final AType<EnumMapAttr> ENUM_MAP = new AType<>();
+	public static final AType<AnnotationsList> ANNOTATION_LIST = new AType<>();
+	public static final AType<MethodParameters> ANNOTATION_MTH_PARAMETERS = new AType<>();
+	public static final AType<PhiListAttr> PHI_LIST = new AType<>();
+	public static final AType<SourceFileAttr> SOURCE_FILE = new AType<>();
+	public static final AType<DeclareVariablesAttr> DECLARE_VARIABLES = new AType<>();
+	public static final AType<LoopLabelAttr> LOOP_LABEL = new AType<>();
+	public static final AType<IgnoreEdgeAttr> IGNORE_EDGE = new AType<>();
 }

jadx-core/src/main/java/jadx/core/dex/attributes/AttrList.java

@@ -1,14 +1,14 @@
 package jadx.core.dex.attributes;
 
-import jadx.core.utils.Utils;
-
-import java.util.LinkedList;
+import java.util.ArrayList;
 import java.util.List;
 
+import jadx.core.utils.Utils;
+
 public class AttrList<T> implements IAttribute {
 
 	private final AType<AttrList<T>> type;
-	private final List<T> list = new LinkedList<T>();
+	private final List<T> list = new ArrayList<>();
 
 	public AttrList(AType<AttrList<T>> type) {
 		this.type = type;

jadx-core/src/main/java/jadx/core/dex/attributes/AttrNode.java

@@ -1,9 +1,9 @@
 package jadx.core.dex.attributes;
 
-import jadx.core.dex.attributes.annotations.Annotation;
-
 import java.util.List;
 
+import jadx.core.dex.attributes.annotations.Annotation;
+
 public abstract class AttrNode implements IAttributeNode {
 
 	private static final AttributeStorage EMPTY_ATTR_STORAGE = new EmptyAttrStorage();
@@ -12,25 +12,28 @@ public abstract class AttrNode implements IAttributeNode {
 
 	@Override
 	public void add(AFlag flag) {
-		getStorage().add(flag);
+		initStorage().add(flag);
 	}
 
 	@Override
 	public void addAttr(IAttribute attr) {
-		getStorage().add(attr);
+		initStorage().add(attr);
 	}
 
 	@Override
 	public <T> void addAttr(AType<AttrList<T>> type, T obj) {
-		getStorage().add(type, obj);
+		initStorage().add(type, obj);
 	}
 
 	@Override
 	public void copyAttributesFrom(AttrNode attrNode) {
-		getStorage().addAll(attrNode.storage);
+		AttributeStorage copyFrom = attrNode.storage;
+		if (!copyFrom.isEmpty()) {
+			initStorage().addAll(copyFrom);
+		}
 	}
 
-	AttributeStorage getStorage() {
+	private AttributeStorage initStorage() {
 		AttributeStorage store = storage;
 		if (store == EMPTY_ATTR_STORAGE) {
 			store = new AttributeStorage();
@@ -93,4 +96,8 @@ public abstract class AttrNode implements IAttributeNode {
 	public String getAttributesString() {
 		return storage.toString();
 	}
+
+	public boolean isAttrStorageEmpty() {
+		return storage.isEmpty();
+	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/AttributeStorage.java

@@ -1,17 +1,17 @@
 package jadx.core.dex.attributes;
 
-import jadx.core.dex.attributes.annotations.Annotation;
-import jadx.core.dex.attributes.annotations.AnnotationsList;
-import jadx.core.utils.Utils;
-
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.EnumSet;
-import java.util.HashMap;
+import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import jadx.core.dex.attributes.annotations.Annotation;
+import jadx.core.dex.attributes.annotations.AnnotationsList;
+import jadx.core.utils.Utils;
+
 /**
  * Storage for different attribute types:
  * 1. flags - boolean attribute (set or not)
@@ -24,7 +24,7 @@ public class AttributeStorage {
 
 	public AttributeStorage() {
 		flags = EnumSet.noneOf(AFlag.class);
-		attributes = new HashMap<AType<?>, IAttribute>(2);
+		attributes = new IdentityHashMap<>();
 	}
 
 	public void add(AFlag flag) {
@@ -38,7 +38,7 @@ public class AttributeStorage {
 	public <T> void add(AType<AttrList<T>> type, T obj) {
 		AttrList<T> list = get(type);
 		if (list == null) {
-			list = new AttrList<T>(type);
+			list = new AttrList<>(type);
 			add(list);
 		}
 		list.getList().add(obj);
@@ -72,7 +72,7 @@ public class AttributeStorage {
 		if (attrList == null) {
 			return Collections.emptyList();
 		}
-		return attrList.getList();
+		return Collections.unmodifiableList(attrList.getList());
 	}
 
 	public void remove(AFlag flag) {
@@ -84,7 +84,7 @@ public class AttributeStorage {
 	}
 
 	public void remove(IAttribute attr) {
-		AType<?> type = attr.getType();
+		AType<? extends IAttribute> type = attr.getType();
 		IAttribute a = attributes.get(type);
 		if (a == attr) {
 			attributes.remove(type);
@@ -101,7 +101,7 @@ public class AttributeStorage {
 		if (size == 0) {
 			return Collections.emptyList();
 		}
-		List<String> list = new ArrayList<String>(size);
+		List<String> list = new ArrayList<>(size);
 		for (AFlag a : flags) {
 			list.add(a.toString());
 		}
@@ -111,6 +111,10 @@ public class AttributeStorage {
 		return list;
 	}
 
+	public boolean isEmpty() {
+		return flags.isEmpty() && attributes.isEmpty();
+	}
+
 	@Override
 	public String toString() {
 		List<String> list = getAttributeStrings();

jadx-core/src/main/java/jadx/core/dex/attributes/EmptyAttrStorage.java

@@ -1,11 +1,11 @@
 package jadx.core.dex.attributes;
 
-import jadx.core.dex.attributes.annotations.Annotation;
-
 import java.util.Collections;
 import java.util.List;
 
-public class EmptyAttrStorage extends AttributeStorage {
+import jadx.core.dex.attributes.annotations.Annotation;
+
+public final class EmptyAttrStorage extends AttributeStorage {
 
 	@Override
 	public boolean contains(AFlag flag) {
@@ -52,4 +52,14 @@ public class EmptyAttrStorage extends AttributeStorage {
 	public List<String> getAttributeStrings() {
 		return Collections.emptyList();
 	}
+
+	@Override
+	public boolean isEmpty() {
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return "";
+	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/IAttribute.java

@@ -1,7 +1,5 @@
 package jadx.core.dex.attributes;
 
 public interface IAttribute {
-
-	AType<?> getType();
-
+	AType<? extends IAttribute> getType();
 }

jadx-core/src/main/java/jadx/core/dex/attributes/IAttributeNode.java

@@ -1,9 +1,9 @@
 package jadx.core.dex.attributes;
 
-import jadx.core.dex.attributes.annotations.Annotation;
-
 import java.util.List;
 
+import jadx.core.dex.attributes.annotations.Annotation;
+
 public interface IAttributeNode {
 
 	void add(AFlag flag);

jadx-core/src/main/java/jadx/core/dex/attributes/annotations/Annotation.java

@@ -1,9 +1,9 @@
 package jadx.core.dex.attributes.annotations;
 
-import jadx.core.dex.instructions.args.ArgType;
-
 import java.util.Map;
 
+import jadx.core.dex.instructions.args.ArgType;
+
 public class Annotation {
 
 	public enum Visibility {

jadx-core/src/main/java/jadx/core/dex/attributes/annotations/AnnotationsList.java

@@ -1,20 +1,23 @@
 package jadx.core.dex.attributes.annotations;
 
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttribute;
 import jadx.core.utils.Utils;
 
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
 public class AnnotationsList implements IAttribute {
 
+	public static final AnnotationsList EMPTY = new AnnotationsList(Collections.<Annotation>emptyList());
+
 	private final Map<String, Annotation> map;
 
 	public AnnotationsList(List<Annotation> anList) {
-		map = new HashMap<String, Annotation>(anList.size());
+		map = new HashMap<>(anList.size());
 		for (Annotation a : anList) {
 			map.put(a.getAnnotationClass(), a);
 		}
@@ -32,6 +35,10 @@ public class AnnotationsList implements IAttribute {
 		return map.size();
 	}
 
+	public boolean isEmpty() {
+		return map.isEmpty();
+	}
+
 	@Override
 	public AType<AnnotationsList> getType() {
 		return AType.ANNOTATION_LIST;

jadx-core/src/main/java/jadx/core/dex/attributes/annotations/MethodParameters.java

@@ -1,18 +1,18 @@
 package jadx.core.dex.attributes.annotations;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttribute;
 import jadx.core.utils.Utils;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class MethodParameters implements IAttribute {
 
 	private final List<AnnotationsList> paramList;
 
 	public MethodParameters(int paramCount) {
-		paramList = new ArrayList<AnnotationsList>(paramCount);
+		paramList = new ArrayList<>(paramCount);
 	}
 
 	public List<AnnotationsList> getParamList() {

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/DeclareVariablesAttr.java

@@ -1,19 +1,19 @@
 package jadx.core.dex.attributes.nodes;
 
+import java.util.LinkedList;
+import java.util.List;
+
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttribute;
 import jadx.core.dex.instructions.args.RegisterArg;
 import jadx.core.utils.Utils;
 
-import java.util.LinkedList;
-import java.util.List;
-
 /**
  * List of variables to be declared at region start.
  */
 public class DeclareVariablesAttr implements IAttribute {
 
-	private final List<RegisterArg> vars = new LinkedList<RegisterArg>();
+	private final List<RegisterArg> vars = new LinkedList<>();
 
 	public Iterable<RegisterArg> getVars() {
 		return vars;

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/EdgeInsnAttr.java

@@ -0,0 +1,48 @@
+package jadx.core.dex.attributes.nodes;
+
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.AttrList;
+import jadx.core.dex.attributes.IAttribute;
+import jadx.core.dex.nodes.BlockNode;
+import jadx.core.dex.nodes.InsnNode;
+
+public class EdgeInsnAttr implements IAttribute {
+
+	private final BlockNode start;
+	private final BlockNode end;
+	private final InsnNode insn;
+
+	public static void addEdgeInsn(BlockNode start, BlockNode end, InsnNode insn) {
+		EdgeInsnAttr edgeInsnAttr = new EdgeInsnAttr(start, end, insn);
+		start.addAttr(AType.EDGE_INSN, edgeInsnAttr);
+		end.addAttr(AType.EDGE_INSN, edgeInsnAttr);
+	}
+
+	public EdgeInsnAttr(BlockNode start, BlockNode end, InsnNode insn) {
+		this.start = start;
+		this.end = end;
+		this.insn = insn;
+	}
+
+	@Override
+	public AType<AttrList<EdgeInsnAttr>> getType() {
+		return AType.EDGE_INSN;
+	}
+
+	public BlockNode getStart() {
+		return start;
+	}
+
+	public BlockNode getEnd() {
+		return end;
+	}
+
+	public InsnNode getInsn() {
+		return insn;
+	}
+
+	@Override
+	public String toString() {
+		return "EDGE_INSN: " + start + "->" + end + " " + insn;
+	}
+}

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/EnumClassAttr.java

@@ -1,38 +1,39 @@
 package jadx.core.dex.attributes.nodes;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttribute;
-import jadx.core.dex.instructions.args.InsnArg;
+import jadx.core.dex.info.FieldInfo;
+import jadx.core.dex.instructions.mods.ConstructorInsn;
 import jadx.core.dex.nodes.ClassNode;
 import jadx.core.dex.nodes.MethodNode;
-import jadx.core.utils.Utils;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
 
 public class EnumClassAttr implements IAttribute {
 
 	public static class EnumField {
-		private final String name;
-		private final List<InsnArg> args;
+		private final FieldInfo field;
+		private final ConstructorInsn constrInsn;
+		private final int startArg;
 		private ClassNode cls;
 
-		public EnumField(String name, int argsCount) {
-			this.name = name;
-			if (argsCount != 0) {
-				this.args = new ArrayList<InsnArg>(argsCount);
-			} else {
-				this.args = Collections.emptyList();
-			}
+		public EnumField(FieldInfo field, ConstructorInsn co, int startArg) {
+			this.field = field;
+			this.constrInsn = co;
+			this.startArg = startArg;
 		}
 
-		public String getName() {
-			return name;
+		public FieldInfo getField() {
+			return field;
 		}
 
-		public List<InsnArg> getArgs() {
-			return args;
+		public ConstructorInsn getConstrInsn() {
+			return constrInsn;
+		}
+
+		public int getStartArg() {
+			return startArg;
 		}
 
 		public ClassNode getCls() {
@@ -45,7 +46,7 @@ public class EnumClassAttr implements IAttribute {
 
 		@Override
 		public String toString() {
-			return name + "(" + Utils.listToString(args) + ") " + cls;
+			return field + "(" + constrInsn + ") " + cls;
 		}
 	}
 
@@ -53,7 +54,7 @@ public class EnumClassAttr implements IAttribute {
 	private MethodNode staticMethod;
 
 	public EnumClassAttr(int fieldsCount) {
-		this.fields = new ArrayList<EnumField>(fieldsCount);
+		this.fields = new ArrayList<>(fieldsCount);
 	}
 
 	public List<EnumField> getFields() {

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/EnumMapAttr.java

@@ -0,0 +1,62 @@
+package jadx.core.dex.attributes.nodes;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.IAttribute;
+import jadx.core.dex.nodes.FieldNode;
+
+public class EnumMapAttr implements IAttribute {
+
+	public static class KeyValueMap {
+		private final Map<Object, Object> map = new HashMap<>();
+
+		public Object get(Object key) {
+			return map.get(key);
+		}
+
+		void put(Object key, Object value) {
+			map.put(key, value);
+		}
+	}
+
+	@Nullable
+	private Map<FieldNode, KeyValueMap> fieldsMap;
+
+	@Nullable
+	public KeyValueMap getMap(FieldNode field) {
+		if (fieldsMap == null) {
+			return null;
+		}
+		return fieldsMap.get(field);
+	}
+
+	public void add(FieldNode field, Object key, Object value) {
+		KeyValueMap map = getMap(field);
+		if (map == null) {
+			map = new KeyValueMap();
+			if (fieldsMap == null) {
+				fieldsMap = new HashMap<>();
+			}
+			fieldsMap.put(field, map);
+		}
+		map.put(key, value);
+	}
+
+	public boolean isEmpty() {
+		return fieldsMap == null || fieldsMap.isEmpty();
+	}
+
+	@Override
+	public AType<EnumMapAttr> getType() {
+		return AType.ENUM_MAP;
+	}
+
+	@Override
+	public String toString() {
+		return "Enum fields map: " + fieldsMap;
+	}
+}

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/FieldReplaceAttr.java

@@ -2,24 +2,39 @@ package jadx.core.dex.attributes.nodes;
 
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttribute;
-import jadx.core.dex.info.FieldInfo;
+import jadx.core.dex.info.ClassInfo;
+import jadx.core.dex.instructions.args.InsnArg;
 
 public class FieldReplaceAttr implements IAttribute {
 
-	private final FieldInfo fieldInfo;
-	private final boolean isOuterClass;
-
-	public FieldReplaceAttr(FieldInfo fieldInfo, boolean isOuterClass) {
-		this.fieldInfo = fieldInfo;
-		this.isOuterClass = isOuterClass;
+	public enum ReplaceWith {
+		CLASS_INSTANCE,
+		VAR
 	}
 
-	public FieldInfo getFieldInfo() {
-		return fieldInfo;
+	private final ReplaceWith replaceType;
+	private final Object replaceObj;
+
+	public FieldReplaceAttr(ClassInfo cls) {
+		this.replaceType = ReplaceWith.CLASS_INSTANCE;
+		this.replaceObj = cls;
 	}
 
-	public boolean isOuterClass() {
-		return isOuterClass;
+	public FieldReplaceAttr(InsnArg reg) {
+		this.replaceType = ReplaceWith.VAR;
+		this.replaceObj = reg;
+	}
+
+	public ReplaceWith getReplaceType() {
+		return replaceType;
+	}
+
+	public ClassInfo getClsRef() {
+		return (ClassInfo) replaceObj;
+	}
+
+	public InsnArg getVarRef() {
+		return (InsnArg) replaceObj;
 	}
 
 	@Override
@@ -29,6 +44,6 @@ public class FieldReplaceAttr implements IAttribute {
 
 	@Override
 	public String toString() {
-		return "REPLACE: " + fieldInfo;
+		return "REPLACE: " + replaceType + " " + replaceObj;
 	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/IgnoreEdgeAttr.java

@@ -0,0 +1,32 @@
+package jadx.core.dex.attributes.nodes;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.IAttribute;
+import jadx.core.dex.nodes.BlockNode;
+import jadx.core.utils.Utils;
+
+public class IgnoreEdgeAttr implements IAttribute {
+
+	private final Set<BlockNode> blocks = new HashSet<>(3);
+
+	public Set<BlockNode> getBlocks() {
+		return blocks;
+	}
+
+	public boolean contains(BlockNode block) {
+		return blocks.contains(block);
+	}
+
+	@Override
+	public AType<IgnoreEdgeAttr> getType() {
+		return AType.IGNORE_EDGE;
+	}
+
+	@Override
+	public String toString() {
+		return "IGNORE_EDGES: " + Utils.listToString(blocks);
+	}
+}

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/JadxError.java

@@ -1,33 +1,38 @@
 package jadx.core.dex.attributes.nodes;
 
-import jadx.core.dex.attributes.AType;
-import jadx.core.dex.attributes.IAttribute;
 import jadx.core.utils.Utils;
 
-public class JadxErrorAttr implements IAttribute {
+public class JadxError {
 
+	private final String error;
 	private final Throwable cause;
 
-	public JadxErrorAttr(Throwable cause) {
+	public JadxError(Throwable cause) {
+		this(null, cause);
+	}
+
+	public JadxError(String error, Throwable cause) {
+		this.error = error;
 		this.cause = cause;
 	}
 
+	public String getError() {
+		return error;
+	}
+
 	public Throwable getCause() {
 		return cause;
 	}
 
-	@Override
-	public AType<JadxErrorAttr> getType() {
-		return AType.JADX_ERROR;
-	}
-
 	@Override
 	public String toString() {
 		StringBuilder str = new StringBuilder();
 		str.append("JadxError: ");
-		if (cause == null) {
-			str.append("null");
-		} else {
+		if (error != null) {
+			str.append(error);
+			str.append(' ');
+		}
+		if (cause != null) {
 			str.append(cause.getClass());
 			str.append(":");
 			str.append(cause.getMessage());
@@ -36,5 +41,4 @@ public class JadxErrorAttr implements IAttribute {
 		}
 		return str.toString();
 	}
-
 }

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/JadxWarn.java

@@ -0,0 +1,21 @@
+package jadx.core.dex.attributes.nodes;
+
+import java.util.Objects;
+
+public class JadxWarn {
+
+	private final String warn;
+
+	public JadxWarn(String warn) {
+		this.warn = Objects.requireNonNull(warn);
+	}
+
+	public String getWarn() {
+		return warn;
+	}
+
+	@Override
+	public String toString() {
+		return "JadxWarn: " + warn;
+	}
+}

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/LineAttrNode.java

@@ -23,4 +23,9 @@ public abstract class LineAttrNode extends AttrNode {
 	public void setDecompiledLine(int decompiledLine) {
 		this.decompiledLine = decompiledLine;
 	}
+
+	public void copyLines(LineAttrNode lineAttrNode) {
+		setSourceLine(lineAttrNode.getSourceLine());
+		setDecompiledLine(lineAttrNode.getDecompiledLine());
+	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/LoopInfo.java

@@ -1,22 +1,25 @@
 package jadx.core.dex.attributes.nodes;
 
-import jadx.core.dex.attributes.AType;
-import jadx.core.dex.nodes.BlockNode;
-import jadx.core.dex.nodes.Edge;
-import jadx.core.utils.BlockUtils;
-
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Set;
 
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.nodes.BlockNode;
+import jadx.core.dex.nodes.Edge;
+import jadx.core.utils.BlockUtils;
+
 public class LoopInfo {
 
 	private final BlockNode start;
 	private final BlockNode end;
 	private final Set<BlockNode> loopBlocks;
 
+	private int id;
+	private LoopInfo parentLoop;
+
 	public LoopInfo(BlockNode start, BlockNode end) {
 		this.start = start;
 		this.end = end;
@@ -40,7 +43,7 @@ public class LoopInfo {
 	 * Exit nodes belongs to loop (contains in {@code loopBlocks})
 	 */
 	public Set<BlockNode> getExitNodes() {
-		Set<BlockNode> nodes = new HashSet<BlockNode>();
+		Set<BlockNode> nodes = new HashSet<>();
 		Set<BlockNode> blocks = getLoopBlocks();
 		for (BlockNode block : blocks) {
 			// exit: successor node not from this loop, (don't change to getCleanSuccessors)
@@ -57,7 +60,7 @@ public class LoopInfo {
 	 * Return loop exit edges.
 	 */
 	public List<Edge> getExitEdges() {
-		List<Edge> edges = new LinkedList<Edge>();
+		List<Edge> edges = new LinkedList<>();
 		Set<BlockNode> blocks = getLoopBlocks();
 		for (BlockNode block : blocks) {
 			for (BlockNode s : block.getSuccessors()) {
@@ -69,8 +72,24 @@ public class LoopInfo {
 		return edges;
 	}
 
+	public int getId() {
+		return id;
+	}
+
+	public void setId(int id) {
+		this.id = id;
+	}
+
+	public LoopInfo getParentLoop() {
+		return parentLoop;
+	}
+
+	public void setParentLoop(LoopInfo parentLoop) {
+		this.parentLoop = parentLoop;
+	}
+
 	@Override
 	public String toString() {
-		return "LOOP: " + start + "->" + end;
+		return "LOOP:" + id + ": " + start + "->" + end;
 	}
 }

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/LoopLabelAttr.java

@@ -0,0 +1,27 @@
+package jadx.core.dex.attributes.nodes;
+
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.IAttribute;
+
+public class LoopLabelAttr implements IAttribute {
+
+	private final LoopInfo loop;
+
+	public LoopLabelAttr(LoopInfo loop) {
+		this.loop = loop;
+	}
+
+	public LoopInfo getLoop() {
+		return loop;
+	}
+
+	@Override
+	public AType<LoopLabelAttr> getType() {
+		return AType.LOOP_LABEL;
+	}
+
+	@Override
+	public String toString() {
+		return "LOOP_LABEL: " + loop;
+	}
+}

jadx-core/src/main/java/jadx/core/dex/attributes/nodes/PhiListAttr.java

@@ -1,15 +1,15 @@
 package jadx.core.dex.attributes.nodes;
 
+import java.util.LinkedList;
+import java.util.List;
+
 import jadx.core.dex.attributes.AType;
 import jadx.core.dex.attributes.IAttribute;
 import jadx.core.dex.instructions.PhiInsn;
 
-import java.util.LinkedList;
-import java.util.List;
-
 public class PhiListAttr implements IAttribute {
 
-	private final List<PhiInsn> list = new LinkedList<PhiInsn>();
+	private final List<PhiInsn> list = new LinkedList<>();
 
 	@Override
 	public AType<PhiListAttr> getType() {

jadx-core/src/main/java/jadx/core/dex/info/AccessInfo.java

@@ -1,9 +1,9 @@
 package jadx.core.dex.info;
 
-import jadx.core.Consts;
-
 import com.android.dx.rop.code.AccessFlags;
 
+import jadx.core.Consts;
+
 public class AccessInfo {
 
 	private final int accFlags;
@@ -25,16 +25,15 @@ public class AccessInfo {
 
 	public AccessInfo remove(int flag) {
 		if (containsFlag(flag)) {
-			return new AccessInfo(accFlags - flag, type);
-		} else {
-			return this;
+			return new AccessInfo(accFlags & ~flag, type);
 		}
+		return this;
 	}
 
 	public AccessInfo getVisibility() {
-		int f = (accFlags & AccessFlags.ACC_PUBLIC)
-				| (accFlags & AccessFlags.ACC_PROTECTED)
-				| (accFlags & AccessFlags.ACC_PRIVATE);
+		int f = accFlags & AccessFlags.ACC_PUBLIC
+				| accFlags & AccessFlags.ACC_PROTECTED
+				| accFlags & AccessFlags.ACC_PRIVATE;
 		return new AccessInfo(f, type);
 	}
 
@@ -141,10 +140,8 @@ public class AccessInfo {
 				if (isBridge()) {
 					code.append("/* bridge */ ");
 				}
-				if (Consts.DEBUG) {
-					if (isVarArgs()) {
-						code.append("/* varargs */ ");
-					}
+				if (Consts.DEBUG && isVarArgs()) {
+					code.append("/* varargs */ ");
 				}
 				break;
 

jadx-core/src/main/java/jadx/core/dex/info/ClassInfo.java

@@ -1,69 +1,86 @@
 package jadx.core.dex.info;
 
-import jadx.core.Consts;
-import jadx.core.deobf.NameMapper;
+import java.io.File;
+
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.DexNode;
-
-import java.io.File;
-import java.util.Map;
-import java.util.WeakHashMap;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.exceptions.JadxRuntimeException;
 
 public final class ClassInfo {
 
-	private static final Map<ArgType, ClassInfo> CLASSINFO_CACHE = new WeakHashMap<ArgType, ClassInfo>();
-
 	private final ArgType type;
 	private String pkg;
 	private String name;
 	private String fullName;
 	// for inner class not equals null
 	private ClassInfo parentClass;
+	// class info after rename (deobfuscation)
+	private ClassInfo alias;
 
-	private ClassInfo(ArgType type) {
-		assert type.isObject() : "Not class type: " + type;
+	private ClassInfo(RootNode root, ArgType type) {
+		this(root, type, true);
+	}
+
+	private ClassInfo(RootNode root, ArgType type, boolean inner) {
+		if (!type.isObject() || type.isGeneric()) {
+			throw new JadxRuntimeException("Not class type: " + type);
+		}
 		this.type = type;
+		this.alias = this;
 
-		splitNames(true);
+		splitNames(root, inner);
+	}
+
+	public static ClassInfo fromType(RootNode root, ArgType type) {
+		if (type.isArray()) {
+			type = ArgType.OBJECT;
+		}
+		ClassInfo cls = root.getInfoStorage().getCls(type);
+		if (cls != null) {
+			return cls;
+		}
+		cls = new ClassInfo(root, type);
+		return root.getInfoStorage().putCls(cls);
 	}
 
 	public static ClassInfo fromDex(DexNode dex, int clsIndex) {
 		if (clsIndex == DexNode.NO_INDEX) {
 			return null;
 		}
-		ArgType type = dex.getType(clsIndex);
-		if (type.isArray()) {
-			type = ArgType.OBJECT;
+		return fromType(dex.root(), dex.getType(clsIndex));
+	}
+
+	public static ClassInfo fromName(RootNode root, String clsName) {
+		return fromType(root, ArgType.object(clsName));
+	}
+
+	public static ClassInfo extCls(RootNode root, ArgType type) {
+		ClassInfo classInfo = fromName(root, type.getObject());
+		return classInfo.alias;
+	}
+
+	public void rename(RootNode root, String fullName) {
+		ClassInfo newAlias = new ClassInfo(root, ArgType.object(fullName), isInner());
+		if (!alias.getFullName().equals(newAlias.getFullName())) {
+			this.alias = newAlias;
 		}
-		return fromType(type);
 	}
 
-	public static ClassInfo fromName(String clsName) {
-		return fromType(ArgType.object(clsName));
+	public boolean isRenamed() {
+		return alias != this;
 	}
 
-	public static ClassInfo fromType(ArgType type) {
-		ClassInfo cls = CLASSINFO_CACHE.get(type);
-		if (cls == null) {
-			cls = new ClassInfo(type);
-			CLASSINFO_CACHE.put(type, cls);
-		}
-		return cls;
+	public ClassInfo getAlias() {
+		return alias;
 	}
 
-	public static void clearCache() {
-		CLASSINFO_CACHE.clear();
-	}
-
-	private void splitNames(boolean canBeInner) {
+	private void splitNames(RootNode root, boolean canBeInner) {
 		String fullObjectName = type.getObject();
-		assert fullObjectName.indexOf('/') == -1 : "Raw type: " + type;
-
 		String clsName;
 		int dot = fullObjectName.lastIndexOf('.');
 		if (dot == -1) {
-			// rename default package if it used from class with package (often for obfuscated apps),
-			pkg = Consts.DEFAULT_PACKAGE_NAME;
+			pkg = "";
 			clsName = fullObjectName;
 		} else {
 			pkg = fullObjectName.substring(0, dot);
@@ -73,69 +90,79 @@ public final class ClassInfo {
 		int sep = clsName.lastIndexOf('$');
 		if (canBeInner && sep > 0 && sep != clsName.length() - 1) {
 			String parClsName = pkg + "." + clsName.substring(0, sep);
-			parentClass = fromName(parClsName);
+			if (pkg.isEmpty()) {
+				parClsName = clsName.substring(0, sep);
+			}
+
+			parentClass = fromName(root, parClsName);
 			clsName = clsName.substring(sep + 1);
 		} else {
 			parentClass = null;
 		}
-
-		char firstChar = clsName.charAt(0);
-		if (Character.isDigit(firstChar)) {
-			clsName = Consts.ANONYMOUS_CLASS_PREFIX + clsName;
-		} else if (firstChar == '$') {
-			clsName = "_" + clsName;
-		}
-		if (NameMapper.isReserved(clsName)) {
-			clsName += "_";
-		}
-		this.fullName = (parentClass != null ? parentClass.getFullName() : pkg) + "." + clsName;
 		this.name = clsName;
+		this.fullName = makeFullClsName(clsName, false);
+	}
+
+	public String makeFullClsName(String shortName, boolean raw) {
+		if (parentClass != null) {
+			String innerSep = raw ? "$" : ".";
+			return parentClass.makeFullClsName(parentClass.getShortName(), raw) + innerSep + shortName;
+		}
+		return pkg.isEmpty() ? shortName : pkg + "." + shortName;
 	}
 
 	public String getFullPath() {
-		return pkg.replace('.', File.separatorChar)
+		ClassInfo usedAlias = getAlias();
+		return usedAlias.getPackage().replace('.', File.separatorChar)
 				+ File.separatorChar
-				+ getNameWithoutPackage().replace('.', '_');
+				+ usedAlias.getNameWithoutPackage().replace('.', '_');
 	}
 
 	public String getFullName() {
 		return fullName;
 	}
 
-	public boolean isObject() {
-		return fullName.equals(Consts.CLASS_OBJECT);
-	}
-
 	public String getShortName() {
 		return name;
 	}
 
-	public String getRawName() {
-		return type.getObject();
-	}
-
 	public String getPackage() {
 		return pkg;
 	}
 
-	public boolean isPackageDefault() {
-		return pkg.isEmpty() || pkg.equals(Consts.DEFAULT_PACKAGE_NAME);
+	public boolean isDefaultPackage() {
+		return pkg.isEmpty();
+	}
+
+	public String getRawName() {
+		return type.getObject();
 	}
 
 	public String getNameWithoutPackage() {
-		return (parentClass != null ? parentClass.getNameWithoutPackage() + "." : "") + name;
+		if (parentClass == null) {
+			return name;
+		}
+		return parentClass.getNameWithoutPackage() + "." + name;
 	}
 
 	public ClassInfo getParentClass() {
 		return parentClass;
 	}
 
+	public ClassInfo getTopParentClass() {
+		if (parentClass != null) {
+			ClassInfo topCls = parentClass.getTopParentClass();
+			return topCls != null ? topCls : parentClass;
+		}
+		return null;
+	}
+
 	public boolean isInner() {
 		return parentClass != null;
 	}
 
-	public void notInner() {
-		splitNames(false);
+	public void notInner(RootNode root) {
+		splitNames(root, false);
 	}
 
 	public ArgType getType() {
@@ -149,7 +176,7 @@ public final class ClassInfo {
 
 	@Override
 	public int hashCode() {
-		return fullName.hashCode();
+		return type.hashCode();
 	}
 
 	@Override
@@ -159,7 +186,7 @@ public final class ClassInfo {
 		}
 		if (obj instanceof ClassInfo) {
 			ClassInfo other = (ClassInfo) obj;
-			return this.getFullName().equals(other.getFullName());
+			return this.type.equals(other.type);
 		}
 		return false;
 	}

jadx-core/src/main/java/jadx/core/dex/info/ConstStorage.java

@@ -0,0 +1,189 @@
+package jadx.core.dex.info;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.JadxArgs;
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.instructions.args.LiteralArg;
+import jadx.core.dex.instructions.args.PrimitiveType;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.DexNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.ResRefField;
+import jadx.core.dex.nodes.parser.FieldInitAttr;
+
+public class ConstStorage {
+
+	private static final class ValueStorage {
+		private final Map<Object, FieldNode> values = new HashMap<>();
+		private final Set<Object> duplicates = new HashSet<>();
+
+		public Map<Object, FieldNode> getValues() {
+			return values;
+		}
+
+		public FieldNode get(Object key) {
+			return values.get(key);
+		}
+
+		/**
+		 * @return true if this value is duplicated
+		 */
+		public boolean put(Object value, FieldNode fld) {
+			FieldNode prev = values.put(value, fld);
+			if (prev != null) {
+				values.remove(value);
+				duplicates.add(value);
+				return true;
+			}
+			if (duplicates.contains(value)) {
+				values.remove(value);
+				return true;
+			}
+			return false;
+		}
+
+		public boolean contains(Object value) {
+			return duplicates.contains(value) || values.containsKey(value);
+		}
+	}
+
+	private final boolean replaceEnabled;
+	private final ValueStorage globalValues = new ValueStorage();
+	private final Map<ClassNode, ValueStorage> classes = new HashMap<>();
+
+	private Map<Integer, String> resourcesNames = new HashMap<>();
+
+	public ConstStorage(JadxArgs args) {
+		this.replaceEnabled = args.isReplaceConsts();
+	}
+
+	public void processConstFields(ClassNode cls, List<FieldNode> staticFields) {
+		if (!replaceEnabled || staticFields.isEmpty()) {
+			return;
+		}
+		for (FieldNode f : staticFields) {
+			AccessInfo accFlags = f.getAccessFlags();
+			if (accFlags.isStatic() && accFlags.isFinal()) {
+				FieldInitAttr fv = f.get(AType.FIELD_INIT);
+				if (fv != null
+						&& fv.getValue() != null
+						&& fv.getValueType() == FieldInitAttr.InitType.CONST
+						&& fv != FieldInitAttr.NULL_VALUE) {
+					addConstField(cls, f, fv.getValue(), accFlags.isPublic());
+				}
+			}
+		}
+	}
+
+	private void addConstField(ClassNode cls, FieldNode fld, Object value, boolean isPublic) {
+		if (isPublic) {
+			globalValues.put(value, fld);
+		} else {
+			getClsValues(cls).put(value, fld);
+		}
+	}
+
+	private ValueStorage getClsValues(ClassNode cls) {
+		ValueStorage classValues = classes.get(cls);
+		if (classValues == null) {
+			classValues = new ValueStorage();
+			classes.put(cls, classValues);
+		}
+		return classValues;
+	}
+
+	@Nullable
+	public FieldNode getConstField(ClassNode cls, Object value, boolean searchGlobal) {
+		DexNode dex = cls.dex();
+		if (value instanceof Integer) {
+			String str = resourcesNames.get(value);
+			if (str != null) {
+				return new ResRefField(dex, str.replace('/', '.'));
+			}
+		}
+		if (!replaceEnabled) {
+			return null;
+		}
+		boolean foundInGlobal = globalValues.contains(value);
+		if (foundInGlobal && !searchGlobal) {
+			return null;
+		}
+		ClassNode current = cls;
+		while (current != null) {
+			ValueStorage classValues = classes.get(current);
+			if (classValues != null) {
+				FieldNode field = classValues.get(value);
+				if (field != null) {
+					if (foundInGlobal) {
+						return null;
+					}
+					return field;
+				}
+			}
+			ClassInfo parentClass = current.getClassInfo().getParentClass();
+			if (parentClass == null) {
+				break;
+			}
+			current = dex.resolveClass(parentClass);
+		}
+		if (searchGlobal) {
+			return globalValues.get(value);
+		}
+		return null;
+	}
+
+	@Nullable
+	public FieldNode getConstFieldByLiteralArg(ClassNode cls, LiteralArg arg) {
+		PrimitiveType type = arg.getType().getPrimitiveType();
+		if (type == null) {
+			return null;
+		}
+		long literal = arg.getLiteral();
+		switch (type) {
+			case BOOLEAN:
+				return getConstField(cls, literal == 1, false);
+			case CHAR:
+				return getConstField(cls, (char) literal, Math.abs(literal) > 10);
+			case BYTE:
+				return getConstField(cls, (byte) literal, Math.abs(literal) > 10);
+			case SHORT:
+				return getConstField(cls, (short) literal, Math.abs(literal) > 100);
+			case INT:
+				return getConstField(cls, (int) literal, Math.abs(literal) > 100);
+			case LONG:
+				return getConstField(cls, literal, Math.abs(literal) > 1000);
+			case FLOAT:
+				float f = Float.intBitsToFloat((int) literal);
+				return getConstField(cls, f, Float.compare(f, 0) == 0);
+			case DOUBLE:
+				double d = Double.longBitsToDouble(literal);
+				return getConstField(cls, d, Double.compare(d, 0) == 0);
+
+			default:
+				return null;
+		}
+	}
+
+	public void setResourcesNames(Map<Integer, String> resourcesNames) {
+		this.resourcesNames = resourcesNames;
+	}
+
+	public Map<Integer, String> getResourcesNames() {
+		return resourcesNames;
+	}
+
+	public Map<Object, FieldNode> getGlobalConstFields() {
+		return globalValues.getValues();
+	}
+
+	public boolean isReplaceEnabled() {
+		return replaceEnabled;
+	}
+}

jadx-core/src/main/java/jadx/core/dex/info/FieldInfo.java

@@ -1,34 +1,38 @@
 package jadx.core.dex.info;
 
-import jadx.core.dex.instructions.args.ArgType;
-import jadx.core.dex.nodes.DexNode;
-
 import com.android.dex.FieldId;
 
-public class FieldInfo {
+import jadx.core.codegen.TypeGen;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.DexNode;
+
+public final class FieldInfo {
 
 	private final ClassInfo declClass;
 	private final String name;
 	private final ArgType type;
+	private String alias;
 
-	public FieldInfo(ClassInfo declClass, String name, ArgType type) {
+	private FieldInfo(ClassInfo declClass, String name, ArgType type) {
 		this.declClass = declClass;
 		this.name = name;
 		this.type = type;
+		this.alias = name;
+	}
+
+	public static FieldInfo from(DexNode dex, ClassInfo declClass, String name, ArgType type) {
+		FieldInfo field = new FieldInfo(declClass, name, type);
+		return dex.root().getInfoStorage().getField(field);
 	}
 
 	public static FieldInfo fromDex(DexNode dex, int index) {
 		FieldId field = dex.getFieldId(index);
-		return new FieldInfo(
+		return from(dex,
 				ClassInfo.fromDex(dex, field.getDeclaringClassIndex()),
 				dex.getString(field.getNameIndex()),
 				dex.getType(field.getTypeIndex()));
 	}
 
-	public static String getNameById(DexNode dex, int ind) {
-		return dex.getString(dex.getFieldId(ind).getNameIndex());
-	}
-
 	public String getName() {
 		return name;
 	}
@@ -41,6 +45,22 @@ public class FieldInfo {
 		return declClass;
 	}
 
+	public String getAlias() {
+		return alias;
+	}
+
+	public void setAlias(String alias) {
+		this.alias = alias;
+	}
+
+	public String getFullId() {
+		return declClass.getFullName() + "." + name + ":" + TypeGen.signature(type);
+	}
+
+	public boolean isRenamed() {
+		return !name.equals(alias);
+	}
+
 	@Override
 	public boolean equals(Object o) {
 		if (this == o) {
@@ -50,16 +70,9 @@ public class FieldInfo {
 			return false;
 		}
 		FieldInfo fieldInfo = (FieldInfo) o;
-		if (!name.equals(fieldInfo.name)) {
-			return false;
-		}
-		if (!type.equals(fieldInfo.type)) {
-			return false;
-		}
-		if (!declClass.equals(fieldInfo.declClass)) {
-			return false;
-		}
-		return true;
+		return name.equals(fieldInfo.name)
+				&& type.equals(fieldInfo.type)
+				&& declClass.equals(fieldInfo.declClass);
 	}
 
 	@Override

jadx-core/src/main/java/jadx/core/dex/info/InfoStorage.java

@@ -0,0 +1,51 @@
+package jadx.core.dex.info;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.DexNode;
+
+public class InfoStorage {
+
+	private final Map<ArgType, ClassInfo> classes = new HashMap<>();
+	private final Map<Integer, MethodInfo> methods = new HashMap<>();
+	private final Map<FieldInfo, FieldInfo> fields = new HashMap<>();
+
+	public ClassInfo getCls(ArgType type) {
+		return classes.get(type);
+	}
+
+	public ClassInfo putCls(ClassInfo cls) {
+		synchronized (classes) {
+			ClassInfo prev = classes.put(cls.getType(), cls);
+			return prev == null ? cls : prev;
+		}
+	}
+
+	private int generateMethodLookupId(DexNode dex, int mthId) {
+		return dex.getDexId() << 16 | mthId;
+	}
+
+	public MethodInfo getMethod(DexNode dex, int mtdId) {
+		return methods.get(generateMethodLookupId(dex, mtdId));
+	}
+
+	public MethodInfo putMethod(DexNode dex, int mthId, MethodInfo mth) {
+		synchronized (methods) {
+			MethodInfo prev = methods.put(generateMethodLookupId(dex, mthId), mth);
+			return prev == null ? mth : prev;
+		}
+	}
+
+	public FieldInfo getField(FieldInfo field) {
+		synchronized (fields) {
+			FieldInfo f = fields.get(field);
+			if (f != null) {
+				return f;
+			}
+			fields.put(field, field);
+			return field;
+		}
+	}
+}

jadx-core/src/main/java/jadx/core/dex/info/MethodInfo.java

@@ -1,15 +1,15 @@
 package jadx.core.dex.info;
 
-import jadx.core.codegen.TypeGen;
-import jadx.core.dex.instructions.args.ArgType;
-import jadx.core.dex.nodes.DexNode;
-import jadx.core.utils.Utils;
-
 import java.util.List;
 
 import com.android.dex.MethodId;
 import com.android.dex.ProtoId;
 
+import jadx.core.codegen.TypeGen;
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.DexNode;
+import jadx.core.utils.Utils;
+
 public final class MethodInfo {
 
 	private final String name;
@@ -17,16 +17,32 @@ public final class MethodInfo {
 	private final List<ArgType> args;
 	private final ClassInfo declClass;
 	private final String shortId;
+	private String alias;
+	private boolean aliasFromPreset;
 
 	private MethodInfo(DexNode dex, int mthIndex) {
 		MethodId mthId = dex.getMethodId(mthIndex);
 		name = dex.getString(mthId.getNameIndex());
+		alias = name;
+		aliasFromPreset = false;
 		declClass = ClassInfo.fromDex(dex, mthId.getDeclaringClassIndex());
 
 		ProtoId proto = dex.getProtoId(mthId.getProtoIndex());
 		retType = dex.getType(proto.getReturnTypeIndex());
 		args = dex.readParamList(proto.getParametersOffset());
+		shortId = makeSignature(true);
+	}
 
+	public static MethodInfo fromDex(DexNode dex, int mthIndex) {
+		MethodInfo mth = dex.root().getInfoStorage().getMethod(dex, mthIndex);
+		if (mth != null) {
+			return mth;
+		}
+		mth = new MethodInfo(dex, mthIndex);
+		return dex.root().getInfoStorage().putMethod(dex, mthIndex, mth);
+	}
+
+	public String makeSignature(boolean includeRetType) {
 		StringBuilder signature = new StringBuilder();
 		signature.append(name);
 		signature.append('(');
@@ -34,13 +50,10 @@ public final class MethodInfo {
 			signature.append(TypeGen.signature(arg));
 		}
 		signature.append(')');
-		signature.append(TypeGen.signature(retType));
-
-		shortId = signature.toString();
-	}
-
-	public static MethodInfo fromDex(DexNode dex, int mthIndex) {
-		return new MethodInfo(dex, mthIndex);
+		if (includeRetType) {
+			signature.append(TypeGen.signature(retType));
+		}
+		return signature.toString();
 	}
 
 	public String getName() {
@@ -86,6 +99,26 @@ public final class MethodInfo {
 		return name.equals("<clinit>");
 	}
 
+	public String getAlias() {
+		return alias;
+	}
+
+	public void setAlias(String alias) {
+		this.alias = alias;
+	}
+
+	public boolean isRenamed() {
+		return !name.equals(alias);
+	}
+
+	public boolean isAliasFromPreset() {
+		return aliasFromPreset;
+	}
+
+	public void setAliasFromPreset(boolean value) {
+		aliasFromPreset = value;
+	}
+
 	@Override
 	public int hashCode() {
 		int result = declClass.hashCode();
@@ -99,23 +132,13 @@ public final class MethodInfo {
 		if (this == obj) {
 			return true;
 		}
-		if (obj == null) {
-			return false;
-		}
-		if (getClass() != obj.getClass()) {
+		if (!(obj instanceof MethodInfo)) {
 			return false;
 		}
 		MethodInfo other = (MethodInfo) obj;
-		if (!shortId.equals(other.shortId)) {
-			return false;
-		}
-		if (!retType.equals(other.retType)) {
-			return false;
-		}
-		if (!declClass.equals(other.declClass)) {
-			return false;
-		}
-		return true;
+		return shortId.equals(other.shortId)
+				&& retType.equals(other.retType)
+				&& declClass.equals(other.declClass);
 	}
 
 	@Override

jadx-core/src/main/java/jadx/core/dex/instructions/ArithNode.java

@@ -1,13 +1,14 @@
 package jadx.core.dex.instructions;
 
+import com.android.dx.io.instructions.DecodedInstruction;
+
+import jadx.core.dex.attributes.AFlag;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.instructions.args.InsnArg;
 import jadx.core.dex.instructions.args.RegisterArg;
 import jadx.core.dex.nodes.InsnNode;
 import jadx.core.utils.InsnUtils;
 
-import com.android.dx.io.instructions.DecodedInstruction;
-
 public class ArithNode extends InsnNode {
 
 	private final ArithOp op;
@@ -39,7 +40,6 @@ public class ArithNode extends InsnNode {
 				addReg(insn, 2, type);
 			}
 		}
-		assert getArgsCount() == 2;
 	}
 
 	public ArithNode(ArithOp op, RegisterArg res, InsnArg a, InsnArg b) {
@@ -51,10 +51,8 @@ public class ArithNode extends InsnNode {
 	}
 
 	public ArithNode(ArithOp op, RegisterArg res, InsnArg a) {
-		super(InsnType.ARITH_ONEARG, 1);
-		this.op = op;
-		setResult(res);
-		addArg(a);
+		this(op, res, res, a);
+		add(AFlag.ARITH_ONEARG);
 	}
 
 	public ArithOp getOp() {
@@ -62,20 +60,15 @@ public class ArithNode extends InsnNode {
 	}
 
 	@Override
-	public boolean equals(Object obj) {
+	public boolean isSame(InsnNode obj) {
 		if (this == obj) {
 			return true;
 		}
-		if (!(obj instanceof ArithNode) || !super.equals(obj)) {
+		if (!(obj instanceof ArithNode) || !super.isSame(obj)) {
 			return false;
 		}
-		ArithNode that = (ArithNode) obj;
-		return op == that.op;
-	}
-
-	@Override
-	public int hashCode() {
-		return 31 * super.hashCode() + op.hashCode();
+		ArithNode other = (ArithNode) obj;
+		return op == other.op;
 	}
 
 	@Override
@@ -85,7 +78,7 @@ public class ArithNode extends InsnNode {
 				+ getResult() + " = "
 				+ getArg(0) + " "
 				+ op.getSymbol() + " "
-				+ (getArgsCount() == 2 ? getArg(1) : "");
+				+ getArg(1);
 	}
 
 }

jadx-core/src/main/java/jadx/core/dex/instructions/ConstClassNode.java

@@ -17,20 +17,20 @@ public final class ConstClassNode extends InsnNode {
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if (this == obj) {
-			return true;
-		}
-		if (!(obj instanceof ConstClassNode) || !super.equals(obj)) {
-			return false;
-		}
-		ConstClassNode that = (ConstClassNode) obj;
-		return clsType.equals(that.clsType);
+	public InsnNode copy() {
+		return copyCommonParams(new ConstClassNode(clsType));
 	}
 
 	@Override
-	public int hashCode() {
-		return 31 * super.hashCode() + clsType.hashCode();
+	public boolean isSame(InsnNode obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (!(obj instanceof ConstClassNode) || !super.isSame(obj)) {
+			return false;
+		}
+		ConstClassNode other = (ConstClassNode) obj;
+		return clsType.equals(other.clsType);
 	}
 
 	@Override

jadx-core/src/main/java/jadx/core/dex/instructions/ConstStringNode.java

@@ -16,20 +16,20 @@ public final class ConstStringNode extends InsnNode {
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if (this == obj) {
-			return true;
-		}
-		if (!(obj instanceof ConstStringNode) || !super.equals(obj)) {
-			return false;
-		}
-		ConstStringNode that = (ConstStringNode) obj;
-		return str.equals(that.str);
+	public InsnNode copy() {
+		return copyCommonParams(new ConstStringNode(str));
 	}
 
 	@Override
-	public int hashCode() {
-		return 31 * super.hashCode() + str.hashCode();
+	public boolean isSame(InsnNode obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (!(obj instanceof ConstStringNode) || !super.isSame(obj)) {
+			return false;
+		}
+		ConstStringNode other = (ConstStringNode) obj;
+		return str.equals(other.str);
 	}
 
 	@Override

jadx-core/src/main/java/jadx/core/dex/instructions/FillArrayNode.java

@@ -1,16 +1,22 @@
 package jadx.core.dex.instructions;
 
+import java.util.ArrayList;
+import java.util.List;
+
+import com.android.dx.io.instructions.FillArrayDataPayloadDecodedInstruction;
+
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.instructions.args.InsnArg;
+import jadx.core.dex.instructions.args.LiteralArg;
 import jadx.core.dex.instructions.args.PrimitiveType;
+import jadx.core.dex.nodes.DexNode;
 import jadx.core.dex.nodes.InsnNode;
 import jadx.core.utils.exceptions.JadxRuntimeException;
 
-import com.android.dx.io.instructions.FillArrayDataPayloadDecodedInstruction;
-
 public final class FillArrayNode extends InsnNode {
 
 	private final Object data;
+	private final int size;
 	private ArgType elemType;
 
 	public FillArrayNode(int resReg, FillArrayDataPayloadDecodedInstruction payload) {
@@ -36,6 +42,7 @@ public final class FillArrayNode extends InsnNode {
 		setResult(InsnArg.reg(resReg, ArgType.array(elType)));
 
 		this.data = payload.getData();
+		this.size = payload.getSize();
 		this.elemType = elType;
 	}
 
@@ -43,31 +50,55 @@ public final class FillArrayNode extends InsnNode {
 		return data;
 	}
 
+	public int getSize() {
+		return size;
+	}
+
 	public ArgType getElementType() {
 		return elemType;
 	}
 
-	public void mergeElementType(ArgType foundElemType) {
-		ArgType r = ArgType.merge(elemType, foundElemType);
+	public void mergeElementType(DexNode dex, ArgType foundElemType) {
+		ArgType r = ArgType.merge(dex, elemType, foundElemType);
 		if (r != null) {
 			elemType = r;
 		}
 	}
 
-	@Override
-	public boolean equals(Object obj) {
-		if (this == obj) {
-			return true;
+	public List<LiteralArg> getLiteralArgs() {
+		List<LiteralArg> list = new ArrayList<>(size);
+		Object array = data;
+		if (array instanceof int[]) {
+			for (int b : (int[]) array) {
+				list.add(InsnArg.lit(b, elemType));
+			}
+		} else if (array instanceof byte[]) {
+			for (byte b : (byte[]) array) {
+				list.add(InsnArg.lit(b, elemType));
+			}
+		} else if (array instanceof short[]) {
+			for (short b : (short[]) array) {
+				list.add(InsnArg.lit(b, elemType));
+			}
+		} else if (array instanceof long[]) {
+			for (long b : (long[]) array) {
+				list.add(InsnArg.lit(b, elemType));
+			}
+		} else {
+			throw new JadxRuntimeException("Unknown type: " + data.getClass() + ", expected: " + elemType);
 		}
-		if (!(obj instanceof FillArrayNode) || !super.equals(obj)) {
-			return false;
-		}
-		FillArrayNode that = (FillArrayNode) obj;
-		return elemType.equals(that.elemType) && data == that.data;
+		return list;
 	}
 
 	@Override
-	public int hashCode() {
-		return 31 * super.hashCode() + elemType.hashCode() + data.hashCode();
+	public boolean isSame(InsnNode obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (!(obj instanceof FillArrayNode) || !super.isSame(obj)) {
+			return false;
+		}
+		FillArrayNode other = (FillArrayNode) obj;
+		return elemType.equals(other.elemType) && data == other.data;
 	}
 }

jadx-core/src/main/java/jadx/core/dex/instructions/FilledNewArrayNode.java

@@ -0,0 +1,41 @@
+package jadx.core.dex.instructions;
+
+import org.jetbrains.annotations.NotNull;
+
+import jadx.core.dex.instructions.args.ArgType;
+import jadx.core.dex.nodes.InsnNode;
+
+public class FilledNewArrayNode extends InsnNode {
+
+	private final ArgType elemType;
+
+	public FilledNewArrayNode(@NotNull ArgType elemType, int size) {
+		super(InsnType.FILLED_NEW_ARRAY, size);
+		this.elemType = elemType;
+	}
+
+	public ArgType getElemType() {
+		return elemType;
+	}
+
+	public ArgType getArrayType() {
+		return ArgType.array(elemType);
+	}
+
+	@Override
+	public boolean isSame(InsnNode obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (!(obj instanceof FilledNewArrayNode) || !super.isSame(obj)) {
+			return false;
+		}
+		FilledNewArrayNode other = (FilledNewArrayNode) obj;
+		return elemType == other.elemType;
+	}
+
+	@Override
+	public String toString() {
+		return super.toString() + " elemType: " + elemType;
+	}
+}

jadx-core/src/main/java/jadx/core/dex/instructions/GotoNode.java

@@ -1,11 +1,11 @@
 package jadx.core.dex.instructions;
 
-import jadx.core.dex.nodes.InsnNode;
+import jadx.core.dex.nodes.BlockNode;
 import jadx.core.utils.InsnUtils;
 
-public class GotoNode extends InsnNode {
+public class GotoNode extends TargetInsnNode {
 
-	protected int target;
+	protected final int target;
 
 	public GotoNode(int target) {
 		this(InsnType.GOTO, target, 0);
@@ -21,20 +21,12 @@ public class GotoNode extends InsnNode {
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if (this == obj) {
-			return true;
-		}
-		if (!(obj instanceof GotoNode) || !super.equals(obj)) {
-			return false;
-		}
-		GotoNode gotoNode = (GotoNode) obj;
-		return target == gotoNode.target;
+	public boolean replaceTargetBlock(BlockNode origin, BlockNode replace) {
+		return false;
 	}
 
 	@Override
-	public int hashCode() {
-		return 31 * super.hashCode() + target;
+	public void initBlocks(BlockNode curBlock) {
 	}
 
 	@Override

jadx-core/src/main/java/jadx/core/dex/instructions/IfNode.java

@@ -1,21 +1,26 @@
 package jadx.core.dex.instructions;
 
+import java.util.List;
+
+import com.android.dx.io.instructions.DecodedInstruction;
+
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.instructions.args.InsnArg;
 import jadx.core.dex.instructions.args.PrimitiveType;
 import jadx.core.dex.nodes.BlockNode;
+import jadx.core.dex.nodes.InsnNode;
 import jadx.core.utils.InsnUtils;
 
-import com.android.dx.io.instructions.DecodedInstruction;
-
 import static jadx.core.utils.BlockUtils.getBlockByOffset;
 import static jadx.core.utils.BlockUtils.selectOther;
 
 public class IfNode extends GotoNode {
 
+	// change default types priority
 	private static final ArgType ARG_TYPE = ArgType.unknown(
-			PrimitiveType.INT, PrimitiveType.OBJECT, PrimitiveType.ARRAY,
-			PrimitiveType.BOOLEAN, PrimitiveType.SHORT, PrimitiveType.CHAR);
+			PrimitiveType.INT,
+			PrimitiveType.OBJECT, PrimitiveType.ARRAY,
+			PrimitiveType.BOOLEAN, PrimitiveType.BYTE, PrimitiveType.SHORT, PrimitiveType.CHAR);
 
 	protected IfOp op;
 
@@ -44,7 +49,6 @@ public class IfNode extends GotoNode {
 		BlockNode tmp = thenBlock;
 		thenBlock = elseBlock;
 		elseBlock = tmp;
-		target = thenBlock.getStartOffset();
 	}
 
 	public void changeCondition(IfOp op, InsnArg arg1, InsnArg arg2) {
@@ -53,15 +57,31 @@ public class IfNode extends GotoNode {
 		setArg(1, arg2);
 	}
 
+	@Override
 	public void initBlocks(BlockNode curBlock) {
-		thenBlock = getBlockByOffset(target, curBlock.getSuccessors());
-		if (curBlock.getSuccessors().size() == 1) {
+		List<BlockNode> successors = curBlock.getSuccessors();
+		thenBlock = getBlockByOffset(target, successors);
+		if (successors.size() == 1) {
 			elseBlock = thenBlock;
 		} else {
-			elseBlock = selectOther(thenBlock, curBlock.getSuccessors());
+			elseBlock = selectOther(thenBlock, successors);
 		}
 	}
 
+	@Override
+	public boolean replaceTargetBlock(BlockNode origin, BlockNode replace) {
+		boolean replaced = false;
+		if (thenBlock == origin) {
+			thenBlock = replace;
+			replaced = true;
+		}
+		if (elseBlock == origin) {
+			elseBlock = replace;
+			replaced = true;
+		}
+		return replaced;
+	}
+
 	public BlockNode getThenBlock() {
 		return thenBlock;
 	}
@@ -71,20 +91,20 @@ public class IfNode extends GotoNode {
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if (this == obj) {
-			return true;
-		}
-		if (!(obj instanceof IfNode) || !super.equals(obj)) {
-			return false;
-		}
-		IfNode ifNode = (IfNode) obj;
-		return op == ifNode.op;
+	public int getTarget() {
+		return thenBlock == null ? target : thenBlock.getStartOffset();
 	}
 
 	@Override
-	public int hashCode() {
-		return 31 * super.hashCode() + op.hashCode();
+	public boolean isSame(InsnNode obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (!(obj instanceof IfNode) || !super.isSame(obj)) {
+			return false;
+		}
+		IfNode other = (IfNode) obj;
+		return op == other.op;
 	}
 
 	@Override

jadx-core/src/main/java/jadx/core/dex/instructions/IndexInsnNode.java

@@ -17,20 +17,20 @@ public class IndexInsnNode extends InsnNode {
 	}
 
 	@Override
-	public boolean equals(Object obj) {
-		if (this == obj) {
-			return true;
-		}
-		if (!(obj instanceof IndexInsnNode) || !super.equals(obj)) {
-			return false;
-		}
-		IndexInsnNode that = (IndexInsnNode) obj;
-		return index == null ? that.index == null : index.equals(that.index);
+	public IndexInsnNode copy() {
+		return copyCommonParams(new IndexInsnNode(insnType, index, getArgsCount()));
 	}
 
 	@Override
-	public int hashCode() {
-		return 31 * super.hashCode() + (index != null ? index.hashCode() : 0);
+	public boolean isSame(InsnNode obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (!(obj instanceof IndexInsnNode) || !super.isSame(obj)) {
+			return false;
+		}
+		IndexInsnNode other = (IndexInsnNode) obj;
+		return index == null ? other.index == null : index.equals(other.index);
 	}
 
 	@Override