Input:
private static java.lang.reflect.Field getIdFieldForClass(Class<?> clazz) {
    for (java.lang.reflect.Field f : clazz.getDeclaredFields()) if (f.isAnnotationPresent(Id.class))
        return f;
    return null;
}

Output:
 private static java.lang.reflect.Field getIdFieldForClass(Class<?> clazz) {
-    for (java.lang.reflect.Field f : clazz.getDeclaredFields()) if (f.isAnnotationPresent(Id.class))
-        return f;
+    for (java.lang.reflect.Field f : clazz.getDeclaredFields()) {
+        if (f.isAnnotationPresent(Id.class)) {
+            return f;
+        }
+    }
     return null;


Input:
public void testCall() throws Exception {
    String browserId = "String_Node_Str";
    String serverAddress = "String_Node_Str";
    final BrowserInfo browserInfo = new BrowserInfo();
    browserInfo.setId(Long.parseLong(browserId));
    browserInfo.setServerReceivedHeartbeat(true);
    final FakeJsTestDriverClient client = new FakeJsTestDriverClient(Lists.newArrayList(browserInfo));
    final FakeBrowserRunner runner = new FakeBrowserRunner();
    final FakeBrowserActionRunner browserActionRunner = new FakeBrowserActionRunner();
    final BrowserManagedRunner browserRunner = new BrowserManagedRunner(runner, browserId, serverAddress, client, browserActionRunner, new NullStopWatch());
    browserRunner.call();
}

Output:
     final FakeBrowserActionRunner browserActionRunner = new FakeBrowserActionRunner();
-    final BrowserManagedRunner browserRunner = new BrowserManagedRunner(runner, browserId, serverAddress, client, browserActionRunner, new NullStopWatch());
+    final BrowserCallable<Collection<ResponseStream>> browserRunner = new BrowserCallable<Collection<ResponseStream>>(browserActionRunner, browserId, new BrowserControl(runner, serverAddress, new NullStopWatch(), client));
     browserRunner.call();


Input:
public static byte[] getBytes(String str) {
    try {
        return str.getBytes("String_Node_Str");
    } catch (java.io.UnsupportedEncodingException e) {
        throw new Error("String_Node_Str" + e.getMessage());
    }
}

Output:
         return str.getBytes("String_Node_Str");
-    } catch (java.io.UnsupportedEncodingException e) {
+    } catch (UnsupportedEncodingException e) {
         throw new Error("String_Node_Str" + e.getMessage());


Input:
protected void addScanJar(File jarFile) throws IOException {
    try {
        if (!jarFile.exists()) {
            return;
        }
        scannedURI.add(jarFile.toURI());
        if (processAllClasses) {
            JarFile jf = null;
            try {
                jf = new JarFile(jarFile);
                Enumeration<JarEntry> entriesEnum = jf.entries();
                while (entriesEnum.hasMoreElements()) {
                    JarEntry je = entriesEnum.nextElement();
                    if (je.getName().endsWith("String_Node_Str")) {
                        addEntry(je);
                    }
                }
            } finally {
                if (jf != null)
                    jf.close();
            }
        } else {
            classParser.parse(jarFile, null);
        }
    } catch (ZipException ze) {
        logger.log(Level.WARNING, ze.getMessage() + "String_Node_Str" + jarFile.getPath());
    }
}

Output:
         scannedURI.add(jarFile.toURI());
-        if (processAllClasses) {
-            JarFile jf = null;
-            try {
-                jf = new JarFile(jarFile);
-                Enumeration<JarEntry> entriesEnum = jf.entries();
-                while (entriesEnum.hasMoreElements()) {
-                    JarEntry je = entriesEnum.nextElement();
-                    if (je.getName().endsWith("String_Node_Str")) {
-                        addEntry(je);
-                    }
-                }
-            } finally {
-                if (jf != null)
-                    jf.close();
-            }
-        } else {
+        if (needScanAnnotation) {
             classParser.parse(jarFile, null);


Input:
public void load(NBTTagCompound nbt) {
    int rods = nbt.getInteger("String_Node_Str");
    int plates = nbt.getInteger("String_Node_Str");
    if (rods > 0) {
        addRods(rods);
    }
    if (plates > 0) {
        addPlates(plates);
    }
    if (nbt.hasKey("String_Node_Str")) {
        rocketComputer = ItemStack.loadItemStackFromNBT(nbt.getCompoundTag("String_Node_Str"));
        if (rocketComputer != null && !(rocketComputer.getItem() instanceof IModuleItem)) {
            System.out.println("String_Node_Str");
        }
    }
    if (nbt.hasKey("String_Node_Str")) {
        rocketEngine = ItemStack.loadItemStackFromNBT(nbt.getCompoundTag("String_Node_Str"));
        if (rocketEngine != null && !(rocketEngine.getItem() instanceof IModuleItem)) {
            System.out.println("String_Node_Str");
        }
    }
    if (nbt.hasKey("String_Node_Str")) {
        warhead = ItemStack.loadItemStackFromNBT(nbt.getCompoundTag("String_Node_Str"));
        if (warhead != null && !(warhead.getItem() instanceof IModuleItem)) {
            System.out.println("String_Node_Str");
        }
    }
    if (nbt.hasKey("String_Node_Str", 10)) {
        itemsUsed.clear();
        NBTTagList list = nbt.getTagList("String_Node_Str", 10);
        for (int i = 0; i < list.tagCount(); i++) {
            ItemStack stack = ItemStack.loadItemStackFromNBT(list.getCompoundTagAt(i));
            if (stack != null) {
                itemsUsed.add(stack);
            } else {
                Engine.error("String_Node_Str" + this + "String_Node_Str" + list.getStringTagAt(i));
            }
        }
    } else {
        if (rods > 0) {
            addItems(ROD_ORE_NAME, rods);
        }
        if (plates > 0) {
            addItems(PLATE_ORE_NAME, plates);
        }
    }
}

Output:
         if (rods > 0) {
-            addItems(ROD_ORE_NAME, rods);
+            addItems(OreNames.ROD_IRON, rods);
         }


Input:
public void handleExternalEvent(IUniqueObject eventTrigger, IEventContainer eventContainer) {
    switch(eventContainer.getEventType()) {
        case LOAD_PATHWAY_BY_GENE:
            IDListEventContainer<Integer> idContainer = (IDListEventContainer<Integer>) eventContainer;
            if (idContainer.getIDType() == EIDType.DAVID) {
                int iGraphItemID = 0;
                ArrayList<ICaleydoGraphItem> alPathwayVertexGraphItem = new ArrayList<ICaleydoGraphItem>();
                for (Integer iDavidID : idContainer.getIDs()) {
                    iGraphItemID = generalManager.getPathwayItemManager().getPathwayVertexGraphItemIdByDavidId(iDavidID);
                    if (iGraphItemID == -1)
                        continue;
                    PathwayVertexGraphItem tmpPathwayVertexGraphItem = ((PathwayVertexGraphItem) generalManager.getPathwayItemManager().getItem(iGraphItemID));
                    if (tmpPathwayVertexGraphItem == null)
                        continue;
                    alPathwayVertexGraphItem.add(tmpPathwayVertexGraphItem);
                }
                if (!alPathwayVertexGraphItem.isEmpty()) {
                    loadDependentPathways(alPathwayVertexGraphItem);
                }
            } else {
                throw new IllegalStateException("String_Node_Str");
            }
            break;
        case LOAD_PATHWAY_BY_PATHWAY_ID:
            IDListEventContainer<Integer> pathwayIDContainer = (IDListEventContainer<Integer>) eventContainer;
            for (Integer iPathwayID : pathwayIDContainer.getIDs()) {
                addPathwayView(iPathwayID);
            }
            break;
        case SELECTION_UPDATE:
            lastSelectionDelta = ((DeltaEventContainer<ISelectionDelta>) eventContainer).getSelectionDelta();
    }
    bUpdateOffScreenTextures = true;
}

Output:
             IDListEventContainer<Integer> idContainer = (IDListEventContainer<Integer>) eventContainer;
-            if (idContainer.getIDType() == EIDType.DAVID) {
+            if (idContainer.getIDType() == EIDType.REFSEQ_MRNA_INT) {
                 int iGraphItemID = 0;


Input:
private void ensureConfigReady(final Config c, final String adminListenerProtocol) throws TransactionFailure, PropertyVetoException {
    final NetworkConfig nc = c.getNetworkConfig();
    final NetworkListener nl = nc.getNetworkListener(SecureAdminCommand.ADMIN_LISTENER_NAME);
    if (nl != null) {
        return;
    }
    final Config config_w = writableConfig(c);
    final NetworkListener nl_w = createAdminNetworkListener(transaction(), nc, adminListenerProtocol);
    final VirtualServer vs_w = createAdminVirtualServer(transaction(), config_w);
}

Output:
     final Config config_w = writableConfig(c);
-    final NetworkListener nl_w = createAdminNetworkListener(transaction(), nc, adminListenerProtocol);
-    final VirtualServer vs_w = createAdminVirtualServer(transaction(), config_w);
+    createAdminNetworkListener(transaction(), nc, adminListenerProtocol);
+    createAdminVirtualServer(transaction(), config_w);
 }


Input:
public void finish(RandomAccessSequenceCache randomAccessGenome, AlignmentToPileupMode.OutputFormat outputFormat) {
    if (randomAccessGenome != null) {
        Sequence seq = new Sequence();
        MutableString clippedBases = new MutableString();
        for (int position = startPosition - maxVariationLength; position <= endPosition + 50; position++) {
            final String targetId = getReferenceId(startReferenceIndex).toString();
            clippedBases.append(randomAccessGenome.get(targetId, position));
        }
        seq.basename = "String_Node_Str" + randomAccessGenome.getBasename() + "String_Node_Str";
        writeSequence(outputFormat, seq, seq.basename, clippedBases);
    }
    for (String basename : basenameIds) {
        int i = 0;
        for (Sequence seq : sequenceBuffers) {
            if (seq.basename.equals(basename)) {
                final MutableString bases = sequenceBuffers.get(i).bases;
                if (bases.length() > startFlapStart) {
                    final String shortBasename = FilenameUtils.getBaseName(AlignmentReaderImpl.getBasename(seq.basename));
                    final MutableString clippedBases = bases.substring(Math.max(0, startFlapStart - maxVariationLength));
                    writeSequence(outputFormat, seq, shortBasename, clippedBases);
                }
            }
            i++;
        }
    }
}

Output:
                 if (bases.length() > startFlapStart) {
-                    final String shortBasename = FilenameUtils.getBaseName(AlignmentReaderImpl.getBasename(seq.basename));
+                    final String shortBasename = FilenameUtils.getName(AlignmentReaderImpl.getBasename(seq.basename));
                     final MutableString clippedBases = bases.substring(Math.max(0, startFlapStart - maxVariationLength));


Input:
public void onGestureTypingInputStart(int x, int y, long eventTime) {
    gestureTypingDetector.clearGesture();
    gestureTypingDetector.addPoint(x, y, eventTime);
}

Output:
 public void onGestureTypingInputStart(int x, int y, long eventTime) {
-    gestureTypingDetector.clearGesture();
-    gestureTypingDetector.addPoint(x, y, eventTime);
+    mGestureTypingDetector.clearGesture();
+    mGestureTypingDetector.addPoint(x, y, eventTime);
 }


Input:
public boolean setClient(Workspace workspace) throws Exception {
    if (isUnicode()) {
        String charset = "String_Node_Str";
        connection.setCharsetName(charset);
    }
    iclient = workspace.setClient(connection, authorisationConfig.getUsername());
    if (!isClientValid(workspace)) {
        return false;
    }
    if (workspace instanceof StaticWorkspaceImpl) {
        connection.setCurrentClient(iclient);
        return true;
    }
    if (workspace.getRootPath() != null) {
        iclient.setRoot(workspace.getRootPath());
    }
    if (workspace.getHostName() != null) {
        iclient.setHostName(workspace.getHostName());
    }
    IClientOptions options = iclient.getOptions();
    options.setClobber(true);
    iclient.setOptions(options);
    iclient.update();
    connection.setCurrentClient(iclient);
    return true;
}

Output:
     if (!isClientValid(workspace)) {
-        return false;
+        String err = "String_Node_Str" + workspace.getFullName();
+        throw new AbortException(err);
     }


Input:
public void onFailure(Throwable caught) {
    if (caught instanceof SquareException) {
        SquareException se = (SquareException) caught;
        switch(se.getType()) {
            case authorization:
                Window.alert(messages.rateAuthorization());
                break;
            default:
                Window.alert(messages.error());
                break;
        }
    } else {
        Window.alert(messages.error());
    }
}

Output:
             case authorization:
-                Window.alert(messages.rateAuthorization());
+                Window.alert(messages.QAAuthorization());
                 break;


Input:
protected Highlight getHighlight(double xPosition, double yPosition) {
    int setCount = mData.getDataSetCount();
    int valCount = mData.getXValCount();
    if (!mData.isGrouped()) {
        int dataSetIndex = 0;
        int xIndex = (int) Math.round(xPosition);
        if (xIndex < 0) {
            xIndex = 0;
            dataSetIndex = 0;
        } else if (xIndex >= valCount) {
            xIndex = valCount - 1;
            dataSetIndex = setCount - 1;
        }
        if (dataSetIndex < 0)
            dataSetIndex = 0;
        else if (dataSetIndex >= setCount)
            dataSetIndex = setCount - 1;
        if (!mData.getDataSetByIndex(dataSetIndex).isStacked())
            return new Highlight(xIndex, dataSetIndex);
        else
            return getStackedHighlight(xIndex, dataSetIndex, yPosition);
    } else {
        int steps = (int) ((float) xPosition / ((float) setCount + mData.getGroupSpace()));
        float groupSpaceSum = mData.getGroupSpace() * (float) steps;
        float baseNoSpace = (float) xPosition - groupSpaceSum;
        if (mLogEnabled)
            Log.i(LOG_TAG, "String_Node_Str" + xPosition + "String_Node_Str" + steps + "String_Node_Str" + groupSpaceSum + "String_Node_Str" + baseNoSpace);
        int dataSetIndex = (int) baseNoSpace % setCount;
        int xIndex = (int) baseNoSpace / setCount;
        if (mLogEnabled)
            Log.i(LOG_TAG, "String_Node_Str" + xIndex + "String_Node_Str" + dataSetIndex);
        if (xIndex < 0) {
            xIndex = 0;
            dataSetIndex = 0;
        } else if (xIndex >= valCount) {
            xIndex = valCount - 1;
            dataSetIndex = setCount - 1;
        }
        if (dataSetIndex < 0)
            dataSetIndex = 0;
        else if (dataSetIndex >= setCount)
            dataSetIndex = setCount - 1;
        if (!mData.getDataSetByIndex(dataSetIndex).isStacked())
            return new Highlight(xIndex, dataSetIndex);
        else
            return getStackedHighlight(xIndex, dataSetIndex, yPosition);
    }
}

Output:
     if (!mData.isGrouped()) {
-        int dataSetIndex = 0;
-        int xIndex = (int) Math.round(xPosition);
+        xIndex = (int) Math.round(xPosition);
         if (xIndex < 0) {


Input:
public void testParseNetworkErrorCantRetry() throws VolleyError {
    when(requeuePolicy.shouldRequeue(any(NetworkResponse.class))).thenReturn(true);
    final RetryPolicy retryPolicy = mock(RetryPolicy.class);
    doThrow(VolleyError.class).when(retryPolicy).retry(any(VolleyError.class));
    when(request.getRetryPolicy()).thenReturn(retryPolicy);
    final VolleyError error = mock(VolleyError.class);
    final VolleyError volleyError = decorator.parseNetworkError(error);
    assertNotNull(volleyError);
    verify(requeuePolicy, never()).executeBeforeRequeueing(any(Listener.class), any(ErrorListener.class));
}

Output:
 public void testParseNetworkErrorCantRetry() throws VolleyError {
-    when(requeuePolicy.shouldRequeue(any(NetworkResponse.class))).thenReturn(true);
+    when(requeuePolicy.shouldRequeue(any(NetworkResponse.class))).thenReturn(Boolean.TRUE);
     final RetryPolicy retryPolicy = mock(RetryPolicy.class);


Input:
public void testCompleteAsyncOfCompletedStage() throws Exception {
    ManagedCompletableFuture<Integer> cf0;
    try {
        cf0 = (ManagedCompletableFuture<Integer>) ManagedCompletableFuture.completedFuture(90);
    } catch (UnsupportedOperationException x) {
        if (AT_LEAST_JAVA_9)
            throw x;
        else
            return;
    }
    CompletableFuture<Integer> cf1 = cf0.completeAsync(() -> 900);
    assertSame(cf0, cf1);
    assertEquals(Integer.valueOf(90), cf0.join());
}

Output:
 public void testCompleteAsyncOfCompletedStage() throws Exception {
-    ManagedCompletableFuture<Integer> cf0;
+    ManagedCompletableFuture<Integer> cf0 = (ManagedCompletableFuture<Integer>) ManagedCompletableFuture.completedFuture(90);
+    CompletableFuture<Integer> cf1;
     try {


Input:
public static String replaceCRLFInMEMO_SQL(String original) {
    if (original == null || original.trim().length() == 0) {
        return original;
    }
    StringBuilder result = new StringBuilder();
    int leftQuotes = original.indexOf("String_Node_Str");
    int rightQuotes = original.indexOf("String_Node_Str", leftQuotes + 1);
    int fakeRightQuotes = getFakeRightQuotes(original, leftQuotes);
    while (rightQuotes == fakeRightQuotes + 1) {
        rightQuotes = original.indexOf("String_Node_Str", rightQuotes + 1);
        fakeRightQuotes = getFakeRightQuotes(original, fakeRightQuotes);
    }
    int leftPrev = 0;
    while (leftQuotes >= 0 && rightQuotes > leftQuotes) {
        if (leftQuotes > leftPrev) {
            result.append(original.substring(leftPrev, leftQuotes));
        }
        if (leftQuotes < rightQuotes) {
            int current = leftQuotes;
            while (rightQuotes + 1 - current > 120) {
                int Offset = 120;
                while (original.charAt(current + Offset - 1) == '\\') {
                    Offset--;
                }
                result.append(original.substring(current, current + Offset).replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str")).append("String_Node_Str");
                current += Offset;
                Offset = 120;
            }
            result.append(original.substring(current, rightQuotes + 1).replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str"));
        }
        leftQuotes = original.indexOf("String_Node_Str", rightQuotes + 1);
        leftPrev = rightQuotes + 1;
        rightQuotes = original.indexOf("String_Node_Str", leftQuotes + 1);
        fakeRightQuotes = getFakeRightQuotes(original, leftQuotes);
        while (rightQuotes == fakeRightQuotes + 1) {
            rightQuotes = original.indexOf("String_Node_Str", rightQuotes + 1);
            fakeRightQuotes = getFakeRightQuotes(original, fakeRightQuotes);
        }
    }
    result.append(original.substring(leftPrev));
    return result.toString();
}

Output:
                 }
-                result.append(original.substring(current, current + Offset).replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str")).append("String_Node_Str");
+                if (count > 500) {
+                    result.append(original.substring(current, current + Offset).replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str")).append("String_Node_Str");
+                    count = 0;
+                } else {
+                    result.append(original.substring(current, current + Offset).replace("String_Node_Str", "String_Node_Str").replace("String_Node_Str", "String_Node_Str")).append("String_Node_Str");
+                }
                 current += Offset;


Input:
private MetaField processToMany(MetaClassSingle<?> ownerMeta, DboTableMeta t, Field field, String colName, Class entityType, Field fieldForKey) {
    if (!entityType.isAnnotationPresent(NoSqlEntity.class))
        throw new RuntimeException("String_Node_Str" + entityType.getName() + "String_Node_Str" + "String_Node_Str" + field.getDeclaringClass().getName() + "String_Node_Str" + field.getName() + "String_Node_Str");
    MetaAbstractClass<?> fkMeta = metaInfo.findOrCreate(entityType);
    if (field.getType().equals(CursorToMany.class)) {
        MetaCursorField metaField = metaCursorProvider.get();
        metaField.setup(t, field, colName, ownerMeta, fkMeta);
        return metaField;
    }
    if (!field.getType().equals(Map.class) && !field.getType().equals(List.class) && !field.getType().equals(Set.class) && !field.getType().equals(Collection.class))
        throw new RuntimeException("String_Node_Str" + field + "String_Node_Str");
    MetaToManyField metaField = metaListProvider.get();
    metaField.setup(t, field, colName, fkMeta, fieldForKey);
    return metaField;
}

Output:
 private MetaField processToMany(MetaClassSingle<?> ownerMeta, DboTableMeta t, Field field, String colName, Class entityType, Field fieldForKey) {
-    if (!entityType.isAnnotationPresent(NoSqlEntity.class))
-        throw new RuntimeException("String_Node_Str" + entityType.getName() + "String_Node_Str" + "String_Node_Str" + field.getDeclaringClass().getName() + "String_Node_Str" + field.getName() + "String_Node_Str");
-    MetaAbstractClass<?> fkMeta = metaInfo.findOrCreate(entityType);
+    Class<?> theSuperclass = null;
+    Class<?> type = entityType;
+    if (!entityType.isAnnotationPresent(NoSqlEntity.class)) {
+        if (!entityType.isAnnotationPresent(NoSqlDiscriminatorColumn.class))
+            throw new RuntimeException("String_Node_Str" + entityType + "String_Node_Str" + "String_Node_Str" + field.getDeclaringClass().getName() + "String_Node_Str" + field.getName());
+        theSuperclass = findSuperclassWithNoSqlEntity(entityType);
+        runOtherSuperclassChecks(entityType, field, theSuperclass);
+    }
+    MetaAbstractClass<?> fkMeta = metaInfo.findOrCreate(type);
+    if (theSuperclass != null) {
+        MetaClassInheritance meta = (MetaClassInheritance) fkMeta;
+        fkMeta = meta.findOrCreate(type, theSuperclass);
+    }
     if (field.getType().equals(CursorToMany.class)) {


Input:
protected int getClientCount() {
    return 2;
}

Output:
 protected int getClientCount() {
-    return 2;
+    return 1;
 }


Input:
private XValue removeQuotes(XValue v) {
    if (v.isXExpr())
        return v;
    String vs = v.toString();
    int vslen = vs.length();
    StringBuffer sb = new StringBuffer();
    char cQuote = 0;
    for (int i = 0; i < vslen; i++) {
        char c = vs.charAt(i);
        if (c == '\\' && i < vslen) {
            sb.append(c);
            c = vs.charAt(++i);
            sb.append(c);
            continue;
        }
        if (c == '"' || c == '\'') {
            if (c == cQuote) {
                cQuote = 0;
                continue;
            } else if (cQuote == 0) {
                cQuote = c;
                continue;
            }
        }
        sb.append(c);
    }
    String sbs = sb.toString();
    if (vs.equals(sbs))
        return v;
    else
        return new XValue(sbs);
}

Output:
         char c = vs.charAt(i);
-        if (c == '\\' && i < vslen) {
-            sb.append(c);
+        if (c == '\\' && i < vslen - 1) {
             c = vs.charAt(++i);


Input:
private List<Catalog> fillPostgresqlCatalogs(Connection dbConn, DatabaseMetaData dbJDBCMetadata, List<Catalog> catalogList) {
    DatabaseConnection databaseConnection = (DatabaseConnection) dbConn;
    String catalogName = databaseConnection.getSID();
    if (StringUtils.isEmpty(catalogName)) {
        catalogName = databaseConnection.getUsername();
    }
    if (StringUtils.isNotEmpty(catalogName)) {
        List<String> filterList = new ArrayList<String>();
        filterList.addAll(postFillCatalog(catalogList, filterList, TalendCWMService.getReadableName(dbConn, catalogName), dbConn));
        for (Catalog catalog : catalogList) {
            List<Schema> schemaList = new ArrayList<Schema>();
            try {
                schemaList = fillSchemaToCatalog(dbConn, dbJDBCMetadata, catalog, filterList);
                if (!schemaList.isEmpty() && schemaList.size() > 0) {
                    CatalogHelper.addSchemas(schemaList, catalog);
                }
            } catch (Throwable e) {
                log.info(e);
            }
            ConnectionHelper.addCatalog(catalog, dbConn);
        }
    }
    return catalogList;
}

Output:
         List<String> filterList = new ArrayList<String>();
-        filterList.addAll(postFillCatalog(catalogList, filterList, TalendCWMService.getReadableName(dbConn, catalogName), dbConn));
+        filterList.addAll(postFillCatalog(metaConnection, catalogList, filterList, TalendCWMService.getReadableName(dbConn, catalogName), dbConn));
         for (Catalog catalog : catalogList) {


Input:
public void onClosed() {
    CoreRegistry.setContext(context);
    if (environment != null) {
        EnvironmentSwitchHandler environmentSwitchHandler = context.get(EnvironmentSwitchHandler.class);
        environmentSwitchHandler.handleSwitchBackFromPreviewEnivronment(context);
        environment.close();
        environment = null;
    }
    ensurePreviewUnloaded();
    WorldConfigurator worldConfig = worldGenerator.getConfigurator();
    Map<String, Component> params = worldConfig.getProperties();
    if (params != null) {
        config.setModuleConfigs(worldGenerator.getUri(), params);
    }
    super.onClosed();
}

Output:
         EnvironmentSwitchHandler environmentSwitchHandler = context.get(EnvironmentSwitchHandler.class);
-        environmentSwitchHandler.handleSwitchBackFromPreviewEnivronment(context);
+        environmentSwitchHandler.handleSwitchBackFromPreviewEnvironment(subContext);
         environment.close();


Input:
private void download(final FileDownloader fd) {
    Bundle b = new Bundle();
    b.putString("String_Node_Str", "String_Node_Str");
    fd.set_notification(TargetActivity.class, b);
    downloaded_file = fd.get_file_name();
    try {
        Log.i("String_Node_Str", fd.download_url);
        progress_bar.setMax(0);
        progress_bar.setProgress(0);
        fd.download(new ProgressUpdateListener() {

            public void on_update(int downloaded_size) {
                Log.i("String_Node_Str", Long.toString(Thread.currentThread().getId()));
                Log.i("String_Node_Str", Integer.toString(downloaded_size));
                Log.i("String_Node_Str", Integer.toString(fd.get_file_size()));
                progress_bar.setMax(fd.get_file_size());
                progress_bar.setProgress(downloaded_size);
                Log.i("String_Node_Str", Integer.toString(progress_bar.getProgress()));
                Log.i("String_Node_Str", Integer.toString(progress_bar.getMax()));
                float num = (float) progress_bar.getProgress() / (float) progress_bar.getMax();
                int result = (int) (num * 100);
                Log.i("String_Node_Str", Integer.toString(result));
                result_view.setText(Integer.toString(result) + "String_Node_Str");
                if (progress_bar.getProgress() == progress_bar.getMax()) {
                    downloaded_file_view.setText(stored_dir + "String_Node_Str" + downloaded_file);
                }
            }
        });
    } catch (Exception e) {
        handler.obtainMessage(-1).sendToTarget();
        Log.i("String_Node_Str", e.getMessage());
        Log.i("String_Node_Str", e.toString());
        e.printStackTrace();
    }
}

Output:
         progress_bar.setProgress(0);
-        fd.download(new ProgressUpdateListener() {
+        fd2.download(new ProgressUpdateListener() {


Input:
public void displayURL(String url) throws Exception {
    try {
        IWebBrowser browser = getExternalBrowser();
        if (browser != null) {
            browser.openURL(new URL(url));
        }
    } catch (PartInitException pie) {
        ViewerPlugin.logError(pie.getLocalizedMessage(), pie);
    }
}

Output:
     try {
-        IWebBrowser browser = getExternalBrowser();
+        browser = getExternalBrowser();
         if (browser != null) {


Input:
private int calcTextPosition(int byteOffset) {
    int rowIndex = byteOffset / bytesPerRow;
    int colIndex = byteOffset % bytesPerRow;
    return (75 * rowIndex) + 10 + (colIndex * 3);
}

Output:
     int colIndex = byteOffset % bytesPerRow;
-    return (75 * rowIndex) + 10 + (colIndex * 3);
+    return (76 * rowIndex) + 10 + (colIndex * 3);
 }


Input:
protected boolean isMatchedBy2(ParsableHeaderValue matchTry) {
    if (matchTry.parameter == null) {
        return true;
    }
    if (parameter == null) {
        return false;
    }
    for (Entry<String, String> requiredParameter : matchTry.parameter.entrySet()) {
        String parameterValueToTest = parameter.get(requiredParameter.getKey());
        String requiredParamVal = requiredParameter.getValue();
        if (parameterValueToTest == null || (requiredParamVal != null && !requiredParamVal.equals(parameterValueToTest))) {
            return false;
        }
    }
    return true;
}

Output:
         String requiredParamVal = requiredParameter.getValue();
-        if (parameterValueToTest == null || (requiredParamVal != null && !requiredParamVal.equals(parameterValueToTest))) {
+        if (parameterValueToTest == null || (requiredParamVal != EMPTY && !requiredParamVal.equals(parameterValueToTest))) {
             return false;


Input:
private void updateFormLoginConfiguration(String loginPage, String errorPage, SecurityMetadata securityMetadata) {
    if (loginPage != null && errorPage != null) {
        FormLoginConfiguration flc = new FormLoginConfigurationImpl(loginPage, errorPage);
        LoginConfiguration lc = new LoginConfigurationImpl(LoginConfiguration.FORM, null, flc);
        securityMetadata.setLoginConfiguration(lc);
        if (tc.isDebugEnabled())
            Tr.debug(tc, "String_Node_Str" + lc);
    }
}

Output:
         LoginConfiguration lc = new LoginConfigurationImpl(LoginConfiguration.FORM, null, flc);
-        securityMetadata.setLoginConfiguration(lc);
+        getSecurityMetadata().setLoginConfiguration(lc);
         if (tc.isDebugEnabled())


Input:
private Object getGenericRepositoryValue(GenericConnection connection, String value, IMetadataTable table) {
    if (connection == null) {
        return null;
    }
    String serialized = connection.getCompProperties();
    if (serialized != null) {
        Deserialized fromSerialized = ComponentProperties.fromSerialized(serialized);
        if (fromSerialized != null) {
            ComponentProperties componentProperties = fromSerialized.properties;
            String tableName = null;
            if (IComponentConstants.SCHEMA.equals(value)) {
                if (table != null) {
                    tableName = table.getTableName();
                    if (tableName != null) {
                        return table.getId() + "String_Node_Str" + tableName;
                    }
                }
            } else if (IComponentConstants.MODULENAME.equals(value)) {
                return tableName;
            } else {
                return ComponentsUtils.getGenericPropertyValue(componentProperties, value);
            }
        }
    }
    return null;
}

Output:
             } else if (IComponentConstants.MODULENAME.equals(value)) {
-                return tableName;
+                if (ComponentsUtils.getGenericPropertyValue(componentProperties, value) != null) {
+                    return ComponentsUtils.getGenericPropertyValue(componentProperties, value);
+                } else {
+                    return "String_Node_Str";
+                }
             } else {


Input:
private void initUIContentForCompFacet(XSDSimpleTypeDefinition baseTypeDef) {
    if (baseTypeDef == null) {
        compProperty.setPropertySources(new IPropertySource<?>[0]);
        return;
    }
    List<IPropertySource<?>> propertySources = new ArrayList<IPropertySource<?>>();
    for (String eachFacetName : baseTypeDef.getValidFacets()) {
        IPropertySource<?> propSource = SimpleTypeFacetPropSourceBuilder.createFacetPropSource(xsdSimpleType, baseTypeDef, eachFacetName, compProperty.getPropertyViewer().getTree());
        if (propSource == null)
            continue;
        propertySources.add(propSource);
    }
    compProperty.setPropertySources(propertySources.toArray(new IPropertySource<?>[0]));
}

Output:
         IPropertySource<?> propSource = SimpleTypeFacetPropSourceBuilder.createFacetPropSource(xsdSimpleType, baseTypeDef, eachFacetName, compProperty.getPropertyViewer().getTree());
-        if (propSource == null)
+        if (propSource == null) {
             continue;


Input:
static String[] parseForTypeSignatures(String typeSigs) {
    ArrayList<String> sigs = new ArrayList<String>(10);
    int i = 1;
    while (true) {
        switch(typeSigs.charAt(i++)) {
            case TypeReference.VoidTypeCode:
                sigs.add(TypeReference.VoidName.toString());
                continue;
            case TypeReference.BooleanTypeCode:
                sigs.add(TypeReference.BooleanName.toString());
                continue;
            case TypeReference.ByteTypeCode:
                sigs.add(TypeReference.ByteName.toString());
                continue;
            case TypeReference.ShortTypeCode:
                sigs.add(TypeReference.ShortName.toString());
                continue;
            case TypeReference.IntTypeCode:
                sigs.add(TypeReference.IntName.toString());
                continue;
            case TypeReference.LongTypeCode:
                sigs.add(TypeReference.LongName.toString());
                continue;
            case TypeReference.FloatTypeCode:
                sigs.add(TypeReference.FloatName.toString());
                continue;
            case TypeReference.DoubleTypeCode:
                sigs.add(TypeReference.DoubleName.toString());
                continue;
            case TypeReference.CharTypeCode:
                sigs.add(TypeReference.CharName.toString());
                continue;
            case TypeReference.ClassTypeCode:
                {
                    int off = i - 1;
                    int depth = 0;
                    while (typeSigs.charAt(i++) != ';' || depth > 0) {
                        if (typeSigs.charAt(i - 1) == '<') {
                            depth++;
                        }
                        if (typeSigs.charAt(i - 1) == '>') {
                            depth--;
                        }
                    }
                    sigs.add(typeSigs.substring(off, i));
                    continue;
                }
            case TypeReference.ArrayTypeCode:
                {
                    int off = i - 1;
                    i++;
                    int depth = 0;
                    while (typeSigs.charAt(i++) != ';' || depth > 0) {
                        if (typeSigs.charAt(i - 1) == '<') {
                            depth++;
                        }
                        if (typeSigs.charAt(i - 1) == '>') {
                            depth--;
                        }
                    }
                    sigs.add(typeSigs.substring(off, i));
                    continue;
                }
            case (byte) 'T':
                {
                    int off = i - 1;
                    while (typeSigs.charAt(i++) != ';') ;
                    sigs.add(typeSigs.substring(off, i));
                    continue;
                }
            case (byte) ')':
                int size = sigs.size();
                if (size == 0) {
                    return null;
                }
                Iterator<String> it = sigs.iterator();
                String[] result = new String[size];
                for (int j = 0; j < size; j++) {
                    result[j] = it.next();
                }
                return result;
            default:
                if (Assertions.verifyAssertions) {
                    Assertions._assert(false, "String_Node_Str" + typeSigs);
                }
        }
    }
}

Output:
                 {
-                    int off = i - 1;
-                    i++;
-                    int depth = 0;
-                    while (typeSigs.charAt(i++) != ';' || depth > 0) {
-                        if (typeSigs.charAt(i - 1) == '<') {
-                            depth++;
-                        }
-                        if (typeSigs.charAt(i - 1) == '>') {
-                            depth--;
-                        }
+                    System.err.println(typeSigs + "String_Node_Str" + i);
+                    switch(typeSigs.charAt(i)) {
+                        case TypeReference.BooleanTypeCode:
+                        case TypeReference.ByteTypeCode:
+                        case TypeReference.IntTypeCode:
+                            sigs.add(typeSigs.substring(i - 1, i + 1));
+                            break;
+                        case 'T':
+                        case TypeReference.ClassTypeCode:
+                            int off = i - 1;
+                            i++;
+                            int depth = 0;
+                            while (typeSigs.charAt(i++) != ';' || depth > 0) {
+                                if (typeSigs.charAt(i - 1) == '<') {
+                                    depth++;
+                                }
+                                if (typeSigs.charAt(i - 1) == '>') {
+                                    depth--;
+                                }
+                            }
+                            sigs.add(typeSigs.substring(off, i));
+                            break;
+                        default:
+                            Assertions.UNREACHABLE("String_Node_Str" + typeSigs.charAt(i));
                     }


Input:
public Symbol rl_build_template_instantiation(Instantiation my_template_instance, Token tok, WmeImpl w) {
    Production my_template = my_template_instance.prod;
    MakeAction my_action = my_template.action_list.asMakeAction();
    boolean chunk_var = this.chunker.variablize_this_chunk;
    IdentifierImpl id = my_agent.recMemory.instantiate_rhs_value(my_action.id, -1, 's', tok, w).asIdentifier();
    SymbolImpl attr = my_agent.recMemory.instantiate_rhs_value(my_action.attr, id.level, 'a', tok, w);
    char first_letter = attr.getFirstLetter();
    SymbolImpl value = my_agent.recMemory.instantiate_rhs_value(my_action.value, id.level, first_letter, tok, w);
    SymbolImpl referent = my_agent.recMemory.instantiate_rhs_value(my_action.referent, id.level, first_letter, tok, w);
    this.chunker.variablize_this_chunk = true;
    this.chunker.variablization_tc = -1;
    MakeAction new_action = rl_make_simple_action(id, attr, value, referent);
    new_action.preference_type = PreferenceType.NUMERIC_INDIFFERENT;
    StringSymbol new_name_symbol;
    String new_name = "String_Node_Str";
    String empty_string = "String_Node_Str";
    int new_id = 0;
    do {
        new_id = rl_next_template_id();
        new_name = ("String_Node_Str" + empty_string + my_template.getName().getValue() + "String_Node_Str" + new_id);
    } while (my_agent.getSymbols().findString(new_name) != null);
    new_name_symbol = my_agent.getSymbols().createString(new_name);
    ByRef<Condition> cond_top = ByRef.create(null);
    ByRef<Condition> cond_bottom = ByRef.create(null);
    Condition.copy_condition_list(my_template_instance.top_of_instantiated_conditions, cond_top, cond_bottom);
    rl_add_goal_or_impasse_tests_to_conds(cond_top.value);
    variableGenerator.reset(cond_top.value, null);
    this.chunker.variablization_tc = my_agent.syms.get_new_tc_number();
    this.chunker.variablize_condition_list(cond_top.value);
    this.chunker.variablize_nots_and_insert_into_conditions(my_template_instance.nots, cond_top.value);
    Production new_production = new Production(ProductionType.USER, new_name_symbol, cond_top.value, cond_bottom.value, new_action);
    try {
        ((DefaultProductionManager) my_agent.getProductions()).addProduction(new_production, false);
    } catch (ReordererException e) {
        e.printStackTrace();
    }
    this.chunker.variablize_this_chunk = chunk_var;
    return new_name_symbol;
}

Output:
     rl_add_goal_or_impasse_tests_to_conds(cond_top.value);
-    variableGenerator.reset(cond_top.value, null);
+    this.chunker.variableGenerator.reset(cond_top.value, null);
     this.chunker.variablization_tc = my_agent.syms.get_new_tc_number();


Input:
protected void onResponse(ListOrganizations organizations, boolean refreshing) {
    if (adapter == null) {
        setUpList();
    }
    adapter.addAll(organizations, paging);
}

Output:
 protected void onResponse(ListOrganizations organizations, boolean refreshing) {
-    if (adapter == null) {
-        setUpList();
+    getListView().setDivider(null);
+    if (getListAdapter() != null) {
+        adapter.addAll(organizations, paging);
+    } else if (adapter == null) {
+        setUpList(organizations);
+    } else {
+        setListAdapter(adapter);
     }


Input:
public ServicePoolBuilder<S> withZooKeeperHostDiscovery(final ZooKeeperConnection connection) {
    checkNotNull(connection);
    return withHostDiscoverySource(new HostDiscoverySource() {
        public HostDiscovery forService(String serviceName) {
            HostDiscovery hostDiscovery = new ZooKeeperHostDiscovery(connection, serviceName);
            _closeHostDiscovery = true;
            return hostDiscovery;
        }
    });
}

Output:
         }
-    });
+    };
+    return withHostDiscoverySourceInternal(hostDiscoverySource, true);
 }


Input:
public FormIndex deleteRepeat(FormIndex index) {
    Vector indexes = new Vector();
    Vector multiplicities = new Vector();
    Vector elements = new Vector();
    collapseIndex(index, indexes, multiplicities, elements);
    for (int i = elements.size() - 1; i >= 0; i--) {
        IFormElement e = (IFormElement) elements.elementAt(i);
        if (e instanceof GroupDef && ((GroupDef) e).getRepeat()) {
            break;
        } else {
            indexes.removeElementAt(i);
            multiplicities.removeElementAt(i);
            elements.removeElementAt(i);
        }
    }
    FormIndex newIndex = buildIndex(indexes, multiplicities, elements);
    TreeReference deleteRef = getChildInstanceRef(newIndex);
    TreeElement deleteElement = mainInstance.resolveReference(deleteRef);
    TreeReference parentRef = deleteRef.getParentRef();
    TreeElement parentElement = mainInstance.resolveReference(parentRef);
    int childMult = deleteElement.getMult();
    parentElement.removeChild(deleteElement);
    for (int i = 0; i < parentElement.getNumChildren(); i++) {
        TreeElement child = parentElement.getChildAt(i);
        if (child.getMult() > childMult) {
            child.setMult(child.getMult() - 1);
        }
    }
    this.getMainInstance().cleanCache();
    triggerTriggerables(deleteRef);
    return newIndex;
}

Output:
         TreeElement child = parentElement.getChildAt(i);
-        if (child.getMult() > childMult) {
+        if (child.doFieldsMatch(deleteElement) && child.getMult() > childMult) {
             child.setMult(child.getMult() - 1);


Input:
public ODocument getConfiguration() {
    return new ODocument().fromJSON("String_Node_Str" + getCommonConfigurationParameters() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + stringArray2Json(ACTION.values()) + "String_Node_Str" + "String_Node_Str");
}

Output:
 public ODocument getConfiguration() {
-    return new ODocument().fromJSON("String_Node_Str" + getCommonConfigurationParameters() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + stringArray2Json(ACTION.values()) + "String_Node_Str" + "String_Node_Str");
+    return new ODocument().fromJSON("String_Node_Str" + getCommonConfigurationParameters() + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + stringArray2Json(ACTION.values()) + "String_Node_Str" + "String_Node_Str");
 }


Input:
private String getDefaultVersion(PomDependencyData dep) {
    String key = getDependencyMgtExtraInfoKey(dep.getGroupId(), dep.getArtifaceId());
    return (String) ivyModuleDescriptor.getExtraInfo().get(key);
}

Output:
 private String getDefaultVersion(PomDependencyData dep) {
-    String key = getDependencyMgtExtraInfoKey(dep.getGroupId(), dep.getArtifaceId());
+    String key = getDependencyMgtExtraInfoKey(dep.getGroupId(), dep.getArtifactId());
     return (String) ivyModuleDescriptor.getExtraInfo().get(key);


Input:
private HSTicketUpdate retrieveTicketUpdate(JSONObject updateObject, JSONArray usersArray) throws JSONException {
    int authorId = -1;
    String content = null;
    String updateId = null;
    String from = null;
    boolean publicNote = true;
    Date update_time = null;
    boolean isUpdateTypeUserReply = false;
    HSAttachment[] attachments = null;
    JSONArray eventsArray = updateObject.getJSONArray("String_Node_Str");
    int eventsArrayLength = eventsArray.length();
    for (int i = 0; i < eventsArrayLength; i++) {
        JSONObject eventObject = eventsArray.getJSONObject(i);
        if (eventObject.getString("String_Node_Str").equals("String_Node_Str")) {
            publicNote = eventObject.getBoolean("String_Node_Str");
            if (!publicNote) {
                return null;
            }
            content = eventObject.getString("String_Node_Str");
            if (!eventObject.isNull("String_Node_Str")) {
                authorId = eventObject.getInt("String_Node_Str");
            }
            JSONObject author = searchForUser(authorId, usersArray);
            if (!author.isNull("String_Node_Str")) {
                from = author.getString("String_Node_Str");
            }
            if (!updateObject.isNull("String_Node_Str")) {
                update_time = parseTime(updateObject.getString("String_Node_Str"));
            }
            String role = author.getString("String_Node_Str");
            if (role.equals("String_Node_Str")) {
                isUpdateTypeUserReply = true;
            }
            JSONArray attachmentObjects = eventObject.getJSONArray("String_Node_Str");
            if (attachmentObjects != null) {
                int length = attachmentObjects.length();
                ArrayList<HSAttachment> attachmentArray = new ArrayList<HSAttachment>();
                for (int j = 0; j < length; j++) {
                    JSONObject attachmentData = attachmentObjects.getJSONObject(j);
                    String attachment_url = attachmentData.getString("String_Node_Str");
                    if (attachment_url.startsWith("String_Node_Str")) {
                        attachment_url = instanceUrl.concat(attachment_url.substring(1));
                    }
                    HSAttachment attachData = HSAttachment.createAttachment(attachment_url, attachmentData.getString("String_Node_Str"), attachmentData.getString("String_Node_Str"));
                    attachmentArray.add(attachData);
                }
                attachments = attachmentArray.toArray(new HSAttachment[length]);
            }
        }
    }
    if (isUpdateTypeUserReply) {
        return HSTicketUpdate.createUpdateByUser(updateId, from, content, update_time, attachments);
    } else {
        return HSTicketUpdate.createUpdateByStaff(updateId, from, content, update_time, attachments);
    }
}

Output:
             JSONObject author = searchForUser(authorId, usersArray);
-            if (!author.isNull("String_Node_Str")) {
-                from = author.getString("String_Node_Str");
+            if (author != null) {
+                if (!author.isNull("String_Node_Str")) {
+                    from = author.getString("String_Node_Str");
+                }
+                String role = author.getString("String_Node_Str");
+                if (role.equals("String_Node_Str")) {
+                    isUpdateTypeUserReply = true;
+                }
             }


Input:
public JARFileMaker addChildren(final File folder) throws IOException {
    this.relativeStartCanonicalPath = folder.getCanonicalPath();
    for (final File f : folder.listFiles()) {
        this.add(f);
    }
    this.relativeStartCanonicalPath = null;
    return this;
}

Output:
     this.relativeStartCanonicalPath = folder.getCanonicalPath();
-    for (final File f : folder.listFiles()) {
-        this.add(f);
+    final File[] files = folder.listFiles();
+    if (files != null) {
+        for (final File f : files) {
+            this.add(f);
+        }
     }


Input:
public void onUseItemButton(UseItemButton event, EntityRef entity, CharacterHeldItemComponent characterHeldItemComponent) {
    if (!event.isDown()) {
        return;
    }
    EntityRef selectedItemEntity = characterHeldItemComponent.selectedItem;
    if (!selectedItemEntity.exists()) {
        return;
    }
    OnItemUseEvent onItemUseEvent = new OnItemUseEvent();
    entity.send(onItemUseEvent);
    if (!onItemUseEvent.isConsumed()) {
        localPlayer.activateOwnedEntityAsClient(selectedItemEntity);
        entity.saveComponent(characterHeldItemComponent);
        event.consume();
    }
}

Output:
     }
-    OnItemUseEvent onItemUseEvent = new OnItemUseEvent();
-    entity.send(onItemUseEvent);
-    if (!onItemUseEvent.isConsumed()) {
+    boolean requestIsValid;
+    if (networkSystem.getMode().isAuthority()) {
+        requestIsValid = true;
+    } else {
+        OnItemUseEvent onItemUseEvent = new OnItemUseEvent();
+        entity.send(onItemUseEvent);
+        requestIsValid = !onItemUseEvent.isConsumed();
+    }
+    if (requestIsValid) {
         localPlayer.activateOwnedEntityAsClient(selectedItemEntity);


Input:
public static final boolean exists(String name) {
    if (name == null)
        return false;
    if (!_loaded)
        load();
    name = name.toLowerCase();
    synchronized (_evals) {
        return _evals.containsKey(name);
    }
}

Output:
         load();
-    name = name.toLowerCase();
+    name = name.toLowerCase(java.util.Locale.ENGLISH);
     synchronized (_evals) {


Input:
private Endpoint getEndpoint(String id, boolean create) {
    Endpoint endpoint = null;
    boolean changed = false;
    synchronized (endpoints) {
        for (Iterator<WeakReference<Endpoint>> i = endpoints.iterator(); i.hasNext(); ) {
            Endpoint e = i.next().get();
            if (e == null) {
                i.remove();
                changed = true;
            } else if (e.getID().equals(id)) {
                endpoint = e;
            }
        }
        if (create && endpoint == null) {
            endpoint = new Endpoint(id);
            endpoint.addPropertyChangeListener(propertyChangeListener);
            endpoints.add(new WeakReference<Endpoint>(endpoint));
            changed = true;
            LoggingService loggingService = videobridge.getLoggingService();
            if (loggingService != null)
                loggingService.logEvent(EventFactory.endpointCreated(getID(), id));
        }
    }
    if (changed)
        firePropertyChange(ENDPOINTS_PROPERTY_NAME, null, null);
    return endpoint;
}

Output:
         if (create && endpoint == null) {
-            endpoint = new Endpoint(id);
+            endpoint = new Endpoint(id, this);
             endpoint.addPropertyChangeListener(propertyChangeListener);


Input:
public ItemStack transferStackInSlot(EntityPlayer player, int index) {
    ItemStack itemstack = null;
    Slot slot = (Slot) this.inventorySlots.get(index);
    if (slot != null && slot.getHasStack()) {
        ItemStack itemstack1 = slot.getStack();
        itemstack = itemstack1.copy();
        if (factory.isOutputSlot(index) || factory.isInputSlot(index)) {
            if (!mergeItemStacks(itemstack1, SlotType.SLOT_PLAYERINV, true)) {
                return null;
            }
            slot.onSlotChange(itemstack1, itemstack);
        } else if (factory.isGhostSlot(index)) {
            return null;
        } else if (factory.isPlayerInventorySlot(index)) {
            if (!mergeItemStacks(itemstack1, SlotType.SLOT_INPUT, false)) {
                if (!mergeItemStacks(itemstack1, SlotType.SLOT_PLAYERHOTBAR, false)) {
                    return null;
                }
            }
        } else if (factory.isPlayerHotbarSlot(index)) {
            if (!mergeItemStacks(itemstack1, SlotType.SLOT_INPUT, false)) {
                if (!mergeItemStacks(itemstack1, SlotType.SLOT_PLAYERINV, false)) {
                    return null;
                }
            }
        } else {
            System.out.println("String_Node_Str");
        }
        if (itemstack1.stackSize == 0) {
            slot.putStack(null);
        } else {
            slot.onSlotChanged();
        }
        if (itemstack1.stackSize == itemstack.stackSize) {
            return null;
        }
        slot.onPickupFromSlot(player, itemstack1);
    }
    return itemstack;
}

Output:
             slot.onSlotChange(itemstack1, itemstack);
-        } else if (factory.isGhostSlot(index)) {
+        } else if (factory.isGhostSlot(index) || factory.isGhostOutputSlot(index)) {
             return null;


Input:
public Boolean getInsured() {
    return Insured;
}

Output:
 public Boolean getInsured() {
-    return Insured;
+    if (Insured != null) {
+        return Insured;
+    } else {
+        return false;
+    }
 }


Input:
public DUC setAttribute(String attribute) {
    checkForBlankString("String_Node_Str", attribute);
    this.attribute = attribute;
    return (DUC) this;
}

Output:
     this.attribute = attribute;
-    return (DUC) this;
+    return (T) this;
 }


Input:
public void onPostExecute(String[] params, Person person) {
    if (person != null) {
        updateChapterUIFrom(person);
        updateOrganizersOnline(person);
    }
}

Output:
 public void onPostExecute(String[] params, Person person) {
-    if (person != null) {
+    if (person != null && getActivity() != null) {
         updateChapterUIFrom(person);


Input:
public void serviceChanged(ServiceEvent event) {
    Object sService = bundleContext.getService(event.getServiceReference());
    if (logger.isTraceEnabled())
        logger.trace("String_Node_Str" + sService.getClass().getName());
    if (!(sService instanceof ProtocolProviderService)) {
        return;
    }
    if (logger.isDebugEnabled())
        logger.debug("String_Node_Str");
    ProtocolProviderService provider = (ProtocolProviderService) sService;
    ProtocolProviderFactory sourceFactory = null;
    ServiceReference[] allBundleServices = event.getServiceReference().getBundle().getRegisteredServices();
    for (ServiceReference bundleServiceRef : allBundleServices) {
        Object service = bundleContext.getService(bundleServiceRef);
        if (service instanceof ProtocolProviderFactory) {
            sourceFactory = (ProtocolProviderFactory) service;
            break;
        }
    }
    if (event.getType() == ServiceEvent.REGISTERED) {
        if (logger.isDebugEnabled())
            logger.debug("String_Node_Str");
        String providerMask = System.getProperty(MetaContactListService.PROVIDER_MASK_PROPERTY);
        if (providerMask != null && providerMask.trim().length() > 0) {
            String servRefMask = (String) event.getServiceReference().getProperty(MetaContactListService.PROVIDER_MASK_PROPERTY);
            if (servRefMask == null || !servRefMask.equals(providerMask)) {
                if (logger.isDebugEnabled())
                    logger.debug("String_Node_Str" + provider.getAccountID());
                return;
            }
        }
        if (sourceFactory != null && currentlyInstalledProviders.containsKey(provider.getAccountID().getAccountUniqueID())) {
            if (logger.isDebugEnabled())
                logger.debug("String_Node_Str" + provider.getAccountID() + "String_Node_Str");
        }
        this.handleProviderAdded((ProtocolProviderService) sService);
    } else if (event.getType() == ServiceEvent.UNREGISTERING) {
        if (sourceFactory == null) {
            return;
        }
        AccountID accountID = provider.getAccountID();
        if (ContactlistActivator.getAccountManager().getStoredAccounts().contains(accountID)) {
            synchronized (this) {
                this.removeMetaContactListListener(storageManager);
                this.handleProviderRemoved((ProtocolProviderService) sService);
                this.addMetaContactListListener(storageManager);
            }
            return;
        }
        if (logger.isDebugEnabled())
            logger.debug("String_Node_Str" + provider.getAccountID() + "String_Node_Str" + "String_Node_Str");
        this.handleProviderRemoved((ProtocolProviderService) sService);
    }
}

Output:
     ProtocolProviderFactory sourceFactory = null;
-    ServiceReference[] allBundleServices = event.getServiceReference().getBundle().getRegisteredServices();
-    for (ServiceReference bundleServiceRef : allBundleServices) {
+    ServiceReference<?>[] allBundleServices = event.getServiceReference().getBundle().getRegisteredServices();
+    for (ServiceReference<?> bundleServiceRef : allBundleServices) {
         Object service = bundleContext.getService(bundleServiceRef);


Input:
private void hitScreenServer(EntityPlayer player, int x, int y, int module) {
    List<IScreenModule> screenModules = getScreenModules();
    IScreenModule<?> screenModule = screenModules.get(module);
    if (screenModule != null) {
        ItemStack itemStack = inventoryHelper.getStackInSlot(module);
        screenModule.mouseClick(getWorld(), x, y, true, player);
        if (screenModule instanceof IScreenModuleUpdater) {
            NBTTagCompound newCompound = ((IScreenModuleUpdater) screenModule).update(itemStack.getTagCompound(), getWorld(), player);
            if (newCompound != null) {
                itemStack.setTagCompound(newCompound);
                markDirtyClient();
            }
        }
        clickedModules.add(new ActivatedModule(module, 5, x, y));
    }
}

Output:
 private void hitScreenServer(EntityPlayer player, int x, int y, int module) {
-    List<IScreenModule> screenModules = getScreenModules();
+    List<IScreenModule<?>> screenModules = getScreenModules();
     IScreenModule<?> screenModule = screenModules.get(module);


Input:
protected int canExpunge(int size, Value<V> v) {
    return size > getMaxSize() || (System.currentTimeMillis() - v.access) > getLifetime() ? (EXPUNGE_YES | EXPUNGE_CONTINUE) : (EXPUNGE_NO | EXPUNGE_STOP);
}

Output:
 protected int canExpunge(int size, Value<V> v) {
-    return size > getMaxSize() || (System.currentTimeMillis() - v.access) > getLifetime() ? (EXPUNGE_YES | EXPUNGE_CONTINUE) : (EXPUNGE_NO | EXPUNGE_STOP);
+    return size >= getMaxSize() || (System.currentTimeMillis() - v.access) > getLifetime() ? (EXPUNGE_YES | EXPUNGE_CONTINUE) : (EXPUNGE_NO | EXPUNGE_STOP);
 }


Input:
public String getProgressStats() {
    String statistics = (String) executeCrawlJobCommand(PROGRESS_STATISTICS_COMMAND);
    if (statistics == null) {
        return "String_Node_Str";
    }
    return statistics;
}

Output:
 public String getProgressStats() {
-    String statistics = (String) executeCrawlJobCommand(PROGRESS_STATISTICS_COMMAND);
-    if (statistics == null) {
+    String status = (String) getCrawlJobAttribute(STATUS_ATTRIBUTE);
+    if (status == null) {
+        status = "String_Node_Str";
+    }
+    String progressStatistics = (String) executeCrawlJobCommand(PROGRESS_STATISTICS_COMMAND);
+    if (progressStatistics == null) {
         return "String_Node_Str";


Input:
public String applySql(String sql, boolean isSubquery, Integer limit, Integer offset) {
    if (limit == null && offset == null) {
        return sql;
    }
    StringBuilder sb = new StringBuilder(sql.length() + length);
    sb.append(sql);
    applySql(sb, isSubquery, limit == null ? null : "String_Node_Str", offset == null ? null : "String_Node_Str");
    return sb.toString();
}

Output:
     sb.append(sql);
-    applySql(sb, isSubquery, limit == null ? null : "String_Node_Str", offset == null ? null : "String_Node_Str");
+    if (supportsVariableLimit()) {
+        applySql(sb, isSubquery, limit == null ? null : "String_Node_Str", offset == null ? null : "String_Node_Str");
+    } else {
+        if (limitIncludesOffset() && offset != null && limit != null) {
+            applySql(sb, isSubquery, Integer.toString(limit + offset), offset.toString());
+        } else {
+            applySql(sb, isSubquery, limit == null ? null : limit.toString(), offset == null ? null : offset.toString());
+        }
+    }
     return sb.toString();


Input:
private void setMaxAlarmIconToAlarmRaised() {
    changeButtonIcon(nonTimeMaxLimitButton, nonTimeMaxLimitAlarmRaisedIcon);
}

Output:
 private void setMaxAlarmIconToAlarmRaised() {
-    changeButtonIcon(nonTimeMaxLimitButton, nonTimeMaxLimitAlarmRaisedIcon);
+    changeButtonIcon(nonTimeMaxLimitButton, nonTimeMaxLimitAlarmRaisedIcon, BUNDLE.getString("String_Node_Str"));
 }


Input:
public String toString() {
    StringBuilder sb = new StringBuilder();
    for (String elem : m_valueSet) {
        sb.append(elem.trim() + "String_Node_Str");
    }
    if (sb.length() > 0) {
        sb.replace(sb.lastIndexOf("String_Node_Str"), sb.lastIndexOf("String_Node_Str"), "String_Node_Str");
    }
    return sb.toString().trim();
}

Output:
     for (String elem : m_valueSet) {
-        sb.append(elem.trim() + "String_Node_Str");
+        sb.append(elem.trim() + StringConstants.COMMA + StringConstants.SPACE);
     }


Input:
public void printVersion() {
    if (versionInfo != null && !"String_Node_Str".equals(versionInfo)) {
        System.out.println(versionInfo);
    }
    for (String name : modules.keySet()) {
        versionInfo += name + "String_Node_Str" + modules.get(name).getModuleVersion();
    }
}

Output:
     }
-    for (String name : modules.keySet()) {
-        versionInfo += name + "String_Node_Str" + modules.get(name).getModuleVersion();
+    for (String name : tools.keySet()) {
+        System.out.println(name + "String_Node_Str" + tools.get(name).getToolVersion());
     }


Input:
public void performLineSearch(RealVector currentPoint, RealVector currentDirection) {
    double objectiveValueAtCurrentPoint = objectiveFunction.computeValue(currentPoint);
    RealVector objectiveGradientAtCurrentPoint = objectiveFunction.computeGradient(currentPoint);
    double dotProductOfObjectiveGradientAndDirection = objectiveGradientAtCurrentPoint.dotProduct(currentDirection);
    mostRecentStepSizes[0] = currentStepSize;
    int iterationNumber = 0;
    while (!LineSearchConditions.checkArmijoCondition(objectiveFunction, currentPoint, currentDirection, mostRecentStepSizes[0], c, objectiveValueAtCurrentPoint, objectiveGradientAtCurrentPoint)) {
        if (iterationNumber == 0) {
            performQuadraticInterpolation(currentPoint, currentDirection, objectiveValueAtCurrentPoint, dotProductOfObjectiveGradientAndDirection);
        } else {
            performCubicInterpolation(currentPoint, currentDirection, objectiveValueAtCurrentPoint, dotProductOfObjectiveGradientAndDirection);
        }
        iterationNumber++;
        if (iterationNumber >= 10) {
            break;
        }
    }
    currentStepSize = mostRecentStepSizes[0];
}

Output:
     mostRecentStepSizes[0] = currentStepSize;
-    int iterationNumber = 0;
-    while (!LineSearchConditions.checkArmijoCondition(objectiveFunction, currentPoint, currentDirection, mostRecentStepSizes[0], c, objectiveValueAtCurrentPoint, objectiveGradientAtCurrentPoint)) {
-        if (iterationNumber == 0) {
+    boolean firstIteration = true;
+    while (!LineSearchConditions.checkArmijoCondition(objectiveFunction, currentPoint, currentDirection, mostRecentStepSizes[0], C, objectiveValueAtCurrentPoint, objectiveGradientAtCurrentPoint)) {
+        if (firstIteration) {
             performQuadraticInterpolation(currentPoint, currentDirection, objectiveValueAtCurrentPoint, dotProductOfObjectiveGradientAndDirection);


Input:
public static boolean HashCheck(List<MYSpFile> listoffiles, int restoreFileID) throws Exception {
    boolean Check = true;
    int count = 0;
    DbConnect dbconnect = new DbConnect();
    List<MYSpFile> listofFileSp = dbconnect.selectQuery(restoreFileID);
    int SplitCountFile = dbconnect.SplitFileCount(restoreFileID);
    for (MYSpFile myfile : listoffiles) {
        for (MYSpFile dbfile : listofFileSp) {
            if (SplitCountFile < count) {
                if ((myfile.getName().equalsIgnoreCase(dbfile.getName()))) {
                    if (myfile.getHash().equalsIgnoreCase(dbfile.getHash())) {
                        Check = true;
                        restoreLog.info("String_Node_Str" + myfile.getName());
                    } else {
                        Check = false;
                        restoreLog.error("String_Node_Str");
                    }
                }
            }
        }
    }
    return Check;
}

Output:
                         Check = false;
-                        restoreLog.error("String_Node_Str");
+                        restoreLog.error("String_Node_Str" + myfile.getName());
                     }


Input:
public void finalize() {
    timer.cancel();
    cleanLoginRequests();
}

Output:
 public void finalize() {
-    timer.cancel();
+    try {
+        timer.cancel();
+    } catch (Exception e) {
+    }
     cleanLoginRequests();


Input:
public void run() {
    this.status = Status.Running;
    while (!isDestroyed() && status.getCode() >= ClusterStatus.Running.getCode()) {
        if (log.isDebugEnabled()) {
            log.debug("String_Node_Str" + this.toString());
        }
        try {
            if (!ClusterStatus.In_Maintenance.equals(status)) {
                monitor();
            } else {
                if (log.isDebugEnabled()) {
                    log.debug("String_Node_Str" + ClusterStatus.In_Maintenance + "String_Node_Str");
                }
            }
        } catch (Exception e) {
            log.error("String_Node_Str" + this.toString(), e);
        }
        try {
            Thread.sleep(monitorInterval);
        } catch (InterruptedException ignore) {
        }
    }
}

Output:
 public void run() {
-    this.status = Status.Running;
-    while (!isDestroyed() && status.getCode() >= ClusterStatus.Running.getCode()) {
+    while (!isDestroyed() && status.getCode() >= Status.Running.getCode()) {
         if (log.isDebugEnabled()) {


Input:
public void store(Iterator<? extends Entry> entries) throws IOException {
    persist(storeIterator.reset(entries));
}

Output:
 public void store(Iterator<? extends Entry> entries) throws IOException {
-    persist(storeIterator.reset(entries));
+    persist(new StoreIterator(entries));
 }


Input:
public int compare(final SAMRecord samRecord1, final SAMRecord samRecord2) {
    final int cmp = fileOrderCompare(samRecord1, samRecord2);
    if (cmp != 0) {
        return cmp;
    }
    if (samRecord1.getReadPairedFlag()) {
        if (samRecord1.getFirstOfPairFlag() && samRecord2.getSecondOfPairFlag()) {
            return -1;
        } else if (samRecord2.getFirstOfPairFlag() && samRecord1.getSecondOfPairFlag()) {
            return 1;
        }
    }
    if (samRecord1.getReadNegativeStrandFlag() == samRecord2.getReadNegativeStrandFlag()) {
        return 0;
    }
    return (samRecord1.getReadNegativeStrandFlag() ? 1 : -1);
}

Output:
     }
-    if (samRecord1.getReadPairedFlag()) {
-        if (samRecord1.getFirstOfPairFlag() && samRecord2.getSecondOfPairFlag()) {
+    final boolean r1Paired = samRecord1.getReadPairedFlag();
+    final boolean r2Paired = samRecord2.getReadPairedFlag();
+    if (r1Paired || r2Paired) {
+        if (!r1Paired)
+            return 1;
+        else if (!r2Paired)
+            return -1;
+        else if (samRecord1.getFirstOfPairFlag() && samRecord2.getSecondOfPairFlag())
             return -1;


Input:
public void handleCommand(ChannelUID channelUID, Command command) {
    if (command instanceof StringType) {
        try {
            client.startActivityByName(command.toString());
        } catch (Exception e) {
            logger.error("String_Node_Str", e);
        }
    } else if (command instanceof DecimalType) {
        try {
            client.startActivity(((DecimalType) command).intValue());
        } catch (Exception e) {
            logger.error("String_Node_Str", e);
        }
    } else {
        logger.warn("String_Node_Str", command);
    }
}

Output:
         try {
-            client.startActivityByName(command.toString());
+            try {
+                int actId = Integer.parseInt(command.toString());
+                client.startActivity(actId);
+            } catch (NumberFormatException ignored) {
+                client.startActivityByName(command.toString());
+            }
         } catch (Exception e) {


Input:
public void fall(float distance, float damageMultiplier) {
    if (this.isDefective()) {
        this.entityDropItem(this.getHeldItem(EnumHand.MAIN_HAND), 0.0F);
        this.setItemStackToSlot(EntityEquipmentSlot.MAINHAND, ItemStack.EMPTY);
    }
    super.fall(distance, damageMultiplier);
}

Output:
 public void fall(float distance, float damageMultiplier) {
-    if (this.isDefective()) {
+    if (this.isDefective() && this.ticksExisted < 20) {
         this.entityDropItem(this.getHeldItem(EnumHand.MAIN_HAND), 0.0F);


Input:
private ArrayList<DiscrepancyNoteBean> populateRowsWithAttachedData(ArrayList<DiscrepancyNoteBean> noteRows) {
    Locale l = request.getLocale();
    resword = ResourceBundleProvider.getWordsBundle(l);
    resformat = ResourceBundleProvider.getFormatBundle(l);
    SimpleDateFormat sdf = new SimpleDateFormat(resformat.getString("String_Node_Str"), ResourceBundleProvider.getLocale());
    DiscrepancyNoteDAO dndao = new DiscrepancyNoteDAO(sm.getDataSource());
    StudySubjectDAO studySubjectDAO = new StudySubjectDAO(sm.getDataSource());
    StudyEventDAO sedao = new StudyEventDAO(sm.getDataSource());
    CRFVersionDAO cvdao = new CRFVersionDAO(sm.getDataSource());
    CRFDAO cdao = new CRFDAO(sm.getDataSource());
    StudyEventDefinitionDAO seddao = new StudyEventDefinitionDAO(sm.getDataSource());
    EventCRFDAO ecdao = new EventCRFDAO(sm.getDataSource());
    ItemDataDAO iddao = new ItemDataDAO(sm.getDataSource());
    ItemDAO idao = new ItemDAO(sm.getDataSource());
    StudyDAO studyDao = new StudyDAO(sm.getDataSource());
    ArrayList<DiscrepancyNoteBean> allNotes = new ArrayList<DiscrepancyNoteBean>();
    for (int i = 0; i < noteRows.size(); i++) {
        DiscrepancyNoteBean dnb = noteRows.get(i);
        dnb.setCreatedDateString(dnb.getCreatedDate() == null ? "String_Node_Str" : sdf.format(dnb.getCreatedDate()));
        if (dnb.getParentDnId() == 0) {
            ArrayList children = dndao.findAllByStudyAndParent(currentStudy, dnb.getId());
            children = children == null ? new ArrayList() : children;
            dnb.setNumChildren(children.size());
            dnb.setChildren(children);
            int lastDnId = dnb.getId();
            int lastChild = 0;
            for (int j = 0; j < children.size(); j++) {
                DiscrepancyNoteBean child = (DiscrepancyNoteBean) children.get(j);
                child.setCreatedDateString(child.getCreatedDate() == null ? "String_Node_Str" : sdf.format(child.getCreatedDate()));
                child.setUpdatedDateString(child.getCreatedDate() != null ? sdf.format(child.getCreatedDate()) : "String_Node_Str");
                if (child.getId() > lastDnId) {
                    lastDnId = child.getId();
                    lastChild = j;
                }
            }
            if (children.size() > 0) {
                DiscrepancyNoteBean lastdn = (DiscrepancyNoteBean) children.get(lastChild);
                dnb.setUpdatedDate(lastdn.getCreatedDate());
                dnb.setUpdatedDateString(dnb.getUpdatedDate() != null ? sdf.format(dnb.getUpdatedDate()) : "String_Node_Str");
            }
        }
        String entityType = dnb.getEntityType();
        if (dnb.getEntityId() > 0 && !entityType.equals("String_Node_Str")) {
            AuditableEntityBean aeb = dndao.findEntity(dnb);
            dnb.setEntityName(aeb.getName());
            if (entityType.equalsIgnoreCase("String_Node_Str")) {
                SubjectBean sb = (SubjectBean) aeb;
                StudySubjectBean ssb = studySubjectDAO.findBySubjectIdAndStudy(sb.getId(), currentStudy);
                dnb.setStudySub(ssb);
                dnb.setSubjectName(ssb.getLabel());
                String column = dnb.getColumn().trim();
                if (!StringUtil.isBlank(column)) {
                    if ("String_Node_Str".equalsIgnoreCase(column)) {
                        dnb.setEntityValue(sb.getGender() + "String_Node_Str");
                        dnb.setEntityName(resword.getString("String_Node_Str"));
                    } else if ("String_Node_Str".equals(column)) {
                        if (sb.getDateOfBirth() != null) {
                            dnb.setEntityValue(sb.getDateOfBirth().toString());
                        }
                        dnb.setEntityName(resword.getString("String_Node_Str"));
                    } else if ("String_Node_Str".equalsIgnoreCase(column)) {
                        dnb.setEntityName(resword.getString("String_Node_Str"));
                        dnb.setEntityValue(sb.getUniqueIdentifier());
                    }
                }
            } else if (entityType.equalsIgnoreCase("String_Node_Str")) {
                StudySubjectBean ssb = (StudySubjectBean) aeb;
                dnb.setStudySub(ssb);
                dnb.setSubjectName(ssb.getLabel());
                String column = dnb.getColumn().trim();
                if (!StringUtil.isBlank(column)) {
                    if ("String_Node_Str".equals(column)) {
                        if (ssb.getEnrollmentDate() != null) {
                            dnb.setEntityValue(ssb.getEnrollmentDate().toString());
                        }
                        dnb.setEntityName(resword.getString("String_Node_Str"));
                    }
                }
            } else if (entityType.equalsIgnoreCase("String_Node_Str")) {
                StudyEventBean se = (StudyEventBean) sedao.findByPK(dnb.getEntityId());
                EventCRFBean ecb = (EventCRFBean) aeb;
                CRFVersionBean cvb = (CRFVersionBean) cvdao.findByPK(ecb.getCRFVersionId());
                CRFBean cb = (CRFBean) cdao.findByPK(cvb.getCrfId());
                dnb.setStageId(ecb.getStage().getId());
                dnb.setEntityName(cb.getName() + "String_Node_Str" + cvb.getName() + "String_Node_Str");
                StudySubjectBean ssub = (StudySubjectBean) studySubjectDAO.findByPK(ecb.getStudySubjectId());
                dnb.setStudySub(ssub);
                dnb.setSubjectName(ssub.getLabel());
                if (se != null) {
                    dnb.setEventStart(se.getDateStarted());
                    dnb.setEventName(se.getName());
                }
                dnb.setCrfName(cb.getName());
                dnb.setCrfStatus(ecb.getStatus().getName());
                String column = dnb.getColumn().trim();
                if (!StringUtil.isBlank(column)) {
                    if ("String_Node_Str".equals(column)) {
                        if (ecb.getDateInterviewed() != null) {
                            dnb.setEntityValue(ecb.getDateInterviewed().toString());
                        }
                        dnb.setEntityName(resword.getString("String_Node_Str"));
                    } else if ("String_Node_Str".equals(column)) {
                        dnb.setEntityValue(ecb.getInterviewerName());
                        dnb.setEntityName(resword.getString("String_Node_Str"));
                    }
                }
            } else if (entityType.equalsIgnoreCase("String_Node_Str")) {
                StudyEventBean se = (StudyEventBean) sedao.findByPK(dnb.getEntityId());
                StudyEventDefinitionBean sedb = (StudyEventDefinitionBean) seddao.findByPK(se.getStudyEventDefinitionId());
                se.setName(sedb.getName());
                dnb.setEntityName(sedb.getName());
                StudySubjectBean ssub = (StudySubjectBean) studySubjectDAO.findByPK(se.getStudySubjectId());
                dnb.setStudySub(ssub);
                dnb.setEventStart(se.getDateStarted());
                dnb.setEventName(se.getName());
                dnb.setSubjectName(ssub.getLabel());
                String column = dnb.getColumn().trim();
                if (!StringUtil.isBlank(column)) {
                    if ("String_Node_Str".equals(column)) {
                        if (se.getDateStarted() != null) {
                            dnb.setEntityValue(se.getDateStarted().toString());
                        }
                        dnb.setEntityName(resword.getString("String_Node_Str"));
                    } else if ("String_Node_Str".equals(column)) {
                        if (se.getDateEnded() != null) {
                            dnb.setEntityValue(se.getDateEnded().toString());
                        }
                        dnb.setEntityName(resword.getString("String_Node_Str"));
                    } else if ("String_Node_Str".equals(column)) {
                        dnb.setEntityValue(se.getLocation());
                        dnb.setEntityName(resword.getString("String_Node_Str"));
                    }
                }
            } else if (entityType.equalsIgnoreCase("String_Node_Str")) {
                ItemDataBean idb = (ItemDataBean) iddao.findByPK(dnb.getEntityId());
                ItemBean ib = (ItemBean) idao.findByPK(idb.getItemId());
                EventCRFBean ec = (EventCRFBean) ecdao.findByPK(idb.getEventCRFId());
                CRFVersionBean cvb = (CRFVersionBean) cvdao.findByPK(ec.getCRFVersionId());
                CRFBean cb = (CRFBean) cdao.findByPK(cvb.getCrfId());
                dnb.setStageId(ec.getStage().getId());
                dnb.setEntityName(ib.getName());
                dnb.setEntityValue(idb.getValue());
                StudyEventBean se = (StudyEventBean) sedao.findByPK(ec.getStudyEventId());
                StudyEventDefinitionBean sedb = (StudyEventDefinitionBean) seddao.findByPK(se.getStudyEventDefinitionId());
                se.setName(sedb.getName());
                StudySubjectBean ssub = (StudySubjectBean) studySubjectDAO.findByPK(ec.getStudySubjectId());
                dnb.setStudySub(ssub);
                dnb.setSubjectName(ssub.getLabel());
                dnb.setEventStart(se.getDateStarted());
                dnb.setEventName(se.getName());
                dnb.setCrfName(cb.getName());
                dnb.setCrfStatus(ec.getStatus().getName());
            }
        }
        dnb.setStudy((StudyBean) studyDao.findByPK(dnb.getStudyId()));
        if (dnb.getParentDnId() == 0 && dnb.getChildren().size() > 0) {
            ArrayList<DiscrepancyNoteBean> children = dnb.getChildren();
            int childrenSize = children.size();
            for (int j = 0; j < childrenSize; j++) {
                DiscrepancyNoteBean child = children.get(j);
                child.setSubjectName(dnb.getSubjectName());
                child.setEventName(dnb.getEventName());
                child.setCrfName(dnb.getCrfName());
                child.setCrfStatus(dnb.getCrfStatus());
                child.setEntityName(dnb.getEntityName());
                child.setEntityValue(dnb.getEntityValue());
                child.setStudySub(dnb.getStudySub());
                child.setStudy(dnb.getStudy());
            }
        }
        allNotes.add(dnb);
    }
    return allNotes;
}

Output:
                 dnb.setCrfName(cb.getName());
-                dnb.setCrfStatus(ecb.getStatus().getName());
+                dnb.setCrfStatus(resword.getString(se.getSubjectEventStatus().getName(true)));
                 String column = dnb.getColumn().trim();


Input:
private void setApp(App newApp) {
    if (newApp == null) {
        Toast.makeText(this, R.string.no_such_app, Toast.LENGTH_LONG).show();
        finish();
        return;
    }
    app = newApp;
    AppUpdateStatusManager appUpdateStatusManager = AppUpdateStatusManager.getInstance(this);
    for (AppUpdateStatusManager.AppUpdateStatus status : appUpdateStatusManager.getByPackageName(app.packageName)) {
        if (status.status == AppUpdateStatusManager.Status.Installed) {
            appUpdateStatusManager.removeApk(status.getUniqueKey());
        }
    }
}

Output:
     app = newApp;
-    AppUpdateStatusManager appUpdateStatusManager = AppUpdateStatusManager.getInstance(this);
-    for (AppUpdateStatusManager.AppUpdateStatus status : appUpdateStatusManager.getByPackageName(app.packageName)) {
+    AppUpdateStatusManager ausm = AppUpdateStatusManager.getInstance(this);
+    for (AppUpdateStatusManager.AppUpdateStatus status : ausm.getByPackageName(app.packageName)) {
         if (status.status == AppUpdateStatusManager.Status.Installed) {


Input:
public Set<Member> getMembers() {
    Keys cw = (Keys) proxyHelper.doOp(ClusterOperation.GET_MEMBERS, null, null);
    Collection<Data> datas = cw.getKeys();
    Set<Member> set = new LinkedHashSet<Member>();
    for (Data d : datas) {
        set.add((Member) IOUtil.toObject(d.buffer));
    }
    return set;
}

Output:
 public Set<Member> getMembers() {
-    Keys cw = (Keys) proxyHelper.doOp(ClusterOperation.GET_MEMBERS, null, null);
-    Collection<Data> datas = cw.getKeys();
-    Set<Member> set = new LinkedHashSet<Member>();
-    for (Data d : datas) {
-        set.add((Member) IOUtil.toObject(d.buffer));
+    Protocol protocol = protocolProxyHelper.doCommand(Command.MEMBERS, (String[]) null, null);
+    Set<Member> members = new HashSet<Member>();
+    for (String arg : protocol.args) {
+        String[] address = arg.split("String_Node_Str");
+        System.out.println(arg + "String_Node_Str" + address[0] + "String_Node_Str" + address[1]);
+        try {
+            Member member = new MemberImpl(new Address(address[0], Integer.valueOf(address[1])), false);
+            members.add(member);
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+        }
     }


Input:
public Set<EClass> getClasses() {
    return classifiers.keyBSet();
}

Output:
 public Set<EClass> getClasses() {
-    return classifiers.keyBSet();
+    return eClassToCid.keySet();
 }


Input:
public void stop() throws ServiceRegistrationException {
    final Callable<CheckedListenableFuture<Cluster>> transition = Automata.sequenceTransitions(this, State.DISABLED, State.STOPPED);
    Threads.lookup(ClusterController.class, Cluster.class).submit(transition);
    ListenerRegistry.getInstance().deregister(Hertz.class, this);
    ListenerRegistry.getInstance().deregister(ClockTick.class, this);
    Clusters.getInstance().deregister(this.getName());
}

Output:
     final Callable<CheckedListenableFuture<Cluster>> transition = Automata.sequenceTransitions(this, State.DISABLED, State.STOPPED);
-    Threads.lookup(ClusterController.class, Cluster.class).submit(transition);
-    ListenerRegistry.getInstance().deregister(Hertz.class, this);
-    ListenerRegistry.getInstance().deregister(ClockTick.class, this);
-    Clusters.getInstance().deregister(this.getName());
+    try {
+        Threads.lookup(ClusterController.class, Cluster.class).submit(transition).get();
+    } catch (InterruptedException ex) {
+        Thread.currentThread().interrupt();
+    } catch (ExecutionException ex) {
+        LOG.error(ex, ex);
+    } finally {
+        ListenerRegistry.getInstance().deregister(Hertz.class, this);
+        ListenerRegistry.getInstance().deregister(ClockTick.class, this);
+        Clusters.getInstance().deregister(this.getName());
+    }
 }


Input:
public boolean applies(Ability abilityToModify, Ability source, Game game) {
    if (abilityToModify instanceof SpellAbility) {
        Card card = game.getCard(abilityToModify.getSourceId());
        if (card != null && !card.getCardType().contains(CardType.ARTIFACT)) {
            return true;
        }
    }
    return false;
}

Output:
 public boolean applies(Ability abilityToModify, Ability source, Game game) {
-    if (abilityToModify instanceof SpellAbility) {
+    if (abilityToModify instanceof SpellAbility || abilityToModify instanceof FlashbackAbility || abilityToModify instanceof RetraceAbility) {
         Card card = game.getCard(abilityToModify.getSourceId());


Input:
protected void upgradeBasicUserVms(Connection conn, long domainRouterId, long networkId, String gateway, String vnet) throws SQLException {
    PreparedStatement pstmt = conn.prepareStatement("String_Node_Str");
    pstmt.setLong(1, domainRouterId);
    ResultSet rs = pstmt.executeQuery();
    List<Object[]> vms = new ArrayList<Object[]>();
    while (rs.next()) {
        Object[] vm = new Object[10];
        vm[0] = rs.getLong(1);
        vm[1] = rs.getString(2);
        vm[2] = rs.getString(3);
        vm[3] = rs.getString(4);
        vm[4] = rs.getString(5);
        vm[5] = rs.getString(6);
        vms.add(vm);
    }
    rs.close();
    pstmt.close();
    s_logger.debug("String_Node_Str" + vms.size() + "String_Node_Str" + domainRouterId);
    int count = 0;
    for (Object[] vm : vms) {
        String state = (String) vm[4];
        boolean running = false;
        if (state.equals("String_Node_Str") || state.equals("String_Node_Str") || state.equals("String_Node_Str")) {
            running = true;
            count++;
        }
        insertNic(conn, networkId, (Long) vm[0], running, (String) vm[1], (String) vm[2], (String) vm[3], "String_Node_Str", gateway, vnet, "String_Node_Str", true, 0, "String_Node_Str", null);
    }
    pstmt = conn.prepareStatement("String_Node_Str");
    pstmt.setLong(1, domainRouterId);
    rs = pstmt.executeQuery();
    rs.next();
    String state = rs.getString(1);
    if (state.equals("String_Node_Str") || state.equals("String_Node_Str") || state.equals("String_Node_Str")) {
        count++;
    }
    rs.close();
    pstmt.close();
    pstmt = conn.prepareStatement("String_Node_Str");
    pstmt.setLong(1, count);
    if (count == 0) {
        pstmt.setBoolean(2, false);
    } else {
        pstmt.setBoolean(2, true);
    }
    pstmt.setLong(3, networkId);
    pstmt.executeUpdate();
    pstmt.close();
}

Output:
             running = true;
-            count++;
+            String type = (String) vm[5];
+            if (type.equalsIgnoreCase("String_Node_Str")) {
+                count++;
+            }
         }


Input:
private Set<String> resolveFiles(List<String> files) {
    if (files != null) {
        Set<String> resolvedFiles = new LinkedHashSet<String>();
        for (String f : files) {
            if (f.startsWith("String_Node_Str") || f.startsWith("String_Node_Str")) {
                resolvedFiles.add(f);
            } else {
                File testFile = new File(f);
                String relativeDir = testFile.getParent() == null ? "String_Node_Str" : testFile.getParent();
                File file = basePath != null ? new File(basePath, f) : new File(f);
                File dir = file.getParentFile() == null ? new File("String_Node_Str") : file.getParentFile();
                final String pattern = file.getName();
                String[] filteredFiles = dir.list(new GlobFilenameFilter(pattern, GlobCompiler.DEFAULT_MASK | GlobCompiler.CASE_INSENSITIVE_MASK));
                if (filteredFiles == null) {
                    System.err.println("String_Node_Str" + "String_Node_Str" + "String_Node_Str");
                    System.exit(1);
                }
                String normalizedBasePath = basePath != null ? basePath.getPath().replaceAll("String_Node_Str", "String_Node_Str") + "String_Node_Str" : "String_Node_Str";
                for (String filteredFile : filteredFiles) {
                    String normalizedRelativeDir = relativeDir.replaceAll("String_Node_Str", "String_Node_Str");
                    if (normalizedRelativeDir.length() > 0) {
                        normalizedRelativeDir += "String_Node_Str";
                    }
                    resolvedFiles.add(String.format("String_Node_Str", normalizedBasePath, normalizedRelativeDir, filteredFile.replaceAll("String_Node_Str", "String_Node_Str")));
                }
            }
        }
        return resolvedFiles;
    }
    return EMPTY_SET;
}

Output:
                     }
-                    resolvedFiles.add(String.format("String_Node_Str", normalizedBasePath, normalizedRelativeDir, filteredFile.replaceAll("String_Node_Str", "String_Node_Str")));
+                    String resolvedFile = String.format("String_Node_Str", normalizedBasePath, normalizedRelativeDir, filteredFile.replaceAll("String_Node_Str", "String_Node_Str"));
+                    if (isPatch) {
+                        resolvedFile = "String_Node_Str" + resolvedFile;
+                    }
+                    resolvedFiles.add(resolvedFile);
                 }


Input:
public Chunk provideChunk(int par1, int par2) {
    this.hellRNG.setSeed((long) par1 * 341873128712L + (long) par2 * 132897987541L);
    Block[] abyte = new Block[32768];
    this.generateNetherTerrain(par1, par2, abyte);
    this.replaceBlocksForBiome(par1, par2, abyte);
    this.netherCaveGenerator.func_151539_a(this, this.worldObj, par1, par2, abyte);
    Chunk chunk = new Chunk(this.worldObj, abyte, par1, par2);
    BiomeGenBase[] abiomegenbase = this.worldObj.getWorldChunkManager().loadBlockGeneratorData((BiomeGenBase[]) null, par1 * 16, par2 * 16, 16, 16);
    byte[] abyte1 = chunk.getBiomeArray();
    for (int k = 0; k < abyte1.length; ++k) {
        abyte1[k] = (byte) abiomegenbase[k].biomeID;
    }
    chunk.resetRelightChecks();
    return chunk;
}

Output:
     this.hellRNG.setSeed((long) par1 * 341873128712L + (long) par2 * 132897987541L);
-    Block[] abyte = new Block[32768];
-    this.generateNetherTerrain(par1, par2, abyte);
-    this.replaceBlocksForBiome(par1, par2, abyte);
-    this.netherCaveGenerator.func_151539_a(this, this.worldObj, par1, par2, abyte);
-    Chunk chunk = new Chunk(this.worldObj, abyte, par1, par2);
+    Block[] blocks = new Block[32768];
+    this.generateNetherTerrain(par1, par2, blocks);
+    this.replaceBlocksForBiome(par1, par2, blocks);
+    for (int i = 0; i < 32767; i++) {
+        if (blocks[i] == TwilightBlocks.mortumGrass && blocks[i + 1] != null)
+            blocks[i] = TwilightBlocks.mortumDirt;
+    }
+    Chunk chunk = new Chunk(this.worldObj, blocks, par1, par2);
     BiomeGenBase[] abiomegenbase = this.worldObj.getWorldChunkManager().loadBlockGeneratorData((BiomeGenBase[]) null, par1 * 16, par2 * 16, 16, 16);


Input:
protected void displayMessage(IMessage message) {
    ISourceLocation loc = message.getISourceLocation();
    Ajde.getDefault().getEditorManager().showSourceLine(loc, true);
    Throwable thrown = message.getThrown();
    if (null != thrown) {
        Ajde.getDefault().getErrorHandler().handleError(message.getMessage(), thrown);
    }
}

Output:
     ISourceLocation loc = message.getISourceLocation();
-    Ajde.getDefault().getEditorManager().showSourceLine(loc, true);
+    BrowserManager.getDefault().getEditorManager().showSourceLine(loc, true);
     Throwable thrown = message.getThrown();


Input:
public void applyChanges(Revision rev, String path, boolean isNew, boolean isDelete, boolean isWritten, long oldWriteCount, long writeCountInc, ArrayList<String> added, ArrayList<String> removed) {
    if (!isWritten) {
        if (writeCountInc == 0) {
            writeCountIncrements.remove(path);
        } else {
            writeCountIncrements.put(path, writeCountInc);
        }
    } else {
        writeCountIncrements.remove(path);
    }
    long newWriteCount = oldWriteCount + writeCountInc;
    Children c = nodeChildrenCache.get(path + "String_Node_Str" + (newWriteCount - 1));
    if (isNew || (!isDelete && c != null)) {
        String id = path + "String_Node_Str" + newWriteCount;
        Children c2 = new Children(path, id, rev);
        TreeSet<String> set = new TreeSet<String>();
        if (c != null) {
            set.addAll(c.children);
        }
        set.removeAll(removed);
        set.addAll(added);
        c2.children.addAll(set);
        if (nodeChildrenCache.get(id) != null) {
            throw new AssertionError("String_Node_Str");
        }
        nodeChildrenCache.put(id, c2);
    }
}

Output:
         if (nodeChildrenCache.get(id) != null) {
-            throw new AssertionError("String_Node_Str");
+            MicroKernelException e = new MicroKernelException("String_Node_Str" + id);
+            LOG.error("String_Node_Str", e);
         }


Input:
public void performDataSync(OSyncAdapter adapter, Bundle extras, OUser user) {
    if (adapter.getModel().getModelName().equals("String_Node_Str")) {
        ODomain domain = new ODomain();
        SaleOrder saleOrder = new SaleOrder(getApplicationContext(), user);
        List<Integer> newIds = new ArrayList<>();
        for (ODataRow row : saleOrder.select(new String[] {}, "String_Node_Str", new String[] { "String_Node_Str", "String_Node_Str" })) {
            newIds.add(row.getInt("String_Node_Str"));
        }
        if (newIds.size() > 0) {
            domain.add("String_Node_Str", "String_Node_Str", newIds);
        }
        if (!firstSync)
            adapter.onSyncFinish(this);
        domain.add("String_Node_Str", "String_Node_Str", user.getUser_id());
        adapter.setDomain(domain);
    }
    if (adapter.getModel().getModelName().equals("String_Node_Str")) {
        adapter.onSyncFinish(syncFinishListener);
    }
}

Output:
         domain.add("String_Node_Str", "String_Node_Str", user.getUser_id());
-        adapter.setDomain(domain);
+        adapter.setDomain(domain).syncDataLimit(50);
     }


Input:
protected void verifySchema(SchemaCatalog catalog, String schemaName) {
    if (schemaName == null)
        throw new IllegalArgumentException("String_Node_Str");
    if (!catalog.getSchemaNames().contains(schemaName))
        throw new IllegalArgumentException("String_Node_Str" + schemaName);
}

Output:
         throw new IllegalArgumentException("String_Node_Str");
-    if (!catalog.getSchemaNames().contains(schemaName))
+    if (!catalog.getSchemaNames().contains(schemaName.toLowerCase()))
         throw new IllegalArgumentException("String_Node_Str" + schemaName);


Input:
public void loadCards(CardsView showCards, SortSetting sortSetting, boolean piles, BigCard bigCard, UUID gameId, boolean merge) {
    if (this.sortSetting == null) {
        this.sortSetting = sortSetting;
    }
    this.bigCard = bigCard;
    this.gameId = gameId;
    int landCount = 0;
    int creatureCount = 0;
    if (!merge) {
        this.clearCards();
        for (CardView card : showCards.values()) {
            addCard(card, bigCard, gameId);
        }
    } else {
        for (CardView card : showCards.values()) {
            if (!cards.containsKey(card.getId())) {
                addCard(card, bigCard, gameId);
            }
            if (updateCountsCallback != null) {
                if (card.getCardTypes().contains(CardType.LAND)) {
                    landCount++;
                }
                if (card.getCardTypes().contains(CardType.CREATURE)) {
                    creatureCount++;
                }
            }
        }
        for (Iterator<Entry<UUID, CardView>> i = cards.entrySet().iterator(); i.hasNext(); ) {
            Entry<UUID, CardView> entry = i.next();
            if (!showCards.containsKey(entry.getKey())) {
                i.remove();
                if (displayNoCopies) {
                    String key = entry.getValue().getName() + entry.getValue().getExpansionSetCode() + entry.getValue().getCardNumber();
                    if (cardsNoCopies.containsKey(key)) {
                        Integer count = cardsNoCopies.get(key);
                        count--;
                        if (count > 0) {
                            cardsNoCopies.put(key, count);
                        } else {
                            cardsNoCopies.remove(key);
                        }
                        for (int j = 0; j < view.size(); j++) {
                            CardView cv = view.get(j);
                            if (cv.getId().equals(entry.getValue().getId())) {
                                if (count > 0) {
                                    String key1 = cv.getName() + cv.getExpansionSetCode() + cv.getCardNumber();
                                    for (CardView cardView : cards.values()) {
                                        String key2 = cardView.getName() + cardView.getExpansionSetCode() + cardView.getCardNumber();
                                        if ((key1).equals(key2)) {
                                            view.set(j, cardView);
                                            break;
                                        }
                                    }
                                } else {
                                    view.remove(j);
                                }
                                break;
                            }
                        }
                    }
                } else {
                    for (CardView cv : view) {
                        if (cv.getId().equals(entry.getKey())) {
                            view.remove(cv);
                            break;
                        }
                    }
                }
            }
        }
        if (updateCountsCallback != null) {
            updateCountsCallback.update(cards.size(), creatureCount, landCount);
        }
    }
    sort(this.sortSetting.getSortIndex(), this.sortSetting.isAscending());
    drawCards(sortSetting, piles);
}

Output:
     sort(this.sortSetting.getSortIndex(), this.sortSetting.isAscending());
-    drawCards(sortSetting, piles);
+    drawCards(sortSetting);
 }


Input:
public void parameters(final String[] par, final SnipeData v) {
    v.sendMessage(TextColors.RED, "String_Node_Str");
}

Output:
 public void parameters(final String[] par, final SnipeData v) {
-    v.sendMessage(TextColors.RED, "String_Node_Str");
+    if (par.length != 0) {
+        v.sendMessage(TextColors.RED, "String_Node_Str");
+    }
 }