Info Call to External Storage API

Description

List of all external storage API calls. Insecure storage of sensitive information by setting insecure permissions or storing data without encryption might expose this information to an attacker.

Recommendation

This entry is informative, no recommendations applicable.

Technical details

Method org.spongycastle.crypto.examples.DESExample.<init>() calling method java.io.FileOutputStream.<init>()


    public DESExample(String p16, String p17, String p18, boolean p19)
    {
        this.encrypt = 1;
        this.cipher = 0;
        this.in = 0;
        this.out = 0;
        this.key = 0;
        this.encrypt = p19;
        try {
            this.in = new java.io.BufferedInputStream(new java.io.FileInputStream(p16));
            try {
                this.out = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p17));
            } catch (java.io.IOException v2) {
                System.err.println(new StringBuilder().append("Output file not created [").append(p17).append("]").toString());
                System.exit(1);
            }
            if (!p19) {
                try {
                    java.io.BufferedOutputStream v5_3 = new java.io.BufferedInputStream(new java.io.FileInputStream(p18));
                    int v8 = v5_3.available();
                    byte[] v4_1 = new byte[v8];
                    v5_3.read(v4_1, 0, v8);
                    this.key = org.spongycastle.util.encoders.Hex.decode(v4_1);
                } catch (java.io.IOException v3) {
                    System.err.println(new StringBuilder().append("Decryption key file not found, or not valid [").append(p18).append("]").toString());
                    System.exit(1);
                }
            } else {
                java.security.SecureRandom v10 = 0;
                try {
                    java.security.SecureRandom v11_1 = new java.security.SecureRandom();
                    try {
                        v11_1.setSeed("www.bouncycastle.org".getBytes());
                        v10 = v11_1;
                    } catch (Exception v9) {
                        v10 = v11_1;
                        System.err.println("Hmmm, no SHA1PRNG, you need the Sun implementation");
                        System.exit(1);
                    } catch (java.io.IOException v1) {
                        System.err.println(new StringBuilder().append("Could not decryption create key file [").append(p18).append("]").toString());
                        System.exit(1);
                    }
                    org.spongycastle.crypto.KeyGenerationParameters v7_1 = new org.spongycastle.crypto.KeyGenerationParameters(v10, 192);
                    org.spongycastle.crypto.generators.DESedeKeyGenerator v6_1 = new org.spongycastle.crypto.generators.DESedeKeyGenerator();
                    v6_1.init(v7_1);
                    this.key = v6_1.generateKey();
                    java.io.BufferedOutputStream v5_1 = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p18));
                    byte[] v4_0 = org.spongycastle.util.encoders.Hex.encode(this.key);
                    v5_1.write(v4_0, 0, v4_0.length);
                    v5_1.flush();
                    v5_1.close();
                } catch (Exception v9) {
                } catch (java.io.IOException v1) {
                }
            }
            return;
        } catch (java.io.IOException v2) {
            System.err.println(new StringBuilder().append("Input file not found [").append(p16).append("]").toString());
            System.exit(1);
        }
    }

Method org.apache.commons.io.output.XmlStreamWriter.<init>() calling method java.io.FileOutputStream.<init>()


    public XmlStreamWriter(java.io.File p2, String p3)
    {
        this(new java.io.FileOutputStream(p2), p3);
        return;
    }

Method org.apache.commons.io.output.LockableFileWriter.initWriter() calling method java.io.FileOutputStream.<init>()


    private java.io.Writer initWriter(java.io.File p8, String p9, boolean p10)
    {
        java.io.OutputStreamWriter v4;
        boolean v1 = p8.exists();
        java.io.FileOutputStream v2 = 0;
        v4 = 0;
        try {
            if (p9 != null) {
                java.io.FileOutputStream v3_1 = new java.io.FileOutputStream(p8.getAbsolutePath(), p10);
                try {
                    v4 = new java.io.OutputStreamWriter(v3_1, p9);
                    v2 = v3_1;
                } catch (RuntimeException v0_1) {
                    v2 = v3_1;
                } catch (RuntimeException v0_0) {
                    v2 = v3_1;
                    org.apache.commons.io.IOUtils.closeQuietly(v4);
                    org.apache.commons.io.IOUtils.closeQuietly(v2);
                    org.apache.commons.io.FileUtils.deleteQuietly(this.lockFile);
                    if (!v1) {
                        org.apache.commons.io.FileUtils.deleteQuietly(p8);
                    }
                    throw v0_0;
                }
                return v4;
            } else {
                v4 = new java.io.FileWriter(p8.getAbsolutePath(), p10);
                return v4;
            }
        } catch (RuntimeException v0_1) {
        } catch (RuntimeException v0_0) {
        }
        org.apache.commons.io.IOUtils.closeQuietly(v4);
        org.apache.commons.io.IOUtils.closeQuietly(v2);
        org.apache.commons.io.FileUtils.deleteQuietly(this.lockFile);
        if (!v1) {
            org.apache.commons.io.FileUtils.deleteQuietly(p8);
        }
        throw v0_1;
    }

Method org.apache.commons.io.output.FileWriterWithEncoding.initWriter() calling method java.io.FileOutputStream.<init>()


    private static java.io.Writer initWriter(java.io.File p8, Object p9, boolean p10)
    {
        if (p8 != null) {
            if (p9 != null) {
                boolean v1 = p8.exists();
                java.io.FileOutputStream v2 = 0;
                java.io.OutputStreamWriter v4 = 0;
                try {
                    java.io.FileOutputStream v3_1 = new java.io.FileOutputStream(p8, p10);
                    try {
                        if (!(p9 instanceof java.nio.charset.Charset)) {
                            if (!(p9 instanceof java.nio.charset.CharsetEncoder)) {
                                v4 = new java.io.OutputStreamWriter(v3_1, ((String) p9));
                            } else {
                                v4 = new java.io.OutputStreamWriter(v3_1, ((java.nio.charset.CharsetEncoder) p9));
                            }
                        } else {
                            v4 = new java.io.OutputStreamWriter(v3_1, ((java.nio.charset.Charset) p9));
                        }
                    } catch (RuntimeException v0_1) {
                        v2 = v3_1;
                        org.apache.commons.io.IOUtils.closeQuietly(v4);
                        org.apache.commons.io.IOUtils.closeQuietly(v2);
                        if (!v1) {
                            org.apache.commons.io.FileUtils.deleteQuietly(p8);
                        }
                        throw v0_1;
                    } catch (RuntimeException v0_0) {
                        v2 = v3_1;
                        org.apache.commons.io.IOUtils.closeQuietly(v4);
                        org.apache.commons.io.IOUtils.closeQuietly(v2);
                        if (!v1) {
                            org.apache.commons.io.FileUtils.deleteQuietly(p8);
                        }
                        throw v0_0;
                    }
                    return v4;
                } catch (RuntimeException v0_1) {
                } catch (RuntimeException v0_0) {
                }
            } else {
                throw new NullPointerException("Encoding is missing");
            }
        } else {
            throw new NullPointerException("File is missing");
        }
    }

Method org.apache.commons.io.output.DeferredFileOutputStream.thresholdReached() calling method java.io.FileOutputStream.<init>()


    protected void thresholdReached()
    {
        if (this.prefix != null) {
            this.outputFile = java.io.File.createTempFile(this.prefix, this.suffix, this.directory);
        }
        java.io.FileOutputStream v0_0 = new java.io.FileOutputStream(this.outputFile);
        this.memoryOutputStream.writeTo(v0_0);
        this.currentOutputStream = v0_0;
        this.memoryOutputStream = 0;
        return;
    }

Method org.apache.commons.io.FileUtils.openOutputStream() calling method java.io.FileOutputStream.<init>()


    public static java.io.FileOutputStream openOutputStream(java.io.File p4, boolean p5)
    {
        if (!p4.exists()) {
            java.io.File v0 = p4.getParentFile();
            if ((v0 != null) && ((!v0.mkdirs()) && (!v0.isDirectory()))) {
                throw new java.io.IOException(new StringBuilder().append("Directory \'").append(v0).append("\' could not be created").toString());
            }
        } else {
            if (!p4.isDirectory()) {
                if (!p4.canWrite()) {
                    throw new java.io.IOException(new StringBuilder().append("File \'").append(p4).append("\' cannot be written to").toString());
                }
            } else {
                throw new java.io.IOException(new StringBuilder().append("File \'").append(p4).append("\' exists but is a directory").toString());
            }
        }
        return new java.io.FileOutputStream(p4, p5);
    }

Method org.apache.commons.io.FileUtils.doCopyFile() calling method java.io.FileOutputStream.<init>()


    private static void doCopyFile(java.io.File p18, java.io.File p19, boolean p20)
    {
        if ((!p19.exists()) || (!p19.isDirectory())) {
            java.io.FileInputStream v8 = 0;
            java.io.FileOutputStream v10 = 0;
            java.nio.channels.FileChannel v3 = 0;
            java.nio.channels.FileChannel v2 = 0;
            try {
                java.io.FileInputStream v9_1 = new java.io.FileInputStream(p18);
                try {
                    java.io.FileOutputStream v11_1 = new java.io.FileOutputStream(p19);
                    try {
                        v3 = v9_1.getChannel();
                        v2 = v11_1.getChannel();
                        long v12 = v3.size();
                        long v4 = 0;
                    } catch (long v14_1) {
                        v10 = v11_1;
                        v8 = v9_1;
                        org.apache.commons.io.IOUtils.closeQuietly(v2);
                        org.apache.commons.io.IOUtils.closeQuietly(v10);
                        org.apache.commons.io.IOUtils.closeQuietly(v3);
                        org.apache.commons.io.IOUtils.closeQuietly(v8);
                        throw v14_1;
                    }
                    while (v4 < v12) {
                        long v6;
                        if ((v12 - v4) <= 31457280) {
                            v6 = (v12 - v4);
                        } else {
                            v6 = 31457280;
                        }
                        v4 += v2.transferFrom(v3, v4, v6);
                    }
                    org.apache.commons.io.IOUtils.closeQuietly(v2);
                    org.apache.commons.io.IOUtils.closeQuietly(v11_1);
                    org.apache.commons.io.IOUtils.closeQuietly(v3);
                    org.apache.commons.io.IOUtils.closeQuietly(v9_1);
                    if (p18.length() == p19.length()) {
                        if (p20) {
                            p19.setLastModified(p18.lastModified());
                        }
                        return;
                    } else {
                        throw new java.io.IOException(new StringBuilder().append("Failed to copy full contents from \'").append(p18).append("\' to \'").append(p19).append("\'").toString());
                    }
                } catch (long v14_1) {
                    v8 = v9_1;
                }
            } catch (long v14_1) {
            }
        } else {
            throw new java.io.IOException(new StringBuilder().append("Destination \'").append(p19).append("\' exists but is a directory").toString());
        }
    }

Method com.zebra.sdk.util.internal.ZipUtil.extractEntry() calling method java.io.FileOutputStream.<init>()


    public void extractEntry(String p5, String p6)
    {
        this.openStreams();
        while(true) {
            java.io.FileOutputStream v0_4 = this.zin.getNextEntry();
            if (v0_4 == null) {
                break;
            }
            if (v0_4.getName().equals(p6)) {
                java.io.FileOutputStream v0_3 = new java.io.FileOutputStream(p5);
                byte[] v1_1 = new byte[16384];
                while(true) {
                    int v2_1 = this.zin.read(v1_1);
                    if (v2_1 == -1) {
                        break;
                    }
                    v0_3.write(v1_1, 0, v2_1);
                }
                v0_3.close();
            }
        }
        this.closeStreams();
        return;
    }

Method com.zebra.sdk.util.internal.ZipUtil.writeEntries() calling method java.io.FileOutputStream.<init>()


    private void writeEntries(java.util.Set p8)
    {
        java.io.FileOutputStream v1_1 = new java.io.FileOutputStream(this.pathToZipFile);
        java.util.zip.ZipOutputStream v2_1 = new java.util.zip.ZipOutputStream(new java.io.BufferedOutputStream(v1_1));
        java.util.Iterator v3 = p8.iterator();
        while (v3.hasNext()) {
            byte[] v0_3 = ((com.zebra.sdk.util.internal.ZipUtil$EntryData) v3.next());
            java.io.FileInputStream v4_1 = new java.util.zip.ZipEntry(v0_3.name);
            if (v0_3.extraData != null) {
                v4_1.setExtra(v0_3.extraData);
            }
            v2_1.putNextEntry(v4_1);
            if (v0_3.srcData == null) {
                if (v0_3.srcFile != null) {
                    java.io.FileInputStream v4_5 = new java.io.FileInputStream(v0_3.srcFile);
                    byte[] v0_6 = new byte[16384];
                    while (v4_5.available() > 0) {
                        v2_1.write(v0_6, 0, v4_5.read(v0_6));
                    }
                    v4_5.close();
                }
            } else {
                v2_1.write(v0_3.srcData);
            }
            v2_1.closeEntry();
        }
        v2_1.close();
        v1_1.close();
        return;
    }

Method com.zebra.sdk.util.internal.Base64.encodeToFile() calling method java.io.FileOutputStream.<init>()


    public static boolean encodeToFile(byte[] p5, String p6)
    {
        java.io.IOException v0_0 = 1;
        int v2 = 0;
        try {
            Exception v1_1 = new com.zebra.sdk.util.internal.Base64$OutputStream(new java.io.FileOutputStream(p6), 1);
            try {
                v1_1.write(p5);
                try {
                    v1_1.close();
                } catch (Exception v1) {
                }
                return v0_0;
            } catch (java.io.IOException v0_1) {
                v2 = v1_1;
                try {
                    v2.close();
                } catch (Exception v1) {
                }
                throw v0_1;
            } catch (java.io.IOException v0) {
                v0_0 = 0;
                try {
                    v1_1.close();
                } catch (Exception v1) {
                }
                return v0_0;
            }
        } catch (java.io.IOException v0_1) {
        } catch (java.io.IOException v0) {
            v1_1 = 0;
        }
    }

Method com.zebra.sdk.util.internal.Base64.decodeToFile() calling method java.io.FileOutputStream.<init>()


    public static boolean decodeToFile(String p5, String p6)
    {
        Throwable v0_0 = 0;
        java.io.IOException v2_0 = 0;
        try {
            Exception v1_1 = new com.zebra.sdk.util.internal.Base64$OutputStream(new java.io.FileOutputStream(p6), 0);
            try {
                v1_1.write(p5.getBytes("UTF-8"));
                v0_0 = 1;
                try {
                    v1_1.close();
                } catch (Exception v1) {
                }
                return v0_0;
            } catch (Throwable v0_1) {
                v2_0 = v1_1;
                try {
                    v2_0.close();
                } catch (Exception v1) {
                }
                throw v0_1;
            } catch (java.io.IOException v2) {
                try {
                    v1_1.close();
                } catch (Exception v1) {
                }
                return v0_0;
            }
        } catch (Throwable v0_1) {
        } catch (Exception v1) {
            v1_1 = 0;
        }
    }

