Input:
private static boolean sendMessage(String url, String filename) {
    int returnStatus = HttpStatus.SC_CREATED;
    HttpClient httpclient = new HttpClient();
    HttpConnectionManager connectionManager = httpclient.getHttpConnectionManager();
    connectionManager.getParams().setSoTimeout(120000);
    PostMethod httpPost = new PostMethod(url);
    RequestEntity requestEntity = null;
    try {
        FileInputStream message = new FileInputStream(filename);
        Base64InputStream message64 = new Base64InputStream(message, true, -1, null);
        requestEntity = new InputStreamRequestEntity(message64, "String_Node_Str");
    } catch (FileNotFoundException e) {
        Logger.getLogger(CpadDataExtract.class.getName()).log(Level.SEVERE, "String_Node_Str", e);
    }
    httpPost.setRequestEntity(requestEntity);
    try {
        httpclient.executeMethod(httpPost);
        returnStatus = httpPost.getStatusCode();
    } catch (SocketTimeoutException e) {
        returnStatus = HttpStatus.SC_REQUEST_TIMEOUT;
        Logger.getLogger(CpadDataExtract.class.getName()).log(Level.SEVERE, "String_Node_Str", e);
    } catch (HttpException e) {
        returnStatus = HttpStatus.SC_INTERNAL_SERVER_ERROR;
        Logger.getLogger(CpadDataExtract.class.getName()).log(Level.SEVERE, "String_Node_Str", e);
    } catch (ConnectException e) {
        returnStatus = HttpStatus.SC_SERVICE_UNAVAILABLE;
        Logger.getLogger(CpadDataExtract.class.getName()).log(Level.SEVERE, "String_Node_Str", e);
    } catch (UnknownHostException e) {
        returnStatus = HttpStatus.SC_NOT_FOUND;
        Logger.getLogger(CpadDataExtract.class.getName()).log(Level.SEVERE, "String_Node_Str", e);
    } catch (IOException e) {
        returnStatus = HttpStatus.SC_GATEWAY_TIMEOUT;
        Logger.getLogger(CpadDataExtract.class.getName()).log(Level.SEVERE, "String_Node_Str", e);
    } finally {
        httpPost.releaseConnection();
    }
    return returnStatus == HttpStatus.SC_OK;
}

Output:
     } catch (FileNotFoundException e) {
-        Logger.getLogger(CpadDataExtract.class.getName()).log(Level.SEVERE, "String_Node_Str", e);
+        Mediator.getLogger(CpadDataExtract.class.getName()).log(Level.SEVERE, "String_Node_Str", e);
     }


Input:
public static boolean createPath(FileSystem fileSystem, Path path) throws IOException {
    if (!fileSystem.exists(path)) {
        LOG.info("String_Node_Str", path);
        fileSystem.mkdirs(path);
        return false;
    }
    return true;
}

Output:
         LOG.info("String_Node_Str", path);
-        fileSystem.mkdirs(path);
+        if (!fileSystem.mkdirs(path)) {
+            LOG.error("String_Node_Str", path);
+            throw new IOException("String_Node_Str");
+        }
         return false;


Input:
public static RealMatrix createOrthogonalMatrix(final Random r, final int size) {
    final double[][] data = new double[size][size];
    for (int i = 0; i < size; ++i) {
        final double[] dataI = data[i];
        double norm2 = 0;
        do {
            for (int j = 0; j < size; ++j) {
                dataI[j] = 2 * r.nextDouble() - 1;
            }
            for (int k = 0; k < i; ++k) {
                final double[] dataK = data[k];
                double dotProduct = 0;
                for (int j = 0; j < size; ++j) {
                    dotProduct += dataI[j] * dataK[j];
                }
                for (int j = 0; j < size; ++j) {
                    dataI[j] -= dotProduct * dataK[j];
                }
            }
            norm2 = 0;
            for (final double dataIJ : dataI) {
                norm2 += dataIJ * dataIJ;
            }
            final double inv = 1.0 / Math.sqrt(norm2);
            for (int j = 0; j < size; ++j) {
                dataI[j] *= inv;
            }
        } while (norm2 * size < 0.01);
    }
    return new RealMatrixImpl(data, false);
}

Output:
     }
-    return new RealMatrixImpl(data, false);
+    return MatrixUtils.createRealMatrix(data);
 }


