build: fix release workflow

Plugins can use `.before('BlockFinisher')` to edit blocks before they are locked.

.editorconfig

@@ -0,0 +1,32 @@
+# EditorConfig is awesome: https://EditorConfig.org
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+indent_style = tab
+tab_width = 4
+
+charset = utf-8
+trim_trailing_whitespace = true
+
+[*.java]
+ij_java_continuation_indent_size = 8
+ij_java_use_single_class_imports = true
+ij_java_class_count_to_use_import_on_demand = 99
+ij_java_names_count_to_use_import_on_demand = 99
+ij_java_packages_to_use_import_on_demand = *
+
+[*.kt]
+ij_kotlin_continuation_indent_size = 8
+ij_kotlin_name_count_to_use_star_import = 99
+ij_kotlin_name_count_to_use_star_import_for_members = 99
+ij_kotlin_packages_to_use_import_on_demand = *
+
+[*.yml]
+indent_style = space
+indent_size = 2
+
+[*.bat]
+end_of_line = crlf

.gitattributes

@@ -0,0 +1,12 @@
+*       text=auto eol=lf
+
+*.java  text eol=lf diff=java
+*.kt    text eol=lf diff=kotlin
+*.kts   text eol=lf diff=kotlin
+
+gradlew text eol=lf
+
+*.bat   text eol=crlf
+
+*.png   binary
+*.jar   binary

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/decompilation-issue.yml

@@ -0,0 +1,40 @@
+name: Decompilation issue
+description: Create a report to help us improve jadx decompiler
+title: '[core] '
+labels:
+  - Core
+  - bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        **Checks before submit**
+        - check [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A) section on wiki
+        - try [latest unstable build](https://nightly.link/skylot/jadx/workflows/build-artifacts/master), maybe issue already fixed
+        - search existing issues by exception message
+  - type: textarea
+    id: details
+    attributes:
+      label: Issue details
+      placeholder: >-
+        Describe issue
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output or stacktrace
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: java
+  - type: textarea
+    id: sample
+    attributes:
+      label: Provide sample and class/method full name
+      description: |
+        - sample: attach or provide a link
+        - full name of class or method with issue
+        - other details which may help to reproduce issue
+  - type: input
+    id: jadx-version
+    attributes:
+      label: Jadx version

.github/ISSUE_TEMPLATE/feature-request.yml

@@ -0,0 +1,13 @@
+name: Feature Request
+description: Suggest an idea for jadx
+title: '[feature] '
+labels:
+  - 'new feature'
+body:
+  - type: textarea
+    id: details
+    attributes:
+      label: Describe your idea
+      placeholder: Feature details
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/jadx-gui-issue.yml

@@ -0,0 +1,43 @@
+name: jadx-gui issue
+description: Create a bug report about issue found in jadx-gui
+title: '[gui] '
+labels:
+  - GUI
+  - bug
+body:
+  - type: markdown
+    attributes:
+      value: |
+        **Checks before submit**
+        - check [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A) section on wiki
+        - try [latest unstable build](https://nightly.link/skylot/jadx/workflows/build-artifacts/master), maybe issue already fixed
+        - search existing issues by exception message
+  - type: textarea
+    id: details
+    attributes:
+      label: Issue details
+      placeholder: Describe issue and how to reproduce it
+    validations:
+      required: true
+  - type: input
+    id: jadx-version
+    attributes:
+      label: Jadx version
+      placeholder: check `Help->About`
+    validations:
+      required: true
+  - type: input
+    id: java-version
+    attributes:
+      label: Java version
+      placeholder: check `Help->About`
+    validations:
+      required: true
+  - type: checkboxes
+    id: os
+    attributes:
+      label: OS
+      options:
+        - label: Windows
+        - label: Linux
+        - label: macOS

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+  # Set update schedule for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/pull_request_template.md

@@ -0,0 +1,5 @@
+:exclamation: Please review the [guidelines for contributing](https://github.com/skylot/jadx/blob/master/CONTRIBUTING.md#Pull-Request-Process)
+
+### Description
+Please describe your pull request.
+Reference issue it fixes.

.github/workflows/build-artifacts.yml

@@ -0,0 +1,90 @@
+name: Build Artifacts
+
+on:
+  push:
+    branches: [ master, build-test ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 21
+
+      - name: Set jadx version
+        run: |
+          JADX_REV=$(git rev-list --count HEAD)
+          JADX_VERSION="r${JADX_REV}.${GITHUB_SHA:0:7}"
+          echo "JADX_VERSION=$JADX_VERSION" >> $GITHUB_ENV
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Build
+        run: ./gradlew dist distWin
+        env:
+          JADX_BUILD_JAVA_VERSION: 11
+
+      - name: Save bundle artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ format('jadx-{0}', env.JADX_VERSION) }}
+          # Waiting fix for https://github.com/actions/upload-artifact/issues/39 to upload zip file
+          # Upload unpacked files for now
+          path: build/jadx/**/*
+          if-no-files-found: error
+          retention-days: 14
+
+      - name: Save Windows bundle artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ format('jadx-gui-{0}-no-jre-win', env.JADX_VERSION) }}
+          # Upload unpacked files for now
+          path: jadx-gui/build/jadx-gui-win/*
+          if-no-files-found: error
+          retention-days: 14
+
+  build-win-bundle:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up JDK
+        uses: oracle-actions/setup-java@v1
+        with:
+          release: 21
+
+      - name: Print Java version
+        shell: bash
+        run: java -version
+
+      - name: Set jadx version
+        shell: bash
+        run: |
+          JADX_REV=$(git rev-list --count HEAD)
+          JADX_VERSION="r${JADX_REV}.${GITHUB_SHA:0:7}"
+          echo "JADX_VERSION=$JADX_VERSION" >> $GITHUB_ENV
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Build
+        run: ./gradlew dist -PbundleJRE=true
+
+      - name: Save Windows with JRE bundle artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ format('jadx-gui-{0}-with-jre-win', env.JADX_VERSION) }}
+          # Upload unpacked files for now
+          path: jadx-gui/build/jadx-gui-with-jre-win/*
+          if-no-files-found: error
+          retention-days: 14

.github/workflows/build-test.yml

@@ -0,0 +1,32 @@
+name: Build Test
+
+on:
+  push:
+    branches: [ master, build-test ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  tests:
+    strategy:
+      matrix:
+        os: [ ubuntu-latest, windows-latest ]
+
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 21
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Build
+        run: ./gradlew build dist distWin
+        env:
+          JADX_BUILD_JAVA_VERSION: 11
+

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,41 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [master]
+  schedule:
+    - cron: '0 9 * * 5'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: ['java']
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        queries: +security-extended
+        languages: ${{ matrix.language }}
+
+    # Don't build tests in jadx-core also skip tests execution and checkstyle tasks
+    - run: |
+        ./gradlew clean build -x checkstyleTest -x checkstyleMain -x test -x ':jadx-core:testClasses'
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3

.github/workflows/release.yml

@@ -0,0 +1,92 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+# additional permissions for provided GitHub token to create new release
+permissions:
+  contents: write
+
+jobs:
+  build-release-win-bundle:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK
+        uses: oracle-actions/setup-java@v1
+        with:
+          release: 23
+
+      - name: Set jadx version
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const jadxVersion = context.ref.split('/').pop().substring(1)
+            core.exportVariable('JADX_VERSION', jadxVersion);
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Build
+        run: ./gradlew dist -PbundleJRE=true
+
+      - name: Save JRE bundle artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ format('jadx-gui-{0}-with-jre-win', env.JADX_VERSION) }}
+          path: ${{ format('build/distWinWithJre/jadx-gui-{0}-with-jre-win.zip', env.JADX_VERSION) }}
+          if-no-files-found: error
+          retention-days: 1
+
+  release:
+    needs: build-release-win-bundle
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up JDK
+        uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 21
+
+      - name: Set jadx version and release name
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const jadxVersion = context.ref.split('/').pop().substring(1)
+            core.exportVariable('JADX_VERSION', jadxVersion);
+
+      - name: Setup Gradle
+        uses: gradle/actions/setup-gradle@v4
+
+      - name: Build
+        run: ./gradlew dist distWin
+        env:
+          JADX_BUILD_JAVA_VERSION: 11
+
+      - name: Download Windows JRE bundle
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ format('jadx-gui-{0}-with-jre-win', env.JADX_VERSION) }}
+          path: ${{ format('build/jadx-gui-{0}-with-jre-win', env.JADX_VERSION) }}
+
+      - run: |
+          cd build
+          pwd
+          ls -l
+          ls jadx-gui-*-with-jre-win
+          mv jadx-gui-*-with-jre-win/jadx-gui-*-with-jre-win.zip .
+          mv distWin/jadx-gui-*-win.zip .
+          ls -l *.zip
+
+      - name: Release
+        uses: softprops/action-gh-release@v2
+        with:
+          name: ${{ env.JADX_VERSION }}
+          draft: true
+          fail_on_unmatched_files: true
+          files: build/jadx-*.zip

.gitignore

@@ -5,23 +5,37 @@
 
 # IntelliJ Idea files
 .idea/
+.run/
 out/
 *.iml
 *.ipr
 *.iws
+.attach_pid*
+*.hprof
+
+**/.DS_Store
 
 bin/
 target/
 build/
+classes/
 idea/
 .gradle/
-gradle.properties
+node_modules/
+.vscode/
 
+jadx-output/
 *-tmp/
+**/tmp/
+*.jobf
+*.jadx
 
-*.dex
 *.class
 *.dump
 *.log
 *.cfg
+*.orig
+quark.json
 
+cliff.toml
+jadx-gui/src/main/resources/logback.xml

.gitlab-ci.yml

@@ -0,0 +1,24 @@
+variables:
+  GRADLE_OPTS: "-Dorg.gradle.daemon=false"
+  TERM: "dumb"
+
+before_script:
+  - chmod +x gradlew
+
+stages:
+  - test
+
+java-11:
+  stage: test
+  image: eclipse-temurin:11
+  script: ./gradlew clean build dist distWin
+
+java-17:
+  stage: test
+  image: eclipse-temurin:17
+  script: ./gradlew clean build dist distWin
+
+java-21:
+  stage: test
+  image: eclipse-temurin:21
+  script: ./gradlew clean build dist distWin

.jitpack.yml

@@ -0,0 +1,5 @@
+jdk:
+  - openjdk11
+install:
+  - echo "Jitpack is not supported. Use artifacts from Maven Central (https://search.maven.org/search?q=jadx), check usage help at https://github.com/skylot/jadx/wiki/Use-jadx-as-a-library"
+  - ./gradlew intentional-fail

.run/jadx-gui.run.xml

@@ -0,0 +1,12 @@
+<component name="ProjectRunConfigurationManager">
+	<configuration default="false" name="jadx-gui" type="Application" factoryName="Application">
+		<option name="MAIN_CLASS_NAME" value="jadx.gui.JadxGUI"/>
+		<module name="jadx.jadx-gui.main"/>
+		<option name="PROGRAM_PARAMETERS" value="-v"/>
+		<option name="VM_PARAMETERS"
+				value="-Xms128M -XX:MaxRAMPercentage=70.0 -Dawt.useSystemAAFontSettings=lcd -Dswing.aatext=true -Djava.util.Arrays.useLegacyMergeSort=true -Djdk.util.zip.disableZip64ExtraFieldValidation=true -XX:+IgnoreUnrecognizedVMOptions --add-opens=java.base/java.lang=ALL-UNNAMED -Dsun.java2d.noddraw=true -Dsun.java2d.d3d=false -Dsun.java2d.ddforcevram=true -Dsun.java2d.ddblit=false -Dswing.useflipBufferStrategy=True"/>
+		<method v="2">
+			<option name="Make" enabled="true"/>
+		</method>
+	</configuration>
+</component>

.travis.yml

@@ -1,12 +0,0 @@
-language: java
-jdk:
-    - oraclejdk7
-    - openjdk7
-    - openjdk6
-before_install:
-    - chmod +x gradlew
-script:
-    - TERM=dumb ./gradlew clean build dist
-notifications:
-    email:
-        - skylot@gmail.com

.typos.toml

@@ -0,0 +1,20 @@
+# Config for 'typos' spellchecker (https://github.com/crate-ci/typos)
+
+[default.extend-words]
+IPUT = "IPUT"
+Laf = "Laf"
+Darcula="Darcula"
+
+[default]
+extend-ignore-identifiers-re = [
+    "finaly", # intentional package name
+]
+
+[files]
+extend-exclude = [
+    "config/",
+    "jadx-core/src/main/resources/",
+    "jadx-core/src/test/",
+    "jadx-gui/src/main/resources/i18n/",
+    "!jadx-gui/src/main/resources/i18n/Messages_en_US.properties",
+]

CODE_OF_CONDUCT.md

@@ -0,0 +1,63 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to make participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, sex characteristics, gender identity and expression,
+level of experience, education, socio-economic status, nationality, personal
+appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies within all project spaces, and it also applies when
+an individual is representing the project or its community in public spaces.
+Examples of representing a project or community include using an official
+project e-mail address, posting via an official social media account, or acting
+as an appointed representative at an online or offline event. Representation of
+a project may be further defined and clarified by project maintainers.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see
+https://www.contributor-covenant.org/faq

CONTRIBUTING.md