Method com.zebra.sdk.printer.internal.ProfileUtilLinkOsImpl.createProfile() calling method java.io.FileOutputStream.<init>()


    public void createProfile(String p3)
    {
        java.io.FileOutputStream v1_1 = new java.io.FileOutputStream(com.zebra.sdk.util.internal.FileUtilities.changeExtension(p3, "zprofile"));
        this.createOutputZipFile(v1_1, this.getAllConfig());
        v1_1.flush();
        v1_1.close();
        return;
    }

Method com.zebra.sdk.printer.internal.ProfileHelper.modifyProfile() calling method java.io.FileOutputStream.<init>()


    public static void modifyProfile(String p7, com.zebra.sdk.printer.internal.ProfileHelper$ProfileComponentTransformer p8)
    {
        String v0_0 = com.zebra.sdk.util.internal.FileReader.toByteArray(p7);
        java.io.File v2_1 = java.io.File.createTempFile("proftmp", 0);
        byte[] v1_6 = new java.io.FileOutputStream(v2_1.getAbsolutePath());
        v1_6.write(v0_0);
        v1_6.close();
        new java.io.File(p7).delete();
        String v0_3 = v2_1.getAbsolutePath();
        try {
            java.util.zip.ZipOutputStream v3_1 = new java.util.zip.ZipOutputStream(new java.io.BufferedOutputStream(new java.io.FileOutputStream(p7)));
            com.zebra.sdk.util.internal.ZipUtil v4_3 = new com.zebra.sdk.util.internal.ZipUtil(v0_3);
            java.util.Iterator v5 = v4_3.getEntryNames().iterator();
        } catch (String v0_8) {
            v0_8.printStackTrace();
            return;
        }
        while (v5.hasNext()) {
            byte[] v1_4;
            String v0_7 = ((String) v5.next());
            if (!p8.shouldTransformComponent(v0_7)) {
                v1_4 = v4_3.extractEntry(v0_7);
            } else {
                v1_4 = p8.transformComponent();
            }
            if ((v1_4 != null) && (v1_4.length > 0)) {
                v3_1.putNextEntry(new java.util.zip.ZipEntry(v0_7));
                v3_1.write(v1_4);
                v3_1.closeEntry();
            }
        }
        v3_1.close();
        v2_1.delete();
        return;
    }

Method com.zebra.sdk.certificate.internal.CertUtilities.getOutputStream() calling method java.io.FileOutputStream.<init>()


    protected java.io.OutputStream getOutputStream(String p2)
    {
        return new java.io.FileOutputStream(p2);
    }

Method com.fasterxml.jackson.core.JsonFactory.createGenerator() calling method java.io.FileOutputStream.<init>()


    public com.fasterxml.jackson.core.JsonGenerator createGenerator(java.io.File p4, com.fasterxml.jackson.core.JsonEncoding p5)
    {
        com.fasterxml.jackson.core.JsonGenerator v0_3;
        com.fasterxml.jackson.core.JsonGenerator v0_1 = new java.io.FileOutputStream(p4);
        com.fasterxml.jackson.core.io.IOContext v1_1 = this._createContext(v0_1, 1);
        v1_1.setEncoding(p5);
        if (p5 != com.fasterxml.jackson.core.JsonEncoding.UTF8) {
            com.fasterxml.jackson.core.JsonGenerator v0_2 = this._createWriter(v0_1, p5, v1_1);
            if (this._outputDecorator != null) {
                v0_2 = this._outputDecorator.decorate(v1_1, v0_2);
            }
            v0_3 = this._createGenerator(v0_2, v1_1);
        } else {
            if (this._outputDecorator != null) {
                v0_1 = this._outputDecorator.decorate(v1_1, v0_1);
            }
            v0_3 = this._createUTF8Generator(v0_1, v1_1);
        }
        return v0_3;
    }

Method android.support.v4.util.AtomicFile.startWrite() calling method java.io.FileOutputStream.<init>()


    public java.io.FileOutputStream startWrite()
    {
        if (this.mBaseName.exists()) {
            if (this.mBackupName.exists()) {
                this.mBaseName.delete();
            } else {
                if (!this.mBaseName.renameTo(this.mBackupName)) {
                    android.util.Log.w("AtomicFile", new StringBuilder().append("Couldn\'t rename file ").append(this.mBaseName).append(" to backup file ").append(this.mBackupName).toString());
                }
            }
        }
        try {
            java.io.FileOutputStream v3_1 = new java.io.FileOutputStream(this.mBaseName);
        } catch (java.io.FileNotFoundException v0) {
            if (this.mBaseName.getParentFile().mkdirs()) {
                try {
                    v3_1 = new java.io.FileOutputStream(this.mBaseName);
                } catch (java.io.FileNotFoundException v1) {
                    throw new java.io.IOException(new StringBuilder().append("Couldn\'t create ").append(this.mBaseName).toString());
                }
            } else {
                throw new java.io.IOException(new StringBuilder().append("Couldn\'t create directory ").append(this.mBaseName).toString());
            }
        }
        return v3_1;
    }

Method android.support.v4.print.PrintHelperKitkat$2.doInBackground() calling method java.io.FileOutputStream.<init>()


    protected varargs Throwable doInBackground(Void[] p13)
    {
        Throwable v7 = 0;
        try {
            if (!this.val$cancellationSignal.isCanceled()) {
                android.print.pdf.PrintedPdfDocument v6_1 = new android.print.pdf.PrintedPdfDocument(this.this$0.mContext, this.val$pdfAttributes);
                android.graphics.Bitmap v4 = android.support.v4.print.PrintHelperKitkat.access$100(this.this$0, this.val$bitmap, this.val$pdfAttributes.getColorMode());
                if (!this.val$cancellationSignal.isCanceled()) {
                    try {
                        android.graphics.RectF v0_1;
                        android.graphics.pdf.PdfDocument$Page v5 = v6_1.startPage(1);
                    } catch (java.io.IOException v8_30) {
                        v6_1.close();
                        if (this.val$fileDescriptor != null) {
                            try {
                                this.val$fileDescriptor.close();
                            } catch (java.io.FileDescriptor v9) {
                            }
                        }
                        if (v4 != this.val$bitmap) {
                            v4.recycle();
                        }
                        throw v8_30;
                    }
                    if (!this.this$0.mIsMinMarginsHandlingCorrect) {
                        android.print.pdf.PrintedPdfDocument v1_1 = new android.print.pdf.PrintedPdfDocument(this.this$0.mContext, this.val$attributes);
                        android.graphics.pdf.PdfDocument$Page v2 = v1_1.startPage(1);
                        v0_1 = new android.graphics.RectF(v2.getInfo().getContentRect());
                        v1_1.finishPage(v2);
                        v1_1.close();
                    } else {
                        v0_1 = new android.graphics.RectF(v5.getInfo().getContentRect());
                    }
                    android.graphics.Matrix v3 = android.support.v4.print.PrintHelperKitkat.access$200(this.this$0, v4.getWidth(), v4.getHeight(), v0_1, this.val$fittingMode);
                    if (!this.this$0.mIsMinMarginsHandlingCorrect) {
                        v3.postTranslate(v0_1.left, v0_1.top);
                        v5.getCanvas().clipRect(v0_1);
                    }
                    v5.getCanvas().drawBitmap(v4, v3, 0);
                    v6_1.finishPage(v5);
                    if (!this.val$cancellationSignal.isCanceled()) {
                        v6_1.writeTo(new java.io.FileOutputStream(this.val$fileDescriptor.getFileDescriptor()));
                        v6_1.close();
                        if (this.val$fileDescriptor != null) {
                            try {
                                this.val$fileDescriptor.close();
                            } catch (java.io.IOException v8) {
                            }
                        }
                        if (v4 != this.val$bitmap) {
                            v4.recycle();
                        }
                    } else {
                        v6_1.close();
                        if (this.val$fileDescriptor != null) {
                            try {
                                this.val$fileDescriptor.close();
                            } catch (java.io.IOException v8) {
                            }
                        }
                        if (v4 != this.val$bitmap) {
                            v4.recycle();
                        }
                    }
                }
            }
        } catch (Throwable v7) {
        }
        return v7;
    }

Method android.support.multidex.MultiDexExtractor.extract() calling method java.io.FileOutputStream.<init>()


    private static void extract(java.util.zip.ZipFile p10, java.util.zip.ZipEntry p11, java.io.File p12, String p13)
    {
        java.io.InputStream v2 = p10.getInputStream(p11);
        java.io.File v6 = java.io.File.createTempFile(p13, ".zip", p12.getParentFile());
        android.util.Log.i("MultiDex", new StringBuilder().append("Extracting ").append(v6.getPath()).toString());
        try {
            java.util.zip.ZipOutputStream v5_1 = new java.util.zip.ZipOutputStream(new java.io.BufferedOutputStream(new java.io.FileOutputStream(v6)));
            try {
                java.util.zip.ZipEntry v1_1 = new java.util.zip.ZipEntry("classes.dex");
                v1_1.setTime(p11.getTime());
                v5_1.putNextEntry(v1_1);
                byte[] v0 = new byte[16384];
                int v3 = v2.read(v0);
            } catch (java.io.IOException v7_13) {
                v5_1.close();
                throw v7_13;
            } catch (java.io.IOException v7_2) {
                android.support.multidex.MultiDexExtractor.closeQuietly(v2);
                v6.delete();
                throw v7_2;
            }
            while (v3 != -1) {
                v5_1.write(v0, 0, v3);
                v3 = v2.read(v0);
            }
            v5_1.closeEntry();
            v5_1.close();
            android.util.Log.i("MultiDex", new StringBuilder().append("Renaming to ").append(p12.getPath()).toString());
            if (v6.renameTo(p12)) {
                android.support.multidex.MultiDexExtractor.closeQuietly(v2);
                v6.delete();
                return;
            } else {
                throw new java.io.IOException(new StringBuilder().append("Failed to rename \"").append(v6.getAbsolutePath()).append("\" to \"").append(p12.getAbsolutePath()).append("\"").toString());
            }
        } catch (java.io.IOException v7_2) {
        }
    }

Method org.apache.commons.io.output.LockableFileWriter.initWriter() calling method java.io.FileWriter.<init>()


    private java.io.Writer initWriter(java.io.File p8, String p9, boolean p10)
    {
        java.io.OutputStreamWriter v4;
        boolean v1 = p8.exists();
        java.io.FileOutputStream v2 = 0;
        v4 = 0;
        try {
            if (p9 != null) {
                java.io.FileOutputStream v3_1 = new java.io.FileOutputStream(p8.getAbsolutePath(), p10);
                try {
                    v4 = new java.io.OutputStreamWriter(v3_1, p9);
                    v2 = v3_1;
                } catch (RuntimeException v0_1) {
                    v2 = v3_1;
                } catch (RuntimeException v0_0) {
                    v2 = v3_1;
                    org.apache.commons.io.IOUtils.closeQuietly(v4);
                    org.apache.commons.io.IOUtils.closeQuietly(v2);
                    org.apache.commons.io.FileUtils.deleteQuietly(this.lockFile);
                    if (!v1) {
                        org.apache.commons.io.FileUtils.deleteQuietly(p8);
                    }
                    throw v0_0;
                }
                return v4;
            } else {
                v4 = new java.io.FileWriter(p8.getAbsolutePath(), p10);
                return v4;
            }
        } catch (RuntimeException v0_1) {
        } catch (RuntimeException v0_0) {
        }
        org.apache.commons.io.IOUtils.closeQuietly(v4);
        org.apache.commons.io.IOUtils.closeQuietly(v2);
        org.apache.commons.io.FileUtils.deleteQuietly(this.lockFile);
        if (!v1) {
            org.apache.commons.io.FileUtils.deleteQuietly(p8);
        }
        throw v0_1;
    }

Method com.zebra.sdk.certificate.internal.CertUtilities.getWriter() calling method java.io.FileWriter.<init>()


    protected java.io.Writer getWriter(String p2)
    {
        return new java.io.FileWriter(p2);
    }

Method org.spongycastle.openssl.jcajce.JcaPKIXIdentityBuilder.build() calling method java.io.FileInputStream.<init>()


    public org.spongycastle.pkix.jcajce.JcaPKIXIdentity build(java.io.File p4, java.io.File p5)
    {
        this.checkFile(p4);
        this.checkFile(p5);
        java.io.FileInputStream v1_1 = new java.io.FileInputStream(p4);
        java.io.FileInputStream v0_1 = new java.io.FileInputStream(p5);
        org.spongycastle.pkix.jcajce.JcaPKIXIdentity v2 = this.build(v1_1, v0_1);
        v1_1.close();
        v0_1.close();
        return v2;
    }

Method org.spongycastle.cms.CMSProcessableFile.write() calling method java.io.FileInputStream.<init>()


    public void write(java.io.OutputStream p6)
    {
        java.io.FileInputStream v0_1 = new java.io.FileInputStream(this.file);
        while(true) {
            int v1 = v0_1.read(this.buf, 0, this.buf.length);
            if (v1 <= 0) {
                break;
            }
            p6.write(this.buf, 0, v1);
        }
        v0_1.close();
        return;
    }

Method org.spongycastle.cms.CMSProcessableFile.getInputStream() calling method java.io.FileInputStream.<init>()


    public java.io.InputStream getInputStream()
    {
        return new java.io.BufferedInputStream(new java.io.FileInputStream(this.file), 32768);
    }