Input:
private boolean generateAztecBinary() {
    int i, j, k, bytes;
    int curtable, newtable, lasttable, chartype, maplength, blocks;
    int[] charmap = new int[2 * inputBytes.length];
    int[] typemap = new int[2 * inputBytes.length];
    int[] blockType = new int[inputBytes.length + 1];
    int[] blockLength = new int[inputBytes.length + 1];
    int weight;
    maplength = 0;
    if (inputDataType == DataType.GS1) {
        charmap[maplength] = 0;
        typemap[maplength++] = 8;
        charmap[maplength] = 400;
        typemap[maplength++] = 8;
    }
    if ((inputDataType == DataType.ECI) && (eciMode != 3)) {
        int flagNumber = 6;
        if (eciMode < 100000) {
            flagNumber = 5;
        }
        if (eciMode < 10000) {
            flagNumber = 4;
        }
        if (eciMode < 1000) {
            flagNumber = 3;
        }
        if (eciMode < 100) {
            flagNumber = 2;
        }
        if (eciMode < 10) {
            flagNumber = 1;
        }
        charmap[maplength] = 0;
        typemap[maplength++] = 8;
        charmap[maplength] = 400 + flagNumber;
        typemap[maplength++] = 8;
    }
    for (i = 0; i < inputBytes.length; i++) {
        if ((inputDataType == DataType.GS1) && ((inputBytes[i] & 0xFF) == '[')) {
            charmap[maplength] = 0;
            typemap[maplength++] = 8;
            charmap[maplength] = 400;
            typemap[maplength++] = 8;
        } else {
            if ((inputBytes[i] & 0xFF) > 0x7F) {
                charmap[maplength] = (inputBytes[i] & 0xFF);
                typemap[maplength++] = 32;
            } else {
                charmap[maplength] = AztecSymbolChar[(inputBytes[i] & 0xFF)];
                typemap[maplength++] = AztecCodeSet[(inputBytes[i] & 0xFF)];
            }
        }
    }
    i = 0;
    do {
        if (((charmap[i] == 300) && (charmap[i + 1] == 11)) && ((typemap[i] == 8) && (typemap[i + 1] == 8))) {
            charmap[i] = 2;
            typemap[i] = 8;
            for (j = i + 1; j < maplength; j++) {
                charmap[i + j] = charmap[i + j + 1];
                typemap[i + j] = typemap[i + j + 1];
            }
            maplength--;
        }
        if (((charmap[i] == 302) && (charmap[i + 1] == 1)) && ((typemap[i] == 24) && (typemap[i + 1] == 23))) {
            charmap[i] = 3;
            typemap[i] = 8;
            for (j = i + 1; j < maplength; j++) {
                charmap[i + j] = charmap[i + j + 1];
                typemap[i + j] = typemap[i + j + 1];
            }
            maplength--;
        }
        if (((charmap[i] == 301) && (charmap[i + 1] == 1)) && ((typemap[i] == 24) && (typemap[i + 1] == 23))) {
            charmap[i] = 4;
            typemap[i] = 8;
            for (j = i + 1; j < maplength; j++) {
                charmap[i + j] = charmap[i + j + 1];
                typemap[i + j] = typemap[i + j + 1];
            }
            maplength--;
        }
        if (((charmap[i] == 21) && (charmap[i + 1] == 1)) && ((typemap[i] == 8) && (typemap[i + 1] == 23))) {
            charmap[i] = 5;
            typemap[i] = 8;
            for (j = i + 1; j < maplength; j++) {
                charmap[i + j] = charmap[i + j + 1];
                typemap[i + j] = typemap[i + j + 1];
            }
            maplength--;
        }
        i++;
    } while (i < (maplength - 1));
    blocks = 1;
    blockType[0] = typemap[0];
    blockLength[0] = 1;
    for (i = 1; i < maplength; i++) {
        if (typemap[i] == typemap[i - 1]) {
            blockLength[blocks - 1]++;
        } else {
            blocks++;
            blockType[blocks - 1] = typemap[i];
            blockLength[blocks - 1] = 1;
        }
    }
    if ((blockType[0] & 1) != 0) {
        blockType[0] = 1;
    }
    if ((blockType[0] & 2) != 0) {
        blockType[0] = 2;
    }
    if ((blockType[0] & 4) != 0) {
        blockType[0] = 4;
    }
    if ((blockType[0] & 8) != 0) {
        blockType[0] = 8;
    }
    if (blocks > 1) {
        for (i = 1; i < blocks; i++) {
            if ((blockType[i] & blockType[i - 1]) != 0) {
                blockType[i] = (blockType[i] & blockType[i - 1]);
            }
        }
        if ((blockType[blocks - 1] & 1) != 0) {
            blockType[blocks - 1] = 1;
        }
        if ((blockType[blocks - 1] & 2) != 0) {
            blockType[blocks - 1] = 2;
        }
        if ((blockType[blocks - 1] & 4) != 0) {
            blockType[blocks - 1] = 4;
        }
        if ((blockType[blocks - 1] & 8) != 0) {
            blockType[blocks - 1] = 8;
        }
        for (i = blocks - 2; i > 0; i--) {
            if ((blockType[i] & blockType[i + 1]) != 0) {
                blockType[i] = (blockType[i] & blockType[i + 1]);
            }
        }
        for (i = 1; i < blocks; i++) {
            if ((blockType[i] & 8) != 0) {
                blockType[i] = 8;
            }
            if ((blockType[i] & 4) != 0) {
                blockType[i] = 4;
            }
            if ((blockType[i] & 2) != 0) {
                blockType[i] = 2;
            }
            if ((blockType[i] & 1) != 0) {
                blockType[i] = 1;
            }
        }
        i = 0;
        do {
            if (blockType[i] == blockType[i + 1]) {
                blockLength[i] += blockLength[i + 1];
                for (j = i + 1; j < blocks - 1; j++) {
                    blockType[j] = blockType[j + 1];
                    blockLength[j] = blockLength[j + 1];
                }
                blocks--;
            } else {
                i++;
            }
        } while (i < blocks - 1);
    }
    j = 0;
    for (i = 0; i < blocks; i++) {
        if ((blockLength[i] < 3) && (blockType[i] != 32)) {
            for (k = 0; k < blockLength[i]; k++) {
                typemap[j + k] = blockType[i] + 64;
            }
        } else {
            for (k = 0; k < blockLength[i]; k++) {
                typemap[j + k] = blockType[i];
            }
        }
        j += blockLength[i];
    }
    if (typemap[0] == 65) {
        typemap[0] = 1;
    }
    for (i = 0; i < maplength; i++) {
        if ((charmap[i] >= 300) && (charmap[i] < 400)) {
            curtable = typemap[i];
            if (curtable > 64) {
                curtable -= 64;
            }
            switch(charmap[i]) {
                case 300:
                    switch(curtable) {
                        case 8:
                            charmap[i] = 1;
                            break;
                        case 4:
                            charmap[i] = 14;
                            break;
                    }
                    break;
                case 301:
                    switch(curtable) {
                        case 8:
                            charmap[i] = 17;
                            break;
                        case 16:
                            charmap[i] = 12;
                            break;
                    }
                    break;
                case 302:
                    switch(curtable) {
                        case 8:
                            charmap[i] = 19;
                            break;
                        case 16:
                            charmap[i] = 13;
                            break;
                    }
                    break;
            }
        }
    }
    binary_string = "String_Node_Str";
    if (debug) {
        System.out.print("String_Node_Str");
    }
    curtable = 1;
    lasttable = 1;
    for (i = 0; i < maplength; i++) {
        newtable = curtable;
        if ((typemap[i] != curtable) && (charmap[i] < 400)) {
            if (curtable == 3) {
                curtable = lasttable;
                newtable = lasttable;
            }
            if (typemap[i] > 64) {
                switch(typemap[i]) {
                    case (64 + 1):
                        switch(curtable) {
                            case 2:
                                binary_string += pentbit[28];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                break;
                            case 4:
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 1;
                                break;
                            case 8:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 1;
                                break;
                            case 16:
                                binary_string += quadbit[15];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                break;
                        }
                        break;
                    case (64 + 2):
                        switch(curtable) {
                            case 1:
                                binary_string += pentbit[28];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 2;
                                break;
                            case 4:
                                binary_string += pentbit[28];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 2;
                                break;
                            case 8:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[28];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 2;
                                break;
                            case 16:
                                binary_string += quadbit[14];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[28];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 2;
                                break;
                        }
                        break;
                    case (64 + 4):
                        switch(curtable) {
                            case 1:
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 4;
                                break;
                            case 2:
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 4;
                                break;
                            case 8:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 4;
                                break;
                            case 16:
                                binary_string += quadbit[14];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 4;
                                break;
                        }
                        break;
                    case (64 + 8):
                        switch(curtable) {
                            case 1:
                                binary_string += pentbit[0];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                break;
                            case 2:
                                binary_string += pentbit[0];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                break;
                            case 4:
                                binary_string += pentbit[0];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                break;
                            case 16:
                                binary_string += quadbit[0];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                break;
                        }
                        break;
                    case (64 + 16):
                        switch(curtable) {
                            case 1:
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 16;
                                break;
                            case 2:
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 16;
                                break;
                            case 4:
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 16;
                                break;
                            case 8:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 16;
                                break;
                        }
                        break;
                }
            } else {
                switch(typemap[i]) {
                    case 1:
                        switch(curtable) {
                            case 2:
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 1;
                                break;
                            case 4:
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 1;
                                break;
                            case 8:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 1;
                                break;
                            case 16:
                                binary_string += quadbit[14];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 1;
                                break;
                        }
                        break;
                    case 2:
                        switch(curtable) {
                            case 1:
                                binary_string += pentbit[28];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 2;
                                break;
                            case 4:
                                binary_string += pentbit[28];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 2;
                                break;
                            case 8:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[28];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 2;
                                break;
                            case 16:
                                binary_string += quadbit[14];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[28];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 2;
                                break;
                        }
                        break;
                    case 4:
                        switch(curtable) {
                            case 1:
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 4;
                                break;
                            case 2:
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 4;
                                break;
                            case 8:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 4;
                                break;
                            case 16:
                                binary_string += quadbit[14];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 4;
                                break;
                        }
                        break;
                    case 8:
                        switch(curtable) {
                            case 1:
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 8;
                                break;
                            case 2:
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 8;
                                break;
                            case 4:
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 8;
                                break;
                            case 16:
                                binary_string += quadbit[14];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 8;
                                break;
                        }
                        break;
                    case 16:
                        switch(curtable) {
                            case 1:
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 16;
                                break;
                            case 2:
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 16;
                                break;
                            case 4:
                                binary_string += pentbit[29];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 16;
                                break;
                            case 8:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[30];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 16;
                                break;
                        }
                        break;
                    case 32:
                        lasttable = curtable;
                        switch(curtable) {
                            case 1:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 3;
                                break;
                            case 2:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 3;
                                break;
                            case 4:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 3;
                                break;
                            case 8:
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 3;
                                break;
                            case 16:
                                binary_string += quadbit[14];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                binary_string += pentbit[31];
                                if (debug) {
                                    System.out.printf("String_Node_Str");
                                }
                                newtable = 3;
                                break;
                        }
                        bytes = 0;
                        do {
                            bytes++;
                        } while (typemap[i + (bytes - 1)] == 32);
                        bytes--;
                        if (bytes > 2079) {
                            error_msg = "String_Node_Str";
                            return false;
                        }
                        if (bytes > 31) {
                            binary_string += "String_Node_Str";
                            for (weight = 0x400; weight > 0; weight = weight >> 1) {
                                if (((bytes - 31) & weight) != 0) {
                                    binary_string += "String_Node_Str";
                                } else {
                                    binary_string += "String_Node_Str";
                                }
                            }
                        } else {
                            for (weight = 0x10; weight > 0; weight = weight >> 1) {
                                if ((bytes & weight) != 0) {
                                    binary_string += "String_Node_Str";
                                } else {
                                    binary_string += "String_Node_Str";
                                }
                            }
                        }
                        if (debug) {
                            System.out.printf("String_Node_Str", bytes);
                        }
                        break;
                }
            }
        }
        curtable = newtable;
        chartype = typemap[i];
        if (chartype > 64) {
            chartype -= 64;
        }
        switch(chartype) {
            case 1:
            case 2:
            case 4:
            case 8:
                if (charmap[i] >= 400) {
                    if (debug) {
                        System.out.printf("String_Node_Str", charmap[i] - 400);
                    }
                    binary_string += tribit[charmap[i] - 400];
                    if (charmap[i] != 400) {
                        binary_string += eciToBinary();
                    }
                } else {
                    binary_string += pentbit[charmap[i]];
                    if (!((chartype == 8) && (charmap[i] == 0))) {
                        if (debug) {
                            System.out.printf("String_Node_Str", charmap[i]);
                        }
                    }
                }
                break;
            case 16:
                binary_string += quadbit[charmap[i]];
                if (debug) {
                    System.out.printf("String_Node_Str", charmap[i]);
                }
                break;
            case 32:
                for (weight = 0x80; weight > 0; weight = weight >> 1) {
                    if ((charmap[i] & weight) != 0) {
                        binary_string += "String_Node_Str";
                    } else {
                        binary_string += "String_Node_Str";
                    }
                }
                if (debug) {
                    System.out.printf("String_Node_Str", charmap[i]);
                }
                break;
        }
    }
    if (debug) {
        System.out.printf("String_Node_Str");
    }
    return true;
}

