diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle
index 74c5cfd..81527b4 100644
--- a/buildSrc/build.gradle
+++ b/buildSrc/build.gradle
@@ -7,10 +7,18 @@
 repositories {
     mavenCentral()
 }
+ext {
+    asmVersion = '9.3'
+}
 
 dependencies {
     compile group: 'com.google.guava', name: 'guava', version: '19.0'
     compile group: 'org.smali', name: 'smali', version: '2.2b4'
+    compile group: 'org.ow2.asm', name: 'asm', version: asmVersion
+    compile group: 'org.ow2.asm', name: 'asm-commons', version: asmVersion
+    compile group: 'org.ow2.asm', name: 'asm-tree', version: asmVersion
+    compile group: 'org.ow2.asm', name: 'asm-analysis', version: asmVersion
+    compile group: 'org.ow2.asm', name: 'asm-util', version: asmVersion
 }
 
 sourceCompatibility = JavaVersion.VERSION_1_8
diff --git a/buildSrc/src/main/java/desugaredlibrary/AsmRewriter.java b/buildSrc/src/main/java/desugaredlibrary/AsmRewriter.java
new file mode 100644
index 0000000..cc1fcf2
--- /dev/null
+++ b/buildSrc/src/main/java/desugaredlibrary/AsmRewriter.java
@@ -0,0 +1,53 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package desugaredlibrary;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+public abstract class AsmRewriter {
+
+  public static int ASM_VERSION = Opcodes.ASM9;
+
+  public static byte[] transformInvoke(byte[] bytes, MethodTransformer transformer) {
+    ClassReader reader = new ClassReader(bytes);
+    ClassWriter writer = new ClassWriter(reader, 0);
+    ClassVisitor subvisitor = new InvokeTransformer(writer, transformer);
+    reader.accept(subvisitor, 0);
+    return writer.toByteArray();
+  }
+
+  public static class InvokeTransformer extends ClassVisitor {
+
+    private final MethodTransformer transformer;
+
+    InvokeTransformer(ClassWriter writer, MethodTransformer transformer) {
+      super(ASM_VERSION, writer);
+      this.transformer = transformer;
+    }
+
+    @Override
+    public MethodVisitor visitMethod(
+        int access, String name, String descriptor, String signature, String[] exceptions) {
+      MethodVisitor sub = super.visitMethod(access, name, descriptor, signature, exceptions);
+      transformer.setMv(sub);
+      return transformer;
+    }
+  }
+
+  public static class MethodTransformer extends MethodVisitor {
+
+    protected MethodTransformer(int api) {
+      super(api);
+    }
+
+    public void setMv(MethodVisitor visitor) {
+      this.mv = visitor;
+    }
+  }
+}
diff --git a/buildSrc/src/main/java/desugaredlibrary/CustomConversionAsmRewriteDescription.java b/buildSrc/src/main/java/desugaredlibrary/CustomConversionAsmRewriteDescription.java
new file mode 100644
index 0000000..137ac12
--- /dev/null
+++ b/buildSrc/src/main/java/desugaredlibrary/CustomConversionAsmRewriteDescription.java
@@ -0,0 +1,54 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package desugaredlibrary;
+
+import com.google.common.collect.ImmutableSet;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class CustomConversionAsmRewriteDescription {
+
+  static final String WRAP_CONVERT = "wrap_convert";
+  static final String INVERTED_WRAP_CONVERT = "inverted_wrap_convert";
+  static final String CONVERT = "convert";
+
+  private static final Set<String> ENUM_WRAP_CONVERT_OWNER =
+      ImmutableSet.of(
+          "j$/nio/file/StandardOpenOption",
+          "j$/nio/file/LinkOption",
+          "j$/nio/file/attribute/PosixFilePermission",
+          "j$/util/stream/Collector$Characteristics");
+  private static final Set<String> WRAP_CONVERT_OWNER =
+      ImmutableSet.of(
+          "j$/nio/file/spi/FileSystemProvider",
+          "j$/nio/file/spi/FileTypeDetector",
+          "j$/nio/file/Path",
+          "j$/nio/file/WatchEvent",
+          "j$/nio/file/attribute/BasicFileAttributes",
+          "j$/nio/file/attribute/BasicFileAttributeView",
+          "j$/nio/file/attribute/FileOwnerAttributeView",
+          "j$/nio/file/attribute/PosixFileAttributes",
+          "j$/nio/file/attribute/PosixFileAttributeView");
+
+  static Map<String, String> getJavaWrapConvertOwnerMap() {
+    return computeConvertOwnerMap("$VivifiedWrapper");
+  }
+
+  static Map<String, String> getJ$WrapConvertOwnerMap() {
+    return computeConvertOwnerMap("$Wrapper");
+  }
+
+  private static HashMap<String, String> computeConvertOwnerMap(String suffix) {
+    HashMap<String, String> map = new HashMap<>();
+    for (String theEnum : ENUM_WRAP_CONVERT_OWNER) {
+      map.put(theEnum, theEnum + "$EnumConversion");
+    }
+    for (String owner : WRAP_CONVERT_OWNER) {
+      map.put(owner, owner + suffix);
+    }
+    return map;
+  }
+}
diff --git a/buildSrc/src/main/java/desugaredlibrary/CustomConversionAsmRewriter.java b/buildSrc/src/main/java/desugaredlibrary/CustomConversionAsmRewriter.java
new file mode 100644
index 0000000..6107e67
--- /dev/null
+++ b/buildSrc/src/main/java/desugaredlibrary/CustomConversionAsmRewriter.java
@@ -0,0 +1,183 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package desugaredlibrary;
+
+import static desugaredlibrary.AsmRewriter.ASM_VERSION;
+import static desugaredlibrary.CustomConversionAsmRewriteDescription.CONVERT;
+import static desugaredlibrary.CustomConversionAsmRewriteDescription.INVERTED_WRAP_CONVERT;
+import static desugaredlibrary.CustomConversionAsmRewriteDescription.WRAP_CONVERT;
+import static desugaredlibrary.CustomConversionAsmRewriter.CustomConversionVersion.LEGACY;
+import static org.objectweb.asm.Opcodes.INVOKESTATIC;
+
+import com.google.common.io.ByteStreams;
+import desugaredlibrary.AsmRewriter.MethodTransformer;
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.OpenOption;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.Enumeration;
+import java.util.Map;
+import java.util.zip.CRC32;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipOutputStream;
+
+public class CustomConversionAsmRewriter {
+
+  public enum CustomConversionVersion {
+    LEGACY,
+    LATEST
+  }
+
+  public CustomConversionAsmRewriter(CustomConversionVersion legacy) {
+    this.legacy = legacy;
+  }
+
+  private final CustomConversionVersion legacy;
+  private final Map<String, String> javaWrapConvertOwnerMap =
+      CustomConversionAsmRewriteDescription.getJavaWrapConvertOwnerMap();
+  private final Map<String, String> j$WrapConvertOwnerMap =
+      CustomConversionAsmRewriteDescription.getJ$WrapConvertOwnerMap();
+
+  public static void generateJars(Path jar, Path outputDirectory) throws IOException {
+    for (CustomConversionVersion version : CustomConversionVersion.values()) {
+      new CustomConversionAsmRewriter(version).convert(jar, outputDirectory);
+    }
+  }
+
+  private void convert(Path jar, Path outputDirectory) throws IOException {
+    String fileName = jar.getFileName().toString();
+    String newFileName =
+        fileName.substring(0, fileName.length() - "_raw.jar".length())
+            + (legacy == LEGACY ? "_legacy" : "")
+            + ".jar";
+    Path convertedJar = outputDirectory.resolve(newFileName);
+    internalConvert(jar, convertedJar);
+  }
+
+  private void internalConvert(Path jar, Path convertedJar) throws IOException {
+    OpenOption[] options =
+        new OpenOption[] {StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING};
+    try (ZipOutputStream out =
+        new ZipOutputStream(
+            new BufferedOutputStream(Files.newOutputStream(convertedJar, options)))) {
+      new CustomConversionAsmRewriter(legacy).convert(jar, out, legacy);
+    }
+  }
+
+  private void convert(
+      Path desugaredLibraryFiles, ZipOutputStream out, CustomConversionVersion legacy)
+      throws IOException {
+    try (ZipFile zipFile = new ZipFile(desugaredLibraryFiles.toFile(), StandardCharsets.UTF_8)) {
+      final Enumeration<? extends ZipEntry> entries = zipFile.entries();
+      while (entries.hasMoreElements()) {
+        ZipEntry entry = entries.nextElement();
+        try (InputStream entryStream = zipFile.getInputStream(entry)) {
+          handleFile(entry, entryStream, out, legacy);
+        }
+      }
+    }
+  }
+
+  private void handleFile(
+      ZipEntry entry, InputStream input, ZipOutputStream out, CustomConversionVersion legacy)
+      throws IOException {
+    if (!entry.getName().endsWith(".class")) {
+      return;
+    }
+    if (legacy == LEGACY
+        && (entry.getName().contains("java.nio.file")
+            || entry.getName().contains("ApiFlips")
+            || entry.getName().contains("java.adapter"))) {
+      return;
+    }
+    final byte[] bytes = ByteStreams.toByteArray(input);
+    input.close();
+    final byte[] rewrittenBytes = transformInvoke(bytes);
+    writeToZipStream(out, entry.getName(), rewrittenBytes, ZipEntry.STORED);
+  }
+
+  public static void writeToZipStream(
+      ZipOutputStream stream, String entry, byte[] content, int compressionMethod)
+      throws IOException {
+    int offset = 0;
+    int length = content.length;
+    CRC32 crc = new CRC32();
+    crc.update(content, offset, length);
+    ZipEntry zipEntry = new ZipEntry(entry);
+    zipEntry.setMethod(compressionMethod);
+    zipEntry.setSize(length);
+    zipEntry.setCrc(crc.getValue());
+    zipEntry.setTime(0);
+    stream.putNextEntry(zipEntry);
+    stream.write(content, offset, length);
+    stream.closeEntry();
+  }
+
+  private byte[] transformInvoke(byte[] bytes) {
+    return AsmRewriter.transformInvoke(bytes, new CustomConversionRewriter(ASM_VERSION));
+  }
+
+  class CustomConversionRewriter extends MethodTransformer {
+
+    protected CustomConversionRewriter(int api) {
+      super(api);
+    }
+
+    @Override
+    public void visitMethodInsn(
+        int opcode, String owner, String name, String descriptor, boolean isInterface) {
+      if (opcode == INVOKESTATIC) {
+        if (name.equals(WRAP_CONVERT)) {
+          convertInvoke(
+              opcode,
+              owner,
+              descriptor,
+              isInterface,
+              javaWrapConvertOwnerMap,
+              j$WrapConvertOwnerMap);
+          return;
+        }
+        if (name.equals(INVERTED_WRAP_CONVERT)) {
+          convertInvoke(
+              opcode,
+              owner,
+              descriptor,
+              isInterface,
+              j$WrapConvertOwnerMap,
+              javaWrapConvertOwnerMap);
+          return;
+        }
+      }
+      super.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
+    }
+
+    private void convertInvoke(
+        int opcode,
+        String owner,
+        String descriptor,
+        boolean isInterface,
+        Map<String, String> javaMap,
+        Map<String, String> j$Map) {
+      if (!javaMap.containsKey(owner)
+          || !j$Map.containsKey(owner)
+          || !(owner.startsWith("java") || owner.startsWith("j$"))) {
+        throw new RuntimeException("Cannot transform wrap_convert method for " + owner);
+      }
+      if (owner.startsWith("java")) {
+        String newOwner = j$Map.get(owner);
+        super.visitMethodInsn(opcode, newOwner, CONVERT, descriptor, isInterface);
+        return;
+      }
+      assert owner.startsWith("j$");
+      String newOwner = javaMap.get(owner);
+      super.visitMethodInsn(opcode, newOwner, CONVERT, descriptor, isInterface);
+    }
+  }
+}
diff --git a/buildSrc/src/main/java/desugaredlibrary/CustomConversionAsmRewriterTask.java b/buildSrc/src/main/java/desugaredlibrary/CustomConversionAsmRewriterTask.java
new file mode 100644
index 0000000..bae3c1c
--- /dev/null
+++ b/buildSrc/src/main/java/desugaredlibrary/CustomConversionAsmRewriterTask.java
@@ -0,0 +1,78 @@
+// Copyright (c) 2022, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+package desugaredlibrary;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import javax.inject.Inject;
+import org.gradle.api.DefaultTask;
+import org.gradle.api.tasks.InputFile;
+import org.gradle.api.tasks.OutputDirectory;
+import org.gradle.api.tasks.TaskAction;
+import org.gradle.workers.IsolationMode;
+import org.gradle.workers.WorkerExecutor;
+
+public class CustomConversionAsmRewriterTask extends DefaultTask {
+
+  private final WorkerExecutor workerExecutor;
+
+  private File rawJar;
+  private File outputDirectory;
+
+  @Inject
+  public CustomConversionAsmRewriterTask(WorkerExecutor workerExecutor) {
+    this.workerExecutor = workerExecutor;
+  }
+
+  @InputFile
+  public File getRawJar() {
+    return rawJar;
+  }
+
+  public void setRawJar(File rawJar) {
+    this.rawJar = rawJar;
+  }
+
+  @OutputDirectory
+  public File getOutputDirectory() {
+    return outputDirectory;
+  }
+
+  public void setOutputDirectory(File outputDirectory) {
+    this.outputDirectory = outputDirectory;
+  }
+
+  @TaskAction
+  void exec() {
+    workerExecutor.submit(
+        Run.class,
+        config -> {
+          config.setIsolationMode(IsolationMode.NONE);
+          config.params(rawJar, outputDirectory);
+        });
+  }
+
+  public static class Run implements Runnable {
+
+    private final File rawJar;
+    private final File outputDirectory;
+
+    @Inject
+    public Run(File rawJar, File outputDirectory) {
+      this.rawJar = rawJar;
+      this.outputDirectory = outputDirectory;
+    }
+
+    @Override
+    public void run() {
+      try {
+        CustomConversionAsmRewriter.generateJars(rawJar.toPath(), outputDirectory.toPath());
+      } catch (IOException e) {
+        throw new UncheckedIOException(e);
+      }
+    }
+  }
+}