Method org.spongycastle.crypto.examples.DESExample.<init>() calling method java.io.FileInputStream.<init>()


    public DESExample(String p16, String p17, String p18, boolean p19)
    {
        this.encrypt = 1;
        this.cipher = 0;
        this.in = 0;
        this.out = 0;
        this.key = 0;
        this.encrypt = p19;
        try {
            this.in = new java.io.BufferedInputStream(new java.io.FileInputStream(p16));
            try {
                this.out = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p17));
            } catch (java.io.IOException v2) {
                System.err.println(new StringBuilder().append("Output file not created [").append(p17).append("]").toString());
                System.exit(1);
            }
            if (!p19) {
                try {
                    java.io.BufferedOutputStream v5_3 = new java.io.BufferedInputStream(new java.io.FileInputStream(p18));
                    int v8 = v5_3.available();
                    byte[] v4_1 = new byte[v8];
                    v5_3.read(v4_1, 0, v8);
                    this.key = org.spongycastle.util.encoders.Hex.decode(v4_1);
                } catch (java.io.IOException v3) {
                    System.err.println(new StringBuilder().append("Decryption key file not found, or not valid [").append(p18).append("]").toString());
                    System.exit(1);
                }
            } else {
                java.security.SecureRandom v10 = 0;
                try {
                    java.security.SecureRandom v11_1 = new java.security.SecureRandom();
                    try {
                        v11_1.setSeed("www.bouncycastle.org".getBytes());
                        v10 = v11_1;
                    } catch (Exception v9) {
                        v10 = v11_1;
                        System.err.println("Hmmm, no SHA1PRNG, you need the Sun implementation");
                        System.exit(1);
                    } catch (java.io.IOException v1) {
                        System.err.println(new StringBuilder().append("Could not decryption create key file [").append(p18).append("]").toString());
                        System.exit(1);
                    }
                    org.spongycastle.crypto.KeyGenerationParameters v7_1 = new org.spongycastle.crypto.KeyGenerationParameters(v10, 192);
                    org.spongycastle.crypto.generators.DESedeKeyGenerator v6_1 = new org.spongycastle.crypto.generators.DESedeKeyGenerator();
                    v6_1.init(v7_1);
                    this.key = v6_1.generateKey();
                    java.io.BufferedOutputStream v5_1 = new java.io.BufferedOutputStream(new java.io.FileOutputStream(p18));
                    byte[] v4_0 = org.spongycastle.util.encoders.Hex.encode(this.key);
                    v5_1.write(v4_0, 0, v4_0.length);
                    v5_1.flush();
                    v5_1.close();
                } catch (Exception v9) {
                } catch (java.io.IOException v1) {
                }
            }
            return;
        } catch (java.io.IOException v2) {
            System.err.println(new StringBuilder().append("Input file not found [").append(p16).append("]").toString());
            System.exit(1);
        }
    }

Method org.spongycastle.asn1.util.Dump.main() calling method java.io.FileInputStream.<init>()


    public static void main(String[] p5)
    {
        org.spongycastle.asn1.ASN1InputStream v0_1 = new org.spongycastle.asn1.ASN1InputStream(new java.io.FileInputStream(p5[0]));
        while(true) {
            org.spongycastle.asn1.ASN1Primitive v2 = v0_1.readObject();
            if (v2 == null) {
                break;
            }
            System.out.println(org.spongycastle.asn1.util.ASN1Dump.dumpAsString(v2));
        }
        return;
    }

Method org.apache.http.entity.mime.content.FileBody.writeTo() calling method java.io.FileInputStream.<init>()


    public void writeTo(java.io.OutputStream p5)
    {
        org.apache.http.util.Args.notNull(p5, "Output stream");
        java.io.FileInputStream v0_1 = new java.io.FileInputStream(this.file);
        try {
            byte[] v2 = new byte[4096];
        } catch (int v3_1) {
            v0_1.close();
            throw v3_1;
        }
        while(true) {
            int v1 = v0_1.read(v2);
            if (v1 == -1) {
                break;
            }
            p5.write(v2, 0, v1);
        }
        p5.flush();
        v0_1.close();
        return;
    }

Method org.apache.http.entity.mime.content.FileBody.getInputStream() calling method java.io.FileInputStream.<init>()


    public java.io.InputStream getInputStream()
    {
        return new java.io.FileInputStream(this.file);
    }

Method org.apache.http.entity.FileEntity.writeTo() calling method java.io.FileInputStream.<init>()


    public void writeTo(java.io.OutputStream p5)
    {
        org.apache.http.util.Args.notNull(p5, "Output stream");
        java.io.FileInputStream v0_1 = new java.io.FileInputStream(this.file);
        try {
            byte[] v2 = new byte[4096];
        } catch (int v3_1) {
            v0_1.close();
            throw v3_1;
        }
        while(true) {
            int v1 = v0_1.read(v2);
            if (v1 == -1) {
                break;
            }
            p5.write(v2, 0, v1);
        }
        p5.flush();
        v0_1.close();
        return;
    }

Method org.apache.http.entity.FileEntity.getContent() calling method java.io.FileInputStream.<init>()


    public java.io.InputStream getContent()
    {
        return new java.io.FileInputStream(this.file);
    }

Method org.apache.commons.net.util.KeyManagerUtils.loadStore() calling method java.io.FileInputStream.<init>()


    private static java.security.KeyStore loadStore(String p4, java.io.File p5, String p6)
    {
        java.security.KeyStore v0 = java.security.KeyStore.getInstance(p4);
        java.io.FileInputStream v1 = 0;
        try {
            java.io.FileInputStream v2_1 = new java.io.FileInputStream(p5);
            try {
                v0.load(v2_1, p6.toCharArray());
                org.apache.commons.net.io.Util.closeQuietly(v2_1);
                return v0;
            } catch (Throwable v3_0) {
                v1 = v2_1;
                org.apache.commons.net.io.Util.closeQuietly(v1);
                throw v3_0;
            }
        } catch (Throwable v3_0) {
        }
        v0.load(v2_1, p6.toCharArray());
        org.apache.commons.net.io.Util.closeQuietly(v2_1);
        return v0;
    }

Method org.apache.commons.io.output.DeferredFileOutputStream.writeTo() calling method java.io.FileInputStream.<init>()


    public void writeTo(java.io.OutputStream p4)
    {
        if (this.closed) {
            if (!this.isInMemory()) {
                java.io.FileInputStream v0_1 = new java.io.FileInputStream(this.outputFile);
                try {
                    org.apache.commons.io.IOUtils.copy(v0_1, p4);
                    org.apache.commons.io.IOUtils.closeQuietly(v0_1);
                } catch (Throwable v1_1) {
                    org.apache.commons.io.IOUtils.closeQuietly(v0_1);
                    throw v1_1;
                }
            } else {
                this.memoryOutputStream.writeTo(p4);
            }
            return;
        } else {
            throw new java.io.IOException("Stream not closed");
        }
    }

Method org.apache.commons.io.input.XmlStreamReader.<init>() calling method java.io.FileInputStream.<init>()


    public XmlStreamReader(java.io.File p2)
    {
        this(new java.io.FileInputStream(p2));
        return;
    }

Method org.apache.commons.io.FileUtils.openInputStream() calling method java.io.FileInputStream.<init>()


    public static java.io.FileInputStream openInputStream(java.io.File p3)
    {
        if (!p3.exists()) {
            throw new java.io.FileNotFoundException(new StringBuilder().append("File \'").append(p3).append("\' does not exist").toString());
        } else {
            if (!p3.isDirectory()) {
                if (p3.canRead()) {
                    return new java.io.FileInputStream(p3);
                } else {
                    throw new java.io.IOException(new StringBuilder().append("File \'").append(p3).append("\' cannot be read").toString());
                }
            } else {
                throw new java.io.IOException(new StringBuilder().append("File \'").append(p3).append("\' exists but is a directory").toString());
            }
        }
    }

Method org.apache.commons.io.FileUtils.doCopyFile() calling method java.io.FileInputStream.<init>()


    private static void doCopyFile(java.io.File p18, java.io.File p19, boolean p20)
    {
        if ((!p19.exists()) || (!p19.isDirectory())) {
            java.io.FileInputStream v8 = 0;
            java.io.FileOutputStream v10 = 0;
            java.nio.channels.FileChannel v3 = 0;
            java.nio.channels.FileChannel v2 = 0;
            try {
                java.io.FileInputStream v9_1 = new java.io.FileInputStream(p18);
                try {
                    java.io.FileOutputStream v11_1 = new java.io.FileOutputStream(p19);
                    try {
                        v3 = v9_1.getChannel();
                        v2 = v11_1.getChannel();
                        long v12 = v3.size();
                        long v4 = 0;
                    } catch (long v14_1) {
                        v10 = v11_1;
                        v8 = v9_1;
                        org.apache.commons.io.IOUtils.closeQuietly(v2);
                        org.apache.commons.io.IOUtils.closeQuietly(v10);
                        org.apache.commons.io.IOUtils.closeQuietly(v3);
                        org.apache.commons.io.IOUtils.closeQuietly(v8);
                        throw v14_1;
                    }
                    while (v4 < v12) {
                        long v6;
                        if ((v12 - v4) <= 31457280) {
                            v6 = (v12 - v4);
                        } else {
                            v6 = 31457280;
                        }
                        v4 += v2.transferFrom(v3, v4, v6);
                    }
                    org.apache.commons.io.IOUtils.closeQuietly(v2);
                    org.apache.commons.io.IOUtils.closeQuietly(v11_1);
                    org.apache.commons.io.IOUtils.closeQuietly(v3);
                    org.apache.commons.io.IOUtils.closeQuietly(v9_1);
                    if (p18.length() == p19.length()) {
                        if (p20) {
                            p19.setLastModified(p18.lastModified());
                        }
                        return;
                    } else {
                        throw new java.io.IOException(new StringBuilder().append("Failed to copy full contents from \'").append(p18).append("\' to \'").append(p19).append("\'").toString());
                    }
                } catch (long v14_1) {
                    v8 = v9_1;
                }
            } catch (long v14_1) {
            }
        } else {
            throw new java.io.IOException(new StringBuilder().append("Destination \'").append(p19).append("\' exists but is a directory").toString());
        }
    }

Method org.apache.commons.io.FileUtils.copyFile() calling method java.io.FileInputStream.<init>()


    public static long copyFile(java.io.File p4, java.io.OutputStream p5)
    {
        java.io.FileInputStream v0_1 = new java.io.FileInputStream(p4);
        try {
            long v2 = org.apache.commons.io.IOUtils.copyLarge(v0_1, p5);
            v0_1.close();
            return v2;
        } catch (Throwable v1) {
            v0_1.close();
            throw v1;
        }
    }

Method org.apache.commons.io.FileUtils.contentEqualsIgnoreEOL() calling method java.io.FileInputStream.<init>()


    public static boolean contentEqualsIgnoreEOL(java.io.File p8, java.io.File p9, String p10)
    {
        boolean v5_0 = 1;
        boolean v0 = p8.exists();
        if (v0 == p9.exists()) {
            if (v0) {
                if ((!p8.isDirectory()) && (!p9.isDirectory())) {
                    if (!p8.getCanonicalFile().equals(p9.getCanonicalFile())) {
                        java.io.InputStreamReader v3;
                        java.io.InputStreamReader v1;
                        java.io.InputStreamReader v2_1;
                        v1 = 0;
                        v3 = 0;
                        try {
                            if (p10 != null) {
                                v2_1 = new java.io.InputStreamReader(new java.io.FileInputStream(p8), p10);
                                v3 = new java.io.InputStreamReader(new java.io.FileInputStream(p9), p10);
                                v1 = v2_1;
                                v5_0 = org.apache.commons.io.IOUtils.contentEqualsIgnoreEOL(v1, v3);
                                org.apache.commons.io.IOUtils.closeQuietly(v1);
                                org.apache.commons.io.IOUtils.closeQuietly(v3);
                                return v5_0;
                            } else {
                                v2_1 = new java.io.InputStreamReader(new java.io.FileInputStream(p8));
                                v3 = new java.io.InputStreamReader(new java.io.FileInputStream(p9));
                                v1 = v2_1;
                            }
                        } catch (boolean v5_9) {
                        } catch (boolean v5_9) {
                            v1 = v2_1;
                        }
                        org.apache.commons.io.IOUtils.closeQuietly(v1);
                        org.apache.commons.io.IOUtils.closeQuietly(v3);
                        throw v5_9;
                    }
                } else {
                    throw new java.io.IOException("Can\'t compare directories, only files");
                }
            }
        } else {
            v5_0 = 0;
        }
        return v5_0;
    }

Method org.apache.commons.io.FileUtils.contentEqualsIgnoreEOL() calling method java.io.FileInputStream.<init>()


    public static boolean contentEqualsIgnoreEOL(java.io.File p8, java.io.File p9, String p10)
    {
        boolean v5_0 = 1;
        boolean v0 = p8.exists();
        if (v0 == p9.exists()) {
            if (v0) {
                if ((!p8.isDirectory()) && (!p9.isDirectory())) {
                    if (!p8.getCanonicalFile().equals(p9.getCanonicalFile())) {
                        java.io.InputStreamReader v2_1;
                        java.io.InputStreamReader v1;
                        java.io.InputStreamReader v3;
                        v1 = 0;
                        v3 = 0;
                        try {
                            if (p10 != null) {
                                v2_1 = new java.io.InputStreamReader(new java.io.FileInputStream(p8), p10);
                                v3 = new java.io.InputStreamReader(new java.io.FileInputStream(p9), p10);
                                v1 = v2_1;
                                v5_0 = org.apache.commons.io.IOUtils.contentEqualsIgnoreEOL(v1, v3);
                                org.apache.commons.io.IOUtils.closeQuietly(v1);
                                org.apache.commons.io.IOUtils.closeQuietly(v3);
                                return v5_0;
                            } else {
                                v2_1 = new java.io.InputStreamReader(new java.io.FileInputStream(p8));
                                v3 = new java.io.InputStreamReader(new java.io.FileInputStream(p9));
                                v1 = v2_1;
                            }
                        } catch (boolean v5_9) {
                        } catch (boolean v5_9) {
                            v1 = v2_1;
                        }
                        org.apache.commons.io.IOUtils.closeQuietly(v1);
                        org.apache.commons.io.IOUtils.closeQuietly(v3);
                        throw v5_9;
                    }
                } else {
                    throw new java.io.IOException("Can\'t compare directories, only files");
                }
            }
        } else {
            v5_0 = 0;
        }
        return v5_0;
    }

Method org.apache.commons.io.FileUtils.contentEqualsIgnoreEOL() calling method java.io.FileInputStream.<init>()


    public static boolean contentEqualsIgnoreEOL(java.io.File p8, java.io.File p9, String p10)
    {
        boolean v5_0 = 1;
        boolean v0 = p8.exists();
        if (v0 == p9.exists()) {
            if (v0) {
                if ((!p8.isDirectory()) && (!p9.isDirectory())) {
                    if (!p8.getCanonicalFile().equals(p9.getCanonicalFile())) {
                        java.io.InputStreamReader v3;
                        java.io.InputStreamReader v2_1;
                        java.io.InputStreamReader v1;
                        v1 = 0;
                        v3 = 0;
                        try {
                            if (p10 != null) {
                                v2_1 = new java.io.InputStreamReader(new java.io.FileInputStream(p8), p10);
                                v3 = new java.io.InputStreamReader(new java.io.FileInputStream(p9), p10);
                                v1 = v2_1;
                                v5_0 = org.apache.commons.io.IOUtils.contentEqualsIgnoreEOL(v1, v3);
                                org.apache.commons.io.IOUtils.closeQuietly(v1);
                                org.apache.commons.io.IOUtils.closeQuietly(v3);
                                return v5_0;
                            } else {
                                v2_1 = new java.io.InputStreamReader(new java.io.FileInputStream(p8));
                                v3 = new java.io.InputStreamReader(new java.io.FileInputStream(p9));
                                v1 = v2_1;
                            }
                        } catch (boolean v5_9) {
                        } catch (boolean v5_9) {
                            v1 = v2_1;
                        }
                        org.apache.commons.io.IOUtils.closeQuietly(v1);
                        org.apache.commons.io.IOUtils.closeQuietly(v3);
                        throw v5_9;
                    }
                } else {
                    throw new java.io.IOException("Can\'t compare directories, only files");
                }
            }
        } else {
            v5_0 = 0;
        }
        return v5_0;
    }

