Update README.md

README.md

@@ -8,374 +8,660 @@ tags:
 - loss:CosineSimilarityLoss
 base_model: Shuu12121/CodeModernBERT-Owl
 widget:
-- source_sentence: "    public void scan() throws Throwable {\n        client = new\
-    \ FTPClient();\n        log.info(\"connecting to \" + host + \"...\");\n     \
-    \   client.connect(host);\n        log.info(client.getReplyString());\n      \
-    \  log.info(\"logging in...\");\n        client.login(\"anonymous\", \"\");\n\
-    \        log.info(client.getReplyString());\n        Date date = Calendar.getInstance().getTime();\n\
-    \        xmlDocument = new XMLDocument(host, dir, date);\n        scanDirectory(dir);\n\
-    \    }\n"
+- source_sentence: |2
+        public void scan() throws Throwable {
+            client = new FTPClient();
+            log.info("connecting to " + host + "...");
+            client.connect(host);
+            log.info(client.getReplyString());
+            log.info("logging in...");
+            client.login("anonymous", "");
+            log.info(client.getReplyString());
+            Date date = Calendar.getInstance().getTime();
+            xmlDocument = new XMLDocument(host, dir, date);
+            scanDirectory(dir);
+        }
   sentences:
-  - "    public static void zip(ZipOutputStream out, File f, String base) throws Exception\
-    \ {\n        if (f.isDirectory()) {\n            File[] fl = f.listFiles();\n\
-    \            base = base.length() == 0 ? \"\" : base + File.separator;\n     \
-    \       for (int i = 0; i < fl.length; i++) {\n                zip(out, fl[i],\
-    \ base + fl[i].getName());\n            }\n        } else {\n            out.putNextEntry(new\
-    \ org.apache.tools.zip.ZipEntry(base));\n            FileInputStream in = new\
-    \ FileInputStream(f);\n            IOUtils.copyStream(in, out);\n            in.close();\n\
-    \        }\n        Thread.sleep(10);\n    }\n"
-  - "    public static void zip(String destination, String folder) {\n        File\
-    \ fdir = new File(folder);\n        File[] files = fdir.listFiles();\n       \
-    \ PrintWriter stdout = new PrintWriter(System.out, true);\n        int read =\
-    \ 0;\n        FileInputStream in;\n        byte[] data = new byte[1024];\n   \
-    \     try {\n            ZipOutputStream out = new ZipOutputStream(new FileOutputStream(destination));\n\
-    \            out.setMethod(ZipOutputStream.DEFLATED);\n            for (int i\
-    \ = 0; i < files.length; i++) {\n                try {\n                    stdout.println(files[i].getName());\n\
-    \                    ZipEntry entry = new ZipEntry(files[i].getName());\n    \
-    \                in = new FileInputStream(files[i].getPath());\n             \
-    \       out.putNextEntry(entry);\n                    while ((read = in.read(data,\
-    \ 0, 1024)) != -1) {\n                        out.write(data, 0, read);\n    \
-    \                }\n                    out.closeEntry();\n                  \
-    \  in.close();\n                } catch (Exception e) {\n                    e.printStackTrace();\n\
-    \                }\n            }\n            out.close();\n        } catch (IOException\
-    \ ex) {\n            ex.printStackTrace();\n        }\n    }\n"
-  - "    private void copyFile(URL from, File to) {\n        try {\n            InputStream\
-    \ is = from.openStream();\n            IOUtils.copy(is, new FileOutputStream(to));\n\
-    \        } catch (IOException e) {\n            e.printStackTrace();\n       \
-    \ }\n    }\n"
-- source_sentence: "    public void createMd5Hash() {\n        try {\n           \
-    \ String vcardObject = new ContactToVcard(TimeZone.getTimeZone(\"UTC\"), \"UTF-8\"\
-    ).convert(this);\n            MessageDigest m = MessageDigest.getInstance(\"MD5\"\
-    );\n            m.update(vcardObject.getBytes());\n            this.md5Hash =\
-    \ new BigInteger(m.digest()).toString();\n            if (log.isTraceEnabled())\
-    \ {\n                log.trace(\"Hash is:\" + this.md5Hash);\n            }\n\
-    \        } catch (ConverterException ex) {\n            log.error(\"Error creating\
-    \ hash:\" + ex.getMessage());\n        } catch (NoSuchAlgorithmException noSuchAlgorithmException)\
-    \ {\n            log.error(\"Error creating hash:\" + noSuchAlgorithmException.getMessage());\n\
-    \        }\n    }\n"
+  - |2
+        public static void zip(ZipOutputStream out, File f, String base) throws Exception {
+            if (f.isDirectory()) {
+                File[] fl = f.listFiles();
+                base = base.length() == 0 ? "" : base + File.separator;
+                for (int i = 0; i < fl.length; i++) {
+                    zip(out, fl[i], base + fl[i].getName());
+                }
+            } else {
+                out.putNextEntry(new org.apache.tools.zip.ZipEntry(base));
+                FileInputStream in = new FileInputStream(f);
+                IOUtils.copyStream(in, out);
+                in.close();
+            }
+            Thread.sleep(10);
+        }
+  - |2
+        public static void zip(String destination, String folder) {
+            File fdir = new File(folder);
+            File[] files = fdir.listFiles();
+            PrintWriter stdout = new PrintWriter(System.out, true);
+            int read = 0;
+            FileInputStream in;
+            byte[] data = new byte[1024];
+            try {
+                ZipOutputStream out = new ZipOutputStream(new FileOutputStream(destination));
+                out.setMethod(ZipOutputStream.DEFLATED);
+                for (int i = 0; i < files.length; i++) {
+                    try {
+                        stdout.println(files[i].getName());
+                        ZipEntry entry = new ZipEntry(files[i].getName());
+                        in = new FileInputStream(files[i].getPath());
+                        out.putNextEntry(entry);
+                        while ((read = in.read(data, 0, 1024)) != -1) {
+                            out.write(data, 0, read);
+                        }
+                        out.closeEntry();
+                        in.close();
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }
+                out.close();
+            } catch (IOException ex) {
+                ex.printStackTrace();
+            }
+        }
+  - |2
+        private void copyFile(URL from, File to) {
+            try {
+                InputStream is = from.openStream();
+                IOUtils.copy(is, new FileOutputStream(to));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+- source_sentence: |2
+        public void createMd5Hash() {
+            try {
+                String vcardObject = new ContactToVcard(TimeZone.getTimeZone("UTC"), "UTF-8").convert(this);
+                MessageDigest m = MessageDigest.getInstance("MD5");
+                m.update(vcardObject.getBytes());
+                this.md5Hash = new BigInteger(m.digest()).toString();
+                if (log.isTraceEnabled()) {
+                    log.trace("Hash is:" + this.md5Hash);
+                }
+            } catch (ConverterException ex) {
+                log.error("Error creating hash:" + ex.getMessage());
+            } catch (NoSuchAlgorithmException noSuchAlgorithmException) {
+                log.error("Error creating hash:" + noSuchAlgorithmException.getMessage());
+            }
+        }
   sentences:
-  - "    public static void main(String[] args) {\n        try {\n            int\
-    \ encodeFlag = 0;\n            if (args[0].equals(\"-e\")) {\n               \
-    \ encodeFlag = Base64.ENCODE;\n            } else if (args[0].equals(\"-d\"))\
-    \ {\n                encodeFlag = Base64.DECODE;\n            }\n            String\
-    \ infile = args[1];\n            String outfile = args[2];\n            File fin\
-    \ = new File(infile);\n            FileInputStream fis = new FileInputStream(fin);\n\
-    \            BufferedInputStream bis = new BufferedInputStream(fis);\n       \
-    \     Base64.InputStream b64in = new Base64.InputStream(bis, encodeFlag | Base64.DO_BREAK_LINES);\n\
-    \            File fout = new File(outfile);\n            FileOutputStream fos\
-    \ = new FileOutputStream(fout);\n            BufferedOutputStream bos = new BufferedOutputStream(fos);\n\
-    \            byte[] buff = new byte[1024];\n            int read = -1;\n     \
-    \       while ((read = b64in.read(buff)) >= 0) {\n                bos.write(buff,\
-    \ 0, read);\n            }\n            bos.close();\n            b64in.close();\n\
-    \        } catch (Exception e) {\n            e.printStackTrace();\n        }\n\
-    \    }\n"
-  - "    public static String md5(String str) {\n        StringBuffer buf = new StringBuffer();\n\
-    \        try {\n            MessageDigest md = MessageDigest.getInstance(\"MD5\"\
-    );\n            byte[] data = new byte[32];\n            md.update(str.getBytes(md5Encoding),\
-    \ 0, str.length());\n            data = md.digest();\n            for (int i =\
-    \ 0; i < data.length; i++) {\n                int halfbyte = (data[i] >>> 4) &\
-    \ 0x0F;\n                int two_halfs = 0;\n                do {\n          \
-    \          if ((0 <= halfbyte) && (halfbyte <= 9)) buf.append((char) ('0' + halfbyte));\
-    \ else buf.append((char) ('a' + (halfbyte - 10)));\n                    halfbyte\
-    \ = data[i] & 0x0F;\n                } while (two_halfs++ < 1);\n            }\n\
-    \        } catch (Exception e) {\n            errorLog(\"{Malgn.md5} \" + e.getMessage());\n\
-    \        }\n        return buf.toString();\n    }\n"
-  - "    public static String md5(String text, String charset) {\n        MessageDigest\
-    \ msgDigest = null;\n        try {\n            msgDigest = MessageDigest.getInstance(\"\
-    MD5\");\n        } catch (NoSuchAlgorithmException e) {\n            throw new\
-    \ IllegalStateException(\"System doesn't support MD5 algorithm.\");\n        }\n\
-    \        msgDigest.update(text.getBytes());\n        byte[] bytes = msgDigest.digest();\n\
-    \        byte tb;\n        char low;\n        char high;\n        char tmpChar;\n\
-    \        String md5Str = new String();\n        for (int i = 0; i < bytes.length;\
-    \ i++) {\n            tb = bytes[i];\n            tmpChar = (char) ((tb >>> 4)\
-    \ & 0x000f);\n            if (tmpChar >= 10) {\n                high = (char)\
-    \ (('a' + tmpChar) - 10);\n            } else {\n                high = (char)\
-    \ ('0' + tmpChar);\n            }\n            md5Str += high;\n            tmpChar\
-    \ = (char) (tb & 0x000f);\n            if (tmpChar >= 10) {\n                low\
-    \ = (char) (('a' + tmpChar) - 10);\n            } else {\n                low\
-    \ = (char) ('0' + tmpChar);\n            }\n            md5Str += low;\n     \
-    \   }\n        return md5Str;\n    }\n"
-- source_sentence: "            @Override\n            public void run() {\n     \
-    \           try {\n                    IOUtils.copy(getSource(), processStdIn);\n\
-    \                    System.err.println(\"Copy done.\");\n                   \
-    \ close();\n                } catch (IOException e) {\n                    e.printStackTrace();\n\
-    \                    IOUtils.closeQuietly(ExternalDecoder.this);\n           \
-    \     }\n            }\n"
+  - |2
+        public static void main(String[] args) {
+            try {
+                int encodeFlag = 0;
+                if (args[0].equals("-e")) {
+                    encodeFlag = Base64.ENCODE;
+                } else if (args[0].equals("-d")) {
+                    encodeFlag = Base64.DECODE;
+                }
+                String infile = args[1];
+                String outfile = args[2];
+                File fin = new File(infile);
+                FileInputStream fis = new FileInputStream(fin);
+                BufferedInputStream bis = new BufferedInputStream(fis);
+                Base64.InputStream b64in = new Base64.InputStream(bis, encodeFlag | Base64.DO_BREAK_LINES);
+                File fout = new File(outfile);
+                FileOutputStream fos = new FileOutputStream(fout);
+                BufferedOutputStream bos = new BufferedOutputStream(fos);
+                byte[] buff = new byte[1024];
+                int read = -1;
+                while ((read = b64in.read(buff)) >= 0) {
+                    bos.write(buff, 0, read);
+                }
+                bos.close();
+                b64in.close();
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+  - |2
+        public static String md5(String str) {
+            StringBuffer buf = new StringBuffer();
+            try {
+                MessageDigest md = MessageDigest.getInstance("MD5");
+                byte[] data = new byte[32];
+                md.update(str.getBytes(md5Encoding), 0, str.length());
+                data = md.digest();
+                for (int i = 0; i < data.length; i++) {
+                    int halfbyte = (data[i] >>> 4) & 0x0F;
+                    int two_halfs = 0;
+                    do {
+                        if ((0 <= halfbyte) && (halfbyte <= 9)) buf.append((char) ('0' + halfbyte)); else buf.append((char) ('a' + (halfbyte - 10)));
+                        halfbyte = data[i] & 0x0F;
+                    } while (two_halfs++ < 1);
+                }
+            } catch (Exception e) {
+                errorLog("{Malgn.md5} " + e.getMessage());
+            }
+            return buf.toString();
+        }
+  - |2
+        public static String md5(String text, String charset) {
+            MessageDigest msgDigest = null;
+            try {
+                msgDigest = MessageDigest.getInstance("MD5");
+            } catch (NoSuchAlgorithmException e) {
+                throw new IllegalStateException("System doesn't support MD5 algorithm.");
+            }
+            msgDigest.update(text.getBytes());
+            byte[] bytes = msgDigest.digest();
+            byte tb;
+            char low;
+            char high;
+            char tmpChar;
+            String md5Str = new String();
+            for (int i = 0; i < bytes.length; i++) {
+                tb = bytes[i];
+                tmpChar = (char) ((tb >>> 4) & 0x000f);
+                if (tmpChar >= 10) {
+                    high = (char) (('a' + tmpChar) - 10);
+                } else {
+                    high = (char) ('0' + tmpChar);
+                }
+                md5Str += high;
+                tmpChar = (char) (tb & 0x000f);
+                if (tmpChar >= 10) {
+                    low = (char) (('a' + tmpChar) - 10);
+                } else {
+                    low = (char) ('0' + tmpChar);
+                }
+                md5Str += low;
+            }
+            return md5Str;
+        }
+- source_sentence: |2
+                @Override
+                public void run() {
+                    try {
+                        IOUtils.copy(getSource(), processStdIn);
+                        System.err.println("Copy done.");
+                        close();
+                    } catch (IOException e) {
+                        e.printStackTrace();
+                        IOUtils.closeQuietly(ExternalDecoder.this);
+                    }
+                }
   sentences:
-  - "    private String readJsonString() {\n        StringBuilder builder = new StringBuilder();\n\
-    \        HttpClient client = new DefaultHttpClient();\n        HttpGet httpGet\
-    \ = new HttpGet(SERVER_URL);\n        try {\n            HttpResponse response\
-    \ = client.execute(httpGet);\n            StatusLine statusLine = response.getStatusLine();\n\
-    \            int statusCode = statusLine.getStatusCode();\n            if (statusCode\
-    \ == 200) {\n                HttpEntity entity = response.getEntity();\n     \
-    \           InputStream content = entity.getContent();\n                BufferedReader\
-    \ reader = new BufferedReader(new InputStreamReader(content));\n             \
-    \   String line;\n                while ((line = reader.readLine()) != null) {\n\
-    \                    builder.append(line);\n                }\n            } else\
-    \ {\n                Log.e(TAG, \"Failed to download file\");\n            }\n\
-    \        } catch (ClientProtocolException e) {\n            e.printStackTrace();\n\
-    \        } catch (IOException e) {\n            e.printStackTrace();\n       \
-    \ }\n        return builder.toString();\n    }\n"
-  - "    public void run() {\n        LogPrinter.log(Level.FINEST, \"Started Download\
-    \ at : {0, date, long}\", new Date());\n        if (!PipeConnected) {\n      \
-    \      throw new IllegalStateException(\"You should connect the pipe before with\
-    \ getInputStream()\");\n        }\n        InputStream ins = null;\n        if\
-    \ (IsAlreadyDownloaded) {\n            LogPrinter.log(Level.FINEST, \"The file\
-    \ already Exists open and foward the byte\");\n            try {\n           \
-    \     ContentLength = (int) TheAskedFile.length();\n                ContentType\
-    \ = URLConnection.getFileNameMap().getContentTypeFor(TheAskedFile.getName());\n\
-    \                ins = new FileInputStream(TheAskedFile);\n                byte[]\
-    \ buffer = new byte[BUFFER_SIZE];\n                int read = ins.read(buffer);\n\
-    \                while (read >= 0) {\n                    Pipe.write(buffer, 0,\
-    \ read);\n                    read = ins.read(buffer);\n                }\n  \
-    \          } catch (IOException e) {\n                e.printStackTrace();\n \
-    \           } finally {\n                if (ins != null) {\n                \
-    \    try {\n                        ins.close();\n                    } catch\
-    \ (IOException e) {\n                    }\n                }\n            }\n\
-    \        } else {\n            LogPrinter.log(Level.FINEST, \"the file does not\
-    \ exist locally so we try to download the thing\");\n            File theDir =\
-    \ TheAskedFile.getParentFile();\n            if (!theDir.exists()) {\n       \
-    \         theDir.mkdirs();\n            }\n            for (URL url : ListFastest)\
-    \ {\n                FileOutputStream fout = null;\n                boolean OnError\
-    \ = false;\n                long timestart = System.currentTimeMillis();\n   \
-    \             long bytecount = 0;\n                try {\n                   \
-    \ URL newUrl = new URL(url.toString() + RequestedFile);\n                    LogPrinter.log(Level.FINEST,\
-    \ \"the download URL = {0}\", newUrl);\n                    URLConnection conn\
-    \ = newUrl.openConnection();\n                    ContentType = conn.getContentType();\n\
-    \                    ContentLength = conn.getContentLength();\n              \
-    \      ins = conn.getInputStream();\n                    fout = new FileOutputStream(TheAskedFile);\n\
-    \                    byte[] buffer = new byte[BUFFER_SIZE];\n                \
-    \    int read = ins.read(buffer);\n                    while (read >= 0) {\n \
-    \                       fout.write(buffer, 0, read);\n                       \
-    \ Pipe.write(buffer, 0, read);\n                        read = ins.read(buffer);\n\
-    \                        bytecount += read;\n                    }\n         \
-    \           Pipe.flush();\n                } catch (IOException e) {\n       \
-    \             OnError = true;\n                } finally {\n                 \
-    \   if (ins != null) {\n                        try {\n                      \
-    \      ins.close();\n                        } catch (IOException e) {\n     \
-    \                   }\n                    }\n                    if (fout !=\
-    \ null) {\n                        try {\n                            fout.close();\n\
-    \                        } catch (IOException e) {\n                        }\n\
-    \                    }\n                }\n                long timeend = System.currentTimeMillis();\n\
-    \                if (OnError) {\n                    continue;\n             \
-    \   } else {\n                    long timetook = timeend - timestart;\n     \
-    \               BigDecimal speed = new BigDecimal(bytecount).multiply(new BigDecimal(1000)).divide(new\
-    \ BigDecimal(timetook), MathContext.DECIMAL32);\n                    for (ReportCalculatedStatistique\
-    \ report : Listener) {\n                        report.reportUrlStat(url, speed,\
-    \ timetook);\n                    }\n                    break;\n            \
-    \    }\n            }\n        }\n        LogPrinter.log(Level.FINEST, \"download\
-    \ finished at {0,date,long}\", new Date());\n        if (Pipe != null) {\n   \
-    \         try {\n                Pipe.close();\n            } catch (IOException\
-    \ e) {\n                e.printStackTrace();\n            }\n        }\n    }\n"
-  - "    public void run(String srcf, String dst) {\n        final Path srcPath =\
-    \ new Path(\"./\" + srcf);\n        final Path desPath = new Path(dst);\n    \
-    \    try {\n            Path[] srcs = FileUtil.stat2Paths(hdfs.globStatus(srcPath),\
-    \ srcPath);\n            OutputStream out = FileSystem.getLocal(conf).create(desPath);\n\
-    \            for (int i = 0; i < srcs.length; i++) {\n                System.out.println(srcs[i]);\n\
-    \                InputStream in = hdfs.open(srcs[i]);\n                IOUtils.copyBytes(in,\
-    \ out, conf, false);\n                in.close();\n            }\n           \
-    \ out.close();\n        } catch (IOException ex) {\n            System.err.print(ex.getMessage());\n\
-    \        }\n    }\n"
-- source_sentence: "    private void readHomePage(ITestThread testThread) throws IOException\
-    \ {\n        if (null == testThread) {\n            throw new IllegalArgumentException(\"\
-    Test thread may not be null.\");\n        }\n        final InputStream urlIn =\
-    \ new URL(testUrl).openStream();\n        final int availableBytes = urlIn.available();\n\
-    \        if (0 == availableBytes) {\n            throw new IllegalStateException(\"\
-    Zero bytes on target host.\");\n        }\n        in = new BufferedReader(new\
-    \ InputStreamReader(urlIn));\n        String line;\n        while (null != in\
-    \ && null != (line = in.readLine())) {\n            page.append(line);\n     \
-    \       page.append('\\n');\n            if (0 != lineDelay) {\n             \
-    \   OS.sleep(lineDelay);\n            }\n            if (testThread.isActionStopped())\
-    \ {\n                break;\n            }\n        }\n    }\n"
+  - |2
+        private String readJsonString() {
+            StringBuilder builder = new StringBuilder();
+            HttpClient client = new DefaultHttpClient();
+            HttpGet httpGet = new HttpGet(SERVER_URL);
+            try {
+                HttpResponse response = client.execute(httpGet);
+                StatusLine statusLine = response.getStatusLine();
+                int statusCode = statusLine.getStatusCode();
+                if (statusCode == 200) {
+                    HttpEntity entity = response.getEntity();
+                    InputStream content = entity.getContent();
+                    BufferedReader reader = new BufferedReader(new InputStreamReader(content));
+                    String line;
+                    while ((line = reader.readLine()) != null) {
+                        builder.append(line);
+                    }
+                } else {
+                    Log.e(TAG, "Failed to download file");
+                }
+            } catch (ClientProtocolException e) {
+                e.printStackTrace();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+            return builder.toString();
+        }
+  - |2
+        public void run() {
+            LogPrinter.log(Level.FINEST, "Started Download at : {0, date, long}", new Date());
+            if (!PipeConnected) {
+                throw new IllegalStateException("You should connect the pipe before with getInputStream()");
+            }
+            InputStream ins = null;
+            if (IsAlreadyDownloaded) {
+                LogPrinter.log(Level.FINEST, "The file already Exists open and foward the byte");
+                try {
+                    ContentLength = (int) TheAskedFile.length();
+                    ContentType = URLConnection.getFileNameMap().getContentTypeFor(TheAskedFile.getName());
+                    ins = new FileInputStream(TheAskedFile);
+                    byte[] buffer = new byte[BUFFER_SIZE];
+                    int read = ins.read(buffer);
+                    while (read >= 0) {
+                        Pipe.write(buffer, 0, read);
+                        read = ins.read(buffer);
+                    }
+                } catch (IOException e) {
+                    e.printStackTrace();
+                } finally {
+                    if (ins != null) {
+                        try {
+                            ins.close();
+                        } catch (IOException e) {
+                        }
+                    }
+                }
+            } else {
+                LogPrinter.log(Level.FINEST, "the file does not exist locally so we try to download the thing");
+                File theDir = TheAskedFile.getParentFile();
+                if (!theDir.exists()) {
+                    theDir.mkdirs();
+                }
+                for (URL url : ListFastest) {
+                    FileOutputStream fout = null;
+                    boolean OnError = false;
+                    long timestart = System.currentTimeMillis();
+                    long bytecount = 0;
+                    try {
+                        URL newUrl = new URL(url.toString() + RequestedFile);
+                        LogPrinter.log(Level.FINEST, "the download URL = {0}", newUrl);
+                        URLConnection conn = newUrl.openConnection();
+                        ContentType = conn.getContentType();
+                        ContentLength = conn.getContentLength();
+                        ins = conn.getInputStream();
+                        fout = new FileOutputStream(TheAskedFile);
+                        byte[] buffer = new byte[BUFFER_SIZE];
+                        int read = ins.read(buffer);
+                        while (read >= 0) {
+                            fout.write(buffer, 0, read);
+                            Pipe.write(buffer, 0, read);
+                            read = ins.read(buffer);
+                            bytecount += read;
+                        }
+                        Pipe.flush();
+                    } catch (IOException e) {
+                        OnError = true;
+                    } finally {
+                        if (ins != null) {
+                            try {
+                                ins.close();
+                            } catch (IOException e) {
+                            }
+                        }
+                        if (fout != null) {
+                            try {
+                                fout.close();
+                            } catch (IOException e) {
+                            }
+                        }
+                    }
+                    long timeend = System.currentTimeMillis();
+                    if (OnError) {
+                        continue;
+                    } else {
+                        long timetook = timeend - timestart;
+                        BigDecimal speed = new BigDecimal(bytecount).multiply(new BigDecimal(1000)).divide(new BigDecimal(timetook), MathContext.DECIMAL32);
+                        for (ReportCalculatedStatistique report : Listener) {
+                            report.reportUrlStat(url, speed, timetook);
+                        }
+                        break;
+                    }
+                }
+            }
+            LogPrinter.log(Level.FINEST, "download finished at {0,date,long}", new Date());
+            if (Pipe != null) {
+                try {
+                    Pipe.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+  - |2
+        public void run(String srcf, String dst) {
+            final Path srcPath = new Path("./" + srcf);
+            final Path desPath = new Path(dst);
+            try {
+                Path[] srcs = FileUtil.stat2Paths(hdfs.globStatus(srcPath), srcPath);
+                OutputStream out = FileSystem.getLocal(conf).create(desPath);
+                for (int i = 0; i < srcs.length; i++) {
+                    System.out.println(srcs[i]);
+                    InputStream in = hdfs.open(srcs[i]);
+                    IOUtils.copyBytes(in, out, conf, false);
+                    in.close();
+                }
+                out.close();
+            } catch (IOException ex) {
+                System.err.print(ex.getMessage());
+            }
+        }
+- source_sentence: |2
+        private void readHomePage(ITestThread testThread) throws IOException {
+            if (null == testThread) {
+                throw new IllegalArgumentException("Test thread may not be null.");
+            }
+            final InputStream urlIn = new URL(testUrl).openStream();
+            final int availableBytes = urlIn.available();
+            if (0 == availableBytes) {
+                throw new IllegalStateException("Zero bytes on target host.");
+            }
+            in = new BufferedReader(new InputStreamReader(urlIn));
+            String line;
+            while (null != in && null != (line = in.readLine())) {
+                page.append(line);
+                page.append('\n');
+                if (0 != lineDelay) {
+                    OS.sleep(lineDelay);
+                }
+                if (testThread.isActionStopped()) {
+                    break;
+                }
+            }
+        }
   sentences:
-  - "    @Override\n    public ReturnValue do_run() {\n        int bufLen = 500 *\
-    \ 1024;\n        ReturnValue ret = new ReturnValue();\n        ret.setExitStatus(ReturnValue.SUCCESS);\n\
-    \        File output = null;\n        if (((String) options.valueOf(\"input-file\"\
-    )).startsWith(\"s3://\")) {\n            Pattern p = Pattern.compile(\"s3://(\\\
-    \\S+):(\\\\S+)@(\\\\S+)\");\n            Matcher m = p.matcher((String) options.valueOf(\"\
-    input-file\"));\n            boolean result = m.find();\n            String accessKey\
-    \ = null;\n            String secretKey = null;\n            String URL = (String)\
-    \ options.valueOf(\"input-file\");\n            if (result) {\n              \
-    \  accessKey = m.group(1);\n                secretKey = m.group(2);\n        \
-    \        URL = \"s3://\" + m.group(3);\n            } else {\n               \
-    \ try {\n                    HashMap<String, String> settings = (HashMap<String,\
-    \ String>) ConfigTools.getSettings();\n                    accessKey = settings.get(\"\
-    AWS_ACCESS_KEY\");\n                    secretKey = settings.get(\"AWS_SECRET_KEY\"\
-    );\n                } catch (Exception e) {\n                    ret.setExitStatus(ReturnValue.SETTINGSFILENOTFOUND);\n\
-    \                    ret.setProcessExitStatus(ReturnValue.SETTINGSFILENOTFOUND);\n\
-    \                    return (ret);\n                }\n            }\n       \
-    \     if (accessKey == null || secretKey == null) {\n                ret.setExitStatus(ReturnValue.ENVVARNOTFOUND);\n\
-    \                ret.setProcessExitStatus(ReturnValue.ENVVARNOTFOUND);\n     \
-    \           return (ret);\n            }\n            AmazonS3 s3 = new AmazonS3Client(new\
-    \ BasicAWSCredentials(accessKey, secretKey));\n            p = Pattern.compile(\"\
-    s3://([^/]+)/(\\\\S+)\");\n            m = p.matcher(URL);\n            result\
-    \ = m.find();\n            if (result) {\n                String bucket = m.group(1);\n\
-    \                String key = m.group(2);\n                S3Object object = s3.getObject(new\
-    \ GetObjectRequest(bucket, key));\n                System.out.println(\"Content-Type:\
-    \ \" + object.getObjectMetadata().getContentType());\n                output =\
-    \ new File((String) options.valueOf(\"output-dir\") + File.separator + key);\n\
-    \                output.getParentFile().mkdirs();\n                if (!output.exists()\
-    \ || output.length() != object.getObjectMetadata().getContentLength()) {\n   \
-    \                 System.out.println(\"Downloading an S3 object from bucket: \"\
-    \ + bucket + \" with key: \" + key);\n                    BufferedInputStream\
-    \ reader = new BufferedInputStream(object.getObjectContent(), bufLen);\n     \
-    \               try {\n                        BufferedOutputStream writer = new\
-    \ BufferedOutputStream(new FileOutputStream(output), bufLen);\n              \
-    \          while (true) {\n                            int data = reader.read();\n\
-    \                            if (data == -1) {\n                             \
-    \   break;\n                            }\n                            writer.write(data);\n\
-    \                        }\n                        reader.close();\n        \
-    \                writer.close();\n                    } catch (FileNotFoundException\
-    \ e) {\n                        System.err.println(e.getMessage());\n        \
-    \            } catch (IOException e) {\n                        System.err.println(e.getMessage());\n\
-    \                    }\n                } else {\n                    System.out.println(\"\
-    Skipping download of S3 object from bucket: \" + bucket + \" with key: \" + key\
-    \ + \" since local output exists: \" + output.getAbsolutePath());\n          \
-    \      }\n            }\n        } else if (((String) options.valueOf(\"input-file\"\
-    )).startsWith(\"http://\") || ((String) options.valueOf(\"input-file\")).startsWith(\"\
-    https://\")) {\n            Pattern p = Pattern.compile(\"(https*)://(\\\\S+):(\\\
-    \\S+)@(\\\\S+)\");\n            Matcher m = p.matcher((String) options.valueOf(\"\
-    input-file\"));\n            boolean result = m.find();\n            String protocol\
-    \ = null;\n            String user = null;\n            String pass = null;\n\
-    \            String URL = (String) options.valueOf(\"input-file\");\n        \
-    \    if (result) {\n                protocol = m.group(1);\n                user\
-    \ = m.group(2);\n                pass = m.group(3);\n                URL = protocol\
-    \ + \"://\" + m.group(4);\n            }\n            URL urlObj = null;\n   \
-    \         try {\n                urlObj = new URL(URL);\n                if (urlObj\
-    \ != null) {\n                    URLConnection urlConn = urlObj.openConnection();\n\
-    \                    if (user != null && pass != null) {\n                   \
-    \     String userPassword = user + \":\" + pass;\n                        String\
-    \ encoding = new Base64().encodeBase64String(userPassword.getBytes());\n     \
-    \                   urlConn.setRequestProperty(\"Authorization\", \"Basic \" +\
-    \ encoding);\n                    }\n                    p = Pattern.compile(\"\
-    ://([^/]+)/(\\\\S+)\");\n                    m = p.matcher(URL);\n           \
-    \         result = m.find();\n                    if (result) {\n            \
-    \            String host = m.group(1);\n                        String path =\
-    \ m.group(2);\n                        output = new File((String) options.valueOf(\"\
-    output-dir\") + path);\n                        output.getParentFile().mkdirs();\n\
-    \                        if (!output.exists() || output.length() != urlConn.getContentLength())\
-    \ {\n                            System.out.println(\"Downloading an http object\
-    \ from URL: \" + URL);\n                            BufferedInputStream reader\
-    \ = new BufferedInputStream(urlConn.getInputStream(), bufLen);\n             \
-    \               BufferedOutputStream writer = new BufferedOutputStream(new FileOutputStream(output),\
-    \ bufLen);\n                            while (true) {\n                     \
-    \           int data = reader.read();\n                                if (data\
-    \ == -1) {\n                                    break;\n                     \
-    \           }\n                                writer.write(data);\n         \
-    \                   }\n                            reader.close();\n         \
-    \                   writer.close();\n                        } else {\n      \
-    \                      System.out.println(\"Skipping download of http object from\
-    \ URL: \" + URL + \" since local output exists: \" + output.getAbsolutePath());\n\
-    \                        }\n                    }\n                }\n       \
-    \     } catch (MalformedURLException e) {\n                System.err.println(e.getMessage());\n\
-    \            } catch (IOException e) {\n                System.err.println(e.getMessage());\n\
-    \            }\n        } else {\n            output = new File((String) options.valueOf(\"\
-    input-file\"));\n        }\n        boolean result = FileTools.unzipFile(output,\
-    \ new File((String) options.valueOf(\"output-dir\")));\n        if (!result) {\n\
-    \            ret.setStderr(\"Can't unzip software bundle \" + options.valueOf(\"\
-    input-file\") + \" to directory \" + options.valueOf(\"output-dir\"));\n     \
-    \       ret.setExitStatus(ReturnValue.RUNTIMEEXCEPTION);\n        }\n        return\
-    \ (ret);\n    }\n"
-  - "    public void writeConfigurationFile() throws IOException, ComponentException\
-    \ {\n        SystemConfig config = parent.getParentSystem().getConfiguration();\n\
-    \        File original = config.getLocation();\n        File backup = new File(original.getParentFile(),\
-    \ original.getName() + \".\" + System.currentTimeMillis());\n        FileInputStream\
-    \ in = new FileInputStream(original);\n        FileOutputStream out = new FileOutputStream(backup);\n\
-    \        byte[] buffer = new byte[2048];\n        try {\n            int bytesread\
-    \ = 0;\n            while ((bytesread = in.read(buffer)) > 0) {\n            \
-    \    out.write(buffer, 0, bytesread);\n            }\n        } catch (IOException\
-    \ e) {\n            logger.warn(\"Failed to copy backup of configuration file\"\
-    );\n            throw e;\n        } finally {\n            in.close();\n     \
-    \       out.close();\n        }\n        FileWriter replace = new FileWriter(original);\n\
-    \        replace.write(config.toFileFormat());\n        replace.close();\n   \
-    \     logger.info(\"Re-wrote configuration file \" + original.getPath());\n  \
-    \  }\n"
-  - "    @Override\n    protected void doGet(HttpServletRequest req, HttpServletResponse\
-    \ resp) throws ServletException, IOException {\n        resp.addHeader(\"Cache-Control\"\
-    , \"max-age=\" + Constants.HTTP_CACHE_SECONDS);\n        String uuid = req.getRequestURI().substring(req.getRequestURI().indexOf(Constants.SERVLET_FULL_PREFIX)\
-    \ + Constants.SERVLET_FULL_PREFIX.length() + 1);\n        boolean notScale = ClientUtils.toBoolean(req.getParameter(Constants.URL_PARAM_NOT_SCALE));\n\
-    \        ServletOutputStream os = resp.getOutputStream();\n        if (uuid !=\
-    \ null && !\"\".equals(uuid)) {\n            try {\n                String mimetype\
-    \ = fedoraAccess.getMimeTypeForStream(uuid, FedoraUtils.IMG_FULL_STREAM);\n  \
-    \              if (mimetype == null) {\n                    mimetype = \"image/jpeg\"\
-    ;\n                }\n                ImageMimeType loadFromMimeType = ImageMimeType.loadFromMimeType(mimetype);\n\
-    \                if (loadFromMimeType == ImageMimeType.JPEG || loadFromMimeType\
-    \ == ImageMimeType.PNG) {\n                    StringBuffer sb = new StringBuffer();\n\
-    \                    sb.append(config.getFedoraHost()).append(\"/objects/\").append(uuid).append(\"\
-    /datastreams/IMG_FULL/content\");\n                    InputStream is = RESTHelper.get(sb.toString(),\
-    \ config.getFedoraLogin(), config.getFedoraPassword(), false);\n             \
-    \       if (is == null) {\n                        return;\n                 \
-    \   }\n                    try {\n                        IOUtils.copyStreams(is,\
-    \ os);\n                    } catch (IOException e) {\n                      \
-    \  resp.setStatus(HttpURLConnection.HTTP_NOT_FOUND);\n                       \
-    \ LOGGER.error(\"Unable to open full image.\", e);\n                    } finally\
-    \ {\n                        os.flush();\n                        if (is != null)\
-    \ {\n                            try {\n                                is.close();\n\
-    \                            } catch (IOException e) {\n                     \
-    \           resp.setStatus(HttpURLConnection.HTTP_NOT_FOUND);\n              \
-    \                  LOGGER.error(\"Unable to close stream.\", e);\n           \
-    \                 } finally {\n                                is = null;\n  \
-    \                          }\n                        }\n                    }\n\
-    \                } else {\n                    Image rawImg = KrameriusImageSupport.readImage(uuid,\
-    \ FedoraUtils.IMG_FULL_STREAM, this.fedoraAccess, 0, loadFromMimeType);\n    \
-    \                BufferedImage scaled = null;\n                    if (!notScale)\
-    \ {\n                        scaled = KrameriusImageSupport.getSmallerImage(rawImg,\
-    \ 1250, 1000);\n                    } else {\n                        scaled =\
-    \ KrameriusImageSupport.getSmallerImage(rawImg, 2500, 2000);\n               \
-    \     }\n                    KrameriusImageSupport.writeImageToStream(scaled,\
-    \ \"JPG\", os);\n                    resp.setContentType(ImageMimeType.JPEG.getValue());\n\
-    \                    resp.setStatus(HttpURLConnection.HTTP_OK);\n            \
-    \    }\n            } catch (IOException e) {\n                resp.setStatus(HttpURLConnection.HTTP_NOT_FOUND);\n\
-    \                LOGGER.error(\"Unable to open full image.\", e);\n          \
-    \  } catch (XPathExpressionException e) {\n                resp.setStatus(HttpURLConnection.HTTP_NOT_FOUND);\n\
-    \                LOGGER.error(\"Unable to create XPath expression.\", e);\n  \
-    \          } finally {\n                os.flush();\n            }\n        }\n\
-    \    }\n"
-- source_sentence: "    public static boolean insert(final Cargo cargo) {\n      \
-    \  int result = 0;\n        final Connection c = DBConnection.getConnection();\n\
-    \        PreparedStatement pst = null;\n        if (c == null) {\n           \
-    \ return false;\n        }\n        try {\n            c.setAutoCommit(false);\n\
-    \            final String sql = \"insert into cargo (nome) values (?)\";\n   \
-    \         pst = c.prepareStatement(sql);\n            pst.setString(1, cargo.getNome());\n\
-    \            result = pst.executeUpdate();\n            c.commit();\n        }\
-    \ catch (final SQLException e) {\n            try {\n                c.rollback();\n\
-    \            } catch (final SQLException e1) {\n                e1.printStackTrace();\n\
-    \            }\n            System.out.println(\"[CargoDAO.insert] Erro ao inserir\
-    \ -> \" + e.getMessage());\n        } finally {\n            DBConnection.closePreparedStatement(pst);\n\
-    \            DBConnection.closeConnection(c);\n        }\n        if (result >\
-    \ 0) {\n            return true;\n        } else {\n            return false;\n\
-    \        }\n    }\n"
+  - |2
+        @Override
+        public ReturnValue do_run() {
+            int bufLen = 500 * 1024;
+            ReturnValue ret = new ReturnValue();
+            ret.setExitStatus(ReturnValue.SUCCESS);
+            File output = null;
+            if (((String) options.valueOf("input-file")).startsWith("s3://")) {
+                Pattern p = Pattern.compile("s3://(\\S+):(\\S+)@(\\S+)");
+                Matcher m = p.matcher((String) options.valueOf("input-file"));
+                boolean result = m.find();
+                String accessKey = null;
+                String secretKey = null;
+                String URL = (String) options.valueOf("input-file");
+                if (result) {
+                    accessKey = m.group(1);
+                    secretKey = m.group(2);
+                    URL = "s3://" + m.group(3);
+                } else {
+                    try {
+                        HashMap<String, String> settings = (HashMap<String, String>) ConfigTools.getSettings();
+                        accessKey = settings.get("AWS_ACCESS_KEY");
+                        secretKey = settings.get("AWS_SECRET_KEY");
+                    } catch (Exception e) {
+                        ret.setExitStatus(ReturnValue.SETTINGSFILENOTFOUND);
+                        ret.setProcessExitStatus(ReturnValue.SETTINGSFILENOTFOUND);
+                        return (ret);
+                    }
+                }
+                if (accessKey == null || secretKey == null) {
+                    ret.setExitStatus(ReturnValue.ENVVARNOTFOUND);
+                    ret.setProcessExitStatus(ReturnValue.ENVVARNOTFOUND);
+                    return (ret);
+                }
+                AmazonS3 s3 = new AmazonS3Client(new BasicAWSCredentials(accessKey, secretKey));
+                p = Pattern.compile("s3://([^/]+)/(\\S+)");
+                m = p.matcher(URL);
+                result = m.find();
+                if (result) {
+                    String bucket = m.group(1);
+                    String key = m.group(2);
+                    S3Object object = s3.getObject(new GetObjectRequest(bucket, key));
+                    System.out.println("Content-Type: " + object.getObjectMetadata().getContentType());
+                    output = new File((String) options.valueOf("output-dir") + File.separator + key);
+                    output.getParentFile().mkdirs();
+                    if (!output.exists() || output.length() != object.getObjectMetadata().getContentLength()) {
+                        System.out.println("Downloading an S3 object from bucket: " + bucket + " with key: " + key);
+                        BufferedInputStream reader = new BufferedInputStream(object.getObjectContent(), bufLen);
+                        try {
+                            BufferedOutputStream writer = new BufferedOutputStream(new FileOutputStream(output), bufLen);
+                            while (true) {
+                                int data = reader.read();
+                                if (data == -1) {
+                                    break;
+                                }
+                                writer.write(data);
+                            }
+                            reader.close();
+                            writer.close();
+                        } catch (FileNotFoundException e) {
+                            System.err.println(e.getMessage());
+                        } catch (IOException e) {
+                            System.err.println(e.getMessage());
+                        }
+                    } else {
+                        System.out.println("Skipping download of S3 object from bucket: " + bucket + " with key: " + key + " since local output exists: " + output.getAbsolutePath());
+                    }
+                }
+            } else if (((String) options.valueOf("input-file")).startsWith("http://") || ((String) options.valueOf("input-file")).startsWith("https://")) {
+                Pattern p = Pattern.compile("(https*)://(\\S+):(\\S+)@(\\S+)");
+                Matcher m = p.matcher((String) options.valueOf("input-file"));
+                boolean result = m.find();
+                String protocol = null;
+                String user = null;
+                String pass = null;
+                String URL = (String) options.valueOf("input-file");
+                if (result) {
+                    protocol = m.group(1);
+                    user = m.group(2);
+                    pass = m.group(3);
+                    URL = protocol + "://" + m.group(4);
+                }
+                URL urlObj = null;
+                try {
+                    urlObj = new URL(URL);
+                    if (urlObj != null) {
+                        URLConnection urlConn = urlObj.openConnection();
+                        if (user != null && pass != null) {
+                            String userPassword = user + ":" + pass;
+                            String encoding = new Base64().encodeBase64String(userPassword.getBytes());
+                            urlConn.setRequestProperty("Authorization", "Basic " + encoding);
+                        }
+                        p = Pattern.compile("://([^/]+)/(\\S+)");
+                        m = p.matcher(URL);
+                        result = m.find();
+                        if (result) {
+                            String host = m.group(1);
+                            String path = m.group(2);
+                            output = new File((String) options.valueOf("output-dir") + path);
+                            output.getParentFile().mkdirs();
+                            if (!output.exists() || output.length() != urlConn.getContentLength()) {
+                                System.out.println("Downloading an http object from URL: " + URL);
+                                BufferedInputStream reader = new BufferedInputStream(urlConn.getInputStream(), bufLen);
+                                BufferedOutputStream writer = new BufferedOutputStream(new FileOutputStream(output), bufLen);
+                                while (true) {
+                                    int data = reader.read();
+                                    if (data == -1) {
+                                        break;
+                                    }
+                                    writer.write(data);
+                                }
+                                reader.close();
+                                writer.close();
+                            } else {
+                                System.out.println("Skipping download of http object from URL: " + URL + " since local output exists: " + output.getAbsolutePath());
+                            }
+                        }
+                    }
+                } catch (MalformedURLException e) {
+                    System.err.println(e.getMessage());
+                } catch (IOException e) {
+                    System.err.println(e.getMessage());
+                }
+            } else {
+                output = new File((String) options.valueOf("input-file"));
+            }
+            boolean result = FileTools.unzipFile(output, new File((String) options.valueOf("output-dir")));
+            if (!result) {
+                ret.setStderr("Can't unzip software bundle " + options.valueOf("input-file") + " to directory " + options.valueOf("output-dir"));
+                ret.setExitStatus(ReturnValue.RUNTIMEEXCEPTION);
+            }
+            return (ret);
+        }
+  - |2
+        public void writeConfigurationFile() throws IOException, ComponentException {
+            SystemConfig config = parent.getParentSystem().getConfiguration();
+            File original = config.getLocation();
+            File backup = new File(original.getParentFile(), original.getName() + "." + System.currentTimeMillis());
+            FileInputStream in = new FileInputStream(original);
+            FileOutputStream out = new FileOutputStream(backup);
+            byte[] buffer = new byte[2048];
+            try {
+                int bytesread = 0;
+                while ((bytesread = in.read(buffer)) > 0) {
+                    out.write(buffer, 0, bytesread);
+                }
+            } catch (IOException e) {
+                logger.warn("Failed to copy backup of configuration file");
+                throw e;
+            } finally {
+                in.close();
+                out.close();
+            }
+            FileWriter replace = new FileWriter(original);
+            replace.write(config.toFileFormat());
+            replace.close();
+            logger.info("Re-wrote configuration file " + original.getPath());
+        }
+  - |2
+        @Override
+        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
+            resp.addHeader("Cache-Control", "max-age=" + Constants.HTTP_CACHE_SECONDS);
+            String uuid = req.getRequestURI().substring(req.getRequestURI().indexOf(Constants.SERVLET_FULL_PREFIX) + Constants.SERVLET_FULL_PREFIX.length() + 1);
+            boolean notScale = ClientUtils.toBoolean(req.getParameter(Constants.URL_PARAM_NOT_SCALE));
+            ServletOutputStream os = resp.getOutputStream();
+            if (uuid != null && !"".equals(uuid)) {
+                try {
+                    String mimetype = fedoraAccess.getMimeTypeForStream(uuid, FedoraUtils.IMG_FULL_STREAM);
+                    if (mimetype == null) {
+                        mimetype = "image/jpeg";
+                    }
+                    ImageMimeType loadFromMimeType = ImageMimeType.loadFromMimeType(mimetype);
+                    if (loadFromMimeType == ImageMimeType.JPEG || loadFromMimeType == ImageMimeType.PNG) {
+                        StringBuffer sb = new StringBuffer();
+                        sb.append(config.getFedoraHost()).append("/objects/").append(uuid).append("/datastreams/IMG_FULL/content");
+                        InputStream is = RESTHelper.get(sb.toString(), config.getFedoraLogin(), config.getFedoraPassword(), false);
+                        if (is == null) {
+                            return;
+                        }
+                        try {
+                            IOUtils.copyStreams(is, os);
+                        } catch (IOException e) {
+                            resp.setStatus(HttpURLConnection.HTTP_NOT_FOUND);
+                            LOGGER.error("Unable to open full image.", e);
+                        } finally {
+                            os.flush();
+                            if (is != null) {
+                                try {
+                                    is.close();
+                                } catch (IOException e) {
+                                    resp.setStatus(HttpURLConnection.HTTP_NOT_FOUND);
+                                    LOGGER.error("Unable to close stream.", e);
+                                } finally {
+                                    is = null;
+                                }
+                            }
+                        }
+                    } else {
+                        Image rawImg = KrameriusImageSupport.readImage(uuid, FedoraUtils.IMG_FULL_STREAM, this.fedoraAccess, 0, loadFromMimeType);
+                        BufferedImage scaled = null;
+                        if (!notScale) {
+                            scaled = KrameriusImageSupport.getSmallerImage(rawImg, 1250, 1000);
+                        } else {
+                            scaled = KrameriusImageSupport.getSmallerImage(rawImg, 2500, 2000);
+                        }
+                        KrameriusImageSupport.writeImageToStream(scaled, "JPG", os);
+                        resp.setContentType(ImageMimeType.JPEG.getValue());
+                        resp.setStatus(HttpURLConnection.HTTP_OK);
+                    }
+                } catch (IOException e) {
+                    resp.setStatus(HttpURLConnection.HTTP_NOT_FOUND);
+                    LOGGER.error("Unable to open full image.", e);
+                } catch (XPathExpressionException e) {
+                    resp.setStatus(HttpURLConnection.HTTP_NOT_FOUND);
+                    LOGGER.error("Unable to create XPath expression.", e);
+                } finally {
+                    os.flush();
+                }
+            }
+        }
+- source_sentence: |2
+        public static boolean insert(final Cargo cargo) {
+            int result = 0;
+            final Connection c = DBConnection.getConnection();
+            PreparedStatement pst = null;
+            if (c == null) {
+                return false;
+            }
+            try {
+                c.setAutoCommit(false);
+                final String sql = "insert into cargo (nome) values (?)";
+                pst = c.prepareStatement(sql);
+                pst.setString(1, cargo.getNome());
+                result = pst.executeUpdate();
+                c.commit();
+            } catch (final SQLException e) {
+                try {
+                    c.rollback();
+                } catch (final SQLException e1) {
+                    e1.printStackTrace();
+                }
+                System.out.println("[CargoDAO.insert] Erro ao inserir -> " + e.getMessage());
+            } finally {
+                DBConnection.closePreparedStatement(pst);
+                DBConnection.closeConnection(c);
+            }
+            if (result > 0) {
+                return true;
+            } else {
+                return false;
+            }
+        }
   sentences:
-  - "    public String md5sum(String toCompute) throws Exception {\n        MessageDigest\
-    \ md = MessageDigest.getInstance(\"MD5\");\n        md.update(toCompute.getBytes());\n\
-    \        java.math.BigInteger hash = new java.math.BigInteger(1, md.digest());\n\
-    \        return hash.toString(16);\n    }\n"
-  - "    protected void runTest(URL pBaseURL, String pName, String pHref) throws Exception\
-    \ {\n        URL url = new URL(pBaseURL, pHref);\n        XSParser parser = new\
-    \ XSParser();\n        parser.setValidating(false);\n        InputSource isource\
-    \ = new InputSource(url.openStream());\n        isource.setSystemId(url.toString());\n\
-    \        String result;\n        try {\n            parser.parse(isource);\n \
-    \           ++numOk;\n            result = \"Ok\";\n        } catch (Exception\
-    \ e) {\n            ++numFailed;\n            result = e.getMessage();\n     \
-    \   }\n        log(\"Running test \" + pName + \" with URL \" + url + \": \" +\
-    \ result);\n    }\n"
-  - "    public String generateMappackMD5(File mapPackFile) throws IOException, NoSuchAlgorithmException\
-    \ {\n        ZipFile zip = new ZipFile(mapPackFile);\n        try {\n        \
-    \    Enumeration<? extends ZipEntry> entries = zip.entries();\n            MessageDigest\
-    \ md5Total = MessageDigest.getInstance(\"MD5\");\n            MessageDigest md5\
-    \ = MessageDigest.getInstance(\"MD5\");\n            while (entries.hasMoreElements())\
-    \ {\n                ZipEntry entry = entries.nextElement();\n               \
-    \ if (entry.isDirectory()) continue;\n                String name = entry.getName();\n\
-    \                if (name.toUpperCase().startsWith(\"META-INF\")) continue;\n\
-    \                md5.reset();\n                InputStream in = zip.getInputStream(entry);\n\
-    \                byte[] data = Utilities.getInputBytes(in);\n                in.close();\n\
-    \                byte[] digest = md5.digest(data);\n                log.trace(\"\
-    Hashsum \" + Hex.encodeHexString(digest) + \" includes \\\"\" + name + \"\\\"\"\
-    );\n                md5Total.update(digest);\n                md5Total.update(name.getBytes());\n\
-    \            }\n            String md5sum = Hex.encodeHexString(md5Total.digest());\n\
-    \            log.trace(\"md5sum of \" + mapPackFile.getName() + \": \" + md5sum);\n\
-    \            return md5sum;\n        } finally {\n            zip.close();\n \
-    \       }\n    }\n"
+  - |2
+        public String md5sum(String toCompute) throws Exception {
+            MessageDigest md = MessageDigest.getInstance("MD5");
+            md.update(toCompute.getBytes());
+            java.math.BigInteger hash = new java.math.BigInteger(1, md.digest());
+            return hash.toString(16);
+        }
+  - |2
+        protected void runTest(URL pBaseURL, String pName, String pHref) throws Exception {
+            URL url = new URL(pBaseURL, pHref);
+            XSParser parser = new XSParser();
+            parser.setValidating(false);
+            InputSource isource = new InputSource(url.openStream());
+            isource.setSystemId(url.toString());
+            String result;
+            try {
+                parser.parse(isource);
+                ++numOk;
+                result = "Ok";
+            } catch (Exception e) {
+                ++numFailed;
+                result = e.getMessage();
+            }
+            log("Running test " + pName + " with URL " + url + ": " + result);
+        }
+  - |2
+        public String generateMappackMD5(File mapPackFile) throws IOException, NoSuchAlgorithmException {
+            ZipFile zip = new ZipFile(mapPackFile);
+            try {
+                Enumeration<? extends ZipEntry> entries = zip.entries();
+                MessageDigest md5Total = MessageDigest.getInstance("MD5");
+                MessageDigest md5 = MessageDigest.getInstance("MD5");
+                while (entries.hasMoreElements()) {
+                    ZipEntry entry = entries.nextElement();
+                    if (entry.isDirectory()) continue;
+                    String name = entry.getName();
+                    if (name.toUpperCase().startsWith("META-INF")) continue;
+                    md5.reset();
+                    InputStream in = zip.getInputStream(entry);
+                    byte[] data = Utilities.getInputBytes(in);
+                    in.close();
+                    byte[] digest = md5.digest(data);
+                    log.trace("Hashsum " + Hex.encodeHexString(digest) + " includes \"" + name + "\"");
+                    md5Total.update(digest);
+                    md5Total.update(name.getBytes());
+                }
+                String md5sum = Hex.encodeHexString(md5Total.digest());
+                log.trace("md5sum of " + mapPackFile.getName() + ": " + md5sum);
+                return md5sum;
+            } finally {
+                zip.close();
+            }
+        }
 pipeline_tag: sentence-similarity
 library_name: sentence-transformers
 metrics:
@@ -397,6 +683,7 @@ model-index:
     - type: spearman_cosine
       value: 0.5635084463158045
       name: Spearman Cosine
+license: c-uda
 ---
 
 # SentenceTransformer based on Shuu12121/CodeModernBERT-Owl