@@ -0,0 +1,27 @@
+# Contributing
+
+Please note, we have [code of conduct](CODE_OF_CONDUCT.md), please follow it in all your interactions with the project.
+
+## Open Issue
+
+1. Before proceed, please do:
+    - check [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A) section on wiki
+    - search existing issues by exception message
+
+2. Describe error:
+    - full name of method or class with error
+    - full java stacktrace (no need to copy method fallback code (commented pseudocode))
+    - **IMPORTANT!:** attach or provide link to apk file (double check apk version)
+
+	  **Note**: GitHub don't allow attaching files with `.apk` extension, but you can change extension by adding `.zip` at the end :)
+
+
+## Pull Request Process
+
+1. Please don't submit any code style fixes or dependencies updates changes.
+
+1. Use only features and API from Java 11 or below.
+
+1. Make sure your code is correctly formatted, see description here: [Code Formatting](https://github.com/skylot/jadx/wiki/Code-Formatting).
+
+1. Make sure your changes are passing build: `./gradlew clean build dist`

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,24 +92,60 @@ 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.
 *******************************************************************************
 
 
+ASM library:
+
+*******************************************************************************
+Copyright (c) 2000-2011 INRIA, France Telecom
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holders nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+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
@@ -139,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,54 +1,217 @@
-## JADX 
+<img src="https://raw.githubusercontent.com/skylot/jadx/master/jadx-gui/src/main/resources/logos/jadx-logo.png" width="64" align="left" />
+
+## JADX
+
+![Build status](https://img.shields.io/github/actions/workflow/status/skylot/jadx/build-artifacts.yml)
+![GitHub contributors](https://img.shields.io/github/contributors/skylot/jadx)
+![GitHub all releases](https://img.shields.io/github/downloads/skylot/jadx/total)
+![GitHub release (latest by SemVer)](https://img.shields.io/github/downloads/skylot/jadx/latest/total)
+![Latest release](https://img.shields.io/github/release/skylot/jadx.svg)
+[![Maven Central](https://img.shields.io/maven-central/v/io.github.skylot/jadx-core)](https://search.maven.org/search?q=g:io.github.skylot%20AND%20jadx)
+![Java 11+](https://img.shields.io/badge/Java-11%2B-blue)
+[![License](http://img.shields.io/:license-apache-blue.svg)](http://www.apache.org/licenses/LICENSE-2.0.html)
+
 **jadx** - Dex to Java decompiler
 
-Command line and GUI tools for produce Java source code from Android Dex and Apk files
+Command line and GUI tools for producing Java source code from Android Dex and Apk files
 
-Note: jadx-gui now in experimental stage
+> [!WARNING]
+> Please note that in most cases **jadx** can't decompile all 100% of the code, so errors will occur.<br />
+> Check [Troubleshooting guide](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A#decompilation-issues) for workarounds.
 
+**Main features:**
+- decompile Dalvik bytecode to Java code from APK, dex, aar, aab and zip files
+- decode `AndroidManifest.xml` and other resources from `resources.arsc`
+- deobfuscator included
 
-### Downloads
-- [unstable](https://drone.io/github.com/skylot/jadx/files)
-[![Build Status](https://drone.io/github.com/skylot/jadx/status.png)](https://drone.io/github.com/skylot/jadx/latest)
-[![Build Status](https://travis-ci.org/skylot/jadx.png?branch=master)](https://travis-ci.org/skylot/jadx)
-- from [github](https://github.com/skylot/jadx/releases)
-- from [sourceforge](http://sourceforge.net/projects/jadx/files/) 
+**jadx-gui features:**
+- view decompiled code with highlighted syntax
+- jump to declaration
+- find usage
+- full text search
+- smali debugger, check [wiki page](https://github.com/skylot/jadx/wiki/Smali-debugger) for setup and usage
 
+Jadx-gui key bindings can be found [here](https://github.com/skylot/jadx/wiki/JADX-GUI-Key-bindings)
+
+See these features in action here: [jadx-gui features overview](https://github.com/skylot/jadx/wiki/jadx-gui-features-overview)
+
+<img src="https://user-images.githubusercontent.com/118523/142730720-839f017e-38db-423e-b53f-39f5f0a0316f.png" width="700"/>
+
+### Download
+- release
+  from [github: ![Latest release](https://img.shields.io/github/release/skylot/jadx.svg)](https://github.com/skylot/jadx/releases/latest)
+- latest [unstable build ![GitHub commits since tagged version (branch)](https://img.shields.io/github/commits-since/skylot/jadx/latest/master)](https://nightly.link/skylot/jadx/workflows/build-artifacts/master)
+
+After download unpack zip file go to `bin` directory and run:
+- `jadx` - command line version
+- `jadx-gui` - UI version
+
+On Windows run `.bat` files with double-click\
+**Note:** ensure you have installed Java 11 or later 64-bit version.
+For Windows, you can download it from [oracle.com](https://www.oracle.com/java/technologies/downloads/#jdk17-windows) (select x64 Installer).
+
+### Install
+- Arch Linux
+  [![Arch Linux package](https://img.shields.io/archlinux/v/extra/any/jadx)](https://archlinux.org/packages/extra/any/jadx/)
+  [![AUR Version](https://img.shields.io/aur/version/jadx-git)](https://aur.archlinux.org/packages/jadx-git)
+  ```bash
+  sudo pacman -S jadx
+  ```
+- macOS
+  [![homebrew version](https://img.shields.io/homebrew/v/jadx)](https://formulae.brew.sh/formula/jadx)
+  ```bash
+  brew install jadx
+  ```
+- Flathub
+  [![Flathub Version](https://img.shields.io/flathub/v/com.github.skylot.jadx)](https://flathub.org/apps/com.github.skylot.jadx)
+  ```bash
+  flatpak install flathub com.github.skylot.jadx
+  ```
+
+### Use jadx as a library
+You can use jadx in your java projects, check details on [wiki page](https://github.com/skylot/jadx/wiki/Use-jadx-as-a-library)
+
+### Build from source
+JDK 11 or higher must be installed:
+```
+git clone https://github.com/skylot/jadx.git
+cd jadx
+./gradlew dist
+```
 
-### Building from source  
-    git clone https://github.com/skylot/jadx.git
-    cd jadx
-    ./gradlew dist
-    
 (on Windows, use `gradlew.bat` instead of `./gradlew`)
 
 Scripts for run jadx will be placed in `build/jadx/bin`
 and also packed to `build/jadx-<version>.zip`
 
-
-### Run
-Run **jadx** on itself:
-
-    cd build/jadx/
-    bin/jadx -d out lib/jadx-core-*.jar
-    #or
-    bin/jadx-gui lib/jadx-core-*.jar
-
-
 ### Usage
 ```
-jadx[-gui] [options] <input file> (.dex, .apk or .jar)
+jadx[-gui] [command] [options] <input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab, .xapk, .jadx.kts)
+commands (use '<command> --help' for command options):
+  plugins	  - manage jadx plugins
+
 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
-Example:
- jadx -d out classes.dex
+  -d, --output-dir                      - output directory
+  -ds, --output-dir-src                 - output directory for sources
+  -dr, --output-dir-res                 - output directory for resources
+  -r, --no-res                          - do not decode resources
+  -s, --no-src                          - do not decompile source code
+  --single-class                        - decompile a single class, full name, raw or alias
+  --single-class-output                 - file or dir for write if decompile a single class
+  --output-format                       - can be 'java' or 'json', default: java
+  -e, --export-gradle                   - save as android gradle project
+  -j, --threads-count                   - processing threads count, default: 4
+  -m, --decompilation-mode              - code output mode:
+                                           'auto' - trying best options (default)
+                                           'restructure' - restore code structure (normal java code)
+                                           'simple' - simplified instructions (linear, with goto's)
+                                           'fallback' - raw instructions without modifications
+  --show-bad-code                       - show inconsistent code (incorrectly decompiled)
+  --no-xml-pretty-print                 - do not prettify XML
+  --no-imports                          - disable use of imports, always write entire package name
+  --no-debug-info                       - disable debug info parsing and processing
+  --add-debug-lines                     - add comments with debug line numbers if available
+  --no-inline-anonymous                 - disable anonymous classes inline
+  --no-inline-methods                   - disable methods inline
+  --no-move-inner-classes               - disable move inner classes into parent
+  --no-inline-kotlin-lambda             - disable inline for Kotlin lambdas
+  --no-finally                          - don't extract finally block
+  --no-restore-switch-over-string       - don't restore switch over string
+  --no-replace-consts                   - don't replace constant value with matching constant field
+  --escape-unicode                      - escape non latin characters in strings (with \u)
+  --respect-bytecode-access-modifiers   - don't change original access modifiers
+  --mappings-path                       - deobfuscation mappings file or directory. Allowed formats: Tiny and Tiny v2 (both '.tiny'), Enigma (.mapping) or Enigma directory
+  --mappings-mode                       - set mode for handling the deobfuscation mapping file:
+                                           'read' - just read, user can always save manually (default)
+                                           'read-and-autosave-every-change' - read and autosave after every change
+                                           'read-and-autosave-before-closing' - read and autosave before exiting the app or closing the project
+                                           'ignore' - don't read or save (can be used to skip loading mapping files referenced in the project file)
+  --deobf                               - activate deobfuscation
+  --deobf-min                           - min length of name, renamed if shorter, default: 3
+  --deobf-max                           - max length of name, renamed if longer, default: 64
+  --deobf-whitelist                     - space separated list of classes (full name) and packages (ends with '.*') to exclude from deobfuscation, default: android.support.v4.* android.support.v7.* android.support.v4.os.* android.support.annotation.Px androidx.core.os.* androidx.annotation.Px
+  --deobf-cfg-file                      - deobfuscation mappings file used for JADX auto-generated names (in the JOBF file format), default: same dir and name as input file with '.jobf' extension
+  --deobf-cfg-file-mode                 - set mode for handling the JADX auto-generated names' deobfuscation map file:
+                                           'read' - read if found, don't save (default)
+                                           'read-or-save' - read if found, save otherwise (don't overwrite)
+                                           'overwrite' - don't read, always save
+                                           'ignore' - don't read and don't save
+  --deobf-res-name-source               - better name source for resources:
+                                           'auto' - automatically select best name (default)
+                                           'resources' - use resources names
+                                           'code' - use R class fields names
+  --use-source-name-as-class-name-alias - use source name as class name alias:
+                                           'always' - always use source name if it's available
+                                           'if-better' - use source name if it seems better than the current one
+                                           'never' - never use source name, even if it's available
+  --use-kotlin-methods-for-var-names    - use kotlin intrinsic methods to rename variables, values: disable, apply, apply-and-hide, default: apply
+  --rename-flags                        - fix options (comma-separated list of):
+                                           'case' - fix case sensitivity issues (according to --fs-case-sensitive option),
+                                           'valid' - rename java identifiers to make them valid,
+                                           'printable' - remove non-printable chars from identifiers,
+                                          or single 'none' - to disable all renames
+                                          or single 'all' - to enable all (default)
+  --integer-format                      - how integers are displayed:
+                                           'auto' - automatically select (default)
+                                           'decimal' - use decimal
+                                           'hexadecimal' - use hexadecimal
+  --fs-case-sensitive                   - treat filesystem as case sensitive, false by default
+  --cfg                                 - save methods control flow graph to dot file
+  --raw-cfg                             - save methods control flow graph (use raw instructions)
+  -f, --fallback                        - set '--decompilation-mode' to 'fallback' (deprecated)
+  --use-dx                              - use dx/d8 to convert java bytecode
+  --comments-level                      - set code comments level, values: error, warn, info, debug, user-only, none, default: info
+  --log-level                           - set log level, values: quiet, progress, error, warn, info, debug, default: progress
+  -v, --verbose                         - verbose output (set --log-level to DEBUG)
+  -q, --quiet                           - turn off output (set --log-level to QUIET)
+  --version                             - print jadx version
+  -h, --help                            - print this help
+
+Plugin options (-P<name>=<value>):
+  dex-input: Load .dex and .apk files
+    - dex-input.verify-checksum         - verify dex file checksum before load, values: [yes, no], default: yes
+  java-convert: Convert .class, .jar and .aar files to dex
+    - java-convert.mode                 - convert mode, values: [dx, d8, both], default: both
+    - java-convert.d8-desugar           - use desugar in d8, values: [yes, no], default: no
+  kotlin-metadata: Use kotlin.Metadata annotation for code generation
+    - kotlin-metadata.class-alias       - rename class alias, values: [yes, no], default: yes
+    - kotlin-metadata.method-args       - rename function arguments, values: [yes, no], default: yes
+    - kotlin-metadata.fields            - rename fields, values: [yes, no], default: yes
+    - kotlin-metadata.companion         - rename companion object, values: [yes, no], default: yes
+    - kotlin-metadata.data-class        - add data class modifier, values: [yes, no], default: yes
+    - kotlin-metadata.to-string         - rename fields using toString, values: [yes, no], default: yes
+    - kotlin-metadata.getters           - rename simple getters to field names, values: [yes, no], default: yes
+  rename-mappings: various mappings support
+    - rename-mappings.format            - mapping format, values: [AUTO, TINY_FILE, TINY_2_FILE, ENIGMA_FILE, ENIGMA_DIR, SRG_FILE, XSRG_FILE, JAM_FILE, CSRG_FILE, TSRG_FILE, TSRG_2_FILE, PROGUARD_FILE, RECAF_SIMPLE_FILE, JOBF_FILE], default: AUTO
+    - rename-mappings.invert            - invert mapping on load, values: [yes, no], default: no
+  smali-input: Load .smali files
+    - smali-input.api-level             - Android API level, default: 27
+
+Environment variables:
+  JADX_DISABLE_XML_SECURITY - set to 'true' to disable all security checks for XML files
+  JADX_DISABLE_ZIP_SECURITY - set to 'true' to disable all security checks for zip files
+  JADX_ZIP_MAX_ENTRIES_COUNT - maximum allowed number of entries in zip files (default: 100 000)
+  JADX_CONFIG_DIR - custom config directory, using system by default
+  JADX_CACHE_DIR - custom cache directory, using system by default
+  JADX_TMP_DIR - custom temp directory, using system by default
+
+Examples:
+  jadx -d out classes.dex
+  jadx --rename-flags "none" classes.dex
+  jadx --rename-flags "valid, printable" classes.dex
+  jadx --log-level ERROR app.apk
+  jadx -Pdex-input.verify-checksum=no app.apk
 ```
+These options also work in jadx-gui running from command line and override options from preferences' dialog
 
+### Troubleshooting
+Please check wiki page [Troubleshooting Q&A](https://github.com/skylot/jadx/wiki/Troubleshooting-Q&A)
+
+### Contributing
+To support this project you can:
+  - Post thoughts about new features/optimizations that important to you
+  - Submit decompilation issues, please read before proceed: [Open issue](CONTRIBUTING.md#Open-Issue)
+  - Open pull request, please follow these rules: [Pull Request Process](CONTRIBUTING.md#Pull-Request-Process)
+
+---------------------------------------
 *Licensed under the Apache 2.0 License*
-
-*Copyright 2013 by Skylot*

SECURITY.md

@@ -0,0 +1,8 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+To report a security issue, please open a [new security advisory](https://github.com/skylot/jadx/security/advisories/new).
+Please fill the steps you took to create the issue, affected versions, and, if known, mitigations for the issue.
+We will check and respond within 3 working days.
+If the issue is confirmed as a vulnerability, we will apply required mitigations at the next release.

build.gradle

@@ -1,70 +0,0 @@
-ext.jadxVersion = file('version').readLines().get(0)
-
-apply plugin: 'sonar-runner'
-
-subprojects {
-    apply plugin: 'java'
-    apply plugin: 'idea'
-    apply plugin: 'eclipse'
-
-    sourceCompatibility = 1.6
-    targetCompatibility = 1.6
-
-    version = jadxVersion
-
-    gradle.projectsEvaluated {
-        tasks.withType(Compile) {
-            if (!"${it}".contains(":jadx-samples:")) {
-                options.compilerArgs << "-Xlint" << "-Xlint:unchecked" << "-Xlint:deprecation"
-            }
-        }
-    }
-
-    jar {
-        version = jadxVersion
-        manifest {
-            mainAttributes('jadx-version' : jadxVersion)
-        }
-    }
-
-    dependencies {
-        compile 'org.slf4j:slf4j-api:1.7.5'
-        testCompile 'junit:junit:4.11'
-        testCompile "org.mockito:mockito-core:1.9.5"
-    }
-
-    repositories {
-        mavenCentral()
-    }
-}
-
-task copyArtifacts(type: Sync, dependsOn: ['jadx-cli:installApp', 'jadx-gui:installApp']) {
-    destinationDir file("$buildDir/jadx")
-    ['jadx-cli', 'jadx-gui'].each {
-        from tasks.getByPath(":${it}:installApp").destinationDir
-    }
-}
-
-task pack(type: Zip, dependsOn: copyArtifacts) {
-    destinationDir buildDir
-    archiveName "jadx-${jadxVersion}.zip"
-    from copyArtifacts.destinationDir
-}
-
-task dist(dependsOn: pack) {
-    description = 'Build jadx distribution zip'
-}
-
-task samples(dependsOn: 'jadx-samples:samples') {
-}
-
-task build(dependsOn: [dist, samples]) {
-}
-
-task clean(type: Delete) {
-    delete buildDir
-}
-
-task wrapper(type: Wrapper) {
-    gradleVersion = '1.9'
-}

build.gradle.kts

@@ -0,0 +1,163 @@
+import com.diffplug.gradle.spotless.FormatExtension
+import com.diffplug.gradle.spotless.SpotlessExtension
+import com.diffplug.spotless.LineEnding
+import com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask
+import org.gradle.nativeplatform.platform.internal.DefaultNativePlatform
+import java.util.Locale
+
+plugins {
+	id("com.github.ben-manes.versions") version "0.51.0"
+	id("se.patrikerdes.use-latest-versions") version "0.2.18"
+	id("com.diffplug.spotless") version "6.25.0"
+}
+
+val jadxVersion by extra { System.getenv("JADX_VERSION") ?: "dev" }
+println("jadx version: $jadxVersion")
+version = jadxVersion
+
+val jadxBuildJavaVersion by extra { getBuildJavaVersion() }
+
+fun getBuildJavaVersion(): Int? {
+	val envVarName = "JADX_BUILD_JAVA_VERSION"
+	val buildJavaVer = System.getenv(envVarName)?.toInt() ?: return null
+	if (buildJavaVer < 11) {
+		throw GradleException("'$envVarName' can't be set to lower than 11")
+	}
+	println("Set Java toolchain for jadx build to version '$buildJavaVer'")
+	return buildJavaVer
+}
+
+allprojects {
+	apply(plugin = "java")
+	apply(plugin = "checkstyle")
+	apply(plugin = "com.diffplug.spotless")
+	apply(plugin = "com.github.ben-manes.versions")
+	apply(plugin = "se.patrikerdes.use-latest-versions")
+
+	repositories {
+		mavenCentral()
+	}
+
+	configure<SpotlessExtension> {
+		java {
+			importOrderFile("$rootDir/config/code-formatter/eclipse.importorder")
+			eclipse().configFile("$rootDir/config/code-formatter/eclipse.xml")
+			removeUnusedImports()
+			commonFormatOptions()
+		}
+		kotlin {
+			ktlint().editorConfigOverride(mapOf("indent_style" to "tab"))
+			commonFormatOptions()
+		}
+		kotlinGradle {
+			ktlint()
+			commonFormatOptions()
+		}
+		format("misc") {
+			target("**/*.gradle", "**/*.xml", "**/.gitignore", "**/.properties")
+			targetExclude(".gradle/**", ".idea/**", "*/build/**")
+			commonFormatOptions()
+		}
+	}
+
+	tasks.named<DependencyUpdatesTask>("dependencyUpdates") {
+		rejectVersionIf {
+			// disallow release candidates as upgradable versions from stable versions
+			isNonStable(candidate.version) && !isNonStable(currentVersion)
+		}
+	}
+}
+
+fun FormatExtension.commonFormatOptions() {
+	lineEndings = LineEnding.UNIX
+	encoding = Charsets.UTF_8
+	trimTrailingWhitespace()
+	endWithNewline()
+}
+
+fun isNonStable(version: String): Boolean {
+	val stableKeyword = listOf("RELEASE", "FINAL", "GA").any { version.uppercase(Locale.getDefault()).contains(it) }
+	val regex = "^[0-9,.v-]+(-r)?$".toRegex()
+	val isStable = stableKeyword || regex.matches(version)
+	return isStable.not()
+}
+
+val copyArtifacts by tasks.registering(Copy::class) {
+	val jarCliPattern = "jadx-cli-(.*)-all.jar".toPattern()
+	from(tasks.getByPath(":jadx-cli:installShadowDist")) {
+		exclude("**/*.jar")
+		filter { line ->
+			jarCliPattern.matcher(line).replaceAll("jadx-$1-all.jar")
+				.replace("-jar \"\\\"\$CLASSPATH\\\"\"", "-cp \"\\\"\$CLASSPATH\\\"\" jadx.cli.JadxCLI")
+				.replace("-jar \"%CLASSPATH%\"", "-cp \"%CLASSPATH%\" jadx.cli.JadxCLI")
+		}
+	}
+	val jarGuiPattern = "jadx-gui-(.*)-all.jar".toPattern()
+	from(tasks.getByPath(":jadx-gui:installShadowDist")) {
+		exclude("**/*.jar")
+		filter { line -> jarGuiPattern.matcher(line).replaceAll("jadx-$1-all.jar") }
+	}
+	from(tasks.getByPath(":jadx-gui:installShadowDist")) {
+		include("**/*.jar")
+		rename("jadx-gui-(.*)-all.jar", "jadx-$1-all.jar")
+	}
+	from(layout.projectDirectory) {
+		include("README.md")
+		include("LICENSE")
+	}
+	into(layout.buildDirectory.dir("jadx"))
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+val pack by tasks.registering(Zip::class) {
+	from(copyArtifacts)
+	archiveFileName.set("jadx-$jadxVersion.zip")
+	destinationDirectory.set(layout.buildDirectory)
+}
+
+val distWin by tasks.registering(Zip::class) {
+	group = "jadx"
+	description = "Build Windows bundle"
+
+	val guiTask = tasks.getByPath("jadx-gui:copyDistWin")
+	dependsOn(guiTask)
+	from(guiTask.outputs)
+
+	destinationDirectory.set(layout.buildDirectory.dir("distWin"))
+	archiveFileName.set("jadx-gui-$jadxVersion-win.zip")
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+val distWinWithJre by tasks.registering(Zip::class) {
+	description = "Build Windows with JRE bundle"
+
+	val guiTask = tasks.getByPath(":jadx-gui:copyDistWinWithJre")
+	dependsOn(guiTask)
+	from(guiTask.outputs)
+
+	destinationDirectory.set(layout.buildDirectory.dir("distWinWithJre"))
+	archiveFileName.set("jadx-gui-$jadxVersion-with-jre-win.zip")
+	duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+}
+
+val dist by tasks.registering {
+	group = "jadx"
+	description = "Build jadx distribution zip bundles"
+
+	dependsOn(pack)
+
+	val os = DefaultNativePlatform.getCurrentOperatingSystem()
+	if (os.isWindows) {
+		if (project.hasProperty("bundleJRE")) {
+			println("Build win bundle with JRE")
+			dependsOn(distWinWithJre)
+		} else {
+			dependsOn(distWin)
+		}
+	}
+}
+
+val cleanBuildDir by tasks.registering(Delete::class) {
+	delete(layout.buildDirectory)
+}
+tasks.getByName("clean").dependsOn(cleanBuildDir)

buildSrc/build.gradle.kts

@@ -0,0 +1,13 @@
+plugins {
+	`kotlin-dsl`
+}
+
+dependencies {
+	implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.21")
+
+	implementation("org.openrewrite:plugin:6.19.1")
+}
+
+repositories {
+	gradlePluginPortal()
+}

buildSrc/src/main/kotlin/jadx-java.gradle.kts

@@ -0,0 +1,63 @@
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+
+plugins {
+	java
+	checkstyle
+
+	id("jadx-rewrite")
+}
+
+val jadxVersion: String by rootProject.extra
+val jadxBuildJavaVersion: Int? by rootProject.extra
+
+group = "io.github.skylot"
+version = jadxVersion
+
+dependencies {
+	implementation("org.slf4j:slf4j-api:2.0.16")
+	compileOnly("org.jetbrains:annotations:26.0.1")
+
+	testImplementation("ch.qos.logback:logback-classic:1.5.12")
+	testImplementation("org.assertj:assertj-core:3.26.3")
+
+	testImplementation("org.junit.jupiter:junit-jupiter:5.11.3")
+	testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+
+	testCompileOnly("org.jetbrains:annotations:26.0.1")
+}
+
+repositories {
+	mavenCentral()
+	// required for: aapt-proto, r8, smali
+	google()
+}
+
+java {
+	jadxBuildJavaVersion?.let { buildJavaVer ->
+		toolchain {
+			languageVersion = JavaLanguageVersion.of(buildJavaVer)
+		}
+	}
+	sourceCompatibility = JavaVersion.VERSION_11
+	targetCompatibility = JavaVersion.VERSION_11
+}
+
+tasks {
+	compileJava {
+		options.encoding = "UTF-8"
+	}
+	jar {
+		manifest {
+			attributes("jadx-version" to jadxVersion)
+		}
+	}
+	test {
+		useJUnitPlatform()
+		maxParallelForks = Runtime.getRuntime().availableProcessors()
+		testLogging {
+			showExceptions = true
+			exceptionFormat = TestExceptionFormat.FULL
+			showCauses = true
+		}
+	}
+}

buildSrc/src/main/kotlin/jadx-kotlin.gradle.kts

@@ -0,0 +1,12 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+	id("jadx-java")
+	id("org.jetbrains.kotlin.jvm")
+}
+
+kotlin {
+	compilerOptions {
+		jvmTarget.set(JvmTarget.JVM_11)
+	}
+}

buildSrc/src/main/kotlin/jadx-library.gradle.kts

@@ -0,0 +1,81 @@
+plugins {
+	id("jadx-java")
+	id("java-library")
+	id("maven-publish")
+	id("signing")
+}
+
+val jadxVersion: String by rootProject.extra
+
+group = "io.github.skylot"
+version = jadxVersion
+
+java {
+	withJavadocJar()
+	withSourcesJar()
+}
+
+publishing {
+	publications {
+		create<MavenPublication>("mavenJava") {
+			artifactId = project.name
+			from(components["java"])
+			versionMapping {
+				usage("java-api") {
+					fromResolutionOf("runtimeClasspath")
+				}
+				usage("java-runtime") {
+					fromResolutionResult()
+				}
+			}
+			pom {
+				name.set(project.name)
+				description.set(project.description ?: "Dex to Java decompiler")
+				url.set("https://github.com/skylot/jadx")
+				licenses {
+					license {
+						name.set("The Apache License, Version 2.0")
+						url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
+					}
+				}
+				developers {
+					developer {
+						id.set("skylot")
+						name.set("Skylot")
+						email.set(project.properties["libEmail"].toString())
+						url.set("https://github.com/skylot")
+					}
+				}
+				scm {
+					connection.set("scm:git:git://github.com/skylot/jadx.git")
+					developerConnection.set("scm:git:ssh://github.com:skylot/jadx.git")
+					url.set("https://github.com/skylot/jadx")
+				}
+			}
+		}
+	}
+	repositories {
+		maven {
+			val releasesRepoUrl = uri("https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/")
+			val snapshotsRepoUrl = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/")
+			url = if (version.toString().endsWith("SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl
+			credentials {
+				username = project.properties["ossrhUser"].toString()
+				password = project.properties["ossrhPassword"].toString()
+			}
+		}
+	}
+}
+
+signing {
+	isRequired = gradle.taskGraph.hasTask("publish")
+	sign(publishing.publications["mavenJava"])
+}
+
+
+tasks.javadoc {
+	val stdOptions = options as StandardJavadocDocletOptions
+	stdOptions.addBooleanOption("html5", true)
+	// disable 'missing' warnings
+	stdOptions.addStringOption("Xdoclint:all,-missing", "-quiet")
+}

buildSrc/src/main/kotlin/jadx-rewrite.gradle.kts

@@ -0,0 +1,37 @@
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+
+plugins {
+	id("org.openrewrite.rewrite")
+}
+
+repositories {
+	mavenCentral()
+}
+
+dependencies {
+	rewrite("org.openrewrite.recipe:rewrite-testing-frameworks:2.21.0")
+	rewrite("org.openrewrite.recipe:rewrite-logging-frameworks:2.15.1")
+	rewrite("org.openrewrite.recipe:rewrite-migrate-java:2.28.0")
+	rewrite("org.openrewrite.recipe:rewrite-static-analysis:1.19.0")
+}
+
+tasks {
+	rewrite {
+		// exclusion("src/test/java/jadx/tests/integration")
+
+		// activeRecipe("org.openrewrite.java.migrate.Java8toJava11")
+
+		// checkstyle auto fix
+		// activeRecipe("org.openrewrite.staticanalysis.CodeCleanup")
+		// setCheckstyleConfigFile(file("$rootDir/config/checkstyle/checkstyle.xml"))
+
+		// logging
+		// activeRecipe("org.openrewrite.java.logging.slf4j.Slf4jBestPractices")
+		// activeRecipe("org.openrewrite.java.logging.slf4j.LoggersNamedForEnclosingClass")
+		// activeRecipe("org.openrewrite.java.logging.slf4j.ParameterizedLogging")
+		// activeRecipe("org.openrewrite.java.logging.PrintStackTraceToLogError")
+
+		// testing
+		activeRecipe("org.openrewrite.java.testing.assertj.Assertj")
+	}
+}

config/checkstyle/checkstyle.xml

@@ -0,0 +1,141 @@
+<?xml version="1.0" ?>
+
+<!DOCTYPE module PUBLIC
+		"-//Puppy Crawl//DTD Check Configuration 1.2//EN"
+		"http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
+
+<module name="Checker">
+	<property name="fileExtensions" value="java, properties, xml"/>
+	<property name="charset" value="UTF-8"/>
+
+	<module name="TreeWalker">
+		<property name="tabWidth" value="4"/>
+		<module name="RegexpSinglelineJava">
+			<property name="format" value="^\t* "/>
+			<property name="message" value="Indent must use tab characters"/>
+			<property name="ignoreComments" value="true"/>
+		</module>
+		<module name="RegexpSinglelineJava">
+			<property name="format" value="^(?!\s+\* $).*?\s+$"/>
+			<property name="message" value="Line has trailing spaces."/>
+		</module>
+		<module name="AvoidEscapedUnicodeCharacters">
+			<property name="allowEscapesForControlCharacters" value="true"/>
+			<property name="allowByTailComment" value="true"/>
+			<property name="allowNonPrintableEscapes" value="true"/>
+		</module>
+
+		<module name="EmptyLineSeparator">
+			<property name="allowNoEmptyLineBetweenFields" value="true"/>
+			<property name="allowMultipleEmptyLines" value="false"/>
+		</module>
+
+		<!-- whitespaces -->
+		<module name="SingleSpaceSeparator"/>
+		<module name="GenericWhitespace"/>
+		<module name="MethodParamPad"/>
+		<module name="NoWhitespaceBefore"/>
+		<module name="OperatorWrap"/>
+		<module name="ParenPad"/>
+		<module name="TypecastParenPad"/>
+		<module name="WhitespaceAfter"/>
+		<module name="WhitespaceAround">
+			<property name="allowEmptyMethods" value="true"/>
+		</module>
+		<!-- <module name="EmptyForIteratorPad"/> -->
+		<!-- <module name="NoWhitespaceAfter"/>-->
+
+		<module name="NoLineWrap"/>
+
+		<module name="IllegalImport"/> <!-- defaults to sun.* packages -->
+		<module name="RedundantImport"/>
+		<module name="UnusedImports"/>
+		<!-- <module name="AvoidStarImport"/> -->
+
+		<module name="NeedBraces"/>
+		<module name="LeftCurly"/>
+		<module name="RightCurly"/>
+		<module name="EmptyCatchBlock">
+			<property name="exceptionVariableName" value="expected|ignore"/>
+		</module>
+
+		<!-- naming -->
+		<module name="PackageName"/>
+		<module name="TypeName"/>
+		<module name="InterfaceTypeParameterName"/>
+		<module name="ClassTypeParameterName"/>
+		<module name="StaticVariableName"/>
+		<module name="ConstantName"/>
+		<module name="MemberName"/>
+		<module name="MethodName"/>
+		<module name="MethodTypeParameterName"/>
+		<module name="ParameterName"/>
+		<module name="LambdaParameterName"/>
+		<module name="LocalVariableName"/>
+		<module name="LocalFinalVariableName"/>
+		<module name="CatchParameterName"/>
+		<!-- <module name="HiddenField"/> -->
+
+		<!-- annotations -->
+		<module name="AnnotationLocation"/>
+		<module name="AnnotationUseStyle">
+			<property name="elementStyle" value="compact"/>
+		</module>
+		<module name="MissingOverride"/>
+		<!-- <module name="MissingDeprecated"/> -->
+
+		<module name="ModifierOrder"/>
+		<!-- <module name="RedundantModifier"/> -->
+		<!-- <module name="ParameterNumber"/> -->
+
+		<module name="EmptyStatement"/>
+		<module name="DefaultComesLast"/>
+		<module name="EqualsHashCode"/>
+		<module name="FallThrough"/>
+		<!-- <module name="IllegalCatch"/> -->
+		<module name="IllegalThrows"/>
+		<module name="IllegalType"/>
+		<module name="InnerAssignment"/>
+		<module name="MultipleVariableDeclarations"/>
+		<module name="NoClone"/>
+		<module name="NoFinalizer"/>
+		<module name="OneStatementPerLine"/>
+		<module name="PackageDeclaration"/>
+		<module name="StringLiteralEquality"/>
+
+		<!-- design -->
+		<module name="OneTopLevelClass"/>
+		<module name="MutableException"/>
+		<module name="InterfaceIsType"/>
+		<module name="ThrowsCount">
+			<property name="max" value="2"/>
+		</module>
+
+		<!-- misc -->
+		<module name="ArrayTypeStyle"/>
+		<module name="OuterTypeFilename"/>
+
+		<!-- sizes -->
+		<module name="OuterTypeNumber"/>
+
+		<module name="SuppressWarningsHolder"/>
+
+		<module name="IllegalType">
+			<property name="illegalClassNames" value="java.util.ArrayList, java.util.HashMap, java.util.HashSet,
+				 java.util.LinkedHashMap, java.util.LinkedHashSet, java.util.TreeMap, java.util.TreeSet"/>
+		</module>
+		<module name="IllegalImport">
+			<property name="illegalClasses" value="jadx.core.utils.DebugUtils"/>
+		</module>
+		<module name="RegexpSinglelineJava">
+			<property name="id" value="printstacktrace"/>
+			<property name="format" value="\.printStackTrace\(\)"/>
+			<property name="ignoreComments" value="true"/>
+			<property name="message"
+					  value="Using Throwable.printStackTrace() is forbidden. Use logger to print exception"/>
+		</module>
+	</module>
+
+	<module name="NewlineAtEndOfFile"/>
+	<module name="SuppressWarningsFilter"/>
+</module>

config/code-formatter/eclipse.importorder

@@ -0,0 +1,8 @@
+#Import Order
+0=java
+1=javax
+2=org
+3=com
+4=
+5=jadx
+6=\#

config/code-formatter/eclipse.xml

@@ -0,0 +1,400 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<profiles version="23">
+    <profile kind="CodeFormatterProfile" name="jadx eclipse" version="23">
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_ellipsis" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_javadoc_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indentation.size" value="4"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_with_spaces" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.continuation_indentation" value="2"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_before_code_block" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_switch_case_expressions" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_package" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_root_tags" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.enabling_tag" value="@formatter:on"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_record_components" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_logical_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_record_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_abstract_method" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_enum_constant_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_switch_case_expressions" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_shift_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_code_block" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_parameters" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_loops" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_switch_case_arrow_operator" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_unary_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation" value="separate_lines_if_wrapped"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_ellipsis" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_enum_constant" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.text_block_indentation" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_type_members_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_assignment" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_module_statements" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_permitted_types" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block_in_case" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_annotations" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_assertion_message_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_method_declaration" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines" value="2147483647"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_resources_in_try" value="80"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_source_code" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_field" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_method" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_not_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_html" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_if" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_empty_lines" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_arguments" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_unary_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_package" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_label" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_permitted_types_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_record_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_tag_description" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_record_constructor" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_string_concatenation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_multiple_fields" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_array_initializer" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_shift_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_shift_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_record_components" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_additive_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_lines_in_comments" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_record_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_relational_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_import_groups" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_logical_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_imports" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_record_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_default" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.disabling_tag" value="@formatter:off"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_enum_constants" value="48"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_imports" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_method_body" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_switch_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_block" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_arrow" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.line_length" value="100"/>
+        <setting id="org.eclipse.jdt.core.formatter.use_on_off_tags" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_method_body_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_method_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_additive_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_constructor" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_relational_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_record_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_lambda_body" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.compact_else_if" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_parameter" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_relational_operator" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_additive_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_line_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_selector_in_method_invocation_on_expression_first_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_record_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_switch_case_with_arrow_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_colon" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_after_code_block" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression" value="48"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_type" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_local_variable" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_default" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_additive_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_wrapped_lines" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_field" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_conditional_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_shift_operator" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_code_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_record_components" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.tabulation.size" value="4"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer" value="2"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_record_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_assignment_operator" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_switch" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_switch_case_with_arrow" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_method" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_record_constructor_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_assertion_message" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_member_type" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_logical_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_record_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_relational_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_block_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_last_class_body_declaration" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_body" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_logical_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_statement_group_in_switch" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_permitted_types" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_constant" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_type_declaration" value="end_of_line"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_package" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_parameter_description" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_code_block" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.tabulation.char" value="tab"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_string_concatenation" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.lineSplit" value="140"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch" value="insert"/>
+    </profile>
+</profiles>

config/jflex/.gitignore

@@ -0,0 +1 @@
+SmaliTokenMaker.java

config/jflex/README.md

@@ -0,0 +1,5 @@
+Refer to the following instructions to modify and use to generate SmaliTokenMarker
+
+```shell
+jflex SmaliTokenMaker.flex --skel skeleton.default
+```

config/jflex/SmaliTokenMaker.flex

@@ -0,0 +1,679 @@
+/*
+ * Generated on 11/22/21, 8:58 PM
+ */
+package jadx.gui.ui.codearea;
+
+import java.io.*;
+import javax.swing.text.Segment;
+
+import org.fife.ui.rsyntaxtextarea.*;
+
+
+/*
+ * 用于Smali代码高亮
+ * MartinKay@qq.com
+ */
+%%
+
+%public
+%class SmaliTokenMaker
+%extends AbstractJFlexCTokenMaker
+%unicode
+/* Case sensitive */
+%type org.fife.ui.rsyntaxtextarea.Token
+
+
+%{
+
+
+	/**
+	 * Constructor.  This must be here because JFlex does not generate a
+	 * no-parameter constructor.
+	 */
+	public SmaliTokenMaker() {
+	}
+
+
+	/**
+	 * Adds the token specified to the current linked list of tokens.
+	 *
+	 * @param tokenType The token's type.
+	 * @see #addToken(int, int, int)
+	 */
+	private void addHyperlinkToken(int start, int end, int tokenType) {
+		int so = start + offsetShift;
+		addToken(zzBuffer, start,end, tokenType, so, true);
+	}
+
+
+	/**
+	 * Adds the token specified to the current linked list of tokens.
+	 *
+	 * @param tokenType The token's type.
+	 */
+	private void addToken(int tokenType) {
+		addToken(zzStartRead, zzMarkedPos-1, tokenType);
+	}
+
+
+	/**
+	 * Adds the token specified to the current linked list of tokens.
+	 *
+	 * @param tokenType The token's type.
+	 * @see #addHyperlinkToken(int, int, int)
+	 */
+	private void addToken(int start, int end, int tokenType) {
+		int so = start + offsetShift;
+		addToken(zzBuffer, start,end, tokenType, so, false);
+	}
+
+
+	/**
+	 * Adds the token specified to the current linked list of tokens.
+	 *
+	 * @param array The character array.
+	 * @param start The starting offset in the array.
+	 * @param end The ending offset in the array.
+	 * @param tokenType The token's type.
+	 * @param startOffset The offset in the document at which this token
+	 *        occurs.
+	 * @param hyperlink Whether this token is a hyperlink.
+	 */
+	public void addToken(char[] array, int start, int end, int tokenType,
+						int startOffset, boolean hyperlink) {
+		super.addToken(array, start,end, tokenType, startOffset, hyperlink);
+		zzStartRead = zzMarkedPos;
+	}
+
+
+	/**
+	 * {@inheritDoc}
+	 */
+	public String[] getLineCommentStartAndEnd(int languageIndex) {
+		return new String[] { "#", null };
+	}
+
+
+	/**
+	 * Returns the first token in the linked list of tokens generated
+	 * from <code>text</code>.  This method must be implemented by
+	 * subclasses so they can correctly implement syntax highlighting.
+	 *
+	 * @param text The text from which to get tokens.
+	 * @param initialTokenType The token type we should start with.
+	 * @param startOffset The offset into the document at which
+	 *        <code>text</code> starts.
+	 * @return The first <code>Token</code> in a linked list representing
+	 *         the syntax highlighted text.
+	 */
+	public Token getTokenList(Segment text, int initialTokenType, int startOffset) {
+
+		resetTokenList();
+		this.offsetShift = -text.offset + startOffset;
+
+		// Start off in the proper state.
+		int state = Token.NULL;
+		switch (initialTokenType) {
+			/* No multi-line comments */
+			/* No documentation comments */
+			default:
+				state = Token.NULL;
+		}
+
+		s = text;
+		try {
+			yyreset(zzReader);
+			yybegin(state);
+			return yylex();
+		} catch (IOException ioe) {
+			ioe.printStackTrace();
+			return new TokenImpl();
+		}
+
+	}
+
+
+	/**
+	 * Refills the input buffer.
+	 *
+	 * @return      <code>true</code> if EOF was reached, otherwise
+	 *              <code>false</code>.
+	 */
+	private boolean zzRefill() {
+		return zzCurrentPos>=s.offset+s.count;
+	}
+
+
+	/**
+	 * Resets the scanner to read from a new input stream.
+	 * Does not close the old reader.
+	 *
+	 * All internal variables are reset, the old input stream
+	 * <b>cannot</b> be reused (internal buffer is discarded and lost).
+	 * Lexical state is set to <tt>YY_INITIAL</tt>.
+	 *
+	 * @param reader   the new input stream
+	 */
+	public final void yyreset(Reader reader) {
+		// 's' has been updated.
+		zzBuffer = s.array;
+		/*
+		 * We replaced the line below with the two below it because zzRefill
+		 * no longer "refills" the buffer (since the way we do it, it's always
+		 * "full" the first time through, since it points to the segment's
+		 * array).  So, we assign zzEndRead here.
+		 */
+		//zzStartRead = zzEndRead = s.offset;
+		zzStartRead = s.offset;
+		zzEndRead = zzStartRead + s.count - 1;
+		zzCurrentPos = zzMarkedPos = zzPushbackPos = s.offset;
+		zzLexicalState = YYINITIAL;
+		zzReader = reader;
+		zzAtBOL  = true;
+		zzAtEOF  = false;
+	}
+
+%}
+
+Letter							= [A-Za-z]
+LetterOrUnderscore				= ({Letter}|"_")
+NonzeroDigit						= [1-9]
+Digit							= ("0"|{NonzeroDigit})
+HexDigit							= ({Digit}|[A-Fa-f])
+OctalDigit						= ([0-7])
+AnyCharacterButApostropheOrBackSlash	= ([^\\'])
+AnyCharacterButDoubleQuoteOrBackSlash	= ([^\\\"\n])
+EscapedSourceCharacter				= ("u"{HexDigit}{HexDigit}{HexDigit}{HexDigit})
+Escape							= ("\\"(([btnfr\"'\\])|([0123]{OctalDigit}?{OctalDigit}?)|({OctalDigit}{OctalDigit}?)|{EscapedSourceCharacter}))
+NonSeparator						= ([^\t\f\r\n\ \(\)\{\}\[\]\;\,\.\=\>\<\!\~\?\:\+\-\*\/\&\|\^\%\"\']|"#"|"\\")
+IdentifierStart					= ({LetterOrUnderscore}|"$")
+IdentifierPart						= ({IdentifierStart}|{Digit}|("\\"{EscapedSourceCharacter}))
+
+LineTerminator				= (\n)
+WhiteSpace				= ([ \t\f]+)
+
+CharLiteral	= ([\']({AnyCharacterButApostropheOrBackSlash}|{Escape})[\'])
+UnclosedCharLiteral			= ([\'][^\'\n]*)
+ErrorCharLiteral			= ({UnclosedCharLiteral}[\'])
+StringLiteral				= ([\"]({AnyCharacterButDoubleQuoteOrBackSlash}|{Escape})*[\"])
+UnclosedStringLiteral		= ([\"]([\\].|[^\\\"])*[^\"]?)
+ErrorStringLiteral			= ({UnclosedStringLiteral}[\"])
+
+/* No multi-line comments */
+/* No documentation comments */
+LineCommentBegin			= "#"
+
+IntegerLiteral			= ({Digit}+)
+HexLiteral			= (0x{HexDigit}+)
+FloatLiteral			= (({Digit}+)("."{Digit}+)?(e[+-]?{Digit}+)? | ({Digit}+)?("."{Digit}+)(e[+-]?{Digit}+)?)
+ErrorNumberFormat			= (({IntegerLiteral}|{HexLiteral}|{FloatLiteral}){NonSeparator}+)
+BooleanLiteral				= ("true"|"false")
+
+Separator					= ([\(\)\{\}\[\]])
+Separator2				= ([\;,.])
+
+Identifier				= ({IdentifierStart}{IdentifierPart}*)
+
+URLGenDelim				= ([:\/\?#\[\]@])
+URLSubDelim				= ([\!\$&'\(\)\*\+,;=])
+URLUnreserved			= ({LetterOrUnderscore}|{Digit}|[\-\.\~])
+URLCharacter			= ({URLGenDelim}|{URLSubDelim}|{URLUnreserved}|[%])
+URLCharacters			= ({URLCharacter}*)
+URLEndCharacter			= ([\/\$]|{Letter}|{Digit})
+URL						= (((https?|f(tp|ile))"://"|"www.")({URLCharacters}{URLEndCharacter})?)
+
+
+/*  Custom Regex  */
+/* fully-qualified name Rules  */
+SimpleName = ([a-zA-Z0-9_$]*)
+QUALIFIED_TYPE_NAME = ("L"({SimpleName}{SLASH})*{SimpleName}*";")
+/* Types */
+VOID_TYPE = ("V")
+BOOLEAN_TYPE = ("Z")
+BYTE_TYPE = ("B")
+SHORT_TYPE = ("S")
+CHAR_TYPE = ("C")
+INT_TYPE = ("I")
+LONG_TYPE = ("J")
+FLOAT_TYPE = ("F")
+DOUBLE_TYPE = ("D")
+/* Multi Args Types Highlight  */
+MULTI_ARGS_TYPES = (({BOOLEAN_TYPE}|{BYTE_TYPE}|{SHORT_TYPE}|{CHAR_TYPE}|{INT_TYPE}|{LONG_TYPE}|{FLOAT_TYPE}|{DOUBLE_TYPE})+);
+
+/* Types fully-qualified name */
+COMPOUND_METHOD_ARG_LITERAL = (({BOOLEAN_TYPE}|{BYTE_TYPE}|{SHORT_TYPE}|{CHAR_TYPE}|{INT_TYPE}|{LONG_TYPE}|{FLOAT_TYPE}|{DOUBLE_TYPE})+{QUALIFIED_TYPE_NAME})
+
+
+LBRACK = ("[")
+RBRACK = ("]")
+LPAREN = ("(")
+RPAREN = (")")
+LBRACE = ("{")
+RBRACE = ("}")
+COLON = (":")
+ASSIGN = ("=")
+DOT = (".")
+SUB = ("-")
+COMMA = (",")
+SLASH = ("/")
+LT = ("<")
+GT = (">")
+ARROW = ("->")
+SEMI = (";")
+ARROW_FUNCTION = ({ARROW}[a-zA-Z_$<>]*)
+CustomSeparator = ({Separator}|{ARROW_FUNCTION})
+
+/* Register */
+VREGISTER = ("v"("0"|[1-9])*)
+PREGISTER = ("p"("0"|[1-9])*)
+
+/* Flags  */
+FLAG_PSWITCH = (":pswitch_"{SimpleName})
+FLAG_PSWITCH_DATA = (":pswitch_data_"{SimpleName})
+FLAG_GOTO = (":goto_"{SimpleName})
+FLAG_COND = (":cond_"{SimpleName})
+FLAG_TRY_START = (":try_start_"{SimpleName})
+FLAG_TRY_END = (":try_end_"{SimpleName})
+FLAG_CATCH = (":catch_"{SimpleName})
+FLAG_CATCHALL = (":catchall_"{SimpleName})
+FLAG_ARRAY = (":array_"{SimpleName})
+
+/* No string state */
+/* No char state */
+/* No MLC state */
+/* No documentation comment state */
+%state EOL_COMMENT
+
+%%
+
+<YYINITIAL> {
+
+	/* Keywords Instructions Highlight */
+"nop" |
+"move" |
+"move/from16" |
+"move/16" |
+"move-wide" |
+"move-wide/from16" |
+"move-wide/16" |
+"move-object" |
+"move-object/from16" |
+"move-object/16" |
+"move-result" |
+"move-result-wide" |
+"move-result-object" |
+"move-exception" |
+"return-void" |
+"return" |
+"return-wide" |
+"return-object" |
+"const/4" |
+"const/16" |
+"const" |
+"const/high16" |
+"const-wide/16" |
+"const-wide/32" |
+"const-wide" |
+"const-wide/high16" |
+"const-string" |
+"const-string/jumbo" |
+"const-class" |
+"monitor-enter" |
+"monitor-exit" |
+"check-cast" |
+"instance-of" |
+"array-length" |
+"new-instance" |
+"new-array" |
+"filled-new-array" |
+"filled-new-array/range" |
+"fill-array-data" |
+"throw" |
+"goto" |
+"goto/16" |
+"goto/32" |
+"cmpl-float" |
+"cmpg-float" |
+"cmpl-double" |
+"cmpg-double" |
+"cmp-long" |
+"if-eq" |
+"if-ne" |
+"if-lt" |
+"if-ge" |
+"if-gt" |
+"if-le" |
+"if-eqz" |
+"if-nez" |
+"if-ltz" |
+"if-gez" |
+"if-gtz" |
+"if-lez" |
+"aget" |
+"aget-wide" |
+"aget-object" |
+"aget-boolean" |
+"aget-byte" |
+"aget-char" |
+"aget-short" |
+"aput" |
+"aput-wide" |
+"aput-object" |
+"aput-boolean" |
+"aput-byte" |
+"aput-char" |
+"aput-short" |
+"iget" |
+"iget-wide" |
+"iget-object" |
+"iget-boolean" |
+"iget-byte" |
+"iget-char" |
+"iget-short" |
+"iput" |
+"iput-wide" |
+"iput-object" |
+"iput-boolean" |
+"iput-byte" |
+"iput-char" |
+"iput-short" |
+"sget" |
+"sget-wide" |
+"sget-object" |
+"sget-boolean" |
+"sget-byte" |
+"sget-char" |
+"sget-short" |
+"sput" |
+"sput-wide" |
+"sput-object" |
+"sput-boolean" |
+"sput-byte" |
+"sput-char" |
+"sput-short" |
+"invoke-virtual" |
+"invoke-super" |
+"invoke-direct" |
+"invoke-static" |
+"invoke-interface" |
+"invoke-virtual/range" |
+"invoke-super/range" |
+"invoke-direct/range" |
+"invoke-static/range" |
+"invoke-interface/range" |
+"neg-int" |
+"not-int" |
+"neg-long" |
+"not-long" |
+"neg-float" |
+"neg-double" |
+"int-to-long" |
+"int-to-float" |
+"int-to-double" |
+"long-to-int" |
+"long-to-float" |
+"long-to-double" |
+"float-to-int" |
+"float-to-long" |
+"float-to-double" |
+"double-to-int" |
+"double-to-long" |
+"double-to-float" |
+"int-to-byte" |
+"int-to-char" |
+"int-to-short" |
+"add-int" |
+"sub-int" |
+"mul-int" |
+"div-int" |
+"rem-int" |
+"and-int" |
+"or-int" |
+"xor-int" |
+"shl-int" |
+"shr-int" |
+"ushr-int" |
+"add-long" |
+"sub-long" |
+"mul-long" |
+"div-long" |
+"rem-long" |
+"and-long" |
+"or-long" |
+"xor-long" |
+"shl-long" |
+"shr-long" |
+"ushr-long" |
+"add-float" |
+"sub-float" |
+"mul-float" |
+"div-float" |
+"rem-float" |
+"add-double" |
+"sub-double" |
+"mul-double" |
+"div-double" |
+"rem-double" |
+"add-int/2addr" |
+"sub-int/2addr" |
+"mul-int/2addr" |
+"div-int/2addr" |
+"rem-int/2addr" |
+"and-int/2addr" |
+"or-int/2addr" |
+"xor-int/2addr" |
+"shl-int/2addr" |
+"shr-int/2addr" |
+"ushr-int/2addr" |
+"add-long/2addr" |
+"sub-long/2addr" |
+"mul-long/2addr" |
+"div-long/2addr" |
+"rem-long/2addr" |
+"and-long/2addr" |
+"or-long/2addr" |
+"xor-long/2addr" |
+"shl-long/2addr" |
+"shr-long/2addr" |
+"ushr-long/2addr" |
+"add-float/2addr" |
+"sub-float/2addr" |
+"mul-float/2addr" |
+"div-float/2addr" |
+"rem-float/2addr" |
+"add-double/2addr" |
+"sub-double/2addr" |
+"mul-double/2addr" |
+"div-double/2addr" |
+"rem-double/2addr" |
+"add-int/lit16" |
+"rsub-int" |
+"mul-int/lit16" |
+"div-int/lit16" |
+"rem-int/lit16" |
+"and-int/lit16" |
+"or-int/lit16" |
+"xor-int/lit16" |
+"add-int/lit8" |
+"rsub-int/lit8" |
+"mul-int/lit8" |
+"div-int/lit8" |
+"rem-int/lit8" |
+"and-int/lit8" |
+"or-int/lit8" |
+"xor-int/lit8" |
+"shl-int/lit8" |
+"shr-int/lit8" |
+"ushr-int/lit8" |
+"invoke-polymorphic" |
+"invoke-polymorphic/range" |
+"invoke-custom" |
+"invoke-custom/range" |
+"const-method-handle" |
+"const-method-type" |
+"packed-switch" |
+"sparse-switch"		{ addToken(Token.FUNCTION); }
+
+	/* Keywords Modifiers(IDENTIFIER标识符、修饰符) Highlight */
+"public" |
+"private" |
+"protected" |
+"final" |
+"annotation" |
+"static" |
+"synthetic" |
+"constructor" |
+"abstract" |
+"enum" |
+"interface" |
+"transient" |
+"bridge" |
+"declared-synchronized" |
+"volatile" |
+"strictfp" |
+"varargs" |
+"native"		{ addToken(Token.RESERVED_WORD); }
+
+
+
+
+	/* Keywords Directives Highlight */
+".method" |
+".end method" |
+".implements" |
+".class" |
+".prologue" |
+".source" |
+".super" |
+".field" |
+".end field" |
+".registers" |
+".locals" |
+".param" |
+".line" |
+".catch" |
+".catchall" |
+".annotation" |
+".end annotation" |
+".local" |
+".end local" |
+".restart local" |
+".packed-switch" |
+".end packed-switch" |
+".array-data" |
+".end array-data" |
+".sparse-switch" |
+".end sparse-switch" |
+".end param"		{ addToken(Token.RESERVED_WORD_2); }
+
+
+	/* VARIABLE Register Highlight */
+{VREGISTER} |
+{PREGISTER}		{ addToken(Token.VARIABLE); }
+
+
+
+	/* Data types Highlight */
+{QUALIFIED_TYPE_NAME} |
+{COMPOUND_METHOD_ARG_LITERAL} |
+{MULTI_ARGS_TYPES} |
+{QUALIFIED_TYPE_NAME} |
+{VOID_TYPE} |
+{BOOLEAN_TYPE} |
+{BYTE_TYPE} |
+{SHORT_TYPE} |
+{CHAR_TYPE} |
+{INT_TYPE} |
+{LONG_TYPE} |
+{FLOAT_TYPE} |
+{DOUBLE_TYPE} 	{ addToken(Token.DATA_TYPE); }
+
+ /* FLAGS */
+{FLAG_PSWITCH} |
+{FLAG_PSWITCH_DATA} |
+{FLAG_GOTO} |
+{FLAG_COND} |
+{FLAG_TRY_START} |
+{FLAG_TRY_END} |
+{FLAG_CATCHALL} |
+{FLAG_ARRAY} |
+{FLAG_CATCH}  	{ addToken(Token.MARKUP_TAG_NAME); }
+
+	/* Functions */
+	/* No functions */
+
+	{BooleanLiteral}			{ addToken(Token.LITERAL_BOOLEAN); }
+
+	{LineTerminator}				{ addNullToken(); return firstToken; }
+
+	{Identifier}					{ addToken(Token.IDENTIFIER); }
+
+	{WhiteSpace}					{ addToken(Token.WHITESPACE); }
+
+	/* String/Character literals. */
+	{CharLiteral}				{ addToken(Token.LITERAL_CHAR); }
+{UnclosedCharLiteral}		{ addToken(Token.ERROR_CHAR); addNullToken(); return firstToken; }
+{ErrorCharLiteral}			{ addToken(Token.ERROR_CHAR); }
+	{StringLiteral}				{ addToken(Token.LITERAL_STRING_DOUBLE_QUOTE); }
+{UnclosedStringLiteral}		{ addToken(Token.ERROR_STRING_DOUBLE); addNullToken(); return firstToken; }
+{ErrorStringLiteral}			{ addToken(Token.ERROR_STRING_DOUBLE); }
+
+	/* Comment literals. */
+	/* No multi-line comments */
+	/* No documentation comments */
+	{LineCommentBegin}			{ start = zzMarkedPos-1; yybegin(EOL_COMMENT); }
+
+	/* Separators. */
+	{CustomSeparator}					{ addToken(Token.SEPARATOR); }
+	{Separator2}					{ addToken(Token.IDENTIFIER); }
+
+	/* Operators. */
+"!" |
+";" |
+"." |
+"=" |
+"/" |
+"'" |
+"(" |
+")" |
+"," |
+"->" |
+";->" |
+"<" |
+">" |
+"@" |
+"[" |
+"]" |
+"{" |
+"}"		{ addToken(Token.OPERATOR); }
+
+	/* Numbers */
+	{IntegerLiteral}				{ addToken(Token.LITERAL_NUMBER_DECIMAL_INT); }
+	{HexLiteral}					{ addToken(Token.LITERAL_NUMBER_HEXADECIMAL); }
+	{FloatLiteral}					{ addToken(Token.LITERAL_NUMBER_FLOAT); }
+	{ErrorNumberFormat}			{ addToken(Token.ERROR_NUMBER_FORMAT); }
+
+	/* Ended with a line not in a string or comment. */
+	<<EOF>>						{ addNullToken(); return firstToken; }
+
+	/* Catch any other (unhandled) characters. */
+	.							{ addToken(Token.IDENTIFIER); }
+
+}
+
+
+/* No char state */
+
+/* No string state */
+
+/* No multi-line comment state */
+
+/* No documentation comment state */
+
+<EOL_COMMENT> {
+	[^hwf\n]+				{}
+	{URL}					{ int temp=zzStartRead; addToken(start,zzStartRead-1, Token.COMMENT_EOL); addHyperlinkToken(temp,zzMarkedPos-1, Token.COMMENT_EOL); start = zzMarkedPos; }
+	[hwf]					{}
+	\n						{ addToken(start,zzStartRead-1, Token.COMMENT_EOL); addNullToken(); return firstToken; }
+	<<EOF>>					{ addToken(start,zzStartRead-1, Token.COMMENT_EOL); addNullToken(); return firstToken; }
+}

config/jflex/skeleton.default

@@ -0,0 +1,246 @@
+
+  /** This character denotes the end of file */
+  public static final int YYEOF = -1;
+
+  /** initial size of the lookahead buffer */
+--- private static final int ZZ_BUFFERSIZE = ...;
+
+  /** lexical states */
+---  lexical states, charmap
+
+  /* error codes */
+  private static final int ZZ_UNKNOWN_ERROR = 0;
+  private static final int ZZ_NO_MATCH = 1;
+  private static final int ZZ_PUSHBACK_2BIG = 2;
+
+  /* error messages for the codes above */
+  private static final String ZZ_ERROR_MSG[] = {
+    "Unkown internal scanner error",
+    "Error: could not match input",
+    "Error: pushback value was too large"
+  };
+
+--- isFinal list
+  /** the input device */
+  private java.io.Reader zzReader;
+
+  /** the current state of the DFA */
+  private int zzState;
+
+  /** the current lexical state */
+  private int zzLexicalState = YYINITIAL;
+
+  /** this buffer contains the current text to be matched and is
+      the source of the yytext() string */
+  private char zzBuffer[];
+
+  /** the textposition at the last accepting state */
+  private int zzMarkedPos;
+
+  /** the textposition at the last state to be included in yytext */
+  private int zzPushbackPos;
+
+  /** the current text position in the buffer */
+  private int zzCurrentPos;
+
+  /** startRead marks the beginning of the yytext() string in the buffer */
+  private int zzStartRead;
+
+  /** endRead marks the last character in the buffer, that has been read
+      from input */
+  private int zzEndRead;
+
+  /** number of newlines encountered up to the start of the matched text */
+  private int yyline;
+
+  /** the number of characters up to the start of the matched text */
+  private int yychar;
+
+  /**
+   * the number of characters from the last newline up to the start of the
+   * matched text
+   */
+  private int yycolumn;
+
+  /**
+   * zzAtBOL == true <=> the scanner is currently at the beginning of a line
+   */
+  private boolean zzAtBOL = true;
+
+  /** zzAtEOF == true <=> the scanner is at the EOF */
+  private boolean zzAtEOF;
+
+--- user class code
+
+  /**
+   * Creates a new scanner
+   * There is also a java.io.InputStream version of this constructor.
+   *
+   * @param   in  the java.io.Reader to read input from.
+   */
+--- constructor declaration
+
+
+  /**
+   * Closes the input stream.
+   */
+  public final void yyclose() throws java.io.IOException {
+    zzAtEOF = true;            /* indicate end of file */
+    zzEndRead = zzStartRead;  /* invalidate buffer    */
+
+    if (zzReader != null)
+      zzReader.close();
+  }
+
+
+  /**
+   * Enters a new lexical state
+   *
+   * @param newState the new lexical state
+   */
+  public final void yybegin(int newState) {
+    zzLexicalState = newState;
+  }
+
+  public final int yystate() {
+    return zzLexicalState;
+  }
+
+  /**
+   * Returns the text matched by the current regular expression.
+   */
+  public final String yytext() {
+    return new String( zzBuffer, zzStartRead, zzMarkedPos-zzStartRead );
+  }
+
+
+  /**
+   * Returns the character at position <tt>pos</tt> from the
+   * matched text.
+   *
+   * It is equivalent to yytext().charAt(pos), but faster
+   *
+   * @param pos the position of the character to fetch.
+   *            A value from 0 to yylength()-1.
+   *
+   * @return the character at position pos
+   */
+  public final char yycharat(int pos) {
+    return zzBuffer[zzStartRead+pos];
+  }
+
+
+  /**
+   * Returns the length of the matched text region.
+   */
+  public final int yylength() {
+    return zzMarkedPos-zzStartRead;
+  }
+
+
+  /**
+   * Reports an error that occured while scanning.
+   *
+   * In a wellformed scanner (no or only correct usage of
+   * yypushback(int) and a match-all fallback rule) this method
+   * will only be called with things that "Can't Possibly Happen".
+   * If this method is called, something is seriously wrong
+   * (e.g. a JFlex bug producing a faulty scanner etc.).
+   *
+   * Usual syntax/scanner level error handling should be done
+   * in error fallback rules.
+   *
+   * @param   errorCode  the code of the errormessage to display
+   */
+--- zzScanError declaration
+    String message;
+    try {
+      message = ZZ_ERROR_MSG[errorCode];
+    }
+    catch (ArrayIndexOutOfBoundsException e) {
+      message = ZZ_ERROR_MSG[ZZ_UNKNOWN_ERROR];
+    }
+
+--- throws clause
+  }
+
+
+  /**
+   * Pushes the specified amount of characters back into the input stream.
+   *
+   * They will be read again by then next call of the scanning method
+   *
+   * @param number  the number of characters to be read again.
+   *                This number must not be greater than yylength()!
+   */
+--- yypushback decl (contains zzScanError exception)
+    if ( number > yylength() )
+      zzScanError(ZZ_PUSHBACK_2BIG);
+
+    zzMarkedPos -= number;
+  }
+
+
+--- zzDoEOF
+  /**
+   * Resumes scanning until the next regular expression is matched,
+   * the end of input is encountered or an I/O-Error occurs.
+   *
+   * @return      the next token
+   * @exception   java.io.IOException  if any I/O-Error occurs
+   */
+--- yylex declaration
+    int zzInput;
+    int zzAction;
+
+    // cached fields:
+    int zzCurrentPosL;
+    int zzMarkedPosL;
+    int zzEndReadL = zzEndRead;
+    char [] zzBufferL = zzBuffer;
+    char [] zzCMapL = ZZ_CMAP;
+
+--- local declarations
+
+    while (true) {
+      zzMarkedPosL = zzMarkedPos;
+
+--- start admin (line, char, col count)
+      zzAction = -1;
+
+      zzCurrentPosL = zzCurrentPos = zzStartRead = zzMarkedPosL;
+
+--- start admin (lexstate etc)
+
+      zzForAction: {
+        while (true) {
+
+--- next input, line, col, char count, next transition, isFinal action
+            zzAction = zzState;
+            zzMarkedPosL = zzCurrentPosL;
+--- line count update
+          }
+
+        }
+      }
+
+      // store back cached position
+      zzMarkedPos = zzMarkedPosL;
+--- char count update
+
+--- actions
+        default:
+          if (zzInput == YYEOF && zzStartRead == zzCurrentPos) {
+            zzAtEOF = true;
+--- eofvalue
+          }
+          else {
+--- no match
+          }
+      }
+    }
+  }
+
+--- main
+
+}

gradle.properties

@@ -0,0 +1,12 @@
+org.gradle.warning.mode=all
+org.gradle.parallel=true
+org.gradle.caching=true
+
+# Flags for google-java-format (optimize imports by spotless) for Java >= 16.
+# Java < 9 will ignore unsupported flags (thanks to -XX:+IgnoreUnrecognizedVMOptions)
+org.gradle.jvmargs=-XX:+IgnoreUnrecognizedVMOptions \
+  --add-exports='jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED' \
+  --add-exports='jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED'

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,8 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionSha256Sum=31c55713e40233a8303827ceb42ca48a47267a0ad4bab9177123121e71524c26
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.2-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.9-bin.zip

gradlew

@@ -1,79 +1,130 @@
-#!/usr/bin/env bash
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# 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
+#
+#      https://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.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
+# Attempt to set APP_HOME
 
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
-warn ( ) {
+warn () {
     echo "$*"
-}
+} >&2
 
-die ( ) {
+die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # 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
-    ;;
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=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"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
-APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
-
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
+
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -82,83 +133,120 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin, switch paths to Windows format before running java
-if $cygwin ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=$((i+1))
-    done
-    case $i in
-        (0) set -- ;;
-        (1) set -- "$args0" ;;
-        (2) set -- "$args0" "$args1" ;;
-        (3) set -- "$args0" "$args1" "$args2" ;;
-        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
     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=("$@")
-}
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,90 +1,94 @@
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@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 Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windowz 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.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-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
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@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="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

jadx-cli/build.gradle

@@ -1,28 +0,0 @@
-apply plugin: 'application'
-
-mainClassName = 'jadx.cli.JadxCLI'
-applicationName = 'jadx'
-
-dependencies {
-    compile(project(':jadx-core'))
-    compile 'com.beust:jcommander:1.30'
-}
-
-startScripts {
-    doLast {
-        // increase default max heap size
-        String var = 'DEFAULT_JVM_OPTS='
-        String args = '-Xmx1300M'
-        unixScript.text = unixScript.text.replace(var + '""', var + '"' + args + '"')
-        windowsScript.text = windowsScript.text.replace(var, var + args)
-    }
-}
-
-applicationDistribution.with {
-    into('') {
-        from '../.'
-        include 'README.md'
-        include 'NOTICE'
-    }
-}
-

jadx-cli/build.gradle.kts

@@ -0,0 +1,49 @@
+plugins {
+	id("jadx-java")
+	id("jadx-library")
+	id("application")
+
+	// use shadow only for application scripts, jar will be copied from jadx-gui
+	id("com.gradleup.shadow") version "8.3.5"
+}
+
+dependencies {
+	implementation(project(":jadx-core"))
+	implementation(project(":jadx-plugins-tools"))
+	implementation(project(":jadx-commons:jadx-app-commons"))
+
+	runtimeOnly(project(":jadx-plugins:jadx-dex-input"))
+	runtimeOnly(project(":jadx-plugins:jadx-java-input"))
+	runtimeOnly(project(":jadx-plugins:jadx-java-convert"))
+	runtimeOnly(project(":jadx-plugins:jadx-smali-input"))
+	runtimeOnly(project(":jadx-plugins:jadx-rename-mappings"))
+	runtimeOnly(project(":jadx-plugins:jadx-kotlin-metadata"))
+	runtimeOnly(project(":jadx-plugins:jadx-script:jadx-script-plugin"))
+	runtimeOnly(project(":jadx-plugins:jadx-xapk-input"))
+	runtimeOnly(project(":jadx-plugins:jadx-aab-input"))
+
+	implementation("org.jcommander:jcommander:2.0")
+	implementation("ch.qos.logback:logback-classic:1.5.12")
+}
+
+application {
+	applicationName = "jadx"
+	mainClass.set("jadx.cli.JadxCLI")
+	applicationDefaultJvmArgs =
+		listOf(
+			"-Xms256M",
+			"-XX:MaxRAMPercentage=70.0",
+			// disable zip checks (#1962)
+			"-Djdk.util.zip.disableZip64ExtraFieldValidation=true",
+		)
+	applicationDistribution.from("$rootDir") {
+		include("README.md")
+		include("NOTICE")
+		include("LICENSE")
+	}
+}
+
+tasks.shadowJar {
+	// shadow jar not needed
+	configurations = listOf()
+}

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

@@ -0,0 +1,277 @@
+package jadx.cli;
+
+import java.io.PrintStream;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.function.Supplier;
+
+import org.jetbrains.annotations.Nullable;
+
+import com.beust.jcommander.JCommander;
+import com.beust.jcommander.Parameter;
+import com.beust.jcommander.ParameterDescription;
+import com.beust.jcommander.ParameterException;
+import com.beust.jcommander.Parameterized;
+
+import jadx.api.JadxDecompiler;
+import jadx.api.plugins.JadxPluginInfo;
+import jadx.api.plugins.options.JadxPluginOptions;
+import jadx.api.plugins.options.OptionDescription;
+import jadx.core.plugins.JadxPluginManager;
+import jadx.core.plugins.PluginContext;
+import jadx.core.utils.Utils;
+import jadx.plugins.tools.JadxExternalPluginsLoader;
+
+public class JCommanderWrapper<T> {
+	private final JCommander jc;
+	private final JadxCLIArgs argsObj;
+
+	public JCommanderWrapper(JadxCLIArgs argsObj) {
+		JCommander.Builder builder = JCommander.newBuilder().addObject(argsObj);
+		builder.acceptUnknownOptions(true); // workaround for "default" command
+		JadxCLICommands.append(builder);
+		this.jc = builder.build();
+		this.argsObj = argsObj;
+	}
+
+	public boolean parse(String[] args) {
+		try {
+			jc.parse(args);
+			return true;
+		} catch (ParameterException e) {
+			System.err.println("Arguments parse error: " + e.getMessage());
+			printUsage();
+			return false;
+		}
+	}
+
+	public boolean processCommands() {
+		String parsedCommand = jc.getParsedCommand();
+		if (parsedCommand == null) {
+			return false;
+		}
+		return JadxCLICommands.process(this, jc, parsedCommand);
+	}
+
+	public void overrideProvided(JadxCLIArgs obj) {
+		List<ParameterDescription> fieldsParams = jc.getParameters();
+		List<ParameterDescription> parameters = new ArrayList<>(1 + fieldsParams.size());
+		parameters.add(jc.getMainParameterValue());
+		parameters.addAll(fieldsParams);
+		for (ParameterDescription parameter : parameters) {
+			if (parameter.isAssigned()) {
+				// copy assigned field value to obj
+				Parameterized parameterized = parameter.getParameterized();
+				Object providedValue = parameterized.get(parameter.getObject());
+				Object newValue = mergeValues(parameterized.getType(), providedValue, () -> parameterized.get(obj));
+				parameterized.set(obj, newValue);
+			}
+		}
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	private static Object mergeValues(Class<?> type, Object value, Supplier<Object> prevValueProvider) {
+		if (type.isAssignableFrom(Map.class)) {
+			// merge maps instead replacing whole map
+			Map prevMap = (Map) prevValueProvider.get();
+			return Utils.mergeMaps(prevMap, (Map) value); // value map will override keys in prevMap
+		}
+		// simple override
+		return value;
+	}
+
+	public List<String> getUnknownOptions() {
+		return jc.getUnknownOptions();
+	}
+
+	public void printUsage() {
+		LogHelper.setLogLevel(LogHelper.LogLevelEnum.ERROR); // mute logger while printing help
+
+		// print usage in not sorted fields order (by default sorted by description)
+		PrintStream out = System.out;
+		out.println();
+		out.println("jadx - dex to java decompiler, version: " + JadxDecompiler.getVersion());
+		out.println();
+		out.println("usage: jadx [command] [options] " + jc.getMainParameterDescription());
+
+		out.println("commands (use '<command> --help' for command options):");
+		for (String command : jc.getCommands().keySet()) {
+			out.println("  " + command + "\t  - " + jc.getUsageFormatter().getCommandDescription(command));
+		}
+		out.println();
+
+		int maxNamesLen = printOptions(jc, out, true);
+		out.println(appendPluginOptions(maxNamesLen));
+		out.println();
+		out.println("Environment variables:");
+		out.println("  JADX_DISABLE_XML_SECURITY - set to 'true' to disable all security checks for XML files");
+		out.println("  JADX_DISABLE_ZIP_SECURITY - set to 'true' to disable all security checks for zip files");
+		out.println("  JADX_ZIP_MAX_ENTRIES_COUNT - maximum allowed number of entries in zip files (default: 100 000)");
+		out.println("  JADX_CONFIG_DIR - custom config directory, using system by default");
+		out.println("  JADX_CACHE_DIR - custom cache directory, using system by default");
+		out.println("  JADX_TMP_DIR - custom temp directory, using system by default");
+		out.println();
+		out.println("Examples:");
+		out.println("  jadx -d out classes.dex");
+		out.println("  jadx --rename-flags \"none\" classes.dex");
+		out.println("  jadx --rename-flags \"valid, printable\" classes.dex");
+		out.println("  jadx --log-level ERROR app.apk");
+		out.println("  jadx -Pdex-input.verify-checksum=no app.apk");
+	}
+
+	public void printUsage(JCommander subCommander) {
+		PrintStream out = System.out;
+		out.println("usage: " + subCommander.getProgramName() + " [options]");
+		printOptions(subCommander, out, false);
+	}
+
+	private static int printOptions(JCommander jc, PrintStream out, boolean addDefaults) {
+		out.println("options:");
+
+		List<ParameterDescription> params = jc.getParameters();
+		Map<String, ParameterDescription> paramsMap = new HashMap<>(params.size());
+		int maxNamesLen = 0;
+		for (ParameterDescription p : params) {
+			paramsMap.put(p.getParameterized().getName(), p);
+			int len = p.getNames().length();
+			String valueDesc = getValueDesc(p);
+			if (valueDesc != null) {
+				len += 1 + valueDesc.length();
+			}
+			maxNamesLen = Math.max(maxNamesLen, len);
+		}
+		maxNamesLen += 3;
+
+		Object args = jc.getObjects().get(0);
+		for (Field f : getFields(args.getClass())) {
+			String name = f.getName();
+			ParameterDescription p = paramsMap.get(name);
+			if (p == null || p.getParameter().hidden()) {
+				continue;
+			}
+			StringBuilder opt = new StringBuilder();
+			opt.append("  ").append(p.getNames());
+			String valueDesc = getValueDesc(p);
+			if (valueDesc != null) {
+				opt.append(' ').append(valueDesc);
+			}
+			addSpaces(opt, maxNamesLen - opt.length());
+			String description = p.getDescription();
+			if (description.contains("\n")) {
+				String[] lines = description.split("\n");
+				opt.append("- ").append(lines[0]);
+				for (int i = 1; i < lines.length; i++) {
+					opt.append('\n');
+					addSpaces(opt, maxNamesLen + 2);
+					opt.append(lines[i]);
+				}
+			} else {
+				opt.append("- ").append(description);
+			}
+			if (addDefaults) {
+				String defaultValue = getDefaultValue(args, f);
+				if (defaultValue != null && !description.contains("(default)")) {
+					opt.append(", default: ").append(defaultValue);
+				}
+			}
+			out.println(opt);
+		}
+		return maxNamesLen;
+	}
+
+	private static @Nullable String getValueDesc(ParameterDescription p) {
+		Parameter parameterAnnotation = p.getParameterAnnotation();
+		return parameterAnnotation == null ? null : parameterAnnotation.defaultValueDescription();
+	}
+
+	/**
+	 * Get all declared fields of the specified class and all super classes
+	 */
+	private static List<Field> getFields(Class<?> clazz) {
+		List<Field> fieldList = new ArrayList<>();
+		while (clazz != null) {
+			fieldList.addAll(Arrays.asList(clazz.getDeclaredFields()));
+			clazz = clazz.getSuperclass();
+		}
+		return fieldList;
+	}
+
+	@Nullable
+	private static String getDefaultValue(Object args, Field f) {
+		try {
+			Class<?> fieldType = f.getType();
+			if (fieldType == int.class) {
+				return Integer.toString(f.getInt(args));
+			}
+			if (fieldType == String.class) {
+				return (String) f.get(args);
+			}
+			if (Enum.class.isAssignableFrom(fieldType)) {
+				Enum<?> val = (Enum<?>) f.get(args);
+				if (val != null) {
+					return val.name().toLowerCase(Locale.ROOT);
+				}
+			}
+		} catch (Exception e) {
+			// ignore
+		}
+		return null;
+	}
+
+	private static void addSpaces(StringBuilder str, int count) {
+		for (int i = 0; i < count; i++) {
+			str.append(' ');
+		}
+	}
+
+	private String appendPluginOptions(int maxNamesLen) {
+		StringBuilder sb = new StringBuilder();
+		int k = 1;
+		// load and init all options plugins to print all options
+		try (JadxDecompiler decompiler = new JadxDecompiler(argsObj.toJadxArgs())) {
+			JadxPluginManager pluginManager = decompiler.getPluginManager();
+			pluginManager.load(new JadxExternalPluginsLoader());
+			pluginManager.initAll();
+			for (PluginContext context : pluginManager.getAllPluginContexts()) {
+				JadxPluginOptions options = context.getOptions();
+				if (options != null) {
+					if (appendPlugin(context.getPluginInfo(), context.getOptions(), sb, maxNamesLen)) {
+						k++;
+					}
+				}
+			}
+		}
+		if (sb.length() == 0) {
+			return "";
+		}
+		return "\nPlugin options (-P<name>=<value>):" + sb;
+	}
+
+	private boolean appendPlugin(JadxPluginInfo pluginInfo, JadxPluginOptions options, StringBuilder out, int maxNamesLen) {
+		List<OptionDescription> descs = options.getOptionsDescriptions();
+		if (descs.isEmpty()) {
+			return false;
+		}
+		out.append("\n  ");
+		out.append(pluginInfo.getPluginId()).append(": ").append(pluginInfo.getDescription());
+		for (OptionDescription desc : descs) {
+			StringBuilder opt = new StringBuilder();
+			opt.append("    - ").append(desc.name());
+			addSpaces(opt, maxNamesLen - opt.length());
+			opt.append("- ").append(desc.description());
+			if (!desc.values().isEmpty()) {
+				opt.append(", values: ").append(desc.values());
+			}
+			if (desc.defaultValue() != null) {
+				opt.append(", default: ").append(desc.defaultValue());
+			}
+			out.append("\n").append(opt);
+		}
+		return true;
+	}
+}

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

@@ -1,68 +1,138 @@
 package jadx.cli;
 
-import jadx.api.Decompiler;
-import jadx.core.utils.ErrorsCounter;
-import jadx.core.utils.exceptions.JadxException;
-
-import java.io.File;
+import java.util.Set;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import jadx.api.JadxArgs;
+import jadx.api.JadxDecompiler;
+import jadx.api.impl.AnnotatedCodeWriter;
+import jadx.api.impl.NoOpCodeCache;
+import jadx.api.impl.SimpleCodeWriter;
+import jadx.api.security.JadxSecurityFlag;
+import jadx.api.security.impl.JadxSecurity;
+import jadx.cli.LogHelper.LogLevelEnum;
+import jadx.cli.plugins.JadxFilesGetter;
+import jadx.commons.app.JadxCommonEnv;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+import jadx.plugins.tools.JadxExternalPluginsLoader;
+
 public class JadxCLI {
 	private static final Logger LOG = LoggerFactory.getLogger(JadxCLI.class);
 
 	public static void main(String[] args) {
+		int result = 1;
 		try {
-			JadxCLIArgs jadxArgs = new JadxCLIArgs(args);
-			checkArgs(jadxArgs);
-			processAndSave(jadxArgs);
-		} catch (Exception e) {
-			LOG.error(e.getMessage());
-			System.exit(1);
+			result = execute(args);
+		} finally {
+			System.exit(result);
 		}
 	}
 
-	private static void processAndSave(JadxCLIArgs jadxArgs) {
+	public static int execute(String[] args) {
 		try {
-			Decompiler jadx = new Decompiler(jadxArgs);
-			jadx.loadFiles(jadxArgs.getInput());
-			jadx.setOutputDir(jadxArgs.getOutDir());
-			jadx.save();
-			LOG.info("done");
-		} catch (Throwable e) {
-			LOG.error("jadx error:", e);
-		}
-		int errorsCount = ErrorsCounter.getErrorCount();
-		if (errorsCount != 0) {
-			ErrorsCounter.printReport();
-		}
-		System.exit(errorsCount);
-	}
-
-	private static void checkArgs(JadxCLIArgs jadxArgs) throws JadxException {
-		if (jadxArgs.getInput().isEmpty()) {
-			LOG.error("Please specify input file");
-			jadxArgs.printUsage();
-			System.exit(1);
-		}
-		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";
+			JadxCLIArgs jadxArgs = new JadxCLIArgs();
+			if (jadxArgs.processArgs(args)) {
+				return processAndSave(jadxArgs);
 			}
-			LOG.info("output directory: " + outDirName);
-			outputDir = new File(outDirName);
-			jadxArgs.setOutputDir(outputDir);
+			return 0;
+		} catch (JadxArgsValidateException e) {
+			LOG.error("Incorrect arguments: {}", e.getMessage());
+			return 1;
+		} catch (Throwable e) {
+			LOG.error("Process error:", e);
+			return 1;
 		}
-		if (outputDir.exists() && !outputDir.isDirectory()) {
-			throw new JadxException("Output directory exists as file " + outputDir);
+	}
+
+	private static int processAndSave(JadxCLIArgs cliArgs) {
+		LogHelper.initLogLevel(cliArgs);
+		LogHelper.setLogLevelsForLoadingStage();
+		JadxArgs jadxArgs = cliArgs.toJadxArgs();
+		jadxArgs.setCodeCache(new NoOpCodeCache());
+		jadxArgs.setPluginLoader(new JadxExternalPluginsLoader());
+		jadxArgs.setFilesGetter(JadxFilesGetter.INSTANCE);
+		initCodeWriterProvider(jadxArgs);
+		applyEnvVars(jadxArgs);
+		try (JadxDecompiler jadx = new JadxDecompiler(jadxArgs)) {
+			jadx.load();
+			if (checkForErrors(jadx)) {
+				return 1;
+			}
+			LogHelper.setLogLevelsForDecompileStage();
+			if (!SingleClassMode.process(jadx, cliArgs)) {
+				save(jadx);
+			}
+			int errorsCount = jadx.getErrorsCount();
+			if (errorsCount != 0) {
+				jadx.printErrorsReport();
+				LOG.error("finished with errors, count: {}", errorsCount);
+				return 1;
+			}
+			LOG.info("done");
+			return 0;
+		}
+	}
+
+	private static void initCodeWriterProvider(JadxArgs jadxArgs) {
+		switch (jadxArgs.getOutputFormat()) {
+			case JAVA:
+				jadxArgs.setCodeWriterProvider(SimpleCodeWriter::new);
+				break;
+			case JSON:
+				// needed for code offsets and source lines
+				jadxArgs.setCodeWriterProvider(AnnotatedCodeWriter::new);
+				break;
+		}
+	}
+
+	private static void applyEnvVars(JadxArgs jadxArgs) {
+		Set<JadxSecurityFlag> flags = JadxSecurityFlag.all();
+		boolean modified = false;
+		boolean disableXmlSecurity = JadxCommonEnv.getBool("JADX_DISABLE_XML_SECURITY", false);
+		if (disableXmlSecurity) {
+			flags.remove(JadxSecurityFlag.SECURE_XML_PARSER);
+			// TODO: not related to 'xml security', but kept for compatibility
+			flags.remove(JadxSecurityFlag.VERIFY_APP_PACKAGE);
+			modified = true;
+		}
+		// TODO: migrate 'ZipSecurity'
+		if (modified) {
+			jadxArgs.setSecurity(new JadxSecurity(flags));
+		}
+	}
+
+	private static boolean checkForErrors(JadxDecompiler jadx) {
+		if (jadx.getRoot().getClasses().isEmpty()) {
+			if (jadx.getArgs().isSkipResources()) {
+				LOG.error("Load failed! No classes for decompile!");
+				return true;
+			}
+			if (!jadx.getArgs().isSkipSources()) {
+				LOG.warn("No classes to decompile; decoding resources only");
+				jadx.getArgs().setSkipSources(true);
+			}
+		}
+		if (jadx.getErrorsCount() > 0) {
+			LOG.error("Load with errors! Check log for details");
+			// continue processing
+			return false;
+		}
+		return false;
+	}
+
+	private static void save(JadxDecompiler jadx) {
+		if (LogHelper.getLogLevel() == LogLevelEnum.QUIET) {
+			jadx.save();
+		} else {
+			LOG.info("processing ...");
+			jadx.save(500, (done, total) -> {
+				int progress = (int) (done * 100.0 / total);
+				System.out.printf("INFO  - progress: %d of %d (%d%%)\r", done, total, progress);
+			});
+			// dumb line clear :)
+			System.out.print("                                                             \r");
 		}
 	}
 }

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

@@ -1,184 +1,698 @@
 package jadx.cli;
 
-import jadx.api.IJadxArgs;
-import jadx.core.Consts;
-import jadx.core.utils.exceptions.JadxException;
-
-import java.io.File;
-import java.io.PrintStream;
-import java.lang.reflect.Field;
+import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.EnumSet;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.beust.jcommander.JCommander;
+import com.beust.jcommander.DynamicParameter;
+import com.beust.jcommander.IStringConverter;
 import com.beust.jcommander.Parameter;
-import com.beust.jcommander.ParameterDescription;
-import com.beust.jcommander.ParameterException;
 
-public final class JadxCLIArgs implements IJadxArgs {
+import jadx.api.CommentsLevel;
+import jadx.api.DecompilationMode;
+import jadx.api.JadxArgs;
+import jadx.api.JadxArgs.RenameEnum;
+import jadx.api.JadxArgs.UseKotlinMethodsForVarNames;
+import jadx.api.JadxDecompiler;
+import jadx.api.args.GeneratedRenamesMappingFileMode;
+import jadx.api.args.IntegerFormat;
+import jadx.api.args.ResourceNameSource;
+import jadx.api.args.UseSourceNameAsClassNameAlias;
+import jadx.api.args.UserRenamesMappingsMode;
+import jadx.core.deobf.conditions.DeobfWhitelist;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+import jadx.core.utils.files.FileUtils;
 
-	@Parameter(description = "<input file> (.dex, .apk or .jar)")
-	protected List<String> files;
+public class JadxCLIArgs {
 
-	@Parameter(names = {"-d", "--output-dir"}, description = "output directory")
-	protected String outDirName;
+	@Parameter(description = "<input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab, .xapk, .jadx.kts)")
+	protected List<String> files = new ArrayList<>(1);
 
-	@Parameter(names = {"-j", "--threads-count"}, description = "processing threads count")
-	protected int threadsCount = Runtime.getRuntime().availableProcessors();
+	@Parameter(names = { "-d", "--output-dir" }, description = "output directory")
+	protected String outDir;
 
-	@Parameter(names = {"-f", "--fallback"}, description = "make simple dump (using goto instead of 'if', 'for', etc)", help = true)
-	protected boolean fallbackMode = false;
+	@Parameter(names = { "-ds", "--output-dir-src" }, description = "output directory for sources")
+	protected String outDirSrc;
 
-	@Parameter(names = {"--cfg"}, description = "save methods control flow graph to dot file")
+	@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 = { "--single-class" }, description = "decompile a single class, full name, raw or alias")
+	protected String singleClass = null;
+
+	@Parameter(names = { "--single-class-output" }, description = "file or dir for write if decompile a single class")
+	protected String singleClassOutput = null;
+
+	@Parameter(names = { "--output-format" }, description = "can be 'java' or 'json'")
+	protected String outputFormat = "java";
+
+	@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 = JadxArgs.DEFAULT_THREADS_COUNT;
+
+	@Parameter(
+			names = { "-m", "--decompilation-mode" },
+			description = "code output mode:"
+					+ "\n 'auto' - trying best options (default)"
+					+ "\n 'restructure' - restore code structure (normal java code)"
+					+ "\n 'simple' - simplified instructions (linear, with goto's)"
+					+ "\n 'fallback' - raw instructions without modifications",
+			converter = DecompilationModeConverter.class
+	)
+	protected DecompilationMode decompilationMode = DecompilationMode.AUTO;
+
+	@Parameter(names = { "--show-bad-code" }, description = "show inconsistent code (incorrectly decompiled)")
+	protected boolean showInconsistentCode = false;
+
+	@Parameter(names = { "--no-xml-pretty-print" }, description = "do not prettify XML")
+	protected boolean skipXmlPrettyPrint = false;
+
+	@Parameter(names = { "--no-imports" }, description = "disable use of imports, always write entire package name")
+	protected boolean useImports = true;
+
+	@Parameter(names = { "--no-debug-info" }, description = "disable debug info parsing and processing")
+	protected boolean debugInfo = true;
+
+	@Parameter(names = { "--add-debug-lines" }, description = "add comments with debug line numbers if available")
+	protected boolean addDebugLines = false;
+
+	@Parameter(names = { "--no-inline-anonymous" }, description = "disable anonymous classes inline")
+	protected boolean inlineAnonymousClasses = true;
+
+	@Parameter(names = { "--no-inline-methods" }, description = "disable methods inline")
+	protected boolean inlineMethods = true;
+
+	@Parameter(names = { "--no-move-inner-classes" }, description = "disable move inner classes into parent")
+	protected boolean moveInnerClasses = true;
+
+	@Parameter(names = { "--no-inline-kotlin-lambda" }, description = "disable inline for Kotlin lambdas")
+	protected boolean allowInlineKotlinLambda = true;
+
+	@Parameter(names = "--no-finally", description = "don't extract finally block")
+	protected boolean extractFinally = true;
+
+	@Parameter(names = "--no-restore-switch-over-string", description = "don't restore switch over string")
+	protected boolean restoreSwitchOverString = 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 = { "--respect-bytecode-access-modifiers" }, description = "don't change original access modifiers")
+	protected boolean respectBytecodeAccessModifiers = false;
+
+	@Parameter(
+			names = { "--mappings-path" },
+			description = "deobfuscation mappings file or directory. Allowed formats: Tiny and Tiny v2 (both '.tiny'), Enigma (.mapping) or Enigma directory"
+	)
+	protected Path userRenamesMappingsPath;
+
+	@Parameter(
+			names = { "--mappings-mode" },
+			description = "set mode for handling the deobfuscation mapping file:"
+					+ "\n 'read' - just read, user can always save manually (default)"
+					+ "\n 'read-and-autosave-every-change' - read and autosave after every change"
+					+ "\n 'read-and-autosave-before-closing' - read and autosave before exiting the app or closing the project"
+					+ "\n 'ignore' - don't read or save (can be used to skip loading mapping files referenced in the project file)"
+	)
+	protected UserRenamesMappingsMode userRenamesMappingsMode = UserRenamesMappingsMode.getDefault();
+
+	@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-whitelist" },
+			description = "space separated list of classes (full name) and packages (ends with '.*') to exclude from deobfuscation"
+	)
+	protected String deobfuscationWhitelistStr = DeobfWhitelist.DEFAULT_STR;
+
+	@Parameter(
+			names = { "--deobf-cfg-file" },
+			description = "deobfuscation mappings file used for JADX auto-generated names (in the JOBF file format),"
+					+ " default: same dir and name as input file with '.jobf' extension"
+	)
+	protected String generatedRenamesMappingFile;
+
+	@Parameter(
+			names = { "--deobf-cfg-file-mode" },
+			description = "set mode for handling the JADX auto-generated names' deobfuscation map file:"
+					+ "\n 'read' - read if found, don't save (default)"
+					+ "\n 'read-or-save' - read if found, save otherwise (don't overwrite)"
+					+ "\n 'overwrite' - don't read, always save"
+					+ "\n 'ignore' - don't read and don't save",
+			converter = DeobfuscationMapFileModeConverter.class
+	)
+	protected GeneratedRenamesMappingFileMode generatedRenamesMappingFileMode = GeneratedRenamesMappingFileMode.getDefault();
+
+	@SuppressWarnings("DeprecatedIsStillUsed")
+	@Parameter(
+			names = { "--deobf-use-sourcename" },
+			description = "use source file name as class name alias."
+					+ "\nDEPRECATED, use \"--use-source-name-as-class-name-alias\" instead",
+			hidden = true
+	)
+	@Deprecated
+	protected Boolean deobfuscationUseSourceNameAsAlias = null;
+
+	@Parameter(
+			names = { "--deobf-res-name-source" },
+			description = "better name source for resources:"
+					+ "\n 'auto' - automatically select best name (default)"
+					+ "\n 'resources' - use resources names"
+					+ "\n 'code' - use R class fields names",
+			converter = ResourceNameSourceConverter.class
+	)
+	protected ResourceNameSource resourceNameSource = ResourceNameSource.AUTO;
+
+	@Parameter(
+			names = { "--use-source-name-as-class-name-alias" },
+			description = "use source name as class name alias:"
+					+ "\n 'always' - always use source name if it's available"
+					+ "\n 'if-better' - use source name if it seems better than the current one"
+					+ "\n 'never' - never use source name, even if it's available",
+			converter = UseSourceNameAsClassNameConverter.class
+	)
+	protected UseSourceNameAsClassNameAlias useSourceNameAsClassNameAlias = null;
+
+	@Parameter(
+			names = { "--use-kotlin-methods-for-var-names" },
+			description = "use kotlin intrinsic methods to rename variables, values: disable, apply, apply-and-hide",
+			converter = UseKotlinMethodsForVarNamesConverter.class
+	)
+	protected UseKotlinMethodsForVarNames useKotlinMethodsForVarNames = UseKotlinMethodsForVarNames.APPLY;
+
+	@Parameter(
+			names = { "--rename-flags" },
+			description = "fix options (comma-separated list of):"
+					+ "\n 'case' - fix case sensitivity issues (according to --fs-case-sensitive option),"
+					+ "\n 'valid' - rename java identifiers to make them valid,"
+					+ "\n 'printable' - remove non-printable chars from identifiers,"
+					+ "\nor single 'none' - to disable all renames"
+					+ "\nor single 'all' - to enable all (default)",
+			converter = RenameConverter.class
+	)
+	protected Set<RenameEnum> renameFlags = EnumSet.allOf(RenameEnum.class);
+
+	@Parameter(
+			names = { "--integer-format" },
+			description = "how integers are displayed:"
+					+ "\n 'auto' - automatically select (default)"
+					+ "\n 'decimal' - use decimal"
+					+ "\n 'hexadecimal' - use hexadecimal",
+			converter = IntegerFormatConverter.class
+	)
+	protected IntegerFormat integerFormat = IntegerFormat.AUTO;
+
+	@Parameter(names = { "--fs-case-sensitive" }, description = "treat filesystem as case sensitive, false by default")
+	protected boolean fsCaseSensitive = false;
+
+	@Parameter(names = { "--cfg" }, description = "save methods control flow graph to dot file")
 	protected boolean cfgOutput = false;
 
-	@Parameter(names = {"--raw-cfg"}, description = "save methods control flow graph (use raw instructions)")
+	@Parameter(names = { "--raw-cfg" }, description = "save methods control flow graph (use raw instructions)")
 	protected boolean rawCfgOutput = false;
 
-	@Parameter(names = {"-v", "--verbose"}, description = "verbose output")
+	@Parameter(names = { "-f", "--fallback" }, description = "set '--decompilation-mode' to 'fallback' (deprecated)")
+	protected boolean fallbackMode = false;
+
+	@Parameter(names = { "--use-dx" }, description = "use dx/d8 to convert java bytecode")
+	protected boolean useDx = false;
+
+	@Parameter(
+			names = { "--comments-level" },
+			description = "set code comments level, values: error, warn, info, debug, user-only, none",
+			converter = CommentsLevelConverter.class
+	)
+	protected CommentsLevel commentsLevel = CommentsLevel.INFO;
+
+	@Parameter(
+			names = { "--log-level" },
+			description = "set log level, values: quiet, progress, error, warn, info, debug",
+			converter = LogLevelConverter.class
+	)
+	protected LogHelper.LogLevelEnum logLevel = LogHelper.LogLevelEnum.PROGRESS;
+
+	@Parameter(names = { "-v", "--verbose" }, description = "verbose output (set --log-level to DEBUG)")
 	protected boolean verbose = false;
 
-	@Parameter(names = {"-h", "--help"}, description = "print this help", help = true)
+	@Parameter(names = { "-q", "--quiet" }, description = "turn off output (set --log-level to QUIET)")
+	protected boolean quiet = false;
+
+	@Parameter(names = { "--disable-plugins" }, description = "comma separated list of plugin ids to disable")
+	protected String disablePlugins = "";
+
+	@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;
+	@DynamicParameter(names = "-P", description = "Plugin options", hidden = true)
+	protected Map<String, String> pluginOptions = new HashMap<>();
 
-	public JadxCLIArgs(String[] args) {
-		parse(args);
-		processArgs();
+	public boolean processArgs(String[] args) {
+		JCommanderWrapper<JadxCLIArgs> jcw = new JCommanderWrapper<>(this);
+		return jcw.parse(args) && process(jcw);
 	}
 
-	private void parse(String[] args) {
-		try {
-			new JCommander(this, args);
-		} catch (ParameterException e) {
-			System.err.println("Arguments parse error: " + e.getMessage());
-			printUsage();
-			System.exit(1);
+	/**
+	 * Set values only for options provided in cmd.
+	 * Used to merge saved options and options passed in command line.
+	 */
+	public boolean overrideProvided(String[] args) {
+		JCommanderWrapper<JadxCLIArgs> jcw = new JCommanderWrapper<>(newInstance());
+		if (!jcw.parse(args)) {
+			return false;
 		}
+		jcw.overrideProvided(this);
+		return process(jcw);
 	}
 
-	public void processArgs() {
-		if (isPrintHelp()) {
-			printUsage();
-			System.exit(0);
-		}
-		try {
-			if (threadsCount <= 0)
-				throw new JadxException("Threads count must be positive");
-
-			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()) {
-				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);
-			}
-		} catch (JadxException e) {
-			System.err.println("ERROR: " + e.getMessage());
-			printUsage();
-			System.exit(1);
-		}
+	protected JadxCLIArgs newInstance() {
+		return new JadxCLIArgs();
 	}
 
-	public void printUsage() {
-		JCommander jc = new JCommander(this);
-		// print usage in not sorted fields order (by default its sorted by description)
-		PrintStream out = System.out;
-		out.println();
-		out.println("jadx - dex to java decompiler, version: " + Consts.JADX_VERSION);
-		out.println();
-		out.println("usage: jadx [options] " + jc.getMainParameterDescription());
-		out.println("options:");
-
-		List<ParameterDescription> params = jc.getParameters();
-
-		int maxNamesLen = 0;
-		for (ParameterDescription p : params) {
-			int len = p.getNames().length();
-			if (len > maxNamesLen)
-				maxNamesLen = len;
+	private boolean process(JCommanderWrapper<JadxCLIArgs> jcw) {
+		files.addAll(jcw.getUnknownOptions());
+		if (jcw.processCommands()) {
+			return false;
 		}
-
-		Field[] fields = this.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;
-				}
+		if (printHelp) {
+			jcw.printUsage();
+			return false;
+		}
+		if (printVersion) {
+			System.out.println(JadxDecompiler.getVersion());
+			return false;
+		}
+		if (threadsCount <= 0) {
+			throw new JadxArgsValidateException("Threads count must be positive, got: " + threadsCount);
+		}
+		for (String fileName : files) {
+			if (fileName.startsWith("-")) {
+				throw new JadxArgsValidateException("Unknown option: " + fileName);
 			}
 		}
-		out.println("Example:");
-		out.println(" jadx -d out classes.dex");
+		return true;
 	}
 
-	private static void addSpaces(StringBuilder str, int count) {
-		for (int i = 0; i < count; i++)
-			str.append(' ');
+	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.setOutputFormat(JadxArgs.OutputFormatEnum.valueOf(outputFormat.toUpperCase()));
+		args.setThreadsCount(threadsCount);
+		args.setSkipSources(skipSources);
+		args.setSkipResources(skipResources);
+		if (fallbackMode) {
+			args.setDecompilationMode(DecompilationMode.FALLBACK);
+		} else {
+			args.setDecompilationMode(decompilationMode);
+		}
+		args.setShowInconsistentCode(showInconsistentCode);
+		args.setCfgOutput(cfgOutput);
+		args.setRawCFGOutput(rawCfgOutput);
+		args.setReplaceConsts(replaceConsts);
+		if (userRenamesMappingsPath != null) {
+			args.setUserRenamesMappingsPath(userRenamesMappingsPath);
+		}
+		args.setUserRenamesMappingsMode(userRenamesMappingsMode);
+		args.setDeobfuscationOn(deobfuscationOn);
+		args.setGeneratedRenamesMappingFile(FileUtils.toFile(generatedRenamesMappingFile));
+		args.setGeneratedRenamesMappingFileMode(generatedRenamesMappingFileMode);
+		args.setDeobfuscationMinLength(deobfuscationMinLength);
+		args.setDeobfuscationMaxLength(deobfuscationMaxLength);
+		args.setDeobfuscationWhitelist(Arrays.asList(deobfuscationWhitelistStr.split(" ")));
+		args.setUseSourceNameAsClassNameAlias(getUseSourceNameAsClassNameAlias());
+		args.setUseKotlinMethodsForVarNames(useKotlinMethodsForVarNames);
+		args.setResourceNameSource(resourceNameSource);
+		args.setEscapeUnicode(escapeUnicode);
+		args.setRespectBytecodeAccModifiers(respectBytecodeAccessModifiers);
+		args.setExportAsGradleProject(exportAsGradleProject);
+		args.setSkipXmlPrettyPrint(skipXmlPrettyPrint);
+		args.setUseImports(useImports);
+		args.setDebugInfo(debugInfo);
+		args.setInsertDebugLines(addDebugLines);
+		args.setInlineAnonymousClasses(inlineAnonymousClasses);
+		args.setInlineMethods(inlineMethods);
+		args.setMoveInnerClasses(moveInnerClasses);
+		args.setAllowInlineKotlinLambda(allowInlineKotlinLambda);
+		args.setExtractFinally(extractFinally);
+		args.setRestoreSwitchOverString(restoreSwitchOverString);
+		args.setRenameFlags(renameFlags);
+		args.setFsCaseSensitive(fsCaseSensitive);
+		args.setCommentsLevel(commentsLevel);
+		args.setIntegerFormat(integerFormat);
+		args.setUseDxInput(useDx);
+		args.setPluginOptions(pluginOptions);
+		args.setDisabledPlugins(Arrays.stream(disablePlugins.split(",")).map(String::trim).collect(Collectors.toSet()));
+		return args;
 	}
 
-	public List<File> getInput() {
-		return input;
+	public List<String> getFiles() {
+		return files;
 	}
 
-	public File getOutDir() {
-		return outputDir;
+	public String getOutDir() {
+		return outDir;
 	}
 
-	public void setOutputDir(File outputDir) {
-		this.outputDir = outputDir;
+	public String getOutDirSrc() {
+		return outDirSrc;
 	}
 
-	public boolean isPrintHelp() {
-		return printHelp;
+	public String getOutDirRes() {
+		return outDirRes;
+	}
+
+	public String getSingleClass() {
+		return singleClass;
+	}
+
+	public String getSingleClassOutput() {
+		return singleClassOutput;
+	}
+
+	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 isUseDx() {
+		return useDx;
+	}
+
+	public DecompilationMode getDecompilationMode() {
+		return decompilationMode;
+	}
+
+	public boolean isShowInconsistentCode() {
+		return showInconsistentCode;
+	}
+
+	public boolean isUseImports() {
+		return useImports;
+	}
+
+	public boolean isDebugInfo() {
+		return debugInfo;
+	}
+
+	public boolean isAddDebugLines() {
+		return addDebugLines;
+	}
+
+	public boolean isInlineAnonymousClasses() {
+		return inlineAnonymousClasses;
+	}
+
+	public boolean isInlineMethods() {
+		return inlineMethods;
+	}
+
+	public boolean isMoveInnerClasses() {
+		return moveInnerClasses;
+	}
+
+	public boolean isAllowInlineKotlinLambda() {
+		return allowInlineKotlinLambda;
+	}
+
+	public boolean isExtractFinally() {
+		return extractFinally;
+	}
+
+	public boolean isRestoreSwitchOverString() {
+		return restoreSwitchOverString;
+	}
+
+	public Path getUserRenamesMappingsPath() {
+		return userRenamesMappingsPath;
+	}
+
+	public UserRenamesMappingsMode getUserRenamesMappingsMode() {
+		return userRenamesMappingsMode;
+	}
+
+	public boolean isDeobfuscationOn() {
+		return deobfuscationOn;
+	}
+
+	public int getDeobfuscationMinLength() {
+		return deobfuscationMinLength;
+	}
+
+	public int getDeobfuscationMaxLength() {
+		return deobfuscationMaxLength;
+	}
+
+	public String getDeobfuscationWhitelistStr() {
+		return deobfuscationWhitelistStr;
+	}
+
+	public String getGeneratedRenamesMappingFile() {
+		return generatedRenamesMappingFile;
+	}
+
+	public GeneratedRenamesMappingFileMode getGeneratedRenamesMappingFileMode() {
+		return generatedRenamesMappingFileMode;
+	}
+
+	public UseSourceNameAsClassNameAlias getUseSourceNameAsClassNameAlias() {
+		if (useSourceNameAsClassNameAlias != null) {
+			return useSourceNameAsClassNameAlias;
+		} else if (deobfuscationUseSourceNameAsAlias != null) {
+			// noinspection deprecation
+			return UseSourceNameAsClassNameAlias.create(deobfuscationUseSourceNameAsAlias);
+		} else {
+			return UseSourceNameAsClassNameAlias.getDefault();
+		}
+	}
+
+	/**
+	 * @deprecated Use {@link #getUseSourceNameAsClassNameAlias()} instead.
+	 */
+	@Deprecated
+	public boolean isDeobfuscationUseSourceNameAsAlias() {
+		return getUseSourceNameAsClassNameAlias().toBoolean();
+	}
+
+	public ResourceNameSource getResourceNameSource() {
+		return resourceNameSource;
+	}
+
+	public UseKotlinMethodsForVarNames getUseKotlinMethodsForVarNames() {
+		return useKotlinMethodsForVarNames;
+	}
+
+	public IntegerFormat getIntegerFormat() {
+		return integerFormat;
+	}
+
+	public boolean isEscapeUnicode() {
+		return escapeUnicode;
+	}
+
+	public boolean isCfgOutput() {
+		return cfgOutput;
+	}
+
+	public boolean isRawCfgOutput() {
+		return rawCfgOutput;
+	}
+
+	public boolean isReplaceConsts() {
+		return replaceConsts;
+	}
+
+	public boolean isRespectBytecodeAccessModifiers() {
+		return respectBytecodeAccessModifiers;
+	}
+
+	public boolean isExportAsGradleProject() {
+		return exportAsGradleProject;
+	}
+
+	public boolean isSkipXmlPrettyPrint() {
+		return skipXmlPrettyPrint;
+	}
+
+	public boolean isRenameCaseSensitive() {
+		return renameFlags.contains(RenameEnum.CASE);
+	}
+
+	public boolean isRenameValid() {
+		return renameFlags.contains(RenameEnum.VALID);
+	}
+
+	public boolean isRenamePrintable() {
+		return renameFlags.contains(RenameEnum.PRINTABLE);
+	}
+
+	public boolean isFsCaseSensitive() {
+		return fsCaseSensitive;
+	}
+
+	public CommentsLevel getCommentsLevel() {
+		return commentsLevel;
+	}
+
+	public LogHelper.LogLevelEnum getLogLevel() {
+		return logLevel;
+	}
+
+	public Map<String, String> getPluginOptions() {
+		return pluginOptions;
+	}
+
+	public String getDisablePlugins() {
+		return disablePlugins;
+	}
+
+	static class RenameConverter implements IStringConverter<Set<RenameEnum>> {
+		private final String paramName;
+
+		RenameConverter(String paramName) {
+			this.paramName = paramName;
+		}
+
+		@Override
+		public Set<RenameEnum> convert(String value) {
+			if (value.equalsIgnoreCase("NONE")) {
+				return EnumSet.noneOf(RenameEnum.class);
+			}
+			if (value.equalsIgnoreCase("ALL")) {
+				return EnumSet.allOf(RenameEnum.class);
+			}
+			Set<RenameEnum> set = EnumSet.noneOf(RenameEnum.class);
+			for (String s : value.split(",")) {
+				try {
+					set.add(RenameEnum.valueOf(s.trim().toUpperCase(Locale.ROOT)));
+				} catch (Exception e) {
+					throw new JadxArgsValidateException(
+							'\'' + s + "' is unknown for parameter " + paramName
+									+ ", possible values are " + enumValuesString(RenameEnum.values()));
+				}
+			}
+			return set;
+		}
+	}
+
+	public static class CommentsLevelConverter extends BaseEnumConverter<CommentsLevel> {
+		public CommentsLevelConverter() {
+			super(CommentsLevel::valueOf, CommentsLevel::values);
+		}
+	}
+
+	public static class UseKotlinMethodsForVarNamesConverter extends BaseEnumConverter<UseKotlinMethodsForVarNames> {
+		public UseKotlinMethodsForVarNamesConverter() {
+			super(UseKotlinMethodsForVarNames::valueOf, UseKotlinMethodsForVarNames::values);
+		}
+	}
+
+	public static class DeobfuscationMapFileModeConverter extends BaseEnumConverter<GeneratedRenamesMappingFileMode> {
+		public DeobfuscationMapFileModeConverter() {
+			super(GeneratedRenamesMappingFileMode::valueOf, GeneratedRenamesMappingFileMode::values);
+		}
+	}
+
+	public static class ResourceNameSourceConverter extends BaseEnumConverter<ResourceNameSource> {
+		public ResourceNameSourceConverter() {
+			super(ResourceNameSource::valueOf, ResourceNameSource::values);
+		}
+	}
+
+	public static class UseSourceNameAsClassNameConverter extends BaseEnumConverter<UseSourceNameAsClassNameAlias> {
+		public UseSourceNameAsClassNameConverter() {
+			super(UseSourceNameAsClassNameAlias::valueOf, UseSourceNameAsClassNameAlias::values);
+		}
+	}
+
+	public static class DecompilationModeConverter extends BaseEnumConverter<DecompilationMode> {
+		public DecompilationModeConverter() {
+			super(DecompilationMode::valueOf, DecompilationMode::values);
+		}
+	}
+
+	public static class LogLevelConverter extends BaseEnumConverter<LogHelper.LogLevelEnum> {
+		public LogLevelConverter() {
+			super(LogHelper.LogLevelEnum::valueOf, LogHelper.LogLevelEnum::values);
+		}
+	}
+
+	public static class IntegerFormatConverter extends BaseEnumConverter<IntegerFormat> {
+		public IntegerFormatConverter() {
+			super(IntegerFormat::valueOf, IntegerFormat::values);
+		}
+	}
+
+	public abstract static class BaseEnumConverter<E extends Enum<E>> implements IStringConverter<E> {
+		private final Function<String, E> parse;
+		private final Supplier<E[]> values;
+
+		public BaseEnumConverter(Function<String, E> parse, Supplier<E[]> values) {
+			this.parse = parse;
+			this.values = values;
+		}
+
+		@Override
+		public E convert(String value) {
+			try {
+				return parse.apply(stringAsEnumName(value));
+			} catch (Exception e) {
+				throw new JadxArgsValidateException(
+						'\'' + value + "' is unknown, possible values are: " + enumValuesString(values.get()));
+			}
+		}
+	}
+
+	public static String enumValuesString(Enum<?>[] values) {
+		return Stream.of(values)
+				.map(v -> v.name().replace('_', '-').toLowerCase(Locale.ROOT))
+				.collect(Collectors.joining(", "));
+	}
+
+	private static String stringAsEnumName(String value) {
+		// inverse of enumValuesString conversion
+		return value.replace('-', '_').toUpperCase(Locale.ROOT);
 	}
 }

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

@@ -0,0 +1,37 @@
+package jadx.cli;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import com.beust.jcommander.JCommander;
+
+import jadx.cli.commands.CommandPlugins;
+import jadx.cli.commands.ICommand;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+
+public class JadxCLICommands {
+	private static final Map<String, ICommand> COMMANDS_MAP = new LinkedHashMap<>();
+
+	static {
+		JadxCLICommands.register(new CommandPlugins());
+	}
+
+	public static void register(ICommand command) {
+		COMMANDS_MAP.put(command.name(), command);
+	}
+
+	public static void append(JCommander.Builder builder) {
+		COMMANDS_MAP.forEach(builder::addCommand);
+	}
+
+	public static boolean process(JCommanderWrapper<?> jcw, JCommander jc, String parsedCommand) {
+		ICommand command = COMMANDS_MAP.get(parsedCommand);
+		if (command == null) {
+			throw new JadxArgsValidateException("Unknown command: " + parsedCommand
+					+ ". Expected one of: " + COMMANDS_MAP.keySet());
+		}
+		JCommander subCommander = jc.getCommands().get(parsedCommand);
+		command.process(jcw, subCommander);
+		return true;
+	}
+}

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

@@ -0,0 +1,125 @@
+package jadx.cli;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.LoggerFactory;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+
+import jadx.api.JadxDecompiler;
+
+public class LogHelper {
+	private static final org.slf4j.Logger LOG = LoggerFactory.getLogger(LogHelper.class);
+
+	public enum LogLevelEnum {
+		QUIET(Level.OFF),
+		PROGRESS(Level.OFF),
+		ERROR(Level.ERROR),
+		WARN(Level.WARN),
+		INFO(Level.INFO),
+		DEBUG(Level.DEBUG);
+
+		private final Level level;
+
+		LogLevelEnum(Level level) {
+			this.level = level;
+		}
+
+		public Level getLevel() {
+			return level;
+		}
+	}
+
+	@Nullable("For disable log level control")
+	private static LogLevelEnum logLevelValue;
+
+	public static void initLogLevel(JadxCLIArgs args) {
+		logLevelValue = getLogLevelFromArgs(args);
+	}
+
+	private static LogLevelEnum getLogLevelFromArgs(JadxCLIArgs args) {
+		if (isCustomLogConfig()) {
+			return null;
+		}
+		if (args.quiet) {
+			return LogLevelEnum.QUIET;
+		}
+		if (args.verbose) {
+			return LogLevelEnum.DEBUG;
+		}
+		return args.logLevel;
+	}
+
+	public static void setLogLevel(LogLevelEnum newLogLevel) {
+		logLevelValue = newLogLevel;
+		applyLogLevel(logLevelValue);
+	}
+
+	public static void setLogLevelsForLoadingStage() {
+		if (logLevelValue == null) {
+			return;
+		}
+		if (logLevelValue == LogLevelEnum.PROGRESS) {
+			// show load errors
+			LogHelper.applyLogLevel(LogLevelEnum.ERROR);
+			fixForShowProgress();
+			return;
+		}
+		applyLogLevel(logLevelValue);
+	}
+
+	public static void setLogLevelsForDecompileStage() {
+		if (logLevelValue == null) {
+			return;
+		}
+		applyLogLevel(logLevelValue);
+		if (logLevelValue == LogLevelEnum.PROGRESS) {
+			fixForShowProgress();
+		}
+	}
+
+	/**
+	 * Show progress: change to 'INFO' for control classes
+	 */
+	private static void fixForShowProgress() {
+		setLevelForClass(JadxCLI.class, Level.INFO);
+		setLevelForClass(JadxDecompiler.class, Level.INFO);
+		setLevelForClass(SingleClassMode.class, Level.INFO);
+	}
+
+	private static void applyLogLevel(@NotNull LogLevelEnum logLevel) {
+		Logger rootLogger = (Logger) LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
+		rootLogger.setLevel(logLevel.getLevel());
+	}
+
+	@Nullable
+	public static LogLevelEnum getLogLevel() {
+		return logLevelValue;
+	}
+
+	public static void setLevelForClass(Class<?> cls, Level level) {
+		((Logger) LoggerFactory.getLogger(cls)).setLevel(level);
+	}
+
+	public static void setLevelForPackage(String pkgName, Level level) {
+		((Logger) LoggerFactory.getLogger(pkgName)).setLevel(level);
+	}
+
+	/**
+	 * Try to detect if user provide custom logback config via -Dlogback.configurationFile=
+	 */
+	private static boolean isCustomLogConfig() {
+		try {
+			String logbackConfig = System.getProperty("logback.configurationFile");
+			if (logbackConfig == null) {
+				return false;
+			}
+			LOG.debug("Use custom log config: {}", logbackConfig);
+			return true;
+		} catch (Exception e) {
+			LOG.error("Failed to detect custom log config", e);
+		}
+		return false;
+	}
+}

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

@@ -0,0 +1,88 @@
+package jadx.cli;
+
+import java.io.File;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.ICodeInfo;
+import jadx.api.JadxDecompiler;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.visitors.SaveCode;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.FileUtils;
+
+public class SingleClassMode {
+	private static final Logger LOG = LoggerFactory.getLogger(SingleClassMode.class);
+
+	public static boolean process(JadxDecompiler jadx, JadxCLIArgs cliArgs) {
+		String singleClass = cliArgs.getSingleClass();
+		String singleClassOutput = cliArgs.getSingleClassOutput();
+		if (singleClass == null && singleClassOutput == null) {
+			return false;
+		}
+		ClassNode clsForProcess;
+		if (singleClass != null) {
+			clsForProcess = jadx.getRoot().resolveClass(singleClass);
+			if (clsForProcess == null) {
+				clsForProcess = jadx.getRoot().getClasses().stream()
+						.filter(cls -> cls.getClassInfo().getAliasFullName().equals(singleClass))
+						.findFirst().orElse(null);
+			}
+			if (clsForProcess == null) {
+				throw new JadxArgsValidateException("Input class not found: " + singleClass);
+			}
+			if (clsForProcess.contains(AFlag.DONT_GENERATE)) {
+				throw new JadxArgsValidateException("Input class can't be saved by current jadx settings (marked as DONT_GENERATE)");
+			}
+			if (clsForProcess.isInner()) {
+				clsForProcess = clsForProcess.getTopParentClass();
+				LOG.warn("Input class is inner, parent class will be saved: {}", clsForProcess.getFullName());
+			}
+		} else {
+			// singleClassOutput is set
+			// expect only one class to be loaded
+			List<ClassNode> classes = jadx.getRoot().getClasses().stream()
+					.filter(c -> !c.isInner() && !c.contains(AFlag.DONT_GENERATE))
+					.collect(Collectors.toList());
+			int size = classes.size();
+			if (size == 1) {
+				clsForProcess = classes.get(0);
+			} else {
+				throw new JadxArgsValidateException("Found " + size + " classes, single class output can't be used");
+			}
+		}
+		ICodeInfo codeInfo;
+		try {
+			codeInfo = clsForProcess.decompile();
+		} catch (Exception e) {
+			throw new JadxRuntimeException("Class decompilation failed", e);
+		}
+		String fileExt = SaveCode.getFileExtension(jadx.getRoot());
+		File out;
+		if (singleClassOutput == null) {
+			out = new File(jadx.getArgs().getOutDirSrc(), clsForProcess.getClassInfo().getAliasFullPath() + fileExt);
+		} else {
+			if (singleClassOutput.endsWith(fileExt)) {
+				// treat as file name
+				out = new File(singleClassOutput);
+			} else {
+				// treat as directory
+				out = new File(singleClassOutput, clsForProcess.getShortName() + fileExt);
+			}
+		}
+		File resultOut = FileUtils.prepareFile(out);
+		if (clsForProcess.getClassInfo().hasAlias()) {
+			LOG.info("Saving class '{}' (alias: '{}') to file '{}'",
+					clsForProcess.getClassInfo().getFullName(), clsForProcess.getFullName(), resultOut.getAbsolutePath());
+		} else {
+			LOG.info("Saving class '{}' to file '{}'", clsForProcess.getFullName(), resultOut.getAbsolutePath());
+		}
+		SaveCode.save(codeInfo.getCodeStr(), resultOut);
+		return true;
+	}
+}

jadx-cli/src/main/java/jadx/cli/clst/ConvertToClsSet.java

@@ -0,0 +1,73 @@
+package jadx.cli.clst;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.JadxArgs;
+import jadx.api.JadxDecompiler;
+import jadx.api.args.UseSourceNameAsClassNameAlias;
+import jadx.core.clsp.ClsSet;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.files.FileUtils;
+
+/**
+ * Utility class for convert dex or jar to jadx classes set (.jcst)
+ */
+public class ConvertToClsSet {
+	private static final Logger LOG = LoggerFactory.getLogger(ConvertToClsSet.class);
+
+	public static void usage() {
+		LOG.info("<android API level (number)> <output .jcst file> <several input dex or jar files> ");
+		LOG.info("Arguments to update core.jcst: "
+				+ "<android API level (number)> "
+				+ "<jadx root>/jadx-core/src/main/resources/clst/core.jcst "
+				+ "<sdk_root>/platforms/android-<api level>/android.jar"
+				+ "<sdk_root>/platforms/android-<api level>/optional/android.car.jar "
+				+ "<sdk_root>/platforms/android-<api level>/optional/org.apache.http.legacy.jar");
+	}
+
+	public static void main(String[] args) {
+		if (args.length != 5) {
+			usage();
+			System.exit(1);
+		}
+		int androidApiLevel = Integer.parseInt(args[0]);
+		List<Path> inputPaths = Stream.of(args).skip(1).map(Paths::get).collect(Collectors.toList());
+		Path output = inputPaths.remove(0);
+
+		JadxArgs jadxArgs = new JadxArgs();
+		jadxArgs.setInputFiles(FileUtils.toFiles(inputPaths));
+
+		// disable not needed passes executed at prepare stage
+		jadxArgs.setDeobfuscationOn(false);
+		jadxArgs.setRenameFlags(EnumSet.noneOf(JadxArgs.RenameEnum.class));
+		jadxArgs.setUseSourceNameAsClassNameAlias(UseSourceNameAsClassNameAlias.NEVER);
+		jadxArgs.setMoveInnerClasses(false);
+		jadxArgs.setInlineAnonymousClasses(false);
+		jadxArgs.setInlineMethods(false);
+
+		// don't require/load class set file
+		jadxArgs.setLoadJadxClsSetFile(false);
+
+		try (JadxDecompiler decompiler = new JadxDecompiler(jadxArgs)) {
+			decompiler.load();
+			RootNode root = decompiler.getRoot();
+			ClsSet set = new ClsSet(root);
+			set.setAndroidApiLevel(androidApiLevel);
+			set.loadFrom(root);
+			set.save(output);
+
+			LOG.info("Output: {}", output);
+			LOG.info("done");
+		} catch (Exception e) {
+			LOG.error("Failed with error", e);
+		}
+	}
+}

jadx-cli/src/main/java/jadx/cli/commands/CommandPlugins.java

@@ -0,0 +1,204 @@
+package jadx.cli.commands;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import com.beust.jcommander.JCommander;
+import com.beust.jcommander.Parameter;
+import com.beust.jcommander.Parameters;
+
+import jadx.api.plugins.JadxPluginInfo;
+import jadx.cli.JCommanderWrapper;
+import jadx.cli.LogHelper;
+import jadx.core.utils.StringUtils;
+import jadx.plugins.tools.JadxPluginsList;
+import jadx.plugins.tools.JadxPluginsTools;
+import jadx.plugins.tools.data.JadxPluginMetadata;
+import jadx.plugins.tools.data.JadxPluginUpdate;
+
+@Parameters(commandDescription = "manage jadx plugins")
+public class CommandPlugins implements ICommand {
+
+	@Parameter(names = { "-i", "--install" }, description = "install plugin with locationId", defaultValueDescription = "<locationId>")
+	protected String install;
+
+	@Parameter(names = { "-j", "--install-jar" }, description = "install plugin from jar file", defaultValueDescription = "<path-to.jar>")
+	protected String installJar;
+
+	@Parameter(names = { "-l", "--list" }, description = "list installed plugins")
+	protected boolean list;
+
+	@Parameter(names = { "-a", "--available" }, description = "list available plugins from jadx-plugins-list (aka marketplace)")
+	protected boolean available;
+
+	@Parameter(names = { "-u", "--update" }, description = "update installed plugins")
+	protected boolean update;
+
+	@Parameter(names = { "--uninstall" }, description = "uninstall plugin with pluginId", defaultValueDescription = "<pluginId>")
+	protected String uninstall;
+
+	@Parameter(names = { "--disable" }, description = "disable plugin with pluginId", defaultValueDescription = "<pluginId>")
+	protected String disable;
+
+	@Parameter(names = { "--enable" }, description = "enable plugin with pluginId", defaultValueDescription = "<pluginId>")
+	protected String enable;
+
+	@Parameter(names = { "--list-all" }, description = "list all plugins including bundled and dropins")
+	protected boolean listAll;
+
+	@Parameter(
+			names = { "--list-versions" },
+			description = "fetch latest versions of plugin from locationId (will download all artefacts, limited to 10)",
+			defaultValueDescription = "<locationId>"
+	)
+	protected String listVersions;
+
+	@Parameter(names = { "-h", "--help" }, description = "print this help", help = true)
+	protected boolean printHelp = false;
+
+	@Override
+	public String name() {
+		return "plugins";
+	}
+
+	@SuppressWarnings("UnnecessaryReturnStatement")
+	@Override
+	public void process(JCommanderWrapper<?> jcw, JCommander subCommander) {
+		if (printHelp) {
+			jcw.printUsage(subCommander);
+			return;
+		}
+		Set<String> unknownOptions = new HashSet<>(subCommander.getUnknownOptions());
+		boolean verbose = unknownOptions.remove("-v") || unknownOptions.remove("--verbose");
+		LogHelper.setLogLevel(verbose ? LogHelper.LogLevelEnum.DEBUG : LogHelper.LogLevelEnum.INFO);
+
+		if (!unknownOptions.isEmpty()) {
+			System.out.println("Error: found unknown options: " + unknownOptions);
+		}
+
+		if (install != null) {
+			installPlugin(install);
+			return;
+		}
+		if (installJar != null) {
+			installPlugin("file:" + installJar);
+			return;
+		}
+		if (uninstall != null) {
+			boolean uninstalled = JadxPluginsTools.getInstance().uninstall(uninstall);
+			System.out.println(uninstalled ? "Uninstalled" : "Plugin not found");
+			return;
+		}
+		if (update) {
+			List<JadxPluginUpdate> updates = JadxPluginsTools.getInstance().updateAll();
+			if (updates.isEmpty()) {
+				System.out.println("No updates");
+			} else {
+				System.out.println("Installed updates: " + updates.size());
+				for (JadxPluginUpdate update : updates) {
+					System.out.println("  " + update.getPluginId() + ": " + update.getOldVersion() + " -> " + update.getNewVersion());
+				}
+			}
+			return;
+		}
+		if (list) {
+			printPlugins(JadxPluginsTools.getInstance().getInstalled());
+			return;
+		}
+		if (listAll) {
+			printAllPlugins();
+			return;
+		}
+		if (listVersions != null) {
+			printVersions(listVersions, 10);
+			return;
+		}
+		if (available) {
+			List<JadxPluginMetadata> availableList = JadxPluginsList.getInstance().get();
+			System.out.println("Available plugins: " + availableList.size());
+			for (JadxPluginMetadata plugin : availableList) {
+				System.out.println(" - " + plugin.getName() + ": " + plugin.getDescription()
+						+ " (" + plugin.getLocationId() + ")");
+			}
+			return;
+		}
+
+		if (disable != null) {
+			if (JadxPluginsTools.getInstance().changeDisabledStatus(disable, true)) {
+				System.out.println("Plugin '" + disable + "' disabled.");
+			} else {
+				System.out.println("Plugin '" + disable + "' already disabled.");
+			}
+			return;
+		}
+		if (enable != null) {
+			if (JadxPluginsTools.getInstance().changeDisabledStatus(enable, false)) {
+				System.out.println("Plugin '" + enable + "' enabled.");
+			} else {
+				System.out.println("Plugin '" + enable + "' already enabled.");
+			}
+			return;
+		}
+	}
+
+	private static void printPlugins(List<JadxPluginMetadata> installed) {
+		System.out.println("Installed plugins: " + installed.size());
+		for (JadxPluginMetadata plugin : installed) {
+			StringBuilder sb = new StringBuilder();
+			sb.append(" - ").append(plugin.getPluginId());
+			String version = plugin.getVersion();
+			if (version != null) {
+				sb.append(" (").append(version).append(')');
+			}
+			if (plugin.isDisabled()) {
+				sb.append(" (disabled)");
+			}
+			sb.append(" - ").append(plugin.getName());
+			sb.append(": ").append(plugin.getDescription());
+			System.out.println(sb);
+		}
+	}
+
+	private void printVersions(String locationId, int limit) {
+		System.out.println("Loading ...");
+		List<JadxPluginMetadata> versions = JadxPluginsTools.getInstance().getVersionsByLocation(locationId, 1, limit);
+		if (versions.isEmpty()) {
+			System.out.println("No versions found");
+			return;
+		}
+		JadxPluginMetadata plugin = versions.get(0);
+		System.out.println("Versions for plugin id: " + plugin.getPluginId());
+		for (JadxPluginMetadata version : versions) {
+			StringBuilder sb = new StringBuilder();
+			sb.append(" - ").append(version.getVersion());
+			String reqVer = version.getRequiredJadxVersion();
+			if (StringUtils.notBlank(reqVer)) {
+				sb.append(", require jadx: ").append(reqVer);
+			}
+			System.out.println(sb);
+		}
+	}
+
+	private static void printAllPlugins() {
+		List<JadxPluginMetadata> installed = JadxPluginsTools.getInstance().getInstalled();
+		printPlugins(installed);
+		Set<String> installedSet = installed.stream().map(JadxPluginMetadata::getPluginId).collect(Collectors.toSet());
+
+		List<JadxPluginInfo> plugins = JadxPluginsTools.getInstance().getAllPluginsInfo();
+		System.out.println("Other plugins: " + plugins.size());
+		for (JadxPluginInfo plugin : plugins) {
+			if (!installedSet.contains(plugin.getPluginId())) {
+				System.out.println(" - " + plugin.getPluginId()
+						+ " - " + plugin.getName()
+						+ ": " + plugin.getDescription());
+			}
+		}
+	}
+
+	private void installPlugin(String locationId) {
+		JadxPluginMetadata plugin = JadxPluginsTools.getInstance().install(locationId);
+		System.out.println("Plugin installed: " + plugin.getPluginId() + ":" + plugin.getVersion());
+	}
+}

jadx-cli/src/main/java/jadx/cli/commands/ICommand.java

@@ -0,0 +1,11 @@
+package jadx.cli.commands;
+
+import com.beust.jcommander.JCommander;
+
+import jadx.cli.JCommanderWrapper;
+
+public interface ICommand {
+	String name();
+
+	void process(JCommanderWrapper<?> jcw, JCommander subCommander);
+}

jadx-cli/src/main/java/jadx/cli/plugins/JadxFilesGetter.java

@@ -0,0 +1,31 @@
+package jadx.cli.plugins;
+
+import java.nio.file.Path;
+
+import jadx.commons.app.JadxCommonFiles;
+import jadx.commons.app.JadxTempFiles;
+import jadx.core.plugins.files.IJadxFilesGetter;
+
+public class JadxFilesGetter implements IJadxFilesGetter {
+
+	public static final JadxFilesGetter INSTANCE = new JadxFilesGetter();
+
+	@Override
+	public Path getConfigDir() {
+		return JadxCommonFiles.getConfigDir();
+	}
+
+	@Override
+	public Path getCacheDir() {
+		return JadxCommonFiles.getCacheDir();
+	}
+
+	@Override
+	public Path getTempDir() {
+		return JadxTempFiles.getTempRootDir();
+	}
+
+	private JadxFilesGetter() {
+		// singleton
+	}
+}

jadx-cli/src/main/java/jadx/cli/tools/ConvertArscFile.java

@@ -0,0 +1,110 @@
+package jadx.cli.tools;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.JadxArgs;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.android.TextResMapFile;
+import jadx.core.utils.files.ZipFile;
+import jadx.core.xmlgen.ResTableBinaryParser;
+
+import static jadx.core.utils.files.FileUtils.expandDirs;
+
+/**
+ * Utility class for convert '.arsc' to simple text file with mapping id to resource name
+ */
+public class ConvertArscFile {
+	private static final Logger LOG = LoggerFactory.getLogger(ConvertArscFile.class);
+	private static int rewritesCount;
+
+	public static void usage() {
+		LOG.info("<res-map file> <input .arsc/android.jar files or dir>");
+		LOG.info("");
+		LOG.info("Note: If res-map already exists - it will be merged and updated");
+	}
+
+	public static void main(String[] args) throws IOException {
+		if (args.length < 2) {
+			usage();
+			System.exit(1);
+		}
+		List<Path> inputPaths = Stream.of(args).map(Paths::get).collect(Collectors.toList());
+		Path resMapFile = inputPaths.remove(0);
+		List<Path> inputResFiles = filterAndSort(expandDirs(inputPaths));
+		Map<Integer, String> resMap;
+		if (Files.isReadable(resMapFile)) {
+			resMap = TextResMapFile.read(resMapFile);
+		} else {
+			resMap = new HashMap<>();
+		}
+		LOG.info("Input entries count: {}", resMap.size());
+
+		RootNode root = new RootNode(new JadxArgs()); // not really needed
+		rewritesCount = 0;
+		for (Path resFile : inputResFiles) {
+			ResTableBinaryParser resTableParser = new ResTableBinaryParser(root, true);
+			if (resFile.getFileName().toString().endsWith(".jar")) {
+				// Load resources.arsc from android.jar
+				try (ZipFile zip = new ZipFile(resFile.toFile())) {
+					ZipEntry entry = zip.getEntry("resources.arsc");
+					if (entry == null) {
+						LOG.error("Failed to load \"resources.arsc\" from {}", resFile);
+						continue;
+					}
+					try (InputStream inputStream = zip.getInputStream(entry)) {
+						resTableParser.decode(inputStream);
+					}
+				}
+			} else {
+				// Load resources.arsc from extracted file
+				try (InputStream inputStream = new BufferedInputStream(Files.newInputStream(resFile))) {
+					resTableParser.decode(inputStream);
+				}
+			}
+			Map<Integer, String> singleResMap = resTableParser.getResStorage().getResourcesNames();
+			mergeResMaps(resMap, singleResMap);
+			LOG.info("{} entries count: {}, after merge: {}", resFile.getFileName(), singleResMap.size(), resMap.size());
+		}
+		LOG.info("Output entries count: {}", resMap.size());
+		LOG.info("Total rewrites count: {}", rewritesCount);
+		TextResMapFile.write(resMapFile, resMap);
+		LOG.info("Result file size: {} B", resMapFile.toFile().length());
+		LOG.info("done");
+	}
+
+	private static List<Path> filterAndSort(List<Path> inputPaths) {
+		return inputPaths.stream()
+				.filter(p -> {
+					String fileName = p.getFileName().toString();
+					return fileName.endsWith(".arsc") || fileName.endsWith(".jar");
+				})
+				.sorted()
+				.collect(Collectors.toList());
+	}
+
+	private static void mergeResMaps(Map<Integer, String> mainResMap, Map<Integer, String> newResMap) {
+		for (Map.Entry<Integer, String> entry : newResMap.entrySet()) {
+			Integer id = entry.getKey();
+			String name = entry.getValue();
+			String prevName = mainResMap.put(id, name);
+			if (prevName != null && !name.equals(prevName)) {
+				LOG.debug("Rewrite id: {} from: '{}' to: '{}'", Integer.toHexString(id), prevName, name);
+				rewritesCount++;
+			}
+		}
+	}
+}

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

@@ -1,13 +1,16 @@
+<!-- Jadx logger config. Used both in cli and gui -->
+
 <configuration>
+	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+		<encoder>
+			<pattern>%-5level - %msg%n</pattern>
+		</encoder>
+	</appender>
 
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>%-5level - %msg%n</pattern>
-        </encoder>
-    </appender>
-
-    <root level="INFO">
-        <appender-ref ref="STDOUT"/>
-    </root>
+	<!-- jadx-gui -->
+	<logger name="com.pinterest.ktlint" level="INFO"/>
 
+	<root level="INFO">
+		<appender-ref ref="STDOUT"/>
+	</root>
 </configuration>

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

@@ -0,0 +1,104 @@
+package jadx.cli;
+
+import java.util.Collections;
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static jadx.core.utils.Utils.newConstStringMap;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class JadxCLIArgsTest {
+
+	private static final Logger LOG = LoggerFactory.getLogger(JadxCLIArgsTest.class);
+
+	@Test
+	public void testInvertedBooleanOption() {
+		assertThat(parse("--no-replace-consts").isReplaceConsts()).isFalse();
+		assertThat(parse("").isReplaceConsts()).isTrue();
+	}
+
+	@Test
+	public void testEscapeUnicodeOption() {
+		assertThat(parse("--escape-unicode").isEscapeUnicode()).isTrue();
+		assertThat(parse("").isEscapeUnicode()).isFalse();
+	}
+
+	@Test
+	public void testSrcOption() {
+		assertThat(parse("--no-src").isSkipSources()).isTrue();
+		assertThat(parse("-s").isSkipSources()).isTrue();
+		assertThat(parse("").isSkipSources()).isFalse();
+	}
+
+	@Test
+	public void testOptionsOverride() {
+		assertThat(override(new JadxCLIArgs(), "--no-imports").isUseImports()).isFalse();
+		assertThat(override(new JadxCLIArgs(), "--no-debug-info").isDebugInfo()).isFalse();
+		assertThat(override(new JadxCLIArgs(), "").isUseImports()).isTrue();
+
+		JadxCLIArgs args = new JadxCLIArgs();
+		args.useImports = false;
+		assertThat(override(args, "--no-imports").isUseImports()).isFalse();
+		args.debugInfo = false;
+		assertThat(override(args, "--no-debug-info").isDebugInfo()).isFalse();
+
+		args = new JadxCLIArgs();
+		args.useImports = false;
+		assertThat(override(args, "").isUseImports()).isFalse();
+	}
+
+	@Test
+	public void testPluginOptionsOverride() {
+		// add key to empty base map
+		checkPluginOptionsMerge(
+				Collections.emptyMap(),
+				"-Poption=otherValue",
+				newConstStringMap("option", "otherValue"));
+
+		// override one key
+		checkPluginOptionsMerge(
+				newConstStringMap("option", "value"),
+				"-Poption=otherValue",
+				newConstStringMap("option", "otherValue"));
+
+		// merge different keys
+		checkPluginOptionsMerge(
+				Collections.singletonMap("option1", "value1"),
+				"-Poption2=otherValue2",
+				newConstStringMap("option1", "value1", "option2", "otherValue2"));
+
+		// merge and override
+		checkPluginOptionsMerge(
+				newConstStringMap("option1", "value1", "option2", "value2"),
+				"-Poption2=otherValue2",
+				newConstStringMap("option1", "value1", "option2", "otherValue2"));
+	}
+
+	private void checkPluginOptionsMerge(Map<String, String> baseMap, String providedArgs, Map<String, String> expectedMap) {
+		JadxCLIArgs args = new JadxCLIArgs();
+		args.pluginOptions = baseMap;
+		Map<String, String> resultMap = override(args, providedArgs).getPluginOptions();
+		assertThat(resultMap).isEqualTo(expectedMap);
+	}
+
+	private JadxCLIArgs parse(String... args) {
+		return parse(new JadxCLIArgs(), args);
+	}
+
+	private JadxCLIArgs parse(JadxCLIArgs jadxArgs, String... args) {
+		return check(jadxArgs, jadxArgs.processArgs(args));
+	}
+
+	private JadxCLIArgs override(JadxCLIArgs jadxArgs, String... args) {
+		return check(jadxArgs, jadxArgs.overrideProvided(args));
+	}
+
+	private static JadxCLIArgs check(JadxCLIArgs jadxArgs, boolean res) {
+		assertThat(res).isTrue();
+		LOG.info("Jadx args: {}", jadxArgs.toJadxArgs());
+		return jadxArgs;
+	}
+}

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

@@ -0,0 +1,47 @@
+package jadx.cli;
+
+import java.util.Set;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import jadx.api.JadxArgs.RenameEnum;
+import jadx.cli.JadxCLIArgs.RenameConverter;
+import jadx.core.utils.exceptions.JadxArgsValidateException;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+public class RenameConverterTest {
+
+	private RenameConverter converter;
+
+	@BeforeEach
+	public void init() {
+		converter = new RenameConverter("someParam");
+	}
+
+	@Test
+	public void all() {
+		Set<RenameEnum> set = converter.convert("all");
+		assertThat(set).hasSize(3);
+		assertThat(set).contains(RenameEnum.CASE);
+		assertThat(set).contains(RenameEnum.VALID);
+		assertThat(set).contains(RenameEnum.PRINTABLE);
+	}
+
+	@Test
+	public void none() {
+		Set<RenameEnum> set = converter.convert("none");
+		assertThat(set).isEmpty();
+	}
+
+	@Test
+	public void wrong() {
+		JadxArgsValidateException thrown = assertThrows(JadxArgsValidateException.class,
+				() -> converter.convert("wrong"),
+				"Expected convert() to throw, but it didn't");
+
+		assertThat(thrown.getMessage()).isEqualTo("'wrong' is unknown for parameter someParam, possible values are case, valid, printable");
+	}
+}

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

@@ -0,0 +1,158 @@
+package jadx.cli;
+
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.Path;
+import java.nio.file.PathMatcher;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.assertj.core.api.Condition;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class TestInput {
+	private static final Logger LOG = LoggerFactory.getLogger(TestInput.class);
+
+	private static final PathMatcher LOG_ALL_FILES = path -> {
+		LOG.debug("File in result dir: {}", path);
+		return true;
+	};
+
+	@TempDir
+	Path testDir;
+
+	@Test
+	public void testHelp() {
+		int result = JadxCLI.execute(new String[] { "--help" });
+		assertThat(result).isEqualTo(0);
+	}
+
+	@Test
+	public void testApkInput() throws Exception {
+		int result = JadxCLI.execute(buildArgs(List.of(), "samples/small.apk"));
+		assertThat(result).isEqualTo(0);
+		List<Path> resultFiles = collectAllFilesInDir(testDir);
+		printFiles(resultFiles);
+		assertThat(resultFiles)
+				.describedAs("check output files")
+				.map(p -> p.getFileName().toString())
+				.haveExactly(2, new Condition<>(f -> f.endsWith(".java"), "java classes"))
+				.haveExactly(9, new Condition<>(f -> f.endsWith(".xml"), "xml resources"))
+				.haveExactly(1, new Condition<>(f -> f.equals("classes.dex"), "dex"))
+				.haveExactly(1, new Condition<>(f -> f.equals("AndroidManifest.xml"), "manifest"))
+				.hasSize(13);
+	}
+
+	@Test
+	public void testDexInput() throws Exception {
+		decompile("samples/hello.dex");
+	}
+
+	@Test
+	public void testSmaliInput() throws Exception {
+		decompile("samples/HelloWorld.smali");
+	}
+
+	@Test
+	public void testClassInput() throws Exception {
+		decompile("samples/HelloWorld.class");
+	}
+
+	@Test
+	public void testMultipleInput() throws Exception {
+		decompile("samples/hello.dex", "samples/HelloWorld.smali");
+	}
+
+	@Test
+	public void testFallbackMode() throws Exception {
+		int result = JadxCLI.execute(buildArgs(List.of("-f"), "samples/hello.dex"));
+		assertThat(result).isEqualTo(0);
+		List<Path> files = collectJavaFilesInDir(testDir);
+		assertThat(files).hasSize(1);
+	}
+
+	@Test
+	public void testSimpleMode() throws Exception {
+		int result = JadxCLI.execute(buildArgs(List.of("--decompilation-mode", "simple"), "samples/hello.dex"));
+		assertThat(result).isEqualTo(0);
+		List<Path> files = collectJavaFilesInDir(testDir);
+		assertThat(files).hasSize(1);
+	}
+
+	@Test
+	public void testResourceOnly() throws Exception {
+		int result = JadxCLI.execute(buildArgs(List.of(), "samples/resources-only.apk"));
+		assertThat(result).isEqualTo(0);
+		List<Path> files = collectFilesInDir(testDir,
+				path -> path.getFileName().toString().equalsIgnoreCase("AndroidManifest.xml"));
+		assertThat(files).isNotEmpty();
+	}
+
+	private void decompile(String... inputSamples) throws URISyntaxException, IOException {
+		int result = JadxCLI.execute(buildArgs(List.of(), inputSamples));
+		assertThat(result).isEqualTo(0);
+		List<Path> resultJavaFiles = collectJavaFilesInDir(testDir);
+		assertThat(resultJavaFiles).isNotEmpty();
+
+		// do not copy input files as resources
+		for (Path path : collectFilesInDir(testDir, LOG_ALL_FILES)) {
+			for (String inputSample : inputSamples) {
+				assertThat(path.toAbsolutePath().toString()).doesNotContain(inputSample);
+			}
+		}
+	}
+
+	private String[] buildArgs(List<String> options, String... inputSamples) throws URISyntaxException {
+		List<String> args = new ArrayList<>(options);
+		args.add("-v");
+		args.add("-d");
+		args.add(testDir.toAbsolutePath().toString());
+
+		for (String inputSample : inputSamples) {
+			URL resource = getClass().getClassLoader().getResource(inputSample);
+			assertThat(resource).isNotNull();
+			String sampleFile = resource.toURI().getRawPath();
+			args.add(sampleFile);
+		}
+		return args.toArray(new String[0]);
+	}
+
+	private void printFiles(List<Path> files) {
+		LOG.info("Output files (count: {}):", files.size());
+		for (Path file : files) {
+			LOG.info(" {}", testDir.relativize(file));
+		}
+	}
+
+	private static List<Path> collectJavaFilesInDir(Path dir) throws IOException {
+		PathMatcher javaMatcher = dir.getFileSystem().getPathMatcher("glob:**.java");
+		return collectFilesInDir(dir, javaMatcher);
+	}
+
+	private static List<Path> collectAllFilesInDir(Path dir) throws IOException {
+		try (Stream<Path> pathStream = Files.walk(dir)) {
+			return pathStream
+					.filter(Files::isRegularFile)
+					.collect(Collectors.toList());
+		}
+	}
+
+	private static List<Path> collectFilesInDir(Path dir, PathMatcher matcher) throws IOException {
+		try (Stream<Path> pathStream = Files.walk(dir)) {
+			return pathStream
+					.filter(p -> Files.isRegularFile(p, LinkOption.NOFOLLOW_LINKS))
+					.filter(matcher::matches)
+					.collect(Collectors.toList());
+		}
+	}
+}

jadx-cli/src/test/resources/samples/HelloWorld.smali

@@ -0,0 +1,26 @@
+.class Lsmali/HelloWorld;
+.super Ljava/lang/Object;
+.source "HelloWorld.java"
+
+.method constructor <init>()V
+    .registers 1
+
+    .line 1
+    invoke-direct {p0}, Ljava/lang/Object;-><init>()V
+
+    return-void
+.end method
+
+.method public static main([Ljava/lang/String;)V
+    .registers 2
+
+    .line 3
+    sget-object p0, Ljava/lang/System;->out:Ljava/io/PrintStream;
+
+    const-string v0, "Hello, World"
+
+    invoke-virtual {p0, v0}, Ljava/io/PrintStream;->println(Ljava/lang/String;)V
+
+    .line 4
+    return-void
+.end method

jadx-commons/jadx-app-commons/README.md

@@ -0,0 +1,6 @@
+## jadx app commons
+
+This module contains common utilities used in jadx apps (cli and gui) and not needed in jadx-code module:
+- `JadxCommonFiles` - wrapper for `dev.dirs:directories` lib to get
+  'config' and 'cache' directories in cross-platform way
+- `JadxCommonEnv` - utils for work with environment variables

jadx-commons/jadx-app-commons/build.gradle.kts

@@ -0,0 +1,7 @@
+plugins {
+	id("jadx-library")
+}
+
+dependencies {
+	implementation("dev.dirs:directories:26")
+}

jadx-commons/jadx-app-commons/src/main/java/jadx/commons/app/JadxCommonEnv.java

@@ -0,0 +1,29 @@
+package jadx.commons.app;
+
+public class JadxCommonEnv {
+
+	public static String get(String varName, String defValue) {
+		String strValue = System.getenv(varName);
+		return isNullOrEmpty(strValue) ? defValue : strValue;
+	}
+
+	public static boolean getBool(String varName, boolean defValue) {
+		String strValue = System.getenv(varName);
+		if (isNullOrEmpty(strValue)) {
+			return defValue;
+		}
+		return strValue.equalsIgnoreCase("true");
+	}
+
+	public static int getInt(String varName, int defValue) {
+		String strValue = System.getenv(varName);
+		if (isNullOrEmpty(strValue)) {
+			return defValue;
+		}
+		return Integer.parseInt(strValue);
+	}
+
+	private static boolean isNullOrEmpty(String value) {
+		return value == null || value.isEmpty();
+	}
+}

jadx-commons/jadx-app-commons/src/main/java/jadx/commons/app/JadxCommonFiles.java

@@ -0,0 +1,74 @@
+package jadx.commons.app;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.function.Function;
+
+import org.jetbrains.annotations.Nullable;
+
+import dev.dirs.ProjectDirectories;
+
+public class JadxCommonFiles {
+
+	private static final Path CONFIG_DIR;
+	private static final Path CACHE_DIR;
+
+	public static Path getConfigDir() {
+		return CONFIG_DIR;
+	}
+
+	public static Path getCacheDir() {
+		return CACHE_DIR;
+	}
+
+	static {
+		DirsLoader loader = new DirsLoader();
+		loader.init();
+		CONFIG_DIR = loader.getConfigDir();
+		CACHE_DIR = loader.getCacheDir();
+	}
+
+	private static final class DirsLoader {
+		private @Nullable ProjectDirectories dirs;
+		private Path configDir;
+		private Path cacheDir;
+
+		public void init() {
+			try {
+				configDir = loadEnvDir("JADX_CONFIG_DIR", pd -> pd.configDir);
+				cacheDir = loadEnvDir("JADX_CACHE_DIR", pd -> pd.cacheDir);
+			} catch (Exception e) {
+				throw new RuntimeException("Failed to init common directories", e);
+			}
+		}
+
+		private Path loadEnvDir(String envVar, Function<ProjectDirectories, String> dirFunc) throws IOException {
+			String envDir = JadxCommonEnv.get(envVar, null);
+			String dirStr;
+			if (envDir != null) {
+				dirStr = envDir;
+			} else {
+				dirStr = dirFunc.apply(loadDirs());
+			}
+			Path path = Path.of(dirStr).toAbsolutePath();
+			Files.createDirectories(path);
+			return path;
+		}
+
+		private synchronized ProjectDirectories loadDirs() {
+			if (dirs == null) {
+				dirs = ProjectDirectories.from("io.github", "skylot", "jadx");
+			}
+			return dirs;
+		}
+
+		public Path getCacheDir() {
+			return cacheDir;
+		}
+
+		public Path getConfigDir() {
+			return configDir;
+		}
+	}
+}

jadx-commons/jadx-app-commons/src/main/java/jadx/commons/app/JadxTempFiles.java

@@ -0,0 +1,31 @@
+package jadx.commons.app;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class JadxTempFiles {
+	private static final String JADX_TMP_INSTANCE_PREFIX = "jadx-instance-";
+
+	private static final Path TEMP_ROOT_DIR = createTempRootDir();
+
+	public static Path getTempRootDir() {
+		return TEMP_ROOT_DIR;
+	}
+
+	private static Path createTempRootDir() {
+		try {
+			String jadxTmpDir = System.getenv("JADX_TMP_DIR");
+			Path dir;
+			if (jadxTmpDir != null) {
+				dir = Files.createTempDirectory(Paths.get(jadxTmpDir), JADX_TMP_INSTANCE_PREFIX);
+			} else {
+				dir = Files.createTempDirectory(JADX_TMP_INSTANCE_PREFIX);
+			}
+			dir.toFile().deleteOnExit();
+			return dir;
+		} catch (Exception e) {
+			throw new RuntimeException("Failed to create temp root directory", e);
+		}
+	}
+}

jadx-core/build.gradle

@@ -1,9 +0,0 @@
-ext.jadxClasspath = 'clsp-data/android-4.3.jar'
-
-dependencies {
-    compile 'com.google.android.tools:dx:1.7'
-    compile 'ch.qos.logback:logback-classic:1.0.13'
-
-    runtime files(jadxClasspath)
-}
-

jadx-core/build.gradle.kts

@@ -0,0 +1,54 @@
+plugins {
+	id("jadx-library")
+}
+
+dependencies {
+	api(project(":jadx-plugins:jadx-input-api"))
+
+	implementation("com.google.code.gson:gson:2.11.0")
+
+	testImplementation("org.apache.commons:commons-lang3:3.17.0")
+
+	testImplementation(project(":jadx-plugins:jadx-dex-input"))
+	testRuntimeOnly(project(":jadx-plugins:jadx-smali-input"))
+	testRuntimeOnly(project(":jadx-plugins:jadx-java-convert"))
+	testRuntimeOnly(project(":jadx-plugins:jadx-java-input"))
+	testRuntimeOnly(project(":jadx-plugins:jadx-raung-input"))
+
+	testImplementation("org.eclipse.jdt:ecj") {
+		version {
+			prefer("3.33.0")
+			strictly("[3.33, 3.34[") // from 3.34 compiled with Java 17
+		}
+	}
+	testImplementation("tools.profiler:async-profiler:3.0")
+}
+
+val jadxTestJavaVersion = getTestJavaVersion()
+
+fun getTestJavaVersion(): Int? {
+	val envVarName = "JADX_TEST_JAVA_VERSION"
+	val testJavaVer = System.getenv(envVarName)?.toInt() ?: return null
+	val currentJavaVer = java.toolchain.languageVersion.get().asInt()
+	if (testJavaVer < currentJavaVer) {
+		throw GradleException("'$envVarName' can't be set to lower version than $currentJavaVer")
+	}
+	println("Set Java toolchain for core tests to version '$testJavaVer'")
+	return testJavaVer
+}
+
+tasks.named<Test>("test") {
+	jadxTestJavaVersion?.let { testJavaVer ->
+		javaLauncher =
+			javaToolchains.launcherFor {
+				languageVersion = JavaLanguageVersion.of(testJavaVer)
+			}
+	}
+
+	// disable cache to allow test's rerun,
+	// because most tests are integration and depends on plugins and environment
+	outputs.cacheIf { false }
+
+	// exclude temp tests
+	exclude("**/tmp/*")
+}

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

@@ -0,0 +1,14 @@
+package jadx.api;
+
+public enum CommentsLevel {
+	NONE,
+	USER_ONLY,
+	ERROR,
+	WARN,
+	INFO,
+	DEBUG;
+
+	public boolean filter(CommentsLevel limit) {
+		return this.ordinal() <= limit.ordinal();
+	}
+}

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

@@ -0,0 +1,23 @@
+package jadx.api;
+
+public enum DecompilationMode {
+	/**
+	 * Trying best options (default)
+	 */
+	AUTO,
+
+	/**
+	 * Restore code structure (normal java code)
+	 */
+	RESTRUCTURE,
+
+	/**
+	 * Simplified instructions (linear with goto's)
+	 */
+	SIMPLE,
+
+	/**
+	 * Raw instructions without modifications
+	 */
+	FALLBACK
+}

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

@@ -1,198 +0,0 @@
-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.ErrorsCounter;
-import jadx.core.utils.exceptions.CodegenException;
-import jadx.core.utils.exceptions.DecodeException;
-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.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Jadx API usage example:
- * <pre><code>
- *  Decompiler jadx = new Decompiler();
- *  jadx.loadFile(new File("classes.dex"));
- *  jadx.setOutputDir(new File("out"));
- *  jadx.save();
- * </code></pre>
- * <p/>
- * Instead of 'save()' you can get list of decompiled classes:
- * <pre><code>
- *  for(JavaClass cls : jadx.getClasses()) {
- *      System.out.println(cls.getCode());
- *  }
- * </code></pre>
- */
-public final class Decompiler {
-	private static final Logger LOG = LoggerFactory.getLogger(Decompiler.class);
-
-	private final IJadxArgs args;
-	private final List<InputFile> inputFiles = new ArrayList<InputFile>();
-
-	private File outDir;
-
-	private RootNode root;
-	private List<IDexTreeVisitor> passes;
-
-	public Decompiler() {
-		this.args = new DefaultJadxArgs();
-		init();
-	}
-
-	public Decompiler(IJadxArgs jadxArgs) {
-		this.args = jadxArgs;
-		init();
-	}
-
-	public void setOutputDir(File outDir) {
-		this.outDir = outDir;
-		init();
-	}
-
-	void init() {
-		if (outDir == null) {
-			outDir = new File("jadx-output");
-		}
-		this.passes = Jadx.getPassesList(args, outDir);
-	}
-
-	public void loadFile(File file) throws IOException, DecodeException {
-		loadFiles(Arrays.asList(file));
-	}
-
-	public void loadFiles(List<File> files) throws IOException, DecodeException {
-		if (files.isEmpty()) {
-			throw new JadxRuntimeException("Empty file list");
-		}
-		inputFiles.clear();
-		for (File file : files) {
-			inputFiles.add(new InputFile(file));
-		}
-		parse();
-	}
-
-	public void save() {
-		try {
-			ExecutorService ex = getSaveExecutor();
-			ex.awaitTermination(1, TimeUnit.DAYS);
-		} catch (InterruptedException e) {
-			LOG.error("Save interrupted", e);
-		}
-	}
-
-	public ThreadPoolExecutor getSaveExecutor() {
-		if (root == null) {
-			throw new JadxRuntimeException("No loaded files");
-		}
-		int threadsCount = args.getThreadsCount();
-		LOG.debug("processing threads count: {}", threadsCount);
-
-		ArrayList<IDexTreeVisitor> passList = new ArrayList<IDexTreeVisitor>(passes);
-		SaveCode savePass = new SaveCode(outDir, args);
-		passList.add(savePass);
-
-		LOG.info("processing ...");
-		ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(threadsCount);
-		for (ClassNode cls : root.getClasses(false)) {
-			if (cls.getCode() == null) {
-				ProcessClass job = new ProcessClass(cls, passList);
-				executor.execute(job);
-			} else {
-				try {
-					savePass.visit(cls);
-				} catch (CodegenException e) {
-					LOG.error("Can't save class {}", cls, e);
-				}
-			}
-		}
-		executor.shutdown();
-		return executor;
-	}
-
-	public List<JavaClass> getClasses() {
-		List<ClassNode> classNodeList = root.getClasses(false);
-		List<JavaClass> classes = new ArrayList<JavaClass>(classNodeList.size());
-		for (ClassNode classNode : classNodeList) {
-			classes.add(new JavaClass(this, classNode));
-		}
-		return Collections.unmodifiableList(classes);
-	}
-
-	public List<JavaPackage> getPackages() {
-		List<JavaClass> classes = getClasses();
-		Map<String, List<JavaClass>> map = new HashMap<String, List<JavaClass>>();
-		for (JavaClass javaClass : classes) {
-			String pkg = javaClass.getPackage();
-			List<JavaClass> clsList = map.get(pkg);
-			if (clsList == null) {
-				clsList = new ArrayList<JavaClass>();
-				map.put(pkg, clsList);
-			}
-			clsList.add(javaClass);
-		}
-		List<JavaPackage> packages = new ArrayList<JavaPackage>(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.getShortName().compareTo(o2.getShortName());
-				}
-			});
-		}
-		return Collections.unmodifiableList(packages);
-	}
-
-	public int getErrorsCount() {
-		return ErrorsCounter.getErrorCount();
-	}
-
-	void parse() throws DecodeException {
-		ClassInfo.clearCache();
-		ErrorsCounter.reset();
-
-		root = new RootNode();
-		LOG.info("loading ...");
-		root.load(inputFiles);
-	}
-
-	void processClass(ClassNode cls) {
-		try {
-			ProcessClass job = new ProcessClass(cls, passes);
-			LOG.info("processing class {} ...", cls);
-			job.run();
-		} catch (Throwable e) {
-			LOG.error("Process class error", e);
-		}
-	}
-
-	RootNode getRoot() {
-		return root;
-	}
-}

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

@@ -1,29 +0,0 @@
-package jadx.api;
-
-public class DefaultJadxArgs implements IJadxArgs {
-
-	@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/ICodeCache.java

@@ -0,0 +1,21 @@
+package jadx.api;
+
+import java.io.Closeable;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public interface ICodeCache extends Closeable {
+
+	void add(String clsFullName, ICodeInfo codeInfo);
+
+	void remove(String clsFullName);
+
+	@NotNull
+	ICodeInfo get(String clsFullName);
+
+	@Nullable
+	String getCode(String clsFullName);
+
+	boolean contains(String clsFullName);
+}

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

@@ -0,0 +1,15 @@
+package jadx.api;
+
+import jadx.api.impl.SimpleCodeInfo;
+import jadx.api.metadata.ICodeMetadata;
+
+public interface ICodeInfo {
+
+	ICodeInfo EMPTY = new SimpleCodeInfo("");
+
+	String getCodeStr();
+
+	ICodeMetadata getCodeMetadata();
+
+	boolean hasMetadata();
+}

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

@@ -0,0 +1,70 @@
+package jadx.api;
+
+import java.util.Map;
+
+import org.jetbrains.annotations.ApiStatus;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+
+public interface ICodeWriter {
+
+	boolean isMetadataSupported();
+
+	ICodeWriter startLine();
+
+	ICodeWriter startLine(char c);
+
+	ICodeWriter startLine(String str);
+
+	ICodeWriter startLineWithNum(int sourceLine);
+
+	ICodeWriter addMultiLine(String str);
+
+	ICodeWriter add(String str);
+
+	ICodeWriter add(char c);
+
+	ICodeWriter add(ICodeWriter code);
+
+	ICodeWriter newLine();
+
+	ICodeWriter addIndent();
+
+	void incIndent();
+
+	void decIndent();
+
+	int getIndent();
+
+	void setIndent(int indent);
+
+	/**
+	 * Return current line (only if metadata is supported)
+	 */
+	int getLine();
+
+	/**
+	 * Return start line position (only if metadata is supported)
+	 */
+	int getLineStartPos();
+
+	void attachDefinition(ICodeNodeRef obj);
+
+	void attachAnnotation(ICodeAnnotation obj);
+
+	void attachLineAnnotation(ICodeAnnotation obj);
+
+	void attachSourceLine(int sourceLine);
+
+	ICodeInfo finish();
+
+	String getCodeStr();
+
+	int getLength();
+
+	StringBuilder getRawBuf();
+
+	@ApiStatus.Internal
+	Map<Integer, ICodeAnnotation> getRawAnnotations();
+}

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

@@ -0,0 +1,7 @@
+package jadx.api;
+
+import java.util.List;
+
+public interface IDecompileScheduler {
+	List<List<JavaClass>> buildBatches(List<JavaClass> classes);
+}

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

@@ -1,13 +0,0 @@
-package jadx.api;
-
-public interface IJadxArgs {
-	int getThreadsCount();
-
-	boolean isCFGOutput();
-
-	boolean isRawCFGOutput();
-
-	boolean isFallbackMode();
-
-	boolean isVerbose();
-}

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

@@ -0,0 +1,868 @@
+package jadx.api;
+
+import java.io.Closeable;
+import java.io.File;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.args.GeneratedRenamesMappingFileMode;
+import jadx.api.args.IntegerFormat;
+import jadx.api.args.ResourceNameSource;
+import jadx.api.args.UseSourceNameAsClassNameAlias;
+import jadx.api.args.UserRenamesMappingsMode;
+import jadx.api.data.ICodeData;
+import jadx.api.deobf.IAliasProvider;
+import jadx.api.deobf.IRenameCondition;
+import jadx.api.impl.AnnotatedCodeWriter;
+import jadx.api.impl.InMemoryCodeCache;
+import jadx.api.plugins.loader.JadxBasePluginLoader;
+import jadx.api.plugins.loader.JadxPluginLoader;
+import jadx.api.security.IJadxSecurity;
+import jadx.api.security.JadxSecurityFlag;
+import jadx.api.security.impl.JadxSecurity;
+import jadx.api.usage.IUsageInfoCache;
+import jadx.api.usage.impl.InMemoryUsageInfoCache;
+import jadx.core.deobf.DeobfAliasProvider;
+import jadx.core.deobf.conditions.DeobfWhitelist;
+import jadx.core.deobf.conditions.JadxRenameConditions;
+import jadx.core.plugins.PluginContext;
+import jadx.core.plugins.files.IJadxFilesGetter;
+import jadx.core.plugins.files.TempFilesGetter;
+import jadx.core.utils.files.FileUtils;
+
+public class JadxArgs implements Closeable {
+	private static final Logger LOG = LoggerFactory.getLogger(JadxArgs.class);
+
+	public static final int DEFAULT_THREADS_COUNT = Math.max(1, Runtime.getRuntime().availableProcessors() / 2);
+
+	public static final String DEFAULT_NEW_LINE_STR = System.lineSeparator();
+	public static final String DEFAULT_INDENT_STR = "    ";
+
+	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 ICodeCache codeCache = new InMemoryCodeCache();
+
+	/**
+	 * Usage data cache. Saves use places of classes, methods and fields between code reloads.
+	 * Can be set to {@link jadx.api.usage.impl.EmptyUsageInfoCache} if code reload not needed.
+	 */
+	private IUsageInfoCache usageInfoCache = new InMemoryUsageInfoCache();
+
+	private Function<JadxArgs, ICodeWriter> codeWriterProvider = AnnotatedCodeWriter::new;
+
+	private int threadsCount = DEFAULT_THREADS_COUNT;
+
+	private boolean cfgOutput = false;
+	private boolean rawCFGOutput = false;
+
+	private boolean showInconsistentCode = false;
+
+	private boolean useImports = true;
+	private boolean debugInfo = true;
+	private boolean insertDebugLines = false;
+	private boolean extractFinally = true;
+	private boolean inlineAnonymousClasses = true;
+	private boolean inlineMethods = true;
+	private boolean allowInlineKotlinLambda = true;
+	private boolean moveInnerClasses = true;
+
+	private boolean skipResources = false;
+	private boolean skipSources = false;
+
+	/**
+	 * Predicate that allows to filter the classes to be process based on their full name
+	 */
+	private Predicate<String> classFilter = null;
+
+	/**
+	 * Save dependencies for classes accepted by {@code classFilter}
+	 */
+	private boolean includeDependencies = false;
+
+	private Path userRenamesMappingsPath = null;
+	private UserRenamesMappingsMode userRenamesMappingsMode = UserRenamesMappingsMode.getDefault();
+
+	private boolean deobfuscationOn = false;
+	private UseSourceNameAsClassNameAlias useSourceNameAsClassNameAlias = UseSourceNameAsClassNameAlias.getDefault();
+
+	private File generatedRenamesMappingFile = null;
+	private GeneratedRenamesMappingFileMode generatedRenamesMappingFileMode = GeneratedRenamesMappingFileMode.getDefault();
+	private ResourceNameSource resourceNameSource = ResourceNameSource.AUTO;
+
+	private int deobfuscationMinLength = 0;
+	private int deobfuscationMaxLength = Integer.MAX_VALUE;
+
+	/**
+	 * List of classes and packages (ends with '.*') to exclude from deobfuscation
+	 */
+	private List<String> deobfuscationWhitelist = DeobfWhitelist.DEFAULT_LIST;
+
+	/**
+	 * Nodes alias provider for deobfuscator and rename visitor
+	 */
+	private IAliasProvider aliasProvider = new DeobfAliasProvider();
+
+	/**
+	 * Condition to rename node in deobfuscator
+	 */
+	private IRenameCondition renameCondition = JadxRenameConditions.buildDefault();
+
+	private boolean escapeUnicode = false;
+	private boolean replaceConsts = true;
+	private boolean respectBytecodeAccModifiers = false;
+	private boolean exportAsGradleProject = false;
+
+	private boolean restoreSwitchOverString = true;
+
+	private boolean skipXmlPrettyPrint = false;
+
+	private boolean fsCaseSensitive;
+
+	public enum RenameEnum {
+		CASE, VALID, PRINTABLE
+	}
+
+	private Set<RenameEnum> renameFlags = EnumSet.allOf(RenameEnum.class);
+
+	public enum OutputFormatEnum {
+		JAVA, JSON
+	}
+
+	private OutputFormatEnum outputFormat = OutputFormatEnum.JAVA;
+
+	private DecompilationMode decompilationMode = DecompilationMode.AUTO;
+
+	private ICodeData codeData;
+
+	private String codeNewLineStr = DEFAULT_NEW_LINE_STR;
+
+	private String codeIndentStr = DEFAULT_INDENT_STR;
+
+	private CommentsLevel commentsLevel = CommentsLevel.INFO;
+
+	private IntegerFormat integerFormat = IntegerFormat.AUTO;
+
+	private boolean useDxInput = false;
+
+	public enum UseKotlinMethodsForVarNames {
+		DISABLE, APPLY, APPLY_AND_HIDE
+	}
+
+	private UseKotlinMethodsForVarNames useKotlinMethodsForVarNames = UseKotlinMethodsForVarNames.APPLY;
+
+	/**
+	 * Additional files structure info.
+	 * Defaults to tmp dirs.
+	 */
+	private IJadxFilesGetter filesGetter = TempFilesGetter.INSTANCE;
+
+	/**
+	 * Additional data validation and security checks
+	 */
+	private IJadxSecurity security = new JadxSecurity(JadxSecurityFlag.all());
+
+	/**
+	 * Don't save files (can be using for performance testing)
+	 */
+	private boolean skipFilesSave = false;
+
+	/**
+	 * Run additional expensive checks to verify internal invariants and info integrity
+	 */
+	private boolean runDebugChecks = false;
+
+	private Map<String, String> pluginOptions = new HashMap<>();
+
+	private Set<String> disabledPlugins = new HashSet<>();
+
+	private JadxPluginLoader pluginLoader = new JadxBasePluginLoader();
+
+	private boolean loadJadxClsSetFile = true;
+
+	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));
+	}
+
+	@Override
+	public void close() {
+		try {
+			inputFiles = null;
+			if (codeCache != null) {
+				codeCache.close();
+			}
+			if (usageInfoCache != null) {
+				usageInfoCache.close();
+			}
+			if (pluginLoader != null) {
+				pluginLoader.close();
+			}
+		} catch (Exception e) {
+			LOG.error("Failed to close JadxArgs", e);
+		} finally {
+			codeCache = null;
+			usageInfoCache = null;
+		}
+	}
+
+	public List<File> getInputFiles() {
+		return inputFiles;
+	}
+
+	public void setInputFile(File inputFile) {
+		this.inputFiles = Collections.singletonList(inputFile);
+	}
+
+	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 = Math.max(1, threadsCount); // make sure threadsCount >= 1
+	}
+
+	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 decompilationMode == DecompilationMode.FALLBACK;
+	}
+
+	/**
+	 * Deprecated: use 'decompilation mode' property
+	 */
+	@Deprecated
+	public void setFallbackMode(boolean fallbackMode) {
+		if (fallbackMode) {
+			this.decompilationMode = DecompilationMode.FALLBACK;
+		}
+	}
+
+	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 isDebugInfo() {
+		return debugInfo;
+	}
+
+	public void setDebugInfo(boolean debugInfo) {
+		this.debugInfo = debugInfo;
+	}
+
+	public boolean isInsertDebugLines() {
+		return insertDebugLines;
+	}
+
+	public void setInsertDebugLines(boolean insertDebugLines) {
+		this.insertDebugLines = insertDebugLines;
+	}
+
+	public boolean isInlineAnonymousClasses() {
+		return inlineAnonymousClasses;
+	}
+
+	public void setInlineAnonymousClasses(boolean inlineAnonymousClasses) {
+		this.inlineAnonymousClasses = inlineAnonymousClasses;
+	}
+
+	public boolean isInlineMethods() {
+		return inlineMethods;
+	}
+
+	public void setInlineMethods(boolean inlineMethods) {
+		this.inlineMethods = inlineMethods;
+	}
+
+	public boolean isAllowInlineKotlinLambda() {
+		return allowInlineKotlinLambda;
+	}
+
+	public void setAllowInlineKotlinLambda(boolean allowInlineKotlinLambda) {
+		this.allowInlineKotlinLambda = allowInlineKotlinLambda;
+	}
+
+	public boolean isMoveInnerClasses() {
+		return moveInnerClasses;
+	}
+
+	public void setMoveInnerClasses(boolean moveInnerClasses) {
+		this.moveInnerClasses = moveInnerClasses;
+	}
+
+	public boolean isExtractFinally() {
+		return extractFinally;
+	}
+
+	public void setExtractFinally(boolean extractFinally) {
+		this.extractFinally = extractFinally;
+	}
+
+	public boolean isSkipResources() {
+		return skipResources;
+	}
+
+	public void setSkipResources(boolean skipResources) {
+		this.skipResources = skipResources;
+	}
+
+	public boolean isSkipSources() {
+		return skipSources;
+	}
+
+	public void setSkipSources(boolean skipSources) {
+		this.skipSources = skipSources;
+	}
+
+	public void setIncludeDependencies(boolean includeDependencies) {
+		this.includeDependencies = includeDependencies;
+	}
+
+	public boolean isIncludeDependencies() {
+		return includeDependencies;
+	}
+
+	public Predicate<String> getClassFilter() {
+		return classFilter;
+	}
+
+	public void setClassFilter(Predicate<String> classFilter) {
+		this.classFilter = classFilter;
+	}
+
+	public Path getUserRenamesMappingsPath() {
+		return userRenamesMappingsPath;
+	}
+
+	public void setUserRenamesMappingsPath(Path path) {
+		this.userRenamesMappingsPath = path;
+	}
+
+	public UserRenamesMappingsMode getUserRenamesMappingsMode() {
+		return userRenamesMappingsMode;
+	}
+
+	public void setUserRenamesMappingsMode(UserRenamesMappingsMode mode) {
+		this.userRenamesMappingsMode = mode;
+	}
+
+	public boolean isDeobfuscationOn() {
+		return deobfuscationOn;
+	}
+
+	public void setDeobfuscationOn(boolean deobfuscationOn) {
+		this.deobfuscationOn = deobfuscationOn;
+	}
+
+	public boolean isDeobfuscationForceSave() {
+		return generatedRenamesMappingFileMode == GeneratedRenamesMappingFileMode.OVERWRITE;
+	}
+
+	public void setDeobfuscationForceSave(boolean deobfuscationForceSave) {
+		if (deobfuscationForceSave) {
+			this.generatedRenamesMappingFileMode = GeneratedRenamesMappingFileMode.OVERWRITE;
+		}
+	}
+
+	public GeneratedRenamesMappingFileMode getGeneratedRenamesMappingFileMode() {
+		return generatedRenamesMappingFileMode;
+	}
+
+	public void setGeneratedRenamesMappingFileMode(GeneratedRenamesMappingFileMode mode) {
+		this.generatedRenamesMappingFileMode = mode;
+	}
+
+	public UseSourceNameAsClassNameAlias getUseSourceNameAsClassNameAlias() {
+		return useSourceNameAsClassNameAlias;
+	}
+
+	public void setUseSourceNameAsClassNameAlias(UseSourceNameAsClassNameAlias useSourceNameAsClassNameAlias) {
+		this.useSourceNameAsClassNameAlias = useSourceNameAsClassNameAlias;
+	}
+
+	/**
+	 * @deprecated Use {@link #getUseSourceNameAsClassNameAlias()} instead.
+	 */
+	@Deprecated
+	public boolean isUseSourceNameAsClassAlias() {
+		return getUseSourceNameAsClassNameAlias().toBoolean();
+	}
+
+	/**
+	 * @deprecated Use {@link #setUseSourceNameAsClassNameAlias(UseSourceNameAsClassNameAlias)} instead.
+	 */
+	@Deprecated
+	public void setUseSourceNameAsClassAlias(boolean useSourceNameAsClassAlias) {
+		final var useSourceNameAsClassNameAlias = UseSourceNameAsClassNameAlias.create(useSourceNameAsClassAlias);
+		setUseSourceNameAsClassNameAlias(useSourceNameAsClassNameAlias);
+	}
+
+	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 List<String> getDeobfuscationWhitelist() {
+		return this.deobfuscationWhitelist;
+	}
+
+	public void setDeobfuscationWhitelist(List<String> deobfuscationWhitelist) {
+		this.deobfuscationWhitelist = deobfuscationWhitelist;
+	}
+
+	public File getGeneratedRenamesMappingFile() {
+		return generatedRenamesMappingFile;
+	}
+
+	public void setGeneratedRenamesMappingFile(File file) {
+		this.generatedRenamesMappingFile = file;
+	}
+
+	public ResourceNameSource getResourceNameSource() {
+		return resourceNameSource;
+	}
+
+	public void setResourceNameSource(ResourceNameSource resourceNameSource) {
+		this.resourceNameSource = resourceNameSource;
+	}
+
+	public IAliasProvider getAliasProvider() {
+		return aliasProvider;
+	}
+
+	public void setAliasProvider(IAliasProvider aliasProvider) {
+		this.aliasProvider = aliasProvider;
+	}
+
+	public IRenameCondition getRenameCondition() {
+		return renameCondition;
+	}
+
+	public void setRenameCondition(IRenameCondition renameCondition) {
+		this.renameCondition = renameCondition;
+	}
+
+	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 isRespectBytecodeAccModifiers() {
+		return respectBytecodeAccModifiers;
+	}
+
+	public void setRespectBytecodeAccModifiers(boolean respectBytecodeAccModifiers) {
+		this.respectBytecodeAccModifiers = respectBytecodeAccModifiers;
+	}
+
+	public boolean isExportAsGradleProject() {
+		return exportAsGradleProject;
+	}
+
+	public void setExportAsGradleProject(boolean exportAsGradleProject) {
+		this.exportAsGradleProject = exportAsGradleProject;
+	}
+
+	public boolean isRestoreSwitchOverString() {
+		return restoreSwitchOverString;
+	}
+
+	public void setRestoreSwitchOverString(boolean restoreSwitchOverString) {
+		this.restoreSwitchOverString = restoreSwitchOverString;
+	}
+
+	public boolean isSkipXmlPrettyPrint() {
+		return skipXmlPrettyPrint;
+	}
+
+	public void setSkipXmlPrettyPrint(boolean skipXmlPrettyPrint) {
+		this.skipXmlPrettyPrint = skipXmlPrettyPrint;
+	}
+
+	public boolean isFsCaseSensitive() {
+		return fsCaseSensitive;
+	}
+
+	public void setFsCaseSensitive(boolean fsCaseSensitive) {
+		this.fsCaseSensitive = fsCaseSensitive;
+	}
+
+	public boolean isRenameCaseSensitive() {
+		return renameFlags.contains(RenameEnum.CASE);
+	}
+
+	public void setRenameCaseSensitive(boolean renameCaseSensitive) {
+		updateRenameFlag(renameCaseSensitive, RenameEnum.CASE);
+	}
+
+	public boolean isRenameValid() {
+		return renameFlags.contains(RenameEnum.VALID);
+	}
+
+	public void setRenameValid(boolean renameValid) {
+		updateRenameFlag(renameValid, RenameEnum.VALID);
+	}
+
+	public boolean isRenamePrintable() {
+		return renameFlags.contains(RenameEnum.PRINTABLE);
+	}
+
+	public void setRenamePrintable(boolean renamePrintable) {
+		updateRenameFlag(renamePrintable, RenameEnum.PRINTABLE);
+	}
+
+	private void updateRenameFlag(boolean enabled, RenameEnum flag) {
+		if (enabled) {
+			renameFlags.add(flag);
+		} else {
+			renameFlags.remove(flag);
+		}
+	}
+
+	public void setRenameFlags(Set<RenameEnum> renameFlags) {
+		this.renameFlags = renameFlags;
+	}
+
+	public Set<RenameEnum> getRenameFlags() {
+		return renameFlags;
+	}
+
+	public OutputFormatEnum getOutputFormat() {
+		return outputFormat;
+	}
+
+	public boolean isJsonOutput() {
+		return outputFormat == OutputFormatEnum.JSON;
+	}
+
+	public void setOutputFormat(OutputFormatEnum outputFormat) {
+		this.outputFormat = outputFormat;
+	}
+
+	public DecompilationMode getDecompilationMode() {
+		return decompilationMode;
+	}
+
+	public void setDecompilationMode(DecompilationMode decompilationMode) {
+		this.decompilationMode = decompilationMode;
+	}
+
+	public ICodeCache getCodeCache() {
+		return codeCache;
+	}
+
+	public void setCodeCache(ICodeCache codeCache) {
+		this.codeCache = codeCache;
+	}
+
+	public Function<JadxArgs, ICodeWriter> getCodeWriterProvider() {
+		return codeWriterProvider;
+	}
+
+	public void setCodeWriterProvider(Function<JadxArgs, ICodeWriter> codeWriterProvider) {
+		this.codeWriterProvider = codeWriterProvider;
+	}
+
+	public IUsageInfoCache getUsageInfoCache() {
+		return usageInfoCache;
+	}
+
+	public void setUsageInfoCache(IUsageInfoCache usageInfoCache) {
+		this.usageInfoCache = usageInfoCache;
+	}
+
+	public ICodeData getCodeData() {
+		return codeData;
+	}
+
+	public void setCodeData(ICodeData codeData) {
+		this.codeData = codeData;
+	}
+
+	public String getCodeIndentStr() {
+		return codeIndentStr;
+	}
+
+	public void setCodeIndentStr(String codeIndentStr) {
+		this.codeIndentStr = codeIndentStr;
+	}
+
+	public String getCodeNewLineStr() {
+		return codeNewLineStr;
+	}
+
+	public void setCodeNewLineStr(String codeNewLineStr) {
+		this.codeNewLineStr = codeNewLineStr;
+	}
+
+	public CommentsLevel getCommentsLevel() {
+		return commentsLevel;
+	}
+
+	public void setCommentsLevel(CommentsLevel commentsLevel) {
+		this.commentsLevel = commentsLevel;
+	}
+
+	public IntegerFormat getIntegerFormat() {
+		return integerFormat;
+	}
+
+	public void setIntegerFormat(IntegerFormat format) {
+		this.integerFormat = format;
+	}
+
+	public boolean isUseDxInput() {
+		return useDxInput;
+	}
+
+	public void setUseDxInput(boolean useDxInput) {
+		this.useDxInput = useDxInput;
+	}
+
+	public UseKotlinMethodsForVarNames getUseKotlinMethodsForVarNames() {
+		return useKotlinMethodsForVarNames;
+	}
+
+	public void setUseKotlinMethodsForVarNames(UseKotlinMethodsForVarNames useKotlinMethodsForVarNames) {
+		this.useKotlinMethodsForVarNames = useKotlinMethodsForVarNames;
+	}
+
+	public IJadxFilesGetter getFilesGetter() {
+		return filesGetter;
+	}
+
+	public void setFilesGetter(IJadxFilesGetter filesGetter) {
+		this.filesGetter = filesGetter;
+	}
+
+	public IJadxSecurity getSecurity() {
+		return security;
+	}
+
+	public void setSecurity(IJadxSecurity security) {
+		this.security = security;
+	}
+
+	public boolean isSkipFilesSave() {
+		return skipFilesSave;
+	}
+
+	public void setSkipFilesSave(boolean skipFilesSave) {
+		this.skipFilesSave = skipFilesSave;
+	}
+
+	public boolean isRunDebugChecks() {
+		return runDebugChecks;
+	}
+
+	public void setRunDebugChecks(boolean runDebugChecks) {
+		this.runDebugChecks = runDebugChecks;
+	}
+
+	public Map<String, String> getPluginOptions() {
+		return pluginOptions;
+	}
+
+	public void setPluginOptions(Map<String, String> pluginOptions) {
+		this.pluginOptions = pluginOptions;
+	}
+
+	public Set<String> getDisabledPlugins() {
+		return disabledPlugins;
+	}
+
+	public void setDisabledPlugins(Set<String> disabledPlugins) {
+		this.disabledPlugins = disabledPlugins;
+	}
+
+	public JadxPluginLoader getPluginLoader() {
+		return pluginLoader;
+	}
+
+	public void setPluginLoader(JadxPluginLoader pluginLoader) {
+		this.pluginLoader = pluginLoader;
+	}
+
+	public boolean isLoadJadxClsSetFile() {
+		return loadJadxClsSetFile;
+	}
+
+	public void setLoadJadxClsSetFile(boolean loadJadxClsSetFile) {
+		this.loadJadxClsSetFile = loadJadxClsSetFile;
+	}
+
+	/**
+	 * Hash of all options that can change result code
+	 */
+	public String makeCodeArgsHash(@Nullable JadxDecompiler decompiler) {
+		String argStr = "args:" + decompilationMode + useImports + showInconsistentCode
+				+ inlineAnonymousClasses + inlineMethods + moveInnerClasses + allowInlineKotlinLambda
+				+ deobfuscationOn + deobfuscationMinLength + deobfuscationMaxLength + deobfuscationWhitelist
+				+ useSourceNameAsClassNameAlias
+				+ resourceNameSource
+				+ useKotlinMethodsForVarNames
+				+ insertDebugLines + extractFinally
+				+ debugInfo + escapeUnicode + replaceConsts + restoreSwitchOverString
+				+ respectBytecodeAccModifiers + fsCaseSensitive + renameFlags
+				+ commentsLevel + useDxInput + integerFormat
+				+ "|" + buildPluginsHash(decompiler);
+		return FileUtils.md5Sum(argStr);
+	}
+
+	private static String buildPluginsHash(@Nullable JadxDecompiler decompiler) {
+		if (decompiler == null) {
+			return "";
+		}
+		return decompiler.getPluginManager().getResolvedPluginContexts()
+				.stream()
+				.map(PluginContext::getInputsHash)
+				.collect(Collectors.joining(":"));
+	}
+
+	@Override
+	public String toString() {
+		return "JadxArgs{" + "inputFiles=" + inputFiles
+				+ ", outDir=" + outDir
+				+ ", outDirSrc=" + outDirSrc
+				+ ", outDirRes=" + outDirRes
+				+ ", threadsCount=" + threadsCount
+				+ ", decompilationMode=" + decompilationMode
+				+ ", showInconsistentCode=" + showInconsistentCode
+				+ ", useImports=" + useImports
+				+ ", skipResources=" + skipResources
+				+ ", skipSources=" + skipSources
+				+ ", includeDependencies=" + includeDependencies
+				+ ", userRenamesMappingsPath=" + userRenamesMappingsPath
+				+ ", userRenamesMappingsMode=" + userRenamesMappingsMode
+				+ ", deobfuscationOn=" + deobfuscationOn
+				+ ", generatedRenamesMappingFile=" + generatedRenamesMappingFile
+				+ ", generatedRenamesMappingFileMode=" + generatedRenamesMappingFileMode
+				+ ", resourceNameSource=" + resourceNameSource
+				+ ", useSourceNameAsClassNameAlias=" + useSourceNameAsClassNameAlias
+				+ ", useKotlinMethodsForVarNames=" + useKotlinMethodsForVarNames
+				+ ", insertDebugLines=" + insertDebugLines
+				+ ", extractFinally=" + extractFinally
+				+ ", deobfuscationMinLength=" + deobfuscationMinLength
+				+ ", deobfuscationMaxLength=" + deobfuscationMaxLength
+				+ ", deobfuscationWhitelist=" + deobfuscationWhitelist
+				+ ", escapeUnicode=" + escapeUnicode
+				+ ", replaceConsts=" + replaceConsts
+				+ ", restoreSwitchOverString=" + restoreSwitchOverString
+				+ ", respectBytecodeAccModifiers=" + respectBytecodeAccModifiers
+				+ ", exportAsGradleProject=" + exportAsGradleProject
+				+ ", skipXmlPrettyPrint=" + skipXmlPrettyPrint
+				+ ", fsCaseSensitive=" + fsCaseSensitive
+				+ ", renameFlags=" + renameFlags
+				+ ", outputFormat=" + outputFormat
+				+ ", commentsLevel=" + commentsLevel
+				+ ", codeCache=" + codeCache
+				+ ", codeWriter=" + codeWriterProvider.apply(this).getClass().getSimpleName()
+				+ ", useDxInput=" + useDxInput
+				+ ", pluginOptions=" + pluginOptions
+				+ ", cfgOutput=" + cfgOutput
+				+ ", rawCFGOutput=" + rawCFGOutput
+				+ '}';
+	}
+}

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

@@ -0,0 +1,96 @@
+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(JadxDecompiler jadx) {
+		JadxArgs args = jadx.getArgs();
+		checkInputFiles(jadx, args);
+		validateOutDirs(args);
+
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Effective jadx args: {}", args);
+		}
+	}
+
+	private static void checkInputFiles(JadxDecompiler jadx, JadxArgs args) {
+		List<File> inputFiles = args.getInputFiles();
+		if (inputFiles.isEmpty() && jadx.getCustomCodeLoaders().isEmpty()) {
+			throw new JadxArgsValidateException("Please specify input file");
+		}
+		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);
+		}
+		if (srcDir == null) {
+			args.setOutDirSrc(new File(args.getOutDir(), JadxArgs.DEFAULT_SRC_DIR));
+		}
+		if (resDir == null) {
+			args.setOutDirRes(new File(args.getOutDir(), JadxArgs.DEFAULT_RES_DIR));
+		}
+
+		checkDir(args.getOutDir(), "Output");
+		checkDir(args.getOutDirSrc(), "Source output");
+		checkDir(args.getOutDirRes(), "Resources output");
+	}
+
+	@NotNull
+	private static File makeDirFromInput(JadxArgs args) {
+		String outDirName;
+		List<File> inputFiles = args.getInputFiles();
+		if (inputFiles.isEmpty()) {
+			outDirName = JadxArgs.DEFAULT_OUT_DIR;
+		} else {
+			File file = inputFiles.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);
+		return new File(outDirName);
+	}
+
+	private static void checkFile(File file) {
+		if (!file.exists()) {
+			throw new JadxArgsValidateException("File not found " + file.getAbsolutePath());
+		}
+	}
+
+	private static void checkDir(File dir, String desc) {
+		if (dir != null && dir.exists() && !dir.isDirectory()) {
+			throw new JadxArgsValidateException(desc + " directory exists as file " + dir);
+		}
+	}
+
+	private JadxArgsValidator() {
+	}
+}

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

@@ -0,0 +1,707 @@
+package jadx.api;
+
+import java.io.Closeable;
+import java.io.File;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.ExecutorService;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.api.metadata.annotations.NodeDeclareRef;
+import jadx.api.metadata.annotations.VarNode;
+import jadx.api.metadata.annotations.VarRef;
+import jadx.api.plugins.CustomResourcesLoader;
+import jadx.api.plugins.JadxPlugin;
+import jadx.api.plugins.events.IJadxEvents;
+import jadx.api.plugins.input.ICodeLoader;
+import jadx.api.plugins.input.JadxCodeInput;
+import jadx.api.plugins.pass.JadxPass;
+import jadx.api.plugins.pass.types.JadxAfterLoadPass;
+import jadx.api.plugins.pass.types.JadxPassType;
+import jadx.api.utils.tasks.ITaskExecutor;
+import jadx.core.Jadx;
+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.PackageNode;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.dex.visitors.SaveCode;
+import jadx.core.export.ExportGradleTask;
+import jadx.core.plugins.JadxPluginManager;
+import jadx.core.plugins.PluginContext;
+import jadx.core.plugins.events.JadxEventsImpl;
+import jadx.core.utils.DecompilerScheduler;
+import jadx.core.utils.Utils;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.FileUtils;
+import jadx.core.utils.files.ZipPatch;
+import jadx.core.utils.tasks.TaskExecutor;
+import jadx.core.xmlgen.ResourcesSaver;
+
+/**
+ * Jadx API usage example:
+ *
+ * <pre>
+ * <code>
+ *
+ * JadxArgs args = new JadxArgs();
+ * args.getInputFiles().add(new File("test.apk"));
+ * args.setOutDir(new File("jadx-test-output"));
+ * try (JadxDecompiler jadx = new JadxDecompiler(args)) {
+ *    jadx.load();
+ *    jadx.save();
+ * }
+ * </code>
+ * </pre>
+ * <p>
+ * Instead of 'save()' you can iterate over decompiled classes:
+ *
+ * <pre>
+ * <code>
+ *
+ *  for(JavaClass cls : jadx.getClasses()) {
+ *      System.out.println(cls.getCode());
+ *  }
+ * </code>
+ * </pre>
+ */
+public final class JadxDecompiler implements Closeable {
+	private static final Logger LOG = LoggerFactory.getLogger(JadxDecompiler.class);
+
+	private final JadxArgs args;
+	private final JadxPluginManager pluginManager;
+	private final List<ICodeLoader> loadedInputs = new ArrayList<>();
+
+	private RootNode root;
+	private List<JavaClass> classes;
+	private List<ResourceFile> resources;
+
+	private final IDecompileScheduler decompileScheduler = new DecompilerScheduler();
+	private final ResourcesLoader resourcesLoader;
+
+	private final List<ICodeLoader> customCodeLoaders = new ArrayList<>();
+	private final List<CustomResourcesLoader> customResourcesLoaders = new ArrayList<>();
+	private final Map<JadxPassType, List<JadxPass>> customPasses = new HashMap<>();
+
+	private IJadxEvents events = new JadxEventsImpl();
+
+	public JadxDecompiler() {
+		this(new JadxArgs());
+	}
+
+	public JadxDecompiler(JadxArgs args) {
+		this.args = Objects.requireNonNull(args);
+		this.pluginManager = new JadxPluginManager(this);
+		this.resourcesLoader = new ResourcesLoader(this);
+	}
+
+	public void load() {
+		reset();
+		JadxArgsValidator.validate(this);
+		LOG.info("loading ...");
+		FileUtils.updateTempRootDir(args.getFilesGetter().getTempDir());
+		loadPlugins();
+		loadInputFiles();
+
+		root = new RootNode(args);
+		root.init();
+		root.setDecompilerRef(this);
+		root.mergePasses(customPasses);
+		root.loadClasses(loadedInputs);
+		root.initClassPath();
+		root.loadResources(resourcesLoader, getResources());
+		root.runPreDecompileStage();
+		root.initPasses();
+		loadFinished();
+	}
+
+	public void reloadPasses() {
+		LOG.info("reloading (passes only) ...");
+		customPasses.clear();
+		root.resetPasses();
+		events.reset();
+		loadPlugins();
+		root.mergePasses(customPasses);
+		root.restartVisitors();
+		root.initPasses();
+		loadFinished();
+	}
+
+	private void loadInputFiles() {
+		loadedInputs.clear();
+		List<File> inputs = ZipPatch.patchZipFiles(args.getInputFiles());
+		args.setInputFiles(inputs);
+		List<Path> inputPaths = Utils.collectionMap(inputs, File::toPath);
+		List<Path> inputFiles = FileUtils.expandDirs(inputPaths);
+		long start = System.currentTimeMillis();
+		for (PluginContext plugin : pluginManager.getResolvedPluginContexts()) {
+			for (JadxCodeInput codeLoader : plugin.getCodeInputs()) {
+				try {
+					ICodeLoader loader = codeLoader.loadFiles(inputFiles);
+					if (loader != null && !loader.isEmpty()) {
+						loadedInputs.add(loader);
+					}
+				} catch (Exception e) {
+					throw new JadxRuntimeException("Failed to load code for plugin: " + plugin, e);
+				}
+			}
+		}
+		loadedInputs.addAll(customCodeLoaders);
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Loaded using {} inputs plugin in {} ms", loadedInputs.size(), System.currentTimeMillis() - start);
+		}
+	}
+
+	private void reset() {
+		root = null;
+		classes = null;
+		resources = null;
+		events.reset();
+	}
+
+	@Override
+	public void close() {
+		reset();
+		closeInputs();
+		closeLoaders();
+		args.close();
+		FileUtils.clearTempRootDir();
+	}
+
+	private void closeInputs() {
+		loadedInputs.forEach(load -> {
+			try {
+				load.close();
+			} catch (Exception e) {
+				LOG.error("Failed to close input", e);
+			}
+		});
+		loadedInputs.clear();
+	}
+
+	private void closeLoaders() {
+		for (CustomResourcesLoader resourcesLoader : customResourcesLoaders) {
+			try {
+				resourcesLoader.close();
+			} catch (Exception e) {
+				LOG.error("Failed to close resource loader: {}", resourcesLoader, e);
+			}
+		}
+		customResourcesLoaders.clear();
+	}
+
+	private void loadPlugins() {
+		pluginManager.providesSuggestion("java-input", args.isUseDxInput() ? "java-convert" : "java-input");
+		pluginManager.load(args.getPluginLoader());
+		if (LOG.isDebugEnabled()) {
+			LOG.debug("Resolved plugins: {}", pluginManager.getResolvedPluginContexts());
+		}
+		pluginManager.initResolved();
+		if (LOG.isDebugEnabled()) {
+			List<String> passes = customPasses.values().stream().flatMap(Collection::stream)
+					.map(p -> p.getInfo().getName()).collect(Collectors.toList());
+			LOG.debug("Loaded custom passes: {} {}", passes.size(), passes);
+		}
+	}
+
+	private void loadFinished() {
+		LOG.debug("Load finished");
+		List<JadxPass> list = customPasses.get(JadxAfterLoadPass.TYPE);
+		if (list != null) {
+			for (JadxPass pass : list) {
+				((JadxAfterLoadPass) pass).init(this);
+			}
+		}
+	}
+
+	@SuppressWarnings("unused")
+	public void registerPlugin(JadxPlugin plugin) {
+		pluginManager.register(plugin);
+	}
+
+	public static String getVersion() {
+		return Jadx.getVersion();
+	}
+
+	public void save() {
+		save(!args.isSkipSources(), !args.isSkipResources());
+	}
+
+	public interface ProgressListener {
+		void progress(long done, long total);
+	}
+
+	@SuppressWarnings("BusyWait")
+	public void save(int intervalInMillis, ProgressListener listener) {
+		try {
+			ITaskExecutor tasks = getSaveTaskExecutor();
+			tasks.execute();
+			long total = tasks.getTasksCount();
+			while (tasks.isRunning()) {
+				listener.progress(tasks.getProgress(), total);
+				Thread.sleep(intervalInMillis);
+			}
+		} catch (InterruptedException e) {
+			LOG.error("Save interrupted", e);
+			Thread.currentThread().interrupt();
+		}
+	}
+
+	public void saveSources() {
+		save(true, false);
+	}
+
+	public void saveResources() {
+		save(false, true);
+	}
+
+	private void save(boolean saveSources, boolean saveResources) {
+		ITaskExecutor executor = getSaveTasks(saveSources, saveResources);
+		executor.execute();
+		executor.awaitTermination();
+	}
+
+	public ITaskExecutor getSaveTaskExecutor() {
+		return getSaveTasks(!args.isSkipSources(), !args.isSkipResources());
+	}
+
+	@Deprecated(forRemoval = true)
+	public ExecutorService getSaveExecutor() {
+		ITaskExecutor executor = getSaveTaskExecutor();
+		executor.execute();
+		return executor.getInternalExecutor();
+	}
+
+	@Deprecated(forRemoval = true)
+	public List<Runnable> getSaveTasks() {
+		return Collections.singletonList(this::save);
+	}
+
+	private TaskExecutor getSaveTasks(boolean saveSources, boolean saveResources) {
+		if (root == null) {
+			throw new JadxRuntimeException("No loaded files");
+		}
+		File sourcesOutDir;
+		File resOutDir;
+		ExportGradleTask gradleExportTask;
+		if (args.isExportAsGradleProject()) {
+			gradleExportTask = new ExportGradleTask(resources, root, args.getOutDir());
+			gradleExportTask.init();
+			sourcesOutDir = gradleExportTask.getSrcOutDir();
+			resOutDir = gradleExportTask.getResOutDir();
+		} else {
+			sourcesOutDir = args.getOutDirSrc();
+			resOutDir = args.getOutDirRes();
+			gradleExportTask = null;
+		}
+
+		TaskExecutor executor = new TaskExecutor();
+		executor.setThreadsCount(args.getThreadsCount());
+		if (saveResources) {
+			// save resources first because decompilation can stop or fail
+			appendResourcesSaveTasks(executor, resOutDir);
+		}
+		if (saveSources) {
+			appendSourcesSave(executor, sourcesOutDir);
+		}
+		if (gradleExportTask != null) {
+			executor.addSequentialTask(gradleExportTask);
+		}
+		return executor;
+	}
+
+	private void appendResourcesSaveTasks(ITaskExecutor executor, File outDir) {
+		if (args.isSkipFilesSave()) {
+			return;
+		}
+		// process AndroidManifest.xml first to load complete resource ids table
+		for (ResourceFile resourceFile : getResources()) {
+			if (resourceFile.getType() == ResourceType.MANIFEST) {
+				new ResourcesSaver(outDir, resourceFile).run();
+				break;
+			}
+		}
+		Set<String> inputFileNames = args.getInputFiles().stream()
+				.map(File::getAbsolutePath)
+				.collect(Collectors.toSet());
+		List<Runnable> tasks = new ArrayList<>();
+		for (ResourceFile resourceFile : getResources()) {
+			ResourceType resType = resourceFile.getType();
+			if (resType == ResourceType.MANIFEST) {
+				// already processed
+				continue;
+			}
+			if (resType != ResourceType.ARSC
+					&& inputFileNames.contains(resourceFile.getOriginalName())) {
+				// ignore resource made from input file
+				continue;
+			}
+			tasks.add(new ResourcesSaver(outDir, resourceFile));
+		}
+		executor.addParallelTasks(tasks);
+	}
+
+	private void appendSourcesSave(ITaskExecutor executor, File outDir) {
+		List<JavaClass> classes = getClasses();
+		List<JavaClass> processQueue = filterClasses(classes);
+		List<List<JavaClass>> batches;
+		try {
+			batches = decompileScheduler.buildBatches(processQueue);
+		} catch (Exception e) {
+			throw new JadxRuntimeException("Decompilation batches build failed", e);
+		}
+		List<Runnable> decompileTasks = new ArrayList<>(batches.size());
+		for (List<JavaClass> decompileBatch : batches) {
+			decompileTasks.add(() -> {
+				for (JavaClass cls : decompileBatch) {
+					try {
+						ClassNode clsNode = cls.getClassNode();
+						ICodeInfo code = clsNode.getCode();
+						SaveCode.save(outDir, clsNode, code);
+					} catch (Exception e) {
+						LOG.error("Error saving class: {}", cls, e);
+					}
+				}
+
+			});
+		}
+		executor.addParallelTasks(decompileTasks);
+	}
+
+	private List<JavaClass> filterClasses(List<JavaClass> classes) {
+		Predicate<String> classFilter = args.getClassFilter();
+		List<JavaClass> list = new ArrayList<>(classes.size());
+		for (JavaClass cls : classes) {
+			ClassNode clsNode = cls.getClassNode();
+			if (clsNode.contains(AFlag.DONT_GENERATE)) {
+				continue;
+			}
+			if (classFilter != null && !classFilter.test(clsNode.getClassInfo().getFullName())) {
+				if (!args.isIncludeDependencies()) {
+					clsNode.add(AFlag.DONT_GENERATE);
+				}
+				continue;
+			}
+			list.add(cls);
+		}
+		return list;
+	}
+
+	public List<JavaClass> getClasses() {
+		if (root == null) {
+			return Collections.emptyList();
+		}
+		if (classes == null) {
+			List<ClassNode> classNodeList = root.getClasses();
+			List<JavaClass> clsList = new ArrayList<>(classNodeList.size());
+			for (ClassNode classNode : classNodeList) {
+				if (classNode.contains(AFlag.DONT_GENERATE)) {
+					continue;
+				}
+				if (!classNode.getClassInfo().isInner()) {
+					clsList.add(convertClassNode(classNode));
+				}
+			}
+			classes = Collections.unmodifiableList(clsList);
+		}
+		return classes;
+	}
+
+	public List<JavaClass> getClassesWithInners() {
+		return Utils.collectionMap(root.getClasses(), this::convertClassNode);
+	}
+
+	public synchronized List<ResourceFile> getResources() {
+		if (resources == null) {
+			if (root == null) {
+				return Collections.emptyList();
+			}
+			resources = resourcesLoader.load(root);
+		}
+		return resources;
+	}
+
+	public List<JavaPackage> getPackages() {
+		return Utils.collectionMap(root.getPackages(), this::convertPackageNode);
+	}
+
+	public int getErrorsCount() {
+		if (root == null) {
+			return 0;
+		}
+		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();
+	}
+
+	/**
+	 * Internal API. Not Stable!
+	 */
+	@ApiStatus.Internal
+	public RootNode getRoot() {
+		return root;
+	}
+
+	/**
+	 * Get JavaClass by ClassNode without loading and decompilation
+	 */
+	@ApiStatus.Internal
+	synchronized JavaClass convertClassNode(ClassNode cls) {
+		JavaClass javaClass = cls.getJavaNode();
+		if (javaClass == null) {
+			javaClass = cls.isInner()
+					? new JavaClass(cls, convertClassNode(cls.getParentClass()))
+					: new JavaClass(cls, this);
+			cls.setJavaNode(javaClass);
+		}
+		return javaClass;
+	}
+
+	@ApiStatus.Internal
+	synchronized JavaField convertFieldNode(FieldNode fld) {
+		JavaField javaField = fld.getJavaNode();
+		if (javaField == null) {
+			JavaClass parentCls = convertClassNode(fld.getParentClass());
+			javaField = new JavaField(parentCls, fld);
+			fld.setJavaNode(javaField);
+		}
+		return javaField;
+	}
+
+	@ApiStatus.Internal
+	synchronized JavaMethod convertMethodNode(MethodNode mth) {
+		JavaMethod javaMethod = mth.getJavaNode();
+		if (javaMethod == null) {
+			javaMethod = new JavaMethod(convertClassNode(mth.getParentClass()), mth);
+			mth.setJavaNode(javaMethod);
+		}
+		return javaMethod;
+	}
+
+	@ApiStatus.Internal
+	synchronized JavaPackage convertPackageNode(PackageNode pkg) {
+		JavaPackage foundPkg = pkg.getJavaNode();
+		if (foundPkg != null) {
+			return foundPkg;
+		}
+		List<JavaClass> clsList = Utils.collectionMap(pkg.getClasses(), this::convertClassNode);
+		int subPkgsCount = pkg.getSubPackages().size();
+		List<JavaPackage> subPkgs = subPkgsCount == 0 ? Collections.emptyList() : new ArrayList<>(subPkgsCount);
+		JavaPackage javaPkg = new JavaPackage(pkg, clsList, subPkgs);
+		if (subPkgsCount != 0) {
+			// add subpackages after parent to avoid endless recursion
+			for (PackageNode subPackage : pkg.getSubPackages()) {
+				subPkgs.add(convertPackageNode(subPackage));
+			}
+		}
+		pkg.setJavaNode(javaPkg);
+		return javaPkg;
+	}
+
+	@Nullable
+	public JavaClass searchJavaClassByOrigFullName(String fullName) {
+		return getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getFullName().equals(fullName))
+				.findFirst()
+				.map(this::convertClassNode)
+				.orElse(null);
+	}
+
+	@Nullable
+	public ClassNode searchClassNodeByOrigFullName(String fullName) {
+		return getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getFullName().equals(fullName))
+				.findFirst()
+				.orElse(null);
+	}
+
+	// returns parent if class contains DONT_GENERATE flag.
+	@Nullable
+	public JavaClass searchJavaClassOrItsParentByOrigFullName(String fullName) {
+		ClassNode node = getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getFullName().equals(fullName))
+				.findFirst()
+				.orElse(null);
+		if (node != null) {
+			if (node.contains(AFlag.DONT_GENERATE)) {
+				return convertClassNode(node.getTopParentClass());
+			} else {
+				return convertClassNode(node);
+			}
+		}
+		return null;
+	}
+
+	@Nullable
+	public JavaClass searchJavaClassByAliasFullName(String fullName) {
+		return getRoot().getClasses().stream()
+				.filter(cls -> cls.getClassInfo().getAliasFullName().equals(fullName))
+				.findFirst()
+				.map(this::convertClassNode)
+				.orElse(null);
+	}
+
+	@Nullable
+	public JavaNode getJavaNodeByRef(ICodeNodeRef ann) {
+		return getJavaNodeByCodeAnnotation(null, ann);
+	}
+
+	@Nullable
+	public JavaNode getJavaNodeByCodeAnnotation(@Nullable ICodeInfo codeInfo, @Nullable ICodeAnnotation ann) {
+		if (ann == null) {
+			return null;
+		}
+		switch (ann.getAnnType()) {
+			case CLASS:
+				return convertClassNode((ClassNode) ann);
+			case METHOD:
+				return convertMethodNode((MethodNode) ann);
+			case FIELD:
+				return convertFieldNode((FieldNode) ann);
+			case DECLARATION:
+				return getJavaNodeByCodeAnnotation(codeInfo, ((NodeDeclareRef) ann).getNode());
+			case VAR:
+				return resolveVarNode((VarNode) ann);
+			case VAR_REF:
+				return resolveVarRef(codeInfo, (VarRef) ann);
+			case OFFSET:
+				// offset annotation don't have java node object
+				return null;
+			default:
+				throw new JadxRuntimeException("Unknown annotation type: " + ann.getAnnType() + ", class: " + ann.getClass());
+		}
+	}
+
+	private JavaVariable resolveVarNode(VarNode varNode) {
+		JavaMethod javaNode = convertMethodNode(varNode.getMth());
+		return new JavaVariable(javaNode, varNode);
+	}
+
+	@Nullable
+	private JavaVariable resolveVarRef(ICodeInfo codeInfo, VarRef varRef) {
+		if (codeInfo == null) {
+			throw new JadxRuntimeException("Missing code info for resolve VarRef: " + varRef);
+		}
+		ICodeAnnotation varNodeAnn = codeInfo.getCodeMetadata().getAt(varRef.getRefPos());
+		if (varNodeAnn != null && varNodeAnn.getAnnType() == ICodeAnnotation.AnnType.DECLARATION) {
+			ICodeNodeRef nodeRef = ((NodeDeclareRef) varNodeAnn).getNode();
+			if (nodeRef.getAnnType() == ICodeAnnotation.AnnType.VAR) {
+				return resolveVarNode((VarNode) nodeRef);
+			}
+		}
+		return null;
+	}
+
+	List<JavaNode> convertNodes(Collection<? extends ICodeNodeRef> nodesList) {
+		return nodesList.stream()
+				.map(this::getJavaNodeByRef)
+				.filter(Objects::nonNull)
+				.collect(Collectors.toList());
+	}
+
+	@Nullable
+	public JavaNode getJavaNodeAtPosition(ICodeInfo codeInfo, int pos) {
+		ICodeAnnotation ann = codeInfo.getCodeMetadata().getAt(pos);
+		return getJavaNodeByCodeAnnotation(codeInfo, ann);
+	}
+
+	@Nullable
+	public JavaNode getClosestJavaNode(ICodeInfo codeInfo, int pos) {
+		ICodeAnnotation ann = codeInfo.getCodeMetadata().getClosestUp(pos);
+		return getJavaNodeByCodeAnnotation(codeInfo, ann);
+	}
+
+	@Nullable
+	public JavaNode getEnclosingNode(ICodeInfo codeInfo, int pos) {
+		ICodeNodeRef obj = codeInfo.getCodeMetadata().getNodeAt(pos);
+		if (obj == null) {
+			return null;
+		}
+		return getJavaNodeByRef(obj);
+	}
+
+	public void reloadCodeData() {
+		root.notifyCodeDataListeners();
+	}
+
+	public JadxArgs getArgs() {
+		return args;
+	}
+
+	public JadxPluginManager getPluginManager() {
+		return pluginManager;
+	}
+
+	public IDecompileScheduler getDecompileScheduler() {
+		return decompileScheduler;
+	}
+
+	public IJadxEvents events() {
+		return events;
+	}
+
+	public void setEventsImpl(IJadxEvents eventsImpl) {
+		this.events = eventsImpl;
+	}
+
+	public void addCustomCodeLoader(ICodeLoader customCodeLoader) {
+		customCodeLoaders.add(customCodeLoader);
+	}
+
+	public List<ICodeLoader> getCustomCodeLoaders() {
+		return customCodeLoaders;
+	}
+
+	public void addCustomResourcesLoader(CustomResourcesLoader loader) {
+		if (customResourcesLoaders.contains(loader)) {
+			return;
+		}
+		customResourcesLoaders.add(loader);
+	}
+
+	public List<CustomResourcesLoader> getCustomResourcesLoaders() {
+		return customResourcesLoaders;
+	}
+
+	public void addCustomPass(JadxPass pass) {
+		customPasses.computeIfAbsent(pass.getPassType(), l -> new ArrayList<>()).add(pass);
+	}
+
+	public ResourcesLoader getResourcesLoader() {
+		return resourcesLoader;
+	}
+
+	@Override
+	public String toString() {
+		return "jadx decompiler " + getVersion();
+	}
+}

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

@@ -1,113 +1,363 @@
 package jadx.api;
 
-import jadx.core.codegen.CodeWriter;
-import jadx.core.dex.info.AccessInfo;
-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.HashMap;
 import java.util.List;
+import java.util.Map;
 
-public final class JavaClass {
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-	private final Decompiler decompiler;
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.core.dex.attributes.AFlag;
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.nodes.AnonymousClassAttr;
+import jadx.core.dex.attributes.nodes.InlinedAttr;
+import jadx.core.dex.info.AccessInfo;
+import jadx.core.dex.nodes.ClassNode;
+import jadx.core.dex.nodes.FieldNode;
+import jadx.core.dex.nodes.MethodNode;
+import jadx.core.utils.ListUtils;
+
+public final class JavaClass implements JavaNode {
+	private static final Logger LOG = LoggerFactory.getLogger(JavaClass.class);
+
+	private final JadxDecompiler decompiler;
 	private final ClassNode cls;
-	private final List<JavaClass> innerClasses;
-	private final List<JavaField> fields;
-	private final List<JavaMethod> methods;
+	private final JavaClass parent;
 
-	JavaClass(Decompiler decompiler, ClassNode classNode) {
+	private List<JavaClass> innerClasses = Collections.emptyList();
+	private List<JavaClass> inlinedClasses = Collections.emptyList();
+	private List<JavaField> fields = Collections.emptyList();
+	private List<JavaMethod> methods = Collections.emptyList();
+	private boolean listsLoaded;
+
+	JavaClass(ClassNode classNode, JadxDecompiler decompiler) {
 		this.decompiler = decompiler;
 		this.cls = classNode;
+		this.parent = null;
+	}
 
-		int inClsCount = cls.getInnerClasses().size();
-		if (inClsCount == 0) {
-			this.innerClasses = Collections.emptyList();
+	/**
+	 * Inner classes constructor
+	 */
+	JavaClass(ClassNode classNode, JavaClass parent) {
+		this.decompiler = null;
+		this.cls = classNode;
+		this.parent = parent;
+	}
+
+	public String getCode() {
+		return getCodeInfo().getCodeStr();
+	}
+
+	public @NotNull ICodeInfo getCodeInfo() {
+		ICodeInfo code = load();
+		if (code != null) {
+			return code;
+		}
+		return cls.decompile();
+	}
+
+	public void decompile() {
+		load();
+	}
+
+	public synchronized ICodeInfo reload() {
+		listsLoaded = false;
+		return cls.reloadCode();
+	}
+
+	public void unload() {
+		listsLoaded = false;
+		cls.unloadCode();
+	}
+
+	public boolean isNoCode() {
+		return cls.contains(AFlag.DONT_GENERATE);
+	}
+
+	public boolean isInner() {
+		return cls.isInner();
+	}
+
+	public synchronized String getSmali() {
+		return cls.getDisassembledCode();
+	}
+
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.CLASS) {
+			return ann.equals(cls);
+		}
+		return false;
+	}
+
+	@Override
+	public ICodeNodeRef getCodeNodeRef() {
+		return cls;
+	}
+
+	/**
+	 * Internal API. Not Stable!
+	 */
+	@ApiStatus.Internal
+	public ClassNode getClassNode() {
+		return cls;
+	}
+
+	/**
+	 * Decompile class and loads internal lists of fields, methods, etc.
+	 * Do nothing if already loaded.
+	 *
+	 * @return code info if decompilation was executed, null otherwise
+	 */
+	private synchronized @Nullable ICodeInfo load() {
+		if (listsLoaded) {
+			return null;
+		}
+		listsLoaded = true;
+
+		ICodeInfo code;
+		if (cls.getState().isProcessComplete()) {
+			// already decompiled -> class internals loaded
+			code = null;
 		} else {
-			List<JavaClass> list = new ArrayList<JavaClass>(inClsCount);
+			code = cls.decompile();
+		}
+
+		JadxDecompiler rootDecompiler = getRootDecompiler();
+		int inClsCount = cls.getInnerClasses().size();
+		if (inClsCount != 0) {
+			List<JavaClass> list = new ArrayList<>(inClsCount);
 			for (ClassNode inner : cls.getInnerClasses()) {
-				list.add(new JavaClass(decompiler, inner));
+				if (!inner.contains(AFlag.DONT_GENERATE)) {
+					JavaClass javaClass = rootDecompiler.convertClassNode(inner);
+					javaClass.load();
+					list.add(javaClass);
+				}
 			}
 			this.innerClasses = Collections.unmodifiableList(list);
 		}
+		int inlinedClsCount = cls.getInlinedClasses().size();
+		if (inlinedClsCount != 0) {
+			List<JavaClass> list = new ArrayList<>(inlinedClsCount);
+			for (ClassNode inner : cls.getInlinedClasses()) {
+				JavaClass javaClass = rootDecompiler.convertClassNode(inner);
+				javaClass.load();
+				list.add(javaClass);
+			}
+			this.inlinedClasses = Collections.unmodifiableList(list);
+		}
 
 		int fieldsCount = cls.getFields().size();
-		if (fieldsCount == 0) {
-			this.fields = Collections.emptyList();
-		} else {
-			List<JavaField> flds = new ArrayList<JavaField>(fieldsCount);
+		if (fieldsCount != 0) {
+			List<JavaField> flds = new ArrayList<>(fieldsCount);
 			for (FieldNode f : cls.getFields()) {
-				flds.add(new JavaField(f));
+				if (!f.contains(AFlag.DONT_GENERATE)) {
+					flds.add(rootDecompiler.convertFieldNode(f));
+				}
 			}
 			this.fields = Collections.unmodifiableList(flds);
 		}
 
 		int methodsCount = cls.getMethods().size();
-		if (methodsCount == 0) {
-			this.methods = Collections.emptyList();
-		} else {
-			List<JavaMethod> mths = new ArrayList<JavaMethod>(methodsCount);
+		if (methodsCount != 0) {
+			List<JavaMethod> mths = new ArrayList<>(methodsCount);
 			for (MethodNode m : cls.getMethods()) {
-				if (!m.getAccessFlags().isSynthetic()) {
-					mths.add(new JavaMethod(m));
+				if (!m.contains(AFlag.DONT_GENERATE)) {
+					mths.add(rootDecompiler.convertMethodNode(m));
 				}
 			}
-			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);
 		}
+		return code;
 	}
 
-	public String getCode() {
-		CodeWriter code = cls.getCode();
-		if (code == null) {
-			decompiler.processClass(cls);
-			code = cls.getCode();
+	JadxDecompiler getRootDecompiler() {
+		if (parent != null) {
+			return parent.getRootDecompiler();
 		}
-		return code != null ? code.toString() : "error processing class";
+		return decompiler;
 	}
 
+	public ICodeAnnotation getAnnotationAt(int pos) {
+		return getCodeInfo().getCodeMetadata().getAt(pos);
+	}
+
+	public Map<Integer, JavaNode> getUsageMap() {
+		Map<Integer, ICodeAnnotation> map = getCodeInfo().getCodeMetadata().getAsMap();
+		if (map.isEmpty() || decompiler == null) {
+			return Collections.emptyMap();
+		}
+		Map<Integer, JavaNode> resultMap = new HashMap<>(map.size());
+		for (Map.Entry<Integer, ICodeAnnotation> entry : map.entrySet()) {
+			int codePosition = entry.getKey();
+			ICodeAnnotation obj = entry.getValue();
+			if (obj instanceof ICodeNodeRef) {
+				JavaNode node = getRootDecompiler().getJavaNodeByRef((ICodeNodeRef) obj);
+				if (node != null) {
+					resultMap.put(codePosition, node);
+				}
+			}
+		}
+		return resultMap;
+	}
+
+	public List<Integer> getUsePlacesFor(ICodeInfo codeInfo, JavaNode javaNode) {
+		if (!codeInfo.hasMetadata()) {
+			return Collections.emptyList();
+		}
+		List<Integer> result = new ArrayList<>();
+		codeInfo.getCodeMetadata().searchDown(0, (pos, ann) -> {
+			if (javaNode.isOwnCodeAnnotation(ann)) {
+				result.add(pos);
+			}
+			return null;
+		});
+		return result;
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return getRootDecompiler().convertNodes(cls.getUseIn());
+	}
+
+	public Integer getSourceLine(int decompiledLine) {
+		return getCodeInfo().getCodeMetadata().getLineMapping().get(decompiledLine);
+	}
+
+	@Override
+	public String getName() {
+		return cls.getShortName();
+	}
+
+	@Override
 	public String getFullName() {
 		return cls.getFullName();
 	}
 
-	public String getShortName() {
-		return cls.getShortName();
+	public String getRawName() {
+		return cls.getRawName();
 	}
 
 	public String getPackage() {
 		return cls.getPackage();
 	}
 
+	public JavaPackage getJavaPackage() {
+		return cls.getPackageNode().getJavaNode();
+	}
+
+	@Override
+	public JavaClass getDeclaringClass() {
+		return parent;
+	}
+
+	public JavaClass getOriginalTopParentClass() {
+		return parent == null ? this : parent.getOriginalTopParentClass();
+	}
+
+	/**
+	 * Return top parent class which contains code of this class.
+	 * Code parent can be different from original parent after move or inline
+	 *
+	 * @return this if already a top class
+	 */
+	@Override
+	public JavaClass getTopParentClass() {
+		JavaClass codeParent = getCodeParent();
+		return codeParent == null ? this : codeParent.getTopParentClass();
+	}
+
+	/**
+	 * Return parent class which contains code of this class.
+	 * Code parent can be different for original parent after move or inline
+	 */
+	public @Nullable JavaClass getCodeParent() {
+		AnonymousClassAttr anonymousClsAttr = cls.get(AType.ANONYMOUS_CLASS);
+		if (anonymousClsAttr != null) {
+			// moved to usage class
+			return getRootDecompiler().convertClassNode(anonymousClsAttr.getOuterCls());
+		}
+		InlinedAttr inlinedAttr = cls.get(AType.INLINED);
+		if (inlinedAttr != null) {
+			return getRootDecompiler().convertClassNode(inlinedAttr.getInlineCls());
+		}
+		return parent;
+	}
+
 	public AccessInfo getAccessInfo() {
 		return cls.getAccessFlags();
 	}
 
 	public List<JavaClass> getInnerClasses() {
+		load();
 		return innerClasses;
 	}
 
+	public List<JavaClass> getInlinedClasses() {
+		load();
+		return inlinedClasses;
+	}
+
 	public List<JavaField> getFields() {
+		load();
 		return fields;
 	}
 
 	public List<JavaMethod> getMethods() {
+		load();
 		return methods;
 	}
 
+	@Nullable
+	public JavaMethod searchMethodByShortId(String shortId) {
+		MethodNode methodNode = cls.searchMethodByShortId(shortId);
+		if (methodNode == null) {
+			return null;
+		}
+		return getRootDecompiler().convertMethodNode(methodNode);
+	}
+
+	public List<JavaClass> getDependencies() {
+		JadxDecompiler d = getRootDecompiler();
+		return ListUtils.map(cls.getDependencies(), d::convertClassNode);
+	}
+
+	public int getTotalDepsCount() {
+		return cls.getTotalDepsCount();
+	}
+
+	@Override
+	public void removeAlias() {
+		cls.removeAlias();
+	}
+
+	@Override
+	public int getDefPos() {
+		return cls.getDefPosition();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		return this == o || o instanceof JavaClass && cls.equals(((JavaClass) o).cls);
+	}
+
+	@Override
+	public int hashCode() {
+		return cls.hashCode();
+	}
+
 	@Override
 	public String toString() {
 		return getFullName();
 	}
-
-	public int getDecompiledLine() {
-		return cls.getDecompiledLine();
-	}
 }

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

@@ -1,30 +1,105 @@
 package jadx.api;
 
+import java.util.List;
+
+import org.jetbrains.annotations.ApiStatus;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
 import jadx.core.dex.info.AccessInfo;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.FieldNode;
 
-public final class JavaField {
+public final class JavaField implements JavaNode {
 
 	private final FieldNode field;
+	private final JavaClass parent;
 
-	public JavaField(FieldNode f) {
+	JavaField(JavaClass cls, FieldNode f) {
 		this.field = f;
+		this.parent = cls;
 	}
 
+	@Override
 	public String getName() {
+		return field.getAlias();
+	}
+
+	@Override
+	public String getFullName() {
+		return parent.getFullName() + '.' + getName();
+	}
+
+	public String getRawName() {
 		return field.getName();
 	}
 
+	@Override
+	public JavaClass getDeclaringClass() {
+		return parent;
+	}
+
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent.getTopParentClass();
+	}
+
 	public AccessInfo getAccessFlags() {
 		return field.getAccessFlags();
 	}
 
 	public ArgType getType() {
-		return field.getType();
+		return ArgType.tryToResolveClassAlias(field.root(), field.getType());
 	}
 
-	public int getDecompiledLine() {
-		return field.getDecompiledLine();
+	@Override
+	public int getDefPos() {
+		return field.getDefPosition();
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return getDeclaringClass().getRootDecompiler().convertNodes(field.getUseIn());
+	}
+
+	@Override
+	public void removeAlias() {
+		this.field.getFieldInfo().removeAlias();
+	}
+
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.FIELD) {
+			return ann.equals(field);
+		}
+		return false;
+	}
+
+	@Override
+	public ICodeNodeRef getCodeNodeRef() {
+		return field;
+	}
+
+	/**
+	 * Internal API. Not Stable!
+	 */
+	@ApiStatus.Internal
+	public FieldNode getFieldNode() {
+		return field;
+	}
+
+	@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,27 +1,51 @@
 package jadx.api;
 
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.core.dex.attributes.AType;
+import jadx.core.dex.attributes.nodes.MethodOverrideAttr;
 import jadx.core.dex.info.AccessInfo;
-import jadx.core.dex.info.MethodInfo;
 import jadx.core.dex.instructions.args.ArgType;
 import jadx.core.dex.nodes.MethodNode;
+import jadx.core.utils.Utils;
 
-import java.util.List;
+public final class JavaMethod implements JavaNode {
+	private static final Logger LOG = LoggerFactory.getLogger(JavaMethod.class);
 
-public final class JavaMethod {
 	private final MethodNode mth;
+	private final JavaClass parent;
 
-	public JavaMethod(MethodNode m) {
+	JavaMethod(JavaClass cls, MethodNode m) {
+		this.parent = cls;
 		this.mth = m;
 	}
 
+	@Override
 	public String getName() {
-		MethodInfo mi = mth.getMethodInfo();
-		if (mi.isConstructor()) {
-			return mth.getParentClass().getShortName();
-		} else if (mi.isClassInit()) {
-			return "static";
-		}
-		return mi.getName();
+		return mth.getAlias();
+	}
+
+	@Override
+	public String getFullName() {
+		return mth.getMethodInfo().getFullName();
+	}
+
+	@Override
+	public JavaClass getDeclaringClass() {
+		return parent;
+	}
+
+	@Override
+	public JavaClass getTopParentClass() {
+		return parent.getTopParentClass();
 	}
 
 	public AccessInfo getAccessFlags() {
@@ -29,11 +53,35 @@ public final class JavaMethod {
 	}
 
 	public List<ArgType> getArguments() {
-		return mth.getMethodInfo().getArgumentsTypes();
+		List<ArgType> infoArgTypes = mth.getMethodInfo().getArgumentsTypes();
+		if (infoArgTypes.isEmpty()) {
+			return Collections.emptyList();
+		}
+		List<ArgType> arguments = mth.getArgTypes();
+		return Utils.collectionMap(arguments,
+				type -> ArgType.tryToResolveClassAlias(mth.root(), type));
 	}
 
 	public ArgType getReturnType() {
-		return mth.getReturnType();
+		ArgType retType = mth.getReturnType();
+		return ArgType.tryToResolveClassAlias(mth.root(), retType);
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return getDeclaringClass().getRootDecompiler().convertNodes(mth.getUseIn());
+	}
+
+	public List<JavaMethod> getOverrideRelatedMethods() {
+		MethodOverrideAttr ovrdAttr = mth.get(AType.METHOD_OVERRIDE);
+		if (ovrdAttr == null) {
+			return Collections.emptyList();
+		}
+		JadxDecompiler decompiler = getDeclaringClass().getRootDecompiler();
+		return ovrdAttr.getRelatedMthNodes()
+				.stream()
+				.map(decompiler::convertMethodNode)
+				.collect(Collectors.toList());
 	}
 
 	public boolean isConstructor() {
@@ -44,7 +92,53 @@ public final class JavaMethod {
 		return mth.getMethodInfo().isClassInit();
 	}
 
-	public int getDecompiledLine() {
-		return mth.getDecompiledLine();
+	@Override
+	public int getDefPos() {
+		return mth.getDefPosition();
+	}
+
+	public String getCodeStr() {
+		return mth.getCodeStr();
+	}
+
+	@Override
+	public void removeAlias() {
+		this.mth.getMethodInfo().removeAlias();
+	}
+
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.METHOD) {
+			return ann.equals(mth);
+		}
+		return false;
+	}
+
+	@Override
+	public ICodeNodeRef getCodeNodeRef() {
+		return mth;
+	}
+
+	/**
+	 * Internal API. Not Stable!
+	 */
+	@ApiStatus.Internal
+	public MethodNode getMethodNode() {
+		return mth;
+	}
+
+	@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

@@ -0,0 +1,27 @@
+package jadx.api;
+
+import java.util.List;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+
+public interface JavaNode {
+
+	ICodeNodeRef getCodeNodeRef();
+
+	String getName();
+
+	String getFullName();
+
+	JavaClass getDeclaringClass();
+
+	JavaClass getTopParentClass();
+
+	int getDefPos();
+
+	List<JavaNode> getUseIn();
+
+	void removeAlias();
+
+	boolean isOwnCodeAnnotation(ICodeAnnotation ann);
+}

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

@@ -1,45 +1,165 @@
 package jadx.api;
 
+import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
-public final class JavaPackage implements Comparable<JavaPackage> {
-	private final String name;
+import org.jetbrains.annotations.ApiStatus.Internal;
+import org.jetbrains.annotations.NotNull;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.core.dex.info.PackageInfo;
+import jadx.core.dex.nodes.PackageNode;
+
+public final class JavaPackage implements JavaNode, Comparable<JavaPackage> {
+	private final PackageNode pkgNode;
 	private final List<JavaClass> classes;
+	private final List<JavaPackage> subPkgs;
 
-	JavaPackage(String name, List<JavaClass> classes) {
-		this.name = name;
+	JavaPackage(PackageNode pkgNode, List<JavaClass> classes, List<JavaPackage> subPkgs) {
+		this.pkgNode = pkgNode;
 		this.classes = classes;
+		this.subPkgs = subPkgs;
 	}
 
+	@Override
 	public String getName() {
-		return name;
+		return pkgNode.getAliasPkgInfo().getName();
+	}
+
+	@Override
+	public String getFullName() {
+		return pkgNode.getAliasPkgInfo().getFullName();
+	}
+
+	public String getRawName() {
+		return pkgNode.getPkgInfo().getName();
+	}
+
+	public String getRawFullName() {
+		return pkgNode.getPkgInfo().getFullName();
+	}
+
+	public List<JavaPackage> getSubPackages() {
+		return subPkgs;
 	}
 
 	public List<JavaClass> getClasses() {
 		return classes;
 	}
 
+	public boolean isRoot() {
+		return pkgNode.isRoot();
+	}
+
+	public boolean isLeaf() {
+		return pkgNode.isLeaf();
+	}
+
+	public boolean isDefault() {
+		return getFullName().isEmpty();
+	}
+
+	public void rename(String alias) {
+		pkgNode.rename(alias);
+	}
+
 	@Override
-	public int compareTo(JavaPackage o) {
-		return name.compareTo(o.name);
+	public void removeAlias() {
+		pkgNode.removeAlias();
+	}
+
+	public boolean isParentRenamed() {
+		PackageInfo parent = pkgNode.getPkgInfo().getParentPkg();
+		PackageInfo aliasParent = pkgNode.getAliasPkgInfo().getParentPkg();
+		return !Objects.equals(parent, aliasParent);
+	}
+
+	public boolean isDescendantOf(JavaPackage ancestor) {
+		JavaPackage current = this;
+		while (current != null) {
+			if (ancestor.equals(current)) {
+				return true;
+			}
+
+			if (current.getPkgNode().getParentPkg() == null) {
+				current = null;
+			} else {
+				current = current.getPkgNode().getParentPkg().getJavaNode();
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public ICodeNodeRef getCodeNodeRef() {
+		return pkgNode;
+	}
+
+	@Internal
+	public PackageNode getPkgNode() {
+		return pkgNode;
+	}
+
+	@Override
+	public JavaClass getDeclaringClass() {
+		return null;
+	}
+
+	@Override
+	public JavaClass getTopParentClass() {
+		return null;
+	}
+
+	@Override
+	public int getDefPos() {
+		return 0;
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		List<JavaNode> list = new ArrayList<>();
+		addUseIn(list);
+		return list;
+	}
+
+	public void addUseIn(List<JavaNode> list) {
+		list.addAll(classes);
+		for (JavaPackage subPkg : subPkgs) {
+			subPkg.addUseIn(list);
+		}
+	}
+
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		return false;
+	}
+
+	@Override
+	public int compareTo(@NotNull JavaPackage o) {
+		return pkgNode.compareTo(o.pkgNode);
 	}
 
 	@Override
 	public boolean equals(Object o) {
-		if (this == o) return true;
-		if (o == null || getClass() != o.getClass()) return false;
+		if (this == o) {
+			return true;
+		}
+		if (o == null || getClass() != o.getClass()) {
+			return false;
+		}
 		JavaPackage that = (JavaPackage) o;
-		if (!name.equals(that.name)) return false;
-		return true;
+		return pkgNode.equals(that.pkgNode);
 	}
 
 	@Override
 	public int hashCode() {
-		return name.hashCode();
+		return pkgNode.hashCode();
 	}
 
 	@Override
 	public String toString() {
-		return name;
+		return pkgNode.toString();
 	}
 }

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

@@ -0,0 +1,109 @@
+package jadx.api;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Nullable;
+
+import jadx.api.metadata.ICodeAnnotation;
+import jadx.api.metadata.ICodeNodeRef;
+import jadx.api.metadata.annotations.VarNode;
+import jadx.api.metadata.annotations.VarRef;
+import jadx.core.dex.instructions.args.ArgType;
+
+public class JavaVariable implements JavaNode {
+	private final JavaMethod mth;
+	private final VarNode varNode;
+
+	public JavaVariable(JavaMethod mth, VarNode varNode) {
+		this.mth = mth;
+		this.varNode = varNode;
+	}
+
+	public JavaMethod getMth() {
+		return mth;
+	}
+
+	public int getReg() {
+		return varNode.getReg();
+	}
+
+	public int getSsa() {
+		return varNode.getSsa();
+	}
+
+	@Override
+	public @Nullable String getName() {
+		return varNode.getName();
+	}
+
+	@Override
+	public ICodeNodeRef getCodeNodeRef() {
+		return varNode;
+	}
+
+	@ApiStatus.Internal
+	public VarNode getVarNode() {
+		return varNode;
+	}
+
+	@Override
+	public String getFullName() {
+		return varNode.getType() + " " + varNode.getName() + " (r" + varNode.getReg() + "v" + varNode.getSsa() + ")";
+	}
+
+	public ArgType getType() {
+		return ArgType.tryToResolveClassAlias(mth.getMethodNode().root(), varNode.getType());
+	}
+
+	@Override
+	public JavaClass getDeclaringClass() {
+		return mth.getDeclaringClass();
+	}
+
+	@Override
+	public JavaClass getTopParentClass() {
+		return mth.getTopParentClass();
+	}
+
+	@Override
+	public int getDefPos() {
+		return varNode.getDefPosition();
+	}
+
+	@Override
+	public List<JavaNode> getUseIn() {
+		return Collections.singletonList(mth);
+	}
+
+	@Override
+	public void removeAlias() {
+		varNode.setName(null);
+	}
+
+	@Override
+	public boolean isOwnCodeAnnotation(ICodeAnnotation ann) {
+		if (ann.getAnnType() == ICodeAnnotation.AnnType.VAR_REF) {
+			VarRef varRef = (VarRef) ann;
+			return varRef.getRefPos() == getDefPos();
+		}
+		return false;
+	}
+
+	@Override
+	public int hashCode() {
+		return varNode.hashCode();
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (this == o) {
+			return true;
+		}
+		if (!(o instanceof JavaVariable)) {
+			return false;
+		}
+		return varNode.equals(((JavaVariable) o).varNode);
+	}
+}

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

@@ -0,0 +1,105 @@
+package jadx.api;
+
+import java.io.File;
+
+import jadx.api.plugins.utils.ZipSecurity;
+import jadx.core.xmlgen.ResContainer;
+import jadx.core.xmlgen.entry.ResourceEntry;
+
+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;
+	private String deobfName;
+
+	public static ResourceFile createResourceFile(JadxDecompiler decompiler, File file, ResourceType type) {
+		return new ResourceFile(decompiler, file.getAbsolutePath(), type);
+	}
+
+	public static ResourceFile createResourceFile(JadxDecompiler decompiler, String name, ResourceType type) {
+		if (!ZipSecurity.isValidZipEntryName(name)) {
+			return null;
+		}
+		return new ResourceFile(decompiler, name, type);
+	}
+
+	protected ResourceFile(JadxDecompiler decompiler, String name, ResourceType type) {
+		this.decompiler = decompiler;
+		this.name = name;
+		this.type = type;
+	}
+
+	public String getOriginalName() {
+		return name;
+	}
+
+	public String getDeobfName() {
+		return deobfName != null ? deobfName : name;
+	}
+
+	public void setDeobfName(String resFullName) {
+		this.deobfName = resFullName;
+	}
+
+	public ResourceType getType() {
+		return type;
+	}
+
+	public ResContainer loadContent() {
+		return ResourcesLoader.loadContent(decompiler, this);
+	}
+
+	void setZipRef(ZipRef zipRef) {
+		this.zipRef = zipRef;
+	}
+
+	public boolean setAlias(ResourceEntry ri) {
+		StringBuilder sb = new StringBuilder();
+		sb.append("res/").append(ri.getTypeName()).append(ri.getConfig());
+		sb.append("/").append(ri.getKeyName());
+		int lastDot = name.lastIndexOf('.');
+		if (lastDot != -1) {
+			sb.append(name.substring(lastDot));
+		}
+		String alias = sb.toString();
+		if (!alias.equals(name)) {
+			setDeobfName(alias);
+			return true;
+		}
+		return false;
+	}
+
+	public ZipRef getZipRef() {
+		return zipRef;
+	}
+
+	@Override
+	public String toString() {
+		return "ResourceFile{name='" + name + '\'' + ", type=" + type + '}';
+	}
+}

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

@@ -0,0 +1,17 @@
+package jadx.api;
+
+import jadx.core.xmlgen.ResContainer;
+
+public class ResourceFileContent extends ResourceFile {
+	private final ICodeInfo content;
+
+	public ResourceFileContent(String name, ResourceType type, ICodeInfo content) {
+		super(null, name, type);
+		this.content = content;
+	}
+
+	@Override
+	public ResContainer loadContent() {
+		return ResContainer.textResource(getDeobfName(), content);
+	}
+}

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

@@ -0,0 +1,60 @@
+package jadx.api;
+
+import java.util.HashMap;
+import java.util.Locale;
+import java.util.Map;
+
+import jadx.core.utils.exceptions.JadxRuntimeException;
+
+public enum ResourceType {
+	CODE(".dex", ".jar", ".class"),
+	XML(".xml"),
+	ARSC(".arsc"),
+	FONT(".ttf", ".otf"),
+	IMG(".png", ".gif", ".jpg"),
+	MEDIA(".mp3", ".wav"),
+	LIB(".so"),
+	MANIFEST,
+	UNKNOWN;
+
+	private final String[] exts;
+
+	ResourceType(String... exts) {
+		this.exts = exts;
+	}
+
+	public String[] getExts() {
+		return exts;
+	}
+
+	private static final Map<String, ResourceType> EXT_MAP = new HashMap<>();
+
+	static {
+		for (ResourceType type : ResourceType.values()) {
+			for (String ext : type.getExts()) {
+				ResourceType prev = EXT_MAP.put(ext, type);
+				if (prev != null) {
+					throw new JadxRuntimeException("Duplicate extension in ResourceType: " + ext);
+				}
+			}
+		}
+	}
+
+	public static ResourceType getFileType(String fileName) {
+		if (fileName.endsWith("/resources.pb")) {
+			return ARSC;
+		}
+		int dot = fileName.lastIndexOf('.');
+		if (dot != -1) {
+			String ext = fileName.substring(dot).toLowerCase(Locale.ROOT);
+			ResourceType resType = EXT_MAP.get(ext);
+			if (resType != null) {
+				if (resType == XML && fileName.equals("AndroidManifest.xml")) {
+					return MANIFEST;
+				}
+				return resType;
+			}
+		}
+		return UNKNOWN;
+	}
+}

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

@@ -0,0 +1,246 @@
+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.List;
+import java.util.zip.ZipEntry;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jadx.api.ResourceFile.ZipRef;
+import jadx.api.impl.SimpleCodeInfo;
+import jadx.api.plugins.CustomResourcesLoader;
+import jadx.api.plugins.resources.IResContainerFactory;
+import jadx.api.plugins.resources.IResTableParserProvider;
+import jadx.api.plugins.resources.IResourcesLoader;
+import jadx.api.plugins.utils.ZipSecurity;
+import jadx.core.dex.nodes.RootNode;
+import jadx.core.utils.Utils;
+import jadx.core.utils.android.Res9patchStreamDecoder;
+import jadx.core.utils.exceptions.JadxException;
+import jadx.core.utils.exceptions.JadxRuntimeException;
+import jadx.core.utils.files.FileUtils;
+import jadx.core.utils.files.ZipFile;
+import jadx.core.xmlgen.BinaryXMLParser;
+import jadx.core.xmlgen.IResTableParser;
+import jadx.core.xmlgen.ResContainer;
+import jadx.core.xmlgen.ResTableBinaryParserProvider;
+
+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 implements IResourcesLoader {
+	private static final Logger LOG = LoggerFactory.getLogger(ResourcesLoader.class);
+
+	private final JadxDecompiler jadxRef;
+
+	private final List<IResTableParserProvider> resTableParserProviders = new ArrayList<>();
+	private final List<IResContainerFactory> resContainerFactories = new ArrayList<>();
+
+	private BinaryXMLParser binaryXmlParser;
+
+	ResourcesLoader(JadxDecompiler jadxRef) {
+		this.jadxRef = jadxRef;
+		this.resTableParserProviders.add(new ResTableBinaryParserProvider());
+	}
+
+	List<ResourceFile> load(RootNode root) {
+		init(root);
+		List<File> inputFiles = jadxRef.getArgs().getInputFiles();
+		List<ResourceFile> list = new ArrayList<>(inputFiles.size());
+		for (File file : inputFiles) {
+			loadFile(list, file);
+		}
+		return list;
+	}
+
+	private void init(RootNode root) {
+		for (IResTableParserProvider resTableParserProvider : resTableParserProviders) {
+			try {
+				resTableParserProvider.init(root);
+			} catch (Exception e) {
+				throw new JadxRuntimeException("Failed to init res table provider: " + resTableParserProvider);
+			}
+		}
+		for (IResContainerFactory resContainerFactory : resContainerFactories) {
+			try {
+				resContainerFactory.init(root);
+			} catch (Exception e) {
+				throw new JadxRuntimeException("Failed to init res container factory: " + resContainerFactory);
+			}
+		}
+	}
+
+	public interface ResourceDecoder<T> {
+		T decode(long size, InputStream is) throws IOException;
+	}
+
+	@Override
+	public void addResContainerFactory(IResContainerFactory resContainerFactory) {
+		resContainerFactories.add(resContainerFactory);
+	}
+
+	@Override
+	public void addResTableParserProvider(IResTableParserProvider resTableParserProvider) {
+		resTableParserProviders.add(resTableParserProvider);
+	}
+
+	public static <T> T decodeStream(ResourceFile rf, ResourceDecoder<T> decoder) throws JadxException {
+		try {
+			ZipRef zipRef = rf.getZipRef();
+			if (zipRef == null) {
+				File file = new File(rf.getOriginalName());
+				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 = ZipSecurity.getInputStreamForEntry(zipFile, entry)) {
+						return decoder.decode(entry.getSize(), inputStream);
+					}
+				}
+			}
+		} catch (Exception e) {
+			throw new JadxException("Error decode: " + rf.getDeobfName(), e);
+		}
+	}
+
+	static ResContainer loadContent(JadxDecompiler jadxRef, ResourceFile rf) {
+		try {
+			ResourcesLoader resLoader = jadxRef.getResourcesLoader();
+			return decodeStream(rf, (size, is) -> resLoader.loadContent(rf, is));
+		} catch (JadxException e) {
+			LOG.error("Decode error", e);
+			ICodeWriter cw = jadxRef.getRoot().makeCodeWriter();
+			cw.add("Error decode ").add(rf.getType().toString().toLowerCase());
+			Utils.appendStackTrace(cw, e.getCause());
+			return ResContainer.textResource(rf.getDeobfName(), cw.finish());
+		}
+	}
+
+	private ResContainer loadContent(ResourceFile resFile, InputStream inputStream) throws IOException {
+		for (IResContainerFactory customFactory : resContainerFactories) {
+			ResContainer resContainer = customFactory.create(resFile, inputStream);
+			if (resContainer != null) {
+				return resContainer;
+			}
+		}
+		switch (resFile.getType()) {
+			case MANIFEST:
+			case XML:
+				ICodeInfo content = loadBinaryXmlParser().parse(inputStream);
+				return ResContainer.textResource(resFile.getDeobfName(), content);
+
+			case ARSC:
+				return decodeTable(resFile, inputStream).decodeFiles();
+
+			case IMG:
+				return decodeImage(resFile, inputStream);
+
+			default:
+				return ResContainer.resourceFileLink(resFile);
+		}
+	}
+
+	public IResTableParser decodeTable(ResourceFile resFile, InputStream is) throws IOException {
+		if (resFile.getType() != ResourceType.ARSC) {
+			throw new IllegalArgumentException("Unexpected resource type for decode: " + resFile.getType() + ", expect '.pb'/'.arsc'");
+		}
+		IResTableParser parser = null;
+		for (IResTableParserProvider provider : resTableParserProviders) {
+			parser = provider.getParser(resFile);
+			if (parser != null) {
+				break;
+			}
+		}
+		if (parser == null) {
+			throw new JadxRuntimeException("Unknown type of resource file: " + resFile.getOriginalName());
+		}
+		parser.decode(is);
+		return parser;
+	}
+
+	private static ResContainer decodeImage(ResourceFile rf, InputStream inputStream) {
+		String name = rf.getOriginalName();
+		if (name.endsWith(".9.png")) {
+			try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
+				Res9patchStreamDecoder decoder = new Res9patchStreamDecoder();
+				if (decoder.decode(inputStream, os)) {
+					return ResContainer.decodedData(rf.getDeobfName(), os.toByteArray());
+				}
+			} catch (Exception e) {
+				LOG.error("Failed to decode 9-patch png image, path: {}", name, e);
+			}
+		}
+		return ResContainer.resourceFileLink(rf);
+	}
+
+	private void loadFile(List<ResourceFile> list, File file) {
+		if (file == null || file.isDirectory()) {
+			return;
+		}
+
+		// Try to load the resources with a custom loader first
+		for (CustomResourcesLoader loader : jadxRef.getCustomResourcesLoaders()) {
+			if (loader.load(this, list, file)) {
+				LOG.debug("Custom loader used for {}", file.getAbsolutePath());
+				return;
+			}
+		}
+
+		// If no custom decoder was able to decode the resources, use the default decoder
+		defaultLoadFile(list, file, "");
+	}
+
+	public void defaultLoadFile(List<ResourceFile> list, File file, String subDir) {
+		if (FileUtils.isZipFile(file)) {
+			ZipSecurity.visitZipEntries(file, (zipFile, entry) -> {
+				addEntry(list, file, entry, subDir);
+				return null;
+			});
+		} else {
+			ResourceType type = ResourceType.getFileType(file.getAbsolutePath());
+			list.add(ResourceFile.createResourceFile(jadxRef, file, type));
+		}
+	}
+
+	public void addEntry(List<ResourceFile> list, File zipFile, ZipEntry entry, String subDir) {
+		if (entry.isDirectory()) {
+			return;
+		}
+		String name = entry.getName();
+		ResourceType type = ResourceType.getFileType(name);
+		ResourceFile rf = ResourceFile.createResourceFile(jadxRef, subDir + name, type);
+		if (rf != null) {
+			rf.setZipRef(new ZipRef(zipFile, name));
+			list.add(rf);
+		}
+	}
+
+	public static ICodeInfo loadToCodeWriter(InputStream is) throws IOException {
+		ByteArrayOutputStream baos = new ByteArrayOutputStream(READ_BUFFER_SIZE);
+		copyStream(is, baos);
+		return new SimpleCodeInfo(baos.toString("UTF-8"));
+	}
+
+	private synchronized BinaryXMLParser loadBinaryXmlParser() {
+		if (binaryXmlParser == null) {
+			binaryXmlParser = new BinaryXMLParser(jadxRef.getRoot());
+		}
+		return binaryXmlParser;
+	}
+}

jadx-core/src/main/java/jadx/api/args/GeneratedRenamesMappingFileMode.java

@@ -0,0 +1,36 @@
+package jadx.api.args;
+
+public enum GeneratedRenamesMappingFileMode {
+
+	/**
+	 * Load if found, don't save (default)
+	 */
+	READ,
+
+	/**
+	 * Load if found, save only if new (don't overwrite)
+	 */
+	READ_OR_SAVE,
+
+	/**
+	 * Don't load, always save
+	 */
+	OVERWRITE,
+
+	/**
+	 * Don't load and don't save
+	 */
+	IGNORE;
+
+	public static GeneratedRenamesMappingFileMode getDefault() {
+		return READ;
+	}
+
+	public boolean shouldRead() {
+		return this == READ || this == READ_OR_SAVE;
+	}
+
+	public boolean shouldWrite() {
+		return this == READ_OR_SAVE || this == OVERWRITE;
+	}
+}

jadx-core/src/main/java/jadx/api/args/IntegerFormat.java

@@ -0,0 +1,11 @@
+package jadx.api.args;
+
+public enum IntegerFormat {
+	AUTO,
+	DECIMAL,
+	HEXADECIMAL;
+
+	public boolean isHexadecimal() {
+		return this == HEXADECIMAL;
+	}
+}

jadx-core/src/main/java/jadx/api/args/ResourceNameSource.java

@@ -0,0 +1,22 @@
+package jadx.api.args;
+
+/**
+ * Resources original name source (for deobfuscation)
+ */
+public enum ResourceNameSource {
+
+	/**
+	 * Automatically select best name (default)
+	 */
+	AUTO,
+
+	/**
+	 * Force use resources provided names
+	 */
+	RESOURCES,
+
+	/**
+	 * Force use resources names from R class
+	 */
+	CODE,
+}

jadx-core/src/main/java/jadx/api/args/UseSourceNameAsClassNameAlias.java

@@ -0,0 +1,38 @@
+package jadx.api.args;
+
+import jadx.core.utils.exceptions.JadxRuntimeException;
+
+public enum UseSourceNameAsClassNameAlias {
+	ALWAYS,
+	IF_BETTER,
+	NEVER;
+
+	public static UseSourceNameAsClassNameAlias getDefault() {
+		return NEVER;
+	}
+
+	/**
+	 * @deprecated Use {@link UseSourceNameAsClassNameAlias} directly.
+	 */
+	@Deprecated
+	public boolean toBoolean() {
+		switch (this) {
+			case IF_BETTER:
+				return true;
+			case NEVER:
+				return false;
+			case ALWAYS:
+				throw new JadxRuntimeException("No match between " + this + " and boolean");
+			default:
+				throw new JadxRuntimeException("Unhandled strategy: " + this);
+		}
+	}
+
+	/**
+	 * @deprecated Use {@link UseSourceNameAsClassNameAlias} directly.
+	 */
+	@Deprecated
+	public static UseSourceNameAsClassNameAlias create(boolean useSourceNameAsAlias) {
+		return useSourceNameAsAlias ? IF_BETTER : NEVER;
+	}
+}

jadx-core/src/main/java/jadx/api/args/UserRenamesMappingsMode.java

@@ -0,0 +1,36 @@
+package jadx.api.args;
+
+public enum UserRenamesMappingsMode {
+
+	/**
+	 * Just read, user can save manually (default)
+	 */
+	READ,
+
+	/**
+	 * Read and autosave after every change
+	 */
+	READ_AND_AUTOSAVE_EVERY_CHANGE,
+
+	/**
+	 * Read and autosave before exiting the app or closing the project
+	 */
+	READ_AND_AUTOSAVE_BEFORE_CLOSING,
+
+	/**
+	 * Don't load and don't save
+	 */
+	IGNORE;
+
+	public static UserRenamesMappingsMode getDefault() {
+		return READ;
+	}
+
+	public boolean shouldRead() {
+		return this != IGNORE;
+	}
+
+	public boolean shouldWrite() {
+		return this == READ_AND_AUTOSAVE_EVERY_CHANGE || this == READ_AND_AUTOSAVE_BEFORE_CLOSING;
+	}
+}