Method org.apache.commons.io.FileUtils.contentEquals() calling method java.io.FileInputStream.<init>()


    public static boolean contentEquals(java.io.File p12, java.io.File p13)
    {
        Throwable v5_0 = 0;
        boolean v0 = p12.exists();
        if (v0 == p13.exists()) {
            if (v0) {
                if ((!p12.isDirectory()) && (!p13.isDirectory())) {
                    if (p12.length() == p13.length()) {
                        if (!p12.getCanonicalFile().equals(p13.getCanonicalFile())) {
                            java.io.FileInputStream v1 = 0;
                            java.io.FileInputStream v3 = 0;
                            try {
                                java.io.FileInputStream v2_1 = new java.io.FileInputStream(p12);
                                try {
                                    java.io.FileInputStream v4_1 = new java.io.FileInputStream(p13);
                                    try {
                                        v5_0 = org.apache.commons.io.IOUtils.contentEquals(v2_1, v4_1);
                                        org.apache.commons.io.IOUtils.closeQuietly(v2_1);
                                        org.apache.commons.io.IOUtils.closeQuietly(v4_1);
                                    } catch (Throwable v5_3) {
                                        v3 = v4_1;
                                        v1 = v2_1;
                                        org.apache.commons.io.IOUtils.closeQuietly(v1);
                                        org.apache.commons.io.IOUtils.closeQuietly(v3);
                                        throw v5_3;
                                    }
                                } catch (Throwable v5_3) {
                                    v1 = v2_1;
                                }
                            } catch (Throwable v5_3) {
                            }
                        } else {
                            v5_0 = 1;
                        }
                    }
                } else {
                    throw new java.io.IOException("Can\'t compare directories, only files");
                }
            } else {
                v5_0 = 1;
            }
        }
        return v5_0;
    }

Method org.apache.commons.io.FileUtils.checksum() calling method java.io.FileInputStream.<init>()


    public static java.util.zip.Checksum checksum(java.io.File p4, java.util.zip.Checksum p5)
    {
        if (!p4.isDirectory()) {
            java.util.zip.CheckedInputStream v0 = 0;
            try {
                java.util.zip.CheckedInputStream v1_1 = new java.util.zip.CheckedInputStream(new java.io.FileInputStream(p4), p5);
                try {
                    org.apache.commons.io.IOUtils.copy(v1_1, new org.apache.commons.io.output.NullOutputStream());
                    org.apache.commons.io.IOUtils.closeQuietly(v1_1);
                    return p5;
                } catch (Throwable v2_2) {
                    v0 = v1_1;
                    org.apache.commons.io.IOUtils.closeQuietly(v0);
                    throw v2_2;
                }
            } catch (Throwable v2_2) {
            }
            org.apache.commons.io.IOUtils.copy(v1_1, new org.apache.commons.io.output.NullOutputStream());
            org.apache.commons.io.IOUtils.closeQuietly(v1_1);
            return p5;
        } else {
            throw new IllegalArgumentException("Checksums can\'t be computed on directories");
        }
    }

Method com.zebra.sdk.util.internal.ZipUtil.writeEntries() calling method java.io.FileInputStream.<init>()


    private void writeEntries(java.util.Set p8)
    {
        java.io.FileOutputStream v1_1 = new java.io.FileOutputStream(this.pathToZipFile);
        java.util.zip.ZipOutputStream v2_1 = new java.util.zip.ZipOutputStream(new java.io.BufferedOutputStream(v1_1));
        java.util.Iterator v3 = p8.iterator();
        while (v3.hasNext()) {
            byte[] v0_3 = ((com.zebra.sdk.util.internal.ZipUtil$EntryData) v3.next());
            java.io.FileInputStream v4_1 = new java.util.zip.ZipEntry(v0_3.name);
            if (v0_3.extraData != null) {
                v4_1.setExtra(v0_3.extraData);
            }
            v2_1.putNextEntry(v4_1);
            if (v0_3.srcData == null) {
                if (v0_3.srcFile != null) {
                    java.io.FileInputStream v4_5 = new java.io.FileInputStream(v0_3.srcFile);
                    byte[] v0_6 = new byte[16384];
                    while (v4_5.available() > 0) {
                        v2_1.write(v0_6, 0, v4_5.read(v0_6));
                    }
                    v4_5.close();
                }
            } else {
                v2_1.write(v0_3.srcData);
            }
            v2_1.closeEntry();
        }
        v2_1.close();
        v1_1.close();
        return;
    }

Method com.zebra.sdk.util.internal.ZipUtil.openStreams() calling method java.io.FileInputStream.<init>()


    private void openStreams()
    {
        this.closeStreams();
        this.fis = new java.io.FileInputStream(this.pathToZipFile);
        this.bis = new java.io.BufferedInputStream(this.fis);
        this.zin = new java.util.zip.ZipInputStream(this.bis);
        return;
    }

Method com.zebra.sdk.util.internal.FileReader.toByteArray() calling method java.io.FileInputStream.<init>()


    public static byte[] toByteArray(String p8, int p9)
    {
        java.io.IOException v0_0 = 0;
        if (p8 != null) {
            int v3_2 = new java.io.File(p8);
            int v4_0 = v3_2.length();
            if (v4_0 < ((long) p9)) {
                int v4_1 = ((int) v4_0);
                java.io.IOException v1_0 = new byte[v4_1];
                try {
                    Throwable v2_1 = new java.io.FileInputStream(v3_2);
                    try {
                        if (v4_1 == v2_1.read(v1_0)) {
                            if (v2_1 != null) {
                                try {
                                    v2_1.close();
                                } catch (java.io.IOException v0) {
                                }
                            }
                            v0_0 = v1_0;
                        } else {
                            if (v2_1 != null) {
                                try {
                                    v2_1.close();
                                } catch (java.io.IOException v1) {
                                }
                            }
                        }
                    } catch (java.io.IOException v0_1) {
                        if (v2_1 != null) {
                            try {
                                v2_1.close();
                            } catch (java.io.IOException v1) {
                            }
                        }
                        throw v0_1;
                    } catch (java.io.IOException v1) {
                        java.io.IOException v1_1 = v2_1;
                        if (v1_1 != null) {
                            try {
                                v1_1.close();
                            } catch (java.io.IOException v1) {
                            }
                        }
                    } catch (java.io.IOException v1) {
                        if (v2_1 != null) {
                            try {
                                v2_1.close();
                            } catch (java.io.IOException v1) {
                            }
                        }
                    }
                } catch (java.io.IOException v1_2) {
                    v2_1 = 0;
                    v0_1 = v1_2;
                } catch (java.io.IOException v1) {
                    v1_1 = 0;
                } catch (java.io.IOException v1) {
                    v2_1 = 0;
                }
            }
        }
        return v0_0;
    }

Method com.zebra.sdk.util.internal.Base64.encodeFromFile() calling method java.io.FileInputStream.<init>()


    public static String encodeFromFile(String p8)
    {
        Exception v1 = 0;
        try {
            int v3_3 = new java.io.File(p8);
            byte[] v4_0 = new byte[((int) (((double) v3_3.length()) * 1.4))];
            com.zebra.sdk.util.internal.Base64$InputStream v2_1 = new com.zebra.sdk.util.internal.Base64$InputStream(new java.io.BufferedInputStream(new java.io.FileInputStream(v3_3)), 1);
            int v3_1 = 0;
            try {
                while(true) {
                    String v0_4 = v2_1.read(v4_0, v3_1, 4096);
                    v3_1 = (v0_4 + v3_1);
                }
                String v0_6 = new String(v4_0, 0, v3_1, "UTF-8");
                try {
                    v2_1.close();
                } catch (Exception v1) {
                }
                return v0_6;
            } catch (String v0_2) {
                v1 = v2_1;
                try {
                    v1.close();
                } catch (Exception v1) {
                }
                throw v0_2;
            } catch (String v0) {
                String v0_1 = v2_1;
                try {
                    v0_1.close();
                    v0_6 = 0;
                } catch (String v0) {
                    v0_6 = 0;
                }
                return v0_6;
            }
            if (v0_4 >= null) {
            }
        } catch (String v0_2) {
        } catch (String v0) {
            v0_1 = 0;
        }
    }

Method com.zebra.sdk.util.internal.Base64.decodeFromFile() calling method java.io.FileInputStream.<init>()


    public static byte[] decodeFromFile(String p9)
    {
        byte[] v0_0 = 0;
        int v2 = 0;
        try {
            int v3_5 = new java.io.File(p9);
        } catch (Exception v1_4) {
            Exception v1_3 = 0;
            byte[] v0_1 = v1_4;
            try {
                v1_3.close();
            } catch (Exception v1) {
            }
            throw v0_1;
        } catch (Exception v1) {
            v1_3 = 0;
            try {
                v1_3.close();
            } catch (Exception v1) {
            }
            return v0_0;
        }
        if (v3_5.length() <= 2147483647) {
            byte[] v4_1 = new byte[((int) v3_5.length())];
            v1_3 = new com.zebra.sdk.util.internal.Base64$InputStream(new java.io.BufferedInputStream(new java.io.FileInputStream(v3_5)), 0);
            try {
                while(true) {
                    int v3_2 = v1_3.read(v4_1, v2, 4096);
                    v2 += v3_2;
                }
                v0_0 = new byte[v2];
                System.arraycopy(v4_1, 0, v0_0, 0, v2);
                try {
                    v1_3.close();
                } catch (Exception v1) {
                }
                return v0_0;
            } catch (byte[] v0_1) {
            } catch (int v2) {
            }
            if (v3_2 >= 0) {
            }
        } else {
            try {
                0.close();
            } catch (Exception v1) {
            }
            return v0_0;
        }
    }

Method com.zebra.sdk.printer.internal.ZebraPrinterLinkOsImpl.downloadFont() calling method java.io.FileInputStream.<init>()


    private void downloadFont(String p4, String p5)
    {
        try {
            java.io.IOException v1_1 = new java.io.FileInputStream(p4);
            try {
                this.downloadFont(v1_1, p5);
            } catch (java.io.IOException v0_2) {
                throw new com.zebra.sdk.comm.ConnectionException(v0_2.getLocalizedMessage());
            }
            if (v1_1 != null) {
                try {
                    v1_1.close();
                } catch (java.io.IOException v0) {
                }
            }
            return;
        } catch (java.io.IOException v0_1) {
            v1_1 = 0;
            if (v1_1 != null) {
                try {
                    v1_1.close();
                } catch (java.io.IOException v1) {
                }
            }
            throw v0_1;
        } catch (java.io.IOException v0_2) {
            v1_1 = 0;
        } catch (java.io.IOException v0_1) {
        }
    }

Method com.zebra.sdk.printer.internal.ZebraFileConnectionImpl.openInputStream() calling method java.io.FileInputStream.<init>()


    public java.io.InputStream openInputStream()
    {
        try {
            return new java.io.FileInputStream(this.decoratedFileConnection);
        } catch (String v0_2) {
            throw new java.io.IOException(v0_2.getMessage());
        }
    }

Method com.zebra.sdk.printer.internal.FirmwareUpdaterLinkOsBase.firmwareVersionsDontMatch() calling method java.io.FileInputStream.<init>()


    private boolean firmwareVersionsDontMatch(String p3)
    {
        com.zebra.sdk.comm.ConnectionException v1_1 = new java.io.FileInputStream(p3);
        try {
            String v0_4 = com.zebra.sdk.printer.internal.FirmwareUtil.firmwareVersionsDontMatch(v1_1, this.zebraPrinterConnection);
            try {
                v1_1.close();
                return v0_4;
            } catch (String v0_1) {
                throw new com.zebra.sdk.comm.ConnectionException(v0_1.getLocalizedMessage());
            }
        } catch (String v0_5) {
            try {
                v1_1.close();
                throw v0_5;
            } catch (String v0_6) {
                throw new com.zebra.sdk.comm.ConnectionException(v0_6.getLocalizedMessage());
            }
        }
        v1_1.close();
        return v0_4;
    }

Method com.zebra.sdk.printer.FontConverterZpl.saveAsTtfPrinterFont() calling method java.io.FileInputStream.<init>()


    public static void saveAsTtfPrinterFont(String p3, java.io.OutputStream p4, String p5)
    {
        try {
            RuntimeException v1_2 = new java.io.FileInputStream(p3);
            try {
                com.zebra.sdk.util.internal.FontConverterHelper.saveFontAsPrinterFont(v1_2, p4, p5, ".TTF");
                try {
                    v1_2.close();
                    return;
                } catch (String v0_4) {
                    throw new RuntimeException(v0_4.getMessage());
                }
            } catch (String v0_6) {
                throw new RuntimeException(v0_6.getMessage());
            }
            v1_2.close();
            return;
        } catch (String v0_1) {
            v1_2 = 0;
            try {
                v1_2.close();
                throw v0_1;
            } catch (String v0_2) {
                throw new RuntimeException(v0_2.getMessage());
            }
        } catch (String v0_6) {
            v1_2 = 0;
        } catch (String v0_1) {
        }
    }

Method com.zebra.sdk.printer.FontConverterZpl.saveAsTtePrinterFont() calling method java.io.FileInputStream.<init>()


    public static void saveAsTtePrinterFont(String p2, java.io.OutputStream p3, String p4)
    {
        try {
            com.zebra.sdk.util.internal.FontConverterHelper.saveFontAsPrinterFont(new java.io.FileInputStream(p2), p3, p4, ".TTE");
            return;
        } catch (String v0_2) {
            throw new RuntimeException(v0_2.getMessage());
        }
    }

Method com.fasterxml.jackson.databind.ObjectReader._inputStream() calling method java.io.FileInputStream.<init>()


    protected java.io.InputStream _inputStream(java.io.File p2)
    {
        return new java.io.FileInputStream(p2);
    }

