Input:
public void doPersist(JobInfos jobInfos, JobInfo jobInfo) {
    File file = jobInfo.getJobsFile();
    synchronized (file) {
        if (jobInfos == null)
            jobInfos = new JobInfos();
        try {
            JAXBContext jaxbContext = JAXBContext.newInstance(JobInfos.class);
            jaxbMarshaller = jaxbContext.createMarshaller();
            jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
            CopyOnWriteArrayList<JobInfo> jobList = new CopyOnWriteArrayList<JobInfo>(jobInfos.getJobInfoList());
            jobInfos.setJobInfoList(jobList);
            jobList.add(jobInfo);
            jaxbMarshaller.marshal(jobInfos, file);
            jobManager.addToCompletedJobs(new CompletedJob(jobInfo.jobId, jobInfo.commandCompletionDate, jobInfo.getJobsFile()));
            jobManager.purgeJob(jobInfo.jobId);
        } catch (JAXBException e) {
            throw new RuntimeException(adminStrings.getLocalString("String_Node_Str", "String_Node_Str", jobInfo.jobId, e.getLocalizedMessage()), e);
        }
    }
}

Output:
     synchronized (file) {
-        if (jobInfos == null)
+        if (jobInfos == null) {
             jobInfos = new JobInfos();


Input:
public void write(int address, int data, boolean word, long cycles) {
    int iAddress = address - offset;
    switch(iAddress) {
        case TR:
            setCounter(data, cycles);
            break;
        case TCTL:
            if (DEBUG) {
                System.out.println(getName() + "String_Node_Str" + Utils.hex16(data));
            }
            inputDivider = 1 << ((data >> 6) & 3);
            clockSource = srcMap[(data >> 8) & 3];
            cyclesMultiplicator = inputDivider;
            if (clockSource == SRC_ACLK) {
                cyclesMultiplicator = (cyclesMultiplicator * core.smclkFrq) / core.aclkFrq;
                if (DEBUG) {
                    System.out.println(getName() + "String_Node_Str" + cyclesMultiplicator);
                }
            }
            if ((data & TCLR) != 0) {
                counter = 0;
                counterStart = cycles;
                updateCaptures(-1, cycles);
            }
            int newMode = (data >> 4) & 3;
            if (mode == STOP && newMode != STOP) {
                updateCounter(cycles);
                nextTimerTrigger = (long) (cycles + cyclesMultiplicator * ((0xffff - counter) & 0xffff));
            }
            mode = newMode;
            interruptEnable = (data & 0x02) > 0;
            if (DEBUG) {
                System.out.println(getName() + "String_Node_Str" + name[type] + "String_Node_Str" + inputDivider + "String_Node_Str" + getSourceName(clockSource) + "String_Node_Str" + interruptEnable + "String_Node_Str" + interruptPending + "String_Node_Str" + mode + ((data & TCLR) != 0 ? "String_Node_Str" : "String_Node_Str"));
            }
            tctl = data;
            tctl &= ~0x04;
            if ((data & 0x01) == 0) {
                interruptPending = false;
            }
            updateCaptures(-1, cycles);
            break;
        case TCCTL0:
        case TCCTL1:
        case TCCTL2:
        case TCCTL3:
        case TCCTL4:
        case TCCTL5:
        case TCCTL6:
            int index = (iAddress - TCCTL0) / 2;
            tcctl[index] = data;
            outMode[index] = (data >> 5) & 7;
            captureOn[index] = (data & 0x100) > 0;
            sync[index] = (data & 0x800) > 0;
            inputSel[index] = (data >> 12) & 3;
            inputSrc[index] = srcMap[4 + index * 4 + inputSel[index]];
            capMode[index] = (data >> 14) & 3;
            triggerInterrupts();
            if (DEBUG) {
                System.out.println(getName() + "String_Node_Str" + index + "String_Node_Str" + Utils.hex16(data) + "String_Node_Str" + capNames[capMode[index]] + "String_Node_Str" + inputSel[index] + "String_Node_Str" + getSourceName(inputSrc[index]) + "String_Node_Str" + captureOn[index] + "String_Node_Str" + ((data & CC_IE) != 0));
            }
            updateCaptures(index, cycles);
            break;
        case TCCR0:
        case TCCR1:
        case TCCR2:
        case TCCR3:
        case TCCR4:
        case TCCR5:
        case TCCR6:
            index = (iAddress - TCCR0) / 2;
            tccr[index] = data;
            updateCounter(cycles);
            int diff = data - counter;
            if (diff < 0) {
                diff += 0x10000;
            }
            if (DEBUG) {
                System.out.println(getName() + "String_Node_Str" + index + "String_Node_Str" + Utils.hex16(data) + "String_Node_Str" + Utils.hex16(counter) + "String_Node_Str" + Utils.hex16(diff));
            }
            expCaptureTime[index] = cycles + (long) (cyclesMultiplicator * diff) - counterPassed;
            counterPassed = 0;
            if (DEBUG) {
                System.out.println(getName() + "String_Node_Str" + cycles + "String_Node_Str" + index + "String_Node_Str" + expCaptureTime[index] + "String_Node_Str" + counter + "String_Node_Str" + data + "String_Node_Str" + (100 * (cyclesMultiplicator * diff * 1L) / 2500000) / 100.0 + "String_Node_Str" + "String_Node_Str" + expCaptureTime[index]);
            }
            calculateNextEventTime(cycles);
    }
}

Output:
             if (mode == STOP && newMode != STOP) {
-                updateCounter(cycles);
+                initialCounter = counter;
+                counterStart = cycles;
                 nextTimerTrigger = (long) (cycles + cyclesMultiplicator * ((0xffff - counter) & 0xffff));


Input:
public void onCropPressed() {
    cropping = true;
    saveFilteredButton.setVisible(true);
    LOGGER.debug("String_Node_Str");
    if (cropRectangle == null) {
        cropRectangle = createDraggableRectangle(wholePane.getWidth() - 250, wholePane.getHeight() - 250, 500, 500);
        forCropping.getChildren().add(cropRectangle);
    } else {
        cropRectangle.setVisible(true);
        resizeHandleNW.setVisible(true);
        resizeHandleSE.setVisible(true);
    }
}

Output:
     if (cropRectangle == null) {
-        cropRectangle = createDraggableRectangle(wholePane.getWidth() - 250, wholePane.getHeight() - 250, 500, 500);
+        cropRectangle = createDraggableRectangle(forCropping.getWidth() - 400, forCropping.getHeight() - 400, 100, 100);
         forCropping.getChildren().add(cropRectangle);


Input:
public UuidConfiguration withImmutability(boolean immutability) {
    return new UuidConfiguration(getInclusionPolicies(), initializeUntil(), getUuidGenerator(), getUuidProperty(), stripHyphens, getUuidIndex(), getUuidRelationshipIndex(), immutability);
}

Output:
 public UuidConfiguration withImmutability(boolean immutability) {
-    return new UuidConfiguration(getInclusionPolicies(), initializeUntil(), getUuidGenerator(), getUuidProperty(), stripHyphens, getUuidIndex(), getUuidRelationshipIndex(), immutability);
+    return new UuidConfiguration(getInclusionPolicies(), initializeUntil(), getUuidGenerator(), getUuidProperty(), shouldStripHyphens(), getUuidIndex(), getUuidRelationshipIndex(), immutability);
 }


Input:
private void makeScreenshot() {
    Image screenshot = new Image(browser.getShell().getDisplay(), browser.getShell().getBounds());
    GC gc = new GC(browser.getShell().getDisplay());
    gc.copyArea(screenshot, 730, 150);
    gc.dispose();
    ImageLoader loader = new ImageLoader();
    loader.data = new ImageData[] { screenshot.getImageData() };
    loader.save(GeneralManager.CALEYDO_HOME_PATH + "String_Node_Str", SWT.IMAGE_PNG);
    screenshot.dispose();
}

Output:
     GC gc = new GC(browser.getShell().getDisplay());
-    gc.copyArea(screenshot, 730, 150);
+    gc.copyArea(screenshot, 743, 143);
     gc.dispose();


Input:
public void onBackPressed() {
    super.onBackPressed();
    FragmentManager fm = getFragmentManager();
    if (fm.getBackStackEntryCount() != 0) {
        String stackName = fm.getBackStackEntryAt(fm.getBackStackEntryCount() - 1).getName();
        mDrawerList.setItemChecked(Integer.parseInt(stackName), true);
        mDrawerList.setSelection(Integer.parseInt(stackName));
    }
}

Output:
         String stackName = fm.getBackStackEntryAt(fm.getBackStackEntryCount() - 1).getName();
-        mDrawerList.setItemChecked(Integer.parseInt(stackName), true);
-        mDrawerList.setSelection(Integer.parseInt(stackName));
+        switchToPosition = Integer.parseInt(stackName);
+    }
+    mDrawerList.setItemChecked(switchToPosition, true);
+    mDrawerList.setSelection(switchToPosition);
+    ActionBar actionBar = getActionBar();
+    if (actionBar != null) {
+        actionBar.setTitle(mDrawerListItems[switchToPosition]);
     }


Input:
public File correct(String replicaId, String checksum, File file, String credentials) throws IOFailure, ArgumentNotValid {
    ArgumentNotValid.checkNotNullOrEmpty(replicaId, "String_Node_Str");
    ArgumentNotValid.checkNotNullOrEmpty(checksum, "String_Node_Str");
    ArgumentNotValid.checkNotNull(file, "String_Node_Str");
    ArgumentNotValid.checkNotNullOrEmpty(credentials, "String_Node_Str");
    RemoteFile rm = RemoteFileFactory.getCopyfileInstance(file);
    CorrectMessage correctMsg = new CorrectMessage(Channels.getTheRepos(), replyQ, checksum, rm, replicaId, credentials);
    CorrectMessage responseMessage = (CorrectMessage) sendAndWaitForOneReply(correctMsg, getTimeout);
    if (responseMessage == null) {
        throw new IOFailure("String_Node_Str" + "String_Node_Str");
    } else if (!responseMessage.isOk()) {
        throw new IOFailure("String_Node_Str" + responseMessage.getErrMsg());
    }
    RemoteFile removedFile = responseMessage.getRemovedFile();
    try {
        File destFile = new File(FileUtils.getTempDir(), removedFile.getName());
        removedFile.copyTo(destFile);
        return destFile;
    } catch (Throwable e) {
        String errMsg = "String_Node_Str" + "String_Node_Str";
        log.warn(errMsg, e);
        throw new IOFailure(errMsg, e);
    }
}

Output:
     CorrectMessage correctMsg = new CorrectMessage(Channels.getTheRepos(), replyQ, checksum, rm, replicaId, credentials);
-    CorrectMessage responseMessage = (CorrectMessage) sendAndWaitForOneReply(correctMsg, getTimeout);
+    CorrectMessage responseMessage = (CorrectMessage) sendAndWaitForOneReply(correctMsg, 0);
     if (responseMessage == null) {


Input:
public void testBytesPassThru() {
    byte[] payload = "String_Node_Str".getBytes();
    Message<byte[]> message = MessageBuilder.withPayload(payload).build();
    Message<?> converted = messageBus.serializePayloadIfNecessary(message, MediaType.APPLICATION_OCTET_STREAM);
    assertSame(payload, converted.getPayload());
    assertEquals(MediaType.APPLICATION_OCTET_STREAM, contentTypeResolver.resolve(converted.getHeaders()));
    Message<?> reconstructed = messageBus.deserializePayloadIfNecessary(converted);
    payload = (byte[]) reconstructed.getPayload();
    assertSame(converted.getPayload(), payload);
    assertNull(reconstructed.getHeaders().get(MessageBusSupport.ORIGINAL_CONTENT_TYPE_HEADER));
}

Output:
     Message<byte[]> message = MessageBuilder.withPayload(payload).build();
-    Message<?> converted = messageBus.serializePayloadIfNecessary(message, MediaType.APPLICATION_OCTET_STREAM);
+    Message<?> converted = messageBus.serializePayloadIfNecessary(message, MimeTypeUtils.APPLICATION_OCTET_STREAM);
     assertSame(payload, converted.getPayload());


Input:
protected ElementParameterType getParameterType(NodeType node, String paramName) {
    ElementParameterType paramType = ParameterUtilTool.findParameterType(node, paramName);
    if (node != null && paramType != null) {
        Object value = ParameterUtilTool.convertParameterValue(paramType);
        if ("String_Node_Str".equals(paramName)) {
            ElementParameterType csvOption = ParameterUtilTool.findParameterType(node, "String_Node_Str");
            if (csvOption != null && Boolean.valueOf(String.valueOf(ParameterUtilTool.convertParameterValue(csvOption)))) {
                ElementParameterType csvRowSeparator = ParameterUtilTool.findParameterType(node, "String_Node_Str");
                paramType.setValue(String.valueOf(ParameterUtilTool.convertParameterValue(csvRowSeparator)));
            }
        } else if ("String_Node_Str".equals(paramName) && "String_Node_Str".equals(node.getComponentName())) {
            ElementParameterType useStream = ParameterUtilTool.findParameterType(node, "String_Node_Str");
            if (Boolean.valueOf(String.valueOf(ParameterUtilTool.convertParameterValue(useStream)))) {
                ElementParameterType streamName = ParameterUtilTool.findParameterType(node, "String_Node_Str");
                paramType.setValue(String.valueOf(ParameterUtilTool.convertParameterValue(streamName)));
            }
        }
    }
    return paramType;
}

Output:
         if ("String_Node_Str".equals(paramName)) {
-            ElementParameterType csvOption = ParameterUtilTool.findParameterType(node, "String_Node_Str");
-            if (csvOption != null && Boolean.valueOf(String.valueOf(ParameterUtilTool.convertParameterValue(csvOption)))) {
+            if ("String_Node_Str".equals(String.valueOf(value))) {
                 ElementParameterType csvRowSeparator = ParameterUtilTool.findParameterType(node, "String_Node_Str");


Input:
public HearthTreeNode applyEffect(PlayerSide targetSide, HearthTreeNode boardState) {
    if (boardState.data_.modelForSide(targetSide).isHandFull()) {
        return null;
    }
    try {
        Card newCard = this.cardClass.newInstance();
        boardState.data_.placeCardHand(targetSide, newCard);
    } catch (InstantiationException | IllegalAccessException e) {
        logger.error("String_Node_Str", e);
    }
    return boardState;
}

Output:
     if (boardState.data_.modelForSide(targetSide).isHandFull()) {
-        return null;
+        return boardState;
     }


Input:
public Descriptor<TagAction> getDescriptor() {
    return Hudson.getInstance().getDescriptorOrDie(getClass());
}

Output:
 public Descriptor<TagAction> getDescriptor() {
-    return Hudson.getInstance().getDescriptorOrDie(getClass());
+    return Hudson.getInstance().getDescriptorOrDie(TagAction.class);
 }


Input:
public void findScenario() {
    testScenario = TestScenarioRepository.findScenario(criteria);
}

Output:
 public void findScenario() {
-    testScenario = TestScenarioRepository.findScenario(criteria);
+    if (testScenario == null) {
+        testScenario = TestScenarioRepository.findScenario(criteria);
+    }
 }


Input:
private void flushRootObjectMap(HashMap rootObjectMap) throws RepositoryException {
    Iterator iterator = rootObjectMap.values().iterator();
    while (iterator.hasNext()) {
        IRootObject rootObject = (IRootObject) iterator.next();
        ChangeHandler ch = rootObject.getChangeHandler();
        if (ch != null) {
            ch.rootObjectIsFlushed();
        }
        iterator.remove();
    }
}

Output:
     while (iterator.hasNext()) {
-        IRootObject rootObject = (IRootObject) iterator.next();
+        IRootObject rootObject = iterator.next();
         ChangeHandler ch = rootObject.getChangeHandler();


Input:
public boolean isSubtype(JSType that) {
    if (JSType.isSubtypeHelper(this, that)) {
        return true;
    }
    if (that.isUnionType()) {
        return false;
    }
    if (that.isRecordType()) {
        return RecordType.isSubtype(this, that.toMaybeRecordType());
    }
    ObjectType thatObj = that.toObjectType();
    FunctionType thatCtor = thatObj == null ? null : thatObj.getConstructor();
    if (getConstructor() != null && getConstructor().isInterface()) {
        for (ObjectType thisInterface : getCtorExtendedInterfaces()) {
            if (thisInterface.isSubtype(that)) {
                return true;
            }
        }
    } else if (thatCtor != null && thatCtor.isInterface()) {
        Iterable<ObjectType> thisInterfaces = getCtorImplementedInterfaces();
        for (ObjectType thisInterface : thisInterfaces) {
            if (thisInterface.isSubtype(that)) {
                return true;
            }
        }
    }
    if (isUnknownType() || implicitPrototypeChainIsUnknown()) {
        return true;
    }
    return thatObj != null && this.isImplicitPrototype(thatObj);
}

Output:
     }
-    return thatObj != null && this.isImplicitPrototype(thatObj);
+    return thatObj != null && isImplicitPrototype(thatObj);
 }


Input:
public int doSuccessSolution(String md5) {
    File permDir = new File(mContext.getFilesDir().getAbsoluteFile(), "String_Node_Str");
    if (permDir.exists() == true) {
        File outFile = new File(permDir, md5);
        if (outFile.exists() == true) {
            System.load(outFile.getAbsolutePath());
            int nRet = jmain(0);
            junmain(getClass());
            return nRet;
        }
    }
    return Constants.ROOT_FAILED_SOLUTION_FILE_NOT_EXISTS;
}

Output:
 public int doSuccessSolution(String md5) {
-    File permDir = new File(mContext.getFilesDir().getAbsoluteFile(), "String_Node_Str");
-    if (permDir.exists() == true) {
-        File outFile = new File(permDir, md5);
-        if (outFile.exists() == true) {
-            System.load(outFile.getAbsolutePath());
-            int nRet = jmain(0);
-            junmain(getClass());
-            return nRet;
-        }
+    NativeHelper.copyNativeLib(mContext, "String_Node_Str");
+    String filePath = mContext.getFilesDir().getAbsoluteFile() + "String_Node_Str" + md5;
+    File outFile = new File(filePath);
+    if (outFile.exists() == true) {
+        System.load(filePath);
+        int nRet = jmain(0);
+        junmain(getClass());
+        return nRet;
     }


Input:
public void onEnable() {
    this.commandsManager.register(new ru.tehkode.permissions.bukkit.commands.PermissionsCommand());
    this.registerEvents();
    logger.log(Level.INFO, "String_Node_Str" + this.getDescription().getVersion() + "String_Node_Str" + this.getDescription().getVersion() + "String_Node_Str");
}

Output:
     this.commandsManager.register(new ru.tehkode.permissions.bukkit.commands.PermissionsCommand());
-    this.registerEvents();
+    this.registerModifyworld();
     logger.log(Level.INFO, "String_Node_Str" + this.getDescription().getVersion() + "String_Node_Str" + this.getDescription().getVersion() + "String_Node_Str");


Input:
private JoinNode getOrCreate(JoinNode baseNode, String joinRelationName, Type<?> joinRelationType, String treatType, String alias, JoinType type, String errorMessage, boolean implicit, boolean defaultJoin, Attribute<?, ?> attribute) {
    JoinTreeNode treeNode = baseNode.getOrCreateTreeNode(joinRelationName, attribute);
    JoinNode node = treeNode.getJoinNode(alias, defaultJoin);
    String qualificationExpression = null;
    if (attribute instanceof QualifiedAttribute) {
        qualificationExpression = ((QualifiedAttribute) attribute).getQualificationExpression();
    }
    EntityType<?> treatJoinType;
    String currentJoinPath;
    if (treatType != null) {
        treatJoinType = metamodel.getEntity(treatType);
        currentJoinPath = "String_Node_Str" + baseNode.getAliasInfo().getAbsolutePath() + "String_Node_Str" + joinRelationName + "String_Node_Str" + treatJoinType.getName() + "String_Node_Str";
    } else {
        treatJoinType = null;
        currentJoinPath = baseNode.getAliasInfo().getAbsolutePath() + "String_Node_Str" + joinRelationName;
    }
    if (node == null) {
        checkAliasIsAvailable(alias, currentJoinPath, errorMessage);
        if (implicit && aliasManager.getAliasInfo(alias) != null) {
            alias = aliasManager.generateJoinAlias(alias);
        }
        JoinAliasInfo newAliasInfo = new JoinAliasInfo(alias, currentJoinPath, implicit, false, aliasManager);
        aliasManager.registerAliasInfo(newAliasInfo);
        node = JoinNode.createAssociationJoinNode(baseNode, treeNode, type, joinRelationType, treatJoinType, qualificationExpression, newAliasInfo);
        newAliasInfo.setJoinNode(node);
        treeNode.addJoinNode(node, defaultJoin);
    } else {
        JoinAliasInfo nodeAliasInfo = node.getAliasInfo();
        if (!alias.equals(nodeAliasInfo.getAlias())) {
            if (nodeAliasInfo.isImplicit() && !implicit) {
                aliasManager.unregisterAliasInfoForBottomLevel(nodeAliasInfo);
                nodeAliasInfo.setAlias(alias);
                nodeAliasInfo.setImplicit(false);
                node.setJoinType(type);
                aliasManager.registerAliasInfo(nodeAliasInfo);
            } else if (!nodeAliasInfo.isImplicit() && !implicit) {
                throw new IllegalArgumentException("String_Node_Str" + nodeAliasInfo.getAlias() + "String_Node_Str" + nodeAliasInfo.getAbsolutePath() + "String_Node_Str" + alias + "String_Node_Str" + currentJoinPath + "String_Node_Str");
            }
        }
        if (treatJoinType != null) {
            if (node.getTreatType() == null) {
                node = node.getTreatedJoinNode(treatJoinType);
            } else if (!treatJoinType.equals(node.getTreatType())) {
                throw new IllegalArgumentException("String_Node_Str" + nodeAliasInfo.getAlias() + "String_Node_Str" + nodeAliasInfo.getAbsolutePath() + "String_Node_Str" + "String_Node_Str" + treatType + "String_Node_Str" + node.getTreatType() + "String_Node_Str");
            }
        }
    }
    return node;
}

Output:
     if (attribute instanceof QualifiedAttribute) {
-        qualificationExpression = ((QualifiedAttribute) attribute).getQualificationExpression();
+        QualifiedAttribute qualifiedAttribute = (QualifiedAttribute) attribute;
+        qualificationExpression = qualifiedAttribute.getQualificationExpression();
+        qualifiedJoinPath = joinRelationName.substring(0, qualificationExpression.length() + 1) + baseNode.getAliasInfo().getAbsolutePath() + "String_Node_Str" + joinRelationName.substring(qualificationExpression.length() + 1);
+    } else {
+        qualifiedJoinPath = baseNode.getAliasInfo().getAbsolutePath() + "String_Node_Str" + joinRelationName;
     }


Input:
public File performExport(RepositoryFile exportRepositoryFile) throws ExportException, IOException {
    File exportFile = null;
    exportFile = File.createTempFile(EXPORT_TEMP_FILENAME_PREFIX, EXPORT_TEMP_FILENAME_EXT);
    exportFile.deleteOnExit();
    String filePath = new File(this.path).getParent();
    if (filePath == null) {
        filePath = "String_Node_Str";
    }
    if (exportRepositoryFile == null) {
        throw new FileNotFoundException("String_Node_Str" + this.path);
    }
    ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(exportFile));
    if (exportRepositoryFile.isFolder()) {
        exportManifest.getManifestInformation().setRootFolder(path.substring(0, path.lastIndexOf("String_Node_Str") + 1));
        if (!ClientRepositoryPaths.getRootFolderPath().equals(exportRepositoryFile.getPath())) {
            zos.putNextEntry(new ZipEntry(ExportFileNameEncoder.encodeZipPathName(getZipEntryName(exportRepositoryFile, filePath))));
        }
        exportDirectory(exportRepositoryFile, zos, filePath);
    } else {
        exportManifest.getManifestInformation().setRootFolder(path.substring(0, path.lastIndexOf("String_Node_Str") + 1));
        exportFile(exportRepositoryFile, zos, filePath);
    }
    if (this.withManifest) {
        ZipEntry entry = new ZipEntry(EXPORT_MANIFEST_FILENAME);
        zos.putNextEntry(entry);
        try {
            exportManifest.toXml(zos);
        } catch (Exception e) {
            log.error("String_Node_Str");
        }
        zos.closeEntry();
    }
    zos.close();
    exportManifest = null;
    zos = null;
    return exportFile;
}

Output:
         if (!ClientRepositoryPaths.getRootFolderPath().equals(exportRepositoryFile.getPath())) {
-            zos.putNextEntry(new ZipEntry(ExportFileNameEncoder.encodeZipPathName(getZipEntryName(exportRepositoryFile, filePath))));
+            zos.putNextEntry(new ZipEntry(getFixedZipEntryName(exportRepositoryFile, filePath)));
         }


Input:
public AbstractRelationshipType getRelationshipType(QName relationshipTypeId) {
    for (AbstractRelationshipType relationshipType : this.getRelationshipTypes()) {
        if (relationshipType.getId().toString().equals(relationshipTypeId.toString())) {
            return relationshipType;
        }
    }
    return null;
}

Output:
     for (AbstractRelationshipType relationshipType : this.getRelationshipTypes()) {
-        if (relationshipType.getId().toString().equals(relationshipTypeId.toString())) {
+        if (relationshipType.getId().equals(relationshipTypeId)) {
             return relationshipType;


Input:
public int getInt(String key) {
    if (properties != null)
        return (int) properties.get(key);
    else
        return root == null ? 0 : root.get(key).asInt();
}

Output:
 public int getInt(String key) {
-    if (properties != null)
-        return (int) properties.get(key);
-    else
-        return root == null ? 0 : root.get(key).asInt();
+    if (properties != null) {
+        Object obj = properties.get(key);
+        if (obj != null && obj instanceof Number)
+            return ((Number) obj).intValue();
+        else
+            return 0;
+    } else {
+        if (root == null)
+            return 0;
+        else {
+            FLValue flvalue = root.get(key);
+            if (flvalue.getType() == kFLNumber)
+                return flvalue.asInt();
+            else
+                return 0;
+        }
+    }
 }


Input:
public void handleSwipe(View view) {
    TaskDescription ad = ((ViewHolder) view.getTag()).taskDescription;
    if (ad == null) {
        Log.v(TAG, "String_Node_Str" + view + "String_Node_Str" + view.getTag());
        return;
    }
    if (DEBUG)
        Log.v(TAG, "String_Node_Str" + ad.getLabel());
    mRecentTaskDescriptions.remove(ad);
    mRecentTasksLoader.remove(ad);
    if (mRecentTaskDescriptions.size() == 0) {
        dismissAndGoBack();
    }
    final ActivityManager am = (ActivityManager) getContext().getSystemService(Context.ACTIVITY_SERVICE);
    if (am != null) {
        am.removeTask(ad.persistentTaskId, ActivityManager.REMOVE_TASK_KILL_PROCESS);
        setContentDescription(getContext().getString(R.string.accessibility_recents_item_dismissed, ad.getLabel()));
        sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_SELECTED);
        setContentDescription(null);
    }
}

Output:
     if (am != null) {
-        am.removeTask(ad.persistentTaskId, ActivityManager.REMOVE_TASK_KILL_PROCESS);
+        am.removeTask(ad.persistentTaskId);
         setContentDescription(getContext().getString(R.string.accessibility_recents_item_dismissed, ad.getLabel()));


Input:
public void setUp() throws Exception {
    cx = Context.enter();
    scope = cx.initStandardObjects();
    ScriptableObject.putProperty(scope, "String_Node_Str", new BirtMath());
}

Output:
     scope = cx.initStandardObjects();
-    ScriptableObject.putProperty(scope, "String_Node_Str", new BirtMath());
+    new CoreJavaScriptInitializer().initialize(cx, scope);
 }


Input:
public void testParsingBlankImport_538() throws Exception {
    runNegativeTest(new String[] { "String_Node_Str", "String_Node_Str" }, "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
    ModuleNode mn = getModuleNode("String_Node_Str");
    assertNotNull(mn);
    assertFalse(mn.encounteredUnrecoverableError());
    List<ImportNode> imports = mn.getImports();
    ImportNode brokenImportNode = imports.get(0);
    assertEquals(0, brokenImportNode.getStart());
    assertEquals(6, brokenImportNode.getEnd());
    assertEquals("String_Node_Str", brokenImportNode.getType().getName());
    ClassNode cn = mn.getClasses().get(0);
    assertNotNull(cn);
    assertTrue(cn.getName().equals("String_Node_Str"));
}

Output:
     List<ImportNode> imports = mn.getImports();
-    ImportNode brokenImportNode = imports.get(0);
-    assertEquals(0, brokenImportNode.getStart());
-    assertEquals(6, brokenImportNode.getEnd());
-    assertEquals("String_Node_Str", brokenImportNode.getType().getName());
+    ImportNode recoveredImport = imports.get(0);
+    assertEquals(0, recoveredImport.getStart());
+    assertEquals(7, recoveredImport.getEnd());
+    assertEquals("String_Node_Str", recoveredImport.getType().getName());
     ClassNode cn = mn.getClasses().get(0);


Input:
public void testCombine() throws Exception {
    CDXIndexCache cache = new CDXIndexCache();
    Map<Long, File> files = new HashMap<Long, File>();
    files.put(4L, TestInfo.METADATA_FILE_4);
    files.put(3L, TestInfo.METADATA_FILE_3);
    cache.combine(files);
    File cacheFile = cache.getCacheFile(files.keySet());
    FileAsserts.assertFileNumberOfLines("String_Node_Str", cacheFile, (int) FileUtils.countLines(TestInfo.METADATA_FILE_3) + (int) FileUtils.countLines(TestInfo.METADATA_FILE_4));
    FileAsserts.assertFileContains("String_Node_Str", "String_Node_Str", cacheFile);
}

Output:
     files.put(3L, TestInfo.METADATA_FILE_3);
-    cache.combine(files);
+    Set<Long> requiredSet = new HashSet<Long>();
+    requiredSet.add(3L);
+    requiredSet.add(4L);
+    cache.combine(files, requiredSet);
     File cacheFile = cache.getCacheFile(files.keySet());


Input:
public boolean hasSideEffects() {
    if (field.isStatic() && (!field.isFinal() || field.constInitializer == null)) {
        JReferenceType fieldEncloser = field.getEnclosingType();
        if (enclosingType != fieldEncloser && program.typeOracle.hasClinit(fieldEncloser)) {
            return true;
        }
    }
    JExpression expr = instance;
    if (expr == null) {
        return false;
    }
    return expr.hasSideEffects();
}

Output:
     if (field.isStatic() && (!field.isFinal() || field.constInitializer == null)) {
-        JReferenceType fieldEncloser = field.getEnclosingType();
-        if (enclosingType != fieldEncloser && program.typeOracle.hasClinit(fieldEncloser)) {
+        if (program.typeOracle.checkClinit(enclosingType, field.getEnclosingType())) {
             return true;


Input:
public org.hl7.fhir.dstu2.model.ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent convertImmunizationRecommendationRecommendationComponent(org.hl7.fhir.dstu3.model.ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent tgt = new org.hl7.fhir.dstu2.model.ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent();
    copyElement(src, tgt);
    tgt.setDate(src.getDate());
    tgt.setVaccineCode(convertCodeableConcept(src.getVaccineCode()));
    tgt.setDoseNumber(src.getDoseNumber());
    tgt.setForecastStatus(convertCodeableConcept(src.getForecastStatus()));
    for (org.hl7.fhir.dstu3.model.ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent t : src.getDateCriterion()) tgt.addDateCriterion(convertImmunizationRecommendationRecommendationDateCriterionComponent(t));
    tgt.setProtocol(convertImmunizationRecommendationRecommendationProtocolComponent(src.getProtocol()));
    for (org.hl7.fhir.dstu3.model.Reference t : src.getSupportingImmunization()) tgt.addSupportingImmunization(convertReference(t));
    for (org.hl7.fhir.dstu3.model.Reference t : src.getSupportingPatientInformation()) tgt.addSupportingPatientInformation(convertReference(t));
    return tgt;
}

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


Input:
public static void logError(String message, Object... data) {
    Log.error(prefixError + message, data);
}

Output:
 public static void logError(String message, Object... data) {
-    Log.error(prefixError + message, data);
+    Log.info(prefixError + message, data);
 }


Input:
public void shellClosed(ShellEvent e) {
    UIManager uiManager = mapperManager.getUiManager();
    if (uiManager.getMapperResponse() == SWT.NONE) {
        for (DataMapTableView dataMapTableView : uiManager.getInputsTablesView()) {
            dataMapTableView.notifyFocusLost();
        }
        for (DataMapTableView dataMapTableView : uiManager.getOutputsTablesView()) {
            dataMapTableView.notifyFocusLost();
        }
        for (DataMapTableView dataMapTableView : uiManager.getVarsTablesView()) {
            dataMapTableView.notifyFocusLost();
        }
        uiManager.setMapperResponse(SWT.CANCEL);
        uiManager.prepareClosing(uiManager.getMapperResponse());
    }
    if (mapperManager.isDataChanged() && !mapperManager.getUiManager().isCloseWithoutPrompt()) {
        boolean closeWindow = MessageDialog.openConfirm(mapperShellFinal, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"));
        if (!closeWindow) {
            e.doit = false;
        } else {
            mapperManager.getAbstractMapComponent().setExternalData(mapperManager.getOriginalExternalData());
            mapperManager.getUiManager().prepareClosing(SWT.CANCEL);
        }
    }
}

Output:
     }
-    if (mapperManager.isDataChanged() && !mapperManager.getUiManager().isCloseWithoutPrompt()) {
+    if (!mapperManager.componentIsReadOnly() && mapperManager.isDataChanged() && !mapperManager.getUiManager().isCloseWithoutPrompt()) {
         boolean closeWindow = MessageDialog.openConfirm(mapperShellFinal, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"));


Input:
public void updatePartRevisionACL(String workspaceId, PartRevisionKey revisionKey, Map<String, String> pACLUserEntries, Map<String, String> pACLUserGroupEntries) throws UserNotFoundException, UserNotActiveException, WorkspaceNotFoundException, PartRevisionNotFoundException, AccessRightException, DocumentRevisionNotFoundException {
    User user = userManager.checkWorkspaceReadAccess(workspaceId);
    Locale locale = new Locale(user.getLanguage());
    ACLFactory aclFactory = new ACLFactory(em);
    PartRevisionDAO partRevisionDAO = new PartRevisionDAO(locale, em);
    PartRevision partRevision = partRevisionDAO.loadPartR(revisionKey);
    if (isAuthor(user, partRevision) || user.isAdministrator()) {
        if (partRevision.getACL() == null) {
            ACL acl = aclFactory.createACL(workspaceId, pACLUserEntries, pACLUserGroupEntries);
            partRevision.setACL(acl);
        } else {
            aclFactory.updateACL(partRevision.getACL(), pACLUserEntries, pACLUserGroupEntries);
        }
    } else {
        throw new AccessRightException(locale, user);
    }
}

Output:
         } else {
-            aclFactory.updateACL(partRevision.getACL(), pACLUserEntries, pACLUserGroupEntries);
+            aclFactory.updateACL(workspaceId, partRevision.getACL(), pACLUserEntries, pACLUserGroupEntries);
         }


Input:
public List<DavResource> getResources(String url) throws SardineException {
    HttpPropFind propFind = new HttpPropFind(url);
    propFind.setEntity(SardineUtil.getResourcesEntity());
    HttpResponse response = this.executeWrapper(propFind);
    StatusLine statusLine = response.getStatusLine();
    if (!SardineUtil.isGoodResponse(statusLine.getStatusCode()))
        throw new SardineException("String_Node_Str", url, statusLine.getStatusCode(), statusLine.getReasonPhrase());
    Multistatus multistatus = SardineUtil.getMulitstatus(this.factory.getUnmarshaller(), response, url);
    List<Response> responses = multistatus.getResponse();
    List<DavResource> resources = new ArrayList<DavResource>(responses.size());
    int firstSlash = url.indexOf('/', 8);
    String baseUrl = null;
    if (url.endsWith("String_Node_Str"))
        baseUrl = url.substring(firstSlash);
    String hostPart = url.substring(0, firstSlash);
    for (Response resp : responses) {
        boolean currentDirectory = false;
        boolean isDirectory = false;
        String href = resp.getHref().get(0);
        String name = null;
        if (baseUrl != null) {
            if ((href.length() == baseUrl.length() - 1) && baseUrl.endsWith("String_Node_Str")) {
                href += "String_Node_Str";
            }
            if (href.startsWith(hostPart)) {
                name = href.substring(hostPart.length() + baseUrl.length());
            } else
                name = href.substring(baseUrl.length());
            if ("String_Node_Str".equals(name) || (name.length() == 0)) {
                isDirectory = true;
                currentDirectory = true;
            }
        } else {
            int last = href.lastIndexOf("String_Node_Str") + 1;
            name = href.substring(last);
            baseUrl = href.substring(0, last);
        }
        if (name.equals("String_Node_Str"))
            continue;
        if (name.endsWith("String_Node_Str")) {
            name = name.substring(0, name.length() - 1);
            isDirectory = true;
        }
        Prop prop = resp.getPropstat().get(0).getProp();
        String creationdate = null;
        Creationdate gcd = prop.getCreationdate();
        if ((gcd != null) && (gcd.getContent().size() == 1))
            creationdate = gcd.getContent().get(0);
        String modifieddate = null;
        Getlastmodified glm = prop.getGetlastmodified();
        if ((glm != null) && (glm.getContent().size() == 1))
            modifieddate = glm.getContent().get(0);
        else
            modifieddate = creationdate;
        String contentType = null;
        Getcontenttype gtt = prop.getGetcontenttype();
        if ((gtt != null) && (gtt.getContent().size() == 1))
            contentType = gtt.getContent().get(0);
        if (isDirectory && (contentType == null)) {
            contentType = "String_Node_Str";
        }
        String contentLength = "String_Node_Str";
        Getcontentlength gcl = prop.getGetcontentlength();
        if ((gcl != null) && (gcl.getContent().size() == 1))
            contentLength = gcl.getContent().get(0);
        DavResource dr = new DavResource(hostPart + baseUrl, name, SardineUtil.parseDate(creationdate), SardineUtil.parseDate(modifieddate), contentType, Long.valueOf(contentLength), currentDirectory);
        resources.add(dr);
    }
    return resources;
}

Output:
     StatusLine statusLine = response.getStatusLine();
-    if (!SardineUtil.isGoodResponse(statusLine.getStatusCode()))
+    if (!SardineUtil.isGoodResponse(statusLine.getStatusCode())) {
+        propFind.abort();
         throw new SardineException("String_Node_Str", url, statusLine.getStatusCode(), statusLine.getReasonPhrase());


Input:
private static Map<String, List<Object>> extractMultiValuedIdentifiers(ResourceMapping mapping, AmazonWebServiceRequest request, Object result) {
    Map<String, List<Object>> ids = new HashMap<>();
    int listSize = -1;
    for (PathSourceMapping m : mapping.getRequestParamMappings()) {
        List<Object> values = ReflectionUtils.getAllByPath(request, m.getSource());
        if (listSize == -1) {
            listSize = values.size();
        } else if (values.size() != listSize) {
            throw new IllegalStateException("String_Node_Str" + listSize + "String_Node_Str" + values.size());
        }
        ids.put(m.getTarget(), values);
    }
    for (PathSourceMapping m : mapping.getResponseIdentifierMappings()) {
        List<Object> values = ReflectionUtils.getAllByPath(result, m.getSource());
        if (listSize == -1) {
            listSize = values.size();
        } else if (values.size() != listSize) {
            throw new IllegalStateException("String_Node_Str" + listSize + "String_Node_Str" + values.size());
        }
        ids.put(m.getTarget(), values);
    }
    return ids;
}

Output:
     int listSize = -1;
-    for (PathSourceMapping m : mapping.getRequestParamMappings()) {
-        List<Object> values = ReflectionUtils.getAllByPath(request, m.getSource());
+    for (PathSourceMapping m : mapping.getResponseIdentifierMappings()) {
+        List<Object> values = ReflectionUtils.getAllByPath(result, m.getSource());
         if (listSize == -1) {


Input:
public Object getValue() throws IllegalActionException {
    try {
        InequalityTerm[] terms = getVariables();
        for (int i = 0; i < terms.length; i++) {
            InequalityTerm term = terms[i];
            if ((term != this) && (term.getValue() == BaseType.UNKNOWN)) {
                return BaseType.UNKNOWN;
            }
        }
        int index = _destinationNames.indexOf(_name);
        ASTPtRootNode parseTree = (ASTPtRootNode) _parseTrees.get(index);
        Type type = _typeInference.inferTypes(parseTree, _getParserScope());
        NamedObj container = getContainer();
        while (container != null && !(container instanceof Entity)) {
            container = container.getContainer();
        }
        if (container != null && ((Entity) container).getPort(_name) == null) {
            if (_numbers.get(index) != null) {
                ArrayType arrayType = new ArrayType(type);
                return arrayType;
            }
        }
        return type;
    } catch (Exception ex) {
        throw new IllegalActionException(AbstractActionsAttribute.this, ex, "String_Node_Str");
    }
}

Output:
         if (container != null && ((Entity) container).getPort(_name) == null) {
-            if (_numbers.get(index) != null) {
+            if (_numbers.get(index) != null && (getDestination(_name) instanceof Variable)) {
                 ArrayType arrayType = new ArrayType(type);


Input:
public void buildApk(File appDir, File outApk, HashMap<String, Boolean> flags) throws AndrolibException {
    LOGGER.info("String_Node_Str");
    if (outApk.exists()) {
        outApk.delete();
    } else {
        File outDir = outApk.getParentFile();
        if (outDir != null && !outDir.exists()) {
            outDir.mkdirs();
        }
    }
    File assetDir = new File(appDir, "String_Node_Str");
    if (!assetDir.exists()) {
        assetDir = null;
    }
    mAndRes.aaptPackage(outApk, null, null, new File(appDir, APK_DIRNAME), assetDir, null, flags);
    if (flags.get("String_Node_Str")) {
        try {
            LOGGER.info("String_Node_Str");
            ZipFile editOrig = new ZipFile(mOrigApkFile.getAbsoluteFile());
            ZipParameters parameters = new ZipParameters();
            parameters.setCompressionMethod(Zip4jConstants.COMP_STORE);
            parameters.setCompressionLevel(0);
            parameters.setIncludeRootFolder(true);
            parameters.setRootFolderInZip("String_Node_Str");
            editOrig.addFolder(new File(appDir, APK_DIRNAME + "String_Node_Str").getAbsolutePath(), parameters);
            if (assetDir.exists()) {
            }
            parameters.setFileNameInZip("String_Node_Str");
        } catch (ZipException e) {
            LOGGER.warning(e.getMessage());
        }
    }
}

Output:
             editOrig.addFolder(new File(appDir, APK_DIRNAME + "String_Node_Str").getAbsolutePath(), parameters);
-            if (assetDir.exists()) {
+            if (assetDir != null) {
             }


Input:
public GenericInventoryGenerator copyAsGenericInventoryGenerator() {
    return (GenericInventoryGenerator) clone();
}

Output:
 public GenericInventoryGenerator copyAsGenericInventoryGenerator() {
-    return (GenericInventoryGenerator) clone();
+    return copy();
 }


Input:
public Map<Integer, Integer> loadAll(Iterable<? extends Integer> keys) throws CacheLoaderException {
    Map<Integer, Integer> result = new HashMap<Integer, Integer>();
    for (Integer key : keys) {
        Integer value = load(key);
        if (value != null) {
            result.put(key, value);
        }
    }
    return result;
}

Output:
     for (Integer key : keys) {
-        Integer value = load(key);
-        if (value != null) {
-            result.put(key, value);
-        }
+        String value = load(key);
+        result.put(key, value);
     }


Input:
public void trackFileSize() {
    long size = ff.length(fd);
    if (size < this.size) {
        setInitialSize(size);
    } else if (size > this.size && lastPageSize < pageSize) {
        pages.ensureCapacity((int) (size / this.pageSize + 1));
        int lastIndex = pages.size() - 1;
        if (lastIndex > -1) {
            long address = pages.getQuick(lastIndex);
            if (address != 0) {
                releaseLast(address);
                pages.setQuick(lastIndex, 0);
            }
            clearHotPage();
        }
        this.size = size;
    }
}

Output:
         setInitialSize(size);
-    } else if (size > this.size && lastPageSize < pageSize) {
-        pages.ensureCapacity((int) (size / this.pageSize + 1));
-        int lastIndex = pages.size() - 1;
-        if (lastIndex > -1) {
-            long address = pages.getQuick(lastIndex);
-            if (address != 0) {
-                releaseLast(address);
-                pages.setQuick(lastIndex, 0);
+    } else if (size > this.size) {
+        pages.ensureCapacity((int) (size / getMapPageSize() + 1));
+        if (lastPageSize < getMapPageSize()) {
+            int lastIndex = pages.size() - 1;
+            if (lastIndex > -1) {
+                long address = pages.getQuick(lastIndex);
+                if (address != 0) {
+                    release(lastIndex, address);
+                    pages.setQuick(lastIndex, 0);
+                }
+                clearHotPage();
             }


Input:
public static byte[] Mid_safe(byte[] src, int bgn, int end) {
    if (src == null)
        return null;
    int src_len = src.length;
    if (bgn < 0)
        bgn = 0;
    if (end >= src_len)
        end = src_len;
    if (bgn > end)
        bgn = end;
    else if (end < bgn)
        end = bgn;
    return Mid(src, bgn, end);
}

Output:
         bgn = 0;
-    if (end >= src_len)
+    else if (bgn >= src_len)
+        bgn = src_len;
+    if (end < 0)
+        end = 0;
+    else if (end >= src_len)
         end = src_len;


Input:
public InputStream getInputStream() {
    try {
        WlHttpURI uri = new WlHttpURI(this.url.toExternalForm());
        Asset asset = AssetManager.getAssetManager().getAsset(uri);
        if (asset == null || AssetManager.getAssetManager().waitForAsset(asset) == false) {
            return null;
        }
        return new FileInputStream(asset.getLocalCacheFile());
    } catch (FileNotFoundException ex) {
        Logger.getLogger(WlHttpURLConnection.class.getName()).log(Level.SEVERE, null, ex);
    } catch (URISyntaxException excp) {
        Logger.getLogger(WlHttpURLConnection.class.getName()).log(Level.SEVERE, null, excp);
    } catch (MalformedURLException excp) {
        Logger.getLogger(WlHttpURLConnection.class.getName()).log(Level.SEVERE, null, excp);
    }
    return null;
}

Output:
         if (asset == null || AssetManager.getAssetManager().waitForAsset(asset) == false) {
-            return null;
+            throw new IOException("String_Node_Str" + url);
         }


Input:
public SufficientStatistics createInitSufficientStatistics() {
    ArrayVector vector = new ArrayVector(this.sizeOfSufficientStatistics());
    double mean = 0;
    double precision = 0.000001;
    vector.set(0, mean * precision);
    vector.set(1, -0.5 * precision);
    return vector;
}

Output:
 public SufficientStatistics createInitSufficientStatistics() {
-    ArrayVector vector = new ArrayVector(this.sizeOfSufficientStatistics());
+    SufficientStatistics vector = this.createZeroSufficientStatistics();
     double mean = 0;


Input:
private void updateForSpends(Transaction tx, boolean fromChain) throws VerificationException {
    checkState(lock.isHeldByCurrentThread());
    if (fromChain)
        checkState(!pending.containsKey(tx.getHash()));
    for (TransactionInput input : tx.getInputs()) {
        TransactionInput.ConnectionResult result = input.connect(unspent, TransactionInput.ConnectMode.ABORT_ON_CONFLICT);
        if (result == TransactionInput.ConnectionResult.NO_SUCH_TX) {
            result = input.connect(spent, TransactionInput.ConnectMode.ABORT_ON_CONFLICT);
            if (result == TransactionInput.ConnectionResult.NO_SUCH_TX) {
                result = input.connect(pending, TransactionInput.ConnectMode.ABORT_ON_CONFLICT);
                if (result == TransactionInput.ConnectionResult.NO_SUCH_TX) {
                    continue;
                }
            }
        }
        if (result == TransactionInput.ConnectionResult.ALREADY_SPENT) {
            if (fromChain) {
            } else {
                log.warn("String_Node_Str");
                log.warn("String_Node_Str", tx.getInputs().indexOf(input));
                log.warn("String_Node_Str", tx.getHash(), Utils.HEX.encode(tx.unsafeBitcoinSerialize()));
                Transaction other = input.getConnectedOutput().getSpentBy().getParentTransaction();
                log.warn("String_Node_Str", other.getHash(), Utils.HEX.encode(tx.unsafeBitcoinSerialize()));
            }
        } else if (result == TransactionInput.ConnectionResult.SUCCESS) {
            Transaction connected = checkNotNull(input.getOutpoint().fromTx);
            log.info("String_Node_Str", input.getOutpoint());
            maybeMovePool(connected, "String_Node_Str");
        }
    }
    if (fromChain) {
        for (Transaction pendingTx : pending.values()) {
            for (TransactionInput input : pendingTx.getInputs()) {
                TransactionInput.ConnectionResult result = input.connect(tx, TransactionInput.ConnectMode.ABORT_ON_CONFLICT);
                checkState(result != TransactionInput.ConnectionResult.ALREADY_SPENT);
                if (result == TransactionInput.ConnectionResult.SUCCESS) {
                    log.info("String_Node_Str", pendingTx.getHashAsString(), pendingTx.getInputs().indexOf(input));
                }
            }
        }
    }
}

Output:
     }
-    if (fromChain) {
-        for (Transaction pendingTx : pending.values()) {
-            for (TransactionInput input : pendingTx.getInputs()) {
-                TransactionInput.ConnectionResult result = input.connect(tx, TransactionInput.ConnectMode.ABORT_ON_CONFLICT);
+    for (Transaction pendingTx : pending.values()) {
+        for (TransactionInput input : pendingTx.getInputs()) {
+            TransactionInput.ConnectionResult result = input.connect(tx, TransactionInput.ConnectMode.ABORT_ON_CONFLICT);
+            if (fromChain) {
                 checkState(result != TransactionInput.ConnectionResult.ALREADY_SPENT);


Input:
public void receivedByte(byte data) {
    if (DEBUG)
        log("String_Node_Str" + Utils.hex8(data) + "String_Node_Str" + stateMachine + "String_Node_Str" + zeroSymbols + ((stateMachine == RadioState.RX_SFD_SEARCH || stateMachine == RadioState.RX_FRAME) ? "String_Node_Str" : "String_Node_Str"));
    if (stateMachine == RadioState.RX_SFD_SEARCH) {
        if (data == 0) {
            zeroSymbols++;
        } else if (zeroSymbols >= 4 && data == 0x7A) {
            setSFD(true);
            if (DEBUG)
                log("String_Node_Str");
            setState(RadioState.RX_FRAME);
        } else {
            zeroSymbols = 0;
        }
    } else if (stateMachine == RadioState.RX_FRAME) {
        if (overflow) {
        } else if (rxFIFO.isFull()) {
            setRxOverflow();
        } else {
            if (!frameRejected) {
                rxFIFO.write(data);
                if (rxread == 0) {
                    rxCrc.setCRC(0);
                    rxlen = data & 0xff;
                    decodeAddress = addressDecode;
                    if (DEBUG)
                        log("String_Node_Str" + rxlen);
                    setFIFO(true);
                } else if (rxread < rxlen - 1) {
                    rxCrc.addBitrev(data & 0xff);
                    if (rxread == 1) {
                        fcf0 = data & 0xff;
                        frameType = fcf0 & FRAME_TYPE;
                    } else if (rxread == 2) {
                        fcf1 = data & 0xff;
                        if (frameType == TYPE_DATA_FRAME) {
                            ackRequest = (fcf0 & ACK_REQUEST) > 0;
                            destinationAddressMode = (fcf1 >> 2) & 3;
                            if (addressDecode && destinationAddressMode != LONG_ADDRESS && destinationAddressMode != SHORT_ADDRESS) {
                                rejectFrame();
                            }
                        } else if (frameType == TYPE_BEACON_FRAME || frameType == TYPE_ACK_FRAME) {
                            decodeAddress = false;
                            ackRequest = false;
                        } else if (addressDecode) {
                            rejectFrame();
                        }
                    } else if (rxread == 3) {
                        dsn = data & 0xff;
                    } else if (decodeAddress) {
                        boolean flushPacket = false;
                        if (destinationAddressMode == LONG_ADDRESS && rxread == 8 + 5) {
                            flushPacket = !rxFIFO.tailEquals(memory, RAM_IEEEADDR, 8);
                            flushPacket |= !rxFIFO.tailEquals(memory, RAM_PANID, 2, 8) && !rxFIFO.tailEquals(BC_ADDRESS, 0, 2, 8);
                            decodeAddress = false;
                        } else if (destinationAddressMode == SHORT_ADDRESS && rxread == 2 + 5) {
                            flushPacket = !rxFIFO.tailEquals(BC_ADDRESS, 0, 2) && !rxFIFO.tailEquals(memory, RAM_SHORTADDR, 2);
                            flushPacket |= !rxFIFO.tailEquals(memory, RAM_PANID, 2, 2) && !rxFIFO.tailEquals(BC_ADDRESS, 0, 2, 2);
                            decodeAddress = false;
                        }
                        if (flushPacket) {
                            rejectFrame();
                        }
                    }
                }
                if (fifoP == false && rxFIFO.length() <= rxlen + 1 && !decodeAddress && !frameRejected && rxFIFO.length() > fifopThr) {
                    setFIFOP(true);
                    if (DEBUG)
                        log("String_Node_Str");
                }
            }
            if (rxread++ == rxlen) {
                if (frameRejected) {
                    if (DEBUG)
                        log("String_Node_Str");
                    setSFD(false);
                    setState(RadioState.RX_WAIT);
                    return;
                }
                int crc = rxFIFO.get(-2) << 8;
                crc += rxFIFO.get(-1);
                crcOk = crc == rxCrc.getCRCBitrev();
                if (DEBUG && !crcOk) {
                    log("String_Node_Str" + Utils.hex16(crc) + "String_Node_Str" + Utils.hex16(rxCrc.getCRCBitrev()));
                }
                rxFIFO.set(-2, registers[REG_RSSI] & 0xff);
                rxFIFO.set(-1, 37 | (crcOk ? 0x80 : 0));
                if (rxFIFO.length() <= rxlen + 1) {
                    setFIFOP(true);
                } else {
                    if (DEBUG)
                        log("String_Node_Str" + rxFIFO.length() + "String_Node_Str" + rxlen);
                }
                setSFD(false);
                if (DEBUG)
                    log("String_Node_Str" + rxFIFO.stateToString());
                if (((autoAck && ackRequest) || shouldAck) && crcOk) {
                    setState(RadioState.TX_ACK_CALIBRATE);
                } else {
                    setState(RadioState.RX_WAIT);
                }
            }
        }
    }
}

Output:
                 }
-                if (fifoP == false && rxFIFO.length() <= rxlen + 1 && !decodeAddress && !frameRejected && rxFIFO.length() > fifopThr) {
+                if (currentFIFOP == false && rxFIFO.length() <= rxlen + 1 && !decodeAddress && !frameRejected && rxFIFO.length() > fifopThr) {
                     setFIFOP(true);


Input:
public Uri save(ContentResolver contentResolver, String title, String description) {
    return CaptureSketchUtils.insertImage(contentResolver, bitmap, title, description);
}

Output:
 public Uri save(ContentResolver contentResolver, String title, String description) {
-    return CaptureSketchUtils.insertImage(contentResolver, bitmap, title, description);
+    return CaptureSketchUtils.insertImage(contentResolver, getBitmap(), title, description);
 }


Input:
private static Logger createFileLogger(String dirName) {
    try {
        File directory = new File(dirName);
        if (!directory.exists()) {
            if (!directory.mkdirs())
                throw new IOException("String_Node_Str" + dirName + "String_Node_Str");
        } else {
            if (directory.isFile())
                throw new IOException("String_Node_Str" + dirName + "String_Node_Str");
        }
        Handler logFileHandler = new FileHandler(generateUniqueLogFileName(dirName), true);
        logFileHandler.setFormatter(new SimpleFormatter());
        logFileHandler.setLevel(Level.FINEST);
        Logger logger = Logger.getAnonymousLogger();
        logger.addHandler(logFileHandler);
        return logger;
    } catch (SecurityException e) {
        logger.log(Level.WARNING, e.getMessage(), e);
    } catch (IOException e) {
        logger.log(Level.WARNING, e.getMessage(), e);
    }
    return null;
}

Output:
     try {
-        File directory = new File(dirName);
-        if (!directory.exists()) {
-            if (!directory.mkdirs())
-                throw new IOException("String_Node_Str" + dirName + "String_Node_Str");
-        } else {
-            if (directory.isFile())
-                throw new IOException("String_Node_Str" + dirName + "String_Node_Str");
+        if (dirName != null) {
+            File directory = new File(dirName);
+            if (!directory.exists()) {
+                if (!directory.mkdirs())
+                    throw new IOException("String_Node_Str" + dirName + "String_Node_Str");
+            } else {
+                if (directory.isFile())
+                    throw new IOException("String_Node_Str" + dirName + "String_Node_Str");
+            }
         }


Input:
public boolean performHapticFeedbackLw(WindowState win, int effectId, boolean always) {
    final boolean hapticsDisabled = Settings.System.getInt(mContext.getContentResolver(), Settings.System.HAPTIC_FEEDBACK_ENABLED, 0) == 0;
    if (!always && (hapticsDisabled || mKeyguardMediator.isShowing())) {
        return false;
    }
    switch(effectId) {
        case HapticFeedbackConstants.LONG_PRESS:
            mVibrator.vibrate(mLongPressVibePattern, -1);
            return true;
        case HapticFeedbackConstants.VIRTUAL_KEY:
            mVibrator.vibrate(mVirtualKeyVibePattern, -1);
            return true;
        case HapticFeedbackConstants.SAFE_MODE_DISABLED:
            mVibrator.vibrate(mSafeModeDisabledVibePattern, -1);
            return true;
        case HapticFeedbackConstants.SAFE_MODE_ENABLED:
            mVibrator.vibrate(mSafeModeEnabledVibePattern, -1);
            return true;
    }
    return false;
}

Output:
     final boolean hapticsDisabled = Settings.System.getInt(mContext.getContentResolver(), Settings.System.HAPTIC_FEEDBACK_ENABLED, 0) == 0;
-    if (!always && (hapticsDisabled || mKeyguardMediator.isShowing())) {
+    if (!always && (hapticsDisabled || mKeyguardMediator.isShowingAndNotHidden())) {
         return false;


Input:
public String toString() {
    final ToStringBuilder toStringBuilder = new ToStringBuilder(this);
    toStringBuilder.append("String_Node_Str", name);
    return toStringBuilder.toString();
}

Output:
     final ToStringBuilder toStringBuilder = new ToStringBuilder(this);
-    toStringBuilder.append("String_Node_Str", name);
+    toStringBuilder.append("String_Node_Str", getName());
     return toStringBuilder.toString();


Input:
public static String[] getPages(String content, FontRenderer fontRenderer, int maxStringWidth, int maxCharacters) {
    ArrayList<String> returnList = new ArrayList<String>();
    int lastCut = 0;
    for (int i = 0; i < content.length(); ) {
        int wordEndIndex = i + 1;
        if (content.substring(i).indexOf("String_Node_Str") == -1) {
            wordEndIndex = content.length();
        } else {
            wordEndIndex = i + content.substring(i).indexOf("String_Node_Str");
        }
        String currentPageString = content.substring(lastCut, wordEndIndex);
        int realLength = fontRenderer.splitStringWidth(currentPageString, maxStringWidth);
        if (!(realLength <= maxStringWidth && currentPageString.length() < maxCharacters)) {
            returnList.add(content.substring(lastCut, i));
            lastCut = i;
        }
        i = wordEndIndex + 1;
    }
    if (lastCut < content.length()) {
        returnList.add(content.substring(lastCut, content.length()));
    }
    String[] returnArray = new String[returnList.size()];
    for (int i = 0; i < returnList.size(); i++) {
        returnArray[i] = returnList.get(i);
    }
    return returnArray;
}

Output:
 public static String[] getPages(String content, FontRenderer fontRenderer, int maxStringWidth, int maxCharacters) {
-    ArrayList<String> returnList = new ArrayList<String>();
+    ArrayList<String> returnList = new ArrayList<>();
     int lastCut = 0;


Input:
public void drawHighlighted(Canvas c, Highlight[] indices) {
    int setCount = mChart.getBarData().getDataSetCount();
    for (int i = 0; i < indices.length; i++) {
        Highlight h = indices[i];
        int index = h.getXIndex();
        int dataSetIndex = h.getDataSetIndex();
        BarDataSet set = mChart.getBarData().getDataSetByIndex(dataSetIndex);
        if (set == null || !set.isHighlightEnabled())
            continue;
        float barspaceHalf = set.getBarSpace() / 2f;
        Transformer trans = mChart.getTransformer(set.getAxisDependency());
        mHighlightPaint.setColor(set.getHighLightColor());
        mHighlightPaint.setAlpha(set.getHighLightAlpha());
        if (index >= 0 && index < (mChart.getXChartMax() * mAnimator.getPhaseX()) / setCount) {
            BarEntry e = set.getEntryForXIndex(index);
            if (e == null || e.getXIndex() != index)
                continue;
            float groupspace = mChart.getBarData().getGroupSpace();
            boolean isStack = h.getStackIndex() < 0 ? false : true;
            float x = index * setCount + dataSetIndex + groupspace / 2f + groupspace * index;
            final float y1;
            final float y2;
            if (isStack) {
                y1 = h.getRange().from;
                y2 = h.getRange().to * mAnimator.getPhaseY();
            } else {
                y1 = e.getVal();
                y2 = 0.f;
            }
            prepareBarHighlight(x, y1, y2, barspaceHalf, trans);
            c.drawRect(mBarRect, mHighlightPaint);
            if (mChart.isDrawHighlightArrowEnabled()) {
                mHighlightPaint.setAlpha(255);
                float offsetY = mAnimator.getPhaseY() * 0.07f;
                float[] values = new float[9];
                trans.getPixelToValueMatrix().getValues(values);
                final float xToYRel = Math.abs(values[Matrix.MSCALE_Y] / values[Matrix.MSCALE_X]);
                final float arrowWidth = set.getBarSpace() / 2.f;
                final float arrowHeight = arrowWidth * xToYRel;
                final float yArrow = y1 > -y2 ? y1 : y1;
                Path arrow = new Path();
                arrow.moveTo(x + 0.4f, yArrow + offsetY);
                arrow.lineTo(x + 0.4f + arrowWidth, yArrow + offsetY - arrowHeight);
                arrow.lineTo(x + 0.4f + arrowWidth, yArrow + offsetY + arrowHeight);
                trans.pathValueToPixel(arrow);
                c.drawPath(arrow, mHighlightPaint);
            }
        }
    }
}

Output:
                 y1 = h.getRange().from;
-                y2 = h.getRange().to * mAnimator.getPhaseY();
+                y2 = h.getRange().to;
             } else {


Input:
protected void onFileSelected(Uri originalUri) {
    try {
        ParcelFileDescriptor descriptor = getContentResolver().openFileDescriptor(originalUri, "String_Node_Str");
        Bitmap bitmap = BitmapFactory.decodeFileDescriptor(descriptor.getFileDescriptor(), null, bitmapOptions);
        new ReceiveImageFileTask(PrivateDialogActivity.this).execute(imageHelper, bitmap, true);
    } catch (FileNotFoundException e) {
        ErrorUtils.showError(this, e.getMessage());
    }
}

Output:
         Bitmap bitmap = BitmapFactory.decodeFileDescriptor(descriptor.getFileDescriptor(), null, bitmapOptions);
-        new ReceiveImageFileTask(PrivateDialogActivity.this).execute(imageHelper, bitmap, true);
+        new ReceiveImageFileTask(PrivateDialogActivity.this).execute(imageUtils, bitmap, true);
     } catch (FileNotFoundException e) {


Input:
protected void initializeVariables() {
    if (DEBUG) {
        System.err.println("String_Node_Str" + ir.getMethod());
    }
    int[] parameterValueNumbers = ir.getParameterValueNumbers();
    for (int i = 0; i < parameterValueNumbers.length; i++) {
        TypeVariable v = getVariable(parameterValueNumbers[i]);
        TypeReference t = ir.getParameterType(i);
        if (DEBUG) {
            System.err.println("String_Node_Str" + parameterValueNumbers[i] + "String_Node_Str" + t);
        }
        if (t.isReferenceType()) {
            IClass klass = cha.lookupClass(t);
            if (DEBUG) {
                System.err.println("String_Node_Str" + klass);
            }
            if (klass != null) {
                v.setType(new ConeType(klass));
            } else {
                v.setType(BOTTOM);
            }
        } else if (doPrimitives) {
            v.setType(PrimitiveType.getPrimitive(t));
        }
    }
    SymbolTable st = ir.getSymbolTable();
    if (st != null) {
        for (int i = 0; i <= st.getMaxValueNumber(); i++) {
            if (st.isConstant(i)) {
                TypeVariable v = getVariable(i);
                v.setType(getConstantType(i));
            }
        }
    }
    for (Iterator<SSAInstruction> it = ir.iterateNormalInstructions(); it.hasNext(); ) {
        SSAInstruction s = it.next();
        if (s instanceof SSAAbstractInvokeInstruction) {
            SSAAbstractInvokeInstruction call = (SSAAbstractInvokeInstruction) s;
            TypeVariable v = getVariable(call.getException());
            Collection<TypeReference> defaultExceptions = call.getExceptionTypes();
            if (defaultExceptions.size() == 0) {
                continue;
            }
            Iterator<TypeReference> types = defaultExceptions.iterator();
            TypeReference t = types.next();
            IClass klass = cha.lookupClass(t);
            if (klass == null) {
                v.setType(BOTTOM);
            } else {
                v.setType(new PointType(klass));
            }
            while (types.hasNext()) {
                t = types.next();
                klass = cha.lookupClass(t);
                if (klass != null) {
                    v.setType(v.getType().meet(new PointType(klass)));
                }
            }
            IMethod m = cha.resolveMethod(call.getDeclaredTarget());
            if (m != null) {
                TypeReference[] x = null;
                try {
                    x = m.getDeclaredExceptions();
                } catch (InvalidClassFileException e) {
                    e.printStackTrace();
                    Assertions.UNREACHABLE();
                } catch (UnsupportedOperationException e) {
                    x = new TypeReference[] { language.getThrowableType() };
                }
                if (x != null) {
                    for (int i = 0; i < x.length; i++) {
                        TypeReference tx = x[i];
                        IClass tc = cha.lookupClass(tx);
                        if (tc != null) {
                            v.setType(v.getType().meet(new ConeType(tc)));
                        }
                    }
                }
            }
        }
    }
}

Output:
         } else if (doPrimitives) {
-            v.setType(PrimitiveType.getPrimitive(t));
+            v.setType(language.getPrimitive(t));
         }


Input:
public void onSend(Device device, CommandType type, int frequency, int timezone, int radius, String phoneNumber, String message, String rawCommand) {
    Command command = new Command();
    command.setType(type);
    command.setDeviceId((int) device.getId());
    command.setAttributes(new HashMap<String, Object>());
    switch(type) {
        case positionPeriodic:
            command.getAttributes().put(CommandType.KEY_FREQUENCY, frequency);
            break;
        case setTimezone:
            command.getAttributes().put(CommandType.KEY_TIMEZONE, timezone);
            break;
        case movementAlarm:
            command.getAttributes().put(CommandType.KEY_RADIUS, radius);
            break;
        case sendSms:
            command.getAttributes().put(CommandType.KEY_PHONE_NUMBER, phoneNumber);
            command.getAttributes().put(CommandType.KEY_MESSAGE, message);
            break;
        case CUSTOM:
            command.setCommand(rawCommand);
            break;
    }
    final Messages i18n = GWT.create(Messages.class);
    RequestBuilder builder = new RequestBuilder(RequestBuilder.POST, "String_Node_Str");
    try {
        builder.sendRequest("String_Node_Str" + commandMapper.write(command) + "String_Node_Str", new RequestCallback() {
            public void onResponseReceived(Request request, Response response) {
                new LogViewDialog("String_Node_Str" + response.getText() + "String_Node_Str").show();
            }
            public void onError(Request request, Throwable exception) {
                new AlertMessageBox(i18n.error(), i18n.errRemoteCall());
            }
        });
    } catch (RequestException e) {
        new AlertMessageBox(i18n.error(), e.getLocalizedMessage());
        e.printStackTrace();
    }
}

Output:
             break;
-        case CUSTOM:
+        case custom:
             command.setCommand(rawCommand);


Input:
public void setTargetItems(List<? extends MappableItem> targetItems) {
    this.targetItems.clear();
    for (MappableItem item : targetItems) this.targetItems.add((T) item);
}

Output:
 public void setTargetItems(List<? extends MappableItem> targetItems) {
-    this.targetItems.clear();
-    for (MappableItem item : targetItems) this.targetItems.add((T) item);
+    this.cdmItems.clear();
+    for (MappableItem item : targetItems) this.cdmItems.add((T) item);
 }


Input:
protected void accessRow(RowDesign row, IContentEmitter emitter, boolean runScript) {
    if (rowClosed) {
        IRowContent rowContent = report.createRowContent();
        assert (rowContent instanceof RowContent);
        IContent parent = context.getContent();
        context.pushContent(rowContent);
        initializeContent(parent, row, rowContent);
        processStyle(row, rowContent);
        processVisibility(row, rowContent);
        processBookmark(row, rowContent);
        processAction(row, rowContent);
        if (context.isInFactory() && runScript) {
            DetailRowScriptExecutor.handleOnCreate((RowContent) rowContent, null, context);
        }
        if (emitter != null) {
            emitter.startRow(rowContent);
        }
        rowClosed = false;
    }
    for (int j = 0; j < row.getCellCount(); j++) {
        CellDesign cell = row.getCell(j);
        if (cell != null) {
            ICellContent cellContent = report.createCellContent();
            assert (cellContent instanceof CellContent);
            IContent parent = context.getContent();
            context.pushContent(cellContent);
            initializeContent(parent, cell, cellContent);
            cellContent.setColumn(cell.getColumn());
            cellContent.setColSpan(cell.getColSpan());
            cellContent.setRowSpan(cell.getRowSpan());
            processStyle(cell, cellContent);
            processVisibility(cell, cellContent);
            processBookmark(cell, cellContent);
            processAction(cell, cellContent);
            if (context.isInFactory()) {
                CellScriptExecutor.handleOnCreate((CellContent) cellContent, null, context);
            }
            if (emitter != null) {
                emitter.startCell(cellContent);
            }
            for (int m = 0; m < cell.getContentCount(); m++) {
                ReportItemDesign item = cell.getContent(m);
                if (item != null) {
                    if (layoutEmitter != null) {
                        item.accept(this.visitor, layoutEmitter.getCellEmitter());
                    } else {
                        item.accept(this.visitor, emitter);
                    }
                }
            }
            if (emitter != null) {
                emitter.endCell(cellContent);
            }
            context.popContent();
        }
    }
    boolean closeRow = true;
    if (closeRow) {
        emitter.endRow((IRowContent) context.getContent());
        context.popContent();
        rowClosed = true;
    }
}

Output:
         if (context.isInFactory() && runScript) {
-            DetailRowScriptExecutor.handleOnCreate((RowContent) rowContent, null, context);
+            try {
+                context.newScope(rowContent);
+                DetailRowScriptExecutor.handleOnCreate((RowContent) rowContent, null, context);
+            } finally {
+                context.exitScope();
+            }
         }


Input:
public void close() {
    this.sb = null;
    this.close();
}

Output:
     this.sb = null;
-    this.close();
+    this.writer.close();
 }


Input:
public void testHierarchize(FoodMartTestCase test) {
    final Axis axis = test.executeAxis2("String_Node_Str" + nl + "String_Node_Str" + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str");
    final String expected = "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str";
    test.assertEquals(expected, test.toString(axis.positions));
}

Output:
 public void testHierarchize(FoodMartTestCase test) {
-    final Axis axis = test.executeAxis2("String_Node_Str" + nl + "String_Node_Str" + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str");
-    final String expected = "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str";
-    test.assertEquals(expected, test.toString(axis.positions));
+    test.assertAxisReturns("String_Node_Str" + nl + "String_Node_Str" + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str", "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str" + nl + "String_Node_Str");
 }


Input:
public void update() {
    Object implClass;
    final Color highlightColor = null;
    if (getCurrentComponent() != null) {
        try {
            implClass = AUTServerConfiguration.getInstance().getImplementationClass(getComponentClass(getCurrentComponent()));
            if (implClass != null) {
                ReflectionBP.invokeMethod("String_Node_Str", implClass, new Class[] { Component.class, Color.class }, new Object[] { getCurrentComponent(), highlightColor });
            }
        } catch (UnsupportedComponentException e) {
        } catch (IllegalArgumentException e) {
            log.error("String_Node_Str", e);
        }
    }
}

Output:
         try {
-            implClass = AUTServerConfiguration.getInstance().getImplementationClass(getComponentClass(getCurrentComponent()));
-            if (implClass != null) {
-                ReflectionBP.invokeMethod("String_Node_Str", implClass, new Class[] { Component.class, Color.class }, new Object[] { getCurrentComponent(), highlightColor });
+            Object adapter = GUIAdapterFactoryRegistry.getInstance().getAdapter(getCurrentComponent());
+            if (adapter != null) {
+                ReflectionBP.invokeMethod("String_Node_Str", adapter, new Class[] { Component.class, Color.class }, new Object[] { getCurrentComponent(), highlightColor });
             }


Input:
public static boolean isSpecifiedBuildInType(XSDSimpleTypeDefinition simpleType, String buildInTypeName) {
    if (simpleType == null || simpleType.getSchema() == null)
        return false;
    XSDSimpleTypeDefinition systemDoubleType = simpleType.getSchema().resolveSimpleTypeDefinition(simpleType.getSchema().getSchemaForSchemaNamespace(), buildInTypeName);
    if (systemDoubleType == null)
        return false;
    return systemDoubleType.equals(simpleType.getBaseType());
}

Output:
         return false;
-    return systemDoubleType.equals(simpleType.getBaseType());
+    return simpleType.equals(systemDoubleType) || systemDoubleType.equals(simpleType.getBaseType());
 }


Input:
private Queue<OutboundFrame> getOutboundQueue(TcpIpConnection connection, boolean priority) {
    if (connection.getChannel() instanceof NioChannel) {
        NioChannel nioChannel = (NioChannel) connection.getChannel();
        NioOutboundPipeline outboundPipeline = nioChannel.outboundPipeline();
        return priority ? outboundPipeline.urgentWriteQueue : outboundPipeline.writeQueue;
    } else {
        return EMPTY_QUEUE;
    }
}

Output:
         NioOutboundPipeline outboundPipeline = nioChannel.outboundPipeline();
-        return priority ? outboundPipeline.urgentWriteQueue : outboundPipeline.writeQueue;
+        return priority ? outboundPipeline.priorityWriteQueue : outboundPipeline.writeQueue;
     } else {


Input:
public void testSingleValueLongCompares() throws IOException {
    byte[] rowKey = dataHelper.randomData("String_Node_Str");
    byte[] qualToCheck = dataHelper.randomData("String_Node_Str");
    Table table = getDefaultTable();
    table.put(new Put(rowKey).addColumn(SharedTestEnvRule.COLUMN_FAMILY, qualToCheck, Bytes.toBytes(2000l)));
    Scan rootScan = new Scan().addColumn(SharedTestEnvRule.COLUMN_FAMILY, qualToCheck).withStartRow(rowKey).withStopRow(rowKey);
    Assert.assertNull("String_Node_Str", getFirst(table, rootScan, CompareOp.LESS, 1000l));
    Assert.assertNotNull("String_Node_Str", getFirst(table, rootScan, CompareOp.GREATER, 1000l));
    Assert.assertNull("String_Node_Str", getFirst(table, rootScan, CompareOp.LESS_OR_EQUAL, 1000l));
    Assert.assertNotNull("String_Node_Str", getFirst(table, rootScan, CompareOp.GREATER_OR_EQUAL, 1000l));
    Assert.assertNotNull("String_Node_Str", getFirst(table, rootScan, CompareOp.LESS_OR_EQUAL, 2000l));
    Assert.assertNotNull("String_Node_Str", getFirst(table, rootScan, CompareOp.GREATER_OR_EQUAL, 2000l));
}

Output:
     table.put(new Put(rowKey).addColumn(SharedTestEnvRule.COLUMN_FAMILY, qualToCheck, Bytes.toBytes(2000l)));
-    Scan rootScan = new Scan().addColumn(SharedTestEnvRule.COLUMN_FAMILY, qualToCheck).withStartRow(rowKey).withStopRow(rowKey);
+    Scan rootScan = new Scan().addColumn(SharedTestEnvRule.COLUMN_FAMILY, qualToCheck).withStartRow(rowKey).withStopRow(rowKey, true);
     Assert.assertNull("String_Node_Str", getFirst(table, rootScan, CompareOp.LESS, 1000l));


Input:
private NodeBuilder buildNode(Object entity, PersistenceCache pc, Object entityId, String nodeId) {
    Node nodeInPersistenceCache = pc.getMainCache().getNodeFromCache(nodeId);
    EntityMetadata entityMetadata = KunderaMetadataManager.getEntityMetadata(entity.getClass());
    if (nodeInPersistenceCache == null) {
        node = new Node(nodeId, entity, ((Field) entityMetadata.getIdAttribute().getJavaMember()).isAnnotationPresent(EmbeddedId.class) ? new ManagedState() : new TransientState(), pc, entityId);
    } else {
        node = nodeInPersistenceCache;
        node.setPersistenceCache(pc);
        node.setTraversed(false);
    }
    onDirtyCheck(entity, node);
    node.setData(entity);
    return this;
}

Output:
     if (nodeInPersistenceCache == null) {
-        node = new Node(nodeId, entity, ((Field) entityMetadata.getIdAttribute().getJavaMember()).isAnnotationPresent(EmbeddedId.class) ? new ManagedState() : new TransientState(), pc, entityId);
+        this.state = state != null ? this.state : new TransientState();
+        node = new Node(nodeId, entity, ((Field) entityMetadata.getIdAttribute().getJavaMember()).isAnnotationPresent(EmbeddedId.class) ? new ManagedState() : this.state, pc, entityId);
     } else {


Input:
public Method resolveDomainMethod(Method requestContextMethod) {
    Class<?> enclosing = requestContextMethod.getDeclaringClass();
    Class<?> searchIn = null;
    Service s = enclosing.getAnnotation(Service.class);
    if (s != null) {
        searchIn = s.value();
    }
    ServiceName sn = enclosing.getAnnotation(ServiceName.class);
    if (sn != null) {
        searchIn = forName(sn.value());
    }
    if (searchIn == null) {
        die(null, "String_Node_Str", RequestContext.class.getSimpleName(), enclosing.getCanonicalName());
    }
    Class<?>[] parameterTypes = requestContextMethod.getParameterTypes();
    Class<?>[] domainArgs = new Class<?>[parameterTypes.length];
    for (int i = 0, j = domainArgs.length; i < j; i++) {
        if (BaseProxy.class.isAssignableFrom(parameterTypes[i])) {
            domainArgs[i] = getTop().resolveDomainClass(parameterTypes[i].asSubclass(BaseProxy.class));
        } else if (EntityProxyId.class.isAssignableFrom(parameterTypes[i])) {
            domainArgs[i] = TypeUtils.ensureBaseType(TypeUtils.getSingleParameterization(EntityProxyId.class, requestContextMethod.getGenericParameterTypes()[i]));
        } else {
            domainArgs[i] = parameterTypes[i];
        }
    }
    Throwable ex;
    try {
        return searchIn.getMethod(requestContextMethod.getName(), domainArgs);
    } catch (SecurityException e) {
        ex = e;
    } catch (NoSuchMethodException e) {
        return report("String_Node_Str", requestContextMethod.getName());
    }
    return die(ex, "String_Node_Str", requestContextMethod.getName(), searchIn.getCanonicalName());
}

Output:
 public Method resolveDomainMethod(Method requestContextMethod) {
-    Class<?> enclosing = requestContextMethod.getDeclaringClass();
-    Class<?> searchIn = null;
-    Service s = enclosing.getAnnotation(Service.class);
-    if (s != null) {
-        searchIn = s.value();
-    }
-    ServiceName sn = enclosing.getAnnotation(ServiceName.class);
-    if (sn != null) {
-        searchIn = forName(sn.value());
-    }
-    if (searchIn == null) {
-        die(null, "String_Node_Str", RequestContext.class.getSimpleName(), enclosing.getCanonicalName());
-    }
+    Class<?> declaringClass = requestContextMethod.getDeclaringClass();
+    Class<?> searchIn = getTop().resolveServiceClass(declaringClass.asSubclass(RequestContext.class));
     Class<?>[] parameterTypes = requestContextMethod.getParameterTypes();


Input:
public List<String> createForeignKeyStatements() throws SQLException {
    final List<String> result = new ArrayList<String>();
    for (final TableMetaData tableMetaData : _sourceDatabaseMetaData.getTableMetaData()) {
        final int counter = 1;
        final List<ColumnMetaData> columns = tableMetaData.getColumnMetaData();
        for (final ColumnMetaData columnMetaData : columns) {
            if (columnMetaData.getReferencedColumn() != null) {
                result.add(createForeignKeyForTable(columnMetaData, counter));
            }
        }
    }
    return result;
}

Output:
     for (final TableMetaData tableMetaData : _sourceDatabaseMetaData.getTableMetaData()) {
-        final int counter = 1;
+        int counter = 1;
         final List<ColumnMetaData> columns = tableMetaData.getColumnMetaData();


Input:
static Set<Webhook> webhookPrototypesWithTag(String tag) {
    Set<Webhook> webhookSet = new HashSet<>(webhookDao.getAll(false));
    Set<Webhook> result = webhookSet.stream().filter(wh -> Objects.equals(tag, wh.getTag()) && wh.isTagPrototype()).collect(Collectors.toSet());
    return result;
}

Output:
     Set<Webhook> webhookSet = new HashSet<>(webhookDao.getAll(false));
-    Set<Webhook> result = webhookSet.stream().filter(wh -> Objects.equals(tag, wh.getTag()) && wh.isTagPrototype()).collect(Collectors.toSet());
+    Set<Webhook> result = webhookSet.stream().filter(wh -> wh.isTagPrototype() && Objects.equals(tag, wh.getTagFromTagUrl())).collect(Collectors.toSet());
     return result;


Input:
private boolean allWhiteSpace(StringBuffer sb) {
    int length = sb.length();
    for (int i = 0; i < length; i += 1) {
        if (!Character.isWhitespace(sb.charAt(i))) {
            return false;
        }
    }
    return true;
}

Output:
     int length = sb.length();
-    for (int i = 0; i < length; i += 1) {
-        if (!Character.isWhitespace(sb.charAt(i))) {
-            return false;
-        }
-    }
+    for (int i = 0; i < length; i += 1) if (!Character.isWhitespace(sb.charAt(i)))
+        return false;
     return true;


Input:
public void refresh() {
    lock.lock();
    try {
        for (WalletPocket pocket : getPockets()) {
            pocket.refresh();
        }
        saveNow();
    } finally {
        lock.unlock();
    }
}

Output:
         }
-        saveNow();
+        saveLater();
     } finally {


Input:
private void write(OperationContext context, MetaDataEntry expected, MetaDataEntry entry, boolean isUpdate, boolean resolve) throws OperationException {
    if (entry == null)
        throw new IllegalArgumentException("String_Node_Str");
    byte[] rowkey = makeRowKey(entry);
    byte[] column = makeColumnKey(entry);
    byte[] bytes;
    try {
        bytes = getSerializer().serialize(entry);
    } catch (MetaDataException e) {
        throw new OperationException(StatusCode.INTERNAL_ERROR, e.getMessage(), e.getCause());
    }
    OperationResult<Map<byte[], byte[]>> result;
    try {
        Read read = new Read(tableName, rowkey, column);
        result = opex.execute(context, read);
    } catch (OperationException e) {
        String message = String.format("String_Node_Str", e.getMessage());
        Log.error(message, e);
        throw new OperationException(e.getStatus(), message, e);
    }
    byte[] bytesRead = null;
    if (!result.isEmpty())
        bytesRead = result.getValue().get(column);
    if (!isUpdate && bytesRead != null) {
        if (resolve && Arrays.equals(bytes, bytesRead)) {
            return;
        }
        String message = String.format("String_Node_Str", entry);
        Log.debug(message);
        throw new OperationException(StatusCode.WRITE_CONFLICT, message);
    }
    if (isUpdate) {
        if (bytesRead == null) {
            String message = String.format("String_Node_Str", entry);
            Log.debug(message);
            throw new OperationException(StatusCode.ENTRY_NOT_FOUND, message);
        }
        if (expected != null) {
            byte[] expectedBytes;
            try {
                expectedBytes = getSerializer().serialize(expected);
            } catch (MetaDataException e) {
                throw new OperationException(StatusCode.INTERNAL_ERROR, e.getMessage(), e);
            }
            if (!Arrays.equals(bytesRead, expectedBytes)) {
                if (resolve && Arrays.equals(bytesRead, bytes)) {
                    return;
                }
                String message = String.format("String_Node_Str" + "String_Node_Str", entry);
                Log.trace(message);
                throw new OperationException(StatusCode.WRITE_CONFLICT, message);
            }
        }
    }
    try {
        if (isUpdate && expected == null) {
            Write write = new Write(tableName, rowkey, column, bytes);
            opex.commit(context, write);
        } else {
            CompareAndSwap compareAndSwap = new CompareAndSwap(tableName, rowkey, column, bytesRead, bytes);
            opex.commit(context, compareAndSwap);
        }
    } catch (OperationException e) {
        if (resolve && e.getStatus() == StatusCode.WRITE_CONFLICT) {
            try {
                Read read = new Read(tableName, rowkey, column);
                result = opex.execute(context, read);
                if (!result.isEmpty() && Arrays.equals(bytes, result.getValue().get(column)))
                    return;
            } catch (OperationException e1) {
                String message = String.format("String_Node_Str", e1.getMessage());
                Log.error(message, e1);
                throw new OperationException(e.getStatus(), message, e1);
            }
        }
        String message = String.format("String_Node_Str", e.getMessage());
        if (e.getStatus() != StatusCode.WRITE_CONFLICT)
            Log.error(message, e);
        throw new OperationException(e.getStatus(), message, e);
    }
}

Output:
         Log.debug(message);
-        throw new OperationException(StatusCode.WRITE_CONFLICT, message);
+        throw new OperationException(StatusCode.ENTRY_EXISTS, message);
     }


Input:
public Long newOid(EClass eClass) {
    return database.newOid(eClass);
}

Output:
 public Long newOid(EClass eClass) {
-    return database.newOid(eClass);
+    long newOid = database.newOid(eClass);
+    return newOid;
 }


Input:
public OrderItemsBean transformToOrderItemFormBean(OrderItems entity) {
    OrderItemsBean formBean = new OrderItemsBean();
    Trucks truckEntityOri = vendorService.findTrucksByTruckCode(entity.getTruckOrigin());
    Trucks truckEntityDes = vendorService.findTrucksByTruckCode(entity.getTruckDestination());
    formBean.setNameSize(entity.getNameSize());
    formBean.setStatus(entity.getStatus());
    formBean.setOrderItemId(entity.getOrderItemId());
    formBean.setClientId(entity.getClientId());
    formBean.setNameSize(entity.getNameSize());
    formBean.setOrderId(entity.getOrderId());
    formBean.setQuantity(entity.getQuantity());
    formBean.setClassification(entity.getClassification());
    formBean.setDescription(entity.getCommodity());
    formBean.setDeclaredValue(entity.getDeclaredValue());
    formBean.setRemarks(entity.getComments());
    formBean.setRate(entity.getRate());
    formBean.setCreatedTimestamp(entity.getCreatedTimestamp());
    formBean.setCreatedBy(entity.getCreatedBy());
    formBean.setModifiedBy(entity.getModifiedBy());
    formBean.setModifiedTimestamp(entity.getModifiedTimestamp());
    formBean.setStatus(entity.getStatus());
    formBean.setWeight(entity.getWeight());
    if (truckEntityOri == null || truckEntityOri.equals("String_Node_Str")) {
        formBean.setPlateNumber("String_Node_Str");
    } else {
        formBean.setPlateNumber(vendorService.findTrucksByTruckCode(entity.getTruckOrigin()).getPlateNumber());
    }
    if (entity.getVendorSea() == null || "String_Node_Str".equals(entity.getVendorSea()) || "String_Node_Str".equals(entity.getVendorSea())) {
        formBean.setVendorSea("String_Node_Str");
    } else {
        formBean.setVendorSea(entity.getVendorSea());
    }
    Orders orderCheck = orderService.findOrdersById(entity.getOrderId());
    if (orderCheck.getServiceMode().equals("String_Node_Str")) {
        formBean.setVendorOrigin("String_Node_Str");
        formBean.setVendorOriginName("String_Node_Str");
        formBean.setFinalPickupDate("String_Node_Str");
        if (entity.getVendorDestination() != null) {
            formBean.setVendorDestination(entity.getVendorDestination());
            formBean.setVendorDestinationName(vendorService.findVendorByVendorCode(entity.getVendorDestination()).getVendorName());
        } else {
            formBean.setVendorDestination("String_Node_Str");
            formBean.setVendorDestinationName("String_Node_Str");
        }
        formBean.setFinalDeliveryDate(entity.getFinalDeliveryDate());
    } else if (orderCheck.getServiceMode().equals("String_Node_Str")) {
        if (entity.getVendorOrigin() != null) {
            formBean.setVendorOrigin(entity.getVendorOrigin());
            formBean.setVendorOriginName(vendorService.findVendorByVendorCode(entity.getVendorOrigin()).getVendorName());
        } else {
            formBean.setVendorOrigin("String_Node_Str");
            formBean.setVendorOriginName("String_Node_Str");
        }
        formBean.setFinalPickupDate(entity.getFinalPickupDate());
        formBean.setVendorDestination("String_Node_Str");
        formBean.setVendorDestinationName("String_Node_Str");
        formBean.setFinalDeliveryDate("String_Node_Str");
    } else if (orderCheck.getServiceMode().equals("String_Node_Str")) {
        formBean.setVendorOrigin("String_Node_Str");
        formBean.setVendorOriginName("String_Node_Str");
        formBean.setFinalPickupDate("String_Node_Str");
        formBean.setVendorDestination("String_Node_Str");
        formBean.setVendorDestinationName("String_Node_Str");
        formBean.setFinalDeliveryDate("String_Node_Str");
    } else if (orderCheck.getServiceType().equals("String_Node_Str")) {
        if (entity.getVendorOrigin() != null) {
            formBean.setVendorOrigin(entity.getVendorOrigin());
            formBean.setVendorOriginName(vendorService.findVendorByVendorCode(entity.getVendorOrigin()).getVendorName());
        } else {
            formBean.setVendorOrigin("String_Node_Str");
            formBean.setVendorOriginName("String_Node_Str");
        }
        formBean.setFinalPickupDate(entity.getFinalPickupDate());
        formBean.setVendorDestination("String_Node_Str");
        formBean.setVendorDestinationName("String_Node_Str");
        formBean.setFinalDeliveryDate("String_Node_Str");
    } else {
        if (entity.getVendorOrigin() == null || "String_Node_Str".equals(entity.getVendorOrigin()) || "String_Node_Str".equals(entity.getVendorOrigin())) {
            formBean.setVendorOrigin("String_Node_Str");
            formBean.setVendorOriginName("String_Node_Str");
            formBean.setFinalPickupDate("String_Node_Str");
        } else {
            formBean.setVendorOrigin(entity.getVendorOrigin());
            formBean.setVendorOriginName(vendorService.findVendorByVendorCode(entity.getVendorOrigin()).getVendorName());
            formBean.setFinalPickupDate(entity.getFinalPickupDate());
        }
        if (entity.getVendorDestination() == null || "String_Node_Str".equals(entity.getVendorDestination()) || "String_Node_Str".equals(entity.getVendorDestination())) {
            formBean.setVendorDestination("String_Node_Str");
            formBean.setVendorDestinationName("String_Node_Str");
            formBean.setFinalDeliveryDate("String_Node_Str");
        } else {
            formBean.setVendorDestination(entity.getVendorDestination());
            formBean.setVendorDestinationName(vendorService.findVendorByVendorCode(entity.getVendorDestination()).getVendorName());
            formBean.setFinalDeliveryDate(entity.getFinalDeliveryDate());
        }
    }
    if (entity.getVesselScheduleId() == null || "String_Node_Str".equals(entity.getVesselScheduleId()) || "String_Node_Str".equals(entity.getVesselScheduleId())) {
        formBean.setVesselScheduleId("String_Node_Str");
        formBean.setVesselName("String_Node_Str");
        formBean.setVendorName("String_Node_Str");
        formBean.setDepartureDate("String_Node_Str");
        formBean.setArrivalDate("String_Node_Str");
    } else {
        formBean.setVesselScheduleId(entity.getVesselScheduleId());
        formBean.setVesselName(vesselSchedulesService.findVesselSchedulesByIdVoyageNumber(entity.getVesselScheduleId()).getVesselName());
        formBean.setVendorName(vendorService.findVendorByVendorCode(entity.getVendorSea()).getVendorName());
        formBean.setDepartureDate(vesselSchedulesService.findVesselSchedulesByIdVoyageNumber(entity.getVesselScheduleId()).getDepartureDate());
        formBean.setArrivalDate(vesselSchedulesService.findVesselSchedulesByIdVoyageNumber(entity.getVesselScheduleId()).getArrivalDate());
    }
    formBean.setFinalPickupDate(entity.getFinalPickupDate());
    formBean.setFinalDeliveryDate(entity.getFinalDeliveryDate());
    formBean.setDriverOrigin(entity.getDriverOrigin());
    formBean.setDriverDestination(entity.getDriverDestination());
    formBean.setTruckOrigin(entity.getTruckOrigin());
    formBean.setTruckDestination(entity.getTruckDestination());
    formBean.setVolume(entity.getVolume());
    formBean.setContainerId(entity.getContainerId());
    return formBean;
}

Output:
         formBean.setFinalPickupDate("String_Node_Str");
-        if (entity.getVendorDestination() != null) {
-            formBean.setVendorDestination(entity.getVendorDestination());
-            formBean.setVendorDestinationName(vendorService.findVendorByVendorCode(entity.getVendorDestination()).getVendorName());
-        } else {
+        if (entity.getVendorDestination() == null || "String_Node_Str".equals(entity.getVendorDestination())) {
             formBean.setVendorDestination("String_Node_Str");


Input:
public String s() {
    if (PlotMain.translations != null) {
        String t = PlotMain.translations.getString(this.toString());
        if (t != null) {
            this.s = t;
        }
    }
    if (this.s.length() < 1) {
        return this.d.replace("String_Node_Str", "String_Node_Str");
    }
    return this.s.replace("String_Node_Str", "String_Node_Str");
}

Output:
     if (this.s.length() < 1) {
-        return this.d.replace("String_Node_Str", "String_Node_Str");
+        return "String_Node_Str";
     }


Input:
public boolean equals(Object obj) {
    if (obj instanceof ElementRefValue) {
        ElementRefValue value = (ElementRefValue) obj;
        if (this.isResolved() == value.isResolved()) {
            if (value.isResolved()) {
                return getElement().equals(value.getElement());
            }
            return getLibraryNamespace().equals(value.getLibraryNamespace()) && getName().equals(value.getName());
        }
        return false;
    }
    return false;
}

Output:
 public boolean equals(Object obj) {
-    if (obj instanceof ElementRefValue) {
-        ElementRefValue value = (ElementRefValue) obj;
-        if (this.isResolved() == value.isResolved()) {
-            if (value.isResolved()) {
-                return getElement().equals(value.getElement());
-            }
-            return getLibraryNamespace().equals(value.getLibraryNamespace()) && getName().equals(value.getName());
-        }
+    if (!(obj instanceof ElementRefValue))
         return false;