Input:
public static String getLocalRubyVersion() {
    if (mLocalRubyVersion != null)
        return mLocalRubyVersion;
    String line = readFirstLine(getRubyPath() + "String_Node_Str");
    if (line != null)
        return (mLocalRubyVersion = line);
    return null;
}

Output:
 public static String getLocalRubyVersion() {
-    if (mLocalRubyVersion != null)
-        return mLocalRubyVersion;
-    String line = readFirstLine(getRubyPath() + "String_Node_Str");
-    if (line != null)
-        return (mLocalRubyVersion = line);
-    return null;
+    if (mLocalRubyVersion == null)
+        mLocalRubyVersion = readFirstLine(getRubyPath() + "String_Node_Str");
+    return mLocalRubyVersion;
 }


Input:
private IndexInput wrapInput(String name) throws IOException {
    return new CompressedIndexInput(name, _directory, _compression, _blockSize);
}

Output:
 private IndexInput wrapInput(String name) throws IOException {
-    return new CompressedIndexInput(name, _directory, _compression, _blockSize);
+    return new CompressedIndexInput(name, _directory, _compression);
 }


Input:
private void replaceVals(GlobalConstants consts, Block block, Map<Block, Congruences> congruences, InitState init) {
    Congruences state = congruences.get(block);
    if (logger.isTraceEnabled()) {
        logger.trace("String_Node_Str");
        logger.trace("String_Node_Str" + System.identityHashCode(block) + "String_Node_Str" + block.getType());
        state.printTraceInfo(logger, consts);
    }
    ListIterator<Statement> stmtIt = block.statementIterator();
    while (stmtIt.hasNext()) {
        Statement stmt = stmtIt.next();
        if (stmt.type() == StatementType.INSTRUCTION) {
            Instruction inst = stmt.instruction();
            replaceCongruent(inst, state, init);
            if (!inst.hasSideEffects() && inst.getOutputs().size() == 1) {
                Var output = inst.getOutput(0);
                if (!InitVariables.varMustBeInitialized(output, true) || init.isInitialized(output, true)) {
                    if (Types.isScalarFuture(output)) {
                        Arg val = state.findRetrieveResult(output);
                        if (val != null) {
                            Instruction futureSet = ICInstructions.futureSet(output, val);
                            stmtIt.set(futureSet);
                            logger.trace("String_Node_Str" + futureSet);
                        }
                    } else if (Types.isScalarValue(output)) {
                        Arg val = state.findValue(output);
                        if (val != null && val.isConstant()) {
                            Instruction valueSet = ICInstructions.valueSet(output, val);
                            stmtIt.set(valueSet);
                            logger.trace("String_Node_Str" + valueSet);
                        }
                    }
                }
            }
            InitVariables.updateInitVars(logger, stmt, init, false);
        } else {
            assert (stmt.type() == StatementType.CONDITIONAL);
            replaceCongruentNonRec(stmt.conditional(), state, init);
            replaceValsRec(consts, stmt.conditional(), congruences, init);
        }
    }
    replaceCleanupCongruent(block, state, init);
    for (Continuation cont : block.getContinuations()) {
        replaceCongruentNonRec(cont, state, init);
        replaceValsRec(consts, cont, congruences, init);
    }
}

Output:
                         Arg val = state.findRetrieveResult(output);
-                        if (val != null) {
+                        if (val != null && init.isInitialized(val, false)) {
                             Instruction futureSet = ICInstructions.futureSet(output, val);


Input:
public void beforeContainmentMarshal(Object child) {
    if (null != marshaller) {
        XMLMarshalListener marshalListener = marshaller.getMarshalListener();
        if (null != marshalListener) {
            marshalListener.beforeMarshal(child);
        }
    }
    setOwningObject(child);
}

Output:
         if (null != marshalListener) {
-            marshalListener.beforeMarshal(child);
+            try {
+                marshalListener.beforeMarshal(child);
+            } catch (EclipseLinkException e) {
+                ErrorHandler errorHandler = marshaller.getErrorHandler();
+                if (null == errorHandler) {
+                    throw e;
+                } else {
+                    try {
+                        MarshalSAXParseException saxParseException = new MarshalSAXParseException(null, null, null, -1, -1, e, child);
+                        errorHandler.error(saxParseException);
+                    } catch (SAXException saxParseException) {
+                        throw e;
+                    }
+                }
+            }
         }


Input:
public ArrayList<Violation> mergeBranchInfo(Context context, List<VInfo> branches, boolean exhaustive) {
    if (branches.size() == 0) {
        throw new STCRuntimeError("String_Node_Str");
    }
    mergeBranchReadInfo(branches, exhaustive);
    ArrayList<Violation> errs = mergeBranchWriteInfo(context, branches, exhaustive);
    if (structFields != null) {
        for (VInfo fieldVI : this.structFields.values()) {
            List<VInfo> vis = new ArrayList<VInfo>(branches.size());
            for (int i = 0; i < branches.size(); i++) {
                vis.add(branches.get(i).getFieldVInfo(fieldVI.getName()));
            }
            errs.addAll(fieldVI.mergeBranchInfo(context, branches, exhaustive));
        }
    }
    return errs;
}

Output:
             }
-            errs.addAll(fieldVI.mergeBranchInfo(context, branches, exhaustive));
+            ArrayList<Violation> mergeErrs = fieldVI.mergeBranchInfo(context, branches, exhaustive);
+            errs.addAll(mergeErrs);
         }


Input:
public DataSource buildDataSource(String driverClass, String userName, String password, String url, Map<String, String> connectParam) throws LoadConfigException {
    DruidDataSource ds = new DruidDataSource();
    ds.setDriverClassName(driverClass);
    ds.setUsername(userName);
    ds.setPassword(password);
    ds.setUrl(url);
    for (Map.Entry<String, String> entry : connectParam.entrySet()) {
        if (entry.getKey().equals("String_Node_Str")) {
            try {
                BeansUtil.setProperty(ds, entry.getKey(), Class.forName(entry.getValue()).newInstance());
            } catch (Exception e) {
                throw new LoadConfigException("String_Node_Str");
            }
        } else {
            try {
                BeansUtil.setProperty(ds, entry.getKey(), entry.getValue());
            } catch (Exception e) {
                LOG.warn("String_Node_Str" + entry);
            }
        }
    }
    ds.setValidationQuery("String_Node_Str");
    return ds;
}

Output:
             try {
-                BeansUtil.setProperty(ds, entry.getKey(), entry.getValue());
+                setConnectionParam(ds, entry.getKey(), entry.getValue());
             } catch (Exception e) {


Input:
public CubeCursor getCubeCursor() throws DataException {
    if (this.cubeCursor != null)
        return this.cubeCursor;
    try {
        stopSign.start();
        CubeQueryExecutor executor = new CubeQueryExecutor(this.outResults, preparedQuery.getCubeQueryDefinition(), this.session, this.scope, this.context);
        BirtCubeView bcv = new BirtCubeView(executor, appContext);
        CubeCursor cubeCursor = bcv.getCubeCursor(stopSign);
        String newResultSetId = executor.getQueryResultsId();
        if (newResultSetId != null) {
            this.queryResultsId = newResultSetId;
        }
        this.scope.put(ScriptConstants.MEASURE_SCRIPTABLE, this.scope, new JSMeasureAccessor(cubeCursor));
        this.scope.put(ScriptConstants.DIMENSION_SCRIPTABLE, this.scope, new JSLevelAccessor(this.preparedQuery.getCubeQueryDefinition(), bcv));
        this.cubeCursor = new CubeCursorImpl(outResults, cubeCursor, this.scope, this.preparedQuery.getCubeQueryDefinition());
        return this.cubeCursor;
    } catch (OLAPException e) {
        throw new DataException(e.getLocalizedMessage());
    }
}

Output:
         }
-        this.scope.put(ScriptConstants.MEASURE_SCRIPTABLE, this.scope, new JSMeasureAccessor(cubeCursor));
+        this.scope.put(ScriptConstants.MEASURE_SCRIPTABLE, this.scope, new JSMeasureAccessor(cubeCursor, bcv.getMeasureMapping()));
         this.scope.put(ScriptConstants.DIMENSION_SCRIPTABLE, this.scope, new JSLevelAccessor(this.preparedQuery.getCubeQueryDefinition(), bcv));


Input:
public void setUp() throws Exception {
    super.setUp();
    notDecompressingExecutor = Executor.newInstance(HttpClients.custom().disableContentCompression().build()).auth(new HttpHost(conf.getHttpHost()), "String_Node_Str", "String_Node_Str");
}

Output:
     super.setUp();
-    notDecompressingExecutor = Executor.newInstance(HttpClients.custom().disableContentCompression().build()).auth(new HttpHost(conf.getHttpHost()), "String_Node_Str", "String_Node_Str");
+    notDecompressingExecutor = Executor.newInstance(HttpClients.custom().disableContentCompression().build()).auth(new HttpHost("String_Node_Str"), "String_Node_Str", "String_Node_Str");
 }


Input:
private void intializeLogger() {
    Logger logger = null;
    String dest = null;
    String file = null;
    Level level = Level.WARNING;
    if (config != null) {
        logger = config.getLogger();
        dest = config.getLogDirectory();
        file = config.getLogFile();
        level = config.getLogLevel();
        if (level == null) {
            level = Level.WARNING;
        }
    }
    EngineLogger.startEngineLogging(logger, dest, file, level);
}

Output:
     }
-    EngineLogger.startEngineLogging(logger, dest, file, level);
+    EngineLogger.startEngineLogging(logger, dest, file, level, rollingSize, maxBackupIndex);
 }


Input:
String doGetQueryParameterQualifier() {
    return super.getQueryParameterQualifier();
}

Output:
 String doGetQueryParameterQualifier() {
-    return super.getQueryParameterQualifier();
+    return null;
 }


Input:
private static Document repair(Document document, File webAppRoot) {
    Map userData = new TreeMap();
    Map snipData = new TreeMap();
    Map unknown = new TreeMap();
    Element rootEl = document.getRootElement();
    Iterator elementIt = rootEl.elementIterator();
    System.err.println("String_Node_Str");
    long identDup = 0;
    long oldDup = 0;
    long newDup = 0;
    while (elementIt.hasNext()) {
        Element element = (Element) elementIt.next();
        Element idElement = null;
        Map data = null;
        if ("String_Node_Str".equals(element.getName())) {
            idElement = element.element("String_Node_Str");
            data = userData;
        } else if ("String_Node_Str".equals(element.getName())) {
            idElement = element.element("String_Node_Str");
            data = snipData;
        }
        if (null != data && null != idElement) {
            String id = element.getName() + "String_Node_Str" + idElement.getText() + "String_Node_Str";
            long mtime = Long.parseLong(element.element("String_Node_Str").getTextTrim());
            Element existingElement = (Element) data.get(id);
            if (existingElement != null) {
                long lastmtime = Long.parseLong(existingElement.element("String_Node_Str").getTextTrim());
                if (mtime > lastmtime) {
                    newDup++;
                    System.err.println("String_Node_Str" + id + "String_Node_Str" + (mtime - lastmtime) + "String_Node_Str");
                    data.put(id, element);
                } else if (mtime == lastmtime) {
                    identDup++;
                    System.err.println("String_Node_Str" + id);
                } else {
                    oldDup++;
                    System.err.println("String_Node_Str" + id);
                }
                if (snipData == data) {
                    String name = idElement.getText();
                    if (name.startsWith("String_Node_Str")) {
                        String commentSnip = name.substring("String_Node_Str".length(), name.lastIndexOf("String_Node_Str"));
                        Element commentEl = element.element("String_Node_Str");
                        if (commentEl == null) {
                            commentEl = element.addElement("String_Node_Str");
                        }
                        if (!commentSnip.equals(commentEl.getText())) {
                            commentEl.addText(commentSnip);
                            System.err.println("String_Node_Str" + name + "String_Node_Str" + commentSnip + "String_Node_Str");
                        }
                    } else if (name.matches("String_Node_Str")) {
                        Element parentEl = element.element("String_Node_Str");
                        if (null == parentEl) {
                            parentEl = element.addElement("String_Node_Str");
                        }
                        if (!"String_Node_Str".equals(parentEl.getText())) {
                            parentEl.addText("String_Node_Str");
                            System.err.println("String_Node_Str" + name + "String_Node_Str");
                        }
                    }
                }
            } else {
                data.put(id, element);
            }
        } else {
            System.err.println("String_Node_Str" + element.getName() + "String_Node_Str");
            unknown.put(element, element);
        }
    }
    System.err.println("String_Node_Str" + identDup + "String_Node_Str" + newDup + "String_Node_Str" + oldDup + "String_Node_Str");
    if (unknown.size() > 0) {
        System.err.println("String_Node_Str" + unknown.size() + "String_Node_Str");
    }
    Document outputDocument = DocumentHelper.createDocument();
    outputDocument.addElement(rootEl.getName());
    rootEl = outputDocument.getRootElement();
    System.err.println("String_Node_Str" + userData.size() + "String_Node_Str");
    Iterator userIt = userData.values().iterator();
    while (userIt.hasNext()) {
        Element userEl = (Element) userIt.next();
        rootEl.add(userEl.detach());
    }
    int attCount = 0;
    System.err.print("String_Node_Str" + snipData.size() + "String_Node_Str");
    if (webAppRoot != null) {
        System.out.println("String_Node_Str");
    } else {
        System.out.println();
    }
    Iterator snipIt = snipData.values().iterator();
    while (snipIt.hasNext()) {
        Element snipEl = (Element) snipIt.next();
        if (webAppRoot != null) {
            attCount += storeAttachments(snipEl, new File(webAppRoot, "String_Node_Str"));
            attCount += storeOldImages(snipEl, new File(webAppRoot, "String_Node_Str"));
        }
        rootEl.add(snipEl.detach());
    }
    System.err.println("String_Node_Str" + attCount + "String_Node_Str");
    return outputDocument;
}