Output:
         if ((typemap[i] != curtable) && (charmap[i] < 400)) {
-            if (curtable == 3) {
+            if (curtable == 32) {
                 curtable = lasttable;


Input:
public Resource transform(byte[] source, FhirFormat cntType, String mapUri) throws Exception {
    StructureMapUtilities scu = new StructureMapUtilities(context);
    return null;
}

Output:
     StructureMapUtilities scu = new StructureMapUtilities(context);
-    return null;
+    org.hl7.fhir.r4.elementmodel.Element src = Manager.parse(context, new ByteArrayInputStream(source), cntType);
+    StructureMap map = scu.getLibrary().get(mapUri);
+    if (map == null)
+        throw new Error("String_Node_Str" + mapUri);
+    Resource dst = ResourceFactory.createResource("String_Node_Str");
+    scu.transform(null, src, map, dst);
+    return dst;
 }


Input:
private void refreshCursorLabel() {
    double f1 = graphView.getCursorX();
    freq2Cent(sCent, f1, "String_Node_Str");
    ((TextView) findViewById(R.id.textview_cur)).setText("String_Node_Str" + dfFreq.format(f1) + "String_Node_Str" + sCent + "String_Node_Str" + dfDB.format(graphView.getCursorY()) + "String_Node_Str");
}

Output:
     double f1 = graphView.getCursorX();
-    freq2Cent(sCent, f1, "String_Node_Str");
-    ((TextView) findViewById(R.id.textview_cur)).setText("String_Node_Str" + dfFreq.format(f1) + "String_Node_Str" + sCent + "String_Node_Str" + dfDB.format(graphView.getCursorY()) + "String_Node_Str");
+    textCur.setLength(0);
+    textCur.append("String_Node_Str");
+    SBNumFormat.fillInNumFixedWidthPositive(textCur, f1, 5, 1);
+    textCur.append("String_Node_Str");
+    freq2Cent(textCur, f1, "String_Node_Str");
+    textCur.append("String_Node_Str");
+    SBNumFormat.fillInNumFixedWidth(textCur, graphView.getCursorY(), 3, 1);
+    textCur.append("String_Node_Str");
+    textCur.getChars(0, Math.min(textCur.length(), textCurChar.length), textCurChar, 0);
+    ((TextView) findViewById(R.id.textview_cur)).setText(textCurChar, 0, Math.min(textCur.length(), textCurChar.length));
 }


Input:
public static String getNotBlankTestMethodSource(MethodInfo testMethod, ClassInfo testClassinfo, String testTargetClassname) {
    PreferenceLoader pref = new PreferenceLoader();
    StringBuilder sb = new StringBuilder();
    String CRLF = StrConst.carriageReturn + StrConst.lineFeed;
    if (pref.isTestMethodGenEnabledSupportJMock2) {
        if (pref.isUsingJUnitHelperRuntime) {
            if (pref.isJUnitVersion4) {
                sb.append("String_Node_Str");
                sb.append("String_Node_Str");
                sb.append(CRLF);
            }
        } else {
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(CRLF);
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(CRLF);
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(CRLF);
        }
    }
    if (pref.isTestMethodGenEnabledSupportEasyMock) {
        sb.append("String_Node_Str");
        sb.append("String_Node_Str");
        sb.append(CRLF);
    }
    sb.append("String_Node_Str");
    String returnTypeName = testMethod.returnType.name;
    Object returnDefaultValue = null;
    if (!returnTypeName.equals("String_Node_Str")) {
        returnTypeName = returnTypeName.replaceAll(RegExp.generics, StrConst.empty);
        returnTypeName = getClassInSourceCode(returnTypeName, testTargetClassname, testClassinfo.importList);
        List<String> generics = testMethod.returnType.generics;
        int genericsLen = generics.size();
        if (genericsLen > 0) {
            returnTypeName += "String_Node_Str" + generics.get(0);
            for (int i = 1; i < genericsLen; i++) {
                returnTypeName += StrConst.comma + generics.get(i);
            }
            returnTypeName += "String_Node_Str";
        }
        if (PrimitiveTypeUtil.isPrimitive(returnTypeName)) {
            returnDefaultValue = PrimitiveTypeUtil.getTypeDefaultValue(returnTypeName);
        }
    }
    if (!testMethod.isStatic) {
        if (testClassinfo.constructors != null && testClassinfo.constructors.size() > 0) {
            ConstructorInfo constructor = testClassinfo.constructors.get(0);
            List<String> args = new ArrayList<String>();
            for (int i = 0; i < constructor.argNames.size(); i++) {
                ArgType argType = constructor.argTypes.get(i);
                sb.append(argType.name);
                sb.append("String_Node_Str");
                sb.append(constructor.argNames.get(i));
                sb.append("String_Node_Str");
                if (PrimitiveTypeUtil.isPrimitive(argType.name)) {
                    String primitiveDefault = PrimitiveTypeUtil.getTypeDefaultValue(argType.name);
                    sb.append(primitiveDefault);
                } else {
                    sb.append("String_Node_Str");
                }
                sb.append("String_Node_Str");
                sb.append(CRLF);
                sb.append("String_Node_Str");
                args.add(constructor.argNames.get(i));
            }
            sb.append(testTargetClassname);
            sb.append("String_Node_Str");
            sb.append(testTargetClassname);
            sb.append("String_Node_Str");
            sb.append(args.get(0));
            for (int i = 1; i < args.size(); i++) {
                sb.append("String_Node_Str");
                sb.append(args.get(i));
            }
            sb.append("String_Node_Str");
        } else {
            sb.append(testTargetClassname);
            sb.append("String_Node_Str");
            sb.append(testTargetClassname);
            sb.append("String_Node_Str");
        }
        sb.append(CRLF);
        sb.append("String_Node_Str");
    }
    if (pref.isTestMethodGenEnabledSupportMockito) {
        sb.append("String_Node_Str");
        sb.append(CRLF);
        sb.append("String_Node_Str");
    }
    List<ArgType> argTypes = testMethod.argTypes;
    List<String> argNames = testMethod.argNames;
    List<String> args = new ArrayList<String>();
    int argTypesLen = argTypes.size();
    if (argTypesLen > 0 && argTypes.get(0).name != null && !argTypes.get(0).name.equals(StrConst.empty)) {
        for (int i = 0; i < argTypesLen; i++) {
            ArgType argType = argTypes.get(i);
            if (argType.name.matches("String_Node_Str"))
                argType.name = argType.name.replaceAll("String_Node_Str", "String_Node_Str");
            String argTypeName = getClassInSourceCode(argType.name, testTargetClassname, testClassinfo.importList);
            boolean isJMock2 = pref.isTestMethodGenEnabledSupportJMock2 && MockGenUtil.isMockableClassName(argTypeName, testClassinfo.importList);
            boolean isEasyMock = pref.isTestMethodGenEnabledSupportEasyMock && MockGenUtil.isMockableClassName(argTypeName, testClassinfo.importList);
            boolean isMockito = pref.isTestMethodGenEnabledSupportMockito && MockGenUtil.isMockableClassName(argTypeName, testClassinfo.importList);
            if (isJMock2) {
                sb.append("String_Node_Str");
            }
            sb.append(argTypeName);
            if (argType.generics.size() > 0) {
                sb.append("String_Node_Str");
                sb.append(argType.generics.get(0));
                if (argType.generics.size() > 1) {
                    for (int j = 1; j < argType.generics.size(); j++) {
                        sb.append(StrConst.comma);
                        sb.append(argType.generics.get(j));
                    }
                }
                sb.append("String_Node_Str");
            }
            String argName = argNames.get(i);
            if (argName == null || argName.length() == 0) {
                argName = "String_Node_Str" + i;
            }
            sb.append("String_Node_Str");
            sb.append(argName);
            sb.append("String_Node_Str");
            if (PrimitiveTypeUtil.isPrimitive(argType.name)) {
                String primitiveDefault = PrimitiveTypeUtil.getTypeDefaultValue(argType.name);
                sb.append(primitiveDefault);
            } else {
                if (isJMock2) {
                    sb.append(pref.isUsingJUnitHelperRuntime ? "String_Node_Str" : "String_Node_Str");
                    sb.append("String_Node_Str");
                    sb.append(argTypeName);
                    sb.append("String_Node_Str");
                } else if (isEasyMock) {
                    sb.append("String_Node_Str");
                    sb.append(argTypeName);
                    sb.append("String_Node_Str");
                } else if (isMockito) {
                    sb.append("String_Node_Str");
                    sb.append(argTypeName);
                    sb.append("String_Node_Str");
                } else {
                    sb.append("String_Node_Str");
                }
            }
            sb.append("String_Node_Str");
            sb.append(CRLF);
            sb.append("String_Node_Str");
            args.add(argName);
        }
    }
    if (pref.isTestMethodGenEnabledSupportJMock2) {
        sb.append(pref.isUsingJUnitHelperRuntime ? "String_Node_Str" : "String_Node_Str");
        sb.append("String_Node_Str");
        sb.append(CRLF);
        sb.append("String_Node_Str");
        sb.append("String_Node_Str");
        sb.append(CRLF);
        sb.append("String_Node_Str");
        sb.append(CRLF);
        sb.append("String_Node_Str");
    }
    if (pref.isTestMethodGenEnabledSupportEasyMock) {
        sb.append("String_Node_Str");
        sb.append("String_Node_Str");
        sb.append(CRLF);
        sb.append("String_Node_Str");
        sb.append(CRLF);
        sb.append("String_Node_Str");
    }
    if (pref.isTestMethodGenEnabledSupportMockito) {
        sb.append("String_Node_Str");
        sb.append(CRLF);
        sb.append("String_Node_Str");
        sb.append(CRLF);
        sb.append("String_Node_Str");
    }
    if (pref.isTestMethodGenExceptions && testMethod.testingTargetException != null) {
        sb.append("String_Node_Str");
        sb.append(CRLF);
        sb.append("String_Node_Str");
    }
    if (!returnTypeName.equals("String_Node_Str")) {
        sb.append(returnTypeName);
        sb.append("String_Node_Str");
    }
    if (testMethod.isStatic) {
        sb.append(testTargetClassname);
    } else {
        sb.append("String_Node_Str");
    }
    sb.append(StrConst.dot);
    sb.append(testMethod.methodName);
    sb.append("String_Node_Str");
    if (args.size() > 0 && argTypesLen > 0 && argTypes.get(0).name != null && !argTypes.get(0).name.equals(StrConst.empty))
        sb.append(args.get(0));
    for (int i = 1; i < argTypes.size(); i++) {
        sb.append("String_Node_Str");
        sb.append(args.get(i));
    }
    sb.append("String_Node_Str");
    sb.append(CRLF);
    if (pref.isTestMethodGenExceptions && testMethod.testingTargetException != null) {
        sb.append("String_Node_Str");
        sb.append(StrConst.expectedExceptionNotThrownMessage);
        sb.append("String_Node_Str");
        sb.append(testMethod.testingTargetException.name);
        sb.append("String_Node_Str");
        sb.append("String_Node_Str");
        sb.append(CRLF);
        sb.append("String_Node_Str");
        sb.append(testMethod.testingTargetException.name);
        sb.append("String_Node_Str");
        sb.append(CRLF);
    } else {
        if (pref.isTestMethodGenEnabledSupportEasyMock) {
            sb.append("String_Node_Str");
            sb.append(CRLF);
        }
        if (pref.isTestMethodGenEnabledSupportMockito) {
            sb.append("String_Node_Str");
            sb.append(CRLF);
            sb.append("String_Node_Str");
            sb.append(CRLF);
        }
        if (!returnTypeName.equals("String_Node_Str")) {
            sb.append("String_Node_Str");
            sb.append(returnTypeName);
            sb.append("String_Node_Str");
            sb.append(returnDefaultValue);
            sb.append("String_Node_Str");
            sb.append(CRLF);
        }
        if (!returnTypeName.equals("String_Node_Str")) {
            sb.append("String_Node_Str");
            sb.append("String_Node_Str");
            sb.append(CRLF);
        }
    }
    return sb.toString();
}

Output:
     if (!testMethod.isStatic) {
-        if (testClassinfo.constructors != null && testClassinfo.constructors.size() > 0) {
+        if (testClassinfo.constructors.size() > 0) {
             ConstructorInfo constructor = testClassinfo.constructors.get(0);


Input:
public void run() {
    logger.info("String_Node_Str" + this.product);
    int min = Integer.parseInt(this.conf.getProperty(DISPATCHER_INTERVAL, "String_Node_Str"));
    while (!this.stopping) {
        doSinglePush();
        doBroadcastPush();
        try {
            Thread.sleep(min * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    logger.info("String_Node_Str" + this.product);
}

Output:
     while (!this.stopping) {
-        doSinglePush();
-        doBroadcastPush();
+        int total = ClientKeeper.count(product.getKey());
+        if (total > 0) {
+            doSinglePush();
+            doBroadcastPush();
+        }
         try {


Input:
private void doReloadStruct() {
    long pTransitionIndex = metadata.createTransitionIndex();
    try {
        metadata.applyTransitionIndex(pTransitionIndex);
        final int columnCount = Unsafe.getUnsafe().getInt(pTransitionIndex + 4);
        int columnCountBits = getColumnBits(columnCount);
        if (columnCountBits > this.columnCountBits) {
            createNewColumnList(columnCount, pTransitionIndex, columnCountBits);
        } else {
            reshuffleExistingColumnList(columnCount, pTransitionIndex);
        }
        applyTransitionIndexToSymbolMapReaders(pTransitionIndex);
        this.columnCount = columnCount;
    } finally {
        TableReaderMetadata.freeTransitionIndex(pTransitionIndex);
    }
}

Output:
         } else {
-            reshuffleExistingColumnList(columnCount, pTransitionIndex);
+            reshuffleColumns(columnCount, pTransitionIndex);
         }


Input:
public void testSearchReferenceParameterWithList() throws Exception {
    RestfulServer rsNoType = new RestfulServer(ourCtx);
    rsNoType.registerProvider(new SearchProviderWithListNoType());
    ServerConformanceProvider sc = new ServerConformanceProvider(rsNoType);
    rsNoType.setServerConformanceProvider(sc);
    rsNoType.init(createServletConfig());
    Conformance conformance = sc.getServerConformance(createHttpServletRequest());
    String confNoType = ourCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(conformance);
    ourLog.info(confNoType);
    RestfulServer rsWithType = new RestfulServer(ourCtx);
    rsWithType.registerProvider(new SearchProviderWithListWithType());
    ServerConformanceProvider scWithType = new ServerConformanceProvider(rsWithType);
    rsWithType.setServerConformanceProvider(scWithType);
    rsWithType.init(createServletConfig());
    Conformance conformanceWithType = scWithType.getServerConformance(createHttpServletRequest());
    String confWithType = ourCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(conformanceWithType);
    ourLog.info(confWithType);
    assertEquals(confNoType, confWithType);
}

Output:
     rsNoType.registerProvider(new SearchProviderWithListNoType());
-    ServerConformanceProvider sc = new ServerConformanceProvider(rsNoType);
-    rsNoType.setServerConformanceProvider(sc);
+    ServerConformanceProvider scNoType = new ServerConformanceProvider(rsNoType);
+    rsNoType.setServerConformanceProvider(scNoType);
     rsNoType.init(createServletConfig());


Input:
protected IStatus run(IProgressMonitor monitor) {
    byte[] buf = new byte[buff_length];
    int totalWork = ((fileLength == -1) ? 100 : (int) fileLength);
    monitor.beginTask(getRemoteFileURL().toString() + Messages.AbstractRetrieveFileTransfer_Progress_Data, totalWork);
    try {
        while (!isDone()) {
            if (monitor.isCanceled())
                throw new UserCancelledException(Messages.AbstractRetrieveFileTransfer_Exception_User_Cancelled);
            int bytes = remoteFileContents.read(buf);
            if (bytes != -1) {
                bytesReceived += bytes;
                localFileContents.write(buf, 0, bytes);
                fireTransferReceiveDataEvent();
                monitor.worked(bytes);
            } else
                done = true;
        }
    } catch (Exception e) {
        exception = e;
        done = true;
    } finally {
        hardClose();
        monitor.done();
        fireTransferReceiveDoneEvent();
    }
    return getFinalStatus(exception);
}

Output:
                 monitor.worked(bytes);
-            } else
+            } else {
                 done = true;


Input:
public Response<Void> agentServiceDeregister(String serviceId, String token) {
    UrlParameters tokenParam = token != null ? new SingleUrlParameters("String_Node_Str", token) : null;
    RawResponse rawResponse = rawClient.makeGetRequest("String_Node_Str" + serviceId, tokenParam);
    if (rawResponse.getStatusCode() == 200) {
        return new Response<Void>(null, rawResponse);
    } else {
        throw new OperationException(rawResponse);
    }
}

Output:
     UrlParameters tokenParam = token != null ? new SingleUrlParameters("String_Node_Str", token) : null;
-    RawResponse rawResponse = rawClient.makeGetRequest("String_Node_Str" + serviceId, tokenParam);
+    RawResponse rawResponse = rawClient.makePutRequest("String_Node_Str" + serviceId, "String_Node_Str", tokenParam);
     if (rawResponse.getStatusCode() == 200) {


Input:
public void display(GL2 gl) {
    buildDisplayList(gl, displayListIndex);
    isDisplayListDirty = false;
    gl.glCallList(displayListIndex);
    checkForHits(gl);
}

Output:
 public void display(GL2 gl) {
-    buildDisplayList(gl, displayListIndex);
-    isDisplayListDirty = false;
+    if (isDisplayListDirty) {
+        buildDisplayList(gl, displayListIndex);
+        isDisplayListDirty = false;
+    }
     gl.glCallList(displayListIndex);


Input:
public void visitCell(CellHandle handle) {
    CellDesign cell = new CellDesign();
    setupStyledElement(cell, handle);
    SlotHandle contentSlot = handle.getContent();
    for (int i = 0; i < contentSlot.getCount(); i++) {
        apply(contentSlot.get(i));
        if (currentElement != null) {
            cell.addContent((ReportItemDesign) currentElement);
        }
    }
    cell.setColSpan(handle.getColumnSpan());
    int columnId = handle.getColumn() - 1;
    if (columnId < 0) {
        columnId = -1;
    }
    cell.setColumn(columnId);
    cell.setRowSpan(handle.getRowSpan());
    if (isCellInGroupHeader(handle)) {
        cell.setDrop(handle.getDrop());
    }
    String onCreate = handle.getOnCreate();
    String onCreateScriptText = createExpression(onCreate);
    if (null != onCreateScriptText) {
        String id = ModuleUtil.getScriptUID(handle.getPropertyHandle(ICellModel.ON_CREATE_METHOD));
        ScriptExpression scriptExpr = new ScriptExpression(onCreateScriptText, id);
        cell.setOnCreate(scriptExpr);
    }
    String OnRenderScriptText = handle.getOnRender();
    if (null != OnRenderScriptText) {
        String id = ModuleUtil.getScriptUID(handle.getPropertyHandle(ICellModel.ON_RENDER_METHOD));
        ScriptExpression scriptExpr = new ScriptExpression(OnRenderScriptText, id);
        cell.setOnRender(scriptExpr);
    }
    setupHighlight(cell, null);
    currentElement = cell;
}

Output:
     setupHighlight(cell, null);
-    currentElement = cell;
+    setCurrentElement(cell);
 }


Input:
public double refinedStepSize() throws IllegalActionException {
    double result = Double.POSITIVE_INFINITY;
    Iterator actors = _actorsFired.iterator();
    while (actors.hasNext()) {
        Actor actor = (Actor) actors.next();
        if (actor instanceof ContinuousStepSizeController) {
            double candidate = ((ContinuousStepSizeController) actor).refinedStepSize();
            if (candidate < result) {
                result = candidate;
            }
        } else if (actor instanceof CompositeActor) {
            Iterator insideActors = ((CompositeActor) actor).deepEntityList().iterator();
            while (insideActors.hasNext()) {
                Actor insideActor = (Actor) insideActors.next();
                if (insideActor instanceof ContinuousStepSizeController) {
                    double candidate = ((ContinuousStepSizeController) insideActor).refinedStepSize();
                    if (candidate < result) {
                        result = candidate;
                    }
                }
            }
        }
    }
    if (_distanceToBoundary > 0.0) {
        ContinuousDirector enclosingDirector = _enclosingContinuousDirector();
        if (enclosingDirector != null) {
            double errorTolerance = enclosingDirector.getErrorTolerance();
            double currentStepSize = enclosingDirector.getCurrentStepSize();
            double refinedStepSize = (currentStepSize * currentStepSize / (currentStepSize + _distanceToBoundary));
            result = Math.min(result, refinedStepSize);
        }
    }
    return result;
}

Output:
         } else if (actor instanceof CompositeActor) {
-            Iterator insideActors = ((CompositeActor) actor).deepEntityList().iterator();
-            while (insideActors.hasNext()) {
-                Actor insideActor = (Actor) insideActors.next();
-                if (insideActor instanceof ContinuousStepSizeController) {
-                    double candidate = ((ContinuousStepSizeController) insideActor).refinedStepSize();
-                    if (candidate < result) {
-                        result = candidate;
-                    }
+            Director director = actor.getDirector();
+            if (director instanceof ContinuousStepSizeController) {
+                double candidate = ((ContinuousStepSizeController) director).refinedStepSize();
+                if (candidate < result) {
+                    result = candidate;
                 }


Input:
public static Class createBlock(String name, Element owner) {
    Class newBlock = createClass(name, owner);
    Element stereo = ElementFinder.getElementByID("String_Node_Str");
    if (!(stereo instanceof Stereotype)) {
        return null;
    }
    Stereotype block = (Stereotype) stereo;
    StereotypesHelper.addStereotype(newBlock, block);
    return newBlock;
}

Output:
     Class newBlock = createClass(name, owner);
-    Element stereo = ElementFinder.getElementByID("String_Node_Str");
+    Element stereo = ElementFinder.getElementByID("String_Node_Str", Project.getProject(owner));
     if (!(stereo instanceof Stereotype)) {


Input:
private void editSelectedBinding(int bindingIndex) {
    if (!btnEdit.isEnabled())
        return;
    ComputedColumnHandle bindingHandle = null;
    if (bindingIndex > -1) {
        bindingHandle = (ComputedColumnHandle) (DEUtil.getBindingHolder(inputElement)).getColumnBindings().getAt(bindingIndex);
    }
    if (bindingHandle == null)
        return;
    String bindingName = bindingHandle.getName();
    DataColumnBindingDialog dialog = new DataColumnBindingDialog(false);
    dialog.setInput(inputElement, bindingHandle);
    dialog.setExpressionProvider(expressionProvider);
    if (dialog.open() == Dialog.OK) {
        if (bindingTable != null)
            bindingTable.getTable().setSelection(bindingIndex);
        if (selectedColumnName != null && selectedColumnName.equals(bindingName))
            selectedColumnName = bindingHandle.getName();
    }
}

Output:
     DataColumnBindingDialog dialog = new DataColumnBindingDialog(false);
-    dialog.setInput(inputElement, bindingHandle);
+    setDialogInput(dialog, bindingHandle);
     dialog.setExpressionProvider(expressionProvider);


Input:
public boolean autodetectCustomImplementation() {
    return !StringUtils.hasText(element.getAttribute(CUSTOM_IMPL_REF));
}

Output:
 public boolean autodetectCustomImplementation() {
-    return !StringUtils.hasText(element.getAttribute(CUSTOM_IMPL_REF));
+    return !StringUtils.hasText(getElement().getAttribute(CUSTOM_IMPL_REF));
 }


Input:
private boolean isConvertibleFrom(IType type) {
    return type.getAnnotation(MapType.MapTypes.MAP_CONVERTIBLE_CLASS) != null;
}

Output:
 private boolean isConvertibleFrom(IType type) {
-    return type.getAnnotation(MapType.MapTypes.MAP_CONVERTIBLE_CLASS) != null;
+    return type.getAnnotation(LazyTypes.MAP_CONVERTIBLE_CLASS) != null;
 }


Input:
private void resolveName(ASTName name, Type lastType, ASTArguments args) throws ASTClassNotFoundException, ASTResolutionException {
    Type[] arguments = ASTArguments2Types(args);
    Class owner;
    try {
        owner = lastType == null ? _currentClass : lastType.toClass(_loader);
    } catch (ClassNotFoundException e) {
        throw new ASTClassNotFoundException(lastType.getName());
    }
    int length = name.jjtGetNumChildren();
    String remainingName = "String_Node_Str";
    for (int i = 0; i < length; i++) {
        ASTIdentifier id = (ASTIdentifier) name.jjtGetChild(i);
        String currentName = remainingName + id.getImage();
        if (currentName.equals("String_Node_Str")) {
            Type.setType(id, Type.createType(owner.getName()));
            continue;
        } else if (currentName.equals("String_Node_Str")) {
            Type.setType(id, Type.createType(owner.getSuperclass().getName()));
            continue;
        }
        if (i == 0 && lastType == null) {
            Type vtype = findVariable(currentName);
            if (vtype != null) {
                Type.setType(id, vtype);
                if (vtype.isPrimitive())
                    owner = null;
                else
                    try {
                        owner = vtype.toClass(_loader);
                    } catch (ClassNotFoundException e) {
                        throw new ASTClassNotFoundException(vtype.getName());
                    }
                continue;
            }
        }
        Type idType;
        if (i < length - 1)
            idType = resolveNameFromClass(owner, currentName, null);
        else
            idType = resolveNameFromClass(owner, currentName, arguments);
        Type.setType(id, idType);
        if (idType != null) {
            remainingName = "String_Node_Str";
            if (idType.isPrimitive())
                owner = null;
            else
                try {
                    owner = idType.toClass(_loader);
                } catch (ClassNotFoundException e) {
                    throw new ASTClassNotFoundException(idType.getName());
                }
        } else if (i < length - 1)
            remainingName = currentName + "String_Node_Str";
        else
            throw new ASTResolutionException(owner.getName(), currentName);
    }
    Type.propagateType(name, name.jjtGetChild(length - 1));
}

Output:
         Type idType;
-        if (i < length - 1)
-            idType = resolveNameFromClass(owner, currentName, null);
-        else
-            idType = resolveNameFromClass(owner, currentName, arguments);
+        Type[] argumentsForResolution = i < length - 1 ? null : arguments;
+        idType = resolveNameFromClass(owner, currentName, argumentsForResolution);
+        if (idType == null && lastType == null && i == 0) {
+            int previousClassNum = _previousClasses.size() - 1;
+            while (idType == null && previousClassNum >= 0) {
+                Class previousClass = (Class) _previousClasses.get(previousClassNum);
+                if (previousClass != null)
+                    idType = resolveNameFromClass(previousClass, currentName, argumentsForResolution);
+                previousClassNum--;
+            }
+        }
         Type.setType(id, idType);


Input:
private void checkConflicts() throws ConfigurationException {
    Date cutTime = DateUtil.currentGMTTime();
    List<ManagementServerHostVO> peers = _mshostDao.getActiveList(new Date(cutTime.getTime() - heartbeatThreshold));
    for (ManagementServerHostVO peer : peers) {
        if (_mshostId == peer.getMsid()) {
            continue;
        }
        if (_clusterNodeIP.equals(peer.getServiceIP().trim())) {
            if ("String_Node_Str".equals(_clusterNodeIP)) {
                throw new ConfigurationException("String_Node_Str");
            } else {
                if (!pingManagementNode(peer.getId())) {
                    throw new ConfigurationException("String_Node_Str" + peer.getServiceIP() + "String_Node_Str");
                }
            }
        }
    }
}

Output:
     for (ManagementServerHostVO peer : peers) {
-        if (_mshostId == peer.getMsid()) {
-            continue;
-        }
-        if (_clusterNodeIP.equals(peer.getServiceIP().trim())) {
+        String peerIP = peer.getServiceIP().trim();
+        if (_clusterNodeIP.equals(peerIP)) {
             if ("String_Node_Str".equals(_clusterNodeIP)) {


Input:
public void testTotalAmount() throws Exception {
    if (!isApplicable()) {
        return;
    }
    MondrianProperties props = MondrianProperties.instance();
    propSaver.set(props.UseAggregates, false);
    String mdx = "String_Node_Str";
    Result result = getCubeTestContext().executeQuery(mdx);
    Object v = result.getCell(new int[] { 0 }).getValue();
    propSaver.set(props.UseAggregates, false);
    Result result1 = getCubeTestContext().executeQuery(mdx);
    Object v1 = result1.getCell(new int[] { 0 }).getValue();
    assertTrue(v.equals(v1));
}

Output:
     String mdx = "String_Node_Str";
-    Result result = getCubeTestContext().executeQuery(mdx);
+    Result result = getTestContext().executeQuery(mdx);
     Object v = result.getCell(new int[] { 0 }).getValue();


Input:
private Collection getChoicesFromParameterQuery(ScalarParameterHandle parameter) {
    String dataType = parameter.getDataType();
    boolean fixedOrder = parameter.isFixedOrder();
    String dataSetName = parameter.getDataSetName();
    String valueExpr = parameter.getValueExpr();
    String labelExpr = parameter.getLabelExpr();
    int limit = parameter.getListlimit();
    String pattern = parameter.getPattern();
    return createDynamicSelectionChoices(pattern, dataSetName, labelExpr, valueExpr, dataType, limit, fixedOrder);
}

Output:
     String pattern = parameter.getPattern();
-    return createDynamicSelectionChoices(pattern, dataSetName, labelExpr, valueExpr, dataType, limit, fixedOrder);
+    return createDynamicSelectionChoices(pattern, dataSetName, labelExpr, valueExpr, dataType, limit, fixedOrder, isDistinct, sortDirection, sortBy);
 }


Input:
public double getAspectRatio() {
    if (aspectY == 0) {
        return 0;
    } else {
        return aspectX / aspectY;
    }
}

Output:
     } else {
-        return aspectX / aspectY;
+        return ((double) aspectX) / ((double) aspectY);
     }


Input:
public String toHexString() {
    StringBuffer buf = new StringBuffer();
    int val;
    for (int i = 0; i < SZ; i += 4) {
        val = bytes[i];
        val = (val * 256) + bytes[i + 1];
        val = (val * 256) + bytes[i + 2];
        val = (val * 256) + bytes[i + 3];
        buf.append(Integer.toHexString(val));
    }
    return buf.toString();
}

Output:
         val = (val * 256) + bytes[i + 3];
-        buf.append(Integer.toHexString(val));
+        str = Integer.toHexString(val);
+        while (str.length() < 8) str = "String_Node_Str" + str;
+        buf.append(str);
     }


Input:
public boolean chooseTargetAmount(Outcome outcome, TargetAmount target, Ability source, Game game) {
    if (log.isDebugEnabled()) {
        log.debug("String_Node_Str" + outcome.toString() + "String_Node_Str" + target.toString());
    }
    UUID opponentId = game.getOpponents(playerId).iterator().next();
    if (target instanceof TargetCreatureOrPlayerAmount) {
        if (outcome.equals(Outcome.Damage) && game.getPlayer(opponentId).getLife() <= target.getAmountRemaining()) {
            target.addTarget(opponentId, target.getAmountRemaining(), source, game);
            return true;
        }
        List<Permanent> targets;
        if (outcome.isGood()) {
            targets = threats(playerId, source.getSourceId(), new FilterCreaturePermanent(), game, target.getTargets());
        } else {
            targets = threats(opponentId, source.getSourceId(), new FilterCreaturePermanent(), game, target.getTargets());
        }
        for (Permanent permanent : targets) {
            if (target.canTarget(getId(), permanent.getId(), source, game)) {
                if (permanent.getToughness().getValue() <= target.getAmountRemaining()) {
                    target.addTarget(permanent.getId(), permanent.getToughness().getValue(), source, game);
                    return true;
                }
            }
        }
        if (outcome.isGood() && target.canTarget(getId(), getId(), source, game)) {
            target.addTarget(opponentId, target.getAmountRemaining(), source, game);
            return true;
        } else if (target.canTarget(getId(), opponentId, source, game)) {
            target.addTarget(opponentId, target.getAmountRemaining(), source, game);
            return true;
        } else if (target.canTarget(getId(), playerId, source, game)) {
            target.addTarget(opponentId, target.getAmountRemaining(), source, game);
            return true;
        }
    }
    return false;
}

Output:
     UUID opponentId = game.getOpponents(playerId).iterator().next();
-    if (target instanceof TargetCreatureOrPlayerAmount) {
+    if (target.getOriginalTarget() instanceof TargetCreatureOrPlayerAmount) {
         if (outcome.equals(Outcome.Damage) && game.getPlayer(opponentId).getLife() <= target.getAmountRemaining()) {


Input:
private void displayRelationships(NodeOrRelationship thing, Output out, boolean verbose, Direction direction, String prefixString, String postfixString, String filter, boolean caseSensitiveFilters, boolean exactFilterMatch) throws ShellException, RemoteException {
    Pattern typeFilter = newPattern(filter, caseSensitiveFilters);
    for (Relationship rel : thing.getRelationships(direction)) {
        String type = rel.getType().name();
        if (!matches(typeFilter, type, caseSensitiveFilters, exactFilterMatch)) {
            continue;
        }
        StringBuffer buf = new StringBuffer(getDisplayNameForCurrentNode());
        buf.append("String_Node_Str" + prefixString).append(rel.getType().name());
        if (verbose) {
            buf.append("String_Node_Str").append(rel.getId());
        }
        buf.append(postfixString + "String_Node_Str");
        buf.append(getDisplayNameForNode(rel.getEndNode()));
        out.println(buf);
    }
}

Output:
         buf.append(postfixString + "String_Node_Str");
-        buf.append(getDisplayNameForNode(rel.getEndNode()));
+        buf.append(getDisplayNameForNode(direction == Direction.OUTGOING ? rel.getEndNode() : rel.getStartNode()));
         out.println(buf);


Input:
void reRenderFilterComponents() {
    container.clear();
    for (int i = 0; i < tHead.getVisibleCellCount(); i++) {
        String key = getColKeyByIndex(i);
        if (key == null) {
            continue;
        }
        Widget widget = filters.get(key);
        if (widget == null) {
            Widget placeHolder = new FlowPanel();
            placeHolder.addStyleName("String_Node_Str");
            container.add(placeHolder);
            filters.put(key, placeHolder);
            setFilterWidth(i, getColWidth(key));
        } else {
            container.add(widget);
            setFilterWidth(i, getColWidth(key));
        }
    }
}

Output:
             filters.put(key, placeHolder);
-            setFilterWidth(i, getColWidth(key));
+            setFilterWidth(i);
         } else {


Input:
public void refresh() {
    masterPart.updateButtonState();
}

Output:
 public void refresh() {
-    masterPart.updateButtonState();
+    bundleMasterPart.updateButtonState();
 }


Input:
public XMLAnyCollectionMapping generateAnyCollectionMapping(Property property, XMLDescriptor descriptor, NamespaceInfo namespaceInfo) {
    AnyProperty prop = (AnyProperty) property;
    XMLAnyCollectionMapping mapping = new XMLAnyCollectionMapping();
    mapping.setAttributeName(property.getPropertyName());
    if (property.isMethodProperty()) {
        mapping.setSetMethodName(property.getSetMethodName());
        mapping.setGetMethodName(property.getGetMethodName());
        if (property.getGetMethodName() == null) {
            mapping.setIsReadOnly(true);
        } else if (property.getSetMethodName() == null) {
            mapping.setIsWriteOnly(true);
        }
    }
    mapping.setUseXMLRoot(true);
    mapping.setAttributeAccessor(new JAXBElementAttributeAccessor(mapping.getAttributeAccessor(), mapping.getContainerPolicy()));
    if (prop.isLax()) {
        mapping.setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT);
    } else {
        mapping.setKeepAsElementPolicy(UnmarshalKeepAsElementPolicy.KEEP_ALL_AS_ELEMENT);
    }
    if (prop.getDomHandlerClass() != null) {
        DomHandlerConverter converter = new DomHandlerConverter(prop.getDomHandlerClass());
        mapping.setConverter(converter);
    }
    descriptor.addMapping(mapping);
    return mapping;
}

Output:
     }
-    mapping.setUseXMLRoot(true);
+    if (!isMixed) {
+        mapping.setUseXMLRoot(true);
+    }
     mapping.setAttributeAccessor(new JAXBElementAttributeAccessor(mapping.getAttributeAccessor(), mapping.getContainerPolicy()));


Input:
public void testMigrateModelsNoDepth() throws Exception {
    String directoryPath = createDirectory(2, 2);
    MigrateModelsManager migrateModelsManager = new MigrateModelsManager();
    try {
        String csvFilePath = migrateModelsManager.migrateModels(directoryPath, false, true);
        assertTrue(csvFilePath.equals(directoryPath + System.getProperty("String_Node_Str") + "String_Node_Str"));
        File csvFile = new File(csvFilePath);
        BufferedReader input = new BufferedReader(new FileReader(csvFile));
        try {
            int count = 0;
            String line = "String_Node_Str";
            while ((line = input.readLine()) != null) {
                if (line.length() > 10) {
                    count++;
                }
            }
            assertTrue(count == 3);
        } finally {
            input.close();
        }
        PowerMock.verifyAll();
    } catch (IOException e) {
        fail("String_Node_Str" + e.getMessage());
    } finally {
        _cleanup(directoryPath);
    }
}

Output:
         File csvFile = new File(csvFilePath);
-        BufferedReader input = new BufferedReader(new FileReader(csvFile));
+        BufferedReader input = new BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(csvFile), java.nio.charset.Charset.defaultCharset()));
         try {


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.debug_log);
    final LibVLC instance;
    try {
        instance = VLCInstance.getLibVlcInstance();
    } catch (LibVlcException e) {
        return;
    }
    final Button startLog = (Button) findViewById(R.id.start_log);
    final Button stopLog = (Button) findViewById(R.id.stop_log);
    startLog.setEnabled(!instance.isDebugBuffering());
    stopLog.setEnabled(instance.isDebugBuffering());
    startLog.setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            instance.startDebugBuffer();
            startLog.setEnabled(false);
            stopLog.setEnabled(true);
        }
    });
    stopLog.setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            instance.stopDebugBuffer();
            stopLog.setEnabled(false);
            startLog.setEnabled(true);
        }
    });
    Button clearLog = (Button) findViewById(R.id.clear_log);
    clearLog.setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            instance.clearBuffer();
            updateTextView(instance);
        }
    });
    updateTextView(instance);
    Button copyToClipboard = (Button) findViewById(R.id.copy_to_clipboard);
    if (((TextView) findViewById(R.id.textview)).getText().length() > 0)
        copyToClipboard.setEnabled(true);
    copyToClipboard.setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            copyTextToClipboard();
            Toast.makeText(DebugLogActivity.this, R.string.copied_to_clipboard, Toast.LENGTH_SHORT).show();
        }
    });
}

