Input:
private void createNewLineWithJavaUDI() {
    EList<TaggedValue> tvs = definition.getTaggedValue();
    String classNameStr = null;
    String jarPathStr = "String_Node_Str";
    for (TaggedValue tv : tvs) {
        if (tv.getTag().equals(PluginConstant.CLASS_NAME_TEXT)) {
            classNameStr = tv.getValue();
            continue;
        }
        if (tv.getTag().equals(PluginConstant.JAR_FILE_PATH)) {
            jarPathStr = tv.getValue();
        }
    }
    if (classNameStr == null) {
        return;
    }
    final Composite lineComp = new Composite(expressionComp, SWT.NONE);
    lineComp.setLayout(new GridLayout(2, false));
    final CCombo combo = new CCombo(lineComp, SWT.BORDER);
    combo.setLayoutData(new GridData());
    ((GridData) combo.getLayoutData()).widthHint = 150;
    combo.setEditable(false);
    combo.setItems(remainDBTypeList.toArray(new String[remainDBTypeList.size()]));
    combo.setText(PatternLanguageType.JAVA.getName());
    combo.addSelectionListener(new LangCombSelectionListener());
    tempExpressionMap.put(combo, BooleanExpressionHelper.createExpression(combo.getText(), null));
    Composite detailComp = new Composite(combo.getParent(), SWT.NONE);
    widgetMap.put(combo, detailComp);
    detailComp.setLayout(new GridLayout(4, false));
    Text classNameText = new Text(detailComp, SWT.BORDER);
    classNameText.setLayoutData(new GridData(GridData.FILL_BOTH));
    ((GridData) classNameText.getLayoutData()).widthHint = 250;
    classNameText.setText(classNameStr);
    classNameText.addModifyListener(new NeedToSetDirtyListener());
    final Text jarPathText = new Text(detailComp, SWT.BORDER);
    jarPathText.setLayoutData(new GridData(GridData.FILL_BOTH));
    ((GridData) jarPathText.getLayoutData()).widthHint = 350;
    jarPathText.setText(jarPathStr);
    jarPathText.addModifyListener(new NeedToSetDirtyListener());
    Button button = new Button(detailComp, SWT.PUSH);
    button.setText("String_Node_Str");
    button.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent e) {
            FileDialog dialog = new FileDialog(combo.getParent().getShell(), SWT.NONE);
            dialog.setFilterExtensions(new String[] { "String_Node_Str" });
            String path = dialog.open();
            if (path != null) {
                jarPathText.setText(path);
            }
        }
    });
    combo.setData(PluginConstant.CLASS_NAME_TEXT, classNameText);
    combo.setData(PluginConstant.JAR_FILE_PATH, jarPathText);
    createExpressionDelButton(detailComp, combo);
    GridDataFactory.fillDefaults().align(SWT.FILL, SWT.FILL).grab(true, false).applyTo(detailComp);
}

Output:
     combo.setEditable(false);
-    combo.setItems(remainDBTypeList.toArray(new String[remainDBTypeList.size()]));
+    combo.setItems(allDBTypeList.toArray(new String[allDBTypeList.size()]));
     combo.setText(PatternLanguageType.JAVA.getName());


Input:
public Structure clone() {
    Structure n = new StructureImpl();
    n.setPDBCode(getPDBCode());
    n.setName(getName());
    n.setPDBHeader(pdbHeader);
    n.setDBRefs(this.getDBRefs());
    n.setConnections(getConnections());
    n.setSites(getSites());
    for (int i = 0; i < nrModels(); i++) {
        List<Chain> cloned_model = new ArrayList<Chain>();
        for (int j = 0; j < size(i); j++) {
            Chain cloned_chain = (Chain) getChain(i, j).clone();
            cloned_chain.setParent(n);
            cloned_model.add(cloned_chain);
        }
        n.addModel(cloned_model);
    }
    List<Compound> newCompoundList = new ArrayList<Compound>();
    for (Compound compound : this.compounds) {
        Compound newCompound = new Compound(compound);
        for (String chainId : compound.getChainIds()) {
            try {
                for (int modelNr = 0; modelNr < n.nrModels(); modelNr++) {
                    Chain newChain = n.getChainByPDB(chainId, modelNr);
                    newChain.setCompound(newCompound);
                    newCompound.addChain(newChain);
                }
            } catch (StructureException e) {
                logger.error("String_Node_Str", e);
            }
        }
        newCompoundList.add(newCompound);
    }
    n.setCompounds(newCompoundList);
    for (SSBond ssbond : ssbonds) {
        n.addSSBond(ssbond.clone());
    }
    return n;
}