Output:
         if (null != data && null != idElement) {
-            String id = element.getName() + "String_Node_Str" + idElement.getText() + "String_Node_Str";
+            String id = element.getName() + "String_Node_Str" + idElement.getText().toUpperCase() + "String_Node_Str";
             long mtime = Long.parseLong(element.element("String_Node_Str").getTextTrim());


Input:
public void doRunTest() throws Exception {
    RenameObjectAction renameAction = new RenameObjectAction();
    RenameObjectAction renameActionM = spy(renameAction);
    CommonViewer commonViewerM = mock(CommonViewer.class);
    Whitebox.setInternalState(renameActionM, "String_Node_Str", commonViewerM);
    IRepositoryViewObject objectRVO = mock(IRepositoryViewObject.class);
    IRepositoryViewObject parentRVO = mock(IRepositoryViewObject.class);
    MDMServerObjectItem mdmItemM = mock(MDMServerObjectItem.class);
    ContainerItem parentItemM = mock(ContainerItem.class);
    Property propertyM = mock(Property.class);
    Property parentPropertyM = mock(Property.class);
    MDMServerObject mdmServerObjectM = mock(MDMServerObject.class);
    ItemState itemStateM = mock(ItemState.class);
    when(objectRVO.getProperty()).thenReturn(propertyM);
    when(propertyM.getItem()).thenReturn(mdmItemM);
    when(mdmItemM.getMDMServerObject()).thenReturn(mdmServerObjectM);
    when(mdmItemM.getState()).thenReturn(itemStateM);
    when(itemStateM.getPath()).thenReturn("String_Node_Str");
    when(parentRVO.getProperty()).thenReturn(parentPropertyM);
    when(parentPropertyM.getItem()).thenReturn(parentItemM);
    PowerMockito.mockStatic(RepositoryNodeProviderRegistryReader.class);
    RepositoryNodeProviderRegistryReader reader = mock(RepositoryNodeProviderRegistryReader.class);
    PowerMockito.when(RepositoryNodeProviderRegistryReader.getInstance()).thenReturn(reader);
    ERepositoryObjectType typeM = ERepositoryObjectType.PROCESS;
    when(resourceProviderM.getRepositoryObjectType(mdmItemM)).thenReturn(typeM);
    PowerMockito.mockStatic(ContainerCacheService.class);
    when(ContainerCacheService.get(eq(typeM), eq("String_Node_Str"))).thenReturn(parentRVO);
    Shell shellM = mock(Shell.class);
    Control controlM = mock(Control.class);
    when(commonViewerM.getControl()).thenReturn(controlM);
    when(controlM.getShell()).thenReturn(shellM);
    List<Object> selectedObjects = new ArrayList<Object>();
    selectedObjects.add(objectRVO);
    when(renameActionM.getSelectedObject()).thenReturn(selectedObjects);
    InputDialog inputDialogM = mock(InputDialog.class);
    PowerMockito.whenNew(InputDialog.class).withArguments(eq(shellM), anyString(), anyString(), anyString(), anyObject()).thenReturn(inputDialogM);
    when(inputDialogM.open()).thenReturn(IDialogConstants.OK_ID);
    when(inputDialogM.getValue()).thenReturn("String_Node_Str");
    renameActionM.doRun();
}

Output:
     RenameObjectAction renameAction = new RenameObjectAction();
-    RenameObjectAction renameActionM = spy(renameAction);
+    RenameObjectAction renameActionM = PowerMockito.spy(renameAction);
     CommonViewer commonViewerM = mock(CommonViewer.class);


Input:
public Color getBackground(Object element, int columnIndex) {
    if (element instanceof ContextTableTabChildModel) {
        ContextTableTabChildModel child = (ContextTableTabChildModel) element;
        IContextParameter contextPara = child.getContextParameter();
        String name = contextPara.getName();
        if (hasSameNameContextParameters(name))
            return Display.getDefault().getSystemColor(SWT.COLOR_RED);
    } else if (element instanceof ContextTableTabParentModel) {
        ContextTableTabParentModel parent = (ContextTableTabParentModel) element;
        IContextParameter contextPara = parent.getContextParameter();
        if (contextPara != null) {
            String name = parent.getContextParameter().getName();
            if (hasSameNameContextParameters(name))
                return Display.getDefault().getSystemColor(SWT.COLOR_RED);
        }
    }
    return null;
}

Output:
         String name = contextPara.getName();
-        if (hasSameNameContextParameters(name))
+        if (hasSameNameContextParameters(name)) {
             return Display.getDefault().getSystemColor(SWT.COLOR_RED);


Input:
public static Event inflateEvent(Cursor data) {
    Event event = new Event();
    for (int i = 0; i < data.getColumnCount(); i++) {
        switch(data.getColumnName(i)) {
            case Database.Events.KEY:
                event.setEventKey(data.getString(i));
                break;
            case Database.Events.NAME:
                event.setEventName(data.getString(i));
                break;
            case Database.Events.LOCATION:
                event.setLocation(data.getString(i));
                break;
            case Database.Events.VENUE:
                event.setVenue(data.getString(i));
                break;
            case Database.Events.TYPE:
                event.setEventType(data.getString(i));
                break;
            case Database.Events.DISTRICT:
                event.setDistrictEnum(data.getInt(i));
                break;
            case Database.Events.DISTRICT_STRING:
                event.setDistrictTitle(data.getString(i));
                break;
            case Database.Events.START:
                event.setStartDate(new Date(data.getLong(i)));
                break;
            case Database.Events.END:
                event.setEndDate(new Date(data.getLong(i)));
                break;
            case Database.Events.OFFICIAL:
                event.setOfficial(data.getInt(i) == 1);
                break;
            case Database.Events.WEEK:
                event.setCompetitionWeek(data.getInt(i));
                break;
            case Database.Events.RANKINGS:
                JsonArray rankings = JSONManager.getasJsonArray(data.getString(i));
                event.setRankings(rankings);
                break;
            case Database.Events.ALLIANCES:
                JsonArray alliances = JSONManager.getasJsonArray(data.getString(i));
                event.setAlliances(alliances);
                break;
            case Database.Events.STATS:
                JsonObject stats = JSONManager.getasJsonObject(data.getString(i));
                event.setStats(stats);
                break;
            default:
        }
    }
    return event;
}

Output:
             case Database.Events.TYPE:
-                event.setEventType(data.getString(i));
+                event.setEventType(data.getInt(i));
                 break;


Input:
public static boolean addPathToServiceForwarderStateExecutor(String pathName) {
    printTraceStart(LOG);
    boolean ret = false;
    Object[] servicePathObj = { pathName };
    Class[] servicePathClass = { String.class };
    SfcProviderServiceForwarderAPI sfcProviderServiceForwarderAPI = SfcProviderServiceForwarderAPI.getAddPathToServiceForwarderState(servicePathObj, servicePathClass);
    Future future = odlSfc.executor.submit(sfcProviderServiceForwarderAPI);
    try {
        ret = (boolean) future.get();
        LOG.debug("String_Node_Str", future.get());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
    printTraceStop(LOG);
    return ret;
}

Output:
     } catch (InterruptedException e) {
-        e.printStackTrace();
+        LOG.warn("String_Node_Str", e);
     } catch (ExecutionException e) {


Input:
public void onResume() {
    super.onResume();
    if (hasEmbedsOrIframes())
        resumeWebView();
}

Output:
     super.onResume();
-    if (hasEmbedsOrIframes())
+    if (hasEmbedsOrIframes()) {
         resumeWebView();


Input:
protected List<Solution> crowdingDistanceSelection(Ranking ranking) {
    CrowdingDistance crowdingDistance = new CrowdingDistance();
    List<Solution> population = new ArrayList<>(solutionsToSelect);
    int rankingIndex = 0;
    while (population.size() <= solutionsToSelect) {
        if (subfrontFillsIntoThePopulation(ranking, rankingIndex, population)) {
            addRankedSolutionsToPopulation(ranking, rankingIndex, population);
            rankingIndex++;
        } else {
            crowdingDistance.computeDensityEstimator(ranking.getSubfront(rankingIndex));
            addLastRankedSolutionsToPopulation(ranking, rankingIndex, population);
        }
    }
    return population;
}

Output:
     int rankingIndex = 0;
-    while (population.size() <= solutionsToSelect) {
+    while (population.size() < solutionsToSelect) {
         if (subfrontFillsIntoThePopulation(ranking, rankingIndex, population)) {


Input:
public int compareTo(Object obj) {
    if (this == obj)
        return 0;
    if (obj == null)
        return 1;
    if (!(obj instanceof AlternateLocation))
        return 1;
    AlternateLocation other = (AlternateLocation) obj;
    if (_demoted != other._demoted) {
        if (_demoted)
            return 1;
        return -1;
    }
    int ret = _count - other._count;
    if (ret != 0)
        return ret;
    if (this.URL.equals(other.URL))
        return 0;
    ret = this.URL.getHost().compareTo(other.URL.getHost());
    if (ret != 0)
        return ret;
    return (this.URL.getPort() - other.URL.getPort());
}

Output:
         return ret;
-    return (this.URL.getPort() - other.URL.getPort());
+    ret = (this.URL.getPort() - other.URL.getPort());
+    if (ret != 0)
+        return ret;
+    ret = SHA1_URN.hashCode() - other.SHA1_URN.hashCode();
+    if (ret != 0)
+        return ret;
+    return URL.getProtocol().hashCode() - other.URL.getProtocol().hashCode();
 }


Input:
public int getNrUpdateErrors() {
    return getCount(Action.MODIFY, failedUpdates);
}

Output:
 public int getNrUpdateErrors() {
-    return getCount(Action.MODIFY, failedUpdates);
+    return Iterables.size(Iterables.filter(failedUpdates, new Predicate<UpdateResult>() {
+        public boolean apply(UpdateResult input) {
+            return Action.MODIFY.equals(input.getAction());
+        }
+    }));
 }


Input:
public ResourceBundle getResourceBundle() {
    try {
        return ResourceBundle.getBundle(getLoggerResourceBundleName(name), Locale.getDefault(), cloader);
    } catch (MissingResourceException e) {
        String root = clazz.getPackage().getName();
        try {
            return ResourceBundle.getBundle(root + "String_Node_Str" + RESOURCE_BUNDLE, Locale.getDefault(), cloader);
        } catch (MissingResourceException me) {
            String p = root;
            while (p != null) {
                try {
                    int i = p.lastIndexOf("String_Node_Str");
                    if (i != -1) {
                        p = p.substring(0, i);
                        return ResourceBundle.getBundle(p + "String_Node_Str" + RESOURCE_BUNDLE, Locale.getDefault(), cloader);
                    } else {
                        p = null;
                    }
                } catch (MissingResourceException mre) {
                }
            }
        }
        try {
            return ResourceBundle.getBundle(getLoggerResourceBundleName(name), Locale.getDefault(), LogDomains.class.getClassLoader());
        } catch (MissingResourceException me) {
        }
        Logger l = LogManager.getLogManager().getLogger(name);
        l.log(Level.FINE, "String_Node_Str" + "String_Node_Str" + clazz.getName());
        return null;
    }
}

Output:
         }
-        Logger l = LogManager.getLogManager().getLogger(name);
-        l.log(Level.FINE, "String_Node_Str" + "String_Node_Str" + clazz.getName());
+        if (!vectorClazz.contains(clazz.getName())) {
+            Logger l = LogManager.getLogManager().getLogger(name);
+            l.log(Level.FINE, "String_Node_Str" + "String_Node_Str" + clazz.getName());
+            vectorClazz.add(clazz.getName());
+        }
         return null;


Input:
private int crc8Add(int acc, int data) {
    int i;
    acc ^= data;
    for (i = 0; i < 8; i++) {
        if ((acc & 0x80) != 0) {
            acc = (acc << 1) ^ 0x31;
        } else {
            acc <<= 1;
        }
    }
    return acc & 0xff;
}

Output:
     int i;
-    acc ^= data;
+    acc ^= (data & 0xff);
     for (i = 0; i < 8; i++) {


Input:
public boolean addService(Class<? extends TBase> clazz, ProfilerCommandService service) {
    ProfilerCommandService inValue = profilerCommandServiceRepository.putIfAbsent(clazz, service);
    if (inValue != null) {
        logger.warn("String_Node_Str", clazz.getName());
        return false;
    }
    return true;
}

Output:
 public boolean addService(Class<? extends TBase> clazz, ProfilerCommandService service) {
-    ProfilerCommandService inValue = profilerCommandServiceRepository.putIfAbsent(clazz, service);
-    if (inValue != null) {
+    if (clazz == null) {
+        throw new NullPointerException("String_Node_Str");
+    }
+    if (service == null) {
+        throw new NullPointerException("String_Node_Str");
+    }
+    final ProfilerCommandService before = profilerCommandServiceRepository.putIfAbsent(clazz, service);
+    if (before != null) {
         logger.warn("String_Node_Str", clazz.getName());


Input:
public void setup() {
    systemManager = new QBitSystemManager();
    eventManager = EventManagerBuilder.eventManagerBuilder().setName("String_Node_Str").build();
    serviceBuilder = ServiceBuilder.serviceBuilder().setEventManager(eventManager).setSystemManager(systemManager);
    eventServiceQueue = serviceBuilder.setServiceObject(eventManager).buildAndStartAll();
    serviceB = new ServiceB();
    serviceBuilder.setServiceObject(serviceB).buildAndStartAll();
    serviceA = new ServiceA(eventServiceQueue.createProxy(EventManager.class));
    final ServiceQueue serviceAQueue = serviceBuilder.setServiceObject(serviceA).buildAndStartAll();
    serviceAQueueProxy = serviceAQueue.createProxy(ServiceAInterface.class);
}

Output:
     eventManager = EventManagerBuilder.eventManagerBuilder().setName("String_Node_Str").build();
-    serviceBuilder = ServiceBuilder.serviceBuilder().setEventManager(eventManager).setSystemManager(systemManager);
-    eventServiceQueue = serviceBuilder.setServiceObject(eventManager).buildAndStartAll();
+    eventServiceQueue = ServiceBuilder.serviceBuilder().setServiceObject(eventManager).buildAndStartAll();
     serviceB = new ServiceB();


Input:
public Schema getSchema() {
    return saxParserFactory.getSchema();
}

Output:
 public Schema getSchema() {
-    return saxParserFactory.getSchema();
+    Schema schema = null;
+    try {
+        schema = saxParserFactory.getSchema();
+    } catch (UnsupportedOperationException ex) {
+    }
+    return schema;
 }


Input:
public ImageHeader getCurrentKey() throws IOException {
    if (_header != null)
        return _header;
    if (_cacheLength > 0) {
        ImageDecoder decoder = CodecManager.getDecoder(ImageType.fromValue(_cacheType));
        if (decoder == null)
            return null;
        ByteArrayInputStream _byte_array_input_stream = new ByteArrayInputStream(_byte_array_data);
        try {
            _header = decoder.decodeImageHeader(_byte_array_input_stream);
        } catch (IOException e) {
            _header = null;
        }
        return _header;
    }
    return null;
}

Output:
             _header = decoder.decodeImageHeader(_byte_array_input_stream);
-        } catch (IOException e) {
+        } catch (Exception e) {
+            e.printStackTrace();
             _header = null;


Input:
private void handleSpecialCharacterAndMissingValues() {
    if (isChecked && valueToFreq.size() < 1) {
        return;
    }
    long counted = 0L;
    List<Object> invalid = new ArrayList<Object>();
    List<Object> lengthMore = new ArrayList<Object>();
    for (Object val : valueToFreq.keySet()) {
        if (isInvalid(val) < 0) {
            invalid.add(val);
            Long freq = this.valueToFreq.get(val);
            counted = (freq == null) ? counted : counted + freq;
        } else if (String.valueOf(val).length() > 1) {
            lengthMore.add(val);
        }
    }
    if (invalid.size() > 0) {
        for (Object val : invalid) {
            valueToFreq.remove(val);
        }
        valueToFreq.put("String_Node_Str", counted);
    }
    if (lengthMore.size() > 0) {
        for (Object val : lengthMore) {
            String k = String.valueOf(val).substring(0, 1);
            Long freq = this.valueToFreq.get(val);
            valueToFreq.remove(val);
            valueToFreq.put(k, freq);
        }
    }
    for (int i = 1; i < 10; i++) {
        Long value = valueToFreq.get(String.valueOf(i));
        if (value == null) {
            valueToFreq.put(String.valueOf(i), 0L);
        }
    }
    isChecked = true;
}

Output:
         }
-        valueToFreq.put("String_Node_Str", counted);
+        valueToFreq.put(INVALID, counted);
     }


Input:
public Token read(String tokenId) throws CoreTokenException {
    Token token = getAdapter().read(tokenId);
    try {
        strategy.reverse(token);
    } catch (TokenStrategyFailedException e) {
        throw new CoreTokenException("String_Node_Str", e);
    }
    return token;
}

Output:
 public Token read(String tokenId) throws CoreTokenException {
-    Token token = getAdapter().read(tokenId);
+    Token token = adapter.read(tokenId);
     try {


Input:
private void addInstrumentationSnippetFor(final AstNode node) {
    final AstNode parent = node.getParent();
    final int type = node.getType();
    final int parentType = parent.getType();
    if (type == CASE) {
        handleSwitchCase((SwitchCase) node);
    } else if (type == IF && parentType == IF) {
        flattenElseIf((IfStatement) node, (IfStatement) parent);
        data.addExecutableLine(node.getLineno(), node.getLength());
    } else if (parentType != CASE) {
        if (parent.hasChildren()) {
            parent.addChildBefore(newInstrumentationNode(node.getLineno()), node);
        } else {
            final Block block = newInstrumentedBlock(node);
            if (parentType == IF) {
                final IfStatement ifStatement = (IfStatement) parent;
                if (ifStatement.getThenPart() == node) {
                    ifStatement.setThenPart(block);
                } else if (ifStatement.getElsePart() == node) {
                    ifStatement.setElsePart(block);
                }
            } else if (parentType == WHILE || parentType == FOR || parentType == DO) {
                ((Loop) parent).setBody(block);
            } else {
                logger.warn("String_Node_Str", parent.toSource());
            }
        }
        data.addExecutableLine(node.getLineno(), node.getLength());
    }
}

Output:
         flattenElseIf((IfStatement) node, (IfStatement) parent);
-        data.addExecutableLine(node.getLineno(), node.getLength());
+        data.addExecutableLine(getActualLineNumber(node), node.getLength());
     } else if (parentType != CASE) {


Input:
public boolean swap(VersionedSegmentsList versionedList, ImmutableSegment segment, boolean closeSuffix) {
    if (versionedList.getVersion() != version) {
        return false;
    }
    List<ImmutableSegment> suffix;
    synchronized (pipeline) {
        if (versionedList.getVersion() != version) {
            return false;
        }
        suffix = versionedList.getStoreSegments();
        if (LOG.isDebugEnabled()) {
            LOG.debug("String_Node_Str" + "String_Node_Str" + versionedList.getStoreSegments().size() + "String_Node_Str" + segment.getCellsCount());
        }
        swapSuffix(suffix, segment, closeSuffix);
    }
    if (region != null) {
        long suffixDataSize = getSegmentsKeySize(suffix);
        long newDataSize = segment.keySize();
        long dataSizeDelta = suffixDataSize - newDataSize;
        long suffixHeapOverhead = getSegmentsHeapOverhead(suffix);
        long newHeapOverhead = segment.heapOverhead();
        long heapOverheadDelta = suffixHeapOverhead - newHeapOverhead;
        region.addMemstoreSize(new MemstoreSize(-dataSizeDelta, -heapOverheadDelta));
        if (LOG.isDebugEnabled()) {
            LOG.debug("String_Node_Str" + suffixDataSize + "String_Node_Str" + newDataSize + "String_Node_Str" + suffixHeapOverhead + "String_Node_Str" + newHeapOverhead);
        }
    }
    return true;
}

Output:
         if (LOG.isDebugEnabled()) {
-            LOG.debug("String_Node_Str" + "String_Node_Str" + versionedList.getStoreSegments().size() + "String_Node_Str" + segment.getCellsCount());
+            int count = 0;
+            if (segment != null) {
+                count = segment.getCellsCount();
+            }
+            LOG.debug("String_Node_Str" + "String_Node_Str" + versionedList.getStoreSegments().size() + "String_Node_Str" + count);
         }


Input:
public void handleEvent(IContainerEvent event) {
    Activator activator = Activator.getDefault();
    if (activator == null)
        return;
    final IContainerManager containerManager = activator.getContainerManager();
    if (containerManager == null)
        return;
    IContainer container = containerManager.getContainer(event.getLocalContainerID());
    if (container == null)
        return;
    if (event instanceof IContainerConnectedEvent || event instanceof IContainerDisconnectedEvent) {
        IChannelContainerAdapter cca = (IChannelContainerAdapter) container.getAdapter(IChannelContainerAdapter.class);
        if (cca == null)
            return;
        ID containerID = container.getID();
        if (event instanceof IContainerConnectedEvent) {
            try {
                URLShare.addURLShare(containerID, cca);
            } catch (ECFException e) {
                Activator.getDefault().getLog().log(new Status(IStatus.INFO, Activator.PLUGIN_ID, IStatus.INFO, NLS.bind(Messages.ShareReceiversECFStart_STATUS_URLSHARE_NOT_CREATED, container.getID()), null));
            }
            try {
                ViewShare.addViewShare(containerID, cca);
            } catch (ECFException e) {
                Activator.getDefault().getLog().log(new Status(IStatus.INFO, Activator.PLUGIN_ID, IStatus.INFO, NLS.bind(Messages.ShareReceiversECFStart_STATUS_VIEWSHARE_NOT_CREATED, container.getID()), null));
            }
            try {
                ConsoleShare.addStackShare(containerID, cca);
            } catch (ECFException e) {
                Activator.getDefault().getLog().log(new Status(IStatus.INFO, Activator.PLUGIN_ID, IStatus.INFO, NLS.bind(Messages.ShareReceiversECFStart_STATUS_CAPTURESHARE_NOT_CREATED, container.getID()), null));
            }
            try {
                ScreenCaptureShare.addScreenCaptureShare(containerID, cca);
            } catch (ECFException e) {
                Activator.getDefault().getLog().log(new Status(IStatus.INFO, Activator.PLUGIN_ID, IStatus.INFO, NLS.bind(Messages.ShareReceiversECFStart_STATUS_SCREENCAPTURESHARE_NOT_CREATED, container.getID()), null));
            }
        } else if (event instanceof IContainerDisconnectedEvent) {
            URLShare.removeURLShare(containerID);
            ViewShare.removeViewShare(containerID);
            ConsoleShare.removeStackShare(containerID);
            ScreenCaptureShare.removeScreenCaptureShare(containerID);
        }
    } else if (event instanceof IContainerDisposeEvent) {
        containerManager.removeListener(containerManagerListener);
        container.removeListener(containerListener);
    }
}

Output:
             }
-        } else if (event instanceof IContainerDisconnectedEvent) {
+        } else if (event instanceof IContainerDisconnectedEvent || event instanceof IContainerEjectedEvent) {
             URLShare.removeURLShare(containerID);


Input:
public GetUserSettingsResponseCollection getUsersSettings(Iterable<String> userSmtpAddresses, UserSettingName... userSettingNames) throws Exception {
    if (this.getRequestedServerVersion().compareTo(MinimumRequestVersionForAutoDiscoverSoapService) < 0) {
        throw new ServiceVersionException(String.format(Strings.AutodiscoverServiceIncompatibleWithRequestVersion, MinimumRequestVersionForAutoDiscoverSoapService));
    }
    List<String> smtpAddresses = new ArrayList<String>();
    smtpAddresses.addAll((Collection<? extends String>) userSmtpAddresses);
    List<UserSettingName> settings = new ArrayList<UserSettingName>();
    settings.addAll(Arrays.asList(userSettingNames));
    return this.getUserSettings(smtpAddresses, settings);
}

Output:
     if (this.getRequestedServerVersion().compareTo(MinimumRequestVersionForAutoDiscoverSoapService) < 0) {
-        throw new ServiceVersionException(String.format(Strings.AutodiscoverServiceIncompatibleWithRequestVersion, MinimumRequestVersionForAutoDiscoverSoapService));
+        throw new ServiceVersionException(String.format("String_Node_Str", MinimumRequestVersionForAutoDiscoverSoapService));
     }


Input:
public void run() {
    try {
        Predicate predicate = null;
        if (request.value != null) {
            predicate = (Predicate) toObject(request.value);
        }
        QueryContext queryContext = new QueryContext(cmap.getName(), predicate, cmap.getMapIndexService());
        Set<MapEntry> results = cmap.getMapIndexService().doQuery(queryContext);
        boolean evaluateValues = (predicate != null && !queryContext.isStrong());
        createResultPairs(request, results, evaluateValues, predicate);
        enqueueAndReturn(new Processable() {
            public void process() {
                int callerPartitionHash = request.blockId;
                if (partitionManager.containsMigratingBlock() || callerPartitionHash != partitionManager.hashBlocks()) {
                    request.response = OBJECT_REDO;
                }
                boolean sent = returnResponse(request);
                if (!sent) {
                    Connection conn = node.connectionManager.getConnection(request.caller);
                    logger.log(Level.WARNING, request + "String_Node_Str" + request.caller + "String_Node_Str" + conn);
                }
            }
        });
    } catch (Throwable e) {
        logger.log(Level.SEVERE, request.toString(), e);
    }
}

Output:
         }
-        QueryContext queryContext = new QueryContext(cmap.getName(), predicate, cmap.getMapIndexService());
+        final QueryContext queryContext = new QueryContext(cmap.getName(), predicate, cmap.getMapIndexService());
         Set<MapEntry> results = cmap.getMapIndexService().doQuery(queryContext);


Input:
protected boolean onSelect(AjaxRequestTarget target, List<ODocument> objects, boolean selectMore) {
    createEdge(objects, selectedOClass);
    modal.setWindowClosedCallback(new ModalWindow.WindowClosedCallback() {
        private static final long serialVersionUID = 1L;
        public void onClose(AjaxRequestTarget target) {
            target.add(getPage());
        }
    });
    return true;
}

Output:
 protected boolean onSelect(AjaxRequestTarget target, List<ODocument> objects, boolean selectMore) {
-    createEdge(objects, selectedOClass);
-    modal.setWindowClosedCallback(new ModalWindow.WindowClosedCallback() {
-        private static final long serialVersionUID = 1L;
-        public void onClose(AjaxRequestTarget target) {
-            target.add(getPage());
-        }
-    });
+    createEdge(objects, selectedEdgeOClassModel.getObject());
+    this.modal.close(target);
+    CreateEdgeCommand.this.sendActionPerformed();
     return true;


Input:
public boolean accepts(ChangeSet changeSet) {
    for (RanChangeSet ranChangeSet : ranChangeSets) {
        if (ranChangeSet.getId().equals(changeSet.getId()) && ranChangeSet.getAuthor().equals(changeSet.getAuthor()) && isPathEquals(changeSet, ranChangeSet)) {
            if (!changeSet.generateCheckSum().equals(ranChangeSet.getLastCheckSum())) {
                UpdateStatement md5sumUpdateStatement = new UpdateStatement(database.getDefaultSchemaName(), database.getDatabaseChangeLogTableName());
                md5sumUpdateStatement.addNewColumnValue("String_Node_Str", changeSet.generateCheckSum());
                md5sumUpdateStatement.setWhereClause("String_Node_Str");
                md5sumUpdateStatement.addWhereParameter(changeSet.getId());
                md5sumUpdateStatement.addWhereParameter(changeSet.getAuthor());
                md5sumUpdateStatement.addWhereParameter(changeSet.getFilePath());
                try {
                    ExecutorService.getInstance().getWriteExecutor(database).update(md5sumUpdateStatement, new ArrayList<SqlVisitor>());
                } catch (JDBCException e) {
                    throw new RuntimeException(e);
                }
            }
            if (changeSet.shouldAlwaysRun()) {
                return true;
            } else if (changeSet.shouldRunOnChange() && !changeSet.generateCheckSum().equals(ranChangeSet.getLastCheckSum())) {
                return true;
            } else {
                return false;
            }
        }
    }
    return true;
}

Output:
                 UpdateStatement md5sumUpdateStatement = new UpdateStatement(database.getDefaultSchemaName(), database.getDatabaseChangeLogTableName());
-                md5sumUpdateStatement.addNewColumnValue("String_Node_Str", changeSet.generateCheckSum());
+                md5sumUpdateStatement.addNewColumnValue("String_Node_Str", changeSet.generateCheckSum().toString());
                 md5sumUpdateStatement.setWhereClause("String_Node_Str");


Input:
public Object getObject() {
    if (object == null) {
        if (this.descriptor != null) {
            if (this.unmarshaller.isResultAlwaysXMLRoot() || shouldWrap || descriptor.isResultAlwaysXMLRoot()) {
                object = this.descriptor.wrapObjectInXMLRoot(this.rootRecord, this.unmarshaller.isResultAlwaysXMLRoot());
            } else {
                object = this.rootRecord.getCurrentObject();
            }
        } else if (documentBuilder != null) {
            Node node = documentBuilder.getDocument().getDocumentElement();
            Root root = unmarshaller.createRoot();
            root.setLocalName(node.getLocalName());
            root.setNamespaceURI(node.getNamespaceURI());
            root.setObject(node);
            object = root;
        } else {
            if (rootRecord != null) {
                object = this.rootRecord.getCurrentObject();
            }
        }
    }
    return this.object;
}

Output:
         if (this.descriptor != null) {
-            if (this.unmarshaller.isResultAlwaysXMLRoot() || shouldWrap || descriptor.isResultAlwaysXMLRoot()) {
+            if (this.unmarshaller.isResultAlwaysXMLRoot() || shouldWrap) {
                 object = this.descriptor.wrapObjectInXMLRoot(this.rootRecord, this.unmarshaller.isResultAlwaysXMLRoot());


Input:
public void open() {
    SwingUtilities.invokeLater(new Runnable() {
        public void run() {
            setVisible(true);
        }
    });
}

Output:
     SwingUtilities.invokeLater(new Runnable() {
-        public void run() {
-            setVisible(true);
-        }
-    });
+            public void run() {
+                setVisible(true);
+            }
+        };
+        dialogThread.start();
+    }
 }


Input:
public Rectangle call() throws Exception {
    TableView table = getRealComponent();
    TableColumn<?, ?> col;
    if (m_columns.size() > 0) {
        col = m_columns.get(column);
    } else {
        col = getRealComponent().getVisibleLeafColumn(column);
    }
    table.scrollToColumn(col);
    return TableUtils.getNodeBoundsofHeader(table, column, true);
}

Output:
     table.scrollToColumn(col);
-    return TableUtils.getNodeBoundsofHeader(table, column, true);
+    return TableUtils.getNodeBoundsofHeader(table, col, true);
 }


Input:
public void testLockWithSecondaryTable() {
    if ((JUnitTestCase.getServerSession()).getPlatform().isHANA()) {
        return;
    }
    if (!isOnServer() && isSelectForUpateSupported()) {
        EntityManager em = createEntityManager();
        Exception pessimisticLockException = null;
        try {
            beginTransaction(em);
            EntityManager em2 = createEntityManager();
            try {
                beginTransaction(em2);
                List employees2 = em2.createQuery("String_Node_Str").getResultList();
                Employee employee2 = (Employee) employees2.get(0);
                List employees = em.createQuery("String_Node_Str").setLockMode(LockModeType.PESSIMISTIC_WRITE).getResultList();
                Employee employee = (Employee) employees.get(0);
                employee.setSalary(90000);
                HashMap properties = new HashMap();
                properties.put(QueryHints.PESSIMISTIC_LOCK_TIMEOUT, 0);
                em2.lock(employee2, LockModeType.PESSIMISTIC_WRITE, properties);
                employee2.setSalary(100000);
                commitTransaction(em2);
            } catch (PessimisticLockException ex) {
                pessimisticLockException = ex;
            } finally {
                closeEntityManagerAndTransaction(em2);
            }
            commitTransaction(em);
        } catch (RuntimeException ex) {
            if (isTransactionActive(em)) {
                rollbackTransaction(em);
            }
            throw ex;
        } finally {
            closeEntityManager(em);
        }
        assertFalse("String_Node_Str", pessimisticLockException == null);
    }
}

Output:
                 employee.setSalary(90000);
-                HashMap properties = new HashMap();
-                properties.put(QueryHints.PESSIMISTIC_LOCK_TIMEOUT, 0);
-                em2.lock(employee2, LockModeType.PESSIMISTIC_WRITE, properties);
+                em2.lock(employee2, LockModeType.PESSIMISTIC_WRITE);
                 employee2.setSalary(100000);


Input:
public static Project create(Sarariman sarariman, String name, Long customer, Date pop_start, Date pop_end, String contract, String subcontract, BigDecimal funded, BigDecimal previouslyBilled, long terms, BigDecimal odc_fee, boolean active) throws SQLException {
    Connection connection = sarariman.openConnection();
    PreparedStatement ps = connection.prepareStatement("String_Node_Str");
    try {
        ps.setString(1, name);
        ps.setLong(2, customer);
        ps.setDate(3, pop_start);
        ps.setDate(4, pop_end);
        ps.setString(5, contract);
        ps.setString(6, subcontract);
        ps.setBigDecimal(7, funded);
        ps.setBigDecimal(8, previouslyBilled);
        ps.setLong(9, terms);
        ps.setLong(10, terms);
        ps.setBoolean(11, active);
        ps.executeUpdate();
        ResultSet rs = ps.getGeneratedKeys();
        try {
            rs.next();
            PeriodOfPerformance pop = new PeriodOfPerformance(pop_start, pop_end);
            return new Project(sarariman, rs.getLong(1), name, customer, contract, subcontract, funded, previouslyBilled, terms, pop, odc_fee, active);
        } finally {
            rs.close();
        }
    } finally {
        ps.close();
        connection.close();
    }
}

Output:
         ps.setLong(9, terms);
-        ps.setLong(10, terms);
+        ps.setBigDecimal(10, odc_fee);
         ps.setBoolean(11, active);


Input:
public void writeResponse(ManagementCenterService mcs, ObjectDataOutput dos) throws Exception {
    Properties properties = System.getProperties();
    dos.writeInt(properties.size());
    for (Object property : properties.keySet()) {
        dos.writeUTF((String) property + "String_Node_Str" + (String) properties.get(property));
    }
}

Output:
     dos.writeInt(properties.size());
-    for (Object property : properties.keySet()) {
-        dos.writeUTF((String) property + "String_Node_Str" + (String) properties.get(property));
+    for (Map.Entry entry : properties.entrySet()) {
+        dos.writeUTF(entry.getKey() + "String_Node_Str" + entry.getValue());
     }


Input:
public String toString() {
    return "String_Node_Str" + date.getTime();
}

Output:
 public String toString() {
-    return "String_Node_Str" + date.getTime();
+    return foo.toString();
 }


Input:
protected void customRun() throws InterruptedException {
    Call call = queue.poll(100, TimeUnit.MILLISECONDS);
    try {
        if (call == null)
            return;
        int count = 0;
        while (call != null) {
            callMap.put(call.getId(), call);
            Connection oldConnection = connection;
            connection = client.getConnectionManager().getConnection();
            if (restoredConnection(oldConnection, connection)) {
                redoUnfinishedCalls(call, oldConnection);
            } else if (connection != null) {
                logger.log(Level.FINEST, "String_Node_Str" + call);
                writer.write(connection, call.getRequest());
            } else {
                interruptWaitingCalls();
            }
            call = null;
            if (count++ < 24) {
                call = queue.poll();
            }
        }
        if (connection != null) {
            writer.flush(connection);
        }
    } catch (Throwable io) {
        logger.log(Level.FINE, "String_Node_Str" + io.getMessage());
        io.printStackTrace();
        enQueue(call);
        client.getConnectionManager().destroyConnection(connection);
    }
}

Output:
             if (restoredConnection(oldConnection, connection)) {
-                redoUnfinishedCalls(call, oldConnection);
+                resubscribe(call, oldConnection);
             } else if (connection != null) {


Input:
public void setDuration(Integer duration) {
    if (duration != null && duration < 0)
        throw new IllegalArgumentException("String_Node_Str");
    assertManager();
    if (duration.equals(this.duration))
        return;
    if (isSystemRequired())
        throw new IllegalStateException("String_Node_Str" + name + "String_Node_Str");
    this.duration = duration;
}

Output:
     assertManager();
-    if (duration.equals(this.duration))
+    if (duration == null && duration == this.duration)
+        return;
+    else if (duration.equals(this.duration))
         return;


Input:
public static Builder write(OutputStream outputStream, List<Rule> rules, ProbabilisticSoftLogicPredicateManager predicateManager, LogicManager<Integer, Double> logicManager, VariableType<Integer> variableType, GroundingMode groundingMode) throws IOException {
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
    objectOutputStream.writeObject(predicateManager);
    ProbabilisticSoftLogicPredicateManager.IdWeights observedIdsAndWeights = predicateManager.getAllObservedWeights();
    ProbabilisticSoftLogicProblem.Builder builder = new ProbabilisticSoftLogicProblem.Builder(observedIdsAndWeights.Ids, observedIdsAndWeights.Weights, predicateManager.size() - observedIdsAndWeights.Ids.length);
    try {
        ProblemSerializer serializer = new ProblemSerializer(outputStream, builder);
        Rule.addGroundingsToBuilder(rules, serializer, predicateManager, logicManager, variableType, groundingMode);
        serializer.addRule(new int[] { -1 }, new int[] { -1 }, new boolean[] { false }, new boolean[] { false }, Double.NaN, Double.NaN);
    } catch (UnsupportedOperationException e) {
        if (e.getMessage() != null && e.getMessage().equals("String_Node_Str")) {
            throw (IOException) e.getCause();
        }
    }
    return builder;
}

Output:
     ProbabilisticSoftLogicPredicateManager.IdWeights observedIdsAndWeights = predicateManager.getAllObservedWeights();
-    ProbabilisticSoftLogicProblem.Builder builder = new ProbabilisticSoftLogicProblem.Builder(observedIdsAndWeights.Ids, observedIdsAndWeights.Weights, predicateManager.size() - observedIdsAndWeights.Ids.length);
+    int[] observedIndexes = new int[logicManager.getNumberOfGroundedPredicates()];
+    double[] observedWeights = new double[logicManager.getNumberOfGroundedPredicates()];
+    for (int index = 0; index < logicManager.getNumberOfGroundedPredicates(); index++) {
+        observedIndexes[index] = (int) logicManager.getGroundedPredicates().get(index).getIdentifier();
+        observedWeights[index] = (double) logicManager.getGroundedPredicates().get(index).getValue();
+    }
+    ProbabilisticSoftLogicProblem.Builder builder = new ProbabilisticSoftLogicProblem.Builder(observedIndexes, observedWeights, predicateManager.size() - observedIdsAndWeights.Ids.length);
     try {


Input:
public Iterator<Atom> iterateAtoms() {
    return atomToType.keySet().iterator();
}

Output:
 public Iterator<Atom> iterateAtoms() {
-    return atomToType.keySet().iterator();
+    return IteratorUtils.chainedIterator(iterateVertices(), iterateEdges());
 }


Input:
private static void recordNonSplitDependencies(JProgram program, OutputStream out) {
    DependencyRecorder deps = new DependencyRecorder(out);
    deps.open();
    deps.startDependencyGraph("String_Node_Str", null);
    ControlFlowAnalyzer cfa = new ControlFlowAnalyzer(program);
    cfa.setDependencyRecorder(deps);
    for (List<JMethod> entryList : program.entryMethods) {
        for (JMethod entry : entryList) cfa.traverseFrom(entry);
    }
    deps.endDependencyGraph();
    deps.close();
}

Output:
     for (List<JMethod> entryList : program.entryMethods) {
-        for (JMethod entry : entryList) cfa.traverseFrom(entry);
+        for (JMethod entry : entryList) {
+            cfa.traverseFrom(entry);
+        }
     }


Input:
public final void shouldReturnNonEmptyConversionsSetUsingSimpleOneDirectionalTraverseWithCycle() {
    final Entity m_dm = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", BigDecimal.valueOf(10L), "String_Node_Str");
    final Entity dm_cm = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", BigDecimal.valueOf(10L), "String_Node_Str");
    final Entity cm_mm = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", BigDecimal.valueOf(10L), "String_Node_Str");
    final Entity mm_m = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", new BigDecimal("String_Node_Str"), "String_Node_Str");
    stubGetAll(Lists.newArrayList(m_dm, dm_cm, cm_mm, mm_m));
    final PossibleUnitConversions result = unitConversionService.getPossibleConversions("String_Node_Str");
    assertEquals(3, result.asUnitToConversionMap().size());
    assertBigDecimalEquals(BigDecimal.valueOf(10L), result.convertTo(BigDecimal.ONE, "String_Node_Str"));
    assertBigDecimalEquals(BigDecimal.valueOf(100L), result.convertTo(BigDecimal.ONE, "String_Node_Str"));
    assertBigDecimalEquals(BigDecimal.valueOf(1000L), result.convertTo(BigDecimal.ONE, "String_Node_Str"));
}

Output:
 public final void shouldReturnNonEmptyConversionsSetUsingSimpleOneDirectionalTraverseWithCycle() {
-    final Entity m_dm = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", BigDecimal.valueOf(10L), "String_Node_Str");
-    final Entity dm_cm = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", BigDecimal.valueOf(10L), "String_Node_Str");
-    final Entity cm_mm = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", BigDecimal.valueOf(10L), "String_Node_Str");
-    final Entity mm_m = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", new BigDecimal("String_Node_Str"), "String_Node_Str");
-    stubGetAll(Lists.newArrayList(m_dm, dm_cm, cm_mm, mm_m));
+    final Entity mToDm = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", BigDecimal.valueOf(10L), "String_Node_Str");
+    final Entity dmToCm = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", BigDecimal.valueOf(10L), "String_Node_Str");
+    final Entity cmToMm = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", BigDecimal.valueOf(10L), "String_Node_Str");
+    final Entity mmToM = mockUnitConversionItem(BigDecimal.ONE, "String_Node_Str", new BigDecimal("String_Node_Str"), "String_Node_Str");
+    stubGetAll(Lists.newArrayList(mToDm, dmToCm, cmToMm, mmToM));
     final PossibleUnitConversions result = unitConversionService.getPossibleConversions("String_Node_Str");


Input:
public static List<DiningTable> parseDiningTables(String diningTablesRespStr) throws JSONException {
    if (diningTablesRespStr == null) {
        return null;
    }
    List<DiningTable> resultList = null;
    JSONObject diningTables = new JSONObject(diningTablesRespStr);
    resultList = new ArrayList<DiningTable>();
    DiningTable tempDiningTable = null;
    JSONArray dishArray = diningTables.getJSONArray("String_Node_Str");
    for (int i = 0; i < dishArray.length(); i++) {
        tempDiningTable = new DiningTable();
        JSONObject dishObj = dishArray.getJSONObject(i);
        tempDiningTable.setId(dishObj.getInt("String_Node_Str"));
        tempDiningTable.setName(dishObj.getString("String_Node_Str"));
        tempDiningTable.setMaxPeople(dishObj.getInt("String_Node_Str"));
        int free = dishObj.getInt("String_Node_Str");
        tempDiningTable.setFree(free == 0 ? true : false);
        resultList.add(tempDiningTable);
    }
    return resultList;
}

Output:
     }
-    List<DiningTable> resultList = null;
+    ArrayList<DiningTable> resultList = null;
     JSONObject diningTables = new JSONObject(diningTablesRespStr);


Input:
public boolean wasLoaded() {
    return loaded;
}

Output:
 public boolean wasLoaded() {
-    return loaded;
+    return wasLoaded;
 }


Input:
private static DecimalFormat getLocalizedDecimalFormat(String pattern) {
    final DecimalFormat df = (DecimalFormat) NumberFormat.getInstance(Locales.getCurrent());
    df.applyLocalizedPattern(pattern);
    return df;
}

Output:
     final DecimalFormat df = (DecimalFormat) NumberFormat.getInstance(Locales.getCurrent());
-    df.applyLocalizedPattern(pattern);
+    df.applyPattern(pattern);
     return df;


Input:
public ReleaseDate scrapeReleaseDate() {
    Element releaseDateElement = document.select("String_Node_Str").first();
    if (releaseDateElement != null & releaseDateElement.text().contains("String_Node_Str"))
        releaseDateElement = document.select("String_Node_Str").first();
    if (releaseDateElement != null) {
        String releaseDateText = releaseDateElement.text().trim();
        if (releaseDateText.length() > 4) {
            return new ReleaseDate(releaseDateText, data18ReleaseDateFormat);
        }
    }
    return ReleaseDate.BLANK_RELEASEDATE;
}

Output:
     Element releaseDateElement = document.select("String_Node_Str").first();
-    if (releaseDateElement != null & releaseDateElement.text().contains("String_Node_Str"))
+    if ((releaseDateElement != null && releaseDateElement.text() != null && releaseDateElement.text().contains("String_Node_Str")) || releaseDateElement == null) {
         releaseDateElement = document.select("String_Node_Str").first();


Input:
public void open(Properties connProperties) throws OdaException {
    if (connProperties == null) {
        IllegalArgumentException e = new IllegalArgumentException("String_Node_Str");
        logger.logp(java.util.logging.Level.FINE, Connection.class.getName(), "String_Node_Str", e.getMessage(), e);
        throw e;
    }
    if (logger.isLoggable(Level.FINE)) {
        String logMsg = "String_Node_Str";
        for (Enumeration enumeration = connProperties.propertyNames(); enumeration.hasMoreElements(); ) {
            String propName = (String) enumeration.nextElement();
            String lcPropName = propName.toLowerCase();
            String propVal;
            if (lcPropName.indexOf("String_Node_Str") >= 0 || lcPropName.indexOf("String_Node_Str") >= 0)
                propVal = "String_Node_Str";
            else
                propVal = connProperties.getProperty(propName);
            logMsg += propName + "String_Node_Str" + propVal + "String_Node_Str";
        }
        logger.logp(Level.FINE, Connection.class.getName(), "String_Node_Str", logMsg);
    }
    close();
    String dataSource = connProperties.getProperty(Constants.ODADataSource);
    if (dataSource != null) {
        UnsupportedOperationException e = new UnsupportedOperationException("String_Node_Str");
        logger.logp(java.util.logging.Level.FINE, Connection.class.getName(), "String_Node_Str", e.getMessage(), e);
        throw e;
    } else {
        String url = connProperties.getProperty(Constants.ODAURL);
        String jndiName = connProperties.getProperty(Constants.ODAJndiName);
        if ((url == null || url.length() == 0) && (jndiName == null || jndiName.length() == 0)) {
            throw new JDBCException(ResourceConstants.DRIVER_MISSING_PROPERTIES, ResourceConstants.ERROR_MISSING_PROPERTIES);
        }
        connectByUrl(url, connProperties);
    }
}

Output:
                 propVal = "String_Node_Str";
-            else
+            else {
                 propVal = connProperties.getProperty(propName);


Input:
public boolean onTouchEvent(MotionEvent ev) {
    if (getChildCount() == 0)
        return false;
    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(ev);
    final int action = ev.getAction();
    final float x = ev.getX();
    switch(action) {
        case MotionEvent.ACTION_DOWN:
            if (!mScroller.isFinished()) {
                mScroller.abortAnimation();
            }
            mLastMotionX = x;
            mTouchState = mScroller.isFinished() ? TOUCH_STATE_REST : TOUCH_STATE_SCROLLING;
            break;
        case MotionEvent.ACTION_MOVE:
            final int xDiff = (int) Math.abs(x - mLastMotionX);
            boolean xMoved = xDiff > mTouchSlop;
            if (xMoved) {
                mTouchState = TOUCH_STATE_SCROLLING;
            }
            if (mTouchState == TOUCH_STATE_SCROLLING) {
                final int deltaX = (int) (mLastMotionX - x);
                mLastMotionX = x;
                final int scrollX = getScrollX();
                if (deltaX < 0) {
                    if (scrollX > 0) {
                        scrollBy(Math.max(-scrollX, deltaX), 0);
                    }
                } else if (deltaX > 0) {
                    final int availableToScroll = getChildAt(getChildCount() - 1).getRight() - scrollX - getWidth();
                    if (availableToScroll > 0) {
                        scrollBy(Math.min(availableToScroll, deltaX), 0);
                    }
                }
                return true;
            }
            break;
        case MotionEvent.ACTION_UP:
            if (mTouchState == TOUCH_STATE_SCROLLING) {
                final VelocityTracker velocityTracker = mVelocityTracker;
                velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                int velocityX = (int) velocityTracker.getXVelocity();
                if (velocityX > SNAP_VELOCITY && mCurrentScreen > 0) {
                    snapToScreen(mCurrentScreen - 1);
                } else if (velocityX < -SNAP_VELOCITY && mCurrentScreen < getChildCount() - 1) {
                    snapToScreen(mCurrentScreen + 1);
                } else {
                    snapToDestination();
                }
                if (mVelocityTracker != null) {
                    mVelocityTracker.recycle();
                    mVelocityTracker = null;
                }
            }
            mTouchState = TOUCH_STATE_REST;
            break;
        case MotionEvent.ACTION_CANCEL:
            mTouchState = TOUCH_STATE_REST;
    }
    return false;
}

Output:
     }
-    return false;
+    return true;
 }


Input:
public static Color getChatDefaultFontColor() {
    return new Color(defaultFontColor);
}

Output:
 public static Color getChatDefaultFontColor() {
-    return new Color(defaultFontColor);
+    return defaultFontColor == -1 ? null : new Color(defaultFontColor);
 }


Input:
public void accept(IDataModelVisitor visitor) {
    visitor.visit(this);
    if (root != null) {
        if (visitor.getClass() == ITreeVisitor.class) {
            root.accept((ITreeVisitor) visitor);
        }
    }
}

Output:
     if (root != null) {
-        if (visitor.getClass() == ITreeVisitor.class) {
+        if (visitor instanceof ITreeVisitor) {
             root.accept((ITreeVisitor) visitor);


Input:
public float getThickness() {
    return getBounds().getThickness();
}

Output:
 public float getThickness() {
-    return getBounds().getThickness();
+    return maxZ - minZ;
 }


Input:
public static <I extends BaseMessage, O extends BaseMessage> void dispatch(final I request) {
    ServiceConfiguration empyreanConfig = ServiceConfigurations.createEphemeral(Empyrean.INSTANCE);
    if (!serviceOperations.containsKey(request.getClass())) {
        try {
            ServiceContext.dispatch(RequestQueue.ENDPOINT, request);
        } catch (Exception ex) {
            Contexts.responseError(request.getCorrelationId(), ex);
        }
    } else {
        try {
            final Context ctx = Contexts.lookup(request.getCorrelationId());
            final Function<I, O> op = (Function<I, O>) serviceOperations.get(request.getClass());
            Threads.enqueue(empyreanConfig, new Runnable() {
                public void run() {
                    Contexts.threadLocal(ctx);
                    try {
                        final O reply = op.apply(request);
                        Contexts.response(reply);
                    } catch (final Exception ex) {
                        Logs.extreme().error(ex, ex);
                        Contexts.responseError(request.getCorrelationId(), ex);
                    } finally {
                        Contexts.removeThreadLocal();
                    }
                }
            });
        } catch (final Exception ex) {
            Logs.extreme().error(ex, ex);
            Contexts.responseError(request.getCorrelationId(), ex);
        }
    }
}

Output:
                 }
-            });
+            }).call();
         } catch (final Exception ex) {


Input:
public MetaGroup clone() {
    MetaGroup metaGroup = new MetaGroup();
    metaGroup.setGroup(group);
    if (CollectionUtils.isNotEmpty(metaList)) {
        List<MetaItem> metas = new ArrayList<MetaItem>();
        for (MetaItem metaItem : metaList) {
            metas.add(metaItem.clone());
        }
        metaGroup.setMetaList(metas);
    }
    return metaGroup;
}

Output:
 public MetaGroup clone() {
-    MetaGroup metaGroup = new MetaGroup();
+    MetaGroup metaGroup = null;
+    try {
+        metaGroup = (MetaGroup) super.clone();
+    } catch (CloneNotSupportedException e) {
+        throw new InternalError(e.toString());
+    }
     metaGroup.setGroup(group);


Input:
protected void calculateOffsets() {
    if (!mCustomViewPortEnabled) {
        float offsetLeft = 0f, offsetRight = 0f, offsetTop = 0f, offsetBottom = 0f;
        if (mLegend != null && mLegend.isEnabled()) {
            if (mLegend.getPosition() == LegendPosition.RIGHT_OF_CHART || mLegend.getPosition() == LegendPosition.RIGHT_OF_CHART_CENTER) {
                offsetRight += mLegend.mTextWidthMax + mLegend.getXOffset() * 2f;
            } else if (mLegend.getPosition() == LegendPosition.BELOW_CHART_LEFT || mLegend.getPosition() == LegendPosition.BELOW_CHART_RIGHT || mLegend.getPosition() == LegendPosition.BELOW_CHART_CENTER) {
                offsetBottom += mLegend.mTextHeightMax * 3f;
            }
        }
        if (mAxisLeft.isEnabled()) {
            offsetLeft += mAxisLeft.getRequiredWidthSpace(mAxisRendererLeft.getAxisPaint());
        }
        if (mAxisRight.isEnabled()) {
            offsetRight += mAxisRight.getRequiredWidthSpace(mAxisRendererRight.getAxisPaint());
        }
        float xlabelheight = mXAxis.mLabelHeight * 2f;
        if (mXAxis.isEnabled()) {
            if (mXAxis.getPosition() == XAxisPosition.BOTTOM) {
                offsetBottom += xlabelheight;
            } else if (mXAxis.getPosition() == XAxisPosition.TOP) {
                offsetTop += xlabelheight;
            } else if (mXAxis.getPosition() == XAxisPosition.BOTH_SIDED) {
                offsetBottom += xlabelheight;
                offsetTop += xlabelheight;
            }
        }
        float min = Utils.convertDpToPixel(10f);
        mViewPortHandler.restrainViewPort(Math.max(min, offsetLeft), Math.max(min, offsetTop), Math.max(min, offsetRight), Math.max(min, offsetBottom));
        if (mLogEnabled) {
            Log.i(LOG_TAG, "String_Node_Str" + offsetLeft + "String_Node_Str" + offsetTop + "String_Node_Str" + offsetRight + "String_Node_Str" + offsetBottom);
            Log.i(LOG_TAG, "String_Node_Str" + mViewPortHandler.getContentRect().toString());
        }
    }
    prepareOffsetMatrix();
    prepareValuePxMatrix();
}

Output:
         }
-        if (mAxisLeft.isEnabled()) {
+        if (mAxisLeft.needsOffset()) {
             offsetLeft += mAxisLeft.getRequiredWidthSpace(mAxisRendererLeft.getAxisPaint());


Input:
public void update(int timeout) throws IOException {
    updateThread = Thread.currentThread();
    synchronized (updateLock) {
    }
    long startTime = System.currentTimeMillis();
    int select = 0;
    if (timeout > 0) {
        select = selector.select(timeout);
    } else {
        select = selector.selectNow();
    }
    if (select == 0) {
        long elapsedTime = System.currentTimeMillis() - startTime;
        try {
            if (elapsedTime < 25)
                Thread.sleep(25 - elapsedTime);
        } catch (InterruptedException ex) {
        }
    } else {
        Set<SelectionKey> keys = selector.selectedKeys();
        synchronized (keys) {
            UdpConnection udp = this.udp;
            outer: for (Iterator<SelectionKey> iter = keys.iterator(); iter.hasNext(); ) {
                SelectionKey selectionKey = iter.next();
                iter.remove();
                try {
                    int ops = selectionKey.readyOps();
                    Connection fromConnection = (Connection) selectionKey.attachment();
                    if (fromConnection != null) {
                        if (udp != null && fromConnection.udpRemoteAddress == null)
                            continue;
                        if ((ops & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
                            try {
                                while (true) {
                                    Object object = fromConnection.tcp.readObject(fromConnection);
                                    if (object == null)
                                        break;
                                    if (DEBUG) {
                                        String objectString = object == null ? "String_Node_Str" : object.getClass().getSimpleName();
                                        if (!(object instanceof FrameworkMessage)) {
                                            debug("String_Node_Str", fromConnection + "String_Node_Str" + objectString);
                                        } else if (TRACE) {
                                            trace("String_Node_Str", fromConnection + "String_Node_Str" + objectString);
                                        }
                                    }
                                    fromConnection.notifyReceived(object);
                                }
                            } catch (IOException ex) {
                                if (TRACE) {
                                    trace("String_Node_Str", "String_Node_Str" + fromConnection, ex);
                                } else if (DEBUG) {
                                    debug("String_Node_Str", fromConnection + "String_Node_Str" + ex.getMessage());
                                }
                                fromConnection.close();
                            } catch (KryoNetException ex) {
                                if (ERROR)
                                    error("String_Node_Str", "String_Node_Str" + fromConnection, ex);
                                fromConnection.close();
                            }
                        }
                        if ((ops & SelectionKey.OP_WRITE) == SelectionKey.OP_WRITE) {
                            try {
                                fromConnection.tcp.writeOperation();
                            } catch (IOException ex) {
                                if (TRACE) {
                                    trace("String_Node_Str", "String_Node_Str" + fromConnection, ex);
                                } else if (DEBUG) {
                                    debug("String_Node_Str", fromConnection + "String_Node_Str" + ex.getMessage());
                                }
                                fromConnection.close();
                            }
                        }
                        continue;
                    }
                    if ((ops & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
                        ServerSocketChannel serverChannel = this.serverChannel;
                        if (serverChannel == null)
                            continue;
                        try {
                            SocketChannel socketChannel = serverChannel.accept();
                            if (socketChannel != null)
                                acceptOperation(socketChannel);
                        } catch (IOException ex) {
                            if (DEBUG)
                                debug("String_Node_Str", "String_Node_Str", ex);
                        }
                        continue;
                    }
                    if (udp == null)
                        continue;
                    InetSocketAddress fromAddress;
                    try {
                        fromAddress = udp.readFromAddress();
                    } catch (IOException ex) {
                        if (WARN)
                            warn("String_Node_Str", "String_Node_Str", ex);
                        continue;
                    }
                    if (fromAddress == null)
                        continue;
                    Connection[] connections = this.connections;
                    for (int i = 0, n = connections.length; i < n; i++) {
                        Connection connection = connections[i];
                        if (fromAddress.equals(connection.udpRemoteAddress)) {
                            fromConnection = connection;
                            break;
                        }
                    }
                    Object object;
                    try {
                        object = udp.readObject(fromConnection);
                    } catch (KryoNetException ex) {
                        if (WARN) {
                            if (fromConnection != null) {
                                if (ERROR)
                                    error("String_Node_Str", "String_Node_Str" + fromConnection, ex);
                            } else
                                warn("String_Node_Str", "String_Node_Str" + fromAddress, ex);
                        }
                        continue;
                    }
                    if (object instanceof FrameworkMessage) {
                        if (object instanceof RegisterUDP) {
                            int fromConnectionID = ((RegisterUDP) object).connectionID;
                            Connection connection = pendingConnections.remove(fromConnectionID);
                            if (connection != null) {
                                if (connection.udpRemoteAddress != null)
                                    continue outer;
                                connection.udpRemoteAddress = fromAddress;
                                addConnection(connection);
                                connection.sendTCP(new RegisterUDP());
                                if (DEBUG)
                                    debug("String_Node_Str", "String_Node_Str" + udp.datagramChannel.socket().getLocalPort() + "String_Node_Str" + fromAddress);
                                connection.notifyConnected();
                                continue;
                            }
                            if (DEBUG)
                                debug("String_Node_Str", "String_Node_Str" + fromConnectionID);
                            continue;
                        }
                        if (object instanceof DiscoverHost) {
                            try {
                                udp.datagramChannel.send(emptyBuffer, fromAddress);
                                if (DEBUG)
                                    debug("String_Node_Str", "String_Node_Str" + fromAddress);
                            } catch (IOException ex) {
                                if (WARN)
                                    warn("String_Node_Str", "String_Node_Str" + fromAddress, ex);
                            }
                            continue;
                        }
                    }
                    if (fromConnection != null) {
                        if (DEBUG) {
                            String objectString = object == null ? "String_Node_Str" : object.getClass().getSimpleName();
                            if (object instanceof FrameworkMessage) {
                                if (TRACE)
                                    trace("String_Node_Str", fromConnection + "String_Node_Str" + objectString);
                            } else
                                debug("String_Node_Str", fromConnection + "String_Node_Str" + objectString);
                        }
                        fromConnection.notifyReceived(object);
                        continue;
                    }
                    if (DEBUG)
                        debug("String_Node_Str", "String_Node_Str" + fromAddress);
                } catch (CancelledKeyException ignored) {
                }
            }
        }
    }
    long time = System.currentTimeMillis();
    Connection[] connections = this.connections;
    for (int i = 0, n = connections.length; i < n; i++) {
        Connection connection = connections[i];
        if (connection.tcp.isTimedOut(time)) {
            if (DEBUG)
                debug("String_Node_Str", connection + "String_Node_Str");
            connection.close();
        } else {
            if (connection.tcp.needsKeepAlive(time))
                connection.sendTCP(FrameworkMessage.keepAlive);
        }
        if (connection.isIdle())
            connection.notifyIdle();
    }
}

Output:
                     if (fromConnection != null) {
-                        if (udp != null && fromConnection.udpRemoteAddress == null)
+                        if (udp != null && fromConnection.udpRemoteAddress == null) {
+                            fromConnection.close();
                             continue;


Input:
protected boolean checkDescendantsURIcompliance() {
    return isURIcompliant(this.getIdentity());
}

Output:
 protected boolean checkDescendantsURIcompliance() {
-    return isURIcompliant(this.getIdentity());
+    return isTopLevelURIformCompliant(this.getIdentity());
 }


Input:
public void rejectFile() {
    try {
        incomingFileTransfer.close();
        fileTransferOpSet.fireFileTransferRequestRejected(new FileTransferRequestEvent(fileTransferOpSet, this, date));
    } catch (IllegalStateException e) {
        logger.debug("String_Node_Str", e);
        return;
    }
}

Output:
     } catch (IllegalStateException e) {
-        logger.debug("String_Node_Str", e);
+        if (logger.isDebugEnabled())
+            logger.debug("String_Node_Str", e);
         return;


Input:
public void query(String queriesString) {
    String[] queries = queriesString.split("String_Node_Str");
    ArrayList<HashMap<String, Double>> tokenCostsList = new ArrayList<HashMap<String, Double>>(queries.length);
    for (String query : queries) {
        HashMap<String, Double> tokenCosts = getTokenCosts(query);
        tokenCostsList.add(tokenCosts);
    }
    HashMap<T, Double> objectCosts = new HashMap<T, Double>(mObjects.size());
    for (T object : mObjects) {
        objectCosts.put(object, 0d);
    }
    for (Map.Entry<String, HashSet<T>> entry : mTokensMap.entrySet()) {
        for (T object : entry.getValue()) {
            double cost = objectCosts.get(object);
            for (HashMap<String, Double> tokenCosts : tokenCostsList) {
                cost += tokenCosts.get(entry.getKey());
            }
            objectCosts.put(object, cost);
        }
    }
    final HashMap<T, Double> costs = objectCosts;
    Collections.sort(mObjects, new Comparator<T>() {

        public int compare(T lhs, T rhs) {
            double ls = costs.get(lhs);
            double rs = costs.get(rhs);
            return ls == rs ? 0 : (ls < rs ? 1 : -1);
        }
    });
}

Output:
         }
-    }
-    final HashMap<T, Double> costs = objectCosts;
-    Collections.sort(mObjects, new Comparator<T>() {
+        final HashMap<T, Double> costs = objectCosts;
+        Collections.sort(mObjects, new Comparator<T>() {


Input:
public SchemaTypeInfo addClass(JavaClass javaClass) {
    if (javaClass == null) {
        return null;
    }
    if (typeInfo == null) {
        this.typeInfoClasses = new ArrayList<JavaClass>();
        this.typeInfo = new HashMap<String, TypeInfo>();
        this.userDefinedSchemaTypes = new HashMap<String, QName>();
        this.packageToNamespaceMappings = new HashMap<String, NamespaceInfo>();
        this.namespaceResolver = new NamespaceResolver();
    }
    TypeInfo info = createTypeInfoFor(javaClass);
    NamespaceInfo namespaceInfo;
    JavaPackage pack = javaClass.getPackage();
    namespaceInfo = this.packageToNamespaceMappings.get(pack.getQualifiedName());
    SchemaTypeInfo schemaInfo = new SchemaTypeInfo();
    schemaInfo.setSchemaTypeName(new QName(info.getClassNamespace(), info.getSchemaTypeName()));
    if (helper.isAnnotationPresent(javaClass, XmlRootElement.class)) {
        XmlRootElement rootElemAnnotation = (XmlRootElement) helper.getAnnotation(javaClass, XmlRootElement.class);
        String elementName = rootElemAnnotation.name();
        if (elementName.equals("String_Node_Str") || elementName.equals("String_Node_Str")) {
            if (javaClass.getName().indexOf("String_Node_Str") != -1) {
                elementName = Introspector.decapitalize(javaClass.getName().substring(javaClass.getName().lastIndexOf('$') + 1));
            } else {
                elementName = Introspector.decapitalize(javaClass.getName().substring(javaClass.getName().lastIndexOf('.') + 1));
            }
        }
        String rootNamespace = rootElemAnnotation.namespace();
        QName rootElemName = null;
        if (rootNamespace.equals("String_Node_Str")) {
            rootElemName = new QName(namespaceInfo.getNamespace(), elementName);
        } else {
            rootElemName = new QName(rootNamespace, elementName);
        }
        schemaInfo.getGlobalElementDeclarations().add(rootElemName);
        ElementDeclaration declaration = new ElementDeclaration(rootElemName, javaClass.getRawName());
        this.globalElements.put(rootElemName, declaration);
    }
    return schemaInfo;
}

Output:
         schemaInfo.getGlobalElementDeclarations().add(rootElemName);
-        ElementDeclaration declaration = new ElementDeclaration(rootElemName, javaClass.getRawName());
+        ElementDeclaration declaration = new ElementDeclaration(rootElemName, javaClass, javaClass.getRawName());
         this.globalElements.put(rootElemName, declaration);


Input:
private void updateList(final Map<String, String> changeTable, final Hashtable<String, String> conflictTable, final AbstractPipelineInput input) {
    final File tempDir = new File(input.getAttribute(ANT_INVOKER_PARAM_TEMPDIR));
    if (!tempDir.isAbsolute()) {
        throw new IllegalArgumentException("String_Node_Str" + tempDir + "String_Node_Str");
    }
    final File xmlDitalist = new File(tempDir, "String_Node_Str");
    Job job = null;
    try {
        job = new Job(tempDir);
    } catch (final IOException ex) {
        logger.logError(ex.getMessage(), ex);
    }
    final Set<String> hrefTopics = job.getSet(HREF_TOPIC_LIST);
    final Set<String> chunkTopics = job.getSet(CHUNK_TOPIC_LIST);
    for (final String s : chunkTopics) {
        if (!StringUtils.isEmptyString(s) && getFragment(s) == null) {
            final Iterator<String> hrefit = hrefTopics.iterator();
            while (hrefit.hasNext()) {
                final String ent = hrefit.next();
                if (FileUtils.resolveFile(tempDir.getAbsolutePath(), ent).equalsIgnoreCase(FileUtils.resolveFile(tempDir.getAbsolutePath(), s))) {
                    hrefit.remove();
                }
            }
        } else if (!StringUtils.isEmptyString(s) && hrefTopics.contains(s)) {
            hrefTopics.remove(s);
        }
    }
    final Set<String> topicList = new LinkedHashSet<String>(INT_128);
    final Set<String> oldTopicList = job.getSet(FULL_DITA_TOPIC_LIST);
    for (String t : hrefTopics) {
        if (t.lastIndexOf(SHARP) != -1) {
            t = t.substring(0, t.lastIndexOf(SHARP));
        }
        t = FileUtils.getRelativePath(xmlDitalist.getAbsolutePath(), FileUtils.resolveFile(tempDir.getAbsolutePath(), t));
        topicList.add(t);
        if (oldTopicList.contains(t)) {
            oldTopicList.remove(t);
        }
    }
    final Set<String> chunkedTopicSet = new LinkedHashSet<String>(INT_128);
    final Set<String> chunkedDitamapSet = new LinkedHashSet<String>(INT_128);
    final Set<String> ditamapList = job.getSet(FULL_DITAMAP_LIST);
    for (final Map.Entry<String, String> entry : changeTable.entrySet()) {
        final String oldFile = entry.getKey();
        if (entry.getValue().equals(oldFile)) {
            String newChunkedFile = entry.getValue();
            newChunkedFile = FileUtils.getRelativePath(xmlDitalist.getAbsolutePath(), newChunkedFile);
            final String extName = FileUtils.getExtension(newChunkedFile);
            if (extName != null && !extName.equalsIgnoreCase("String_Node_Str")) {
                chunkedTopicSet.add(newChunkedFile);
                if (!topicList.contains(newChunkedFile)) {
                    topicList.add(newChunkedFile);
                    if (oldTopicList.contains(newChunkedFile)) {
                        oldTopicList.remove(newChunkedFile);
                    }
                }
            } else {
                if (!ditamapList.contains(newChunkedFile)) {
                    ditamapList.add(newChunkedFile);
                    if (oldTopicList.contains(newChunkedFile)) {
                        oldTopicList.remove(newChunkedFile);
                    }
                }
                chunkedDitamapSet.add(newChunkedFile);
            }
        }
    }
    for (final String s : oldTopicList) {
        if (!StringUtils.isEmptyString(s)) {
            final File f = new File(tempDir, s);
            if (f.exists()) {
                f.delete();
            }
        }
    }
    for (final Map.Entry<String, String> entry : changeTable.entrySet()) {
        final String oldFile = entry.getKey();
        if (entry.getValue().equals(oldFile)) {
            final String targetPath = conflictTable.get(entry.getKey());
            if (targetPath != null) {
                final File target = new File(targetPath);
                if (!FileUtils.fileExists(target.getAbsolutePath())) {
                    final File from = new File(entry.getValue());
                    String relativePath = FileUtils.getRelativePath(xmlDitalist.getAbsolutePath(), from.getAbsolutePath());
                    final String relativeTargetPath = FileUtils.getRelativePath(xmlDitalist.getAbsolutePath(), target.getAbsolutePath());
                    if (relativeTargetPath.lastIndexOf(SLASH) != -1) {
                        relativePath2fix.put(relativeTargetPath, relativeTargetPath.substring(0, relativeTargetPath.lastIndexOf(SLASH) + 1));
                    }
                    target.delete();
                    from.renameTo(target);
                    if (topicList.contains(relativePath)) {
                        topicList.remove(relativePath);
                    }
                    if (chunkedTopicSet.contains(relativePath)) {
                        chunkedTopicSet.remove(relativePath);
                    }
                    relativePath = FileUtils.getRelativePath(xmlDitalist.getAbsolutePath(), target.getAbsolutePath());
                    topicList.add(relativePath);
                    chunkedTopicSet.add(relativePath);
                } else {
                    conflictTable.remove(entry.getKey());
                }
            }
        }
    }
    for (final String file : chunkedTopicSet) {
        job.getOrCreateFileInfo(file).isResourceOnly = false;
    }
    for (final String file : chunkedDitamapSet) {
        job.getOrCreateFileInfo(file).isResourceOnly = false;
    }
    for (FileInfo f : job.getFileInfo().values()) {
        if ("String_Node_Str".equals(f.format) || "String_Node_Str".equals(f.format)) {
            f.isActive = false;
        }
    }
    for (final String file : topicList) {
        final FileInfo ff = job.getOrCreateFileInfo(file);
        ff.format = "String_Node_Str";
        ff.isActive = true;
    }
    for (final String file : ditamapList) {
        final FileInfo ff = job.getOrCreateFileInfo(file);
        ff.format = "String_Node_Str";
        ff.isActive = true;
    }
    job.setProperty("String_Node_Str", CHUNKED_DITAMAP_LIST_FILE);
    job.setProperty("String_Node_Str", CHUNKED_TOPIC_LIST_FILE);
    job.setProperty("String_Node_Str", RESOURCE_ONLY_LIST_FILE);
    for (final String file : chunkedDitamapSet) {
        job.getOrCreateFileInfo(file).isChunkedDitaMap = true;
    }
    for (final String file : chunkedDitamapSet) {
        job.getOrCreateFileInfo(file).isChunked = true;
    }
    try {
        job.write();
    } catch (final IOException ex) {
        logger.logError(ex.getMessage(), ex);
    }
}

Output:
     }
-    for (final String file : chunkedDitamapSet) {
+    for (final String file : chunkedTopicSet) {
         job.getOrCreateFileInfo(file).isChunked = true;


Input:
public void setTagName(String tag) {
    Assert.isNotNull(tag);
    this.tagName = tag;
}

Output:
 public void setTagName(String tag) {
-    Assert.isNotNull(tag);
+    Assert.isNotNull(tag, "String_Node_Str");
     this.tagName = tag;


Input:
public void receive(SimulcastStream simStream, boolean urgent) {
    if (simStream == null) {
        weakCurrent = null;
        weakNext = null;
        return;
    }
    SimulcastStream current = getCurrent();
    SimulcastStream next = getNext();
    if (current == simStream || next == simStream) {
        if (logger.isDebugEnabled()) {
            logger.debug("String_Node_Str" + simStream.getOrder() + "String_Node_Str");
        }
        return;
    }
    if (logger.isDebugEnabled()) {
        logger.debug("String_Node_Str" + simStream.getOrder() + "String_Node_Str" + urgent + "String_Node_Str" + getSimulcastSender().getSimulcastReceiver().getSimulcastEngine().getVideoChannel().getEndpoint().getID() + "String_Node_Str");
    }
    simStream.askForKeyframe();
    if (urgent || current == null) {
        weakCurrent = new WeakReference<>(simStream);
    } else {
        weakNext = new WeakReference<>(simStream);
    }
}

Output:
     if (simStream == null) {
-        weakCurrent = null;
-        weakNext = null;
+        this.state = new State(null, null);
         return;


Input:
public void destroy(HandlerContext context) {
    super.destroy(context);
    synchronized (this) {
        if (debugClazz != null && debugObject != null) {
            try {
                Method destroyMethod = debugClazz.getMethod("String_Node_Str");
                destroyMethod.setAccessible(true);
                destroyMethod.invoke(debugObject);
            } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
                LOG.debug("String_Node_Str", e);
            } finally {
                debugClazz = null;
                debugObject = null;
            }
        }
    }
}

Output:
     synchronized (this) {
-        if (debugClazz != null && debugObject != null) {
+        if (pruningDebug != null) {
             try {


Input:
private void computeTileScaledNoiseLUT(final int y, final int x0, final int y0, final int w, final ThermalNoiseInfo noiseInfo, final Sentinel1Calibrator.CalibrationInfo calInfo, final double azT0, final double azT1, final float[] vec0LUT, final float[] vec1LUT, final int[] vec0Pixels, final int pixelIdx0, final double[] lut) {
    final double[] noiseLut = new double[w];
    computeTileNoiseLUT(y, x0, y0, w, noiseInfo, noiseLut);
    final double[] calLut = new double[w];
    computeTileCalibrationLUTs(y, x0, w, calInfo, azT0, azT1, vec0LUT, vec1LUT, vec0Pixels, pixelIdx0, calLut);
    if (removeThermalNoise) {
        for (int i = 0; i < w; i++) {
            lut[i] = noiseLut[i] / (calLut[i] * calLut[i]);
        }
    } else {
        for (int i = 0; i < w; i++) {
            lut[i] = -noiseLut[i] / (calLut[i] * calLut[i]);
        }
    }
}

Output:
     final double[] noiseLut = new double[w];
-    computeTileNoiseLUT(y, x0, y0, w, noiseInfo, noiseLut);
+    computeTileNoiseLUT(y, x0, w, noiseInfo, noiseLut);
     final double[] calLut = new double[w];


Input:
public static Document fetchUrlDoc(String url) throws IOException {
    return Jsoup.connect(url).userAgent("String_Node_Str").get();
}

Output:
 public static Document fetchUrlDoc(String url) throws IOException {
-    return Jsoup.connect(url).userAgent("String_Node_Str").get();
+    try {
+        return Jsoup.connect(url).userAgent("String_Node_Str").get();
+    } catch (Exception e) {
+        log.debug(format("String_Node_Str", url, e.getMessage()));
+        return null;
+    }
 }


Input:
public void onRow(Row4Aggregation row) throws IOException, DataException {
    Row4Aggregation newRow = new Row4Aggregation();
    if (row.getLevelMembers().length != newMemberSize || orignalLevelCount != newMemberSize) {
        Member[] nMembers = new Member[newMemberSize];
        System.arraycopy(row.getLevelMembers(), 0, nMembers, 0, firstTimeLevel);
        Member[] timeMember = cubeDimensionReader.getLevelMembers(timeDimensionIndex, endLevelIndex, row.getDimPos()[timeDimensionIndex]);
        System.arraycopy(timeMember, 0, nMembers, firstTimeLevel, timeMember.length);
        if ((orignalLevelCount - (lowestTimeLevel + 1)) > 0) {
            System.arraycopy(row.getLevelMembers(), lowestTimeLevel + 1, nMembers, firstTimeLevel + timeMember.length, orignalLevelCount - (lowestTimeLevel + 1));
        }
        newRow.setLevelMembers(nMembers);
        newRow.setDimPos(row.getDimPos());
        newRow.setMeasures(row.getMeasures());
        newRow.setMeasureList(row.getMeasureList());
        newRow.setParameterValues(row.getParameterValues());
    } else {
        newRow = row;
    }
    if (this.existReferenceDate) {
        sortedFactRows.push(newRow);
    }
    if (this.existLastDate) {
        factRows.add(newRow);
    }
}

Output:
     }
-    if (this.existReferenceDate) {
+    if (this.existReferenceDate && !this.avoidExtraSort) {
         sortedFactRows.push(newRow);


Input:
public Object getMapValueElement(final Object object, final Object key) {
    Map map = (Map) object;
    return map.get(key);
}

Output:
 public Object getMapValueElement(final Object object, final Object key) {
-    Map map = (Map) object;
-    return map.get(key);
+    if (object instanceof ColumnAndIndex) {
+        ColumnAndIndex columnAndIndex = (ColumnAndIndex) object;
+        IColumn childColumn = columnAndIndex.column.getColumn(key.toString());
+        return getField.get(childColumn, columnAndIndex.index, columnAndIndex.columnIndex);
+    } else {
+        Map map = (Map) object;
+        return map.get(key);
+    }
 }


Input:
private <T> Pair2[] findMatchedMethod(Class<T> klass) {
    Method[] all = Mirror.me(klass).getAllDeclaredMethodsWithoutTop();
    List<Pair2> p2 = new ArrayList<Pair2>();
    for (Method m : all) {
        int mod = m.getModifiers();
        if (mod == 0 || Modifier.isStatic(mod) || Modifier.isPrivate(mod))
            continue;
        ArrayList<MethodInterceptor> mls = new ArrayList<MethodInterceptor>();
        for (Pair p : pairs) if (p.matcher.match(m))
            mls.add(p.listener);
        if (mls.size() > 0)
            p2.add(new Pair2(m, mls));
    }
    return p2.toArray(new Pair2[p2.size()]);
}

Output:
         int mod = m.getModifiers();
-        if (mod == 0 || Modifier.isStatic(mod) || Modifier.isPrivate(mod))
+        if (mod == 0 || Modifier.isStatic(mod) || Modifier.isPrivate(mod) || Modifier.isFinal(mod) || Modifier.isAbstract(mod))
             continue;