Input:
protected void respond(AjaxRequestTarget target) {
    Request request = RequestCycle.get().getRequest();
    String action = request.getParameter(DraggableBehavior.PARAM_ACTION);
    String id = extractId(request.getParameter(DraggableBehavior.PARAM_DRAGGABLE_ID));
    if (id != null) {
        final String finalId = id.endsWith(TemplateGenerator.WRAPPER_SUFFIX) ? id.substring(0, id.length() - 8) : id;
        MarkupContainer comp = (MarkupContainer) getComponent();
        Component child = (Component) comp.visitChildren(Component.class, new IVisitor<Component>() {
            public Object component(Component component) {
                String markupId = component.getMarkupId();
                if (finalId.equals(markupId))
                    return component;
                return IVisitor.CONTINUE_TRAVERSAL;
            }
        });
        if (child != null && action != null) {
            int height = stripUnitPart(request.getParameter(PARAM_RESIZE_HEIGHT));
            int width = stripUnitPart(request.getParameter(PARAM_RESIZE_WIDTH));
            int x = stripUnitPart(request.getParameter(DraggableBehavior.PARAM_X));
            int y = stripUnitPart(request.getParameter(DraggableBehavior.PARAM_Y));
            if (action.equals(ACTION_SELECT)) {
                Object ret = callback.executeOnSelect(getJSEvent(EventType.rightClick, 0, new Point(x, y), new IComponent[] { (IComponent) child }));
                if (ret instanceof Boolean && !((Boolean) ret).booleanValue()) {
                    onSelectComponent = null;
                } else {
                    target.appendJavascript("String_Node_Str" + id + "String_Node_Str");
                }
                return;
            }
            if (child != onSelectComponent) {
                onSelectComponent = (IComponent) child;
            }
            if (action.equals(ACTION_RESIZE)) {
                if (width != -1 && height != -1) {
                    if (child instanceof ISupportWebBounds) {
                        Insets paddingAndBorder = ((ISupportWebBounds) child).getPaddingAndBorder();
                        if (paddingAndBorder != null) {
                            height += paddingAndBorder.bottom + paddingAndBorder.top;
                            width += paddingAndBorder.left + paddingAndBorder.right;
                        }
                    }
                    if (child instanceof IScriptableProvider)
                        ((IRuntimeComponent) ((IScriptableProvider) child).getScriptObject()).setSize(width, height);
                    if (child instanceof IProviderStylePropertyChanges)
                        ((IProviderStylePropertyChanges) child).getStylePropertyChanges().setRendered();
                }
                callback.executeOnResize(getJSEvent(EventType.onDrop, 0, new Point(x, y), new IComponent[] { (IComponent) child }));
            } else if (action.equals(DraggableBehavior.ACTION_DRAG_START)) {
                Object onDragAllowed = callback.executeOnDrag(getJSEvent(EventType.onDrag, 0, new Point(x, y), new IComponent[] { (IComponent) child }));
                if ((onDragAllowed instanceof Boolean && !((Boolean) onDragAllowed).booleanValue()) || (onDragAllowed instanceof Number && ((Number) onDragAllowed).intValue() == DRAGNDROP.NONE)) {
                    onDragComponent = null;
                } else {
                    onDragComponent = (IComponent) child;
                }
            } else {
                if (child == onDragComponent) {
                    if (x != -1 && y != -1) {
                        ((IRuntimeComponent) ((IScriptableProvider) child).getScriptObject()).setLocation(x, y);
                        if (child instanceof IProviderStylePropertyChanges) {
                            if ((child).getParent() instanceof WrapperContainer) {
                                WrapperContainer wrapper = (WrapperContainer) (child).getParent();
                                wrapper.getStylePropertyChanges().getChanges();
                                wrapper.getStylePropertyChanges().setRendered();
                            }
                            ((IProviderStylePropertyChanges) child).getStylePropertyChanges().setRendered();
                        }
                    }
                    callback.executeOnDrop(getJSEvent(EventType.onDrop, 0, new Point(x, y), new IComponent[] { (IComponent) child }));
                }
            }
        }
    }
    WebEventExecutor.generateResponse(target, getComponent().getPage());
    target.prependJavascript("String_Node_Str");
}

Output:
         });
-        if (child != null && action != null) {
+        if (child instanceof IComponent && action != null) {
             int height = stripUnitPart(request.getParameter(PARAM_RESIZE_HEIGHT));


Input:
public URL findResource(ModuleHandle moduleHandle, String fileName, int type) {
    if (fileName == null)
        return null;
    try {
        File f = new File(fileName);
        if (f.isAbsolute())
            return f.exists() && f.isFile() ? f.getCanonicalFile().toURL() : null;
    } catch (IOException e) {
        return null;
    }
    try {
        URL objURI = new URL(fileName);
        if (isGlobalResource(objURI))
            return objURI;
        return tryLocalResourceSearch(objURI);
    } catch (MalformedURLException e) {
    }
    if (moduleHandle == null)
        return tryFragmentSearch(fileName);
    String resourcePath = moduleHandle.getModule().getSession().getResourceFolder();
    if (resourcePath == null)
        resourcePath = moduleHandle.getResourceFolder();
    if (resourcePath != null) {
        File f = new File(resourcePath, fileName);
        try {
            if (f.exists() && f.isFile())
                return f.getCanonicalFile().toURL();
        } catch (IOException e) {
        }
    }
    URL url = tryFragmentSearch(fileName);
    if (url != null)
        return url;
    URL systemId = moduleHandle.getModule().getSystemId();
    if (systemId == null)
        return null;
    try {
        url = new URL(systemId, URIUtil.convertFileNameToURLString(fileName));
        if (isGlobalResource(url))
            return url;
        return tryLocalResourceSearch(url);
    } catch (MalformedURLException e) {
    }
    return null;
}

Output:
     if (fileName == null)
-        return null;
-    try {
-        File f = new File(fileName);
-        if (f.isAbsolute())
-            return f.exists() && f.isFile() ? f.getCanonicalFile().toURL() : null;
-    } catch (IOException e) {
-        return null;
+        return u;
+    switch(type) {
+        case IResourceLocator.MESSAGE_FILE:
+            u = getMessageFile(moduleHandle, fileName);
+            break;
+        default:
+            u = getResource(moduleHandle, fileName);
+            break;
     }


Input:
protected void replicateTo(ID[] remotes) {
    trace("String_Node_Str" + Arrays.asList(remotes) + "String_Node_Str");
    try {
        ISharedObjectContext context = getSharedObject().getContext();
        if (context == null)
            return;
        ID[] group = context.getGroupMemberIDs();
        if (group == null || group.length < 1) {
            return;
        }
        SharedObjectDescription[] createInfos = getSharedObject().getReplicaDescriptions(remotes);
        if (createInfos != null) {
            if (createInfos.length == 1) {
                context.sendCreate((remotes == null) ? null : remotes[0], createInfos[0]);
            } else {
                for (int i = 0; i < remotes.length; i++) {
                    context.sendCreate(remotes[i], createInfos[i]);
                }
            }
        }
    } catch (IOException e) {
        traceStack("String_Node_Str" + Arrays.asList(remotes) + "String_Node_Str", e);
        return;
    }
}

Output:
 protected void replicateTo(ID[] remotes) {
-    trace("String_Node_Str" + Arrays.asList(remotes) + "String_Node_Str");
+    if (remotes == null) {
+        trace("String_Node_Str");
+    } else {
+        trace("String_Node_Str" + Arrays.asList(remotes) + "String_Node_Str");
+    }
     try {


Input:
public boolean onTouchEvent(MotionEvent event) {
    boolean result = super.onTouchEvent(event);
    if (!result) {
        mViewPager.onTouchEvent(event);
    }
    return result;
}

Output:
     if (!result) {
-        mViewPager.onTouchEvent(event);
+        try {
+            mViewPager.onTouchEvent(event);
+        } catch (IllegalArgumentException e) {
+            Log.d(Constants.TAG, "String_Node_Str");
+        }
     }


Input:
public static MicroAggregationFunction createGeometricMean(boolean ignoreMissingData) {
    return new MicroAggregationFunction(new DistributionAggregateFunctionGeometricMean(ignoreMissingData), true, DataScale.INTERVAL, "String_Node_Str");
}

Output:
 public static MicroAggregationFunction createGeometricMean(boolean ignoreMissingData) {
-    return new MicroAggregationFunction(new DistributionAggregateFunctionGeometricMean(ignoreMissingData), true, DataScale.INTERVAL, "String_Node_Str");
+    return new MicroAggregationFunction(new DistributionAggregateFunctionGeometricMean(ignoreMissingData), DataScale.INTERVAL, "String_Node_Str");
 }


Input:
public boolean touchStore() {
    if (cookieStoreFile.lastModified() + CACHE_WRITE_DELTA > System.currentTimeMillis()) {
        return false;
    }
    boolean ignore = cookieStoreFile.setLastModified(System.currentTimeMillis());
    return true;
}

Output:
     }
-    boolean ignore = cookieStoreFile.setLastModified(System.currentTimeMillis());
-    return true;
+    return (cookieStoreFile.setLastModified(System.currentTimeMillis()));
 }


Input:
public static void deleteCertificate(User requestUser, SearchResultRow certSerialized) throws EucalyptusServiceException {
    try {
        int i = 0;
        String certId = certSerialized.getField(i++);
        i++;
        i++;
        String accountName = certSerialized.getField(i++);
        String userName = certSerialized.getField(i++);
        Account account = Accounts.lookupAccountByName(accountName);
        User user = account.lookupUserByName(userName);
        EuarePermission.authorizeDeleteUserCertificate(requestUser, account, user);
        user.removeKey(certId);
    } catch (EucalyptusServiceException e) {
        LOG.debug(e, e);
        throw e;
    } catch (Exception e) {
        LOG.error("String_Node_Str" + certSerialized, e);
        LOG.debug(e, e);
        throw new EucalyptusServiceException("String_Node_Str" + certSerialized + "String_Node_Str" + e.getMessage());
    }
}

Output:
         EuarePermission.authorizeDeleteUserCertificate(requestUser, account, user);
-        user.removeKey(certId);
+        user.removeCertificate(certId);
     } catch (EucalyptusServiceException e) {


Input:
public void renderReport(OutputStream os, HttpServletRequest request, IReportDocument reportDocument, String format, long pageNumber, String pageRange, boolean masterPage, boolean svgFlag, List activeIds, Locale locale, boolean rtl, String iServletPath) throws RemoteException {
    if (reportDocument == null) {
        AxisFault fault = new AxisFault(BirtResources.getMessage(ResourceConstants.ACTION_EXCEPTION_NO_REPORT_DOCUMENT));
        fault.setFaultCode(new QName("String_Node_Str"));
        throw fault;
    }
    OutputStream out = os;
    if (out == null)
        out = new ByteArrayOutputStream();
    String servletPath = iServletPath;
    if (servletPath == null)
        servletPath = request.getServletPath();
    IRenderTask renderTask = engine.createRenderTask(reportDocument);
    BirtUtility.addTask(request, renderTask);
    HashMap context = new HashMap();
    context.put(EngineConstants.APPCONTEXT_BIRT_VIEWER_HTTPSERVET_REQUEST, request);
    context.put(EngineConstants.APPCONTEXT_CLASSLOADER_KEY, ReportEngineService.class.getClassLoader());
    context.put(EngineConstants.APPCONTEXT_CHART_RESOLUTION, ParameterAccessor.getDpi(request));
    ParameterAccessor.pushAppContext(context, request);
    renderTask.setAppContext(context);
    RenderOption renderOption = null;
    if (format == null)
        format = ParameterAccessor.getFormat(request);
    if (ParameterAccessor.PARAM_FORMAT_PDF.equalsIgnoreCase(format)) {
        renderOption = createPDFRenderOption(servletPath, request, ParameterAccessor.isDesigner(request));
    } else {
        renderOption = createHTMLRenderOption(svgFlag, servletPath, request);
    }
    renderOption.setOutputStream(out);
    renderOption.setOutputFormat(format);
    ViewerHTMLActionHandler handler = null;
    if (format.equalsIgnoreCase(ParameterAccessor.PARAM_FORMAT_PDF)) {
        handler = new ViewerHTMLActionHandler(reportDocument, pageNumber, locale, false, rtl, masterPage, format);
    } else {
        boolean isEmbeddable = false;
        if (IBirtConstants.SERVLET_PATH_FRAMESET.equalsIgnoreCase(servletPath) || IBirtConstants.SERVLET_PATH_RUN.equalsIgnoreCase(servletPath))
            isEmbeddable = true;
        if (renderOption instanceof IHTMLRenderOption)
            ((IHTMLRenderOption) renderOption).setEmbeddable(isEmbeddable);
        renderOption.setOption(IHTMLRenderOption.HTML_RTL_FLAG, new Boolean(rtl));
        renderOption.setOption(IHTMLRenderOption.INSTANCE_ID_LIST, activeIds);
        renderOption.setOption(IHTMLRenderOption.MASTER_PAGE_CONTENT, new Boolean(masterPage));
        handler = new ViewerHTMLActionHandler(reportDocument, pageNumber, locale, isEmbeddable, rtl, masterPage, format);
    }
    String resourceFolder = ParameterAccessor.getParameter(request, ParameterAccessor.PARAM_RESOURCE_FOLDER);
    handler.setResourceFolder(resourceFolder);
    renderOption.setActionHandler(handler);
    initializeEmitterConfigs(request, renderOption.getOptions());
    renderTask.setRenderOption(renderOption);
    renderTask.setLocale(locale);
    try {
        if (pageNumber > 0)
            renderTask.setPageNumber(pageNumber);
        if (pageRange != null) {
            if (!IBirtConstants.SERVLET_PATH_FRAMESET.equalsIgnoreCase(servletPath) || !ParameterAccessor.PARAM_FORMAT_HTML.equalsIgnoreCase(format))
                renderTask.setPageRange(pageRange);
        }
        renderTask.render();
    } catch (Exception e) {
        AxisFault fault = new AxisFault(e.getLocalizedMessage(), e);
        fault.setFaultCode(new QName("String_Node_Str"));
        fault.setFaultString(e.getLocalizedMessage());
        throw fault;
    } finally {
        BirtUtility.removeTask(request);
        renderTask.close();
    }
}

Output:
     } catch (Exception e) {
-        AxisFault fault = new AxisFault(e.getLocalizedMessage(), e);
+        AxisFault fault = new AxisFault(e.getLocalizedMessage(), e.getCause());
         fault.setFaultCode(new QName("String_Node_Str"));


Input:
private void updateCache() {
    if (states.get().cache != null) {
        return;
    }
    Map<String, MergedBus> mergedBuses = new LinkedHashMap<>();
    Map<ConfiguredBus, MergedBus> mapping = new IdentityHashMap<>();
    boolean[] encountered = new boolean[graph.getMaxVertex()];
    Arrays.fill(encountered, false);
    int busNum = 0;
    for (int v : graph.getVertices()) {
        if (!encountered[v]) {
            final Set<ConfiguredBus> busSet = new LinkedHashSet<>(1);
            busSet.add(graph.getVertexObject(v));
            graph.traverse(v, (v1, e, v2) -> {
                SwitchImpl aSwitch = graph.getEdgeObject(e);
                if (aSwitch.isOpen()) {
                    return TraverseResult.TERMINATE;
                } else {
                    busSet.add(graph.getVertexObject(v2));
                    return TraverseResult.CONTINUE;
                }
            }, encountered);
            if (isBusValid(busSet)) {
                String mergedBusId = BusBreakerVoltageLevel.this.id + "String_Node_Str" + busNum++;
                MergedBus mergedBus = new MergedBus(mergedBusId, busSet);
                mergedBuses.put(mergedBus.getId(), mergedBus);
                for (ConfiguredBus bus : busSet) {
                    mapping.put(bus, mergedBus);
                }
            }
        }
    }
    states.get().cache = new BusCache(mergedBuses, mapping);
}

Output:
                 mergedBuses.put(mergedBus.getId(), mergedBus);
-                for (ConfiguredBus bus : busSet) {
-                    mapping.put(bus, mergedBus);
-                }
+                busSet.forEach(bus -> mapping.put(bus, mergedBus));
             }


Input:
public IConceptVector getConceptVector(String query) throws IOException, SQLException {
    if (caching && esaCache.containsKey(query)) {
        return esaCache.get(query);
    }
    String strTerm;
    int numTerms = 0;
    ResultSet rs;
    int doc;
    double score;
    int vint;
    double vdouble;
    double tf;
    double vsum;
    int plen;
    this.clean();
    values.clear();
    query = Utils.removeDiacriticalMarks(query);
    TokenStream ts = analyzer.tokenStream("String_Node_Str", new StringReader(query));
    ts.reset();
    while (ts.incrementToken()) {
        TermAttribute t = ts.getAttribute(TermAttribute.class);
        strTerm = t.term();
        if (strTerm.equals("String_Node_Str") || strTerm.equals("String_Node_Str")) {
            continue;
        }
        termList.add(strTerm);
        numTerms++;
    }
    ts.end();
    ts.close();
    ByteArrayInputStream bais;
    DataInputStream dis;
    if (!loadToMemory) {
        db.executeUpdate("String_Node_Str");
        db.executeUpdate("String_Node_Str");
        PreparedStatement psTTerms = db.getConnection().prepareStatement("String_Node_Str");
        for (String t : termList) {
            psTTerms.setBytes(1, t.getBytes("String_Node_Str"));
            psTTerms.addBatch();
        }
        psTTerms.executeBatch();
        psTTerms.close();
        ResultSet res;
        esaNdx.clear();
        esaIdf.clear();
        res = db.executeSelect("String_Node_Str" + lang + "String_Node_Str");
        while (res.next()) {
            esaNdx.put(new String(res.getBytes("String_Node_Str"), "String_Node_Str"), res.getBytes("String_Node_Str"));
        }
        res.close();
        res = db.executeSelect("String_Node_Str" + lang + "String_Node_Str");
        while (res.next()) {
            esaIdf.put(new String(res.getBytes("String_Node_Str"), "String_Node_Str"), res.getFloat("String_Node_Str"));
        }
        res.close();
    }
    for (String t : termList) {
        if (!idfMap.containsKey(t)) {
            Float idf = esaIdf.get(t);
            if (idf != null) {
                idfMap.put(t, idf);
            }
        }
        if (freqMap.containsKey(t)) {
            vint = freqMap.get(t);
            freqMap.put(t, vint + 1);
        } else {
            freqMap.put(t, 1);
        }
    }
    if (numTerms == 0) {
        return null;
    }
    vsum = 0;
    for (String tk : idfMap.keySet()) {
        tf = 1.0 + Math.log(freqMap.get(tk));
        vdouble = (idfMap.get(tk) * tf);
        tfidfMap.put(tk, vdouble);
        vsum += vdouble * vdouble;
    }
    vsum = Math.sqrt(vsum);
    for (String tk : idfMap.keySet()) {
        vdouble = tfidfMap.get(tk);
        tfidfMap.put(tk, vdouble / vsum);
    }
    score = 0;
    for (String tk : termList) {
        byte[] rss = esaNdx.get(tk);
        score = 0;
        if (rss != null) {
            bais = new ByteArrayInputStream(rss);
            dis = new DataInputStream(bais);
            plen = dis.readInt();
            for (int k = 0; k < plen; k++) {
                doc = dis.readInt();
                score = dis.readFloat();
                float scoreF = (float) (score * tfidfMap.get(tk));
                values.adjustOrPutValue(doc, scoreF, scoreF);
            }
            dis.close();
            bais.close();
        }
    }
    float[] valuesF = values.getValues();
    ids = values.keys();
    HeapSort.heapSort(valuesF, ids);
    IConceptVector newCv = new TroveConceptVector(ids.length);
    for (int i = ids.length - 1; i >= 0 && valuesF[i] > 0; i--) {
        newCv.set(ids[i], valuesF[i] / numTerms);
    }
    if (caching) {
        esaCache.put(query, newCv);
    }
    return newCv;
}

Output:
     }
-    return newCv;
+    if (newCv.count() > 0)
+        return newCv;
+    else
+        return null;
 }