Output:
         for (String chainId : compound.getChainIds()) {
-            try {
-                for (int modelNr = 0; modelNr < n.nrModels(); modelNr++) {
+            for (int modelNr = 0; modelNr < n.nrModels(); modelNr++) {
+                try {
                     Chain newChain = n.getChainByPDB(chainId, modelNr);


Input:
private Set<ProjectModel> addProjects(Set<ProjectModel> existingVertices, ProjectModelTraversal traversal) {
    existingVertices.add(traversal.getCanonicalProject());
    for (ProjectModelTraversal child : traversal.getChildren()) addProjects(existingVertices, child);
    return existingVertices;
}

Output:
 private Set<ProjectModel> addProjects(Set<ProjectModel> existingVertices, ProjectModelTraversal traversal) {
-    existingVertices.add(traversal.getCanonicalProject());
-    for (ProjectModelTraversal child : traversal.getChildren()) addProjects(existingVertices, child);
+    TraversalState nodeTraversalState = traversal.getTraversalState();
+    if (nodeTraversalState == TraversalState.ALL)
+        existingVertices.add(traversal.getCanonicalProject());
+    if (nodeTraversalState != TraversalState.NONE) {
+        for (ProjectModelTraversal child : traversal.getChildren()) addProjects(existingVertices, child);
+    }
     return existingVertices;


Input:
public void setEnvironment() throws Exception {
    super.init(userMode);
    publisherURLHttp = getPublisherURLHttp();
    storeURLHttp = getStoreURLHttp();
    endpointUrl = backEndServerUrl.getWebAppURLHttp() + "String_Node_Str";
    apiStore = new APIStoreRestClient(storeURLHttp);
    apiPublisher = new APIPublisherRestClient(publisherURLHttp);
    apiPublisher.login(user.getUserName(), user.getPassword());
    userManagementClient = new UserManagementClient(publisherContext.getContextUrls().getBackEndUrl(), createSession(publisherContext));
    userManagementClient.addRole(role, null, permissions);
    userManagementClient.addUser(allowedUser, String.valueOf(allowedUserPass), new String[] { role }, null);
    tagListUrl = new URL(getStoreURLHttp() + "String_Node_Str");
}

Output:
     apiPublisher.login(user.getUserName(), user.getPassword());
-    userManagementClient = new UserManagementClient(publisherContext.getContextUrls().getBackEndUrl(), createSession(publisherContext));
-    userManagementClient.addRole(role, null, permissions);
-    userManagementClient.addUser(allowedUser, String.valueOf(allowedUserPass), new String[] { role }, null);
+    userManagementClient1 = new UserManagementClient(keyManagerContext.getContextUrls().getBackEndUrl(), createSession(keyManagerContext));
+    userManagementClient1.addRole(role, null, permissions);
+    userManagementClient1.addUser(allowedUser, String.valueOf(allowedUserPass), new String[] { role }, null);
     tagListUrl = new URL(getStoreURLHttp() + "String_Node_Str");


Input:
public synchronized boolean equals(java.lang.Object obj) {
    if (!(obj instanceof Contact))
        return false;
    Contact other = (Contact) obj;
    if (obj == null)
        return false;
    if (this == obj)
        return true;
    if (__equalsCalc != null) {
        return (__equalsCalc == obj);
    }
    __equalsCalc = obj;
    boolean _equals;
    _equals = true && this.businessPartnerId == other.getBusinessPartnerId() && this.clientId == other.getClientId() && ((this.email == null && other.getEmail() == null) || (this.email != null && this.email.equals(other.getEmail()))) && ((this.fax == null && other.getFax() == null) || (this.fax != null && this.fax.equals(other.getFax()))) && ((this.firstName == null && other.getFirstName() == null) || (this.firstName != null && this.firstName.equals(other.getFirstName()))) && this.id == other.getId() && ((this.lastName == null && other.getLastName() == null) || (this.lastName != null && this.lastName.equals(other.getLastName()))) && ((this.phone == null && other.getPhone() == null) || (this.phone != null && this.phone.equals(other.getPhone()))) && ((this.phone2 == null && other.getPhone2() == null) || (this.phone2 != null && this.phone2.equals(other.getPhone2())));
    __equalsCalc = null;
    return _equals;
}

Output:
     boolean _equals;
-    _equals = true && this.businessPartnerId == other.getBusinessPartnerId() && this.clientId == other.getClientId() && ((this.email == null && other.getEmail() == null) || (this.email != null && this.email.equals(other.getEmail()))) && ((this.fax == null && other.getFax() == null) || (this.fax != null && this.fax.equals(other.getFax()))) && ((this.firstName == null && other.getFirstName() == null) || (this.firstName != null && this.firstName.equals(other.getFirstName()))) && this.id == other.getId() && ((this.lastName == null && other.getLastName() == null) || (this.lastName != null && this.lastName.equals(other.getLastName()))) && ((this.phone == null && other.getPhone() == null) || (this.phone != null && this.phone.equals(other.getPhone()))) && ((this.phone2 == null && other.getPhone2() == null) || (this.phone2 != null && this.phone2.equals(other.getPhone2())));
+    _equals = true && ((this.businessPartnerId == null && other.getBusinessPartnerId() == null) || (this.businessPartnerId != null && this.businessPartnerId.equals(other.getBusinessPartnerId()))) && ((this.clientId == null && other.getClientId() == null) || (this.clientId != null && this.clientId.equals(other.getClientId()))) && ((this.email == null && other.getEmail() == null) || (this.email != null && this.email.equals(other.getEmail()))) && ((this.fax == null && other.getFax() == null) || (this.fax != null && this.fax.equals(other.getFax()))) && ((this.firstName == null && other.getFirstName() == null) || (this.firstName != null && this.firstName.equals(other.getFirstName()))) && ((this.id == null && other.getId() == null) || (this.id != null && this.id.equals(other.getId()))) && ((this.lastName == null && other.getLastName() == null) || (this.lastName != null && this.lastName.equals(other.getLastName()))) && ((this.phone == null && other.getPhone() == null) || (this.phone != null && this.phone.equals(other.getPhone()))) && ((this.phone2 == null && other.getPhone2() == null) || (this.phone2 != null && this.phone2.equals(other.getPhone2())));
     __equalsCalc = null;


Input:
public void preDeregister() throws Exception {
    super.preDeregister();
    managedObject.removeMessageListener(registrationId);
}

Output:
     super.preDeregister();
-    managedObject.removeMessageListener(registrationId);
+    try {
+        managedObject.removeMessageListener(registrationId);
+    } catch (Exception ignored) {
+    }
 }


Input:
private void notifyChildRemoved(StructuralEvent event) {
    List<StructuralListener> copy = null;
    synchronized (missed) {
        copy = new ArrayList<StructuralListener>(listeners);
    }
    for (StructuralListener l : copy) {
        l.childRemoved(event);
    }
}

Output:
     for (StructuralListener l : copy) {
-        l.childRemoved(event);
+        new ChildRemoved(event).dispatch(l);
     }


Input:
private void skipTo(int absoluteIndex) throws IOException, DataException {
    if (currRowLenReadIndex == absoluteIndex)
        return;
    currRowLenReadIndex = absoluteIndex + 1;
    rowLenIs.seek(absoluteIndex * 4);
    rowExprsIs.seek(IOUtil.readInt(rowLenIs) + 4);
    rowExprsDis = new DataInputStream(rowExprsIs);
}

Output:
     rowLenIs.seek(absoluteIndex * 4);
-    rowExprsIs.seek(IOUtil.readInt(rowLenIs) + 4);
+    rowExprsIs.seek(IOUtil.readInt(rowLenIs) + this.metaOffset);
     rowExprsDis = new DataInputStream(rowExprsIs);


Input:
private List<TypeName> nestedTypeList(Type type, boolean includeKeyTypes, boolean valueType, boolean includeBaseType) {
    List<TypeName> typeList = new ArrayList<TypeName>();
    Type curr = type;
    do {
        TypeName reprType;
        if (valueType) {
            reprType = valRepresentationType(curr);
        } else {
            reprType = representationType(curr, false);
        }
        typeList.add(reprType);
        if (includeKeyTypes && Types.isArray(curr)) {
            typeList.add(representationType(Types.arrayKeyType(curr), false));
        }
        curr = Types.containerElemType(curr);
    } while (Types.isContainer(curr));
    if (includeBaseType) {
        TypeName reprType;
        if (valueType) {
            reprType = valRepresentationType(curr);
        } else {
            reprType = representationType(curr, false);
        }
        typeList.add(reprType);
    }
    return typeList;
}

Output:
         typeList.add(reprType);
-        if (includeKeyTypes && Types.isArray(curr)) {
+        if (includeKeyTypes && (Types.isArray(curr) || Types.isArrayLocal(curr))) {
             typeList.add(representationType(Types.arrayKeyType(curr), false));


Input:
public void witch$setAggressive(boolean aggressive) {
    this.setAggressive(aggressive);
}

Output:
 public void witch$setAggressive(boolean aggressive) {
-    this.setAggressive(aggressive);
+    this.getDataWatcher().updateObject(21, Byte.valueOf((byte) (aggressive ? 1 : 0)));
 }


Input:
private void findColumnIndex() throws DataException {
    if (parameterColNames == null) {
        return;
    }
    for (int i = 0; i < parameterColNames.length; i++) {
        parameterColIndexs[i][0] = -1;
        for (int j = 0; j < dimesionResultIterators.length; j++) {
            ILevel[] levels = dimesionResultIterators[j].getDimesion().getHierarchy().getLevels();
            for (int k = 0; k < levels.length; k++) {
                String[] columns = levels[k].getKeyNames();
                int index = find(columns, parameterColNames[i]);
                if (index >= 0) {
                    parameterColIndexs[i][0] = 0;
                    parameterColIndexs[i][1] = j;
                    parameterColIndexs[i][2] = k;
                    parameterColIndexs[i][3] = index;
                    break;
                }
                columns = levels[k].getAttributeNames();
                index = find(columns, parameterColNames[i]);
                if (index >= 0) {
                    parameterColIndexs[i][0] = 1;
                    parameterColIndexs[i][1] = j;
                    parameterColIndexs[i][2] = k;
                    parameterColIndexs[i][3] = index;
                    break;
                }
            }
            if (parameterColIndexs[i][0] != -1) {
                break;
            }
        }
        if (parameterColIndexs[i][0] == -1) {
            throw new DataException(ResourceConstants.PARAMETER_COL_OF_AGGREGATION_NOT_EXIST, parameterColNames[i]);
        }
    }
}

Output:
 private void findColumnIndex() throws DataException {
-    if (parameterColNames == null) {
+    if (paraColumns == null) {
         return;


Input:
public void testRun() throws IOException, SAXException {
    gui = HarvestDefinitionGUI.getInstance();
    WebConversation conv = new WebConversation();
    conv.setExceptionsThrownOnErrorStatus(false);
    WebResponse resp = conv.getResponse("String_Node_Str" + Integer.toString(TestInfo.GUI_WEB_SERVER_PORT) + "String_Node_Str" + TestInfo.GUI_WEB_SERVER_WEBBASE);
    assertTrue("String_Node_Str" + resp.getURL() + "String_Node_Str" + resp.getResponseCode(), resp.getResponseCode() == 200);
}

Output:
 public void testRun() throws IOException, SAXException {
-    gui = HarvestDefinitionGUI.getInstance();
+    gui = GUIWebServer.getInstance();
     WebConversation conv = new WebConversation();


Input:
private void considerAndRemoveCorner(List<Point2D_I32> contour, LinkedList.Element<Corner> target, double scoreCurrent) {
    LinkedList.Element<Corner> p = previous(target);
    LinkedList.Element<Corner> n = next(target);
    double sumSides = 0;
    LinkedList.Element<Corner> e = list.getHead();
    while (e != null) {
        sumSides += e.object.sideScore;
        e = e.next;
    }
    sumSides -= target.object.sideScore + p.object.sideScore;
    double scoreNewSide = scoreSide(contour, p.object.index, n.object.index);
    sumSides += scoreNewSide;
    double scoreNoCorner = sumSides / (list.size() - 1) + cornerScorePenalty * (list.size() - 1);
    if (scoreNoCorner < scoreCurrent) {
        list.remove(target);
        p.object.splitLocation = target.object.index;
        p.object.splitScore0 = target.object.sideScore;
        p.object.splitScore1 = n.object.sideScore;
        p.object.sideScore = scoreNewSide;
        savePolyline();
    }
}

Output:
     sumSides -= target.object.sideScore + p.object.sideScore;
-    double scoreNewSide = scoreSide(contour, p.object.index, n.object.index);
+    double scoreNewSide = computeSideError(contour, p.object.index, n.object.index);
     sumSides += scoreNewSide;


Input:
public HttpBuilder param(String name, String value, boolean urlEncoding) {
    String encodedValue = null;
    if (urlEncoding) {
        try {
            encodedValue = URLEncoder.encode(value, charset.name());
        } catch (UnsupportedEncodingException e) {
            Logger.error(e);
        }
    }
    if (encodedValue == null) {
        encodedValue = value;
    }
    NameValuePair nameValuePair = new BasicNameValuePair(name, encodedValue);
    this.nameValuePairs.add(nameValuePair);
    return this;
}

Output:
     String encodedValue = null;
-    if (urlEncoding) {
+    if (urlEncoding && value != null) {
         try {


Input:
protected void installDeploymentFactory(File installedDM) throws IOException {
    if (sLogger.isLoggable(Level.FINE)) {
        sLogger.fine("String_Node_Str" + installedDM.getAbsolutePath());
    }
    JarFile jarFile = null;
    Manifest m = null;
    try {
        jarFile = new JarFile(installedDM);
        m = jarFile.getManifest();
    } finally {
        jarFile.close();
        jarFile = null;
    }
    String className = m.getMainAttributes().getValue(J2EE_DEPLOYMENT_MANAGER);
    URL[] urls = new URL[] { installedDM.toURI().toURL() };
    URLClassLoader urlClassLoader = new java.net.URLClassLoader(urls, getClass().getClassLoader());
    Class factory = null;
    try {
        factory = urlClassLoader.loadClass(className);
    } catch (ClassNotFoundException cnfe) {
        sLogger.log(Level.SEVERE, "String_Node_Str", new Object[] { "String_Node_Str" });
        throw new IllegalArgumentException(className + "String_Node_Str" + installedDM.getName());
    }
    Object df = null;
    try {
        df = factory.newInstance();
    } catch (Exception ie) {
        sLogger.log(Level.SEVERE, "String_Node_Str", new Object[] { className });
        sLogger.log(Level.SEVERE, "String_Node_Str", ie);
        throw new IllegalArgumentException("String_Node_Str" + installedDM.getName());
    }
    if (df instanceof DeploymentFactory) {
        DeploymentFactoryManager.getInstance().registerDeploymentFactory((DeploymentFactory) df);
    } else {
        throw new IllegalArgumentException("String_Node_Str" + className + "String_Node_Str");
    }
}

Output:
     String className = m.getMainAttributes().getValue(J2EE_DEPLOYMENT_MANAGER);
-    URL[] urls = new URL[] { installedDM.toURI().toURL() };
-    URLClassLoader urlClassLoader = new java.net.URLClassLoader(urls, getClass().getClassLoader());
+    final URL[] urls = new URL[] { installedDM.toURI().toURL() };
+    URLClassLoader urlClassLoader;
+    urlClassLoader = AccessController.doPrivileged(new PrivilegedAction<URLClassLoader>() {
+        public URLClassLoader run() {
+            return new java.net.URLClassLoader(urls, getClass().getClassLoader());
+        }
+    });
     Class factory = null;


Input:
public boolean removeCache(String cacheName) {
    Cache oldCache;
    if (cacheName == null) {
        throw new NullPointerException("String_Node_Str");
    }
    synchronized (caches) {
        oldCache = caches.remove(cacheName);
    }
    if (oldCache != null) {
        oldCache.stop();
    }
    return oldCache != null;
}

Output:
 public boolean removeCache(String cacheName) {
-    Cache oldCache;
+    if (status != Status.STARTED) {
+        throw new IllegalStateException();
+    }
     if (cacheName == null) {


Input:
private int findExpression(List<Operator> ops, int offset, int length) {
    if (offset >= ops.size()) {
        throw new RuntimeException("String_Node_Str");
    }
    Operator op = ops.get(offset);
    if (op instanceof BinaryOperator) {
        throw new RuntimeException("String_Node_Str");
    } else if (op instanceof UnaryOperator) {
        return 1;
    } else if (op instanceof PrecedenceOperator) {
        PrecedenceOperator pop = (PrecedenceOperator) op;
        if (!pop.begin) {
            throw new RuntimeException("String_Node_Str");
        } else {
            int open = 1;
            for (int i = offset + 1; i < length; i++) {
                if (ops.get(i) instanceof PrecedenceOperator) {
                    pop = (PrecedenceOperator) ops.get(i);
                    if (pop.begin)
                        open++;
                    else
                        open--;
                    if (open == 0) {
                        return i - offset + 1;
                    }
                }
            }
            throw new RuntimeException("String_Node_Str" + open + "String_Node_Str" + length);
        }
    } else {
        throw new RuntimeException("String_Node_Str");
    }
}

Output:
             int open = 1;
-            for (int i = offset + 1; i < length; i++) {
+            for (int i = offset + 1; i < offset + length; i++) {
                 if (ops.get(i) instanceof PrecedenceOperator) {


Input:
private String addExtension(String path, MediaType mediaType) {
    String extension = mediaType.getSubtype();
    if (extension.contains("String_Node_Str")) {
        int index = extension.lastIndexOf("String_Node_Str");
        if (index > 0 && index + 1 < extension.length()) {
            extension = extension.substring(index + 1);
        }
    } else if (extension.contains("String_Node_Str")) {
        extension = Lib.getExtension(extension);
    }
    String toReturn = null;
    if (Strings.isValid(extension)) {
        StringBuilder builder = new StringBuilder(path);
        builder.append("String_Node_Str");
        builder.append(extension);
        toReturn = builder.toString();
    }
    return toReturn;
}

Output:
     String extension = mediaType.getSubtype();
-    if (extension.contains("String_Node_Str")) {
+    if ("String_Node_Str".equals(extension)) {
+        extension = "String_Node_Str";
+    } else if (extension.contains("String_Node_Str")) {
         int index = extension.lastIndexOf("String_Node_Str");


Input:
public org.hl7.fhir.dstu2.model.ImplementationGuide.ImplementationGuidePackageComponent convertImplementationGuidePackageComponent(org.hl7.fhir.dstu3.model.ImplementationGuide.ImplementationGuidePackageComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.ImplementationGuide.ImplementationGuidePackageComponent tgt = new org.hl7.fhir.dstu2.model.ImplementationGuide.ImplementationGuidePackageComponent();
    copyElement(src, tgt);
    tgt.setName(src.getName());
    tgt.setDescription(src.getDescription());
    for (org.hl7.fhir.dstu3.model.ImplementationGuide.ImplementationGuidePackageResourceComponent t : src.getResource()) tgt.addResource(convertImplementationGuidePackageResourceComponent(t));
    return tgt;
}

Output:
 public org.hl7.fhir.dstu2.model.ImplementationGuide.ImplementationGuidePackageComponent convertImplementationGuidePackageComponent(org.hl7.fhir.dstu3.model.ImplementationGuide.ImplementationGuidePackageComponent src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
protected boolean mergeImpl() throws IOException {
    boolean implicitDirCache = false;
    if (dircache == null) {
        dircache = getRepository().lockDirCache();
        implicitDirCache = true;
    }
    try {
        builder = dircache.builder();
        DirCacheBuildIterator buildIt = new DirCacheBuildIterator(builder);
        tw = new NameConflictTreeWalk(db);
        tw.addTree(mergeBase());
        tw.addTree(sourceTrees[0]);
        tw.addTree(sourceTrees[1]);
        tw.addTree(buildIt);
        if (workingTreeIterator != null)
            tw.addTree(workingTreeIterator);
        while (tw.next()) {
            if (!processEntry(tw.getTree(T_BASE, CanonicalTreeParser.class), tw.getTree(T_OURS, CanonicalTreeParser.class), tw.getTree(T_THEIRS, CanonicalTreeParser.class), tw.getTree(T_INDEX, DirCacheBuildIterator.class), (workingTreeIterator == null) ? null : tw.getTree(T_FILE, WorkingTreeIterator.class))) {
                cleanUp();
                return false;
            }
            if (tw.isSubtree() && enterSubtree)
                tw.enterSubtree();
        }
        if (!inCore) {
            if (!builder.commit()) {
                cleanUp();
                throw new IndexWriteException();
            }
            builder = null;
            checkout();
        } else {
            builder.finish();
            builder = null;
        }
        if (getUnmergedPathes().isEmpty()) {
            resultTree = dircache.writeTree(oi);
            return true;
        } else {
            resultTree = null;
            return false;
        }
    } finally {
        if (implicitDirCache)
            dircache.unlock();
    }
}

Output:
         }
-        if (getUnmergedPathes().isEmpty()) {
+        if (getUnmergedPaths().isEmpty()) {
             resultTree = dircache.writeTree(oi);


Input:
public synchronized void parseData() throws BasicModel.FieldNotDefinedException {
    mDataToBind.clear();
    if (!mIsMatchListLoaded || mAPIData == null || mAPIData.event == null || mAPIData.teamAtEventRank == null) {
        return;
    }
    Match nextMatch = null, lastMatch = null;
    Collections.sort(mMatches, new MatchSortByPlayOrderComparator());
    int[] record = MatchHelper.getRecordForTeam(mMatches, mTeamKey);
    String recordString = String.format("String_Node_Str", record[0], record[1], record[2]);
    Event event = mAPIData.event;
    int year = event.getEventYear();
    boolean activeEvent = event.isHappeningNow();
    String actionBarTitle = String.format(mResources.getString(R.string.team_actionbar_title), mTeamKey.substring(3));
    String actionBarSubtitle = String.format("String_Node_Str", year, event.getEventShortName());
    EventBus.getDefault().post(new ActionBarTitleEvent(actionBarTitle, actionBarSubtitle));
    if (activeEvent) {
        nextMatch = MatchHelper.getNextMatchPlayed(mMatches);
        lastMatch = MatchHelper.getLastMatchPlayed(mMatches);
    }
    JsonArray alliances = event.getAlliances();
    int allianceNumber = 0, alliancePick = 0;
    if (alliances == null || alliances.size() == 0) {
        allianceNumber = MatchHelper.getAllianceForTeam(mMatches, mTeamKey);
    } else {
        for (int i = 0; i < alliances.size(); i++) {
            JsonArray teams = alliances.get(i).getAsJsonObject().get("String_Node_Str").getAsJsonArray();
            for (int j = 0; j < teams.size(); j++) {
                if (teams.get(j).getAsString().equals(mTeamKey)) {
                    allianceNumber = i + 1;
                    alliancePick = j;
                }
            }
        }
    }
    JsonArray rankData = mAPIData.teamAtEventRank;
    int rank = 0;
    String rankingString = "String_Node_Str";
    if (rankData.size() > 0) {
        rank = rankData.get(1).getAsJsonArray().get(0).getAsInt();
        JsonArray headerRow = rankData.get(0).getAsJsonArray();
        JsonArray teamRank = rankData.get(1).getAsJsonArray();
        CaseInsensitiveMap<String> rankingElements = new CaseInsensitiveMap<>();
        for (int i = 2; i < teamRank.size(); i++) {
            rankingElements.put(headerRow.get(i).getAsString(), teamRank.get(i).getAsString());
        }
        EventHelper.extractRankingString(rankingElements);
        rankingString = EventHelper.createRankingBreakdown(rankingElements);
    }
    if (rank > 0) {
        mDataToBind.add(new LabelValueListItem(mResources.getString(R.string.team_at_event_rank), rank + Utilities.getOrdinalFor(rank)));
    }
    LabelValueListItem rankBreakdownItem = new LabelValueListItem("String_Node_Str", rankingString);
    MatchHelper.EventStatus status;
    try {
        status = MatchHelper.evaluateStatusOfTeam(event, mMatches, mTeamKey);
    } catch (BasicModel.FieldNotDefinedException e) {
        Log.d(Constants.LOG_TAG, "String_Node_Str" + Arrays.toString(e.getStackTrace()));
        status = MatchHelper.EventStatus.NOT_AVAILABLE;
    }
    if (status != MatchHelper.EventStatus.NOT_AVAILABLE) {
        if (year != 2015 && !recordString.equals("String_Node_Str")) {
            mDataToBind.add(new LabelValueListItem(mResources.getString(R.string.team_at_event_record), recordString));
        }
        if (status != MatchHelper.EventStatus.PLAYING_IN_QUALS && status != MatchHelper.EventStatus.NO_ALLIANCE_DATA) {
            mDataToBind.add(new LabelValueListItem(mResources.getString(R.string.team_at_event_alliance), EventHelper.generateAllianceSummary(mResources, allianceNumber, alliancePick)));
        }
        if (status != MatchHelper.EventStatus.NOT_PICKED) {
            mDataToBind.add(new LabelValueListItem(mResources.getString(R.string.team_at_event_status), status.getDescriptionString(mResources)));
        }
        if (rankingString != null && !rankingString.isEmpty()) {
            mDataToBind.add(rankBreakdownItem);
        }
        if (lastMatch != null) {
            mDataToBind.add(new LabelValueListItem(mResources.getString(R.string.title_last_match), mMatchRenderer.renderFromModel(lastMatch, MatchRenderer.RENDER_DEFAULT)));
        }
        if (nextMatch != null) {
            mDataToBind.add(new LabelValueListItem(mResources.getString(R.string.title_next_match), mMatchRenderer.renderFromModel(nextMatch, MatchRenderer.RENDER_DEFAULT)));
        }
    } else {
        mDataToBind.add(rankBreakdownItem);
    }
    mDataToBind.add(new EmptyListElement("String_Node_Str"));
}

Output:
         }
-    } else {
+    } else if (rank > 0) {
         mDataToBind.add(rankBreakdownItem);


Input:
private void setStripeSizeAndWidth(Volume volume) throws IOException {
    int size, width;
    int sizeConf = config.getStripeSizeInKiB();
    int widthConf = config.getStripeWidth();
    int sizeVol = getVolStripeSize(volume);
    int widthVol = getVolStripeWidth(volume);
    if (!config.isStripeSizeSet() && !config.isStripeWidthSet()) {
        config.setStripeSizeInBytes(sizeVol * BenchmarkUtils.KiB_IN_BYTES);
        config.setStripeWidth(widthVol);
        return;
    } else {
        if (!config.isStripeSizeSet() && config.isStripeWidthSet()) {
            size = sizeVol;
            width = widthConf;
        } else if (config.isStripeSizeSet() && !config.isStripeWidthSet()) {
            size = sizeConf;
            width = widthVol;
        } else if (config.isStripeSizeSet() && config.isStripeWidthSet()) {
            size = sizeConf;
            width = widthConf;
        } else
            throw new UnknownError("String_Node_Str");
    }
    String val = "String_Node_Str" + width + "String_Node_Str" + size + "String_Node_Str";
    volume.setXAttr(config.getUserCredentials(), "String_Node_Str", "String_Node_Str", val, MRC.XATTR_FLAGS.XATTR_FLAGS_REPLACE);
    config.setStripeSizeInBytes(size);
    config.setStripeWidth(width);
}

Output:
     volume.setXAttr(config.getUserCredentials(), "String_Node_Str", "String_Node_Str", val, MRC.XATTR_FLAGS.XATTR_FLAGS_REPLACE);
-    config.setStripeSizeInBytes(size);
+    config.setStripeSizeInBytes(size * BenchmarkUtils.KiB_IN_BYTES);
     config.setStripeWidth(width);


Input:
public void visit(UserDefinedArtifactType artifact) {
    super.visit(artifact);
    if (this.atomEntry != null) {
        String userType = artifact.getUserType();
        this.atomEntry.getExtensionAttributes().put(SrampConstants.SRAMP_DERIVED_QNAME, userType);
    }
}

Output:
         String userType = artifact.getUserType();
-        this.atomEntry.getExtensionAttributes().put(SrampConstants.SRAMP_DERIVED_QNAME, userType);
+        this.atomEntry.getExtensionAttributes().put(SrampConstants.SRAMP_USER_TYPE_QNAME, userType);
     }


Input:
public String toString() {
    StringBuffer sbuffer = new StringBuffer(100);
    sbuffer.append("String_Node_Str");
    sbuffer.append("String_Node_Str").append(reactor);
    sbuffer.append("String_Node_Str").append(host);
    sbuffer.append("String_Node_Str").append(port);
    sbuffer.append("String_Node_Str").append(id);
    sbuffer.append("String_Node_Str").append(startupTime);
    sbuffer.append("String_Node_Str").append(lastReadTime);
    sbuffer.append("String_Node_Str").append(lastWriteTime);
    sbuffer.append("String_Node_Str").append(writeAttempts);
    sbuffer.append("String_Node_Str").append(netInCounter).append("String_Node_Str").append(netOutCounter);
    if (isClosed.get()) {
        sbuffer.append("String_Node_Str").append(isClosed);
        sbuffer.append("String_Node_Str").append(closeTime);
        sbuffer.append("String_Node_Str").append(closeReason);
    }
    sbuffer.append("String_Node_Str");
    return sbuffer.toString();
}

Output:
     sbuffer.append("String_Node_Str").append(reactor);
-    sbuffer.append("String_Node_Str").append(host);
-    sbuffer.append("String_Node_Str").append(port);
+    sbuffer.append("String_Node_Str").append(host).append("String_Node_Str").append(port);
     sbuffer.append("String_Node_Str").append(id);


Input:
protected Control createDialogArea(Composite parent) {
    Group comp = new Group(parent, SWT.NONE);
    comp.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
    ((GridLayout) parent.getLayout()).marginTop = 5;
    ((GridLayout) parent.getLayout()).marginLeft = 5;
    ((GridLayout) parent.getLayout()).marginRight = 5;
    ((GridLayout) parent.getLayout()).marginBottom = 5;
    parent.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_WHITE));
    comp.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_WHITE));
    comp.setLayout(new GridLayout(1, false));
    comp.setText("String_Node_Str" + transformer.getName() + "String_Node_Str");
    Set<String> inputVariables = new HashSet<String>();
    for (WSTransformerProcessStep step : transformer.getProcessSteps()) {
        for (WSTransformerVariablesMapping mapping : step.getInputMappings()) {
            inputVariables.add(mapping.getPipelineVariable() == null ? TransformerMainPage.DEFAULT_VAR : mapping.getPipelineVariable());
        }
    }
    ComplexTableViewerColumn[] columns = new ComplexTableViewerColumn[] { new ComplexTableViewerColumn("String_Node_Str", true, "String_Node_Str", "String_Node_Str", "String_Node_Str", true, inputVariables.toArray(new String[inputVariables.size()]), 0), new ComplexTableViewerColumn("String_Node_Str", false, "String_Node_Str", "String_Node_Str", "String_Node_Str", true, new String[] { "String_Node_Str", "String_Node_Str" }, 0), new ComplexTableViewerColumn("String_Node_Str", true, "String_Node_Str", "String_Node_Str", "String_Node_Str", false, null, 10) };
    objectViewer = new ComplexTableViewer(Arrays.asList(columns), toolkit, comp);
    objectViewer.create();
    Table table = objectViewer.getViewer().getTable();
    table.getColumns()[2].setWidth(500);
    table.setHeaderVisible(true);
    table.setLinesVisible(true);
    if (page.getCacheList() != null) {
        objectViewer.getViewer().setInput(page.getCacheList());
    } else {
        List<Line> list = new ArrayList<Line>();
        objectViewer.getViewer().setInput(list);
    }
    return comp;
}

Output:
     }
-    ComplexTableViewerColumn[] columns = new ComplexTableViewerColumn[] { new ComplexTableViewerColumn("String_Node_Str", true, "String_Node_Str", "String_Node_Str", "String_Node_Str", true, inputVariables.toArray(new String[inputVariables.size()]), 0), new ComplexTableViewerColumn("String_Node_Str", false, "String_Node_Str", "String_Node_Str", "String_Node_Str", true, new String[] { "String_Node_Str", "String_Node_Str" }, 0), new ComplexTableViewerColumn("String_Node_Str", true, "String_Node_Str", "String_Node_Str", "String_Node_Str", false, null, 10) };
+    ComplexTableViewerColumn[] columns = new ComplexTableViewerColumn[] { new ComplexTableViewerColumn("String_Node_Str", true, "String_Node_Str", "String_Node_Str", "String_Node_Str", true, inputVariables.toArray(new String[inputVariables.size()]), 0), new ComplexTableViewerColumn("String_Node_Str", false, "String_Node_Str", "String_Node_Str", "String_Node_Str", true, new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" }, 0), new ComplexTableViewerColumn("String_Node_Str", true, "String_Node_Str", "String_Node_Str", "String_Node_Str", false, null, 10) };
     objectViewer = new ComplexTableViewer(Arrays.asList(columns), toolkit, comp);


Input:
public void decode(FacesContext context, UIComponent component) {
    Tree tree = (Tree) component;
    super.decode(context, tree);
    final TreeNodeEventListener nodeSelectionListener = tree.getNodeSelectionListener();
    String params = context.getExternalContext().getRequestParameterMap().get("String_Node_Str");
    if (params != null && nodeSelectionListener != null) {
        if (params != null) {
            params = params.replace("String_Node_Str", "String_Node_Str");
            String[] pair = params.split("String_Node_Str", 2);
            String key = pair[0];
            String value = null;
            if (pair.length == 2) {
                value = pair[1];
            }
            if (value != null && !"String_Node_Str".equals(value.trim())) {
                Node n = TreeModelUtils.mapDataToModel(value);
                TreeModelUtils.updateNodeById(tree.getValue(), n.getNodeId(), n);
                if ("String_Node_Str".equals(key)) {
                    Node n2 = checkNodeIsSelected(tree.getValue(), tree);
                    nodeSelectionListener.processValueChange(new TreeNodeSelectionEvent(n2, n));
                } else if ("String_Node_Str".equals(key)) {
                    nodeSelectionListener.processValueChecked(new TreeNodeCheckedEvent(n, true));
                } else if ("String_Node_Str".equals(key)) {
                    nodeSelectionListener.processValueUnchecked(new TreeNodeCheckedEvent(n, false));
                }
            }
        }
    }
}

Output:
     String params = context.getExternalContext().getRequestParameterMap().get("String_Node_Str");
-    if (params != null && nodeSelectionListener != null) {
-        if (params != null) {
-            params = params.replace("String_Node_Str", "String_Node_Str");
-            String[] pair = params.split("String_Node_Str", 2);
-            String key = pair[0];
-            String value = null;
-            if (pair.length == 2) {
-                value = pair[1];
-            }
-            if (value != null && !"String_Node_Str".equals(value.trim())) {
-                Node n = TreeModelUtils.mapDataToModel(value);
-                TreeModelUtils.updateNodeById(tree.getValue(), n.getNodeId(), n);
+    if (params != null) {
+        params = params.replace("String_Node_Str", "String_Node_Str");
+        String[] pair = params.split("String_Node_Str", 2);
+        String key = pair[0];
+        String value = null;
+        if (pair.length == 2) {
+            value = pair[1];
+        }
+        if (value != null && !"String_Node_Str".equals(value.trim())) {
+            Node n = TreeModelUtils.mapDataToModel(value);
+            TreeModelUtils.updateNodeById(tree.getValue(), n.getNodeId(), n);
+            if (nodeSelectionListener != null) {
                 if ("String_Node_Str".equals(key)) {


Input:
public void cmdGoogle(Context ctx) {
    if (ctx.rawArgs.length() < 1) {
        ctx.send(Emotes.getFailure() + "String_Node_Str").queue();
        return;
    }
    final String query = String.join("String_Node_Str", ctx.args);
    String key = bot.getKeys().optString("String_Node_Str");
    if (key == null) {
        ctx.send(Emotes.getFailure() + "String_Node_Str").queue();
        return;
    }
    String encodedQuery;
    try {
        encodedQuery = URLEncoder.encode(query, "String_Node_Str");
    } catch (UnsupportedEncodingException e) {
        bot.logger.error("String_Node_Str", e);
        ctx.send(Emotes.getFailure() + "String_Node_Str").queue();
        return;
    }
    ctx.channel.sendTyping().queue();
    try {
        ctx.send(cache.get(format(API_URL_BASE, key, encodedQuery))).queue();
    } catch (ExecutionException e) {
        logger.error("String_Node_Str", e.getCause());
        ctx.send(FAILED_EMBED).queue();
    }
}

Output:
         ctx.send(cache.get(format(API_URL_BASE, key, encodedQuery))).queue();
-    } catch (ExecutionException e) {
+    } catch (ExecutionException | UncheckedExecutionException e) {
         logger.error("String_Node_Str", e.getCause());


Input:
public void update(Object obj) {
    CellTransform transform = cell.getWorldTransform();
    Vector3f translation = transform.getTranslation(null);
    translation = translation.add(bounds.getCenter());
    rootNode.setLocalTranslation(translation);
    rootNode.setLocalRotation(transform.getRotation(null));
    wm.addToUpdateList(rootNode);
}

Output:
     CellTransform transform = cell.getWorldTransform();
-    Vector3f translation = transform.getTranslation(null);
-    translation = translation.add(bounds.getCenter());
-    rootNode.setLocalTranslation(translation);
+    rootNode.setLocalTranslation(transform.getTranslation(null));
     rootNode.setLocalRotation(transform.getRotation(null));


Input:
private static void collectClientElementsRecursively(Project project, Element element, int depth, List<Pair<Element, ObjectNode>> elements) {
    ObjectNode jsonObject = Converters.getElementToJsonConverter().apply(element, project);
    if (jsonObject == null) {
        return;
    }
    elements.add(new Pair<>(element, jsonObject));
    if (depth != 0) {
        for (Element elementChild : element.getOwnedElement()) {
            collectClientElementsRecursively(project, elementChild, --depth, elements);
        }
    }
    if (element.equals(project.getPrimaryModel())) {
        List<Package> attachedModels = project.getModels();
        attachedModels.remove(project.getPrimaryModel());
        attachedModels.forEach(attachedModel -> collectClientElementsRecursively(project, attachedModel, 0, elements));
    }
}

Output:
     elements.add(new Pair<>(element, jsonObject));
-    if (depth != 0) {
+    if (depth-- != 0) {
         for (Element elementChild : element.getOwnedElement()) {


Input:
public void testScanWithFilter() throws IOException {
    prepareScanData(TRANSACTION_COLUMNS);
    writeData(COLUMN, lastTs(prewriteTs), ANOTHER_VALUE);
    ValueFilter valueFilter = new ValueFilter(CompareOp.EQUAL, new BinaryComparator(ANOTHER_VALUE));
    PrefixFilter prefixFilter = new PrefixFilter(ANOTHER_ROW);
    FilterList filterList = new FilterList();
    filterList.addFilter(valueFilter);
    filterList.addFilter(prefixFilter);
    ThemisScanner scanner = prepareScanner(TRANSACTION_COLUMNS, filterList);
    checkAndCloseScanner(scanner);
    filterList = new FilterList(Operator.MUST_PASS_ONE);
    filterList.addFilter(valueFilter);
    filterList.addFilter(prefixFilter);
    scanner = prepareScanner(TRANSACTION_COLUMNS, filterList);
    checkScanRow(new ColumnCoordinate[] { COLUMN_WITH_ANOTHER_ROW }, scanner.next());
    Assert.assertEquals(3, scanner.next().size());
    checkAndCloseScanner(scanner);
}

Output:
     checkScanRow(new ColumnCoordinate[] { COLUMN_WITH_ANOTHER_ROW }, scanner.next());
-    Assert.assertEquals(3, scanner.next().size());
+    Assert.assertEquals(1, scanner.next().size());
     checkAndCloseScanner(scanner);


Input:
private void checkPermission(Permission permission) {
    if (((GitLabConnectionConfig) Jenkins.getInstance().getDescriptor(GitLabConnectionConfig.class)).isUseAuthenticatedEndpoint()) {
        if (!Jenkins.getActiveInstance().getACL().hasPermission(authentication, permission)) {
            String message = Messages.AccessDeniedException2_MissingPermission(authentication.getName(), permission.group.title + "String_Node_Str" + permission.name);
            LOGGER.finest("String_Node_Str");
            throw HttpResponses.errorWithoutStack(403, message);
        }
    }
}

Output:
 private void checkPermission(Permission permission) {
-    if (((GitLabConnectionConfig) Jenkins.getInstance().getDescriptor(GitLabConnectionConfig.class)).isUseAuthenticatedEndpoint()) {
+    if (((GitLabConnectionConfig) Jenkins.getInstance().getDescriptor(GitLabConnectionConfig.class)).getUseAuthenticatedEndpoint()) {
         if (!Jenkins.getActiveInstance().getACL().hasPermission(authentication, permission)) {


Input:
private static void appendIsTypingMessage(StringBuilder builder, String senderName, ChatState chatState, boolean friendSignedOff) {
    String stateMessage = null;
    if (friendSignedOff) {
        stateMessage = I18n.tr("String_Node_Str", senderName);
    } else if (chatState == ChatState.composing) {
        stateMessage = I18n.tr("String_Node_Str", senderName);
    } else if (chatState == ChatState.paused) {
        stateMessage = I18n.tr("String_Node_Str", senderName);
    } else {
        return;
    }
    String cssClass = "String_Node_Str";
    builder.append("String_Node_Str").append(cssClass).append("String_Node_Str").append(stateMessage).append("String_Node_Str").append("String_Node_Str");
}

Output:
     if (friendSignedOff) {
-        stateMessage = I18n.tr("String_Node_Str", senderName);
+        stateMessage = tr("String_Node_Str", senderName);
     } else if (chatState == ChatState.composing) {


Input:
public synchronized void stop() {
    LensEventService eventService = (LensEventService) LensServices.get().getService(LensEventService.NAME);
    eventService.removeListener(queryStatusListener);
    queryStatusListener.stop();
    for (ScheduledReporter reporter : reporters) {
        reporter.stop();
    }
    LOG.info("String_Node_Str");
    super.stop();
}

Output:
     LensEventService eventService = (LensEventService) LensServices.get().getService(LensEventService.NAME);
-    eventService.removeListener(queryStatusListener);
-    queryStatusListener.stop();
-    for (ScheduledReporter reporter : reporters) {
-        reporter.stop();
+    if (eventService != null) {
+        eventService.removeListener(queryStatusListener);
+    }
+    if (queryStatusListener != null) {
+        queryStatusListener.stop();
+    }
+    if (reporters != null) {
+        for (ScheduledReporter reporter : reporters) {
+            reporter.stop();
+        }
     }


Input:
public Collection getEvictedRevisions(ModuleId mid, String rootModuleConf) {
    Collection resolved = (Collection) _evictedDeps.get(new ModuleIdConf(mid, rootModuleConf));
    if (resolved == null) {
        return new HashSet();
    } else {
        Collection ret = new HashSet();
        for (Iterator iter = resolved.iterator(); iter.hasNext(); ) {
            IvyNode node = (IvyNode) iter.next();
            ret.add(node.getRealNode().getResolvedId());
        }
        return ret;
    }
}

Output:
 public Collection getEvictedRevisions(ModuleId mid, String rootModuleConf) {
-    Collection resolved = (Collection) _evictedDeps.get(new ModuleIdConf(mid, rootModuleConf));
-    if (resolved == null) {
+    Collection evicted = (Collection) _evictedRevs.get(new ModuleIdConf(mid, rootModuleConf));
+    if (evicted == null) {
         return new HashSet();


Input:
protected boolean calculateEnabled() {
    List selected = getSelectedObjects();
    if (selected.size() != 1 || !(selected.get(0) instanceof EditPart)) {
        return false;
    }
    EditPart part = (EditPart) selected.get(0);
    Object model = part.getModel();
    if (!(model instanceof ReportItemHandle) && model instanceof IAdaptable) {
        model = ((IAdaptable) model).getAdapter(DesignElementHandle.class);
    }
    if (!(model instanceof ReportItemHandle) || DEUtil.isReferenceElement((ReportItemHandle) model)) {
        return false;
    }
    Object[] objs = ElementAdapterManager.getAdapters(model, IReportItemViewProvider.class);
    if (objs == null || objs.length > 1) {
        return false;
    }
    if (((ReportItemHandle) model).getViews().size() != 0) {
        return false;
    }
    return true;
}

Output:
     }
-    if (((ReportItemHandle) model).getViews().size() != 0) {
+    if (((ReportItemHandle) model).getViews().size() != 0 || !((ReportItemHandle) model).canAddView("String_Node_Str")) {
         return false;


Input:
private static Map<String, Object> executor(final String name, final boolean daemon, final int priority, final int n, final Object value) {
    Map<String, Object> options = new HashMap<>();
    options.put("String_Node_Str", name);
    options.put("String_Node_Str", daemon);
    options.put("String_Node_Str", priority);
    if (value instanceof Map) {
        Map<String, Object> config = (Map<String, Object>) value;
        Object rawType = config.get("String_Node_Str");
        if (rawType == null) {
            throw new IllegalArgumentException("String_Node_Str");
        }
        String type = rawType.toString();
        options.put("String_Node_Str", type);
        options.put(type, config.containsKey("String_Node_Str") ? Integer.parseInt(config.get("String_Node_Str").toString()) : n);
        options.put("String_Node_Str", config.containsKey("String_Node_Str") ? Boolean.parseBoolean(config.get("String_Node_Str").toString()) : daemon);
        options.put("String_Node_Str", config.containsKey("String_Node_Str") ? Boolean.parseBoolean(config.get("String_Node_Str").toString()) : false);
        options.put("String_Node_Str", config.containsKey("String_Node_Str") ? Integer.parseInt(config.get("String_Node_Str").toString()) : priority);
    } else {
        Iterable<String> spec = Splitter.on("String_Node_Str").trimResults().omitEmptyStrings().split(value.toString());
        for (String option : spec) {
            String[] opt = option.split("String_Node_Str");
            String optname = opt[0].trim();
            Object optvalue;
            if (optname.equals("String_Node_Str")) {
                optvalue = opt.length > 1 ? Boolean.parseBoolean(opt[1].trim()) : daemon;
            } else if (optname.equals("String_Node_Str")) {
                optvalue = opt.length > 1 ? Boolean.parseBoolean(opt[1].trim()) : false;
            } else if (optname.equals("String_Node_Str")) {
                optvalue = opt.length > 1 ? Integer.parseInt(opt[1].trim()) : priority;
            } else {
                optvalue = opt.length > 1 ? Integer.parseInt(opt[1].trim()) : n;
                options.put("String_Node_Str", optname);
            }
            options.put(optname, optvalue);
        }
    }
    return options;
}

Output:
         options.put("String_Node_Str", config.containsKey("String_Node_Str") ? Boolean.parseBoolean(config.get("String_Node_Str").toString()) : daemon);
-        options.put("String_Node_Str", config.containsKey("String_Node_Str") ? Boolean.parseBoolean(config.get("String_Node_Str").toString()) : false);
+        options.put("String_Node_Str", config.containsKey("String_Node_Str") && Boolean.parseBoolean(config.get("String_Node_Str").toString()));
         options.put("String_Node_Str", config.containsKey("String_Node_Str") ? Integer.parseInt(config.get("String_Node_Str").toString()) : priority);


Input:
public void processRequest() throws Exception {
    FormDiscrepancyNotes discNotes = null;
    SubjectDAO sdao = new SubjectDAO(sm.getDataSource());
    StudySubjectDAO subdao = new StudySubjectDAO(sm.getDataSource());
    FormProcessor fp = new FormProcessor(request);
    String fromResolvingNotes = fp.getString("String_Node_Str", true);
    if (StringUtil.isBlank(fromResolvingNotes)) {
        session.removeAttribute(ViewNotesServlet.WIN_LOCATION);
        session.removeAttribute(ViewNotesServlet.NOTES_TABLE);
        checkStudyLocked(Page.LIST_STUDY_SUBJECTS_SERVLET, respage.getString("String_Node_Str"));
        checkStudyFrozen(Page.LIST_STUDY_SUBJECTS_SERVLET, respage.getString("String_Node_Str"));
    }
    int studySubId = fp.getInt("String_Node_Str", true);
    if (studySubId == 0) {
        addPageMessage(respage.getString("String_Node_Str"));
        forwardPage(Page.LIST_STUDY_SUBJECTS);
    } else {
        String action = fp.getString("String_Node_Str", true);
        if (StringUtil.isBlank(action)) {
            addPageMessage(respage.getString("String_Node_Str"));
            forwardPage(Page.LIST_STUDY_SUBJECTS);
            return;
        }
        StudySubjectBean sub = (StudySubjectBean) subdao.findByPK(studySubId);
        StudyGroupClassDAO sgcdao = new StudyGroupClassDAO(sm.getDataSource());
        StudyGroupDAO sgdao = new StudyGroupDAO(sm.getDataSource());
        SubjectGroupMapDAO sgmdao = new SubjectGroupMapDAO(sm.getDataSource());
        ArrayList groupMaps = (ArrayList) sgmdao.findAllByStudySubject(studySubId);
        HashMap gMaps = new HashMap();
        for (int i = 0; i < groupMaps.size(); i++) {
            SubjectGroupMapBean groupMap = (SubjectGroupMapBean) groupMaps.get(i);
            gMaps.put(new Integer(groupMap.getStudyGroupClassId()), groupMap);
        }
        StudyDAO stdao = new StudyDAO(sm.getDataSource());
        ArrayList classes = new ArrayList();
        if (!"String_Node_Str".equalsIgnoreCase(action)) {
            int parentStudyId = currentStudy.getParentStudyId();
            if (parentStudyId > 0) {
                StudyBean parentStudy = (StudyBean) stdao.findByPK(parentStudyId);
                classes = sgcdao.findAllActiveByStudy(parentStudy);
            } else {
                classes = sgcdao.findAllActiveByStudy(currentStudy);
            }
            for (int i = 0; i < classes.size(); i++) {
                StudyGroupClassBean group = (StudyGroupClassBean) classes.get(i);
                ArrayList studyGroups = sgdao.findAllByGroupClass(group);
                group.setStudyGroups(studyGroups);
                SubjectGroupMapBean gMap = (SubjectGroupMapBean) gMaps.get(new Integer(group.getId()));
                if (gMap != null) {
                    group.setStudyGroupId(gMap.getStudyGroupId());
                    group.setGroupNotes(gMap.getNotes());
                }
            }
            session.setAttribute("String_Node_Str", classes);
        }
        if ("String_Node_Str".equalsIgnoreCase(action)) {
            session.setAttribute("String_Node_Str", sub);
            String enrollDateStr = local_df.format(sub.getEnrollmentDate());
            session.setAttribute("String_Node_Str", enrollDateStr);
            discNotes = new FormDiscrepancyNotes();
            session.setAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME, discNotes);
            forwardPage(Page.UPDATE_STUDY_SUBJECT);
        } else if ("String_Node_Str".equalsIgnoreCase(action)) {
            confirm(sgdao);
        } else if ("String_Node_Str".equalsIgnoreCase(action)) {
            StudySubjectBean subject = (StudySubjectBean) session.getAttribute("String_Node_Str");
            subject.setUpdater(ub);
            subdao.update(subject);
            FormDiscrepancyNotes fdn = (FormDiscrepancyNotes) session.getAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
            DiscrepancyNoteDAO dndao = new DiscrepancyNoteDAO(sm.getDataSource());
            AddNewSubjectServlet.saveFieldNotes("String_Node_Str", fdn, dndao, subject.getId(), "String_Node_Str", currentStudy);
            ArrayList groups = (ArrayList) session.getAttribute("String_Node_Str");
            if (!groups.isEmpty()) {
                for (int i = 0; i < groups.size(); i++) {
                    StudyGroupClassBean sgc = (StudyGroupClassBean) groups.get(i);
                    SubjectGroupMapBean sgm = new SubjectGroupMapBean();
                    SubjectGroupMapBean gMap = (SubjectGroupMapBean) gMaps.get(new Integer(sgc.getId()));
                    sgm.setStudyGroupId(sgc.getStudyGroupId());
                    sgm.setNotes(sgc.getGroupNotes());
                    sgm.setStudyGroupClassId(sgc.getId());
                    sgm.setStudySubjectId(subject.getId());
                    sgm.setStatus(Status.AVAILABLE);
                    if (sgm.getStudyGroupId() > 0) {
                        if (gMap != null && gMap.getId() > 0) {
                            sgm.setUpdater(ub);
                            sgm.setId(gMap.getId());
                            sgmdao.update(sgm);
                        } else {
                            sgm.setOwner(ub);
                            sgmdao.create(sgm);
                        }
                    }
                }
            }
            addPageMessage(respage.getString("String_Node_Str"));
            session.removeAttribute("String_Node_Str");
            session.removeAttribute("String_Node_Str");
            session.removeAttribute("String_Node_Str");
            session.removeAttribute(AddNewSubjectServlet.FORM_DISCREPANCY_NOTES_NAME);
            request.setAttribute("String_Node_Str", new Integer(studySubId).toString());
            forwardPage(Page.VIEW_STUDY_SUBJECT_SERVLET);
        } else {
            addPageMessage(respage.getString("String_Node_Str"));
            forwardPage(Page.LIST_STUDY_SUBJECTS);
            return;
        }
    }
}

Output:
                     StudyGroupClassBean sgc = (StudyGroupClassBean) groups.get(i);
-                    SubjectGroupMapBean sgm = new SubjectGroupMapBean();
-                    SubjectGroupMapBean gMap = (SubjectGroupMapBean) gMaps.get(new Integer(sgc.getId()));
-                    sgm.setStudyGroupId(sgc.getStudyGroupId());
-                    sgm.setNotes(sgc.getGroupNotes());
-                    sgm.setStudyGroupClassId(sgc.getId());
-                    sgm.setStudySubjectId(subject.getId());
-                    sgm.setStatus(Status.AVAILABLE);
-                    if (sgm.getStudyGroupId() > 0) {
-                        if (gMap != null && gMap.getId() > 0) {
-                            sgm.setUpdater(ub);
-                            sgm.setId(gMap.getId());
-                            sgmdao.update(sgm);
-                        } else {
-                            sgm.setOwner(ub);
-                            sgmdao.create(sgm);
+                    if (sgc.getStudyGroupId() == 0) {
+                        Collection subjectGroups = sgmdao.findAllByStudySubject(subject.getId());
+                        for (Iterator it = subjectGroups.iterator(); it.hasNext(); ) {
+                            sgmdao.deleteTestGroupMap(((SubjectGroupMapBean) it.next()).getId());
+                        }
+                    } else {
+                        SubjectGroupMapBean sgm = new SubjectGroupMapBean();
+                        SubjectGroupMapBean gMap = (SubjectGroupMapBean) gMaps.get(new Integer(sgc.getId()));
+                        sgm.setStudyGroupId(sgc.getStudyGroupId());
+                        sgm.setNotes(sgc.getGroupNotes());
+                        sgm.setStudyGroupClassId(sgc.getId());
+                        sgm.setStudySubjectId(subject.getId());
+                        sgm.setStatus(Status.AVAILABLE);
+                        if (sgm.getStudyGroupId() > 0) {
+                            if (gMap != null && gMap.getId() > 0) {
+                                sgm.setUpdater(ub);
+                                sgm.setId(gMap.getId());
+                                sgmdao.update(sgm);
+                            } else {
+                                sgm.setOwner(ub);
+                                sgmdao.create(sgm);
+                            }
                         }


Input:
public static String getHive1StandaloneURLString(DatabaseConnection dbConn, boolean supportContext) {
    String s = EDatabaseConnTemplate.HIVE.getUrlTemplate(EDatabaseVersion4Drivers.HIVE);
    if (s != null) {
        if (supportContext) {
            s = TalendQuoteUtils.addQuotes(s);
        }
        s = getStringReplace(s, EDatabaseConnVar.LOGIN.getVariable(), dbConn.getUsername(), supportContext);
        s = getStringReplace(s, EDatabaseConnVar.PASSWORD.getVariable(), dbConn.getPassword(), supportContext, true);
        s = getStringReplace(s, EDatabaseConnVar.HOST.getVariable(), dbConn.getServerName(), supportContext);
        s = getStringReplace(s, EDatabaseConnVar.PORT.getVariable(), dbConn.getPort(), supportContext);
        s = getStringReplace(s, EDatabaseConnVar.SID.getVariable(), dbConn.getSID(), supportContext);
        s = getStringReplace(s, EDatabaseConnVar.SERVICE_NAME.getVariable(), dbConn.getSID(), supportContext);
        s = getStringReplace(s, EDatabaseConnVar.DATASOURCE.getVariable(), dbConn.getDatasourceName(), supportContext);
        s = getStringReplace(s, EDatabaseConnVar.FILENAME.getVariable(), dbConn.getFileFieldName(), supportContext);
    }
    return s;
}

Output:
     String s = EDatabaseConnTemplate.HIVE.getUrlTemplate(EDatabaseVersion4Drivers.HIVE);
-    if (s != null) {
-        if (supportContext) {
-            s = TalendQuoteUtils.addQuotes(s);
-        }
-        s = getStringReplace(s, EDatabaseConnVar.LOGIN.getVariable(), dbConn.getUsername(), supportContext);
-        s = getStringReplace(s, EDatabaseConnVar.PASSWORD.getVariable(), dbConn.getPassword(), supportContext, true);
-        s = getStringReplace(s, EDatabaseConnVar.HOST.getVariable(), dbConn.getServerName(), supportContext);
-        s = getStringReplace(s, EDatabaseConnVar.PORT.getVariable(), dbConn.getPort(), supportContext);
-        s = getStringReplace(s, EDatabaseConnVar.SID.getVariable(), dbConn.getSID(), supportContext);
-        s = getStringReplace(s, EDatabaseConnVar.SERVICE_NAME.getVariable(), dbConn.getSID(), supportContext);
-        s = getStringReplace(s, EDatabaseConnVar.DATASOURCE.getVariable(), dbConn.getDatasourceName(), supportContext);
-        s = getStringReplace(s, EDatabaseConnVar.FILENAME.getVariable(), dbConn.getFileFieldName(), supportContext);
-    }
-    return s;
+    return getHiveStandaloneURlString(s, supportContext, server, port, sid);
 }


Input:
public void selectAlternateSetting(UsbDeviceConnection connection, int alternateSetting) throws UnsupportedOperationException {
    currentSetting = alternateSetting;
    final UsbInterface usbInterface = getUsbInterface();
    if (usbInterface == null) {
        throw new UnsupportedOperationException("String_Node_Str" + alternateSetting);
    }
    connection.claimInterface(usbInterface, true);
    final LibusbError result = connection.setInterface(usbInterface);
    Timber.d("String_Node_Str", result);
    Timber.d("String_Node_Str", Arrays.toString(getCurrentEndpoints()));
}

Output:
     connection.claimInterface(usbInterface, true);
-    final LibusbError result = connection.setInterface(usbInterface);
-    Timber.d("String_Node_Str", result);
-    Timber.d("String_Node_Str", Arrays.toString(getCurrentEndpoints()));
+    return connection.setInterface(usbInterface);
 }


Input:
public HashMap<String, String[]> getParameters() {
    return parameters;
}

Output:
 public HashMap<String, String[]> getParameters() {
-    return parameters;
+    return parameters != null ? new HashMap<String, String[]>(parameters) : null;
 }


Input:
private boolean moveBlocks() {
    if (player.getWorld() != headblock.getWorld()) {
        cancel();
        return false;
    }
    Location headlocation = player.getEyeLocation();
    Location legslocation = player.getLocation();
    Vector headdirection = headlocation.toVector().subtract(headblocklocation.toVector()).normalize().multiply(.5);
    Vector legsdirection = legslocation.toVector().subtract(legsblocklocation.toVector()).normalize().multiply(.5);
    Block newheadblock = headblock;
    Block newlegsblock = legsblock;
    if (!headlocation.getBlock().equals(headblock)) {
        headblocklocation = headblocklocation.clone().add(headdirection);
        newheadblock = headblocklocation.getBlock();
    }
    if (!legslocation.getBlock().equals(legsblock)) {
        legsblocklocation = legsblocklocation.clone().add(legsdirection);
        newlegsblock = legsblocklocation.getBlock();
    }
    if (EarthMethods.isTransparentToEarthbending(player, newheadblock) && !newheadblock.isLiquid()) {
        GeneralMethods.breakBlock(newheadblock);
    } else if (!EarthMethods.isEarthbendable(player, newheadblock) && !newheadblock.isLiquid() && newheadblock.getType() != Material.AIR) {
        cancel();
        return false;
    }
    if (EarthMethods.isTransparentToEarthbending(player, newlegsblock) && !newlegsblock.isLiquid()) {
        GeneralMethods.breakBlock(newlegsblock);
    } else if (!EarthMethods.isEarthbendable(player, newlegsblock) && !newlegsblock.isLiquid() && newlegsblock.getType() != Material.AIR) {
        cancel();
        return false;
    }
    if (headblock.getLocation().distance(player.getEyeLocation()) > range || legsblock.getLocation().distance(player.getLocation()) > range) {
        cancel();
        return false;
    }
    if (!newheadblock.equals(headblock)) {
        new TempBlock(newheadblock, headtype, headdata);
        if (TempBlock.isTempBlock(headblock))
            TempBlock.revertBlock(headblock, Material.AIR);
    }
    if (!newlegsblock.equals(legsblock)) {
        new TempBlock(newlegsblock, legstype, legsdata);
        if (TempBlock.isTempBlock(legsblock))
            TempBlock.revertBlock(legsblock, Material.AIR);
    }
    headblock = newheadblock;
    legsblock = newlegsblock;
    return true;
}

Output:
 private boolean moveBlocks() {
-    if (player.getWorld() != headblock.getWorld()) {
+    if (!player.getWorld().equals(headblock.getWorld())) {
         cancel();


Input:
public static void generateGlueCodeForJNIMethod(VM_Assembler asm, VM_NormalMethod method, int methodID) {
    asm.emitPUSH_Reg(EBP);
    asm.emitMOV_Reg_Reg(EBP, SP);
    asm.emitPUSH_Imm(methodID);
    asm.emitSUB_Reg_Imm(SP, WORDSIZE);
    asm.emitPUSH_Reg(JTOC);
    asm.emitPUSH_Reg(EBX);
    asm.emitPUSH_Reg(S0);
    VM_ProcessorLocalState.emitPushProcessor(asm);
    asm.emitSUB_RegDisp_Imm(EBP, (2 * WORDSIZE), VM_Entrypoints.JNIExternalFunctionsField.getOffset());
    VM_TypeReference[] types = method.getParameterTypes();
    int numArguments = types.length;
    int argOffset = 2;
    for (int i = 0; i < numArguments; i++) {
        if (types[i].isLongType() || types[i].isDoubleType()) {
            asm.emitMOV_Reg_RegDisp(EBX, EBP, ((argOffset + 1) * WORDSIZE));
            asm.emitPUSH_Reg(EBX);
            asm.emitMOV_Reg_RegDisp(EBX, EBP, (argOffset * WORDSIZE));
            asm.emitPUSH_Reg(EBX);
            argOffset += 2;
        } else {
            asm.emitMOV_Reg_RegDisp(EBX, EBP, (argOffset * WORDSIZE));
            asm.emitPUSH_Reg(EBX);
            argOffset++;
        }
    }
    int retryLabel = asm.getMachineCodeIndex();
    asm.emitMOV_Reg_RegDisp(EBX, EBP, (2 * WORDSIZE));
    VM_ProcessorLocalState.emitSetProcessor(asm, EBX, VM_Entrypoints.JNIEnvSavedPRField.getOffset());
    VM_ProcessorLocalState.emitMoveFieldToReg(asm, JTOC, VM_Entrypoints.jtocField.getOffset());
    VM_ProcessorLocalState.emitMoveFieldToReg(asm, T0, VM_Entrypoints.vpStatusField.getOffset());
    asm.emitCMP_Reg_Imm(T0, VM_Processor.IN_NATIVE);
    VM_ForwardReference fr = asm.forwardJcc(asm.EQ);
    asm.emitMOV_Reg_RegDisp(T0, JTOC, VM_Entrypoints.the_boot_recordField.getOffset());
    asm.emitCALL_RegDisp(T0, VM_Entrypoints.sysVirtualProcessorYieldIPField.getOffset());
    asm.emitJMP_Imm(retryLabel);
    fr.resolve(asm);
    asm.emitMOV_Reg_Imm(T1, VM_Processor.IN_JAVA);
    VM_ProcessorLocalState.emitCompareAndExchangeField(asm, VM_Entrypoints.vpStatusField.getOffset(), T1);
    asm.emitJCC_Cond_Imm(asm.NE, retryLabel);
    int numLocalVariables = method.getLocalWords() - method.getParameterWords();
    asm.emitSUB_Reg_Imm(SP, (numLocalVariables << LG_WORDSIZE));
    asm.emitMOV_Reg_RegDisp(S0, EBX, VM_Entrypoints.JNITopJavaFPField.getOffset());
    asm.emitSUB_Reg_Reg(S0, EBP);
    asm.emitMOV_RegDisp_Reg(EBP, SAVED_JAVA_FP_OFFSET, S0);
    VM_ProcessorLocalState.emitMoveRegToField(asm, VM_Entrypoints.framePointerField.getOffset(), EBP);
    asm.emitNOP();
}

Output:
     asm.emitPUSH_Imm(methodID);
-    asm.emitSUB_Reg_Imm(SP, WORDSIZE);
+    asm.emitSUB_Reg_Imm(SP, STACKFRAME_HEADER_SIZE - 2 * WORDSIZE);
     asm.emitPUSH_Reg(JTOC);


Input:
private static void startSync() {
    LOG.debug("String_Node_Str");
    timeTillNextSync = lic.getSyncInterval();
    if (!inSync) {
        inSync = true;
        Threads.newThread(new Runnable() {
            public void run() {
                LOG.debug("String_Node_Str");
                sync(lic);
                setSyncCompleted();
                LOG.debug("String_Node_Str");
            }
        }, LDAP_SYNC_THREAD).start();
    }
}

Output:
     timeTillNextSync = lic.getSyncInterval();
-    if (!inSync) {
-        inSync = true;
+    if (!getAndSetSync(true)) {
         Threads.newThread(new Runnable() {


Input:
private void processPropertyAnnotations(TypeInfo info, JavaClass cls, JavaHasAnnotations javaHasAnnotations, Property property) {
    if (helper.isAnnotationPresent(javaHasAnnotations, XmlMixed.class)) {
        info.setMixed(true);
        property.setMixedContent(true);
    }
    if (helper.isAnnotationPresent(javaHasAnnotations, XmlContainerProperty.class)) {
        XmlContainerProperty container = (XmlContainerProperty) helper.getAnnotation(javaHasAnnotations, XmlContainerProperty.class);
        property.setInverseReferencePropertyName(container.value());
        property.setInverseReferencePropertyGetMethodName(container.getMethodName());
        property.setInverseReferencePropertySetMethodName(container.setMethodName());
    } else if (helper.isAnnotationPresent(javaHasAnnotations, XmlInverseReference.class)) {
        XmlInverseReference inverseReference = (XmlInverseReference) helper.getAnnotation(javaHasAnnotations, XmlInverseReference.class);
        property.setInverseReferencePropertyName(inverseReference.mappedBy());
        TypeInfo targetInfo = this.getTypeInfo().get(property.getActualType().getName());
        if (targetInfo != null && targetInfo.getXmlAccessType() == XmlAccessType.PROPERTY) {
            String propName = property.getPropertyName();
            propName = Character.toUpperCase(propName.charAt(0)) + propName.substring(1);
            property.setInverseReferencePropertyGetMethodName(GET_STR + propName);
            property.setInverseReferencePropertySetMethodName(SET_STR + propName);
        }
        property.setInverseReference(true);
    }
    processXmlJavaTypeAdapter(property, info, cls);
    if (helper.isAnnotationPresent(property.getElement(), XmlAttachmentRef.class) && areEquals(property.getActualType(), JAVAX_ACTIVATION_DATAHANDLER)) {
        property.setIsSwaAttachmentRef(true);
        property.setSchemaType(XMLConstants.SWA_REF_QNAME);
    }
    processXmlElement(property, info);
    if (!(property.isSwaAttachmentRef()) && isMtomAttachment(property)) {
        property.setIsMtomAttachment(true);
        property.setSchemaType(XMLConstants.BASE_64_BINARY_QNAME);
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlMimeType.class)) {
        property.setMimeType(((XmlMimeType) helper.getAnnotation(property.getElement(), XmlMimeType.class)).value());
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlInlineBinaryData.class) || info.isBinaryDataToBeInlined()) {
        property.setisInlineBinaryData(true);
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlSchemaType.class)) {
        XmlSchemaType schemaType = (XmlSchemaType) helper.getAnnotation(property.getElement(), XmlSchemaType.class);
        QName schemaTypeQname = new QName(schemaType.namespace(), schemaType.name());
        property.setSchemaType(schemaTypeQname);
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlAttribute.class)) {
        property.setIsAttribute(true);
        property.setIsRequired(((XmlAttribute) helper.getAnnotation(property.getElement(), XmlAttribute.class)).required());
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlAnyAttribute.class)) {
        if (info.isSetAnyAttributePropertyName()) {
            throw org.eclipse.persistence.exceptions.JAXBException.multipleAnyAttributeMapping(cls.getName());
        }
        if (!property.getType().getName().equals("String_Node_Str")) {
            throw org.eclipse.persistence.exceptions.JAXBException.anyAttributeOnNonMap(property.getPropertyName());
        }
        property.setIsAnyAttribute(true);
        info.setAnyAttributePropertyName(property.getPropertyName());
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlElementWrapper.class)) {
        XmlElementWrapper wrapper = (XmlElementWrapper) helper.getAnnotation(property.getElement(), XmlElementWrapper.class);
        org.eclipse.persistence.jaxb.xmlmodel.XmlElementWrapper xmlEltWrapper = new org.eclipse.persistence.jaxb.xmlmodel.XmlElementWrapper();
        xmlEltWrapper.setName(wrapper.name());
        xmlEltWrapper.setNamespace(wrapper.namespace());
        xmlEltWrapper.setNillable(wrapper.nillable());
        xmlEltWrapper.setRequired(wrapper.required());
        property.setXmlElementWrapper(xmlEltWrapper);
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlList.class)) {
        if (!isCollectionType(property) && !property.getType().isArray()) {
            throw JAXBException.invalidList(property.getPropertyName());
        }
        property.setIsXmlList(true);
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlValue.class)) {
        property.setIsXmlValue(true);
        info.setXmlValueProperty(property);
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlReadOnly.class)) {
        property.setReadOnly(true);
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlWriteOnly.class)) {
        property.setWriteOnly(true);
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlCDATA.class)) {
        property.setCdata(true);
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlAccessMethods.class)) {
        XmlAccessMethods accessMethods = (XmlAccessMethods) helper.getAnnotation(property.getElement(), XmlAccessMethods.class);
        if (!(accessMethods.getMethodName().equals(EMPTY_STRING))) {
            property.setGetMethodName(accessMethods.getMethodName());
        }
        if (!(accessMethods.setMethodName().equals(EMPTY_STRING))) {
            property.setSetMethodName(accessMethods.setMethodName());
        }
        if (!(property.isMethodProperty())) {
            property.setMethodProperty(true);
        }
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlProperties.class)) {
        XmlProperties xmlProperties = (XmlProperties) helper.getAnnotation(property.getElement(), XmlProperties.class);
        Map<Object, Object> propertiesMap = createUserPropertiesMap(xmlProperties.value());
        property.setUserProperties(propertiesMap);
    } else if (helper.isAnnotationPresent(property.getElement(), XmlProperty.class)) {
        XmlProperty xmlProperty = (XmlProperty) helper.getAnnotation(property.getElement(), XmlProperty.class);
        Map<Object, Object> propertiesMap = createUserPropertiesMap(new XmlProperty[] { xmlProperty });
        property.setUserProperties(propertiesMap);
    }
    if (helper.isAnnotationPresent(property.getElement(), XmlKey.class)) {
        info.addXmlKeyProperty(property);
    }
    processXmlJoinNodes(property);
    processXmlNullPolicy(property);
}

Output:
     if (helper.isAnnotationPresent(property.getElement(), XmlAnyAttribute.class)) {
-        if (info.isSetAnyAttributePropertyName()) {
+        if (info.isSetAnyAttributePropertyName() && !info.getAnyAttributePropertyName().equals(property.getPropertyName())) {
             throw org.eclipse.persistence.exceptions.JAXBException.multipleAnyAttributeMapping(cls.getName());


Input:
public HandlerRegistration addValueChangeHandler(ValueChangeHandler<Boolean> handler) {
    if (!valueChangeHandlerInitialized) {
        this.addKeyUpHandler(new KeyUpHandler() {
            public void onKeyUp(KeyUpEvent event) {
                valueBeforeClick = getValue();
            }
        });
        this.addMouseUpHandler(new MouseUpHandler() {
            public void onMouseUp(MouseUpEvent event) {
                valueBeforeClick = getValue();
            }
        });
        this.addClickHandler(new ClickHandler() {
            public void onClick(ClickEvent event) {
                ValueChangeEvent.fireIfNotEqual(CheckBox.this, valueBeforeClick, getValue());
            }
        });
        valueChangeHandlerInitialized = true;
    }
    return addHandler(handler, ValueChangeEvent.getType());
}

Output:
     if (!valueChangeHandlerInitialized) {
-        this.addKeyUpHandler(new KeyUpHandler() {
-            public void onKeyUp(KeyUpEvent event) {
-                valueBeforeClick = getValue();
-            }
-        });
-        this.addMouseUpHandler(new MouseUpHandler() {
-            public void onMouseUp(MouseUpEvent event) {
-                valueBeforeClick = getValue();
-            }
-        });
-        this.addClickHandler(new ClickHandler() {
-            public void onClick(ClickEvent event) {
-                ValueChangeEvent.fireIfNotEqual(CheckBox.this, valueBeforeClick, getValue());
-            }
-        });
+        ensureDomEventHandlers();
         valueChangeHandlerInitialized = true;


Input:
public String getText(Mode mode) {
    if (staticText != null && !staticText.isEmpty()) {
        return staticText;
    }
    StringBuilder sb = new StringBuilder();
    Target target = mode.getTargets().get(0);
    if (target.getMaxNumberOfTargets() > 1) {
        if (target.getNumberOfTargets() < target.getNumberOfTargets()) {
            sb.append("String_Node_Str");
        }
        sb.append(CardUtil.numberToText(target.getMaxNumberOfTargets())).append("String_Node_Str").append(target.getTargetName()).append("String_Node_Str");
    } else {
        if (!target.getTargetName().toUpperCase().startsWith("String_Node_Str")) {
            sb.append("String_Node_Str");
        }
        sb.append(target.getTargetName()).append("String_Node_Str");
    }
    String p = power.toString();
    if (!p.startsWith("String_Node_Str")) {
        sb.append("String_Node_Str");
    }
    sb.append(p).append("String_Node_Str");
    String t = toughness.toString();
    if (!t.startsWith("String_Node_Str")) {
        if (p.startsWith("String_Node_Str")) {
            sb.append("String_Node_Str");
        } else {
            sb.append("String_Node_Str");
        }
    }
    sb.append(t);
    if (duration != Duration.WhileOnBattlefield) {
        sb.append("String_Node_Str").append(duration.toString());
    }
    String message = null;
    String fixedPart = null;
    if (t.equals("String_Node_Str")) {
        message = toughness.getMessage();
        fixedPart = "String_Node_Str";
    } else if (p.equals("String_Node_Str")) {
        message = power.getMessage();
        fixedPart = "String_Node_Str";
    } else if (!power.getMessage().isEmpty()) {
        message = power.getMessage();
        fixedPart = "String_Node_Str";
    } else if (!toughness.getMessage().isEmpty()) {
        message = toughness.getMessage();
        fixedPart = "String_Node_Str";
    }
    if (message != null && !message.isEmpty() && fixedPart != null) {
        sb.append(fixedPart).append(message);
    }
    return sb.toString();
}

Output:
     if (!t.startsWith("String_Node_Str")) {
-        if (p.startsWith("String_Node_Str")) {
+        if (t.equals("String_Node_Str") && p.startsWith("String_Node_Str")) {
             sb.append("String_Node_Str");


Input:
public int getPreferredWidth(int i, int i1) {
    return 105;
}

Output:
 public int getPreferredWidth(int i, int i1) {
-    return 105;
+    return width;
 }


Input:
public void testGetId() throws Exception {
    HDFSBlobStore store = new HDFSBlobStore(storeUri.toASCIIString());
    assertNotNull(store);
    assertEquals(storeUri, store.getId());
}

Output:
 public void testGetId() throws Exception {
-    HDFSBlobStore store = new HDFSBlobStore(storeUri.toASCIIString());
+    HDFSBlobStore store = new HDFSBlobStore(storeUri);
     assertNotNull(store);


Input:
public JoinInfo copy(boolean newRequest, Address newAddress) {
    return new JoinInfo(newRequest, newAddress, groupName, groupPassword, nodeType, packetVersion, buildNumber, memberCount);
}

Output:
 public JoinInfo copy(boolean newRequest, Address newAddress) {
-    return new JoinInfo(newRequest, newAddress, groupName, groupPassword, nodeType, packetVersion, buildNumber, memberCount);
+    return new JoinInfo(newRequest, newAddress, config, nodeType, packetVersion, buildNumber, memberCount);
 }


Input:
public double getRecall() {
    int tp = IntStream.of(truePositives).sum();
    int fp = IntStream.of(falsePositives).sum();
    int fn = IntStream.of(falseNegatives).sum();
    return ConfusionMatrixMeasures.recall(tp, fp, fn);
}

Output:
     int fn = IntStream.of(falseNegatives).sum();
-    return ConfusionMatrixMeasures.recall(tp, fp, fn);
+    return ConfusionMatrixMeasures.recall(tp, fn);
 }


Input:
public void performAction() {
    synchronized (lock) {
        AbstractFile file;
        AbstractFile otherFile;
        if ((file = mainFrame.getActiveTable().getSelectedFile(true)) == null)
            return;
        try {
            if (mainFrame.getActiveTable().isParentFolderSelected())
                otherFile = mainFrame.getInactiveTable().getCurrentFolder().getParentSilently();
            else {
                otherFile = mainFrame.getInactiveTable().getCurrentFolder().getDirectChild(file.getName());
                if (!(file.isBrowsable() == otherFile.isBrowsable()))
                    otherFile = null;
            }
        } catch (Exception e) {
            otherFile = null;
        }
        open(file, mainFrame.getActiveTable().getFolderPanel());
        if (!file.isBrowsable())
            open(otherFile, mainFrame.getInactiveTable().getFolderPanel());
        else if (otherFile != null && otherFile.exists()) {
            isWaiting = true;
            status = true;
            while (isWaiting) {
                try {
                    wait();
                } catch (Exception e) {
                }
            }
            if (status)
                open(otherFile, mainFrame.getInactiveTable().getFolderPanel());
        }
    }
}

Output:
 public void performAction() {
-    synchronized (lock) {
-        AbstractFile file;
-        AbstractFile otherFile;
-        if ((file = mainFrame.getActiveTable().getSelectedFile(true)) == null)
-            return;
-        try {
-            if (mainFrame.getActiveTable().isParentFolderSelected())
-                otherFile = mainFrame.getInactiveTable().getCurrentFolder().getParentSilently();
-            else {
-                otherFile = mainFrame.getInactiveTable().getCurrentFolder().getDirectChild(file.getName());
-                if (!(file.isBrowsable() == otherFile.isBrowsable()))
-                    otherFile = null;
-            }
-        } catch (Exception e) {
-            otherFile = null;
+    Thread openThread;
+    AbstractFile file;
+    AbstractFile otherFile;
+    if ((file = mainFrame.getActiveTable().getSelectedFile(true)) == null || !file.isBrowsable())
+        return;
+    try {
+        if (mainFrame.getActiveTable().isParentFolderSelected())
+            otherFile = mainFrame.getInactiveTable().getCurrentFolder().getParentSilently();
+        else {
+            otherFile = mainFrame.getInactiveTable().getCurrentFolder().getDirectChild(file.getName());
+            if (!otherFile.exists() && !otherFile.isBrowsable())
+                otherFile = null;
         }


Input:
public boolean shouldRetry(ConnectionState connectionState) {
    if (!retryAttempted) {
        retryAttempted = true;
        return true;
    } else {
        return false;
    }
}

Output:
 public boolean shouldRetry(ConnectionState connectionState) {
-    if (!retryAttempted) {
-        retryAttempted = true;
-        return true;
-    } else {
-        return false;
-    }
+    return connectionState.retryCount <= 1;
 }


Input:
public boolean apply(Game game, Ability source) {
    int affectedTargets = 0;
    for (UUID permanentId : targetPointer.getTargets(game, source)) {
        Permanent permanent = game.getPermanent(permanentId);
        if (permanent != null) {
            permanent.getAbilities().clear();
            affectedTargets++;
        }
    }
    return affectedTargets > 0;
}

Output:
         if (permanent != null) {
-            permanent.getAbilities().clear();
+            permanent.removeAllAbilities(source.getSourceId(), game);
             affectedTargets++;


Input:
private JointResultMetadata populatorJointResultMetadata(IResultClass left, String leftPrefix, IResultClass right, String rightPrefix) throws DataException {
    int[] index = new int[left.getFieldCount() + right.getFieldCount()];
    boolean[] isFromLeft = new boolean[left.getFieldCount() + right.getFieldCount()];
    List projectedColumns = new ArrayList();
    for (int i = 1; i <= left.getFieldCount(); i++) {
        index[i - 1] = i;
        isFromLeft[i - 1] = true;
        projectedColumns.add(new ResultFieldMetadata(i, leftPrefix + left.getFieldName(i), leftPrefix + left.getFieldName(i), left.getFieldValueClass(i), left.getFieldNativeTypeName(i), false));
    }
    for (int i = left.getFieldCount() + 1; i <= index.length; i++) {
        index[i - 1] = i - left.getFieldCount();
        isFromLeft[i - 1] = false;
        projectedColumns.add(new ResultFieldMetadata(i, rightPrefix + right.getFieldName(i - left.getFieldCount()), rightPrefix + right.getFieldName(i - left.getFieldCount()), right.getFieldValueClass(i - left.getFieldCount()), right.getFieldNativeTypeName(i - left.getFieldCount()), false));
    }
    ResultClass resultClass = new ResultClass(projectedColumns);
    return new JointResultMetadata(resultClass, isFromLeft, index);
}

Output:
 private JointResultMetadata populatorJointResultMetadata(IResultClass left, String leftPrefix, IResultClass right, String rightPrefix) throws DataException {
-    int[] index = new int[left.getFieldCount() + right.getFieldCount()];
-    boolean[] isFromLeft = new boolean[left.getFieldCount() + right.getFieldCount()];
+    int length = left.getFieldCount() + right.getFieldCount() + ((dataSet.getComputedColumns() == null) ? 0 : dataSet.getComputedColumns().size());
+    int[] index = new int[length];
+    int[] columnSource = new int[length];
     List projectedColumns = new ArrayList();


Input:
public Multimap deserialize(final JsonElement json, final Type typeOfT, final JsonDeserializationContext context) throws JsonParseException {
    final Multimap multimap = HashMultimap.create();
    final Map map = context.deserialize(json, createMapType(typeOfT));
    for (final Object key : map.keySet()) {
        final Collection values = (Collection) map.get(key);
        multimap.putAll(key, values);
    }
    return multimap;
}

Output:
     final Multimap multimap = HashMultimap.create();
-    final Map map = context.deserialize(json, createMapType(typeOfT));
-    for (final Object key : map.keySet()) {
-        final Collection values = (Collection) map.get(key);
-        multimap.putAll(key, values);
+    final Map<Object, Collection> map = context.deserialize(json, createMapType(typeOfT));
+    for (Entry<Object, Collection> entry : map.entrySet()) {
+        multimap.putAll(entry.getKey(), entry.getValue());
     }


Input:
public org.hl7.fhir.dstu2.model.Account convertAccount(org.hl7.fhir.dstu3.model.Account src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.Account tgt = new org.hl7.fhir.dstu2.model.Account();
    copyDomainResource(src, tgt);
    for (org.hl7.fhir.dstu3.model.Identifier t : src.getIdentifier()) tgt.addIdentifier(convertIdentifier(t));
    tgt.setName(src.getName());
    tgt.setType(convertCodeableConcept(src.getType()));
    tgt.setStatus(convertAccountStatus(src.getStatus()));
    tgt.setActivePeriod(convertPeriod(src.getActive()));
    tgt.setCurrency(convertCoding(src.getCurrency()));
    tgt.setBalance(convertMoney(src.getBalance()));
    tgt.setCoveragePeriod(convertPeriod(src.getCoveragePeriod()));
    tgt.setSubject(convertReference(src.getSubject()));
    tgt.setOwner(convertReference(src.getOwner()));
    tgt.setDescription(src.getDescription());
    return tgt;
}

Output:
 public org.hl7.fhir.dstu2.model.Account convertAccount(org.hl7.fhir.dstu3.model.Account src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
private void reloadAttributes(XSNamedMap attributeDeclarations) {
    Collection removedAttributes = new HashBag(this.attributeDeclarations.values());
    for (int i = attributeDeclarations.getLength() - 1; i >= 0; i--) {
        ExplicitAttributeDeclaration attribute = this.reloadAttribute((XSAttributeDecl) attributeDeclarations.item(i));
        removedAttributes.remove(attribute);
    }
    for (Iterator stream = removedAttributes.iterator(); stream.hasNext(); ) {
        this.removeAttribute((ExplicitAttributeDeclaration) stream.next());
    }
}

Output:
     for (int i = attributeDeclarations.getLength() - 1; i >= 0; i--) {
-        ExplicitAttributeDeclaration attribute = this.reloadAttribute((XSAttributeDecl) attributeDeclarations.item(i));
-        removedAttributes.remove(attribute);
+        XSAttributeDecl attrDecl = (XSAttributeDecl) attributeDeclarations.item(i);
+        String ns = attrDecl.getNamespace();
+        if (ns == null) {
+            ns = "String_Node_Str";
+        }
+        if (ns.equals(getNamespaceUrl())) {
+            ExplicitAttributeDeclaration attribute = this.reloadAttribute(attrDecl);
+            removedAttributes.remove(attribute);
+        }
     }


Input:
public void rollbackTransaction(AbstractSession session, AbstractSession callingSession) throws DatabaseException {
    getActiveBatchWritingMechanism().clear();
    super.rollbackTransaction(session, callingSession);
}

Output:
     getActiveBatchWritingMechanism().clear();
-    super.rollbackTransaction(session, callingSession);
+    super.rollbackTransaction(session);
 }


Input:
private void addListeners() {
    if (WindowSystem.isGTK() && forceDrawLinksGtk) {
        table.addListener(SWT.Paint, new Listener() {
            public void handleEvent(Event event) {
                paintEvent(event);
            }
        });
    }
    ControlListener controlListener = new ControlListener() {
        public void controlMoved(ControlEvent e) {
        }
        public void controlResized(ControlEvent e) {
            backgroundRefresher.refreshBackgroundWithLimiter();
        }
    };
    table.addControlListener(controlListener);
    if (tableViewerCreator != null) {
        tableViewerCreator.getSelectionHelper().addAfterSelectionListener(new ILineSelectionListener() {
            public void handle(LineSelectionEvent e) {
                controlsLinker.updateLinksStyleAndControlsSelection(table, true);
            }
        });
    } else {
        table.addSelectionListener(new SelectionListener() {
            public void widgetDefaultSelected(SelectionEvent e) {
            }
            public void widgetSelected(SelectionEvent e) {
                controlsLinker.updateLinksStyleAndControlsSelection(table, true);
            }
        });
    }
    ScrollBar vBarTable = table.getVerticalBar();
    SelectionListener scrollListener = new SelectionAdapter() {
        public void widgetSelected(SelectionEvent event) {
            backgroundRefresher.refreshBackgroundWithLimiter();
        }
    };
    vBarTable.addSelectionListener(scrollListener);
}

Output:
             }
-        });
+        };
+        table.addListener(SWT.Paint, tablePaintListener);
     }


Input:
public boolean containsLocation(Location location) throws IOException, ClassNotFoundException {
    while (location != null) {
        if (this.equals(location))
            return true;
        location = LocationResolver.getLocationResolver().getParent(location);
    }
    return false;
}

Output:
 public boolean containsLocation(Location location) throws IOException, ClassNotFoundException {
-    while (location != null) {
+    while (location != null && !location.isNone()) {
         if (this.equals(location))


Input:
public boolean await() {
    for (Integer port : this.ports) {
        if (!Ping.ping(this.ip, port, DEFAULT_POLL_ITERATIONS, DEFAULT_SLEEP_POLL_TIME, TimeUnit.MILLISECONDS)) {
            return false;
        }
    }
    return true;
}

Output:
     for (Integer port : this.ports) {
-        if (!Ping.ping(this.ip, port, DEFAULT_POLL_ITERATIONS, DEFAULT_SLEEP_POLL_TIME, TimeUnit.MILLISECONDS)) {
+        if (!Ping.ping(this.ip, port, this.pollIterations, this.sleepPollTime, TimeUnit.MILLISECONDS)) {
             return false;


Input:
public InputStream newInputStream(String fileName) throws IOException {
    Objects.requireNonNull(fileName);
    Path zipFilePath = getZipFilePath();
    if (Files.exists(zipFilePath)) {
        ZipFile zipFile = new ZipFile(zipFilePath);
        InputStream is = zipFile.getInputStream(fileName);
        if (is != null) {
            InputStream fis = new ForwardingInputStream<InputStream>(is) {
                public void close() throws IOException {
                    zipFile.close();
                }
            };
            return observer != null ? new ObservableInputStream(fis, zipFilePath + "String_Node_Str" + fileName, observer) : fis;
        } else {
            zipFile.close();
        }
    }
    return null;
}

Output:
     Path zipFilePath = getZipFilePath();
-    if (Files.exists(zipFilePath)) {
-        ZipFile zipFile = new ZipFile(zipFilePath);
-        InputStream is = zipFile.getInputStream(fileName);
-        if (is != null) {
-            InputStream fis = new ForwardingInputStream<InputStream>(is) {
-                public void close() throws IOException {
-                    zipFile.close();
-                }
-            };
-            return observer != null ? new ObservableInputStream(fis, zipFilePath + "String_Node_Str" + fileName, observer) : fis;
-        } else {
-            zipFile.close();
-        }
+    if (entryExists(zipFilePath, fileName)) {
+        InputStream is = new ZipEntryInputStream(new ZipFile(zipFilePath), fileName);
+        return observer != null ? new ObservableInputStream(is, zipFilePath + "String_Node_Str" + fileName, observer) : is;
     }


Input:
public static boolean tryMatchOrError(ArrayDeque<HtmlTagEntry> openStack, ArrayDeque<HtmlTagEntry> closeQueue, ErrorReporter errorReporter) {
    while (!openStack.isEmpty() && !closeQueue.isEmpty()) {
        HtmlTagEntry openTag = openStack.peekFirst();
        HtmlTagEntry closeTag = closeQueue.peekFirst();
        if (closeTag.isDefinitelyOptional()) {
            if (closeTag.getTagName().equals(openTag.getTagName())) {
                openStack.pollFirst();
                closeQueue.pollFirst();
                continue;
            }
            if (!openTag.hasTagName()) {
                return tryMatchCommonPrefix(openTag, closeTag, errorReporter);
            }
        }
        if (closeTag.hasTagName()) {
            while (!openStack.isEmpty()) {
                openTag = openStack.peekFirst();
                if (openTag.isDefinitelyOptional()) {
                    openStack.pollFirst();
                    continue;
                } else if (!openTag.hasTagName()) {
                    openTag.getBranches().popOptionalTags();
                    if (openTag.getBranches().isEmpty()) {
                        openStack.pollFirst();
                        continue;
                    }
                }
                break;
            }
        }
        if (matchOrError(openTag, closeTag, errorReporter)) {
            openStack.pollFirst();
            closeQueue.pollFirst();
        } else {
            return false;
        }
    }
    return true;
}

Output:
             if (!openTag.hasTagName()) {
-                return tryMatchCommonPrefix(openTag, closeTag, errorReporter);
+                if (tryMatchCommonPrefix(openTag, closeTag, errorReporter)) {
+                    openStack.pollFirst();
+                    closeQueue.pollFirst();
+                    return true;
+                }
+                return false;
             }