Method com.fasterxml.jackson.core.JsonFactory.createParser() calling method java.io.FileInputStream.<init>()


    public com.fasterxml.jackson.core.JsonParser createParser(java.io.File p4)
    {
        com.fasterxml.jackson.core.io.IOContext v1 = this._createContext(p4, 1);
        com.fasterxml.jackson.core.JsonParser v0_3 = new java.io.FileInputStream(p4);
        if (this._inputDecorator != null) {
            v0_3 = this._inputDecorator.decorate(v1, v0_3);
        }
        return this._createParser(v0_3, v1);
    }

Method com.fasterxml.jackson.core.JsonFactory._optimizedStreamFromURL() calling method java.io.FileInputStream.<init>()


    protected java.io.InputStream _optimizedStreamFromURL(java.net.URL p3)
    {
        java.io.FileInputStream v0_4;
        if (!"file".equals(p3.getProtocol())) {
            v0_4 = p3.openStream();
        } else {
            java.io.FileInputStream v0_7 = p3.getHost();
            if (((v0_7 != null) && (v0_7.length() != 0)) || (p3.getPath().indexOf(37) >= 0)) {
            } else {
                v0_4 = new java.io.FileInputStream(p3.getPath());
            }
        }
        return v0_4;
    }

Method android.support.v4.util.AtomicFile.openRead() calling method java.io.FileInputStream.<init>()


    public java.io.FileInputStream openRead()
    {
        if (this.mBackupName.exists()) {
            this.mBaseName.delete();
            this.mBackupName.renameTo(this.mBaseName);
        }
        return new java.io.FileInputStream(this.mBaseName);
    }

Method org.apache.commons.lang3.SystemUtils.getUserHome() calling method java.io.File.<init>()


    public static java.io.File getUserHome()
    {
        return new java.io.File(System.getProperty("user.home"));
    }

Method org.apache.commons.lang3.SystemUtils.getUserDir() calling method java.io.File.<init>()


    public static java.io.File getUserDir()
    {
        return new java.io.File(System.getProperty("user.dir"));
    }

Method org.apache.commons.lang3.SystemUtils.getJavaIoTmpDir() calling method java.io.File.<init>()


    public static java.io.File getJavaIoTmpDir()
    {
        return new java.io.File(System.getProperty("java.io.tmpdir"));
    }

Method org.apache.commons.lang3.SystemUtils.getJavaHome() calling method java.io.File.<init>()


    public static java.io.File getJavaHome()
    {
        return new java.io.File(System.getProperty("java.home"));
    }

Method org.apache.commons.io.output.LockableFileWriter.<init>() calling method java.io.File.<init>()


    public LockableFileWriter(String p2, boolean p3, String p4)
    {
        this(new java.io.File(p2), p3, p4);
        return;
    }

Method org.apache.commons.io.output.LockableFileWriter.<init>() calling method java.io.File.<init>()


    public LockableFileWriter(java.io.File p5, String p6, boolean p7, String p8)
    {
        java.io.File v5_1 = p5.getAbsoluteFile();
        if (v5_1.getParentFile() != null) {
            org.apache.commons.io.FileUtils.forceMkdir(v5_1.getParentFile());
        }
        if (!v5_1.isDirectory()) {
            if (p8 == null) {
                p8 = System.getProperty("java.io.tmpdir");
            }
            java.io.File v0_1 = new java.io.File(p8);
            org.apache.commons.io.FileUtils.forceMkdir(v0_1);
            this.testLockDir(v0_1);
            this.lockFile = new java.io.File(v0_1, new StringBuilder().append(v5_1.getName()).append(".lck").toString());
            this.createLock();
            this.out = this.initWriter(v5_1, p6, p7);
            return;
        } else {
            throw new java.io.IOException("File specified is a directory");
        }
    }

Method org.apache.commons.io.output.FileWriterWithEncoding.<init>() calling method java.io.File.<init>()


    public FileWriterWithEncoding(String p2, java.nio.charset.CharsetEncoder p3, boolean p4)
    {
        this(new java.io.File(p2), p3, p4);
        return;
    }

Method org.apache.commons.io.output.FileWriterWithEncoding.<init>() calling method java.io.File.<init>()


    public FileWriterWithEncoding(String p3, java.nio.charset.CharsetEncoder p4)
    {
        this(new java.io.File(p3), p4, 0);
        return;
    }

Method org.apache.commons.io.output.FileWriterWithEncoding.<init>() calling method java.io.File.<init>()


    public FileWriterWithEncoding(String p2, java.nio.charset.Charset p3, boolean p4)
    {
        this(new java.io.File(p2), p3, p4);
        return;
    }

Method org.apache.commons.io.output.FileWriterWithEncoding.<init>() calling method java.io.File.<init>()


    public FileWriterWithEncoding(String p3, java.nio.charset.Charset p4)
    {
        this(new java.io.File(p3), p4, 0);
        return;
    }

Method org.apache.commons.io.output.FileWriterWithEncoding.<init>() calling method java.io.File.<init>()


    public FileWriterWithEncoding(String p2, String p3, boolean p4)
    {
        this(new java.io.File(p2), p3, p4);
        return;
    }

Method org.apache.commons.io.output.FileWriterWithEncoding.<init>() calling method java.io.File.<init>()


    public FileWriterWithEncoding(String p3, String p4)
    {
        this(new java.io.File(p3), p4, 0);
        return;
    }

Method org.apache.commons.io.monitor.FileAlterationObserver.<init>() calling method java.io.File.<init>()


    public FileAlterationObserver(String p2, java.io.FileFilter p3, org.apache.commons.io.IOCase p4)
    {
        this(new java.io.File(p2), p3, p4);
        return;
    }

Method org.apache.commons.io.monitor.FileAlterationObserver.<init>() calling method java.io.File.<init>()


    public FileAlterationObserver(String p2, java.io.FileFilter p3)
    {
        this(new java.io.File(p2), p3);
        return;
    }

Method org.apache.commons.io.monitor.FileAlterationObserver.<init>() calling method java.io.File.<init>()


    public FileAlterationObserver(String p2)
    {
        this(new java.io.File(p2));
        return;
    }

Method org.apache.commons.io.filefilter.WildcardFilter.accept() calling method java.io.File.<init>()


    public boolean accept(java.io.File p7, String p8)
    {
        int v4 = 0;
        if ((p7 == null) || (!new java.io.File(p7, p8).isDirectory())) {
            String[] v0 = this.wildcards;
            int v1 = 0;
            while (v1 < v0.length) {
                if (!org.apache.commons.io.FilenameUtils.wildcardMatch(p8, v0[v1])) {
                    v1++;
                } else {
                    v4 = 1;
                    break;
                }
            }
        }
        return v4;
    }

Method org.apache.commons.io.filefilter.AbstractFileFilter.accept() calling method java.io.File.<init>()


    public boolean accept(java.io.File p2, String p3)
    {
        return this.accept(new java.io.File(p2, p3));
    }

Method org.apache.commons.io.FileUtils.toFile() calling method java.io.File.<init>()


    public static java.io.File toFile(java.net.URL p4)
    {
        if ((p4 != null) && ("file".equalsIgnoreCase(p4.getProtocol()))) {
            java.io.File v1_2 = new java.io.File(org.apache.commons.io.FileUtils.decodeUrl(p4.getFile().replace(47, java.io.File.separatorChar)));
        } else {
            v1_2 = 0;
        }
        return v1_2;
    }

Method org.apache.commons.io.FileUtils.moveFileToDirectory() calling method java.io.File.<init>()


    public static void moveFileToDirectory(java.io.File p3, java.io.File p4, boolean p5)
    {
        if (p3 != null) {
            if (p4 != null) {
                if ((!p4.exists()) && (p5)) {
                    p4.mkdirs();
                }
                if (p4.exists()) {
                    if (p4.isDirectory()) {
                        org.apache.commons.io.FileUtils.moveFile(p3, new java.io.File(p4, p3.getName()));
                        return;
                    } else {
                        throw new java.io.IOException(new StringBuilder().append("Destination \'").append(p4).append("\' is not a directory").toString());
                    }
                } else {
                    throw new java.io.FileNotFoundException(new StringBuilder().append("Destination directory \'").append(p4).append("\' does not exist [createDestDir=").append(p5).append("]").toString());
                }
            } else {
                throw new NullPointerException("Destination directory must not be null");
            }
        } else {
            throw new NullPointerException("Source must not be null");
        }
    }

Method org.apache.commons.io.FileUtils.moveDirectoryToDirectory() calling method java.io.File.<init>()


    public static void moveDirectoryToDirectory(java.io.File p3, java.io.File p4, boolean p5)
    {
        if (p3 != null) {
            if (p4 != null) {
                if ((!p4.exists()) && (p5)) {
                    p4.mkdirs();
                }
                if (p4.exists()) {
                    if (p4.isDirectory()) {
                        org.apache.commons.io.FileUtils.moveDirectory(p3, new java.io.File(p4, p3.getName()));
                        return;
                    } else {
                        throw new java.io.IOException(new StringBuilder().append("Destination \'").append(p4).append("\' is not a directory").toString());
                    }
                } else {
                    throw new java.io.FileNotFoundException(new StringBuilder().append("Destination directory \'").append(p4).append("\' does not exist [createDestDir=").append(p5).append("]").toString());
                }
            } else {
                throw new NullPointerException("Destination directory must not be null");
            }
        } else {
            throw new NullPointerException("Source must not be null");
        }
    }

Method org.apache.commons.io.FileUtils.isSymlink() calling method java.io.File.<init>()


    public static boolean isSymlink(java.io.File p5)
    {
        int v2_0 = 0;
        if (p5 != null) {
            if (!org.apache.commons.io.FilenameUtils.isSystemWindows()) {
                java.io.File v1_1;
                if (p5.getParent() != null) {
                    v1_1 = new java.io.File(p5.getParentFile().getCanonicalFile(), p5.getName());
                } else {
                    v1_1 = p5;
                }
                if (!v1_1.getCanonicalFile().equals(v1_1.getAbsoluteFile())) {
                    v2_0 = 1;
                }
            }
            return v2_0;
        } else {
            throw new NullPointerException("File must not be null");
        }
    }

Method org.apache.commons.io.FileUtils.getUserDirectory() calling method java.io.File.<init>()


    public static java.io.File getUserDirectory()
    {
        return new java.io.File(org.apache.commons.io.FileUtils.getUserDirectoryPath());
    }

Method org.apache.commons.io.FileUtils.getTempDirectory() calling method java.io.File.<init>()


    public static java.io.File getTempDirectory()
    {
        return new java.io.File(org.apache.commons.io.FileUtils.getTempDirectoryPath());
    }

Method org.apache.commons.io.FileUtils.getFile() calling method java.io.File.<init>()


    public static varargs java.io.File getFile(String[] p8)
    {
        if (p8 != null) {
            int v4 = p8.length;
            int v3 = 0;
            java.io.File v2 = 0;
            while (v3 < v4) {
                java.io.File v1_2;
                String v5 = p8[v3];
                if (v2 != null) {
                    v1_2 = new java.io.File(v2, v5);
                } else {
                    v1_2 = new java.io.File(v5);
                }
                v3++;
                v2 = v1_2;
            }
            return v2;
        } else {
            throw new NullPointerException("names must not be null");
        }
    }

Method org.apache.commons.io.FileUtils.getFile() calling method java.io.File.<init>()


    public static varargs java.io.File getFile(java.io.File p8, String[] p9)
    {
        if (p8 != null) {
            if (p9 != null) {
                int v4 = p9.length;
                int v3 = 0;
                java.io.File v2 = p8;
                while (v3 < v4) {
                    java.io.File v1_1 = new java.io.File(v2, p9[v3]);
                    v3++;
                    v2 = v1_1;
                }
                return v2;
            } else {
                throw new NullPointerException("names must not be null");
            }
        } else {
            throw new NullPointerException("directorydirectory must not be null");
        }
    }

Method org.apache.commons.io.FileUtils.doCopyDirectory() calling method java.io.File.<init>()


    private static void doCopyDirectory(java.io.File p9, java.io.File p10, java.io.FileFilter p11, boolean p12, java.util.List p13)
    {
        java.io.File[] v5;
        if (p11 != null) {
            v5 = p9.listFiles(p11);
        } else {
            v5 = p9.listFiles();
        }
        if (v5 != null) {
            if (!p10.exists()) {
                if ((!p10.mkdirs()) && (!p10.isDirectory())) {
                    throw new java.io.IOException(new StringBuilder().append("Destination \'").append(p10).append("\' directory cannot be created").toString());
                }
            } else {
                if (!p10.isDirectory()) {
                    throw new java.io.IOException(new StringBuilder().append("Destination \'").append(p10).append("\' exists but is not a directory").toString());
                }
            }
            if (p10.canWrite()) {
                java.io.File[] v0 = v5;
                int v3 = v0.length;
                int v2 = 0;
                while (v2 < v3) {
                    java.io.File v4 = v0[v2];
                    java.io.File v1_1 = new java.io.File(p10, v4.getName());
                    if ((p13 == null) || (!p13.contains(v4.getCanonicalPath()))) {
                        if (!v4.isDirectory()) {
                            org.apache.commons.io.FileUtils.doCopyFile(v4, v1_1, p12);
                        } else {
                            org.apache.commons.io.FileUtils.doCopyDirectory(v4, v1_1, p11, p12, p13);
                        }
                    }
                    v2++;
                }
                if (p12) {
                    p10.setLastModified(p9.lastModified());
                }
                return;
            } else {
                throw new java.io.IOException(new StringBuilder().append("Destination \'").append(p10).append("\' cannot be written to").toString());
            }
        } else {
            throw new java.io.IOException(new StringBuilder().append("Failed to list contents of ").append(p9).toString());
        }
    }

Method org.apache.commons.io.FileUtils.copyFileToDirectory() calling method java.io.File.<init>()


    public static void copyFileToDirectory(java.io.File p4, java.io.File p5, boolean p6)
    {
        if (p5 != null) {
            if ((!p5.exists()) || (p5.isDirectory())) {
                org.apache.commons.io.FileUtils.copyFile(p4, new java.io.File(p5, p4.getName()), p6);
                return;
            } else {
                throw new IllegalArgumentException(new StringBuilder().append("Destination \'").append(p5).append("\' is not a directory").toString());
            }
        } else {
            throw new NullPointerException("Destination must not be null");
        }
    }

Method org.apache.commons.io.FileUtils.copyDirectoryToDirectory() calling method java.io.File.<init>()


    public static void copyDirectoryToDirectory(java.io.File p3, java.io.File p4)
    {
        if (p3 != null) {
            if ((!p3.exists()) || (p3.isDirectory())) {
                if (p4 != null) {
                    if ((!p4.exists()) || (p4.isDirectory())) {
                        org.apache.commons.io.FileUtils.copyDirectory(p3, new java.io.File(p4, p3.getName()), 1);
                        return;
                    } else {
                        throw new IllegalArgumentException(new StringBuilder().append("Destination \'").append(p4).append("\' is not a directory").toString());
                    }
                } else {
                    throw new NullPointerException("Destination must not be null");
                }
            } else {
                throw new IllegalArgumentException(new StringBuilder().append("Source \'").append(p4).append("\' is not a directory").toString());
            }
        } else {
            throw new NullPointerException("Source must not be null");
        }
    }