Input:
public void before(Object target, Object[] args) {
    logger.beforeInterceptor(target, target.getClass().getName(), targetMethod.getName(), "String_Node_Str", args);
    try {
        if (target != null) {
            if (target instanceof AsyncAccessor) {
                ((AsyncAccessor) target)._$PINPOINT$_setAsync(Boolean.FALSE);
            }
            if (target instanceof TraceAccessor) {
                final Trace trace = ((TraceAccessor) target)._$PINPOINT$_getTrace();
                if (trace != null && trace.canSampled()) {
                    trace.close();
                }
                ((TraceAccessor) target)._$PINPOINT$_setTrace(null);
            }
        }
    } catch (Throwable t) {
        logger.warn("String_Node_Str", t.getMessage(), t);
    }
}

Output:
 public void before(Object target, Object[] args) {
-    logger.beforeInterceptor(target, target.getClass().getName(), targetMethod.getName(), "String_Node_Str", args);
+    if (logger.isDebugEnabled()) {
+        logger.beforeInterceptor(target, methodDescriptor.getClassName(), methodDescriptor.getMethodName(), "String_Node_Str", args);
+    }
     try {


Input:
public String getQualifiedName() {
    String name = getElement().getFullName();
    if (name == null)
        return null;
    Module rootElement = getElement().getRoot();
    if (rootElement instanceof Library) {
        String namespace = ((Library) rootElement).getNamespace();
        return StringUtil.buildQualifiedReference(namespace, name);
    }
    return name;
}

Output:
     Module rootElement = getElement().getRoot();
-    if (rootElement instanceof Library) {
-        String namespace = ((Library) rootElement).getNamespace();
-        return StringUtil.buildQualifiedReference(namespace, name);
-    }
-    return name;
+    String namespace = rootElement.getNamespace();
+    return StringUtil.buildQualifiedReference(namespace, name);
 }


Input:
public void applyTargetFirst() {
    addRequiredTargetImportDeclarations();
    createMovedMethod();
    moveAdditionalMethods();
    modifyMovedMethodInvocationInTargetClass();
    ITextFileBufferManager bufferManager = FileBuffers.getTextFileBufferManager();
    ITextFileBuffer targetTextFileBuffer = bufferManager.getTextFileBuffer(targetFile.getFullPath(), LocationKind.IFILE);
    IDocument targetDocument = targetTextFileBuffer.getDocument();
    TextEdit targetEdit = targetRewriter.rewriteAST(targetDocument, null);
    try {
        UndoEdit undoEdit = targetEdit.apply(targetDocument, UndoEdit.CREATE_UNDO);
        undoRefactoring.put(targetFile, targetDocument, undoEdit);
    } catch (MalformedTreeException e) {
        e.printStackTrace();
    } catch (BadLocationException e) {
        e.printStackTrace();
    }
    if (leaveDelegate) {
        addDelegationInSourceMethod();
    } else {
        removeSourceMethod();
    }
    modifyMovedMethodInvocationInSourceClass();
    ITextFileBuffer sourceTextFileBuffer = bufferManager.getTextFileBuffer(sourceFile.getFullPath(), LocationKind.IFILE);
    IDocument sourceDocument = sourceTextFileBuffer.getDocument();
    TextEdit sourceEdit = sourceRewriter.rewriteAST(sourceDocument, null);
    try {
        UndoEdit undoEdit = sourceEdit.apply(sourceDocument, UndoEdit.CREATE_UNDO);
        undoRefactoring.put(sourceFile, sourceDocument, undoEdit);
    } catch (MalformedTreeException e) {
        e.printStackTrace();
    } catch (BadLocationException e) {
        e.printStackTrace();
    }
}

Output:
 public void applyTargetFirst() {
-    addRequiredTargetImportDeclarations();
+    if (!sourceCompilationUnit.equals(targetCompilationUnit))
+        addRequiredTargetImportDeclarations();
     createMovedMethod();


Input:
public static IRegion locationToRegion(IDocument document, Location location) throws BadLocationException {
    int offset = document.getLineOffset(location.beginLine()) + location.beginColumn();
    int length = location.endColumn() - location.beginColumn();
    for (int i = location.beginLine(); i < location.endLine(); i++) {
        length += document.getLineOffset(i);
    }
    return new Region(offset, length);
}

Output:
 public static IRegion locationToRegion(IDocument document, Location location) throws BadLocationException {
-    int offset = document.getLineOffset(location.beginLine()) + location.beginColumn();
+    int offset = document.getLineOffset(location.beginLine() - 1) + location.beginColumn();
     int length = location.endColumn() - location.beginColumn();


Input:
public int calculate(Game game, Ability sourceAbility, Effect effect) {
    CallerOfTheClawWatcher watcher = (CallerOfTheClawWatcher) game.getState().getWatchers().get("String_Node_Str", sourceAbility.getControllerId());
    if (watcher != null) {
        return watcher.getCreaturesCount();
    }
    return 0;
}

Output:
 public int calculate(Game game, Ability sourceAbility, Effect effect) {
-    CallerOfTheClawWatcher watcher = (CallerOfTheClawWatcher) game.getState().getWatchers().get("String_Node_Str", sourceAbility.getControllerId());
+    CallerOfTheClawWatcher watcher = (CallerOfTheClawWatcher) game.getState().getWatchers().get(CallerOfTheClawWatcher.class.getName(), sourceAbility.getControllerId());
     if (watcher != null) {


Input:
static <T> ConstructorBindingImpl<T> create(InjectorImpl injector, Key<T> key, InjectionPoint constructorInjector, Object source, Scoping scoping, Errors errors) throws ErrorsException {
    int numErrors = errors.size();
    Class<? super T> rawType = constructorInjector == null ? key.getTypeLiteral().getRawType() : (Class) constructorInjector.getDeclaringType().getRawType();
    if (Modifier.isAbstract(rawType.getModifiers())) {
        errors.missingImplementation(key);
    }
    if (Classes.isInnerClass(rawType)) {
        errors.cannotInjectInnerClass(rawType);
    }
    errors.throwIfNewErrors(numErrors);
    if (constructorInjector == null) {
        try {
            constructorInjector = InjectionPoint.forConstructorOf(key.getTypeLiteral());
        } catch (ConfigurationException e) {
            throw errors.merge(e.getErrorMessages()).toException();
        }
    }
    if (!scoping.isExplicitlyScoped()) {
        Class<?> annotatedType = constructorInjector.getMember().getDeclaringClass();
        Class<? extends Annotation> scopeAnnotation = findScopeAnnotation(errors, annotatedType);
        if (scopeAnnotation != null) {
            scoping = Scoping.makeInjectable(Scoping.forAnnotation(scopeAnnotation), injector, errors.withSource(rawType));
        }
    }
    errors.throwIfNewErrors(numErrors);
    Factory<T> factoryFactory = new Factory<T>();
    InternalFactory<? extends T> scopedFactory = Scoping.scope(key, injector, factoryFactory, source, scoping);
    return new ConstructorBindingImpl<T>(injector, key, source, scopedFactory, scoping, factoryFactory, constructorInjector);
}

Output:
     errors.throwIfNewErrors(numErrors);
-    Factory<T> factoryFactory = new Factory<T>();
+    Factory<T> factoryFactory = new Factory<T>(failIfNotLinked, key);
     InternalFactory<? extends T> scopedFactory = Scoping.scope(key, injector, factoryFactory, source, scoping);


Input:
private void updateSeriesPalette(int removedIndex) {
    for (int i = 0, j = 0; i < seriesDefns.size(); i++) {
        if (i != removedIndex) {
            ((SeriesDefinition) seriesDefns.get(i)).getSeriesPalette().shift(-j++);
        }
    }
}

Output:
         if (i != removedIndex) {
-            ((SeriesDefinition) seriesDefns.get(i)).getSeriesPalette().shift(-j++);
+            seriesDefns.get(i).getSeriesPalette().shift(-j++);
         }


Input:
private void fixStructuredNameComponents(ContentValues augmented, ContentValues update) {
    final String unstruct = update.getAsString(StructuredName.DISPLAY_NAME);
    final boolean touchedUnstruct = !TextUtils.isEmpty(unstruct);
    final boolean touchedStruct = !areAllEmpty(update, STRUCTURED_FIELDS);
    if (touchedUnstruct && !touchedStruct) {
        NameSplitter.Name name = new NameSplitter.Name();
        mSplitter.split(name, unstruct);
        name.toValues(update);
    } else if (!touchedUnstruct && touchedStruct) {
        NameSplitter.Name name = new NameSplitter.Name();
        name.fromValues(augmented);
        final String joined = mSplitter.join(name);
        update.put(StructuredName.DISPLAY_NAME, joined);
    }
}

Output:
 private void fixStructuredNameComponents(ContentValues augmented, ContentValues update) {
-    final String unstruct = update.getAsString(StructuredName.DISPLAY_NAME);
-    final boolean touchedUnstruct = !TextUtils.isEmpty(unstruct);
-    final boolean touchedStruct = !areAllEmpty(update, STRUCTURED_FIELDS);
+    final boolean touchedUnstruct = update.containsKey(StructuredName.DISPLAY_NAME);
+    final boolean touchedStruct = areAnySpecified(update, STRUCTURED_FIELDS);
     if (touchedUnstruct && !touchedStruct) {


Input:
public static void loadDefaults() {
    _settingsBoolean.put("String_Node_Str", true);
    _settingsBoolean.put("String_Node_Str", false);
    _settingsBoolean.put("String_Node_Str", true);
    _settingsBoolean.put("String_Node_Str", true);
    _settingsBoolean.put("String_Node_Str", false);
    _settingsBoolean.put("String_Node_Str", false);
    _settingsNumeric.put("String_Node_Str", 10f);
    _settingsNumeric.put("String_Node_Str", 64f);
    _settingsNumeric.put("String_Node_Str", 1.5f);
    _settingsNumeric.put("String_Node_Str", 1.2f);
    _settingsNumeric.put("String_Node_Str", 0.8f);
    _settingsNumeric.put("String_Node_Str", 0.05f);
    _settingsNumeric.put("String_Node_Str", 0.05f);
}

Output:
     _settingsNumeric.put("String_Node_Str", 1.5f);
-    _settingsNumeric.put("String_Node_Str", 1.2f);
+    _settingsNumeric.put("String_Node_Str", 1.6f);
     _settingsNumeric.put("String_Node_Str", 0.8f);


Input:
private void saveHiddenSites() {
    List<SiteModel> sites = mSiteStore.getDotComSites();
    for (SiteModel site : sites) {
        site.setIsVisible(true);
        mDispatcher.dispatch(SiteActionBuilder.newUpdateSiteAction(site));
    }
    boolean skippedCurrentSite = false;
    String currentSiteName = null;
    SiteList hiddenSites = getAdapter().getHiddenSites();
    for (SiteRecord site : hiddenSites) {
        if (site.localId == mCurrentLocalId) {
            skippedCurrentSite = true;
            currentSiteName = site.getBlogNameOrHomeURL();
        } else {
            SiteModel siteModel = mSiteStore.getSiteByLocalId(site.localId);
            siteModel.setIsVisible(false);
            mDispatcher.dispatch(SiteActionBuilder.newUpdateSiteAction(siteModel));
            StatsTable.deleteStatsForBlog(this, site.localId);
        }
    }
    if (skippedCurrentSite) {
        String cantHideCurrentSite = getString(R.string.site_picker_cant_hide_current_site);
        ToastUtils.showToast(this, String.format(cantHideCurrentSite, currentSiteName), ToastUtils.Duration.LONG);
    }
}

Output:
 private void saveHiddenSites() {
-    List<SiteModel> sites = mSiteStore.getDotComSites();
+    List<SiteModel> sites = mSiteStore.getWPComSites();
     for (SiteModel site : sites) {


Input:
private void maybeGrowAdjustVertices(int cap) {
    boolean vHasPositions = ((vertexBufferMask & VERTEX_POSITIONS) != 0);
    boolean vHasNormals = ((vertexBufferMask & VERTEX_POSITIONS) != 0);
    boolean vHasColors = ((vertexBufferMask & VERTEX_POSITIONS) != 0);
    boolean vHasTexcoords = ((vertexBufferMask & VERTEX_POSITIONS) != 0);
    boolean rHasPositions = hasPositions();
    boolean rHasNormals = hasNormals();
    boolean rHasColors = hasColors();
    boolean rHasTexcoords = hasTextureCoords();
    if (cap - vertexCapacity > 0) {
        cap = vertexCapacity + (vertexCapacity >> 1);
    }
    if (cap - vertexCapacity < 0) {
        cap = vertexCapacity;
    }
    int vcap = cap * vertexStride;
    if (vHasPositions != rHasPositions || vHasNormals != rHasNormals || vHasColors != rHasColors || vHasTexcoords != rHasTexcoords) {
        int newVertexStride = 0;
        int newPositionOffset = -1;
        int newNormalOffset = -1;
        int newColorOffset = -1;
        int newTexcoordOffset = -1;
        byte newVertexBufferMask = 0;
        if (rHasPositions) {
            newPositionOffset = newVertexStride++;
            newVertexBufferMask |= VERTEX_POSITIONS;
        }
        if (rHasNormals) {
            newNormalOffset = newVertexStride++;
            newVertexBufferMask |= VERTEX_NORMALS;
        }
        if (rHasColors) {
            newColorOffset = newVertexStride++;
            newVertexBufferMask |= VERTEX_COLORS;
        }
        if (rHasTexcoords) {
            newTexcoordOffset = newVertexStride++;
            newVertexBufferMask |= VERTEX_TEXCOORDS;
        }
        int[] newVerts = new int[cap * newVertexStride];
        Arrays.fill(newVerts, -1);
        if (vHasPositions) {
            int nidx = newPositionOffset;
            int oidx = vertexPositionOffset;
            for (int i = 0; i < numVertices; ++i) {
                newVerts[nidx] = vertices[oidx];
                nidx += newVertexStride;
                oidx += vertexStride;
            }
        }
        if (vHasNormals) {
            int nidx = newNormalOffset;
            int oidx = vertexNormalOffset;
            for (int i = 0; i < numVertices; ++i) {
                newVerts[nidx] = vertices[oidx];
                nidx += newVertexStride;
                oidx += vertexStride;
            }
        }
        if (vHasColors) {
            int nidx = newColorOffset;
            int oidx = vertexColorOffset;
            for (int i = 0; i < numVertices; ++i) {
                newVerts[nidx] = vertices[oidx];
                nidx += newVertexStride;
                oidx += vertexStride;
            }
        }
        if (vHasNormals) {
            int nidx = newTexcoordOffset;
            int oidx = vertexTexcoordOffset;
            for (int i = 0; i < numVertices; ++i) {
                newVerts[nidx] = vertices[oidx];
                nidx += newVertexStride;
                oidx += vertexStride;
            }
        }
        vertexStride = newVertexStride;
        vertexBufferMask = newVertexBufferMask;
        vertexPositionOffset = newPositionOffset;
        vertexNormalOffset = newNormalOffset;
        vertexColorOffset = newColorOffset;
        vertexTexcoordOffset = newTexcoordOffset;
        vertices = newVerts;
    } else if (vcap > vertices.length) {
        vertices = Arrays.copyOf(vertices, vcap);
        int vstart = numVertices * vertexStride;
        for (int i = vstart; i < vcap; ++i) {
            vertices[i] = -1;
        }
    }
    vertexCapacity = cap;
}

Output:
     boolean vHasPositions = ((vertexBufferMask & VERTEX_POSITIONS) != 0);
-    boolean vHasNormals = ((vertexBufferMask & VERTEX_POSITIONS) != 0);
-    boolean vHasColors = ((vertexBufferMask & VERTEX_POSITIONS) != 0);
-    boolean vHasTexcoords = ((vertexBufferMask & VERTEX_POSITIONS) != 0);
+    boolean vHasNormals = ((vertexBufferMask & VERTEX_NORMALS) != 0);
+    boolean vHasColors = ((vertexBufferMask & VERTEX_COLORS) != 0);
+    boolean vHasTexcoords = ((vertexBufferMask & VERTEX_TEXCOORDS) != 0);
     boolean rHasPositions = hasPositions();


Input:
protected final void drawGuiContainerBackgroundLayer(final float f, final int x, final int y) {
    final int ox = this.guiLeft;
    final int oy = this.guiTop;
    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
    this.drawBG(ox, oy, x, y);
    final List<Slot> slots = this.getInventorySlots();
    for (final Slot slot : slots) {
        if (slot instanceof OptionalSlotFake) {
            final OptionalSlotFake fs = (OptionalSlotFake) slot;
            if (fs.renderDisabled()) {
                if (fs.isEnabled()) {
                    this.drawTexturedModalRect(ox + fs.xDisplayPosition - 1, oy + fs.yDisplayPosition - 1, fs.getSourceX() - 1, fs.getSourceY() - 1, 18, 18);
                } else {
                    GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
                    GL11.glColor4f(1.0F, 1.0F, 1.0F, 0.4F);
                    GL11.glEnable(GL11.GL_BLEND);
                    this.drawTexturedModalRect(ox + fs.xDisplayPosition - 1, oy + fs.yDisplayPosition - 1, fs.getSourceX() - 1, fs.getSourceY() - 1, 18, 18);
                    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
                    GL11.glPopAttrib();
                }
            }
        }
    }
}

Output:
                     GL11.glColor4f(1.0F, 1.0F, 1.0F, 0.4F);
-                    GL11.glEnable(GL11.GL_BLEND);
+                    GlStateManager.enableBlend();
                     this.drawTexturedModalRect(ox + fs.xDisplayPosition - 1, oy + fs.yDisplayPosition - 1, fs.getSourceX() - 1, fs.getSourceY() - 1, 18, 18);


Input:
private void parsePaymentRequest(Protos.PaymentRequest request) throws PaymentRequestException {
    try {
        if (request == null)
            throw new PaymentRequestException("String_Node_Str");
        if (!request.hasPaymentDetailsVersion())
            throw new PaymentRequestException.InvalidVersion("String_Node_Str");
        if (request.getPaymentDetailsVersion() != 1)
            throw new PaymentRequestException.InvalidVersion("String_Node_Str" + request.getPaymentDetailsVersion());
        paymentRequest = request;
        if (!request.hasSerializedPaymentDetails())
            throw new PaymentRequestException("String_Node_Str");
        paymentDetails = Protos.PaymentDetails.newBuilder().mergeFrom(request.getSerializedPaymentDetails()).build();
        if (paymentDetails == null)
            throw new PaymentRequestException("String_Node_Str");
        if (!paymentDetails.hasNetwork())
            params = MainNetParams.get();
        else
            params = NetworkParameters.fromPmtProtocolID(paymentDetails.getNetwork());
        if (params == null)
            throw new PaymentRequestException.InvalidNetwork("String_Node_Str" + paymentDetails.getNetwork());
        if (paymentDetails.getOutputsCount() < 1)
            throw new PaymentRequestException.InvalidOutputs("String_Node_Str");
        for (Protos.Output output : paymentDetails.getOutputsList()) {
            if (output.hasAmount())
                totalValue = totalValue.add(BigInteger.valueOf(output.getAmount()));
        }
        if (totalValue.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0)
            throw new PaymentRequestException.InvalidOutputs("String_Node_Str");
    } catch (InvalidProtocolBufferException e) {
        throw new PaymentRequestException(e);
    }
}

Output:
         }
-        if (totalValue.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) > 0)
+        if (totalValue.compareTo(NetworkParameters.MAX_MONEY) > 0)
             throw new PaymentRequestException.InvalidOutputs("String_Node_Str");


Input:
public Cookie removeCookie(String name) {
    Cookie cookie = cookiesMap().get(name);
    if (cookie != null) {
        if (cookie.isFromUserAgent()) {
            cookie.setMaxAge(0L);
        } else {
            cookiesMap().remove(name);
        }
    }
    return cookie;
}

Output:
     if (cookie != null) {
-        if (cookie.isFromUserAgent()) {
+        if (invalidate && cookie.isFromUserAgent()) {
             cookie.setMaxAge(0L);


Input:
public boolean isNextToLeftBound() {
    return (getView().getLeft() - getMarginRight()) < getParentView().getWidth() * 0.25;
}

Output:
 public boolean isNextToLeftBound() {
-    return (getView().getLeft() - getMarginRight()) < getParentView().getWidth() * 0.25;
+    return (getView().getRight() - getMarginRight()) < getParentView().getWidth() * 0.6;
 }


Input:
public int errorCount() {
    if (delegateCompiler != null && delegateCompiler != this)
        return delegateCompiler.errorCount();
    else
        return log.nerrors;
}

Output:
         return delegateCompiler.errorCount();
-    else
-        return log.nerrors;
+    else {
+        if (werror && log.nerrors == 0 && log.nwarnings > 0) {
+            log.error("String_Node_Str");
+        }
+    }
+    return log.nerrors;
 }


Input:
private void chkPilesActionPerformed(java.awt.event.ActionEvent evt) {
    if (cbSortBy.getSelectedItem() instanceof SortBy) {
        if (this.currentView != null) {
            this.currentView.drawCards(sortSetting, chkPiles.isSelected());
        }
    }
}

Output:
         if (this.currentView != null) {
-            this.currentView.drawCards(sortSetting, chkPiles.isSelected());
+            sortSetting.setPilesToggle(chkPiles.isSelected());
+            this.currentView.drawCards(sortSetting);
         }


Input:
Object instantiate(List<InjectionPointProvider> parameterProviders) {
    Type[] parameterTypes = constructor.getGenericParameterTypes();
    int n = parameterTypes.length;
    List<InjectionPointProvider> consumedInjectables = n == 0 ? null : injectionState.saveConsumedInjectables();
    Object[] arguments = n == 0 ? NO_ARGS : new Object[n];
    boolean varArgs = constructor.isVarArgs();
    if (varArgs) {
        n--;
    }
    for (int i = 0; i < n; i++) {
        InjectionPointProvider parameterProvider = parameterProviders.get(i);
        Object value;
        if (parameterProvider instanceof ConstructorParameter) {
            value = createOrReuseArgumentValue((ConstructorParameter) parameterProvider);
        } else {
            value = getArgumentValueToInject(parameterProvider);
        }
        Type parameterType = parameterTypes[i];
        arguments[i] = wrapInProviderIfNeeded(parameterType, value);
    }
    if (varArgs) {
        Type parameterType = parameterTypes[n];
        arguments[n] = obtainInjectedVarargsArray(parameterType);
    }
    if (consumedInjectables != null) {
        injectionState.restoreConsumedInjectables(consumedInjectables);
    }
    return invokeConstructor(arguments);
}

Output:
         } else {
-            value = getArgumentValueToInject(parameterProvider);
+            value = getArgumentValueToInject(parameterProvider, i);
         }


Input:
public String saveMongoStop(final String streamName) {
    try {
        ssaw.api().stopSaveToMongo(streamName);
        return "String_Node_Str".concat(streamName).concat("String_Node_Str");
    } catch (StratioEngineStatusException | StratioEngineConnectionException e) {
        throw new StreamingShellException(e);
    }
}

Output:
         return "String_Node_Str".concat(streamName).concat("String_Node_Str");
-    } catch (StratioEngineStatusException | StratioEngineConnectionException e) {
+    } catch (StratioStreamingException e) {
         throw new StreamingShellException(e);


Input:
public int run() throws InvalidOptionException, DataStoreException, JAXBException, IOException {
    Convention convention = null;
    final Format outputFormat;
    final String format = options.get(Option.FORMAT);
    if (format == null || format.equalsIgnoreCase("String_Node_Str")) {
        if (isCRS) {
            outputFormat = Format.WKT;
            convention = Convention.WKT2_SIMPLIFIED;
        } else {
            outputFormat = Format.TEXT;
        }
    } else if (isCRS && (format.equalsIgnoreCase("String_Node_Str") || format.equalsIgnoreCase("String_Node_Str"))) {
        outputFormat = Format.WKT;
        convention = Convention.WKT2;
    } else if (isCRS && format.equalsIgnoreCase("String_Node_Str")) {
        outputFormat = Format.WKT;
        convention = Convention.WKT1;
    } else if (format.equalsIgnoreCase("String_Node_Str")) {
        outputFormat = Format.XML;
    } else {
        throw new InvalidOptionException(Errors.format(Errors.Keys.IllegalOptionValue_2, "String_Node_Str", format), format);
    }
    if (hasUnexpectedFileCount(1, 1)) {
        return Command.INVALID_ARGUMENT_EXIT_CODE;
    }
    final Metadata metadata;
    final DataStore store = DataStores.open(files.get(0));
    try {
        metadata = store.getMetadata();
    } finally {
        store.close();
    }
    if (metadata == null) {
        return 0;
    }
    Object object = metadata;
    if (isCRS) {
        boolean found = false;
        for (final ReferenceSystem rs : metadata.getReferenceSystemInfo()) {
            if (rs instanceof CoordinateReferenceSystem) {
                object = (CoordinateReferenceSystem) rs;
                found = true;
                break;
            }
        }
        if (!found) {
            return 0;
        }
    }
    switch(outputFormat) {
        case TEXT:
            {
                final TreeTable tree = MetadataStandard.ISO_19115.asTreeTable(metadata, ValueExistencePolicy.NON_EMPTY);
                final TreeTableFormat tf = new TreeTableFormat(locale, timezone);
                tf.setColumns(TableColumn.NAME, TableColumn.VALUE);
                tf.format(tree, out);
                break;
            }
        case WKT:
            {
                final WKTFormat f = new WKTFormat(locale, timezone);
                if (convention != null) {
                    f.setConvention(convention);
                }
                if (colors) {
                    f.setColors(Colors.DEFAULT);
                }
                f.format(object, out);
                out.println();
                break;
            }
        case XML:
            {
                final MarshallerPool pool = new MarshallerPool(null);
                final Marshaller marshaller = pool.acquireMarshaller();
                marshaller.setProperty(XML.LOCALE, locale);
                marshaller.setProperty(XML.TIMEZONE, timezone);
                if (isConsole()) {
                    marshaller.marshal(object, out);
                } else {
                    out.flush();
                    marshaller.setProperty(Marshaller.JAXB_ENCODING, encoding.name());
                    marshaller.marshal(object, System.out);
                    System.out.flush();
                }
                break;
            }
    }
    out.flush();
    return 0;
}

Output:
     }
-    if (hasUnexpectedFileCount(1, 1)) {
-        return Command.INVALID_ARGUMENT_EXIT_CODE;
-    }
-    final Metadata metadata;
-    final DataStore store = DataStores.open(files.get(0));
-    try {
-        metadata = store.getMetadata();
-    } finally {
-        store.close();
+    Object metadata;
+    if (useStandardInput()) {
+        DataStore store = DataStores.open(System.in);
+        try {
+            metadata = store.getMetadata();
+        } finally {
+            store.close();
+        }
+    } else {
+        if (hasUnexpectedFileCount(1, 1)) {
+            return Command.INVALID_ARGUMENT_EXIT_CODE;
+        }
+        DataStore store = DataStores.open(files.get(0));
+        try {
+            metadata = store.getMetadata();
+        } finally {
+            store.close();
+        }
     }


Input:
private void process() throws Exception {
    LOG.info("String_Node_Str" + port);
    ServerSocket serverSocket = serverChannel.socket();
    Selector selector = Selector.open();
    serverSocket.setReuseAddress(true);
    serverSocket.bind(new InetSocketAddress(port));
    serverChannel.configureBlocking(false);
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);
    while (!isClosed.get()) {
        final int n = selector.select();
        if (n == 0) {
            continue;
        }
        final Iterator it = selector.selectedKeys().iterator();
        while (it.hasNext()) {
            SelectionKey key = (SelectionKey) it.next();
            if (key.isAcceptable()) {
                final ServerSocketChannel server = (ServerSocketChannel) key.channel();
                final SocketChannel channel = server.accept();
                channel.configureBlocking(false);
                final SocketChannelEntryReader socketChannelEntryReader = new SocketChannelEntryReader(entrySize, this.externalizable);
                final Bootstrap bootstrap = socketChannelEntryReader.readWelcomeMessage(channel);
                final ModificationIterator remoteModificationIterator = map.acquireModificationIterator(bootstrap.identifier);
                remoteModificationIterator.dirtyEntries(bootstrap.timeStamp);
                final Attached attached = new Attached(socketChannelEntryReader, remoteModificationIterator);
                channel.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ, attached);
                if (bootstrap.identifier == map.getIdentifier())
                    throw new IllegalStateException("String_Node_Str" + map.getIdentifier());
                socketChannelEntryWriter.sendBootstrap(channel, map.lastModification(), localIdentifier);
                LOG.info("String_Node_Str" + map.getIdentifier() + "String_Node_Str" + bootstrap.identifier);
            }
            try {
                if (key.isWritable()) {
                    final SocketChannel socketChannel = (SocketChannel) key.channel();
                    final Attached attachment = (Attached) key.attachment();
                    socketChannelEntryWriter.writeAll(socketChannel, attachment.remoteModificationIterator);
                }
                if (key.isReadable()) {
                    final SocketChannel socketChannel = (SocketChannel) key.channel();
                    final Attached attachment = (Attached) key.attachment();
                    attachment.socketChannelEntryReader.readAll(socketChannel);
                }
            } catch (Exception e) {
                LOG.log(Level.SEVERE, "String_Node_Str", e);
                try {
                    key.channel().close();
                } catch (IOException ex) {
                }
            }
            it.remove();
        }
    }
}

Output:
                 channel.configureBlocking(false);
-                final SocketChannelEntryReader socketChannelEntryReader = new SocketChannelEntryReader(entrySize, this.externalizable);
-                final Bootstrap bootstrap = socketChannelEntryReader.readWelcomeMessage(channel);
+                final SocketChannelEntryReader socketChannelEntryReader = new SocketChannelEntryReader(maxEntrySize, this.externalizable);
+                final Bootstrap bootstrap = socketChannelEntryReader.readBootstrap(channel);
                 final ModificationIterator remoteModificationIterator = map.acquireModificationIterator(bootstrap.identifier);


Input:
public WAL.Entry filter(WAL.Entry entry) {
    if (!SchemaUtil.isMetaTable(entry.getKey().getTablename().getName())) {
        return entry;
    }
    List<Cell> cells = entry.getEdit().getCells();
    List<Cell> cellsToRemove = Lists.newArrayList();
    for (Cell cell : cells) {
        if (!isTenantRowCell(cell)) {
            cellsToRemove.add(cell);
        }
    }
    cells.removeAll(cellsToRemove);
    if (cells.size() > 0) {
        return entry;
    } else {
        return null;
    }
}

Output:
 public WAL.Entry filter(WAL.Entry entry) {
-    if (!SchemaUtil.isMetaTable(entry.getKey().getTablename().getName())) {
+    if (!SchemaUtil.isMetaTable(entry.getKey().getTableName().getName())) {
         return entry;


Input:
protected Node add(TreePath t) {
    NodePkgInfo leafPkg = super.add(TreeUtil.getPackageName(t.getCompilationUnit()));
    NodeMapOwner leaf = addNode(leafPkg, t);
    return (Node) leaf;
}

Output:
     NodePkgInfo leafPkg = super.add(TreeUtil.getPackageName(t.getCompilationUnit()));
-    NodeMapOwner leaf = addNode(leafPkg, t);
-    return (Node) leaf;
+    return addNode(leafPkg, t);
 }


Input:
public static void setOptionVariableValues(ServiceCommand serviceCommand, Map<String, String> variableToValueMap) {
    CommandOptions commandOptions = serviceCommand.getOptions();
    if (commandOptions == null || commandOptions.getOptions() == null) {
        return;
    }
    String options = commandOptions.getOptions();
    StringBuffer variableBuffer = null;
    StringBuffer resolvedOptions = new StringBuffer(options);
    int dollarSignIndex = -1;
    for (int i = 0; i < resolvedOptions.length(); i++) {
        if (resolvedOptions.charAt(i) == '$') {
            dollarSignIndex = i;
            variableBuffer = new StringBuffer();
        } else if ((resolvedOptions.charAt(i) == '}' || i == resolvedOptions.length() - 1) && variableBuffer != null) {
            if (variableBuffer.length() > 0) {
                String variable = variableBuffer.toString();
                String value = variableToValueMap.get(variable);
                int endingIndex = i + 1;
                if (value != null && dollarSignIndex >= 0 && (endingIndex <= resolvedOptions.length())) {
                    resolvedOptions.replace(dollarSignIndex, endingIndex, "String_Node_Str");
                    resolvedOptions.insert(dollarSignIndex, value);
                }
            }
            variableBuffer = null;
            dollarSignIndex = -1;
        } else if (variableBuffer != null && resolvedOptions.charAt(i) != '{') {
            variableBuffer.append(resolvedOptions.charAt(i));
        }
    }
    CommandOptions resolvedOp = new CommandOptions();
    resolvedOp.setOptions(resolvedOptions.toString());
    serviceCommand.setOptions(resolvedOp);
}

Output:
     int dollarSignIndex = -1;
-    for (int i = 0; i < resolvedOptions.length(); i++) {
+    for (int i = 0; i < resolvedOptions.length(); ) {
+        boolean inserted = false;
         if (resolvedOptions.charAt(i) == '$') {


Input:
private ActivityStack preAddTask(TaskRecord task, String reason) {
    final ActivityStack prevStack = task.stack;
    if (prevStack != null && prevStack != this) {
        prevStack.removeTask(task, reason, MOVING);
    }
    return prevStack;
}

Output:
     if (prevStack != null && prevStack != this) {
-        prevStack.removeTask(task, reason, MOVING);
+        prevStack.removeTask(task, reason, toTop ? REMOVE_TASK_MODE_MOVING_TO_TOP : REMOVE_TASK_MODE_MOVING);
     }


Input:
protected Void doInBackground(Void... params) {
    createFile();
    mDownloadTask.setDownloadState(DownloadState.DOWNLOADING);
    mDlTaskMng.updateDownloadTask(mDownloadTask);
    for (DownloadListener l : mDlTaskMng.getListeners(mDownloadTask)) {
        l.onDownloadStart();
    }
    HttpURLConnection conn = null;
    RandomAccessFile accessFile = null;
    InputStream is = null;
    int finishedSize = 0;
    int totalSize = 0;
    int startSize = 0;
    try {
        URL url = new URL(mDownloadTask.getUrl());
        conn = (HttpURLConnection) url.openConnection();
        conn.setConnectTimeout(5000);
        conn.setRequestProperty("String_Node_Str", "String_Node_Str");
        conn.setRequestMethod("String_Node_Str");
        conn.setRequestProperty("String_Node_Str", "String_Node_Str" + mDownloadTask.getFinishedSize() + "String_Node_Str" + mDownloadTask.getTotalSize());
        conn.setRequestProperty("String_Node_Str", "String_Node_Str");
        accessFile = new RandomAccessFile(mDownloadTask.getFilePath() + "String_Node_Str" + mDownloadTask.getFileName(), "String_Node_Str");
        accessFile.seek(mDownloadTask.getFinishedSize());
        finishedSize = mDownloadTask.getFinishedSize();
        totalSize = mDownloadTask.getTotalSize();
        startSize = finishedSize;
        is = conn.getInputStream();
        Log.d(TAG, "String_Node_Str" + mDlTaskMng.getListeners(mDownloadTask).size());
        Log.i(TAG, "String_Node_Str");
        byte[] buffer = new byte[BUFFER_SIZE];
        int length = -1;
        long startTime = System.currentTimeMillis();
        int speed = 0;
        while ((length = is.read(buffer)) != -1) {
            if (mPause) {
                Log.i(TAG, "String_Node_Str");
                mDownloadTask.setDownloadState(DownloadState.PAUSE);
                mDownloadTask.setFinishedSize(finishedSize);
                for (DownloadListener l : mDlTaskMng.getListeners(mDownloadTask)) {
                    l.onDownloadPause();
                }
                mDlTaskMng.updateDownloadTask(mDownloadTask);
                return null;
            }
            finishedSize += length;
            Log.d(TAG, "String_Node_Str" + length);
            accessFile.write(buffer, 0, length);
            if (finishedSize - mDownloadTask.getFinishedSize() > UPDATE_DB_PER_SIZE) {
                mDownloadTask.setFinishedSize(finishedSize);
                mDlTaskMng.updateDownloadTask(mDownloadTask);
                speed = (int) ((finishedSize - startSize) / (int) (System.currentTimeMillis() + 1 - startTime));
                publishProgress(finishedSize, totalSize, speed);
            } else if (totalSize - finishedSize < UPDATE_DB_PER_SIZE) {
                mDownloadTask.setFinishedSize(finishedSize);
                speed = (int) ((finishedSize - startSize) / (int) (System.currentTimeMillis() + 1 - startTime));
                publishProgress(finishedSize, totalSize, speed);
            }
        }
        conn.disconnect();
        mDownloadTask.setDownloadState(DownloadState.FINISHED);
        mDownloadTask.setFinishedSize(finishedSize);
        Log.d(TAG, "String_Node_Str" + mDownloadTask);
        mDlTaskMng.updateDownloadTask(mDownloadTask);
        for (DownloadListener l : mDlTaskMng.getListeners(mDownloadTask)) {
            l.onDownloadFinish(mDownloadTask.getFilePath() + "String_Node_Str" + mDownloadTask.getFileName());
        }
        mDlTaskMng.getListeners(mDownloadTask).clear();
        mDlTaskMng.removeListener(mDownloadTask);
    } catch (Exception e) {
        Log.e(TAG, "String_Node_Str" + e.getMessage());
        e.printStackTrace();
        mDownloadTask.setDownloadState(DownloadState.FAILED);
        mDownloadTask.setFinishedSize(finishedSize);
        for (DownloadListener l : mDlTaskMng.getListeners(mDownloadTask)) {
            l.onDownloadFail();
        }
        mDlTaskMng.updateDownloadTask(mDownloadTask);
    } finally {
        try {
            if (is != null) {
                is.close();
            }
            if (accessFile != null) {
                accessFile.close();
            }
            if (conn != null) {
                conn.disconnect();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return null;
}

Output:
     InputStream is = null;
-    int finishedSize = 0;
-    int totalSize = 0;
-    int startSize = 0;
+    long finishedSize = 0;
+    long totalSize = 0;
+    long startSize = 0;
     try {


Input:
public void clear() {
    for (int row = 0; row < getRowCount(); ++row) {
        for (int col = 0; col < getCellCount(row); ++col) {
            Widget child = getWidget(row, col);
            if (child != null) {
                removeWidget(child);
            }
        }
    }
    assert (widgetMap.size() == 0);
}

Output:
         for (int col = 0; col < getCellCount(row); ++col) {
-            Widget child = getWidget(row, col);
+            Widget child = widgetMap.getWidget(row, col);
             if (child != null) {


Input:
public void refreshModel(HierarchicalGraph graph, AttributeColumn[] cols, final DataTablesModel dataTablesModel) {
    showingColumns = cols;
    DynamicModel dm = Lookup.getDefault().lookup(DynamicController.class).getModel();
    if (dm != null) {
        timeIntervalsRenderer.setMinMax(dm.getMin(), dm.getMax());
        currentTimeFormat = dm.getTimeFormat();
        timeIntervalsRenderer.setTimeFormat(currentTimeFormat);
        sparkLinesRenderer.setTimeFormat(currentTimeFormat);
    }
    timeIntervalsRenderer.setDrawGraphics(timeIntervalGraphics);
    refreshingTable = true;
    if (selectedNodes == null) {
        selectedNodes = getNodesFromSelectedRows();
    }
    NodeTreeModel nodeTreeModel = new NodeTreeModel(graph.wrapToTreeNode());
    final OutlineModel mdl = DefaultOutlineModel.createOutlineModel(nodeTreeModel, new NodeRowModel(cols), true);
    outlineTable.setRootVisible(false);
    outlineTable.setRenderDataProvider(new NodeRenderer());
    try {
        SwingUtilities.invokeAndWait(new Runnable() {
            public void run() {
                outlineTable.setModel(mdl);
                NodeDataTable.this.dataTablesModel = dataTablesModel;
                setNodesSelection(selectedNodes);
                selectedNodes = null;
            }
        });
    } catch (InterruptedException ex) {
        Exceptions.printStackTrace(ex);
    } catch (InvocationTargetException ex) {
        Exceptions.printStackTrace(ex);
    }
    refreshingTable = false;
}

Output:
     outlineTable.setRenderDataProvider(new NodeRenderer());
-    try {
-        SwingUtilities.invokeAndWait(new Runnable() {
-            public void run() {
-                outlineTable.setModel(mdl);
-                NodeDataTable.this.dataTablesModel = dataTablesModel;
-                setNodesSelection(selectedNodes);
-                selectedNodes = null;
-            }
-        });
-    } catch (InterruptedException ex) {
-        Exceptions.printStackTrace(ex);
-    } catch (InvocationTargetException ex) {
-        Exceptions.printStackTrace(ex);
-    }
+    outlineTable.setModel(mdl);
+    NodeDataTable.this.dataTablesModel = dataTablesModel;
+    setNodesSelection(selectedNodes);
+    selectedNodes = null;
     refreshingTable = false;


Input:
private void sendState() throws InterruptedException, MalformedURLException {
    URL url = newCollectorUrl();
    try {
        HttpURLConnection connection = openConnection(url);
        OutputStream outputStream = connection.getOutputStream();
        final OutputStreamWriter writer = new OutputStreamWriter(outputStream);
        try {
            JsonObject root = new JsonObject();
            root.add("String_Node_Str", identifier.toJson());
            TimedMemberState timedMemberState = timedMemberStateFactory.createTimedMemberState();
            root.add("String_Node_Str", timedMemberState.toJson());
            root.writeTo(writer);
            writer.flush();
            outputStream.flush();
            post(connection);
        } finally {
            closeResource(writer);
            closeResource(outputStream);
        }
    } catch (ConnectException e) {
        if (logger.isFinestEnabled()) {
            logger.finest(e);
        } else {
            logger.info("String_Node_Str" + url);
        }
    } catch (Exception e) {
        logger.warning(e);
    }
}

Output:
         OutputStream outputStream = connection.getOutputStream();
-        final OutputStreamWriter writer = new OutputStreamWriter(outputStream);
+        final OutputStreamWriter writer = new OutputStreamWriter(outputStream, "String_Node_Str");
         try {


Input:
public static String parseString(ItemStack stack) {
    if (stack.getTypeId() == 0)
        return null;
    String type = stack.getType().toString().toLowerCase();
    MaterialData md = stack.getData();
    byte data = (md != null ? md.getData() : 0);
    if (stack.getType() == Material.WOOL) {
        data = (byte) (15 - data);
    }
    int amount = stack.getAmount();
    String enchantments = "String_Node_Str";
    for (Entry<Enchantment, Integer> entry : stack.getEnchantments().entrySet()) {
        int id = entry.getKey().getId();
        int lvl = entry.getValue();
        enchantments += "String_Node_Str" + id + "String_Node_Str" + lvl;
    }
    if (!enchantments.equals("String_Node_Str")) {
        enchantments = enchantments.substring(2);
    }
    String result = type;
    if (data != 0) {
        result += "String_Node_Str" + data;
    }
    if (amount > 1 || data != 0) {
        result += "String_Node_Str" + amount;
    }
    if (!enchantments.equals("String_Node_Str")) {
        result += "String_Node_Str" + enchantments;
    }
    return result;
}

Output:
     if (!enchantments.equals("String_Node_Str")) {
-        enchantments = enchantments.substring(2);
+        enchantments = enchantments.substring(1);
     }


Input:
private void updateObjLitOrFunctionDeclarationAtAssignNode(Name n, String alias) {
    Ref ref = n.declaration;
    Node rvalue = ref.node.getNext();
    Node varNode = new Node(Token.VAR);
    Node varParent = ref.node.getAncestor(3);
    Node gramps = ref.node.getAncestor(2);
    boolean isObjLit = rvalue.getType() == Token.OBJECTLIT;
    if (isObjLit && n.canEliminate()) {
        varParent.replaceChild(gramps, varNode);
        ref.node = null;
    } else {
        if (rvalue.getType() == Token.FUNCTION) {
            checkForHosedThisReferences(rvalue, n.docInfo, n);
        }
        ref.node.getParent().removeChild(rvalue);
        Node nameNode = NodeUtil.newName(compiler.getCodingConvention(), alias, ref.node.getAncestor(2), n.fullName());
        if (ref.node.getLastChild().getBooleanProp(Node.IS_CONSTANT_NAME)) {
            nameNode.putBooleanProp(Node.IS_CONSTANT_NAME, true);
        }
        varNode.addChildToBack(nameNode);
        nameNode.addChildToFront(rvalue);
        varParent.replaceChild(gramps, varNode);
        ref.node = nameNode;
    }
    if (isObjLit) {
        declareVarsForObjLitValues(n, alias, rvalue, varNode, varParent.getChildBefore(varNode), varParent);
    }
    addStubsForUndeclaredProperties(n, alias, varParent, varNode);
    if (!varNode.hasChildren()) {
        varParent.removeChild(varNode);
    }
    compiler.reportCodeChange();
}

Output:
         ref.node = null;
-    } else {
+        insertedVarNode = true;
+    } else if (!n.isSimpleName()) {
         if (rvalue.getType() == Token.FUNCTION) {


Input:
public void commit() throws Exception {
    try {
        Iterables.transform(this.getAllocationTokens(), VmInstance.Create.INSTANCE);
    } catch (Exception ex) {
        this.abort();
        throw ex;
    }
}

Output:
     try {
-        Iterables.transform(this.getAllocationTokens(), VmInstance.Create.INSTANCE);
+        for (ResourceToken t : this.getAllocationTokens()) {
+            VmInstance.Create.INSTANCE.apply(t);
+        }
     } catch (Exception ex) {


Input:
public void run() {
    if (bEnableBootstrapViaMuddleware) {
        logger.logMsg("String_Node_Str", LoggerType.STATUS);
        runUsingMuddleWare("String_Node_Str");
    } else {
        logger.logMsg("String_Node_Str", LoggerType.STATUS);
        runFromLocalXML_File();
    }
    logger.logMsg("String_Node_Str", LoggerType.STATUS);
    refSWTGUIManager.runApplication();
    logger.logMsg("String_Node_Str", LoggerType.STATUS);
    refOneForAllManager.destroyOnExit();
    logger.logMsg("String_Node_Str", LoggerType.STATUS);
    logger.logMsg("String_Node_Str", LoggerType.STATUS);
}

Output:
         logger.logMsg("String_Node_Str", LoggerType.STATUS);
-        runFromLocalXML_File();
+        refXmlParserManager.parseXmlFileByName(sFileName);
     }


Input:
public void doConfigure() {
    if (part == null) {
        throw new IllegalStateException("String_Node_Str");
    }
    CamelContext camelContext = getContext();
    driverContext = createDriverContext(camelContext, part);
    String name = part.getName();
    C config = driverContext.getConfiguration();
    NettyComponent nettyComponent = camelContext.getComponent("String_Node_Str", NettyComponent.class);
    nettyComponent.setConfiguration(createNettyConfiguration(config));
    LOG.info("String_Node_Str", name);
    inMemoryScheduler.setInjectUrl(asRoute("String_Node_Str", name));
    from(asRoute("String_Node_Str", name)).doTry().inOut(asRoute("String_Node_Str", config.getDeviceHost(), config.getDevicePort())).to(asRoute("String_Node_Str", name)).doCatch(Exception.class).to(asRoute("String_Node_Str", name)).end();
    ResponseHandlersMap<C, String, String> handlers = getResponseHandlerMap(driverContext);
    from(asRoute("String_Node_Str", name)).bean(handlers).split(body()).inOnly(asRoute("String_Node_Str", name));
    ICatalogue catalogue = ApiFactory.getCatalogueApi(part.getID());
    IOrbitPrediction prediction = ApiFactory.getOrbitPredictionApi(part.getID());
    IPointingDataOptimizer<C> optimizer = createOptimizer(config.getPointingDataOptimzerClassName());
    TrackingSupport<C> tracker = createTrackingSupport(config, catalogue, prediction, optimizer);
    GroundStationCommandFilter commandFilter = new GroundStationCommandFilter(config);
    from(StandardEndpoints.COMMANDS + "String_Node_Str").filter().method(commandFilter, "String_Node_Str").log(asRoute("String_Node_Str", simple("String_Node_Str").getText(), name)).split().method(tracker, "String_Node_Str").setHeader("String_Node_Str", simple("String_Node_Str")).setHeader("String_Node_Str", simple("String_Node_Str")).setHeader("String_Node_Str", simple("String_Node_Str")).setHeader("String_Node_Str", simple("String_Node_Str")).bean(verifier, "String_Node_Str").bean(inMemoryScheduler, "String_Node_Str").routeId(asRoute("String_Node_Str", name));
    from(inMemoryScheduler.getInjectUrl()).setHeader("String_Node_Str", simple("String_Node_Str")).setHeader("String_Node_Str", simple("String_Node_Str")).setHeader("String_Node_Str", simple("String_Node_Str")).setHeader("String_Node_Str", simple("String_Node_Str")).bean(new NativeCommandExtractor()).log(LoggingLevel.INFO, asRoute("String_Node_Str", simple("String_Node_Str").getText(), name)).to(asRoute("String_Node_Str", name));
    ProcessorDefinition<?> publish = from(asRoute("String_Node_Str", name));
    addInjectionRoute(publish);
    from(asRoute("String_Node_Str", name)).bean(new OnChange()).choice().when(header(StandardArguments.VALUE_HAS_CHANGED).isEqualTo(false)).log(LoggingLevel.DEBUG, asRoute("String_Node_Str", simple("String_Node_Str").getText())).otherwise().to(asRoute("String_Node_Str", name));
}

Output:
     ICatalogue catalogue = ApiFactory.getCatalogueApi(part.getID());
-    IOrbitPrediction prediction = ApiFactory.getOrbitPredictionApi(part.getID());
+    PointingDataCalculator calulator = new PointingDataCalculator();
     IPointingDataOptimizer<C> optimizer = createOptimizer(config.getPointingDataOptimzerClassName());


Input:
public DTMasterParams doCompute(MasterContext<DTMasterParams, DTWorkerParams> context) {
    if (context.isFirstIteration()) {
        return buildInitialMasterParams();
    }
    boolean isFirst = false;
    Map<Integer, NodeStats> nodeStatsMap = null;
    double trainError = 0d, validationError = 0d;
    long trainCount = 0L, validationCount = 0L;
    for (DTWorkerParams params : context.getWorkerResults()) {
        if (!isFirst) {
            isFirst = true;
            nodeStatsMap = params.getNodeStatsMap();
        } else {
            Map<Integer, NodeStats> currNodeStatsmap = params.getNodeStatsMap();
            for (Entry<Integer, NodeStats> entry : nodeStatsMap.entrySet()) {
                NodeStats resultNodeStats = entry.getValue();
                mergeNodeStats(resultNodeStats, currNodeStatsmap.get(entry.getKey()));
            }
        }
        trainError += params.getTrainError();
        validationError += params.getValidationError();
        if (this.isRF) {
            trainCount += params.getTrainCount() * this.treeNum;
            validationCount += params.getValidationCount() * this.treeNum;
        }
        if (this.isGBDT) {
            trainCount += params.getTrainCount();
            validationCount += params.getValidationCount();
        }
    }
    for (Entry<Integer, NodeStats> entry : nodeStatsMap.entrySet()) {
        NodeStats nodeStats = entry.getValue();
        int treeId = nodeStats.getTreeId();
        Node doneNode = Node.getNode(trees.get(treeId).getNode(), nodeStats.getNodeId());
        Map<Integer, double[]> statistics = nodeStats.getFeatureStatistics();
        List<GainInfo> gainList = new ArrayList<GainInfo>();
        for (Entry<Integer, double[]> gainEntry : statistics.entrySet()) {
            int columnNum = gainEntry.getKey();
            ColumnConfig config = this.columnConfigList.get(columnNum);
            double[] statsArray = gainEntry.getValue();
            GainInfo gainInfo = this.impurity.computeImpurity(statsArray, config);
            if (gainInfo != null) {
                gainList.add(gainInfo);
            }
        }
        GainInfo maxGainInfo = GainInfo.getGainInfoByMaxGain(gainList);
        if (maxGainInfo == null) {
            doneNode.setLeaf(true);
            continue;
        }
        populateGainInfoToNode(doneNode, maxGainInfo);
        boolean isLeaf = maxGainInfo.getGain() <= 0d || Node.indexToLevel(doneNode.getId()) == this.maxDepth;
        doneNode.setLeaf(isLeaf);
        if (!doneNode.isLeaf()) {
            boolean leftChildIsLeaf = Node.indexToLevel(doneNode.getId()) + 1 == this.maxDepth || Double.compare(maxGainInfo.getLeftImpurity(), 0d) == 0;
            int leftIndex = Node.leftIndex(doneNode.getId());
            Node left = new Node(leftIndex, maxGainInfo.getLeftPredict(), maxGainInfo.getLeftImpurity(), true);
            doneNode.setLeft(left);
            if (!leftChildIsLeaf) {
                this.queue.offer(new TreeNode(treeId, left));
            } else {
                LOG.info("String_Node_Str", leftIndex, treeId);
            }
            boolean rightChildIsLeaf = Node.indexToLevel(doneNode.getId()) + 1 == this.maxDepth || Double.compare(maxGainInfo.getRightImpurity(), 0d) == 0;
            int rightIndex = Node.rightIndex(doneNode.getId());
            Node right = new Node(rightIndex, maxGainInfo.getRightPredict(), maxGainInfo.getRightImpurity(), true);
            doneNode.setRight(right);
            if (!rightChildIsLeaf) {
                this.queue.offer(new TreeNode(treeId, right));
            } else {
                LOG.info("String_Node_Str", rightIndex, treeId);
            }
        } else {
            LOG.info("String_Node_Str", doneNode.getId(), treeId);
        }
    }
    Map<Integer, TreeNode> todoNodes = new HashMap<Integer, TreeNode>();
    DTMasterParams masterParams = new DTMasterParams(trainCount, trainError, validationCount, validationError);
    if (queue.isEmpty()) {
        if (this.isGBDT) {
            Node treeNode = this.trees.get(this.trees.size() - 1).getNode();
            if (this.trees.size() == this.treeNum + this.existingTreeSize) {
                masterParams.setHalt(true);
                LOG.info("String_Node_Str", context.getCurrentIteration());
            } else if (treeNode.getLeft() == null && treeNode.getRight() == null) {
                masterParams.setHalt(true);
                LOG.warn("String_Node_Str", context.getCurrentIteration());
            } else {
                TreeNode newRootNode = new TreeNode(this.trees.size(), new Node(Node.ROOT_INDEX));
                LOG.info("String_Node_Str", this.trees.size());
                this.trees.add(newRootNode);
                newRootNode.setFeatures(getSubsamplingFeatures(this.featureSubsetStrategy));
                todoNodes.put(0, newRootNode);
                masterParams.setTodoNodes(todoNodes);
                masterParams.setSwitchToNextTree(true);
            }
        } else {
            masterParams.setHalt(true);
            LOG.info("String_Node_Str", context.getCurrentIteration());
        }
    } else {
        int nodeIndexInGroup = 0;
        long currMem = 0L;
        List<Integer> depthList = new ArrayList<Integer>();
        for (int i = 0; i < this.trees.size(); i++) {
            depthList.add(-1);
        }
        while (!queue.isEmpty() && currMem <= this.maxStatsMemory) {
            TreeNode node = this.queue.poll();
            int treeId = node.getTreeId();
            int oldDepth = depthList.get(treeId);
            int currDepth = Node.indexToLevel(node.getNode().getId());
            if (currDepth > oldDepth) {
                depthList.set(treeId, currDepth);
            }
            List<Integer> subsetFeatures = getSubsamplingFeatures(featureSubsetStrategy);
            node.setFeatures(subsetFeatures);
            currMem += getStatsMem(subsetFeatures);
            todoNodes.put(nodeIndexInGroup, node);
            nodeIndexInGroup += 1;
        }
        masterParams.setTreeDepth(depthList);
        masterParams.setTodoNodes(todoNodes);
        masterParams.setSwitchToNextTree(false);
        LOG.info("String_Node_Str", todoNodes.size());
    }
    masterParams.setTrees(trees);
    return masterParams;
}

Output:
     double trainError = 0d, validationError = 0d;
-    long trainCount = 0L, validationCount = 0L;
+    double weightedTrainCount = 0d, weightedValidationCount = 0d;
     for (DTWorkerParams params : context.getWorkerResults()) {


Input:
public void boundaryTypeWrongRectValueTest() {
    given().param("String_Node_Str", "String_Node_Str").param("String_Node_Str", "String_Node_Str").param("String_Node_Str", "String_Node_Str").param("String_Node_Str", "String_Node_Str").when().get(getEndPointName()).then().assertThat().body("String_Node_Str", is(102)).statusCode(400);
}

Output:
 public void boundaryTypeWrongRectValueTest() {
-    given().param("String_Node_Str", "String_Node_Str").param("String_Node_Str", "String_Node_Str").param("String_Node_Str", "String_Node_Str").param("String_Node_Str", "String_Node_Str").when().get(getEndPointName()).then().assertThat().body("String_Node_Str", is(102)).statusCode(400);
+    given().param("String_Node_Str", "String_Node_Str").param("String_Node_Str", "String_Node_Str").param("String_Node_Str", "String_Node_Str").param("String_Node_Str", "String_Node_Str").when().get(getEndPointName()).then().assertThat().body("String_Node_Str", is(GeocodingErrorCodes.INVALID_PARAMETER_FORMAT)).statusCode(400);
 }


Input:
protected TypeLookupResult findTypeForNameWithKnownObjectExpression(String name, ClassNode type, ClassNode declaringType, VariableScope scope, TypeConfidence confidence, boolean isStaticObjectExpression, boolean isPrimaryExpression, boolean isLhsExpression) {
    TypeConfidence confidence0 = confidence;
    boolean isFieldAccessDirect = (isThisObjectExpression(scope) ? scope.isFieldAccessDirect() : false);
    ASTNode declaration = findDeclaration(name, declaringType, isLhsExpression, isStaticObjectExpression, isFieldAccessDirect, scope.getMethodCallArgumentTypes());
    ClassNode realDeclaringType;
    VariableInfo variableInfo;
    if (declaration != null) {
        type = getTypeFromDeclaration(declaration, declaringType);
        realDeclaringType = getDeclaringTypeFromDeclaration(declaration, declaringType);
    } else if ("String_Node_Str".equals(name)) {
        declaration = type = realDeclaringType = declaringType.getGenericsTypes()[0].getType();
    } else if (isPrimaryExpression && (variableInfo = scope.lookupName(name)) != null) {
        type = variableInfo.type;
        realDeclaringType = variableInfo.declaringType;
        declaration = findDeclaration(name, realDeclaringType, isLhsExpression, isStaticObjectExpression, false, scope.getMethodCallArgumentTypes());
        if (declaration == null) {
            declaration = variableInfo.declaringType;
        }
    } else if ("String_Node_Str".equals(name)) {
        realDeclaringType = VariableScope.CLOSURE_CLASS_NODE;
        declaration = realDeclaringType.getMethods("String_Node_Str").get(0);
    } else {
        realDeclaringType = declaringType;
        confidence = TypeConfidence.UNKNOWN;
    }
    if (declaration != null && !VariableScope.CLASS_CLASS_NODE.equals(realDeclaringType) && !VariableScope.CLASS_CLASS_NODE.equals(type)) {
        if (declaration instanceof FieldNode) {
            if (isStaticObjectExpression && !((FieldNode) declaration).isStatic()) {
                confidence = TypeConfidence.UNKNOWN;
            }
        } else if (declaration instanceof PropertyNode) {
            FieldNode underlyingField = ((PropertyNode) declaration).getField();
            if (underlyingField != null) {
                if (isStaticObjectExpression && !underlyingField.isStatic()) {
                    confidence = TypeConfidence.UNKNOWN;
                }
            } else if (isStaticObjectExpression && !((PropertyNode) declaration).isStatic()) {
                confidence = TypeConfidence.UNKNOWN;
            }
        } else if (declaration instanceof MethodNode) {
            if (isStaticObjectExpression && !((MethodNode) declaration).isStatic()) {
                confidence = TypeConfidence.UNKNOWN;
            } else {
                if (((MethodNode) declaration).getParameters().length != scope.getMethodCallNumberOfArguments()) {
                    confidence = TypeConfidence.LOOSELY_INFERRED;
                }
            }
        }
    }
    if (TypeConfidence.UNKNOWN.equals(confidence) && VariableScope.CLASS_CLASS_NODE.equals(realDeclaringType)) {
        ClassNode typeParam = realDeclaringType.getGenericsTypes()[0].getType();
        if (!VariableScope.CLASS_CLASS_NODE.equals(typeParam) && !VariableScope.OBJECT_CLASS_NODE.equals(typeParam)) {
            return findTypeForNameWithKnownObjectExpression(name, type, typeParam, scope, confidence0, isStaticObjectExpression, isPrimaryExpression, isLhsExpression);
        }
    }
    return new TypeLookupResult(type, realDeclaringType, declaration, confidence, scope);
}

Output:
                 confidence = TypeConfidence.UNKNOWN;
-            } else {
-                if (((MethodNode) declaration).getParameters().length != scope.getMethodCallNumberOfArguments()) {
-                    confidence = TypeConfidence.LOOSELY_INFERRED;
-                }
+            } else if (isLooseMatch(scope.getMethodCallArgumentTypes(), ((MethodNode) declaration).getParameters())) {
+                confidence = TypeConfidence.LOOSELY_INFERRED;
             }


Input:
private final void bringDownServiceLocked(ServiceRecord r, boolean force) {
    if (!force && r.startRequested) {
        return;
    }
    if (r.connections.size() > 0) {
        if (!force) {
            Iterator<ConnectionRecord> it = r.connections.values().iterator();
            while (it.hasNext()) {
                ConnectionRecord cr = it.next();
                if ((cr.flags & Context.BIND_AUTO_CREATE) != 0) {
                    return;
                }
            }
        }
        Iterator<ConnectionRecord> it = r.connections.values().iterator();
        while (it.hasNext()) {
            ConnectionRecord c = it.next();
            try {
                c.conn.connected(r.name, null);
            } catch (Exception e) {
                Slog.w(TAG, "String_Node_Str" + r.name + "String_Node_Str" + c.conn.asBinder() + "String_Node_Str" + c.binding.client.processName + "String_Node_Str", e);
            }
        }
    }
    if (r.bindings.size() > 0 && r.app != null && r.app.thread != null) {
        Iterator<IntentBindRecord> it = r.bindings.values().iterator();
        while (it.hasNext()) {
            IntentBindRecord ibr = it.next();
            if (DEBUG_SERVICE)
                Slog.v(TAG, "String_Node_Str" + ibr + "String_Node_Str" + ibr.hasBound);
            if (r.app != null && r.app.thread != null && ibr.hasBound) {
                try {
                    bumpServiceExecutingLocked(r);
                    updateOomAdjLocked(r.app);
                    ibr.hasBound = false;
                    r.app.thread.scheduleUnbindService(r, ibr.intent.getIntent());
                } catch (Exception e) {
                    Slog.w(TAG, "String_Node_Str" + r.shortName, e);
                    serviceDoneExecutingLocked(r, true);
                }
            }
        }
    }
    if (DEBUG_SERVICE)
        Slog.v(TAG, "String_Node_Str" + r.name + "String_Node_Str" + r.intent);
    EventLog.writeEvent(EventLogTags.AM_DESTROY_SERVICE, System.identityHashCode(r), r.shortName, (r.app != null) ? r.app.pid : -1);
    mServices.remove(r.name);
    mServicesByIntent.remove(r.intent);
    if (localLOGV)
        Slog.v(TAG, "String_Node_Str" + r.shortName);
    r.totalRestartCount = 0;
    unscheduleServiceRestartLocked(r);
    int N = mPendingServices.size();
    for (int i = 0; i < N; i++) {
        if (mPendingServices.get(i) == r) {
            mPendingServices.remove(i);
            if (DEBUG_SERVICE)
                Slog.v(TAG, "String_Node_Str" + r.shortName);
            i--;
            N--;
        }
    }
    r.cancelNotification();
    r.isForeground = false;
    r.foregroundId = 0;
    r.foregroundNoti = null;
    r.deliveredStarts.clear();
    r.pendingStarts.clear();
    if (r.app != null) {
        synchronized (r.stats.getBatteryStats()) {
            r.stats.stopLaunchedLocked();
        }
        r.app.services.remove(r);
        if (r.app.thread != null) {
            try {
                if (DEBUG_SERVICE)
                    Slog.v(TAG, "String_Node_Str" + r.shortName);
                bumpServiceExecutingLocked(r);
                mStoppingServices.add(r);
                updateOomAdjLocked(r.app);
                r.app.thread.scheduleStopService(r);
            } catch (Exception e) {
                Slog.w(TAG, "String_Node_Str" + r.shortName, e);
                serviceDoneExecutingLocked(r, true);
            }
            updateServiceForegroundLocked(r.app, false);
        } else {
            if (DEBUG_SERVICE)
                Slog.v(TAG, "String_Node_Str" + r.shortName);
        }
    } else {
        if (DEBUG_SERVICE)
            Slog.v(TAG, "String_Node_Str" + r.shortName);
    }
}

Output:
     r.foregroundNoti = null;
-    r.deliveredStarts.clear();
+    r.clearDeliveredStartsLocked();
     r.pendingStarts.clear();


Input:
protected void ungroupPrimitive(PrimitiveRenderEvent pre, boolean drawText) {
    if (_iun == null) {
        logger.log(ILogger.WARNING, Messages.getString("String_Node_Str", getULocale()));
        return;
    }
    if (pre.getSource() instanceof StructureSource) {
        final Series series = (Series) getElementFromSource((StructureSource) pre.getSource(), StructureType.SERIES);
        if (series != null) {
            if (drawText) {
                svg_g2d.popParent();
                svg_g2d.popParent();
            } else {
                svg_g2d.setDeferStrokColor(null);
                svg_g2d.popParent();
            }
        }
    }
}

Output:
     if (pre.getSource() instanceof StructureSource) {
-        final Series series = (Series) getElementFromSource((StructureSource) pre.getSource(), StructureType.SERIES);
+        StructureSource sourceObject = (StructureSource) pre.getSource();
+        final Series series = (Series) getElementFromSource(sourceObject, StructureType.SERIES);
         if (series != null) {


Input:
public void applyAndPropagateAnalyzer(XPathAnalyzer analyzer) throws AnalysisInvalidException {
    if (analyzer.shortCircuit()) {
        return;
    }
    analyzer.doAnalysis(TreeReference.this);
    if (this.hasPredicates()) {
        TreeReference contextForPredicates = this;
        if (this.contextType == CONTEXT_ORIGINAL) {
            if (analyzer.getOriginalContextRef() == null) {
                throw AnalysisInvalidException.INSTANCE;
            }
            contextForPredicates = this.contextualize(analyzer.getOriginalContextRef());
        } else if (!this.isAbsolute()) {
            if (analyzer.getContextRef() == null) {
                throw AnalysisInvalidException.INSTANCE;
            }
            contextForPredicates = this.contextualize(analyzer.getContextRef());
        }
        for (int i = 0; i < data.size(); i++) {
            TreeReferenceLevel subLevel = data.get(i);
            if (subLevel.getPredicates() != null) {
                TreeReference subContext = contextForPredicates.removePredicates().getSubReference(i);
                XPathAnalyzer subAnalyzer = analyzer.spawnSubAnalyzer(subContext);
                for (XPathExpression expr : subLevel.getPredicates()) {
                    expr.applyAndPropagateAnalyzer(subAnalyzer);
                }
            }
        }
    }
}

Output:
     analyzer.doAnalysis(TreeReference.this);
-    if (this.hasPredicates()) {
+    if (analyzer.shouldIncludePredicates() && this.hasPredicates()) {
         TreeReference contextForPredicates = this;


Input:
public int getTextureCoordSetIdx() {
    return textureSetIdx;
}

Output:
 public int getTextureCoordSetIdx() {
-    return textureSetIdx;
+    return 0;
 }


Input:
static void activateBeanValidation(Set<BapiInterceptor> bapiInterceptors, SessionManagerConfig sessionManagerConfig) {
    try {
        ValidatorFactory factory = validatorFactoryFactory.buildValidatorFactory();
        bapiInterceptors.add(new BeanValidationInterceptor(factory));
    } catch (ValidationException e) {
        if (sessionManagerConfig.getValidationMode() == ValidationMode.AUTO) {
            LOGGER.warn("String_Node_Str" + "String_Node_Str" + "String_Node_Str", e);
        } else {
            throw new HibersapException("String_Node_Str", e);
        }
    }
}

Output:
     } catch (ValidationException e) {
-        if (sessionManagerConfig.getValidationMode() == ValidationMode.AUTO) {
+        ValidationMode validationMode = sessionManagerConfig.getValidationMode();
+        if (validationMode == ValidationMode.AUTO) {
             LOGGER.warn("String_Node_Str" + "String_Node_Str" + "String_Node_Str", e);


Input:
private void registerOutputParameter() throws OdaException {
    if (parameterDefn != null) {
        for (int i = 0; i < parameterDefn.getParameterCount(); i++) {
            if (parameterDefn.getParameterMode(i) == IParameterMetaData.parameterModeOut || parameterDefn.getParameterMode(i) == IParameterMetaData.parameterModeInOut) {
                registerOutParameter(i + 1, parameterDefn.getParameterType(i));
            }
        }
    }
}

Output:
             if (parameterDefn.getParameterMode(i) == IParameterMetaData.parameterModeOut || parameterDefn.getParameterMode(i) == IParameterMetaData.parameterModeInOut) {
-                registerOutParameter(i + 1, parameterDefn.getParameterType(i));
+                registerOutParameter(i + 1, getParameterType(i));
             }


Input:
private ExpressionNode parseExpression(FHIRLexer lexer, boolean proximal) throws FHIRLexerException {
    ExpressionNode result = new ExpressionNode(lexer.nextId());
    SourceLocation c = lexer.getCurrentStartLocation();
    result.setStart(lexer.getCurrentLocation());
    if (lexer.getCurrent().equals("String_Node_Str")) {
        lexer.take();
        lexer.setCurrent("String_Node_Str" + lexer.getCurrent());
    }
    if (lexer.getCurrent().equals("String_Node_Str")) {
        lexer.take();
        lexer.setCurrent("String_Node_Str" + lexer.getCurrent());
    }
    if (lexer.isConstant(false)) {
        checkConstant(lexer.getCurrent(), lexer);
        result.setConstant(lexer.take());
        result.setKind(Kind.Constant);
        result.setEnd(lexer.getCurrentLocation());
    } else if ("String_Node_Str".equals(lexer.getCurrent())) {
        lexer.next();
        result.setKind(Kind.Group);
        result.setGroup(parseExpression(lexer, true));
        if (!"String_Node_Str".equals(lexer.getCurrent()))
            throw lexer.error("String_Node_Str" + lexer.getCurrent() + "String_Node_Str");
        result.setEnd(lexer.getCurrentLocation());
        lexer.next();
    } else {
        if (!lexer.isToken() && !lexer.getCurrent().startsWith("String_Node_Str"))
            throw lexer.error("String_Node_Str" + lexer.getCurrent() + "String_Node_Str");
        if (lexer.getCurrent().startsWith("String_Node_Str"))
            result.setName(lexer.readConstant("String_Node_Str"));
        else
            result.setName(lexer.take());
        result.setEnd(lexer.getCurrentLocation());
        if (!result.checkName())
            throw lexer.error("String_Node_Str" + result.getName() + "String_Node_Str");
        if ("String_Node_Str".equals(lexer.getCurrent())) {
            Function f = Function.fromCode(result.getName());
            FunctionDetails details = null;
            if (f == null) {
                details = hostServices.resolveFunction(result.getName());
                if (details == null)
                    throw lexer.error("String_Node_Str" + result.getName() + "String_Node_Str");
                f = Function.Custom;
            }
            result.setKind(Kind.Function);
            result.setFunction(f);
            lexer.next();
            while (!"String_Node_Str".equals(lexer.getCurrent())) {
                result.getParameters().add(parseExpression(lexer, true));
                if ("String_Node_Str".equals(lexer.getCurrent()))
                    lexer.next();
                else if (!"String_Node_Str".equals(lexer.getCurrent()))
                    throw lexer.error("String_Node_Str" + lexer.getCurrent() + "String_Node_Str");
            }
            result.setEnd(lexer.getCurrentLocation());
            lexer.next();
            checkParameters(lexer, c, result, details);
        } else
            result.setKind(Kind.Name);
    }
    ExpressionNode focus = result;
    if ("String_Node_Str".equals(lexer.getCurrent())) {
        lexer.next();
        ExpressionNode item = new ExpressionNode(lexer.nextId());
        item.setKind(Kind.Function);
        item.setFunction(ExpressionNode.Function.Item);
        item.getParameters().add(parseExpression(lexer, true));
        if (!lexer.getCurrent().equals("String_Node_Str"))
            throw lexer.error("String_Node_Str" + lexer.getCurrent() + "String_Node_Str");
        lexer.next();
        result.setInner(item);
        focus = item;
    }
    if ("String_Node_Str".equals(lexer.getCurrent())) {
        lexer.next();
        focus.setInner(parseExpression(lexer, false));
    }
    result.setProximal(proximal);
    if (proximal) {
        while (lexer.isOp()) {
            focus.setOperation(ExpressionNode.Operation.fromCode(lexer.getCurrent()));
            focus.setOpStart(lexer.getCurrentStartLocation());
            focus.setOpEnd(lexer.getCurrentLocation());
            lexer.next();
            focus.setOpNext(parseExpression(lexer, false));
            focus = focus.getOpNext();
        }
        result = organisePrecedence(lexer, result);
    }
    return result;
}

Output:
             if (f == null) {
-                details = hostServices.resolveFunction(result.getName());
+                details = hostServices != null ? hostServices.resolveFunction(result.getName()) : null;
                 if (details == null)


Input:
boolean isStruct() {
    return (mask & STRUCT_MASK) != 0;
}

Output:
 boolean isStruct() {
-    return (mask & STRUCT_MASK) != 0;
+    return (this.mask & STRUCT_MASK) != 0;
 }


Input:
private static int minutesSinceLastUpdate(String tagName) {
    if (TextUtils.isEmpty(tagName))
        return 0;
    String updated = getTagLastUpdated(tagName);
    if (TextUtils.isEmpty(updated))
        return NEVER_UPDATED;
    Date dtUpdated = DateTimeUtils.iso8601ToJavaDate(updated);
    if (dtUpdated == null)
        return 0;
    Date dtNow = new Date();
    return DateTimeUtils.minutesBetween(dtUpdated, dtNow);
}

Output:
 private static int minutesSinceLastUpdate(String tagName) {
-    if (TextUtils.isEmpty(tagName))
+    if (TextUtils.isEmpty(tagName)) {
         return 0;


Input:
public void onRedditDataChange(final String thingIdAndType) {
    mListener.onCommentChanged(this);
}

Output:
 public void onRedditDataChange(final String thingIdAndType) {
-    mListener.onCommentChanged(this);
+    HANDLER.dispatchMessage(Message.obtain(HANDLER, HANDLER_REQUEST_COMMENT_CHANGED, this));
 }


Input:
public PlanSummary process(ArrayList<Chargeable> data) {
    PlanSummary ret = new PlanSummary(this);
    double globalPrice = 0;
    for (Chargeable chargeable : data) {
        if (chargeable.getChargeableType() == Chargeable.CHARGEABLE_TYPE_CALL) {
            Call call = (Call) chargeable;
            if (call.getType() != Call.CALL_TYPE_SENT) {
                continue;
            }
            double callPrice = 0;
            if (call.getContact().getMsisdnType() == MsisdnType.ES_SPECIAL_ZER0) {
                callPrice = 0;
            } else {
                callPrice = initialPrice + (call.getDuration() * pricePerSecond);
            }
            globalPrice += callPrice;
            ret.addPlanCall(new PlanChargeable(call, callPrice, this.getCurrency()));
        } else if (chargeable.getChargeableType() == Chargeable.CHARGEABLE_TYPE_SMS) {
            Sms sms = (Sms) chargeable;
            if (sms.getType() == Sms.SMS_TYPE_RECEIVED) {
                continue;
            }
            globalPrice += smsPrice;
            ret.addPlanCall(new PlanChargeable(chargeable, smsPrice, this.getCurrency()));
        }
    }
    if (globalPrice < minimumMonthFee) {
        ret.addPlanCall(new PlanChargeable(new ChargeableMessage(ChargeableMessage.MESSAGE_MONTH_FEE), minimumMonthFee - globalPrice, this.getCurrency()));
    }
    return ret;
}

Output:
     if (globalPrice < minimumMonthFee) {
-        ret.addPlanCall(new PlanChargeable(new ChargeableMessage(ChargeableMessage.MESSAGE_MONTH_FEE), minimumMonthFee - globalPrice, this.getCurrency()));
+        ret.addPlanCall(new PlanChargeable(new ChargeableMessage(ChargeableMessage.MESSAGE_MINIMUM_MONTH_FEE), minimumMonthFee - globalPrice, this.getCurrency()));
     }


Input:
public final int runWithoutHelp(CommandRunnerParams params) throws IOException, InterruptedException {
    Preconditions.checkNotNull(binary, BINARY_OPTION + "String_Node_Str");
    Preconditions.checkNotNull(output, OUTPUT_OPTION + "String_Node_Str");
    Preconditions.checkNotNull(oldCompDir, OLD_COMPDIR_OPTION + "String_Node_Str");
    Preconditions.checkNotNull(updatedCompDir, NEW_COMPDIR_OPTION + "String_Node_Str");
    Preconditions.checkNotNull(!binary.equals(output), BINARY_OPTION + "String_Node_Str" + OUTPUT_OPTION);
    Preconditions.checkArgument(oldCompDir.length() >= updatedCompDir.length(), "String_Node_Str" + "String_Node_Str");
    Preconditions.checkArgument(!oldCompDir.equals(updatedCompDir), "String_Node_Str");
    Files.copy(binary, output, StandardCopyOption.REPLACE_EXISTING);
    return invokeWithParams(params);
}

Output:
     Preconditions.checkNotNull(updatedCompDir, NEW_COMPDIR_OPTION + "String_Node_Str");
-    Preconditions.checkNotNull(!binary.equals(output), BINARY_OPTION + "String_Node_Str" + OUTPUT_OPTION);
+    Preconditions.checkState(!binary.equals(output), BINARY_OPTION + "String_Node_Str" + OUTPUT_OPTION);
     Preconditions.checkArgument(oldCompDir.length() >= updatedCompDir.length(), "String_Node_Str" + "String_Node_Str");