Output:
     Button copyToClipboard = (Button) findViewById(R.id.copy_to_clipboard);
-    if (((TextView) findViewById(R.id.textview)).getText().length() > 0)
-        copyToClipboard.setEnabled(true);
+    copyToClipboard.setEnabled(((TextView) findViewById(R.id.textview)).getText().length() > 0);
     copyToClipboard.setOnClickListener(new View.OnClickListener() {


Input:
public Object visitCatchNode(CatchNode node, LinkedList args) {
    NameContext ctx = (NameContext) args.get(0);
    NameContext subCtx = new NameContext(ctx);
    Environ env = (Environ) node.getDefinedProperty(ENVIRON_KEY);
    subCtx.environ = env;
    LinkedList childArgs = TNLManip.cons(subCtx);
    node.setParam((ParameterNode) node.getParam().accept(this, childArgs));
    node.setBlock((BlockNode) node.getBlock().accept(this, childArgs));
    return node;
}

Output:
     NameContext subCtx = new NameContext(ctx);
-    Environ env = (Environ) node.getDefinedProperty(ENVIRON_KEY);
-    subCtx.environ = env;
+    subCtx.environ = new Environ(ctx.environ);
     LinkedList childArgs = TNLManip.cons(subCtx);


Input:
void updateCrumbs() {
    FragmentManager fm = mActivity.getFragmentManager();
    int numEntries = fm.getBackStackEntryCount();
    int numPreEntries = getPreEntryCount();
    int numViews = mContainer.getChildCount();
    for (int i = 0; i < numEntries + numPreEntries; i++) {
        BackStackEntry bse = i < numPreEntries ? getPreEntry(i) : fm.getBackStackEntryAt(i - numPreEntries);
        if (i < numViews) {
            View v = mContainer.getChildAt(i);
            Object tag = v.getTag();
            if (tag != bse) {
                for (int j = i; j < numViews; j++) {
                    mContainer.removeViewAt(i);
                }
                numViews = i;
            }
        }
        if (i >= numViews) {
            final View item = mInflater.inflate(com.android.internal.R.layout.fragment_bread_crumb_item, this, false);
            final TextView text = (TextView) item.findViewById(com.android.internal.R.id.title);
            text.setText(bse.getBreadCrumbTitle());
            text.setTag(bse);
            if (i == 0) {
                item.findViewById(com.android.internal.R.id.left_icon).setVisibility(View.GONE);
            }
            mContainer.addView(item);
            text.setOnClickListener(mOnClickListener);
        }
    }
    int viewI = numEntries + numPreEntries;
    numViews = mContainer.getChildCount();
    while (numViews > viewI) {
        mContainer.removeViewAt(numViews - 1);
        numViews--;
    }
    for (int i = 0; i < numViews; i++) {
        final View child = mContainer.getChildAt(i);
        child.findViewById(com.android.internal.R.id.title).setEnabled(i < numViews - 1);
        if (mMaxVisible > 0) {
            child.setVisibility(i < numViews - mMaxVisible ? View.GONE : View.VISIBLE);
            final View leftIcon = child.findViewById(com.android.internal.R.id.left_icon);
            leftIcon.setVisibility(i > numViews - mMaxVisible && i != 0 ? View.VISIBLE : View.GONE);
        }
    }
}

Output:
         if (i >= numViews) {
-            final View item = mInflater.inflate(com.android.internal.R.layout.fragment_bread_crumb_item, this, false);
+            final View item = mInflater.inflate(mLayoutResId, this, false);
             final TextView text = (TextView) item.findViewById(com.android.internal.R.id.title);


Input:
private Counter getCounter(String counterPath) {
    String json = "String_Node_Str" + counterPath + "String_Node_Str";
    LOG.info("String_Node_Str" + json);
    String response = sendJSonPostRequest(url, json, null);
    List<MetricsResponse> responseData = GSON.fromJson(response, new TypeToken<List<MetricsResponse>>() {
    }.getType());
    if (responseData == null || responseData.size() == 0) {
        throw new RuntimeException(String.format("String_Node_Str", counterPath));
    }
    if (responseData.size() > 1) {
        throw new RuntimeException(String.format("String_Node_Str", counterPath));
    }
    return new Counter(responseData.get(0).getPath(), responseData.get(0).getResult().getData());
}

Output:
     String json = "String_Node_Str" + counterPath + "String_Node_Str";
-    LOG.info("String_Node_Str" + json);
+    if (LOG.isDebugEnabled()) {
+        LOG.debug("String_Node_Str", json);
+    }
     String response = sendJSonPostRequest(url, json, null);


Input:
protected void switchPersistenceUnits(Map<Class, String> entityPuCol) throws IOException, TException, InvalidRequestException, UnavailableException, TimedOutException, SchemaDisagreementException {
    if (entityPuCol != null) {
        Iterator<Class> iter = entityPuCol.keySet().iterator();
        log.warn("String_Node_Str");
        while (iter.hasNext()) {
            Class clazz = iter.next();
            String pu = entityPuCol.get(clazz);
            Map<String, Metamodel> metaModels = KunderaMetadata.INSTANCE.getApplicationMetadata().getMetamodelMap();
            EntityMetadata mAdd = null;
            for (Metamodel m : metaModels.values()) {
                mAdd = ((MetamodelImpl) m).getEntityMetadataMap().get(clazz);
                if (mAdd != null) {
                    break;
                }
            }
            mAdd.setPersistenceUnit(pu);
            PersistenceUnitMetadata puMetadata = KunderaMetadata.INSTANCE.getApplicationMetadata().getPersistenceUnitMetadata(pu);
            String client = puMetadata.getProperties().getProperty(PersistenceProperties.KUNDERA_CLIENT_FACTORY);
            if (client.equalsIgnoreCase("String_Node_Str")) {
                if (RUN_IN_EMBEDDED_MODE) {
                    CassandraCli.cassandraSetUp();
                    CassandraCli.initClient();
                }
                if (AUTO_MANAGE_SCHEMA) {
                    if (mAdd.getTableName().equalsIgnoreCase("String_Node_Str")) {
                        loadDataForHABITAT();
                    } else if (mAdd.getTableName().equalsIgnoreCase("String_Node_Str")) {
                        loadDataForPERSONNEL();
                    }
                }
            } else if (client.equalsIgnoreCase("String_Node_Str")) {
                if (RUN_IN_EMBEDDED_MODE) {
                    HBaseCli.createTable("String_Node_Str");
                    HBaseCli.addColumnFamily("String_Node_Str", "String_Node_Str");
                    HBaseCli.addColumnFamily("String_Node_Str", "String_Node_Str");
                    HBaseCli.createTable("String_Node_Str");
                    HBaseCli.addColumnFamily("String_Node_Str", "String_Node_Str");
                    HBaseCli.addColumnFamily("String_Node_Str", "String_Node_Str");
                    HBaseCli.createTable("String_Node_Str");
                    HBaseCli.addColumnFamily("String_Node_Str", "String_Node_Str");
                    HBaseCli.addColumnFamily("String_Node_Str", "String_Node_Str");
                    HBaseCli.addColumnFamily("String_Node_Str", "String_Node_Str");
                }
            }
            String schema = puMetadata.getProperty(PersistenceProperties.KUNDERA_KEYSPACE);
            mAdd.setSchema(schema != null ? schema : "String_Node_Str");
            log.warn("String_Node_Str" + pu + "String_Node_Str" + clazz.getCanonicalName());
        }
    }
    dao.closeEntityManager();
    em = dao.getEntityManager(persistenceUnits);
}

Output:
             } else if (client.equalsIgnoreCase("String_Node_Str")) {
-                if (RUN_IN_EMBEDDED_MODE) {
+                if (!RUN_IN_EMBEDDED_MODE) {
                     HBaseCli.createTable("String_Node_Str");


Input:
public static void setInfo() {
    for (Logger logger : loggers.values()) {
        logger.setLevel(Level.INFO);
    }
}

Output:
 public static void setInfo() {
-    for (Logger logger : loggers.values()) {
-        logger.setLevel(Level.INFO);
-    }
+    setLevel(Level.INFO);
 }


Input:
public Object innerCall() throws Exception {
    final TransactionContext context = getEndpoint().getTransactionContext(txnId);
    final TransactionalMultiMap<Object, Object> multiMap = context.getMultiMap(name);
    if (value == null) {
        final Collection<Object> objects = multiMap.remove(key);
        Collection<Data> coll = createCollection(objects.size());
        for (Object object : objects) {
            final Data data = toData(object);
            coll.add(data);
        }
        return new PortableCollection(coll);
    } else {
        return multiMap.remove(key, value);
    }
}

Output:
     final TransactionalMultiMap<Object, Object> multiMap = context.getMultiMap(name);
-    if (value == null) {
-        final Collection<Object> objects = multiMap.remove(key);
-        Collection<Data> coll = createCollection(objects.size());
-        for (Object object : objects) {
-            final Data data = toData(object);
-            coll.add(data);
-        }
-        return new PortableCollection(coll);
-    } else {
-        return multiMap.remove(key, value);
-    }
+    return multiMap.remove(key, value);
 }


Input:
public static void updateCommitStatus(Run<?, ?> build, TaskListener listener, BuildState state, String name) {
    GitLabApi client = getClient(build);
    if (client == null) {
        println(listener, "String_Node_Str");
        return;
    }
    try {
        String commitHash = getBuildRevision(build);
        String buildUrl = getBuildUrl(build);
        for (String gitlabProjectId : retrieveGitlabProjectIds(build, build.getEnvironment(listener))) {
            try {
                if (existsCommit(client, gitlabProjectId, commitHash)) {
                    client.changeBuildStatus(gitlabProjectId, commitHash, state, getBuildBranch(build), name, buildUrl, null);
                }
            } catch (WebApplicationException | ProcessingException e) {
                printf(listener, "String_Node_Str", gitlabProjectId, e.getMessage());
                LOGGER.log(Level.SEVERE, String.format("String_Node_Str", gitlabProjectId), e);
            }
        }
    } catch (IOException | InterruptedException | IllegalStateException e) {
        printf(listener, "String_Node_Str", e.getMessage());
    }
}

Output:
     try {
-        String commitHash = getBuildRevision(build);
-        String buildUrl = getBuildUrl(build);
-        for (String gitlabProjectId : retrieveGitlabProjectIds(build, build.getEnvironment(listener))) {
+        final String buildUrl = getBuildUrl(build);
+        for (final GitLabBranchBuild gitLabBranchBuild : retrieveGitlabProjectIds(build, build.getEnvironment(listener))) {
             try {


Input:
protected Control createDialogArea(Composite parent) {
    Composite comp = (Composite) super.createDialogArea(parent);
    Tree tree = new TooltipTree(comp, SWT.BORDER) {
        protected String getItemTooltipText(TreeItem item) {
            if (item.getData(INDICATORITEM) == null) {
                return item.getText();
            }
            IndicatorDefinition indicatorDefinition = ((IIndicatorNode) item.getData(INDICATORITEM)).getIndicatorInstance().getIndicatorDefinition();
            String description = TaggedValueHelper.getDescription(indicatorDefinition);
            return description.equals(PluginConstant.EMPTY_STRING) ? item.getText() : description;
        }
    };
    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(true, true).applyTo(tree);
    ((GridData) tree.getLayoutData()).widthHint = 650;
    ((GridData) tree.getLayoutData()).heightHint = 380;
    createTreeStructure(tree);
    tree.setLinesVisible(true);
    tree.addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(SelectionEvent e) {
        }

        public void widgetSelected(SelectionEvent e) {
            IIndicatorNode indicatorNode = ((IIndicatorNode) e.item.getData(INDICATORITEM));
            if (indicatorNode == null) {
                purposeLabel.setText(PURPOSE + ((TreeItem) e.item).getText());
                descriptionLabel.setText(DESCRIPTION + ((TreeItem) e.item).getText());
                return;
            }
            Indicator indicator = indicatorNode.getIndicatorInstance();
            IndicatorDefinition indicatorDefinition = indicator.getIndicatorDefinition();
            purposeLabel.setText(PURPOSE + TaggedValueHelper.getPurpose(indicatorDefinition));
            String description = DESCRIPTION + TaggedValueHelper.getDescription(indicatorDefinition);
            description = splitLongString(description);
            descriptionLabel.setText(description);
        }
        private String splitLongString(String longString) {
            if (longString.length() > ROW_MAX_LENGTH) {
                char space = ' ';
                for (int i = ROW_MAX_LENGTH; i > 0; i--) {
                    if (longString.charAt(i) == space) {
                        String substring1 = longString.substring(0, i);
                        String lineSeparator = System.getProperty("String_Node_Str", "String_Node_Str");
                        String substring2 = longString.substring(i, longString.length());
                        substring2 = splitLongString(substring2);
                        longString = substring1 + lineSeparator + substring2;
                        break;
                    }
                }
            }
            return longString;
        }
    });
    tree.pack();
    purposeLabel = new Label(comp, SWT.NULL);
    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(true, true).applyTo(purposeLabel);
    descriptionLabel = new Label(comp, SWT.NULL);
    GridDataFactory.fillDefaults().grab(true, true).applyTo(descriptionLabel);
    ((GridData) descriptionLabel.getLayoutData()).heightHint = 40;
    comp.layout();
    return comp;
}

Output:
     tree.setLinesVisible(true);
-    tree.addSelectionListener(new SelectionListener() {
-        public void widgetDefaultSelected(SelectionEvent e) {
-        }
+    tree.addSelectionListener(new SelectionAdapter() {


Input:
public void notifyOfNewImage(at.ac.tuwien.sepm.ws16.qse01.entities.Image image, int index) {
    if (index == -1)
        listOfImages.add(image);
    else
        listOfImages.add(index, image);
    prepareHBox(image, index);
}

Output:
 public void notifyOfNewImage(at.ac.tuwien.sepm.ws16.qse01.entities.Image image, int index) {
-    if (index == -1)
+    if (index == -1) {
         listOfImages.add(image);


Input:
private MethodImplementation toMethodImplementation(SootMethod m) {
    if (m.isAbstract() || m.isNative()) {
        return null;
    }
    Body activeBody = m.retrieveActiveBody();
    if (m.getName().contains("String_Node_Str") || m.getName().equals("String_Node_Str"))
        if (!m.getName().equals("String_Node_Str") && !m.getName().equals("String_Node_Str"))
            throw new RuntimeException("String_Node_Str" + m.getName());
    EmptySwitchEliminator.v().transform(activeBody);
    SynchronizedMethodTransformer.v().transform(activeBody);
    FastDexTrapTightener.v().transform(activeBody);
    DexArrayInitDetector initDetector = new DexArrayInitDetector();
    initDetector.constructArrayInitializations(activeBody);
    initDetector.fixTraps(activeBody);
    TrapSplitter.v().transform(activeBody);
    int inWords = SootToDexUtils.getDexWords(m.getParameterTypes());
    if (!m.isStatic()) {
        inWords++;
    }
    Collection<Unit> units = activeBody.getUnits();
    StmtVisitor stmtV = new StmtVisitor(m, initDetector);
    toInstructions(units, stmtV);
    int registerCount = stmtV.getRegisterCount();
    if (inWords > registerCount) {
        registerCount = inWords;
    }
    MethodImplementationBuilder builder = new MethodImplementationBuilder(registerCount);
    LabelAssigner labelAssinger = new LabelAssigner(builder);
    List<BuilderInstruction> instructions = stmtV.getRealInsns(labelAssinger);
    fixLongJumps(instructions, labelAssinger, stmtV);
    Map<Local, Integer> seenRegisters = new HashMap<Local, Integer>();
    Map<Instruction, LocalRegisterAssignmentInformation> instructionRegisterMap = stmtV.getInstructionRegisterMap();
    if (Options.v().write_local_annotations()) {
        for (LocalRegisterAssignmentInformation assignment : stmtV.getParameterInstructionsList()) {
            if (assignment.getLocal().getName().equals("String_Node_Str"))
                continue;
            addRegisterAssignmentDebugInfo(assignment, seenRegisters, builder);
        }
    }
    for (BuilderInstruction ins : instructions) {
        Stmt origStmt = stmtV.getStmtForInstruction(ins);
        if (stmtV.getInstructionPayloadMap().containsKey(ins))
            builder.addLabel(labelAssinger.getLabelName(stmtV.getInstructionPayloadMap().get(ins)));
        if (origStmt != null) {
            for (Trap t : m.getActiveBody().getTraps()) {
                if (t.getBeginUnit() == origStmt || t.getEndUnit() == origStmt || t.getHandlerUnit() == origStmt) {
                    labelAssinger.getOrCreateLabel(origStmt);
                    break;
                }
            }
            String labelName = labelAssinger.getLabelName(origStmt);
            if (labelName != null && !builder.getLabel(labelName).isPlaced())
                builder.addLabel(labelName);
            if (stmtV.getStmtForInstruction(ins) != null) {
                List<Tag> tags = origStmt.getTags();
                for (Tag t : tags) {
                    if (t instanceof LineNumberTag) {
                        LineNumberTag lnt = (LineNumberTag) t;
                        builder.addLineNumber(lnt.getLineNumber());
                    } else if (t instanceof SourceFileTag) {
                        SourceFileTag sft = (SourceFileTag) t;
                        builder.addSetSourceFile(new ImmutableStringReference(sft.getSourceFile()));
                    }
                }
            }
        }
        builder.addInstruction(ins);
        LocalRegisterAssignmentInformation registerAssignmentTag = instructionRegisterMap.get(ins);
        if (registerAssignmentTag != null) {
            addRegisterAssignmentDebugInfo(registerAssignmentTag, seenRegisters, builder);
        }
    }
    for (int registersLeft : seenRegisters.values()) builder.addEndLocal(registersLeft);
    toTries(activeBody.getTraps(), stmtV, builder, labelAssinger);
    for (Label lbl : labelAssinger.getAllLabels()) if (!lbl.isPlaced())
        throw new RuntimeException("String_Node_Str" + lbl);
    return builder.getMethodImplementation();
}

Output:
     StmtVisitor stmtV = new StmtVisitor(m, initDetector);
-    toInstructions(units, stmtV);
+    Chain<Trap> traps = activeBody.getTraps();
+    Set<Unit> trapReferences = new HashSet<Unit>(traps.size() * 3);
+    for (Trap t : activeBody.getTraps()) {
+        trapReferences.add(t.getBeginUnit());
+        trapReferences.add(t.getEndUnit());
+        trapReferences.add(t.getHandlerUnit());
+    }
+    toInstructions(units, stmtV, trapReferences);
     int registerCount = stmtV.getRegisterCount();


Input:
public ResultList executeForResultList(Query q) {
    Log.trace("String_Node_Str" + q);
    demandConnector.requestConnection();
    try {
        SQLiteStatement s = db.prepare(q.getExecutableSql());
        int columnCount = s.columnCount();
        String[] colNames = new String[columnCount];
        List<Object[]> result = new ArrayList<Object[]>();
        int rowIndex = 0;
        while (s.step()) {
            Object[] row = new Object[columnCount];
            for (int j = 0; j < columnCount; j++) {
                row[j] = s.columnValue(j);
            }
            result.add(row);
            ++rowIndex;
        }
        if (result.size() > 0) {
            Object[][] resultArr = new Object[result.size()][columnCount];
            int i = 0;
            for (Object[] row : result) resultArr[i++] = row;
            for (int j = 0; j < columnCount; j++) {
                colNames[j] = s.getColumnName(j);
            }
            return new ResultList(colNames, resultArr);
        }
    } catch (SQLiteException ex) {
        throwError(ex);
    }
    return null;
}

Output:
 public ResultList executeForResultList(Query q) {
-    Log.trace("String_Node_Str" + q);
+    Log.trace("String_Node_Str", q);
     demandConnector.requestConnection();


Input:
private static void setRegexpFileValue(RegexpFileConnection connection, INode node, String repositoryValue) {
    if ("String_Node_Str".equals(repositoryValue)) {
        String value = getParameterValue(connection, node, "String_Node_Str");
        if (value != null) {
            connection.setFilePath(value);
        }
    }
    if ("String_Node_Str".equals(repositoryValue)) {
        String value = getParameterValue(connection, node, "String_Node_Str");
        if (value != null) {
            connection.setRowSeparatorValue(value);
        }
    }
    if ("String_Node_Str".equals(repositoryValue)) {
        IElementParameter param = node.getElementParameter("String_Node_Str");
        if (param != null) {
            String value = (String) param.getValue();
            if (value != null) {
                connection.setFieldSeparatorValue(value);
            }
        }
    }
    if ("String_Node_Str".equals(repositoryValue)) {
        String value = getParameterValue(connection, node, "String_Node_Str");
        if (value != null) {
            connection.setHeaderValue(value);
        }
    }
    if ("String_Node_Str".equals(repositoryValue)) {
        String value = getParameterValue(connection, node, "String_Node_Str");
        if (value != null) {
            connection.setFooterValue(value);
        }
    }
    if ("String_Node_Str".equals(repositoryValue)) {
        String value = getParameterValue(connection, node, "String_Node_Str");
        if (value != null) {
            connection.setLimitValue(value);
        }
    }
    if ("String_Node_Str".equals(repositoryValue)) {
        String value = getParameterValue(connection, node, "String_Node_Str");
        if (value != null) {
            connection.setRemoveEmptyRow(Boolean.valueOf(value).booleanValue());
        }
    }
    if ("String_Node_Str".equals(repositoryValue)) {
        String value = getParameterValue(connection, node, "String_Node_Str");
        if (value != null) {
            connection.setEncoding(value);
        }
    }
}

Output:
     }
-    if ("String_Node_Str".equals(repositoryValue)) {
-        String value = getParameterValue(connection, node, "String_Node_Str");
+    if ("String_Node_Str".equals(param.getRepositoryValue())) {
+        String value = getParameterValue(connection, node, param);
         if (value != null) {