Method org.apache.commons.io.FileUtils.copyDirectory() calling method java.io.File.<init>()


    public static void copyDirectory(java.io.File p10, java.io.File p11, java.io.FileFilter p12, boolean p13)
    {
        if (p10 != null) {
            if (p11 != null) {
                if (p10.exists()) {
                    if (p10.isDirectory()) {
                        if (!p10.getCanonicalPath().equals(p11.getCanonicalPath())) {
                            java.util.ArrayList v2_0 = 0;
                            if (p11.getCanonicalPath().startsWith(p10.getCanonicalPath())) {
                                java.io.File[] v6;
                                if (p12 != null) {
                                    v6 = p10.listFiles(p12);
                                } else {
                                    v6 = p10.listFiles();
                                }
                                if ((v6 != null) && (v6.length > 0)) {
                                    v2_0 = new java.util.ArrayList(v6.length);
                                    java.io.File[] v0 = v6;
                                    int v4 = v0.length;
                                    int v3 = 0;
                                    while (v3 < v4) {
                                        v2_0.add(new java.io.File(p11, v0[v3].getName()).getCanonicalPath());
                                        v3++;
                                    }
                                }
                            }
                            org.apache.commons.io.FileUtils.doCopyDirectory(p10, p11, p12, p13, v2_0);
                            return;
                        } else {
                            throw new java.io.IOException(new StringBuilder().append("Source \'").append(p10).append("\' and destination \'").append(p11).append("\' are the same").toString());
                        }
                    } else {
                        throw new java.io.IOException(new StringBuilder().append("Source \'").append(p10).append("\' exists but is not a directory").toString());
                    }
                } else {
                    throw new java.io.FileNotFoundException(new StringBuilder().append("Source \'").append(p10).append("\' does not exist").toString());
                }
            } else {
                throw new NullPointerException("Destination must not be null");
            }
        } else {
            throw new NullPointerException("Source must not be null");
        }
    }

Method org.apache.commons.io.FileSystemUtils.freeSpaceKb() calling method java.io.File.<init>()


    public static long freeSpaceKb(long p2)
    {
        return org.apache.commons.io.FileSystemUtils.freeSpaceKb(new java.io.File(".").getAbsolutePath(), p2);
    }

Method org.apache.commons.io.FileCleaningTracker$Tracker.delete() calling method java.io.File.<init>()


    public boolean delete()
    {
        return this.deleteStrategy.deleteQuietly(new java.io.File(this.path));
    }

Method mono.MonoPackageManager.LoadApplication() calling method java.io.File.<init>()


    public static void LoadApplication(android.content.Context p11, android.content.pm.ApplicationInfo p12, String[] p13)
    {
        try {
            if ((p11 instanceof android.app.Application)) {
                mono.MonoPackageManager.Context = p11;
            }
        } catch (int v0_2) {
            throw v0_2;
        }
        if (!mono.MonoPackageManager.initialized) {
            p11.registerReceiver(new mono.android.app.NotifyTimeZoneChanges(), new android.content.IntentFilter("android.intent.action.TIMEZONE_CHANGED"));
            System.loadLibrary("monodroid");
            int v0_4 = java.util.Locale.getDefault();
            int v0_7 = new StringBuilder().append(v0_4.getLanguage()).append("-").append(v0_4.getCountry()).toString();
            String[] v1_7 = p11.getFilesDir().getAbsolutePath();
            String[] v5_0 = p11.getCacheDir().getAbsolutePath();
            String[] v6_0 = mono.MonoPackageManager.getNativeLibraryPath(p11);
            ClassLoader v4 = p11.getClassLoader();
            String v2_3 = android.os.Environment.getExternalStorageDirectory();
            String v7_6 = new java.io.File(v2_3, new StringBuilder().append("Android/data/").append(p11.getPackageName()).append("/files/.__override__").toString()).getAbsolutePath();
            String v9_9 = new java.io.File(v2_3, new StringBuilder().append("../legacy/Android/data/").append(p11.getPackageName()).append("/files/.__override__").toString()).getAbsolutePath();
            String v2_4 = mono.MonoPackageManager.getNativeLibraryPath(p12);
            String[] v3_5 = new String[3];
            v3_5[0] = v1_7;
            v3_5[1] = v5_0;
            v3_5[2] = v6_0;
            String[] v5_1 = new String[2];
            v5_1[0] = v7_6;
            v5_1[1] = v9_9;
            mono.android.Runtime.init(v0_7, p13, v2_4, v3_5, v4, v5_1, mono.MonoPackageManager_Resources.Assemblies, p11.getPackageName());
            mono.android.app.ApplicationRegistration.registerApplications();
            mono.MonoPackageManager.initialized = 1;
        }
        return;
    }

Method com.zebra.sdk.util.internal.ReflectionUtil.getClasses() calling method java.io.File.<init>()


    private static Class[] getClasses(String p9)
    {
        Class v0_13 = Thread.currentThread().getContextClassLoader();
        if ((com.zebra.sdk.util.internal.ReflectionUtil.$assertionsDisabled) || (v0_13 != null)) {
            java.util.Iterator v1_0 = p9.replace(46, 47);
            java.util.ArrayList v2_0 = v0_13.getResource(v1_0);
            java.util.ArrayList v3_1 = new java.util.ArrayList();
            if (!v2_0.getProtocol().equals("jar")) {
                java.util.Iterator v1_1 = v0_13.getResources(v1_0);
                java.util.ArrayList v2_2 = new java.util.ArrayList();
                while (v1_1.hasMoreElements()) {
                    v2_2.add(new java.io.File(((java.net.URL) v1_1.nextElement()).getFile()));
                }
                java.util.Iterator v1_2 = v2_2.iterator();
                while (v1_2.hasNext()) {
                    v3_1.addAll(com.zebra.sdk.util.internal.ReflectionUtil.findClasses(((java.io.File) v1_2.next()), p9));
                }
            } else {
                Class v0_14 = java.net.URLDecoder.decode(v2_0.getFile(), "UTF-8");
                java.util.ArrayList v2_6 = new java.util.jar.JarFile(v0_14.substring(5, v0_14.indexOf("!")));
                java.io.File v4_6 = v2_6.entries();
                while (v4_6.hasMoreElements()) {
                    Class v0_23 = ((java.util.jar.JarEntry) v4_6.nextElement()).getName();
                    if ((v0_23.startsWith(v1_0)) && ((v0_23.length() > (v1_0.length() + 5)) && (v0_23.endsWith(".class")))) {
                        Class v0_24 = v0_23.replace(47, 46);
                        v3_1.add(Class.forName(v0_24.substring(0, (v0_24.length() - 6))));
                    }
                }
                v2_6.close();
            }
            Class v0_18 = new Class[v3_1.size()];
            return ((Class[]) v3_1.toArray(v0_18));
        } else {
            throw new AssertionError();
        }
    }

Method com.zebra.sdk.util.internal.FileUtilities.GetFileNameOnPrinter() calling method java.io.File.<init>()


    public static String GetFileNameOnPrinter(String p3)
    {
        if (p3 != null) {
            String v0_10 = new java.io.File(p3).getName();
            if (!v0_10.equals("")) {
                return new StringBuilder().append("E:").append(com.zebra.sdk.util.internal.StringUtilities.convertTo8dot3(v0_10).toUpperCase()).toString();
            } else {
                throw new com.zebra.sdk.device.ZebraIllegalArgumentException("Invalid file path");
            }
        } else {
            throw new com.zebra.sdk.device.ZebraIllegalArgumentException("Invalid file path");
        }
    }

Method com.zebra.sdk.util.internal.FileReader.toByteArray() calling method java.io.File.<init>()


    public static byte[] toByteArray(String p8, int p9)
    {
        java.io.IOException v0_0 = 0;
        if (p8 != null) {
            int v3_2 = new java.io.File(p8);
            int v4_0 = v3_2.length();
            if (v4_0 < ((long) p9)) {
                int v4_1 = ((int) v4_0);
                java.io.IOException v1_0 = new byte[v4_1];
                try {
                    Throwable v2_1 = new java.io.FileInputStream(v3_2);
                    try {
                        if (v4_1 == v2_1.read(v1_0)) {
                            if (v2_1 != null) {
                                try {
                                    v2_1.close();
                                } catch (java.io.IOException v0) {
                                }
                            }
                            v0_0 = v1_0;
                        } else {
                            if (v2_1 != null) {
                                try {
                                    v2_1.close();
                                } catch (java.io.IOException v1) {
                                }
                            }
                        }
                    } catch (java.io.IOException v0_1) {
                        if (v2_1 != null) {
                            try {
                                v2_1.close();
                            } catch (java.io.IOException v1) {
                            }
                        }
                        throw v0_1;
                    } catch (java.io.IOException v1) {
                        java.io.IOException v1_1 = v2_1;
                        if (v1_1 != null) {
                            try {
                                v1_1.close();
                            } catch (java.io.IOException v1) {
                            }
                        }
                    } catch (java.io.IOException v1) {
                        if (v2_1 != null) {
                            try {
                                v2_1.close();
                            } catch (java.io.IOException v1) {
                            }
                        }
                    }
                } catch (java.io.IOException v1_2) {
                    v2_1 = 0;
                    v0_1 = v1_2;
                } catch (java.io.IOException v1) {
                    v1_1 = 0;
                } catch (java.io.IOException v1) {
                    v2_1 = 0;
                }
            }
        }
        return v0_0;
    }

Method com.zebra.sdk.util.internal.Base64.encodeFromFile() calling method java.io.File.<init>()


    public static String encodeFromFile(String p8)
    {
        Exception v1 = 0;
        try {
            int v3_3 = new java.io.File(p8);
            byte[] v4_0 = new byte[((int) (((double) v3_3.length()) * 1.4))];
            com.zebra.sdk.util.internal.Base64$InputStream v2_1 = new com.zebra.sdk.util.internal.Base64$InputStream(new java.io.BufferedInputStream(new java.io.FileInputStream(v3_3)), 1);
            int v3_1 = 0;
            try {
                while(true) {
                    String v0_4 = v2_1.read(v4_0, v3_1, 4096);
                    v3_1 = (v0_4 + v3_1);
                }
                String v0_6 = new String(v4_0, 0, v3_1, "UTF-8");
                try {
                    v2_1.close();
                } catch (Exception v1) {
                }
                return v0_6;
            } catch (String v0_2) {
                v1 = v2_1;
                try {
                    v1.close();
                } catch (Exception v1) {
                }
                throw v0_2;
            } catch (String v0) {
                String v0_1 = v2_1;
                try {
                    v0_1.close();
                    v0_6 = 0;
                } catch (String v0) {
                    v0_6 = 0;
                }
                return v0_6;
            }
            if (v0_4 >= null) {
            }
        } catch (String v0_2) {
        } catch (String v0) {
            v0_1 = 0;
        }
    }

Method com.zebra.sdk.util.internal.Base64.decodeFromFile() calling method java.io.File.<init>()


    public static byte[] decodeFromFile(String p9)
    {
        byte[] v0_0 = 0;
        int v2 = 0;
        try {
            int v3_5 = new java.io.File(p9);
        } catch (Exception v1_4) {
            Exception v1_3 = 0;
            byte[] v0_1 = v1_4;
            try {
                v1_3.close();
            } catch (Exception v1) {
            }
            throw v0_1;
        } catch (Exception v1) {
            v1_3 = 0;
            try {
                v1_3.close();
            } catch (Exception v1) {
            }
            return v0_0;
        }
        if (v3_5.length() <= 2147483647) {
            byte[] v4_1 = new byte[((int) v3_5.length())];
            v1_3 = new com.zebra.sdk.util.internal.Base64$InputStream(new java.io.BufferedInputStream(new java.io.FileInputStream(v3_5)), 0);
            try {
                while(true) {
                    int v3_2 = v1_3.read(v4_1, v2, 4096);
                    v2 += v3_2;
                }
                v0_0 = new byte[v2];
                System.arraycopy(v4_1, 0, v0_0, 0, v2);
                try {
                    v1_3.close();
                } catch (Exception v1) {
                }
                return v0_0;
            } catch (byte[] v0_1) {
            } catch (int v2) {
            }
            if (v3_2 >= 0) {
            }
        } else {
            try {
                0.close();
            } catch (Exception v1) {
            }
            return v0_0;
        }
    }

Method com.zebra.sdk.printer.internal.ZebraFileConnectionImpl.<init>() calling method java.io.File.<init>()


    public ZebraFileConnectionImpl(String p2)
    {
        this.decoratedFileConnection = 0;
        this.decoratedFileConnection = new java.io.File(p2);
        return;
    }

Method com.zebra.sdk.printer.internal.ProfileHelper.modifyProfile() calling method java.io.File.<init>()


    public static void modifyProfile(String p7, com.zebra.sdk.printer.internal.ProfileHelper$ProfileComponentTransformer p8)
    {
        String v0_0 = com.zebra.sdk.util.internal.FileReader.toByteArray(p7);
        java.io.File v2_1 = java.io.File.createTempFile("proftmp", 0);
        byte[] v1_6 = new java.io.FileOutputStream(v2_1.getAbsolutePath());
        v1_6.write(v0_0);
        v1_6.close();
        new java.io.File(p7).delete();
        String v0_3 = v2_1.getAbsolutePath();
        try {
            java.util.zip.ZipOutputStream v3_1 = new java.util.zip.ZipOutputStream(new java.io.BufferedOutputStream(new java.io.FileOutputStream(p7)));
            com.zebra.sdk.util.internal.ZipUtil v4_3 = new com.zebra.sdk.util.internal.ZipUtil(v0_3);
            java.util.Iterator v5 = v4_3.getEntryNames().iterator();
        } catch (String v0_8) {
            v0_8.printStackTrace();
            return;
        }
        while (v5.hasNext()) {
            byte[] v1_4;
            String v0_7 = ((String) v5.next());
            if (!p8.shouldTransformComponent(v0_7)) {
                v1_4 = v4_3.extractEntry(v0_7);
            } else {
                v1_4 = p8.transformComponent();
            }
            if ((v1_4 != null) && (v1_4.length > 0)) {
                v3_1.putNextEntry(new java.util.zip.ZipEntry(v0_7));
                v3_1.write(v1_4);
                v3_1.closeEntry();
            }
        }
        v3_1.close();
        v2_1.delete();
        return;
    }

Method com.zebra.sdk.printer.internal.FirmwareUpdaterLinkOsBase.updateFirmware() calling method java.io.File.<init>()


    private void updateFirmware(String p5, long p6, com.zebra.sdk.printer.FirmwareUpdateHandler p8, boolean p9)
    {
        if (new java.io.File(p5).exists()) {
            this.throwExceptionStatusOnly();
            if ((p9 != 1) && (!this.firmwareVersionsDontMatch(p5))) {
                p8.firmwareDownloadComplete();
                p8.printerOnline(com.zebra.sdk.printer.ZebraPrinterFactory.getLinkOsPrinter(this.zebraPrinterConnection), com.zebra.sdk.printer.internal.FirmwareUtil.getFWVersionFromPrinterConnection(this.zebraPrinterConnection).trim());
            } else {
                this.doFwDownload(p5, p6, p8);
            }
            return;
        } else {
            throw new java.io.FileNotFoundException(new StringBuilder().append(p5).append(" does not exist.").toString());
        }
    }

Method com.zebra.sdk.device.Profile.addFirmware() calling method java.io.File.<init>()


    public void addFirmware(String p5)
    {
        new com.zebra.sdk.util.internal.ZipUtil(this.pathToProfile).addEntry("firmwareFile.txt", new java.io.File(p5), new java.io.File(p5).getName().getBytes());
        return;
    }

Method com.fasterxml.jackson.databind.deser.std.JdkDeserializers$FileDeserializer._deserialize() calling method java.io.File.<init>()


    protected java.io.File _deserialize(String p2, com.fasterxml.jackson.databind.DeserializationContext p3)
    {
        return new java.io.File(p2);
    }

Method android.support.v4.util.AtomicFile.<init>() calling method java.io.File.<init>()


    public AtomicFile(java.io.File p4)
    {
        this.mBaseName = p4;
        this.mBackupName = new java.io.File(new StringBuilder().append(p4.getPath()).append(".bak").toString());
        return;
    }

Method android.support.v4.provider.RawDocumentFile.renameTo() calling method java.io.File.<init>()


    public boolean renameTo(String p3)
    {
        int v1_1;
        java.io.File v0_1 = new java.io.File(this.mFile.getParentFile(), p3);
        if (!this.mFile.renameTo(v0_1)) {
            v1_1 = 0;
        } else {
            this.mFile = v0_1;
            v1_1 = 1;
        }
        return v1_1;
    }

Method android.support.v4.provider.RawDocumentFile.createFile() calling method java.io.File.<init>()


    public android.support.v4.provider.DocumentFile createFile(String p7, String p8)
    {
        String v1 = android.webkit.MimeTypeMap.getSingleton().getExtensionFromMimeType(p7);
        if (v1 != null) {
            p8 = new StringBuilder().append(p8).append(".").append(v1).toString();
        }
        java.io.File v2_1 = new java.io.File(this.mFile, p8);
        try {
            v2_1.createNewFile();
            int v3_5 = new android.support.v4.provider.RawDocumentFile(this, v2_1);
        } catch (java.io.IOException v0) {
            android.util.Log.w("DocumentFile", new StringBuilder().append("Failed to createFile: ").append(v0).toString());
            v3_5 = 0;
        }
        return v3_5;
    }

Method android.support.v4.provider.RawDocumentFile.createDirectory() calling method java.io.File.<init>()


    public android.support.v4.provider.DocumentFile createDirectory(String p3)
    {
        int v1_2;
        java.io.File v0_1 = new java.io.File(this.mFile, p3);
        if ((!v0_1.isDirectory()) && (!v0_1.mkdir())) {
            v1_2 = 0;
        } else {
            v1_2 = new android.support.v4.provider.RawDocumentFile(this, v0_1);
        }
        return v1_2;
    }

Method android.support.v4.content.FileProvider.buildPath() calling method java.io.File.<init>()


    private static varargs java.io.File buildPath(java.io.File p5, String[] p6)
    {
        int v4 = p6.length;
        int v3 = 0;
        java.io.File v1 = p5;
        while (v3 < v4) {
            java.io.File v0_1;
            String v2 = p6[v3];
            if (v2 == null) {
                v0_1 = v1;
            } else {
                v0_1 = new java.io.File(v1, v2);
            }
            v3++;
            v1 = v0_1;
        }
        return v1;
    }

Method android.support.v4.content.FileProvider.<clinit>() calling method java.io.File.<init>()


    static FileProvider()
    {
        java.util.HashMap v0_1 = new String[2];
        v0_1[0] = "_display_name";
        v0_1[1] = "_size";
        android.support.v4.content.FileProvider.COLUMNS = v0_1;
        android.support.v4.content.FileProvider.DEVICE_ROOT = new java.io.File("/");
        android.support.v4.content.FileProvider.sCache = new java.util.HashMap();
        return;
    }

Method android.support.v4.content.FileProvider$SimplePathStrategy.getFileForUri() calling method java.io.File.<init>()


    public java.io.File getFileForUri(android.net.Uri p10)
    {
        String v2_1 = p10.getEncodedPath();
        int v4 = v2_1.indexOf(47, 1);
        String v5 = android.net.Uri.decode(v2_1.substring(1, v4));
        String vtmp6 = android.net.Uri.decode(v2_1.substring((v4 + 1)));
        java.io.File v3_1 = ((java.io.File) this.mRoots.get(v5));
        if (v3_1 != null) {
            try {
                java.io.File v1_2 = new java.io.File(v3_1, vtmp6).getCanonicalFile();
            } catch (java.io.IOException v0) {
                throw new IllegalArgumentException(new StringBuilder().append("Failed to resolve canonical path for ").append(v1_2).toString());
            }
            if (v1_2.getPath().startsWith(v3_1.getPath())) {
                return v1_2;
            } else {
                throw new SecurityException("Resolved path jumped beyond configured root");
            }
        } else {
            throw new IllegalArgumentException(new StringBuilder().append("Unable to find configured root for ").append(p10).toString());
        }
    }

Method android.support.v4.content.ContextCompat.getNoBackupFilesDir() calling method java.io.File.<init>()


    public static final java.io.File getNoBackupFilesDir(android.content.Context p5)
    {
        java.io.File v2_1;
        if (android.os.Build$VERSION.SDK_INT < 21) {
            v2_1 = android.support.v4.content.ContextCompat.createFilesDir(new java.io.File(p5.getApplicationInfo().dataDir, "no_backup"));
        } else {
            v2_1 = android.support.v4.content.ContextCompatApi21.getNoBackupFilesDir(p5);
        }
        return v2_1;
    }

Method android.support.v4.content.ContextCompat.getDataDir() calling method java.io.File.<init>()


    public static java.io.File getDataDir(android.content.Context p2)
    {
        int v1_1;
        if (!android.support.v4.os.BuildCompat.isAtLeastN()) {
            String v0 = p2.getApplicationInfo().dataDir;
            if (v0 == null) {
                v1_1 = 0;
            } else {
                v1_1 = new java.io.File(v0);
            }
        } else {
            v1_1 = android.support.v4.content.ContextCompatApi24.getDataDir(p2);
        }
        return v1_1;
    }

Method android.support.v4.content.ContextCompat.getCodeCacheDir() calling method java.io.File.<init>()


    public static java.io.File getCodeCacheDir(android.content.Context p5)
    {
        java.io.File v2_1;
        if (android.os.Build$VERSION.SDK_INT < 21) {
            v2_1 = android.support.v4.content.ContextCompat.createFilesDir(new java.io.File(p5.getApplicationInfo().dataDir, "code_cache"));
        } else {
            v2_1 = android.support.v4.content.ContextCompatApi21.getCodeCacheDir(p5);
        }
        return v2_1;
    }

Method android.support.v4.content.ContextCompat.buildPath() calling method java.io.File.<init>()


    private static varargs java.io.File buildPath(java.io.File p5, String[] p6)
    {
        int v4 = p6.length;
        int v3 = 0;
        java.io.File v1 = p5;
        while (v3 < v4) {
            java.io.File v0_2;
            String v2 = p6[v3];
            if (v1 != null) {
                if (v2 == null) {
                    v0_2 = v1;
                } else {
                    v0_2 = new java.io.File(v1, v2);
                }
            } else {
                v0_2 = new java.io.File(v2);
            }
            v3++;
            v1 = v0_2;
        }
        return v1;
    }

Method android.support.multidex.MultiDexExtractor.performExtractions() calling method java.io.File.<init>()


    private static java.util.List performExtractions(java.io.File p14, java.io.File p15)
    {
        String v4 = new StringBuilder().append(p14.getName()).append(".classes").toString();
        android.support.multidex.MultiDexExtractor.prepareDexDir(p15, v4);
        java.util.ArrayList v6_1 = new java.util.ArrayList();
        java.util.zip.ZipFile v0_1 = new java.util.zip.ZipFile(p14);
        int v9 = 2;
        try {
            java.util.zip.ZipEntry v1 = v0_1.getEntry(new StringBuilder().append("classes").append(2).append(".dex").toString());
        } catch (String v10_13) {
            try {
                v0_1.close();
            } catch (java.io.IOException v2_0) {
                android.util.Log.w("MultiDex", "Failed to close resource", v2_0);
            }
            throw v10_13;
        }
        while (v1 != null) {
            java.io.File v3_1 = new java.io.File(p15, new StringBuilder().append(v4).append(v9).append(".zip").toString());
            v6_1.add(v3_1);
            android.util.Log.i("MultiDex", new StringBuilder().append("Extraction is needed for file ").append(v3_1).toString());
            int v8 = 0;
            boolean v7 = 0;
            while ((v8 < 3) && (!v7)) {
                String v10_5;
                v8++;
                android.support.multidex.MultiDexExtractor.extract(v0_1, v1, v3_1, v4);
                v7 = android.support.multidex.MultiDexExtractor.verifyZipFile(v3_1);
                StringBuilder vtmp22 = new StringBuilder().append("Extraction ");
                if (!v7) {
                    v10_5 = "failed";
                } else {
                    v10_5 = "success";
                }
                android.util.Log.i("MultiDex", vtmp22.append(v10_5).append(" - length ").append(v3_1.getAbsolutePath()).append(": ").append(v3_1.length()).toString());
                if (!v7) {
                    v3_1.delete();
                    if (v3_1.exists()) {
                        android.util.Log.w("MultiDex", new StringBuilder().append("Failed to delete corrupted secondary dex \'").append(v3_1.getPath()).append("\'").toString());
                    }
                }
            }
            if (v7) {
                v9++;
                v1 = v0_1.getEntry(new StringBuilder().append("classes").append(v9).append(".dex").toString());
            } else {
                throw new java.io.IOException(new StringBuilder().append("Could not create zip file ").append(v3_1.getAbsolutePath()).append(" for secondary dex (").append(v9).append(")").toString());
            }
        }
        try {
            v0_1.close();
        } catch (java.io.IOException v2_1) {
            android.util.Log.w("MultiDex", "Failed to close resource", v2_1);
        }
        return v6_1;
    }

Method android.support.multidex.MultiDexExtractor.loadExistingExtractions() calling method java.io.File.<init>()


    private static java.util.List loadExistingExtractions(android.content.Context p9, java.io.File p10, java.io.File p11)
    {
        android.util.Log.i("MultiDex", "loading existing secondary dex files");
        String v1 = new StringBuilder().append(p10.getName()).append(".classes").toString();
        int v5 = android.support.multidex.MultiDexExtractor.getMultiDexPreferences(p9).getInt("dex.number", 1);
        java.util.ArrayList v3_1 = new java.util.ArrayList(v5);
        int v4 = 2;
        while (v4 <= v5) {
            java.io.File v0_1 = new java.io.File(p11, new StringBuilder().append(v1).append(v4).append(".zip").toString());
            if (!v0_1.isFile()) {
                throw new java.io.IOException(new StringBuilder().append("Missing extracted secondary dex file \'").append(v0_1.getPath()).append("\'").toString());
            } else {
                v3_1.add(v0_1);
                if (android.support.multidex.MultiDexExtractor.verifyZipFile(v0_1)) {
                    v4++;
                } else {
                    android.util.Log.i("MultiDex", new StringBuilder().append("Invalid zip file: ").append(v0_1).toString());
                    throw new java.io.IOException("Invalid ZIP file.");
                }
            }
        }
        return v3_1;
    }

Method android.support.multidex.MultiDexExtractor.load() calling method java.io.File.<init>()


    static java.util.List load(android.content.Context p9, android.content.pm.ApplicationInfo p10, java.io.File p11, boolean p12)
    {
        java.util.List v0;
        android.util.Log.i("MultiDex", new StringBuilder().append("MultiDexExtractor.load(").append(p10.sourceDir).append(", ").append(p12).append(")").toString());
        java.io.File v8_1 = new java.io.File(p10.sourceDir);
        long v4 = android.support.multidex.MultiDexExtractor.getZipCrc(v8_1);
        if ((p12) || (android.support.multidex.MultiDexExtractor.isModified(p9, v8_1, v4))) {
            android.util.Log.i("MultiDex", "Detected that extraction must be performed.");
            v0 = android.support.multidex.MultiDexExtractor.performExtractions(v8_1, p11);
            android.support.multidex.MultiDexExtractor.putStoredApkInfo(p9, android.support.multidex.MultiDexExtractor.getTimeStamp(v8_1), v4, (v0.size() + 1));
        } else {
            try {
                v0 = android.support.multidex.MultiDexExtractor.loadExistingExtractions(p9, v8_1, p11);
            } catch (java.io.IOException v7) {
                android.util.Log.w("MultiDex", "Failed to reload existing extracted secondary dex files, falling back to fresh extraction", v7);
                v0 = android.support.multidex.MultiDexExtractor.performExtractions(v8_1, p11);
                android.support.multidex.MultiDexExtractor.putStoredApkInfo(p9, android.support.multidex.MultiDexExtractor.getTimeStamp(v8_1), v4, (v0.size() + 1));
            }
        }
        android.util.Log.i("MultiDex", new StringBuilder().append("load found ").append(v0.size()).append(" secondary dex files").toString());
        return v0;
    }

Method android.support.multidex.MultiDex.install() calling method java.io.File.<init>()


    public static void install(android.content.Context p11)
    {
        android.util.Log.i("MultiDex", "install");
        if (!android.support.multidex.MultiDex.IS_VM_MULTIDEX_CAPABLE) {
            if (android.os.Build$VERSION.SDK_INT >= 4) {
                try {
                    android.content.pm.ApplicationInfo v1 = android.support.multidex.MultiDex.getApplicationInfo(p11);
                } catch (RuntimeException v3_0) {
                    android.util.Log.e("MultiDex", "Multidex installation failure", v3_0);
                    throw new RuntimeException(new StringBuilder().append("Multi dex installation failed (").append(v3_0.getMessage()).append(").").toString());
                }
                if (v1 != null) {
                    String v0 = v1.sourceDir;
                    if (!android.support.multidex.MultiDex.installedApk.contains(v0)) {
                        android.support.multidex.MultiDex.installedApk.add(v0);
                        if (android.os.Build$VERSION.SDK_INT > 20) {
                            android.util.Log.w("MultiDex", new StringBuilder().append("MultiDex is not guaranteed to work in SDK version ").append(android.os.Build$VERSION.SDK_INT).append(": SDK version higher than ").append(20).append(" should be backed by ").append("runtime with built-in multidex capabilty but it\'s not the ").append("case here: java.vm.version=\"").append(System.getProperty("java.vm.version")).append("\"").toString());
                        }
                        try {
                            ClassLoader v5 = p11.getClassLoader();
                        } catch (RuntimeException v3_1) {
                            android.util.Log.w("MultiDex", "Failure while trying to obtain Context class loader. Must be running in test mode. Skip patching.", v3_1);
                        }
                        if (v5 != null) {
                            try {
                                android.support.multidex.MultiDex.clearOldDexDir(p11);
                            } catch (Throwable v6) {
                                android.util.Log.w("MultiDex", "Something went wrong when trying to clear old MultiDex extraction, continuing without cleaning.", v6);
                            }
                            java.io.File v2_1 = new java.io.File(v1.dataDir, android.support.multidex.MultiDex.SECONDARY_FOLDER_NAME);
                            java.util.List v4_0 = android.support.multidex.MultiDexExtractor.load(p11, v1, v2_1, 0);
                            if (!android.support.multidex.MultiDex.checkValidZipFiles(v4_0)) {
                                android.util.Log.w("MultiDex", "Files were not valid zip files.  Forcing a reload.");
                                java.util.List v4_1 = android.support.multidex.MultiDexExtractor.load(p11, v1, v2_1, 1);
                                if (!android.support.multidex.MultiDex.checkValidZipFiles(v4_1)) {
                                    throw new RuntimeException("Zip files were not valid.");
                                } else {
                                    android.support.multidex.MultiDex.installSecondaryDexes(v5, v2_1, v4_1);
                                }
                            } else {
                                android.support.multidex.MultiDex.installSecondaryDexes(v5, v2_1, v4_0);
                            }
                            android.util.Log.i("MultiDex", "install done");
                        } else {
                            android.util.Log.e("MultiDex", "Context class loader is null. Must be running in test mode. Skip patching.");
                        }
                    } else {
                    }
                }
            } else {
                throw new RuntimeException(new StringBuilder().append("Multi dex installation failed. SDK ").append(android.os.Build$VERSION.SDK_INT).append(" is unsupported. Min SDK version is ").append(4).append(".").toString());
            }
        } else {
            android.util.Log.i("MultiDex", "VM has multidex support, MultiDex support library is disabled.");
        }
        return;
    }

Method android.support.multidex.MultiDex.clearOldDexDir() calling method java.io.File.<init>()


    private static void clearOldDexDir(android.content.Context p10)
    {
        java.io.File v1_1 = new java.io.File(p10.getFilesDir(), "secondary-dexes");
        if (v1_1.isDirectory()) {
            android.util.Log.i("MultiDex", new StringBuilder().append("Clearing old secondary dex dir (").append(v1_1.getPath()).append(").").toString());
            java.io.File[] v2 = v1_1.listFiles();
            if (v2 != null) {
                java.io.File[] v0 = v2;
                int v4 = v0.length;
                int v3 = 0;
                while (v3 < v4) {
                    java.io.File v5 = v0[v3];
                    android.util.Log.i("MultiDex", new StringBuilder().append("Trying to delete old file ").append(v5.getPath()).append(" of size ").append(v5.length()).toString());
                    if (v5.delete()) {
                        android.util.Log.i("MultiDex", new StringBuilder().append("Deleted old file ").append(v5.getPath()).toString());
                    } else {
                        android.util.Log.w("MultiDex", new StringBuilder().append("Failed to delete old file ").append(v5.getPath()).toString());
                    }
                    v3++;
                }
                if (v1_1.delete()) {
                    android.util.Log.i("MultiDex", new StringBuilder().append("Deleted old secondary dex dir ").append(v1_1.getPath()).toString());
                } else {
                    android.util.Log.w("MultiDex", new StringBuilder().append("Failed to delete secondary dex dir ").append(v1_1.getPath()).toString());
                }
            } else {
                android.util.Log.w("MultiDex", new StringBuilder().append("Failed to list secondary dex dir content (").append(v1_1.getPath()).append(").").toString());
            }
        }
        return;
    }

Method org.apache.commons.io.input.Tailer.run() calling method java.io.RandomAccessFile.<init>()


    public void run()
    {
        long v2 = 0;
        long v6_0 = 0;
        java.io.RandomAccessFile v8 = 0;
        try {
            while ((this.run) && (v8 == null)) {
                try {
                    java.io.RandomAccessFile v1_2 = new java.io.RandomAccessFile(this.file, "r");
                } catch (java.io.FileNotFoundException v0) {
                    this.listener.fileNotFound();
                    v1_2 = v8;
                }
                if (v1_2 != null) {
                    if (!this.end) {
                        v6_0 = 0;
                    } else {
                        v6_0 = this.file.length();
                    }
                    v2 = System.currentTimeMillis();
                    v1_2.seek(v6_0);
                    v8 = v1_2;
                } else {
                    try {
                        Thread.sleep(this.delay);
                        v8 = v1_2;
                    } catch (InterruptedException v10) {
                        v8 = v1_2;
                    }
                }
                return;
            }
        } catch (InterruptedException v10_12) {
            v1_2 = v8;
            org.apache.commons.io.IOUtils.closeQuietly(v1_2);
            throw v10_12;
        } catch (java.io.FileNotFoundException v0) {
            v1_2 = v8;
            this.listener.handle(v0);
            org.apache.commons.io.IOUtils.closeQuietly(v1_2);
            return;
        } catch (InterruptedException v10_12) {
        } catch (java.io.FileNotFoundException v0) {
        }
        while (this.run) {
            long v4 = this.file.length();
            if (v4 >= v6_0) {
                if (v4 <= v6_0) {
                    if (org.apache.commons.io.FileUtils.isFileNewer(this.file, v2)) {
                        v8.seek(0);
                        v2 = System.currentTimeMillis();
                        v6_0 = this.readLines(v8);
                    }
                } else {
                    v2 = System.currentTimeMillis();
                    v6_0 = this.readLines(v8);
                }
                try {
                    Thread.sleep(this.delay);
                } catch (InterruptedException v10) {
                }
            } else {
                this.listener.fileRotated();
                int v9 = v8;
                try {
                    v1_2 = new java.io.RandomAccessFile(this.file, "r");
                    v6_0 = 0;
                    try {
                        org.apache.commons.io.IOUtils.closeQuietly(v9);
                        v8 = v1_2;
                    } catch (java.io.FileNotFoundException v0) {
                        this.listener.fileNotFound();
                        v8 = v1_2;
                    }
                } catch (java.io.FileNotFoundException v0) {
                    v1_2 = v8;
                }
            }
            return;
        }
        org.apache.commons.io.IOUtils.closeQuietly(v8);
        return;
    }

Method org.apache.commons.io.input.ReversedLinesFileReader.<init>() calling method java.io.RandomAccessFile.<init>()


    public ReversedLinesFileReader(java.io.File p11, int p12, String p13)
    {
        this.trailingNewlineOfFileSkipped = 0;
        this.blockSize = p12;
        this.encoding = p13;
        this.randomAccessFile = new java.io.RandomAccessFile(p11, "r");
        this.totalByteLength = this.randomAccessFile.length();
        int v4 = ((int) (this.totalByteLength % ((long) p12)));
        if (v4 <= 0) {
            this.totalBlockCount = (this.totalByteLength / ((long) p12));
            if (this.totalByteLength > 0) {
                v4 = p12;
            }
        } else {
            this.totalBlockCount = ((this.totalByteLength / ((long) p12)) + 1);
        }
        this.currentFilePart = new org.apache.commons.io.input.ReversedLinesFileReader$FilePart(this, this.totalBlockCount, v4, 0, 0);
        java.nio.charset.Charset v7 = java.nio.charset.Charset.forName(p13);
        if (v7.newEncoder().maxBytesPerChar() != 1065353216) {
            if (v7 != java.nio.charset.Charset.forName("UTF-8")) {
                if (v7 != java.nio.charset.Charset.forName("Shift_JIS")) {
                    if ((v7 != java.nio.charset.Charset.forName("UTF-16BE")) && (v7 != java.nio.charset.Charset.forName("UTF-16LE"))) {
                        if (v7 != java.nio.charset.Charset.forName("UTF-16")) {
                            throw new java.io.UnsupportedEncodingException(new StringBuilder().append("Encoding ").append(p13).append(" is not supported yet (feel free to submit a patch)").toString());
                        } else {
                            throw new java.io.UnsupportedEncodingException("For UTF-16, you need to specify the byte order (use UTF-16BE or UTF-16LE)");
                        }
                    } else {
                        this.byteDecrement = 2;
                    }
                } else {
                    this.byteDecrement = 1;
                }
            } else {
                this.byteDecrement = 1;
            }
        } else {
            this.byteDecrement = 1;
        }
        java.io.UnsupportedEncodingException v0_40 = new byte[][3];
        v0_40[0] = "\r\n".getBytes(p13);
        v0_40[1] = "\n".getBytes(p13);
        v0_40[2] = "\r".getBytes(p13);
        this.newLineSequences = v0_40;
        this.avoidNewlineSplitBufferSize = this.newLineSequences[0].length;
        return;
    }

Method org.apache.commons.io.filefilter.MagicNumberFileFilter.accept() calling method java.io.RandomAccessFile.<init>()


    public boolean accept(java.io.File p9)
    {
        boolean v4_0 = 0;
        if ((p9 != null) && ((p9.isFile()) && (p9.canRead()))) {
            java.io.RandomAccessFile v1 = 0;
            try {
                byte[] v0 = new byte[this.magicNumbers.length];
                java.io.RandomAccessFile v2_1 = new java.io.RandomAccessFile(p9, "r");
                try {
                    v2_1.seek(this.byteOffset);
                } catch (boolean v4_1) {
                    v1 = v2_1;
                    org.apache.commons.io.IOUtils.closeQuietly(v1);
                    throw v4_1;
                } catch (byte[] v5) {
                    v1 = v2_1;
                    org.apache.commons.io.IOUtils.closeQuietly(v1);
                }
                if (v2_1.read(v0) == this.magicNumbers.length) {
                    v4_0 = java.util.Arrays.equals(this.magicNumbers, v0);
                    org.apache.commons.io.IOUtils.closeQuietly(v2_1);
                } else {
                    org.apache.commons.io.IOUtils.closeQuietly(v2_1);
                }
            } catch (boolean v4_1) {
            } catch (byte[] v5) {
            }
        }
        return v4_0;
    }

Method android.support.multidex.ZipUtil.getZipCrc() calling method java.io.RandomAccessFile.<init>()


    static long getZipCrc(java.io.File p4)
    {
        java.io.RandomAccessFile v1_1 = new java.io.RandomAccessFile(p4, "r");
        try {
            Throwable v2_1 = android.support.multidex.ZipUtil.computeCrcOfCentralDir(v1_1, android.support.multidex.ZipUtil.findCentralDirectory(v1_1));
            v1_1.close();
            return v2_1;
        } catch (Throwable v2_2) {
            v1_1.close();
            throw v2_2;
        }
    }

Method android.support.v7.widget.ActivityChooserModel$PersistHistoryAsyncTask.doInBackground() calling method android.content.Context.openFileOutput()


    public varargs Void doInBackground(Object[] p19)
    {
        java.util.List v4_1 = ((java.util.List) p19[0]);
        String v5_1 = ((String) p19[1]);
        try {
            java.io.FileOutputStream v3 = this.this$0.mContext.openFileOutput(v5_1, 0);
            org.xmlpull.v1.XmlSerializer v12 = android.util.Xml.newSerializer();
            try {
                v12.setOutput(v3, 0);
                v12.startDocument("UTF-8", Boolean.valueOf(1));
                v12.startTag(0, "historical-records");
                int v11 = v4_1.size();
                int v6 = 0;
            } catch (IllegalArgumentException v7) {
                android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, new StringBuilder().append("Error writing historical record file: ").append(this.this$0.mHistoryFileName).toString(), v7);
                this.this$0.mCanReadHistoricalData = 1;
                if (v3 == null) {
                    java.io.IOException v13_3 = 0;
                    return v13_3;
                } else {
                    try {
                        v3.close();
                    } catch (java.io.IOException v13) {
                    }
                }
            } catch (IllegalStateException v9) {
                android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, new StringBuilder().append("Error writing historical record file: ").append(this.this$0.mHistoryFileName).toString(), v9);
                this.this$0.mCanReadHistoricalData = 1;
                if (v3 == null) {
                } else {
                    try {
                        v3.close();
                    } catch (java.io.IOException v13) {
                    }
                }
            } catch (java.io.IOException v8) {
                android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, new StringBuilder().append("Error writing historical record file: ").append(this.this$0.mHistoryFileName).toString(), v8);
                this.this$0.mCanReadHistoricalData = 1;
                if (v3 == null) {
                } else {
                    try {
                        v3.close();
                    } catch (java.io.IOException v13) {
                    }
                }
            } catch (java.io.IOException v13_2) {
                this.this$0.mCanReadHistoricalData = 1;
                if (v3 != null) {
                    try {
                        v3.close();
                    } catch (int v14) {
                    }
                }
                throw v13_2;
            }
            while (v6 < v11) {
                android.support.v7.widget.ActivityChooserModel$HistoricalRecord v10_1 = ((android.support.v7.widget.ActivityChooserModel$HistoricalRecord) v4_1.remove(0));
                v12.startTag(0, "historical-record");
                v12.attribute(0, "activity", v10_1.activity.flattenToString());
                v12.attribute(0, "time", String.valueOf(v10_1.time));
                v12.attribute(0, "weight", String.valueOf(v10_1.weight));
                v12.endTag(0, "historical-record");
                v6++;
            }
            v12.endTag(0, "historical-records");
            v12.endDocument();
            this.this$0.mCanReadHistoricalData = 1;
            if (v3 == null) {
            } else {
                try {
                    v3.close();
                } catch (java.io.IOException v13) {
                }
            }
        } catch (java.io.FileNotFoundException v2) {
            android.util.Log.e(android.support.v7.widget.ActivityChooserModel.LOG_TAG, new StringBuilder().append("Error writing historical record file: ").append(v5_1).toString(), v2);
            v13_3 = 0;
            return v13_3;
        }
    }