Input:
public UserVmResponse createUserVmResponse(UserVm userVm) {
    UserVmResponse userVmResponse = new UserVmResponse();
    Account acct = ApiDBUtils.findAccountById(Long.valueOf(userVm.getAccountId()));
    if ((acct != null) && (acct.getRemoved() == null)) {
        userVmResponse.setAccountName(acct.getAccountName());
        userVmResponse.setDomainId(acct.getDomainId());
        userVmResponse.setDomainName(ApiDBUtils.findDomainById(acct.getDomainId()).getName());
    } else {
        return null;
    }
    userVmResponse.setId(userVm.getId());
    userVmResponse.setName(userVm.getHostName());
    userVmResponse.setCreated(userVm.getCreated());
    if (userVm.getState() != null) {
        userVmResponse.setState(userVm.getState().toString());
    }
    userVmResponse.setHaEnable(userVm.isHaEnabled());
    if (userVm.getDisplayName() != null) {
        userVmResponse.setDisplayName(userVm.getDisplayName());
    } else {
        userVmResponse.setDisplayName(userVm.getHostName());
    }
    InstanceGroupVO group = ApiDBUtils.findInstanceGroupForVM(userVm.getId());
    if (group != null) {
        userVmResponse.setGroup(group.getName());
        userVmResponse.setGroupId(group.getId());
    }
    userVmResponse.setZoneId(userVm.getDataCenterId());
    userVmResponse.setZoneName(ApiDBUtils.findZoneById(userVm.getDataCenterId()).getName());
    Account account = UserContext.current().getAccount();
    if (((account == null) || (account.getType() == Account.ACCOUNT_TYPE_ADMIN)) && (userVm.getHostId() != null)) {
        userVmResponse.setHostId(userVm.getHostId());
        userVmResponse.setHostName(ApiDBUtils.findHostById(userVm.getHostId()).getName());
    }
    VMTemplateVO template = ApiDBUtils.findTemplateById(userVm.getTemplateId());
    if (template != null) {
        userVmResponse.setTemplateId(userVm.getTemplateId());
        userVmResponse.setTemplateName(template.getName());
        userVmResponse.setTemplateDisplayText(template.getDisplayText());
        userVmResponse.setPasswordEnabled(template.getEnablePassword());
    } else {
        userVmResponse.setTemplateId(-1L);
        userVmResponse.setTemplateName("String_Node_Str");
        userVmResponse.setTemplateDisplayText("String_Node_Str");
        userVmResponse.setPasswordEnabled(false);
    }
    if (userVm.getPassword() != null) {
        userVmResponse.setPassword(userVm.getPassword());
    }
    if (userVm.getIsoId() != null) {
        VMTemplateVO iso = ApiDBUtils.findTemplateById(userVm.getIsoId());
        if (iso != null) {
            userVmResponse.setIsoId(userVm.getIsoId());
            userVmResponse.setIsoName(iso.getName());
        }
    }
    ServiceOffering offering = ApiDBUtils.findServiceOfferingById(userVm.getServiceOfferingId());
    userVmResponse.setServiceOfferingId(userVm.getServiceOfferingId());
    userVmResponse.setServiceOfferingName(offering.getName());
    userVmResponse.setCpuNumber(offering.getCpu());
    userVmResponse.setCpuSpeed(offering.getSpeed());
    userVmResponse.setMemory(offering.getRamSize());
    VolumeVO rootVolume = ApiDBUtils.findRootVolume(userVm.getId());
    if (rootVolume != null) {
        userVmResponse.setRootDeviceId(rootVolume.getDeviceId());
        String rootDeviceType = "String_Node_Str";
        if (rootVolume.getPoolId() != null) {
            StoragePoolVO storagePool = ApiDBUtils.findStoragePoolById(rootVolume.getPoolId());
            rootDeviceType = storagePool.getPoolType().toString();
        }
        userVmResponse.setRootDeviceType(rootDeviceType);
    }
    DecimalFormat decimalFormat = new DecimalFormat("String_Node_Str");
    String cpuUsed = null;
    VmStats vmStats = ApiDBUtils.getVmStatistics(userVm.getId());
    if (vmStats != null) {
        float cpuUtil = (float) vmStats.getCPUUtilization();
        cpuUsed = decimalFormat.format(cpuUtil) + "String_Node_Str";
        userVmResponse.setCpuUsed(cpuUsed);
        Long networkKbRead = Double.doubleToLongBits(vmStats.getNetworkReadKBs());
        userVmResponse.setNetworkKbsRead(networkKbRead);
        Long networkKbWrite = Double.doubleToLongBits(vmStats.getNetworkWriteKBs());
        userVmResponse.setNetworkKbsWrite(networkKbWrite);
    }
    userVmResponse.setGuestOsId(userVm.getGuestOSId());
    userVmResponse.setNetworkGroupList(ApiDBUtils.getNetworkGroupsNamesForVm(userVm.getId()));
    List<? extends Nic> nics = ApiDBUtils.getNics(userVm);
    List<NicResponse> nicResponses = new ArrayList<NicResponse>();
    for (Nic singleNic : nics) {
        NicResponse nicResponse = new NicResponse();
        nicResponse.setId(singleNic.getId());
        nicResponse.setIpaddress(singleNic.getIp4Address());
        nicResponse.setGateway(singleNic.getGateway());
        nicResponse.setNetmask(singleNic.getNetmask());
        nicResponse.setNetworkid(singleNic.getNetworkId());
        if (acct.getType() == Account.ACCOUNT_TYPE_ADMIN) {
            if (singleNic.getBroadcastUri() != null) {
                nicResponse.setBroadcastUri(singleNic.getBroadcastUri().toString());
            }
            if (singleNic.getIsolationUri() != null) {
                nicResponse.setIsolationUri(singleNic.getIsolationUri().toString());
            }
        }
        Network network = ApiDBUtils.findNetworkById(singleNic.getNetworkId());
        nicResponse.setTrafficType(network.getTrafficType().toString());
        NetworkOffering networkOffering = ApiDBUtils.findNetworkOfferingById(network.getNetworkOfferingId());
        if (networkOffering.getGuestIpType() != null) {
            nicResponse.setType(networkOffering.getGuestIpType().toString());
        }
        nicResponse.setObjectName("String_Node_Str");
        nicResponses.add(nicResponse);
    }
    userVmResponse.setNics(nicResponses);
    userVmResponse.setObjectName("String_Node_Str");
    return userVmResponse;
}

Output:
     userVmResponse.setId(userVm.getId());
-    userVmResponse.setName(userVm.getHostName());
+    userVmResponse.setName(userVm.getName());
     userVmResponse.setCreated(userVm.getCreated());


Input:
private void deleteCredentialsInSmartLock() {
    if (isSmartLockAvailable()) {
        return;
    }
    Credential credential = new Credential.Builder(mUsername).setPassword(mPassword).build();
    Auth.CredentialsApi.delete(mCredentialsClient, credential).setResultCallback(new ResultCallback<Status>() {
        public void onResult(Status status) {
            AppLog.i(T.NUX, status.isSuccess() ? "String_Node_Str" + mUsername : "String_Node_Str" + mUsername);
        }
    });
}

Output:
 private void deleteCredentialsInSmartLock() {
-    if (isSmartLockAvailable()) {
+    if (!isSmartLockAvailable()) {
         return;


Input:
public void roomInformationTest() {
    ArrayList<RoomInformation> roomInformation = message.rooms;
    assertEquals(5, roomInformation.size());
    assertEquals("String_Node_Str", roomInformation.get(0).getName());
}

Output:
 public void roomInformationTest() {
-    ArrayList<RoomInformation> roomInformation = message.rooms;
+    List<RoomInformation> roomInformation = message.rooms;
     assertEquals(5, roomInformation.size());


Input:
private static boolean isAggregationBinding(String bindingName, List bindings) throws DataException {
    boolean find = false;
    for (int i = 0; i < bindings.size(); i++) {
        IBinding binding = (IBinding) bindings.get(i);
        if (bindingName.equals(binding.getBindingName())) {
            find = true;
            if (OlapExpressionUtil.isAggregationBinding(binding))
                return true;
            List refBindingName = ExpressionCompilerUtil.extractColumnExpression(binding.getExpression(), ScriptConstants.DATA_BINDING_SCRIPTABLE);
            for (int j = 0; j < refBindingName.size(); j++) {
                if (isAggregationBinding((String) refBindingName.get(j), bindings))
                    return true;
            }
        }
    }
    if (!find)
        return true;
    return false;
}

Output:
             find = true;
-            if (OlapExpressionUtil.isAggregationBinding(binding))
+            if (OlapExpressionUtil.isAggregationBinding(binding)) {
                 return true;


Input:
public static Collection<AbstractProcessProvider> findAllProcessProviders() {
    if (providerMap.isEmpty()) {
        IConfigurationElement[] elems = Platform.getExtensionRegistry().getConfigurationElementsFor(EXTENSION_ID);
        for (IConfigurationElement elem : elems) {
            String pid = elem.getAttribute(ATTR_PID);
            try {
                AbstractProcessProvider createExecutableExtension = (AbstractProcessProvider) elem.createExecutableExtension(ATTR_CLASS);
                providerMap.put(pid, createExecutableExtension);
            } catch (CoreException ex) {
                ExceptionHandler.process(ex);
            }
        }
    }
    return providerMap.values();
}

Output:
             try {
-                AbstractProcessProvider createExecutableExtension = (AbstractProcessProvider) elem.createExecutableExtension(ATTR_CLASS);
-                providerMap.put(pid, createExecutableExtension);
+                Object provider = elem.createExecutableExtension(ATTR_CLASS);
+                if (provider instanceof AbstractProcessProvider) {
+                    AbstractProcessProvider createExecutableExtension = (AbstractProcessProvider) provider;
+                    providerMap.put(pid, createExecutableExtension);
+                }
             } catch (CoreException ex) {


Input:
public void paste() {
    Clipboard clipboard = java.awt.Toolkit.getDefaultToolkit().getSystemClipboard();
    Transferable transferable = clipboard.getContents(this);
    GraphModel model = _getGraphModel();
    if (transferable == null) {
        return;
    }
    try {
        NamedObj container = (NamedObj) model.getRoot();
        StringBuffer moml = new StringBuffer();
        moml.append("String_Node_Str");
        moml.append(offsetPastedMomlLocation((String) transferable.getTransferData(DataFlavor.stringFlavor), 10, 10));
        moml.append("String_Node_Str");
        MoMLChangeRequest change = new MoMLChangeRequest(this, container, moml.toString());
        change.setUndoable(true);
        container.requestChange(change);
    } catch (Exception ex) {
        MessageHandler.error("String_Node_Str", ex);
    }
}

Output:
         moml.append("String_Node_Str");
-        moml.append(offsetPastedMomlLocation((String) transferable.getTransferData(DataFlavor.stringFlavor), 10, 10));
+        moml.append(_offsetPastedMomlLocation((String) transferable.getTransferData(DataFlavor.stringFlavor), 10, 10));
         moml.append("String_Node_Str");


Input:
private void onSyncPackageJson(Config conf, Path workDirectory, Throwing.Consumer<String> action) throws IOException {
    Path tmp = Paths.get(conf.getString("String_Node_Str"), "String_Node_Str");
    Files.createDirectories(tmp);
    Throwing.Consumer<String> syncPackageJson = existingSha1 -> {
        Path packageJson = workDirectory.resolve("String_Node_Str");
        String sha1 = Hashing.sha1().hashBytes(Files.readAllBytes(packageJson)).toString();
        if (!existingSha1.equals(sha1)) {
            action.accept("String_Node_Str");
            Files.write(tmp.resolve("String_Node_Str" + sha1), Arrays.asList("String_Node_Str"));
        }
    };
    if (!Files.exists(workDirectory.resolve("String_Node_Str"))) {
        syncPackageJson.accept("String_Node_Str");
    } else {
        String existingSha1 = Files.find(tmp, 1, (path, attr) -> path.getFileName().toString().startsWith("String_Node_Str")).findFirst().map(path -> path.getFileName().toString().replace("String_Node_Str", "String_Node_Str")).orElse("String_Node_Str");
        syncPackageJson.accept(existingSha1);
    }
}

Output:
     Files.createDirectories(tmp);
-    Throwing.Consumer<String> syncPackageJson = existingSha1 -> {
-        Path packageJson = workDirectory.resolve("String_Node_Str");
-        String sha1 = Hashing.sha1().hashBytes(Files.readAllBytes(packageJson)).toString();
-        if (!existingSha1.equals(sha1)) {
-            action.accept("String_Node_Str");
-            Files.write(tmp.resolve("String_Node_Str" + sha1), Arrays.asList("String_Node_Str"));
-        }
-    };
-    if (!Files.exists(workDirectory.resolve("String_Node_Str"))) {
-        syncPackageJson.accept("String_Node_Str");
-    } else {
-        String existingSha1 = Files.find(tmp, 1, (path, attr) -> path.getFileName().toString().startsWith("String_Node_Str")).findFirst().map(path -> path.getFileName().toString().replace("String_Node_Str", "String_Node_Str")).orElse("String_Node_Str");
-        syncPackageJson.accept(existingSha1);
+    String sha1 = Hashing.sha1().hashBytes(Files.readAllBytes(workDirectory.resolve("String_Node_Str"))).toString();
+    Path lastSha1 = tmp.resolve(sha1 + "String_Node_Str");
+    if (!Files.exists(lastSha1) || !Files.exists(workDirectory.resolve("String_Node_Str"))) {
+        action.accept("String_Node_Str");
+        Files.write(tmp.resolve(lastSha1), Arrays.asList("String_Node_Str"));
     }


Input:
public String[] getOtherScores() {
    return null;
}

Output:
 public String[] getOtherScores() {
-    return null;
+    return new String[0];
 }


Input:
private <T extends Item> Collection<T> executeQuery(final AttributeQuery query, final Class<T> itemClass) {
    final Map<ItemId, T> allItems = getAllItems(itemClass);
    final Collection<T> matches = new ArrayList<>();
    for (final T item : allItems.values()) {
        final String attribute = query.getAttributeName();
        try {
            final Method getter = new PropertyDescriptor(attribute, item.getClass()).getReadMethod();
            final Object itemPropertyValue = getter.invoke(item);
            final Class<?> itemPropertyType = getter.getReturnType();
            final Condition condition = query.getCondition();
            final Set<String> values = condition.getValues();
            String singleValue = null;
            if (values != null && !values.isEmpty()) {
                singleValue = values.iterator().next();
            }
            final boolean isSingleItemProperty = !Collection.class.isAssignableFrom(itemPropertyType);
            String singleItemPropertyValue = null;
            if (isSingleItemProperty) {
                singleItemPropertyValue = String.valueOf(itemPropertyValue);
            }
            switch(query.getCondition().getComparisonOperator()) {
                case NULL:
                    if (itemPropertyValue == null) {
                        matches.add(item);
                    }
                    break;
                case NOT_NULL:
                    if (itemPropertyValue != null) {
                        matches.add(item);
                    }
                    break;
                case LESS_THAN_OR_EQUALS:
                    if (isSingleItemProperty && singleItemPropertyValue.compareTo(singleValue) >= 0) {
                        matches.add(item);
                    }
                    break;
                case GREATER_THAN_OR_EQUALS:
                    if (isSingleItemProperty && singleItemPropertyValue.compareTo(singleValue) <= 0) {
                        matches.add(item);
                    }
                    break;
                case EQUALS:
                    if (isSingleItemProperty && singleItemPropertyValue.equals(singleValue)) {
                        matches.add(item);
                    } else if (itemPropertyValue.equals(values)) {
                        matches.add(item);
                    }
                    break;
                default:
                    break;
            }
        } catch (final Exception e) {
            throw new IllegalStateException("String_Node_Str" + attribute + "String_Node_Str" + item.getClass() + "String_Node_Str");
        }
    }
    return matches;
}

Output:
                 case LESS_THAN_OR_EQUALS:
-                    if (isSingleItemProperty && singleItemPropertyValue.compareTo(singleValue) >= 0) {
+                    if (isSingleItemProperty && singleItemPropertyValue.compareTo(singleValue) <= 0) {
                         matches.add(item);


Input:
private File downloadPDB(String pdbId) {
    if ((path == null) || (path.equals("String_Node_Str"))) {
        String property = "String_Node_Str";
        String tempdir = System.getProperty(property);
        if (!(tempdir.endsWith(lineSplit)))
            tempdir = tempdir + lineSplit;
        System.err.println("String_Node_Str");
        System.err.println("String_Node_Str" + tempdir);
        path = tempdir;
    }
    File tempFile;
    if (pdbDirectorySplit) {
        String middle = pdbId.substring(1, 3).toLowerCase();
        String dir = path + lineSplit + middle;
        File directoryCheck = new File(dir);
        if (!directoryCheck.exists()) {
            directoryCheck.mkdir();
        }
        tempFile = new File(dir + lineSplit + "String_Node_Str" + pdbId.toLowerCase() + "String_Node_Str");
    } else {
        tempFile = new File(path + lineSplit + "String_Node_Str" + pdbId.toLowerCase() + "String_Node_Str");
    }
    String serverName = System.getProperty(PDB_FILE_SERVER_PROPERTY);
    if (serverName == null)
        serverName = DEFAULT_PDB_FILE_SERVER;
    String ftp = String.format("String_Node_Str", serverName, pdbId.toLowerCase());
    System.out.println("String_Node_Str" + ftp);
    System.out.println("String_Node_Str" + tempFile);
    try {
        URL url = new URL(ftp);
        InputStream conn = new GZIPInputStream(url.openStream());
        FileOutputStream outPut = new FileOutputStream(tempFile);
        GZIPOutputStream gzOutPut = new GZIPOutputStream(outPut);
        PrintWriter pw = new PrintWriter(gzOutPut);
        BufferedReader fileBuffer = new BufferedReader(new InputStreamReader(conn));
        String line;
        while ((line = fileBuffer.readLine()) != null) {
            pw.println(line);
        }
        pw.flush();
        pw.close();
        outPut.close();
        conn.close();
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
    return tempFile;
}

Output:
         URL url = new URL(ftp);
-        InputStream conn = new GZIPInputStream(url.openStream());
+        InputStream uStream = url.openStream();
+        InputStream conn = new GZIPInputStream(uStream);
         FileOutputStream outPut = new FileOutputStream(tempFile);


Input:
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.filtershow_activity);
    ActionBar actionBar = getActionBar();
    actionBar.setDisplayOptions(ActionBar.DISPLAY_SHOW_CUSTOM);
    actionBar.setCustomView(R.layout.filtershow_actionbar);
    actionBar.getCustomView().setOnClickListener(new OnClickListener() {
        public void onClick(View view) {
            saveImage();
        }
    });
    mImageLoader = new ImageLoader(getApplicationContext());
    LinearLayout listFilters = (LinearLayout) findViewById(R.id.listFilters);
    LinearLayout listBorders = (LinearLayout) findViewById(R.id.listBorders);
    mImageShow = (ImageShow) findViewById(R.id.imageShow);
    mImageCurves = (ImageCurves) findViewById(R.id.imageCurves);
    mImageBorders = (ImageBorder) findViewById(R.id.imageBorder);
    mImageStraighten = (ImageStraighten) findViewById(R.id.imageStraighten);
    mImageViews.add(mImageShow);
    mImageViews.add(mImageCurves);
    mImageViews.add(mImageBorders);
    mImageViews.add(mImageStraighten);
    mListFx = findViewById(R.id.fxList);
    mListBorders = findViewById(R.id.bordersList);
    mListGeometry = findViewById(R.id.gemoetryList);
    mListColors = findViewById(R.id.colorsFxList);
    mListViews.add(mListFx);
    mListViews.add(mListBorders);
    mListViews.add(mListGeometry);
    mListViews.add(mListColors);
    mFxButton = (ImageButton) findViewById(R.id.fxButton);
    mBorderButton = (ImageButton) findViewById(R.id.borderButton);
    mGeometryButton = (ImageButton) findViewById(R.id.geometryButton);
    mColorsButton = (ImageButton) findViewById(R.id.colorsButton);
    mBottomPanelButtons.add(mFxButton);
    mBottomPanelButtons.add(mBorderButton);
    mBottomPanelButtons.add(mGeometryButton);
    mBottomPanelButtons.add(mColorsButton);
    mFxButton.setSelected(true);
    mVignetteButton = (ImageButton) findViewById(R.id.vignetteButton);
    mCurvesButtonRGB = (ImageButton) findViewById(R.id.curvesButtonRGB);
    mSharpenButton = (ImageButton) findViewById(R.id.sharpenButton);
    mVibranceButton = (ImageButton) findViewById(R.id.vibranceButton);
    mContrastButton = (ImageButton) findViewById(R.id.contrastButton);
    mSaturationButton = (ImageButton) findViewById(R.id.saturationButton);
    mTintButton = (ImageButton) findViewById(R.id.tintButton);
    mExposureButton = (ImageButton) findViewById(R.id.exposureButton);
    mShadowRecoveryButton = (ImageButton) findViewById(R.id.shadowRecoveryButton);
    mColorsPanelButtons.add(mVignetteButton);
    mColorsPanelButtons.add(mCurvesButtonRGB);
    mColorsPanelButtons.add(mSharpenButton);
    mColorsPanelButtons.add(mContrastButton);
    mColorsPanelButtons.add(mSaturationButton);
    mColorsPanelButtons.add(mTintButton);
    mColorsPanelButtons.add(mVibranceButton);
    mColorsPanelButtons.add(mExposureButton);
    mColorsPanelButtons.add(mShadowRecoveryButton);
    findViewById(R.id.showOriginalButton).setOnTouchListener(createOnTouchShowOriginalButton());
    findViewById(R.id.straightenButton).setOnClickListener(createOnClickStraightenButton());
    findViewById(R.id.cropButton).setOnClickListener(createOnClickCropButton());
    findViewById(R.id.rotateButton).setOnClickListener(createOnClickRotateButton());
    findViewById(R.id.flipButton).setOnClickListener(createOnClickFlipButton());
    mVignetteButton.setOnClickListener(createOnClickVignetteButton());
    mCurvesButtonRGB.setOnClickListener(createOnClickCurvesRGBButton());
    mSharpenButton.setOnClickListener(createOnClickSharpenButton());
    mContrastButton.setOnClickListener(createOnClickContrastButton());
    mSaturationButton.setOnClickListener(createOnClickSaturationButton());
    mTintButton.setOnClickListener(createOnClickTintButton());
    mVibranceButton.setOnClickListener(createOnClickVibranceButton());
    mExposureButton.setOnClickListener(createOnClickExposureButton());
    mShadowRecoveryButton.setOnClickListener(createOnClickShadowRecoveryButton());
    mFxButton.setOnClickListener(createOnClickFxButton());
    mBorderButton.setOnClickListener(createOnClickBorderButton());
    mGeometryButton.setOnClickListener(createOnClickGeometryButton());
    mColorsButton.setOnClickListener(createOnClickColorsButton());
    findViewById(R.id.resetOperationsButton).setOnClickListener(createOnClickResetOperationsButton());
    ListView operationsList = (ListView) findViewById(R.id.operationsList);
    operationsList.setAdapter(mImageShow.getListAdapter());
    operationsList.setOnItemClickListener(this);
    mImageLoader.setAdapter((HistoryAdapter) mImageShow.getListAdapter());
    fillListImages(listFilters);
    fillListBorders(listBorders);
    mImageShow.setImageLoader(mImageLoader);
    mImageCurves.setImageLoader(mImageLoader);
    mImageCurves.setMaster(mImageShow);
    mImageBorders.setImageLoader(mImageLoader);
    mImageBorders.setMaster(mImageShow);
    mImageStraighten.setImageLoader(mImageLoader);
    mImageStraighten.setMaster(mImageShow);
    Intent intent = getIntent();
    String data = intent.getDataString();
    if (data != null) {
        Uri uri = Uri.parse(data);
        mImageLoader.loadBitmap(uri);
    } else {
        pickImage();
    }
}

Output:
     ListView operationsList = (ListView) findViewById(R.id.operationsList);
-    operationsList.setAdapter(mImageShow.getListAdapter());
+    operationsList.setAdapter(mImageShow.getHistoryAdapter());
     operationsList.setOnItemClickListener(this);


Input:
public void runInference() {
    nIter = 0;
    boolean convergence = false;
    probOfEvidence = Double.NEGATIVE_INFINITY;
    local_elbo = Double.NEGATIVE_INFINITY;
    local_iter = 0;
    int global_iter = 0;
    this.testConvergence();
    while (!convergence && (local_iter++) < maxIter) {
        boolean done = true;
        for (Node node : nodes) {
            if (!node.isActive() || node.isObserved() || plateuStructure.isNonReplicatedVar(node.getMainVariable()))
                continue;
            Message<NaturalParameters> selfMessage = newSelfMessage(node);
            Optional<Message<NaturalParameters>> message = node.getChildren().stream().filter(children -> children.isActive()).map(children -> newMessageToParent(children, node)).reduce(Message::combineNonStateless);
            if (message.isPresent())
                selfMessage.combine(message.get());
            updateCombinedMessage(node, selfMessage);
            done &= node.isDone();
        }
        convergence = this.testConvergence();
        if (done) {
            convergence = true;
        }
    }
    CompoundVector posteriorOLD = this.plateuStructure.getPlateauNaturalParameterPosterior();
    CompoundVector posteriorNew = this.plateuStructure.getPlateauNaturalParameterPosterior();
    int count = 0;
    for (Node node : nodes) {
        if (!node.isActive() || node.isObserved() || plateuStructure.isReplicatedVar(node.getMainVariable()))
            continue;
        Message<NaturalParameters> selfMessage = newSelfMessage(node);
        Optional<Message<NaturalParameters>> message = node.getChildren().stream().filter(children -> children.isActive()).map(children -> newMessageToParent(children, node)).reduce(Message::combineNonStateless);
        if (message.isPresent())
            selfMessage.combine(message.get());
        updateCombinedMessage(node, selfMessage);
        posteriorNew.setVectorByPosition(count, node.getQDist().getNaturalParameters());
        node.getQDist().setNaturalParameters((NaturalParameters) posteriorOLD.getVectorByPosition(count));
        node.getQDist().fixNumericalInstability();
        node.getQDist().updateMomentFromNaturalParameters();
        count++;
    }
    this.plateuStructure.updateNaturalParameterPosteriors(posteriorNew);
    probOfEvidence = local_elbo;
    probOfEvidence = local_elbo;
    if (output) {
        System.out.println("String_Node_Str" + global_iter + "String_Node_Str" + local_iter + "String_Node_Str" + local_elbo);
        logger.info("String_Node_Str", global_iter, local_iter, local_elbo);
    }
    nIter = local_iter;
}

Output:
     for (Node node : nodes) {
-        if (!node.isActive() || node.isObserved() || plateuStructure.isReplicatedVar(node.getMainVariable()))
+        if (node.isObserved() || plateuStructure.isReplicatedVar(node.getMainVariable()))
             continue;


Input:
public int getInitialColumnWidth(int index) {
    return 100;
}

Output:
 public int getInitialColumnWidth(int index) {
-    return 100;
+    return ListViewTableCellEditor.WIDTH;
 }


Input:
public static int getApproximateMaxSize(MaxSizeConfig maxSizeConfig, MaxSizePolicy policy) {
    if (maxSizeConfig.getMaxSizePolicy() == policy) {
        return getApproximateMaxSize(maxSizeConfig.getSize());
    }
    return -1;
}

Output:
     }
-    return -1;
+    return -1D;
 }


Input:
public static void copyFolder(File resFolder, File destFolder, boolean interruptable) throws Exception {
    Thread currentThread = Thread.currentThread();
    if (interruptable && currentThread.isInterrupted()) {
        throw new InterruptedException();
    }
    if (!resFolder.exists()) {
        return;
    }
    destFolder.mkdirs();
    String[] file = resFolder.list();
    File temp = null;
    for (String element : file) {
        if (interruptable && currentThread.isInterrupted()) {
            throw new InterruptedException();
        }
        temp = new File(resFolder, element);
        if (temp.isFile()) {
            FileInputStream input = new FileInputStream(temp);
            FileOutputStream output = new FileOutputStream(new File(destFolder, temp.getName()));
            byte[] b = new byte[1024 * 5];
            int len;
            while ((len = input.read(b)) != -1) {
                if (interruptable && currentThread.isInterrupted()) {
                    break;
                }
                output.write(b, 0, len);
            }
            output.flush();
            output.close();
            input.close();
        }
        if (temp.isDirectory()) {
            copyFolder(new File(resFolder, element), new File(destFolder, element));
        }
    }
}

Output:
         if (temp.isDirectory()) {
-            copyFolder(new File(resFolder, element), new File(destFolder, element));
+            copyFolder(new File(resFolder, element), new File(destFolder, element), interruptable);
         }


Input:
public void autoMap(String currentSchema) {
    if (this.hl7Manager instanceof HL7OutputManager) {
        List<HL7TreeNode> roots = this.hl7Manager.getTreeData(currentSchema);
        List<HL7TreeNode> mappableNodes = new ArrayList<HL7TreeNode>();
        for (HL7TreeNode root : roots) {
            getMappableNode((Element) root, mappableNodes);
        }
        List<IMetadataColumn> schemaData = this.hl7Manager.getSchemaData(currentSchema);
        for (HL7TreeNode node : mappableNodes) {
            for (IMetadataColumn column : schemaData) {
                if (node.getLabel().equals(column.getLabel())) {
                    node.setDefaultValue(null);
                    node.setColumn(column);
                    break;
                }
            }
        }
        this.hl7UI.redrawLinkers();
        return;
    }
    this.hl7UI.autoMap();
}

Output:
     if (this.hl7Manager instanceof HL7OutputManager) {
-        List<HL7TreeNode> roots = this.hl7Manager.getTreeData(currentSchema);
+        List<HL7TreeNode> roots = this.hl7Manager.getTreeData("String_Node_Str");
         List<HL7TreeNode> mappableNodes = new ArrayList<HL7TreeNode>();


Input:
static boolean isSameType(Object model1, Object model2) {
    if ((model1 instanceof TdTable || model1 instanceof TdColumn) && (model2 instanceof TdTable || model2 instanceof TdColumn)) {
        if (model1 instanceof TdTable && model2 instanceof TdTable) {
            return true;
        } else if (model1 instanceof TdColumn && model2 instanceof TdColumn) {
            return true;
        }
    }
    return false;
}

Output:
 static boolean isSameType(Object model1, Object model2) {
-    if ((model1 instanceof TdTable || model1 instanceof TdColumn) && (model2 instanceof TdTable || model2 instanceof TdColumn)) {
-        if (model1 instanceof TdTable && model2 instanceof TdTable) {
-            return true;
-        } else if (model1 instanceof TdColumn && model2 instanceof TdColumn) {
-            return true;
-        }
+    if (model1 instanceof TdTable && model2 instanceof TdTable) {
+        return true;
+    }
+    if (model1 instanceof TdColumn && model2 instanceof TdColumn) {
+        return true;
     }


Input:
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
    logger.trace("String_Node_Str" + msg);
    if (msg instanceof DataFrame) {
        ZWaveDataFrameTransactionInboundHandler transactionHandler = (ZWaveDataFrameTransactionInboundHandler) ctx.pipeline().get("String_Node_Str");
        if (transactionHandler != null) {
            DataFrame frame = (DataFrame) msg;
            if (transactionHandler.hasCurrentRequestTransaction()) {
                logger.trace("String_Node_Str" + frame + "String_Node_Str" + pendingQueue.size());
                pendingQueue.add(frame);
            } else {
                logger.trace("String_Node_Str", frame);
                ctx.writeAndFlush(msg, promise);
                frame.incremenentSendCount();
                transactionHandler.onDataFrameWrite(frame);
            }
        } else {
            logger.error("String_Node_Str");
        }
    } else {
        ctx.writeAndFlush(msg, promise);
    }
}

Output:
                 logger.trace("String_Node_Str" + frame + "String_Node_Str" + pendingQueue.size());
-                pendingQueue.add(frame);
+                pendingQueue.add(new FrameWrite(frame, promise));
             } else {


Input:
public WishlistComponentCursor queryWishlistComponent(long wc_id, long item_id) {
    String[] wcColumns = null;
    String wcSelection = "String_Node_Str" + S.COLUMN_WISHLIST_COMPONENT_WISHLIST_ID + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + S.COLUMN_WISHLIST_COMPONENT_COMPONENT_ID + "String_Node_Str";
    String[] wcSelectionArgs = new String[] { String.valueOf(wc_id), String.valueOf(item_id) };
    String wcGroupBy = null;
    String wcHaving = null;
    String wcOrderBy = null;
    String wcLimit = null;
    SQLiteQueryBuilder qb = builderWishlistComponent();
    Cursor cursor = qb.query(getReadableDatabase(), wcColumns, wcSelection, wcSelectionArgs, wcGroupBy, wcHaving, wcOrderBy, wcLimit);
    return new WishlistComponentCursor(cursor);
}

Output:
     SQLiteQueryBuilder qb = builderWishlistComponent();
-    Cursor cursor = qb.query(getReadableDatabase(), wcColumns, wcSelection, wcSelectionArgs, wcGroupBy, wcHaving, wcOrderBy, wcLimit);
+    Cursor cursor = qb.query(getWritableDatabase(), wcColumns, wcSelection, wcSelectionArgs, wcGroupBy, wcHaving, wcOrderBy, wcLimit);
     return new WishlistComponentCursor(cursor);


Input:
public Map tick() {
    if (game == null) {
        ENGINE_LOGGER.critical("String_Node_Str");
        return null;
    }
    if (_isPlayerTurn) {
        List<ScriptCommand> playerCommands = this.gameGUI.getCommandObjects();
        boolean playerCommandExecuted = false;
        for (ScriptCommand pc : playerCommands) {
            boolean executed = pc.doCommand(this.game, 0);
            if (executed) {
                playerCommandExecuted = true;
                break;
            }
        }
        if (!playerCommandExecuted)
            this.game.doNothing(0);
    } else {
        boolean computerCommandExecuted = false;
        for (ScriptCommand cc : this.cpuCommands) {
            boolean executed = cc.doCommand(this.game, 1);
            if (executed) {
                computerCommandExecuted = true;
                break;
            }
        }
        if (!computerCommandExecuted)
            this.game.doNothing(1);
    }
    this._isPlayerTurn = !_isPlayerTurn;
    return game.nextTurn();
}

Output:
     }
-    if (_isPlayerTurn) {
-        List<ScriptCommand> playerCommands = this.gameGUI.getCommandObjects();
-        boolean playerCommandExecuted = false;
-        for (ScriptCommand pc : playerCommands) {
-            boolean executed = pc.doCommand(this.game, 0);
-            if (executed) {
-                playerCommandExecuted = true;
-                break;
+    if (!game.isGameOver()) {
+        if (_isPlayerTurn) {
+            List<ScriptCommand> playerCommands = this.gameGUI.getCommandObjects();
+            boolean playerCommandExecuted = false;
+            for (ScriptCommand pc : playerCommands) {
+                boolean executed = pc.doCommand(this.game, 0);
+                if (executed) {
+                    playerCommandExecuted = true;
+                    break;
+                }
             }


Input:
public static long doAdmmIteration(Configuration baseConf, Path previousHdfsPath, Path currentHdfsPath, Path signalDataLocation, int iterationNumber, boolean addIntercept, boolean regularizeIntercept, float regularizationFactor) throws IOException, ClassNotFoundException, InterruptedException {
    Configuration conf = new Configuration(baseConf);
    conf.set("String_Node_Str", previousHdfsPath.toString());
    conf.setInt("String_Node_Str", iterationNumber);
    conf.setBoolean("String_Node_Str", addIntercept);
    conf.setBoolean("String_Node_Str", regularizeIntercept);
    conf.setFloat("String_Node_Str", regularizationFactor);
    Job job = new Job(conf);
    job.setJarByClass(AdmmOptimizerDriver.class);
    job.setJobName("String_Node_Str" + iterationNumber);
    AdmmIterationInputFormat.setNumMapTasks(job, 240);
    FileInputFormat.setInputPaths(job, signalDataLocation);
    FileOutputFormat.setOutputPath(job, currentHdfsPath);
    job.setInputFormatClass(AdmmIterationInputFormat.class);
    job.setOutputFormatClass(AdmmIterationOutputFormat.class);
    job.setMapOutputKeyClass(NullWritable.class);
    job.setMapOutputValueClass(AdmmReducerContextWritable.class);
    job.setOutputKeyClass(NullWritable.class);
    job.setOutputValueClass(AdmmReducerContextWritable.class);
    job.setMapperClass(AdmmIterationMapper.class);
    job.setCombinerClass(AdmmIterationCombiner.class);
    job.setReducerClass(AdmmIterationReducer.class);
    HadoopUtil.delete(conf, currentHdfsPath);
    boolean succeeded = job.waitForCompletion(true);
    if (!succeeded) {
        throw new IllegalStateException("String_Node_Str");
    }
    return job.getCounters().findCounter(AdmmIterationReducer.IterationCounter.ITERATION).getValue();
}

Output:
     conf.setFloat("String_Node_Str", regularizationFactor);
-    Job job = new Job(conf);
+    Job job = Job.getInstance(conf);
     job.setJarByClass(AdmmOptimizerDriver.class);


Input:
protected void provideViwerContent(XSDSchema xsdSchema) {
    drillDownAdapter = new DrillDownAdapter(domViewer);
    domViewer.setLabelProvider(new XSDTreeLabelProvider());
    domViewer.setContentProvider(new XSDTreeContentProvider(site, xsdSchema));
    domViewer.addSelectionChangedListener(new ISelectionChangedListener() {
        public void selectionChanged(SelectionChangedEvent e) {
            StructuredSelection sel = (StructuredSelection) e.getSelection();
            xpath = getXpath(sel);
            xpathText.setText(xpath);
        }
    });
    domViewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, true));
    domViewer.setSorter(new ViewerSorter() {
        public int category(Object element) {
            if (element instanceof XSDFacet)
                return 100;
            if (element instanceof XSDIdentityConstraintDefinition) {
                XSDIdentityConstraintDefinition icd = (XSDIdentityConstraintDefinition) element;
                if (icd.getIdentityConstraintCategory().equals(XSDIdentityConstraintCategory.UNIQUE_LITERAL))
                    return 300;
                else if (icd.getIdentityConstraintCategory().equals(XSDIdentityConstraintCategory.KEY_LITERAL))
                    return 301;
                else
                    return 302;
            }
            return 200;
        }
        public int compare(Viewer theViewer, Object e1, Object e2) {
            int cat1 = category(e1);
            int cat2 = category(e2);
            return cat1 - cat2;
        }
    });
    domViewer.setInput(site);
}

Output:
     domViewer.setLabelProvider(new XSDTreeLabelProvider());
-    domViewer.setContentProvider(new XSDTreeContentProvider(site, xsdSchema));
+    domViewer.setContentProvider(new XPathTreeContentProvider(site, xsdSchema));
     domViewer.addSelectionChangedListener(new ISelectionChangedListener() {


Input:
public void handleOpen(IDataSourceInstanceHandle dataSource) {
    try {
        ScriptStatus status = super.handleJS(dataSource.getScriptScope(), dataSource.getName(), OPEN, ((ScriptDataSourceHandle) dataSourceHandle).getOpen());
        if (status.didRun())
            return;
        if (scriptedEventHandler != null)
            scriptedEventHandler.open(new DataSourceInstance(dataSource));
    } catch (Exception e) {
        addException(context, e);
    }
}

Output:
     try {
-        ScriptStatus status = super.handleJS(dataSource.getScriptScope(), dataSource.getName(), OPEN, ((ScriptDataSourceHandle) dataSourceHandle).getOpen());
+        String id = ModuleUtil.getScriptUID(dataSourceHandle.getPropertyHandle(IScriptDataSourceModel.OPEN_METHOD));
+        ScriptStatus status = super.handleJS(dataSource.getScriptScope(), dataSource.getName(), OPEN, ((ScriptDataSourceHandle) dataSourceHandle).getOpen(), id);
         if (status.didRun())


Input:
private void generateData(List<Event> events) {
    chartData.setChartSource("String_Node_Str");
    chartData.setTop(5);
    chartData.setChartStyle("String_Node_Str");
    chartData.setChartType("String_Node_Str");
    chartEvents = EventUtils.getRequiredEvents(events, chartData);
    tpsPerService(events);
    eventsTableModel.setData(events);
}

Output:
     chartData.setChartType("String_Node_Str");
-    chartEvents = EventUtils.getRequiredEvents(events, chartData);
-    tpsPerService(events);
-    eventsTableModel.setData(events);
+    generateInitialChartData();
+    tpsPerService(eventsData);
+    eventsTableModel.setData(eventsData);
 }


Input:
private static boolean validateColumnType(StructuredSelection selection, TableViewer targetViewer) {
    boolean isValidation = true;
    List selectionList = selection.toList();
    List elements = (List) targetViewer.getInput();
    for (Object element : elements) {
        if (selectionList.contains(element)) {
            isValidation = false;
            break;
        }
    }
    for (Object obj : selectionList) {
        if (!(obj instanceof Column)) {
            isValidation = false;
            break;
        }
    }
    return isValidation;
}

Output:
     List selectionList = selection.toList();
-    List elements = (List) targetViewer.getInput();
-    for (Object element : elements) {
-        if (selectionList.contains(element)) {
-            isValidation = false;
-            break;
+    if (!allowDuplication) {
+        List elements = (List) targetViewer.getInput();
+        for (Object element : elements) {
+            if (selectionList.contains(element)) {
+                isValidation = false;
+                break;
+            }
         }


Input:
private void animateR() {
    if (this.animate.getRepeatDur() <= (System.currentTimeMillis() - repeatDuration)) {
        stopAnimation();
    }
    if (info.getR() >= to_xml) {
        if (this.animate.getRepeatCount() == count) {
            stopAnimation();
        } else {
            count++;
            from_xml = Float.parseFloat(this.animate.getFrom());
            info.setR(from_xml);
        }
    } else {
        from_xml++;
        info.setR(from_xml);
        ruicontrol.relayout();
    }
}

Output:
     }
-    if (info.getR() >= to_xml) {
+    if (from_xml >= to_xml) {
         if (this.animate.getRepeatCount() == count) {


Input:
public void nodeDeleted(String path) {
    if (path.equals(watcher.znodePaths.clusterStateZNode) && !master.isStopped()) {
        clusterShutDown.set(true);
    }
    handle(path);
}

Output:
 public void nodeDeleted(String path) {
-    if (path.equals(watcher.znodePaths.clusterStateZNode) && !master.isStopped()) {
+    if (path.equals(watcher.getZNodePaths().clusterStateZNode) && !master.isStopped()) {
         clusterShutDown.set(true);


Input:
public void onPlayerChat(PlayerChatEvent event) {
    String message = event.getMessage();
    User user = new User(plugin, event.getPlayer());
    if (plugin.mainProperties.getBoolean("String_Node_Str", false)) {
        if (user.inChannel()) {
            user.getActiveChannel().sendChat(user, message);
        } else {
            user.sendMessage(ChatColor.RED + "String_Node_Str");
        }
        event.setCancelled(true);
        return;
    }
    if (user.isMuted()) {
        event.setCancelled(true);
        user.sendMessage(ChatColor.GRAY + plugin.mainProperties.getString("String_Node_Str", "String_Node_Str"));
        return;
    }
    boolean blocked = ChatChecker.checkBlocked(message, plugin);
    if (blocked) {
        event.setCancelled(true);
        user.sendMessage(ChatColor.GRAY + plugin.mainProperties.getString("String_Node_Str", "String_Node_Str"));
        return;
    }
    long slowTimeLeft = slow.playerBlocked(user.getName());
    if ((!user.hasPerm("String_Node_Str")) && slow.isEnabled()) {
        if (slowTimeLeft > 0) {
            user.sendMessage(ChatColor.GRAY + "String_Node_Str" + (int) Math.ceil(slowTimeLeft / 1000) + "String_Node_Str");
            event.setCancelled(true);
            return;
        } else {
            slow.playerAdd(user.getName());
        }
    }
    String prefix;
    log.info(user.getName() + "String_Node_Str" + message);
    if (user.getGroup() != null && !(prefix = user.getGroup().getPrefix()).isEmpty()) {
        message = user.getGroup().getPrefixColor() + "String_Node_Str" + prefix + "String_Node_Str" + user.getColor() + user.getName() + "String_Node_Str" + ChatColor.WHITE + message;
        plugin.getServer().broadcastMessage(message);
        event.setCancelled(true);
    } else {
        message = user.getColor() + user.getName() + "String_Node_Str" + ChatColor.WHITE + message;
        plugin.getServer().broadcastMessage(message);
        event.setCancelled(true);
    }
}

Output:
     String message = event.getMessage();
-    User user = new User(plugin, event.getPlayer());
+    User user = User.getUser(plugin, event.getPlayer());
     if (plugin.mainProperties.getBoolean("String_Node_Str", false)) {


Input:
public Map<Role, List<IOAction>> getTakeable() {
    Map<Role, List<IOAction>> res = new HashMap<>();
    for (Role r : this.states.keySet()) {
        EndpointState s = this.states.get(r);
        switch(s.getStateKind()) {
            case OUTPUT:
                {
                    List<IOAction> as = s.getAllTakeable();
                    for (IOAction a : as) {
                        if (a.isSend()) {
                            if (this.buffs.canSend(r, (Send) a)) {
                                List<IOAction> tmp = res.get(r);
                                if (tmp == null) {
                                    tmp = new LinkedList<>();
                                    res.put(r, tmp);
                                }
                                tmp.add(a);
                            }
                        } else if (a.isConnect()) {
                            Connect c = (Connect) a;
                            EndpointState speer = this.states.get(c.peer);
                            {
                                List<IOAction> peeras = speer.getAllTakeable();
                                for (IOAction peera : peeras) {
                                    if (peera.equals(c.toDual(r)) && this.buffs.canConnect(r, c)) {
                                        List<IOAction> tmp = res.get(r);
                                        if (tmp == null) {
                                            tmp = new LinkedList<>();
                                            res.put(r, tmp);
                                        }
                                        tmp.add(a);
                                    }
                                }
                            }
                        } else if (a.isDisconnect()) {
                            if (this.buffs.canDisconnect(r, (Disconnect) a)) {
                                List<IOAction> tmp = res.get(r);
                                if (tmp == null) {
                                    tmp = new LinkedList<>();
                                    res.put(r, tmp);
                                }
                                tmp.add(a);
                            }
                        } else {
                            throw new RuntimeException("String_Node_Str" + a);
                        }
                    }
                    break;
                }
            case UNARY_INPUT:
            case POLY_INPUT:
                {
                    for (IOAction a : this.buffs.inputable(r)) {
                        if (a.isReceive()) {
                            if (s.isTakeable(a)) {
                                List<IOAction> tmp = res.get(r);
                                if (tmp == null) {
                                    tmp = new LinkedList<>();
                                    res.put(r, tmp);
                                }
                                tmp.add(a);
                            }
                        } else {
                            throw new RuntimeException("String_Node_Str" + a);
                        }
                    }
                    break;
                }
            case TERMINAL:
                {
                    break;
                }
            case ACCEPT:
                {
                    for (IOAction a : this.buffs.acceptable(r)) {
                        if (a.isAccept()) {
                            Accept c = (Accept) a;
                            EndpointState speer = this.states.get(c.peer);
                            {
                                List<IOAction> peeras = speer.getAllTakeable();
                                for (IOAction peera : peeras) {
                                    if (peera.equals(c.toDual(r)) && this.buffs.canAccept(r, c)) {
                                        List<IOAction> tmp = res.get(r);
                                        if (tmp == null) {
                                            tmp = new LinkedList<>();
                                            res.put(r, tmp);
                                        }
                                        tmp.add(a);
                                    }
                                }
                            }
                        } else {
                            throw new RuntimeException("String_Node_Str" + a);
                        }
                    }
                    break;
                }
            default:
                {
                    throw new RuntimeException("String_Node_Str" + s);
                }
        }
    }
    return res;
}

Output:
     for (Role r : this.states.keySet()) {
-        EndpointState s = this.states.get(r);
+        EndpointFSM s = this.states.get(r);
         switch(s.getStateKind()) {


Input:
public void modifyText(ModifyEvent e) {
    String min = lowerText.getText();
    if (!CheckValueUtils.isNumberWithNegativeValue(min)) {
        updateStatus(IStatus.ERROR, MSG_ONLY_NUMBER);
    } else {
        updateStatus(IStatus.OK, MSG_OK);
    }
}

Output:
     String min = lowerText.getText();
-    if (!CheckValueUtils.isNumberWithNegativeValue(min)) {
+    String max = higherText.getText();
+    if (!min.equals("String_Node_Str") && !CheckValueUtils.isNumberWithNegativeValue(min)) {
         updateStatus(IStatus.ERROR, MSG_ONLY_NUMBER);


Input:
public ScriptNode createContainer(String componentId, String folderType, Object permissions) {
    ScriptNode container = null;
    try {
        QName folderQName = (folderType == null) ? null : QName.createQName(folderType, serviceRegistry.getNamespaceService());
        final NodeRef containerNodeRef = this.siteService.createContainer(getShortName(), componentId, folderQName, null);
        if (permissions != null && permissions instanceof ScriptableObject) {
            ScriptableObject scriptable = (ScriptableObject) permissions;
            Object[] propIds = scriptable.getIds();
            for (int i = 0; i < propIds.length; i++) {
                Object propId = propIds[i];
                if (propId instanceof String) {
                    final String key = (String) propId;
                    final Object value = scriptable.get(key, scriptable);
                    if (value instanceof String) {
                        AuthenticationUtil.runAs(new RunAsWork<Object>() {

                            public Object doWork() throws Exception {
                                Site.this.serviceRegistry.getPermissionService().setPermission(containerNodeRef, key, (String) value, true);
                                return null;
                            }
                        }, AuthenticationUtil.SYSTEM_USER_NAME);
                    }
                }
            }
        }
        container = new ScriptNode(containerNodeRef, this.serviceRegistry, this.scope);
    } catch (AlfrescoRuntimeException e) {
    }
    return container;
}

Output:
     try {
-        QName folderQName = (folderType == null) ? null : QName.createQName(folderType, serviceRegistry.getNamespaceService());
-        final NodeRef containerNodeRef = this.siteService.createContainer(getShortName(), componentId, folderQName, null);
-        if (permissions != null && permissions instanceof ScriptableObject) {
-            ScriptableObject scriptable = (ScriptableObject) permissions;
-            Object[] propIds = scriptable.getIds();
-            for (int i = 0; i < propIds.length; i++) {
-                Object propId = propIds[i];
-                if (propId instanceof String) {
-                    final String key = (String) propId;
-                    final Object value = scriptable.get(key, scriptable);
-                    if (value instanceof String) {
-                        AuthenticationUtil.runAs(new RunAsWork<Object>() {
+        NodeRef containerNodeRef = AuthenticationUtil.runAs(new RunAsWork<NodeRef>() {


Input:
public static void sendLoginInfo(Channel channel, Account account) {
    LOGGER.debug("String_Node_Str");
    for (Character character : account.getCharacterCollection()) {
        P007_CharacterInfo characterInfo = new P007_CharacterInfo();
        characterInfo.init(channel);
        characterInfo.setLoginCount(ClientBean.get(channel).getLoginCount());
        characterInfo.setUnknown1(new byte[16]);
        characterInfo.setUnknown2(0);
        characterInfo.setCharacterName(character.getName());
        ByteBuffer buffer = ByteBuffer.allocate(100).order(ByteOrder.LITTLE_ENDIAN);
        buffer.putShort((short) 6);
        buffer.putShort((short) character.getLastOutpost().getGameID());
        buffer.put(new byte[] { 0x33, 0x36, 0x31, 0x30 });
        buffer.put((byte) ((character.getSkin().byteValue() << 5) | (character.getHeight().byteValue() << 1) | character.getSex().byteValue()));
        buffer.put((byte) ((character.getFace().byteValue() << 7) | (character.getHaircolor().byteValue() << 2) | (character.getSkin().byteValue() >> 3)));
        buffer.put((byte) ((character.getPrimaryProfession().getId().byteValue() << 4) | (character.getFace().byteValue() >> 1)));
        buffer.put((byte) ((character.getCampaign().byteValue() << 6) | character.getHairstyle().byteValue()));
        buffer.put(new byte[16]);
        byte level = character.getLevel().getLevel().byteValue();
        buffer.put((byte) ((level << 4) | character.getCampaign()));
        buffer.put(new byte[] { -1, -0x23, -0x23, 0, -0x23, -0x23, -0x23, -0x23 });
        byte[] a = new byte[buffer.position()];
        buffer.position(0);
        buffer.get(a);
        characterInfo.setCharacterInfo(a);
        channel.write(characterInfo);
    }
    sendAccountGuiInfo(channel);
}

Output:
         buffer.put(new byte[16]);
-        byte level = character.getLevel().getLevel().byteValue();
+        byte level = 0;
         buffer.put((byte) ((level << 4) | character.getCampaign()));


Input:
public void run(DataSource dataSource, ConnCallback callback) {
    Transaction t = Trans.get();
    if (null != t) {
        Connection conn = null;
        Savepoint sp = null;
        try {
            conn = t.getConnection(dataSource);
            sp = conn.setSavepoint();
            callback.invoke(conn);
        } catch (Exception e) {
            if (e instanceof DaoException)
                if (null != conn && null != e.getCause() && e.getCause() instanceof SQLException) {
                    try {
                        if (null == sp)
                            conn.rollback();
                        else
                            conn.rollback(sp);
                    } catch (SQLException e1) {
                        if (log.isErrorEnabled())
                            log.error(e1);
                    }
                }
            throw new DaoException(e);
        }
    } else {
        Connection conn = null;
        boolean old = false;
        try {
            conn = dataSource.getConnection();
            old = conn.getAutoCommit();
            conn.setAutoCommit(false);
            callback.invoke(conn);
            if (!conn.getAutoCommit())
                conn.commit();
        } catch (Exception e) {
            try {
                conn.rollback();
            } catch (SQLException e1) {
            }
            throw new DaoException(e);
        } finally {
            if (null != conn) {
                try {
                    if (old != conn.getAutoCommit())
                        conn.setAutoCommit(old);
                } catch (SQLException autoE) {
                    if (log.isWarnEnabled())
                        log.warn("String_Node_Str" + old + "String_Node_Str", autoE);
                }
                try {
                    conn.close();
                } catch (SQLException closeE) {
                    if (log.isWarnEnabled())
                        log.warn("String_Node_Str", closeE);
                }
            }
        }
    }
}

Output:
             try {
-                conn.rollback();
+                if (conn != null)
+                    conn.rollback();
             } catch (SQLException e1) {


Input:
protected void initialize() {
    if (getConnection().getEncoding() != null && !getConnection().getEncoding().equals("String_Node_Str")) {
        encodingCombo.setText(getConnection().getEncoding());
    } else {
        encodingCombo.select(0);
    }
    fieldSeparatorCombo.setText(getConnection().getFieldSeparatorType().getName());
    fieldSeparatorText.setText(getConnection().getFieldSeparatorValue());
    fieldSeparatorText.setEditable(false);
    rowSeparatorCombo.setText(getConnection().getRowSeparatorType().getLiteral());
    rowSeparatorText.setText(getConnection().getRowSeparatorValue());
    rowSeparatorText.setEditable(false);
    if (!isContextMode()) {
        fieldSeparatorManager();
        rowSeparatorManager();
    }
    boolean flag = false;
    flag = initRowsToSkip(rowsToSkipHeaderCheckboxCombo, getConnection().getHeaderValue());
    getConnection().setUseHeader(flag);
    flag = initRowsToSkip(rowsToSkipFooterCheckboxCombo, getConnection().getFooterValue());
    getConnection().setUseFooter(flag);
    flag = initRowsToSkip(rowsToSkipLimitCheckboxCombo, getConnection().getLimitValue());
    getConnection().setUseLimit(flag);
    emptyRowsToSkipCheckbox.setSelection(getConnection().isRemoveEmptyRow());
    firstRowIsCaptionCheckbox.setSelection(getConnection().isFirstLineCaption());
    String textEnclosure = getConnection().getTextEnclosure();
    String textEnclosureValue = ShadowProcessHelper.getValueFromArray(textEnclosure, TEXT_ENCLOSURE_DATA);
    if (textEnclosureValue == null) {
        textEnclosureCombo.select(0);
    } else {
        textEnclosureCombo.setText(textEnclosureValue);
    }
    String escapeChar = getConnection().getEscapeChar();
    String escapeCharValue = ShadowProcessHelper.getValueFromArray(escapeChar, ESCAPE_CHAR_DATA);
    if (escapeCharValue == null) {
        escapeCharCombo.select(0);
    } else {
        escapeCharCombo.setText(escapeCharValue);
    }
    splitwayRecordForJavaFID.setSelection(getConnection().isSplitRecord());
    if (Escape.DELIMITED.equals(getConnection().getEscapeType())) {
        csvRadio.setSelection(false);
        delimitedRadio.setSelection(true);
        textEnclosureCombo.setEnabled(false);
        escapeCharCombo.setEnabled(false);
        splitwayRecordForJavaFID.setEnabled(true);
    }
    if (Escape.CSV.equals(getConnection().getEscapeType())) {
        csvRadio.setSelection(true);
        delimitedRadio.setSelection(false);
        splitwayRecordForJavaFID.setEnabled(false);
    }
    String s = getConnection().getEscapeChar();
    if (!(s == null) && !s.equals("String_Node_Str") && !s.equals(EMPTY_VALUE)) {
        escapeCharCombo.setText(s);
    }
    s = getConnection().getTextEnclosure();
    if (!(s == null) && !s.equals("String_Node_Str") && !s.equals(EMPTY_VALUE)) {
        textEnclosureCombo.setText(s);
    }
    encodingCombo.clearSelection();
    fieldSeparatorCombo.clearSelection();
    rowSeparatorCombo.clearSelection();
    escapeCharCombo.clearSelection();
    textEnclosureCombo.clearSelection();
    emptyRowsToSkipCheckbox.setSelection(getConnection().isRemoveEmptyRow());
    checkFieldsValue();
    if (isContextMode()) {
        adaptFormToEditable();
    }
}

Output:
     emptyRowsToSkipCheckbox.setSelection(getConnection().isRemoveEmptyRow());
-    firstRowIsCaptionCheckbox.setSelection(getConnection().isFirstLineCaption());
+    firstRowIsCaptionCheckbox.setSelection(false);
     String textEnclosure = getConnection().getTextEnclosure();


Input:
private void startMainPager() {
    mTitleTv.setText(getString(R.string.home_pager));
    bottomNavigationBar.setVisibility(View.VISIBLE);
    bottomNavigationBar.setSelectedItemId(R.id.tab_main_pager);
    mDrawerLayout.closeDrawers();
}

Output:
     mTitleTv.setText(getString(R.string.home_pager));
-    bottomNavigationBar.setVisibility(View.VISIBLE);
-    bottomNavigationBar.setSelectedItemId(R.id.tab_main_pager);
+    mBottomNavigationView.setVisibility(View.VISIBLE);
+    mBottomNavigationView.setSelectedItemId(R.id.tab_main_pager);
     mDrawerLayout.closeDrawers();


Input:
public void characters(char[] ch, int start, int length) throws SAXException {
    super.characters(ch, start, length);
    String str = new String(ch).substring(start, start + length);
    if (curapk != null && curel != null) {
        if (curel == "String_Node_Str") {
            curapk.version = str;
        } else if (curel == "String_Node_Str") {
            try {
                curapk.vercode = Integer.parseInt(str);
            } catch (NumberFormatException ex) {
                curapk.vercode = 0;
            }
        } else if (curel == "String_Node_Str") {
            try {
                curapk.size = Integer.parseInt(str);
            } catch (NumberFormatException ex) {
                curapk.size = 0;
            }
        } else if (curel == "String_Node_Str") {
            curapk.hash = str;
        } else if (curel == "String_Node_Str") {
            curapk.apkName = str;
        }
    } else if (curapp != null && curel != null) {
        if (curel == "String_Node_Str") {
            curapp.id = str;
        } else if (curel == "String_Node_Str") {
            curapp.name = str;
        } else if (curel == "String_Node_Str") {
            curapp.icon = str;
        } else if (curel == "String_Node_Str") {
            curapp.description = str;
        } else if (curel == "String_Node_Str") {
            curapp.summary = str;
        } else if (curel == "String_Node_Str") {
            curapp.license = str;
        } else if (curel == "String_Node_Str") {
            curapp.sourceURL = str;
        } else if (curel == "String_Node_Str") {
            curapp.webURL = str;
        } else if (curel == "String_Node_Str") {
            curapp.trackerURL = str;
        } else if (curel == "String_Node_Str") {
            curapp.marketVersion = str;
        } else if (curel == "String_Node_Str") {
            try {
                curapp.marketVercode = Integer.parseInt(str);
            } catch (NumberFormatException ex) {
                curapp.marketVercode = 0;
            }
        }
    }
}

Output:
     String str = new String(ch).substring(start, start + length);
-    if (curapk != null && curel != null) {
-        if (curel == "String_Node_Str") {
-            curapk.version = str;
-        } else if (curel == "String_Node_Str") {
-            try {
-                curapk.vercode = Integer.parseInt(str);
-            } catch (NumberFormatException ex) {
-                curapk.vercode = 0;
-            }
-        } else if (curel == "String_Node_Str") {
-            try {
-                curapk.size = Integer.parseInt(str);
-            } catch (NumberFormatException ex) {
-                curapk.size = 0;
-            }
-        } else if (curel == "String_Node_Str") {
-            curapk.hash = str;
-        } else if (curel == "String_Node_Str") {
-            curapk.apkName = str;
-        }
-    } else if (curapp != null && curel != null) {
-        if (curel == "String_Node_Str") {
-            curapp.id = str;
-        } else if (curel == "String_Node_Str") {
-            curapp.name = str;
-        } else if (curel == "String_Node_Str") {
-            curapp.icon = str;
-        } else if (curel == "String_Node_Str") {
-            curapp.description = str;
-        } else if (curel == "String_Node_Str") {
-            curapp.summary = str;
-        } else if (curel == "String_Node_Str") {
-            curapp.license = str;
-        } else if (curel == "String_Node_Str") {
-            curapp.sourceURL = str;
-        } else if (curel == "String_Node_Str") {
-            curapp.webURL = str;
-        } else if (curel == "String_Node_Str") {
-            curapp.trackerURL = str;
-        } else if (curel == "String_Node_Str") {
-            curapp.marketVersion = str;
-        } else if (curel == "String_Node_Str") {
-            try {
-                curapp.marketVercode = Integer.parseInt(str);
-            } catch (NumberFormatException ex) {
-                curapp.marketVercode = 0;
-            }
-        }
-    }
+    if (curchars == null)
+        curchars = str;
+    else
+        curchars += str;
 }


Input:
private void doAuthAction(int messageId, String twoStepCode, boolean shouldSendTwoStepSMS) {
    if (!NetworkUtils.checkConnection(getActivity())) {
        return;
    }
    mInProgressMessageId = messageId;
    startProgress();
    mOldSitesIDs = SiteUtils.getCurrentSiteIds(mSiteStore, false);
    if (isSocialLogin) {
        if (shouldSendTwoStepSMS) {
            PushSocialSmsPayload payload = new PushSocialSmsPayload(mUserId, mNonceSms);
            mDispatcher.dispatch(AccountActionBuilder.newPushSocialSmsAction(payload));
        } else {
            setAuthCodeTypeAndNonce(twoStepCode);
            PushSocialAuthPayload payload = new PushSocialAuthPayload(mUserId, mType, mNonce, twoStepCode);
            mDispatcher.dispatch(AccountActionBuilder.newPushSocialAuthAction(payload));
        }
    } else {
        AuthenticatePayload payload = new AuthenticatePayload(mEmailAddress, mPassword);
        payload.twoStepCode = twoStepCode;
        payload.shouldSendTwoStepSms = shouldSendTwoStepSMS;
        mDispatcher.dispatch(AuthenticationActionBuilder.newAuthenticateAction(payload));
    }
}

Output:
     mOldSitesIDs = SiteUtils.getCurrentSiteIds(mSiteStore, false);
-    if (isSocialLogin) {
+    if (mIsSocialLogin) {
         if (shouldSendTwoStepSMS) {


Input:
protected void onPrerequisiteComplete(final Task<?> task) {
    synchronized (mTaskLock) {
        mPrerequisites.remove(task);
        checkPrerequisites();
    }
}

Output:
         mPrerequisites.remove(task);
-        checkPrerequisites();
+        checkExecution();
     }


Input:
public void stepUp(TreeViewer targetTreeViewer) {
    TreeItem item;
    TreeItem[] items = targetTreeViewer.getTree().getSelection();
    for (int i = 0; i < items.length; i++) {
        item = items[i];
        if (!(item.getData() instanceof XSDConcreteComponent))
            continue;
        XSDConcreteComponent component = (XSDConcreteComponent) item.getData();
        if (!(component instanceof XSDParticle))
            continue;
        else {
            XSDParticle particle = (XSDParticle) component;
            if (particle.getContainer() instanceof XSDModelGroup) {
                XSDModelGroup mp = (XSDModelGroup) particle.getContainer();
                int index = mp.getContents().indexOf(particle);
                if (index > 0) {
                    mp.getContents().move(index - 1, index);
                    this.refresh();
                }
            }
        }
    }
    this.markDirtyWithoutCommit();
}

Output:
         item = items[i];
-        if (!(item.getData() instanceof XSDConcreteComponent))
-            continue;
-        XSDConcreteComponent component = (XSDConcreteComponent) item.getData();
-        if (!(component instanceof XSDParticle))
-            continue;
-        else {
-            XSDParticle particle = (XSDParticle) component;
-            if (particle.getContainer() instanceof XSDModelGroup) {
-                XSDModelGroup mp = (XSDModelGroup) particle.getContainer();
-                int index = mp.getContents().indexOf(particle);
-                if (index > 0) {
-                    mp.getContents().move(index - 1, index);
-                    this.refresh();
-                }
+        Object data = item.getData();
+        EList content = getXSDComponentContainer(data);
+        if (content != null) {
+            int index = content.indexOf(data);
+            if (index > 0) {
+                content.move(index - 1, index);
+                isDirty = true;
+                this.refresh();
             }


Input:
private void sendGuidedPoint() {
    if (state == GuidedStates.ACTIVE) {
        myDrone.events.notifyDroneEvent(DroneEventsType.GUIDEDPOINT);
        MavLinkModes.setGuidedMode(myDrone, coord.getY(), coord.getX(), altitude.valueInMeters());
    }
}

Output:
         myDrone.events.notifyDroneEvent(DroneEventsType.GUIDEDPOINT);
-        MavLinkModes.setGuidedMode(myDrone, coord.getY(), coord.getX(), altitude.valueInMeters());
+        MavLinkModes.setGuidedMode(myDrone, coord.getLat(), coord.getLng(), altitude.valueInMeters());
     }


Input:
private void _evalFieldMacro(Entity<?> en, List<MappingInfo> infos) {
    for (MappingInfo info : infos) {
        if (null != info.annPrev) {
            en.addBeforeInsertMacro(__macro(en.getField(info.name), _annToFieldMacroInfo(info.annPrev.els(), info.annPrev.value())));
        }
        if (null != info.annNext && en.addAfterInsertMacro(__macro(en.getField(info.name), _annToFieldMacroInfo(info.annNext.els(), info.annNext.value())))) {
            continue;
        } else if (null != info.annId && info.annId.auto()) {
            MappingField idField = en.getField(info.name);
            String autoSql = "String_Node_Str";
            Pojo autoInfo = new SqlFieldMacro(idField, autoSql);
            autoInfo.setEntity(en);
            en.addAfterInsertMacro(autoInfo);
        }
    }
}

Output:
         } else if (null != info.annId && info.annId.auto()) {
-            MappingField idField = en.getField(info.name);
-            String autoSql = "String_Node_Str";
-            Pojo autoInfo = new SqlFieldMacro(idField, autoSql);
-            autoInfo.setEntity(en);
-            en.addAfterInsertMacro(autoInfo);
+            en.addAfterInsertMacro(expert.fetchPojoId(en, en.getField(info.name)));
         }


Input:
public void process() {
    if (renderingConfig.isSsao()) {
        PerformanceMonitor.startActivity("String_Node_Str");
        sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.ReadOnlyGBuffer.getName());
        ssaoBlurredFBO = dynamicFBOsManager.get(SSAO_BLURRED_URN);
        ssaoFBO = dynamicFBOsManager.get(SSAO_URN);
        generateSSAO();
        generateBlurredSSAO();
        PerformanceMonitor.endActivity();
    }
}

Output:
         PerformanceMonitor.startActivity("String_Node_Str");
-        sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.ReadOnlyGBuffer.getName());
+        sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.READ_ONLY_GBUFFER.getName());
         ssaoBlurredFBO = dynamicFBOsManager.get(SSAO_BLURRED_URN);


Input:
public static void normalizeLogProps(double[] logProps) {
    double logPropSum = Double.NEGATIVE_INFINITY;
    for (int d = 0; d < logProps.length; d++) {
        logPropSum = Utilities.logAdd(logPropSum, logProps[d]);
    }
    for (int d = 0; d < logProps.length; d++) {
        logProps[d] -= logPropSum;
        assert (!Double.isNaN(logProps[d]));
    }
}

Output:
     }
-    for (int d = 0; d < logProps.length; d++) {
-        logProps[d] -= logPropSum;
-        assert (!Double.isNaN(logProps[d]));
+    if (logPropSum != Double.NEGATIVE_INFINITY) {
+        for (int d = 0; d < logProps.length; d++) {
+            logProps[d] -= logPropSum;
+            assert (!Double.isNaN(logProps[d]));
+        }
+    } else {
+        double uniform = Utilities.log(1.0 / (double) logProps.length);
+        for (int d = 0; d < logProps.length; d++) {
+            logProps[d] = uniform;
+        }
     }


Input:
private void retrieveFile(String zipFileName, AdminCommandContext context, File tempDirectory, Properties props, ActionReport report) {
    Payload.Outbound outboundPayload = context.getOutboundPayload();
    boolean retrieveFiles = false;
    if (outboundPayload == null) {
        outboundPayload = PayloadImpl.Outbound.newInstance();
        retrieveFiles = true;
    }
    try {
        List<File> files = new ArrayList<File>(Arrays.asList(tempDirectory.listFiles()));
        for (int i = 0; i < files.size(); i++) {
            File file = files.get(i);
            if (file.isDirectory()) {
                files.addAll(Arrays.asList(file.listFiles()));
                continue;
            }
            if (file.getAbsolutePath().contains("String_Node_Str")) {
                continue;
            }
            outboundPayload.attachFile("String_Node_Str", tempDirectory.toURI().relativize(file.toURI()), "String_Node_Str", props, file);
        }
        if (retrieveFiles) {
            File targetLocalFile = new File(retrieveFilePath);
            if (targetLocalFile.exists()) {
                throw new Exception("String_Node_Str");
            }
            if (!targetLocalFile.getParentFile().exists()) {
                throw new Exception("String_Node_Str");
            }
            FileOutputStream targetStream = new FileOutputStream(targetLocalFile);
            outboundPayload.writeTo(targetStream);
            targetStream.flush();
            targetStream.close();
        }
    } catch (Exception ex) {
        final String errorMsg = localStrings.getLocalString("String_Node_Str", "String_Node_Str", retrieveFilePath);
        logger.log(Level.SEVERE, errorMsg, ex);
        report.setMessage(errorMsg);
        report.setActionExitCode(ActionReport.ExitCode.FAILURE);
        return;
    }
}

Output:
             }
-            FileOutputStream targetStream = new FileOutputStream(targetLocalFile);
-            outboundPayload.writeTo(targetStream);
-            targetStream.flush();
-            targetStream.close();
+            FileOutputStream targetStream = null;
+            try {
+                targetStream = new FileOutputStream(targetLocalFile);
+                outboundPayload.writeTo(targetStream);
+                targetStream.flush();
+            } finally {
+                if (targetStream != null)
+                    targetStream.close();
+            }
         }


Input:
public static WPImageSpan prepareWPImageSpan(Context context, String blogId, final String mediaId) {
    Cursor cursor = WordPress.wpDB.getMediaFile(blogId, mediaId);
    if (cursor == null || !cursor.moveToFirst()) {
        if (cursor != null)
            cursor.close();
        return null;
    }
    String url = cursor.getString(cursor.getColumnIndex("String_Node_Str"));
    if (url == null) {
        cursor.close();
        return null;
    }
    Uri uri = Uri.parse(url);
    WPImageSpan imageSpan = new WPImageSpan(context, R.drawable.remote_image, uri);
    MediaFile mediaFile = imageSpan.getMediaFile();
    mediaFile.setMediaId(mediaId);
    mediaFile.setCaption(cursor.getString(cursor.getColumnIndex("String_Node_Str")));
    mediaFile.setDescription(cursor.getString(cursor.getColumnIndex("String_Node_Str")));
    mediaFile.setTitle(cursor.getString(cursor.getColumnIndex("String_Node_Str")));
    mediaFile.setWidth(cursor.getInt(cursor.getColumnIndex("String_Node_Str")));
    mediaFile.setHeight(cursor.getInt(cursor.getColumnIndex("String_Node_Str")));
    mediaFile.setMimeType(cursor.getString(cursor.getColumnIndex("String_Node_Str")));
    mediaFile.setFileName(cursor.getString(cursor.getColumnIndex("String_Node_Str")));
    mediaFile.setThumbnailURL(cursor.getString(cursor.getColumnIndex("String_Node_Str")));
    mediaFile.setDateCreatedGMT(cursor.getLong(cursor.getColumnIndex("String_Node_Str")));
    boolean isVideo = false;
    String mimeType = cursor.getString(cursor.getColumnIndex("String_Node_Str"));
    if (mimeType != null && mimeType.contains("String_Node_Str"))
        isVideo = true;
    mediaFile.setVideo(isVideo);
    cursor.close();
    return imageSpan;
}

Output:
     mediaFile.setDateCreatedGMT(cursor.getLong(cursor.getColumnIndex("String_Node_Str")));
-    boolean isVideo = false;
-    String mimeType = cursor.getString(cursor.getColumnIndex("String_Node_Str"));
-    if (mimeType != null && mimeType.contains("String_Node_Str"))
-        isVideo = true;
-    mediaFile.setVideo(isVideo);
+    mediaFile.setVideo(mediaFile.getMimeType().contains("String_Node_Str"));
+    mediaFile.save();
     cursor.close();


Input:
public void run() {
    CESymmParameters params = parent.getParameters();
    try {
        Atom[] atoms = StructureTools.getRepresentativeAtomArray(structure);
        CeSymmResult result = CeSymm.analyze(atoms, params);
        List<StructureIdentifier> names = new ArrayList<StructureIdentifier>();
        for (int su = 0; su < result.getSymmOrder(); su++) {
            names.add(name);
        }
        result.getMultipleAlignment().getEnsemble().setStructureIdentifiers(names);
        MultipleAlignmentJmol jmol = SymmetryDisplay.display(result);
        String title = jmol.getTitle();
        if (params != null)
            title += "String_Node_Str" + params.getOrderDetectorMethod() + "String_Node_Str" + params.getRefineMethod();
        jmol.setTitle(title);
    } catch (StructureException e) {
        logger.warn(e.getMessage());
    }
    parent.notifyCalcFinished();
}

Output:
         CeSymmResult result = CeSymm.analyze(atoms, params);
-        List<StructureIdentifier> names = new ArrayList<StructureIdentifier>();
-        for (int su = 0; su < result.getSymmOrder(); su++) {
-            names.add(name);
-        }
-        result.getMultipleAlignment().getEnsemble().setStructureIdentifiers(names);
-        MultipleAlignmentJmol jmol = SymmetryDisplay.display(result);
+        AbstractAlignmentJmol jmol = SymmetryDisplay.display(result);
         String title = jmol.getTitle();


Input:
public void addPermission(String permission, String world) {
    String nodePath = "String_Node_Str";
    if (world != null && !world.isEmpty()) {
        nodePath = "String_Node_Str" + world + "String_Node_Str" + nodePath;
    }
    List<String> permissions = this.node.getStringList(nodePath, new LinkedList<String>());
    if (!permissions.contains(permission)) {
        permissions.add(0, permission);
    }
    this.node.setProperty(nodePath, permissions);
    this.save();
}

Output:
 public void addPermission(String permission, String world) {
-    String nodePath = "String_Node_Str";
+    String permissionsNode = "String_Node_Str";
     if (world != null && !world.isEmpty()) {


Input:
public void testSameMemberAdded() throws Exception {
    HazelcastClient client = mock(HazelcastClient.class);
    InetSocketAddress inetSocketAddress = new InetSocketAddress("String_Node_Str", 5701);
    final Connection connection = mock(Connection.class);
    final CountDownLatch latch = new CountDownLatch(2);
    final List<LifecycleState> lifecycleEvents = new ArrayList<LifecycleState>();
    final LifecycleServiceClientImpl lifecycleService = createLifecycleServiceClientImpl(client, lifecycleEvents);
    ConnectionManager connectionManager = new ConnectionManager(client, lifecycleService, inetSocketAddress) {

        protected Connection getNextConnection() {
            latch.countDown();
            return connection;
        }
    };
    ClientBinder binder = mock(ClientBinder.class);
    connectionManager.setBinder(binder);
    Cluster cluster = mock(Cluster.class);
    Member member = mock(Member.class);
    when(member.getInetSocketAddress()).thenReturn(inetSocketAddress);
    MembershipEvent membershipEvent = new MembershipEvent(cluster, member, MembershipEvent.MEMBER_ADDED);
    connectionManager.memberAdded(membershipEvent);
    connectionManager.getClusterMembers().contains(inetSocketAddress);
    assertEquals(1, connectionManager.getClusterMembers().size());
    assertArrayEquals(new Object[0], lifecycleEvents.toArray());
}

Output:
     final LifecycleServiceClientImpl lifecycleService = createLifecycleServiceClientImpl(client, lifecycleEvents);
-    ConnectionManager connectionManager = new ConnectionManager(client, lifecycleService, inetSocketAddress) {
+    ConnectionManager connectionManager = new ConnectionManager(client, lifecycleService, inetSocketAddress, 60000) {


Input:
public void partOpened(IWorkbenchPartReference partRef) {
    if (partRef instanceof WorkbenchPartReference) {
        WorkbenchPartReference workbenchPartRef = (WorkbenchPartReference) partRef;
        Control partContent = workbenchPartRef.getPane().getControl();
        if (partContent != null && !partContent.isDisposed() && partContent.getData(GD_RCP_DATA_KEY) == null) {
            String partId = workbenchPartRef.getId();
            if (partRef instanceof IViewReference) {
                String secondaryId = ((IViewReference) partRef).getSecondaryId();
                if (secondaryId != null) {
                    partId += "String_Node_Str" + secondaryId;
                }
            }
            if (partId == null || partId.trim().length() == 0) {
                return;
            }
            partContent.setData(GD_RCP_DATA_KEY, partId);
            Control partToolbar = workbenchPartRef.getPane().getToolBar();
            if (partToolbar != null) {
                partToolbar.setData(GD_RCP_DATA_KEY, partId + TOOLBAR_ID_SUFFIX);
            }
            Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
            Event activateEvent = new Event();
            activateEvent.time = (int) System.currentTimeMillis();
            activateEvent.type = SWT.Activate;
            activateEvent.widget = shell;
            shell.notifyListeners(SWT.Activate, activateEvent);
        }
    }
}

Output:
         Control partContent = workbenchPartRef.getPane().getControl();
-        if (partContent != null && !partContent.isDisposed() && partContent.getData(GD_RCP_DATA_KEY) == null) {
+        if (partContent != null && !partContent.isDisposed() && partContent.getData(TEST_RCP_DATA_KEY) == null) {
             String partId = workbenchPartRef.getId();


Input:
static CachedMethod[] getMethods(Kryo kryo, Class type) {
    CachedMethod[] cachedMethods = methodCache.get(type);
    if (cachedMethods != null)
        return cachedMethods;
    ArrayList<Method> allMethods = new ArrayList();
    Class nextClass = type;
    while (nextClass != null && nextClass != Object.class) {
        Collections.addAll(allMethods, nextClass.getDeclaredMethods());
        nextClass = nextClass.getSuperclass();
    }
    PriorityQueue<Method> methods = new PriorityQueue(Math.max(1, allMethods.size()), new Comparator<Method>() {
        public int compare(Method o1, Method o2) {
            int diff = o1.getName().compareTo(o2.getName());
            if (diff != 0)
                return diff;
            Class[] argTypes1 = o1.getParameterTypes();
            Class[] argTypes2 = o2.getParameterTypes();
            if (argTypes1.length > argTypes2.length)
                return 1;
            if (argTypes1.length < argTypes2.length)
                return -1;
            for (int i = 0; i < argTypes1.length; i++) {
                diff = argTypes1[i].getName().compareTo(argTypes2[i].getName());
                if (diff != 0)
                    return diff;
            }
            throw new RuntimeException("String_Node_Str");
        }
    });
    for (int i = 0, n = allMethods.size(); i < n; i++) {
        Method method = allMethods.get(i);
        int modifiers = method.getModifiers();
        if (Modifier.isStatic(modifiers))
            continue;
        if (Modifier.isPrivate(modifiers))
            continue;
        if (method.isSynthetic())
            continue;
        methods.add(method);
    }
    int n = methods.size();
    cachedMethods = new CachedMethod[n];
    for (int i = 0; i < n; i++) {
        CachedMethod cachedMethod = new CachedMethod();
        cachedMethod.method = methods.poll();
        Class[] parameterTypes = cachedMethod.method.getParameterTypes();
        cachedMethod.serializers = new Serializer[parameterTypes.length];
        for (int ii = 0, nn = parameterTypes.length; ii < nn; ii++) if (Modifier.isFinal(parameterTypes[ii].getModifiers()))
            cachedMethod.serializers[ii] = kryo.getSerializer(parameterTypes[ii]);
        cachedMethods[i] = cachedMethod;
    }
    methodCache.put(type, cachedMethods);
    return cachedMethods;
}

Output:
         cachedMethod.serializers = new Serializer[parameterTypes.length];
-        for (int ii = 0, nn = parameterTypes.length; ii < nn; ii++) if (Modifier.isFinal(parameterTypes[ii].getModifiers()))
+        for (int ii = 0, nn = parameterTypes.length; ii < nn; ii++) if (Serializer.isFinal(parameterTypes[ii]))
             cachedMethod.serializers[ii] = kryo.getSerializer(parameterTypes[ii]);


Input:
void updateSynchronizers() {
    synchronized (endpoints) {
        for (EndpointInfo endpoint : endpoints) {
            final String endpointId = endpoint.getId();
            for (Entry<MediaType, Long> ssrc : endpoint.getSsrcs().entrySet()) {
                Recorder recorder = recorders.get(ssrc.getKey());
                if (recorder != null) {
                    Synchronizer synchronizer = recorder.getSynchronizer();
                    synchronizer.setEndpoint(ssrc.getValue(), endpointId);
                }
                logger.info("String_Node_Str" + endpointId + "String_Node_Str" + ssrc.getKey() + "String_Node_Str" + ssrc.getValue());
            }
        }
    }
}

Output:
 void updateSynchronizers() {
-    synchronized (endpoints) {
+    synchronized (endpointsSyncRoot) {
         for (EndpointInfo endpoint : endpoints) {


Input:
private void processFieldSubmissionGroupItems(ArrayList<HashMap> listOfUploadFilePaths, Node groupNode, ItemGroup itemGroup) throws Exception {
    String itemName;
    String itemValue;
    Integer itemOrdinal = null;
    final NamedNodeMap attributes = groupNode.getAttributes();
    boolean enketoOrdinalFound = false;
    for (int attrIndex = 0; attrIndex < attributes.getLength(); attrIndex++) {
        if (attributes.item(attrIndex).getNodeName().equals(ENKETO_ORDINAL)) {
            logger.debug("String_Node_Str");
            logger.debug(attributes.item(attrIndex).getNodeName());
            logger.debug(attributes.item(attrIndex).getNodeValue());
            enketoOrdinalFound = true;
            itemOrdinal = new Integer(attributes.item(attrIndex).getNodeValue());
        }
    }
    if (!enketoOrdinalFound) {
        itemOrdinal = 1;
    }
    if (container.getRequestType() == FieldRequestTypeEnum.DELETE_FIELD) {
        ItemData existingItemData = lookupFieldItemData(crfVersion, itemGroup, itemOrdinal);
        existingItemData.setDeleted(true);
        existingItemData.setValue("String_Node_Str");
        existingItemData.setOldStatus(existingItemData.getStatus());
        existingItemData.setUserAccount(container.getUser());
        existingItemData.setStatus(Status.AVAILABLE);
        existingItemData.setUpdateId(container.getUser().getUserId());
        existingItemData = itemDataDao.saveOrUpdate(existingItemData);
        closeItemDiscrepancyNotes(container, existingItemData);
        return;
    }
    NodeList itemNodeList = groupNode.getChildNodes();
    for (int m = 0; m < itemNodeList.getLength(); m = m + 1) {
        Node itemNode = itemNodeList.item(m);
        if (ShouldProcessItemNode(itemNode)) {
            itemName = itemNode.getNodeName().trim();
            itemValue = itemNode.getTextContent();
            Item item = lookupItem(itemName, crfVersion);
            if (item == null) {
                logger.error("String_Node_Str" + itemName + "String_Node_Str");
                continue;
            }
            ItemFormMetadata itemFormMetadata = itemFormMetadataDao.findByItemCrfVersion(item.getItemId(), crfVersion.getCrfVersionId());
            Integer responseTypeId = itemFormMetadata.getResponseSet().getResponseType().getResponseTypeId();
            if (responseTypeId == 3 || responseTypeId == 7) {
                itemValue = itemValue.replaceAll("String_Node_Str", "String_Node_Str");
            }
            if (responseTypeId == 4) {
                for (HashMap uploadFilePath : listOfUploadFilePaths) {
                    if ((boolean) uploadFilePath.containsKey(itemValue) && itemValue != "String_Node_Str") {
                        itemValue = (String) uploadFilePath.get(itemValue);
                        break;
                    }
                }
            }
            ItemData newItemData = createItemData(item, itemValue, itemOrdinal, eventCrf, container.getStudy(), container.getSubject(), container.getUser());
            Errors itemErrors = validateItemData(newItemData, item, responseTypeId);
            if (itemErrors.hasErrors()) {
                container.getErrors().addAllErrors(itemErrors);
                throw new Exception("String_Node_Str");
            }
            ItemData existingItemData = itemDataDao.findByItemEventCrfOrdinal(item.getItemId(), eventCrf.getEventCrfId(), itemOrdinal);
            if (existingItemData == null) {
                newItemData.setStatus(Status.UNAVAILABLE);
                itemDataDao.saveOrUpdate(newItemData);
            } else if (existingItemData.getValue().equals(newItemData.getValue())) {
            } else {
                existingItemData.setValue(newItemData.getValue());
                existingItemData.setUpdateId(container.getUser().getUserId());
                existingItemData.setDateUpdated(new Date());
                itemDataDao.saveOrUpdate(existingItemData);
            }
        }
    }
}

Output:
     if (container.getRequestType() == FieldRequestTypeEnum.DELETE_FIELD) {
-        ItemData existingItemData = lookupFieldItemData(crfVersion, itemGroup, itemOrdinal);
+        ItemData existingItemData = lookupFieldItemData(itemGroup, itemOrdinal);
         existingItemData.setDeleted(true);


Input:
public static User createUser(JSONObject userJson) {
    User user = new User();
    user.setExternalUrls(createExternalUrls(userJson.getJSONObject("String_Node_Str")));
    user.setHref(userJson.getString("String_Node_Str"));
    user.setId(userJson.getString("String_Node_Str"));
    user.setType(createObjectType(userJson.getString("String_Node_Str")));
    user.setUri(userJson.getString("String_Node_Str"));
    user.setFollowers(createFollowers(userJson.getJSONObject("String_Node_Str")));
    if (existsAndNotNull("String_Node_Str", userJson)) {
        user.setDisplayName(userJson.getString("String_Node_Str"));
    }
    if (existsAndNotNull("String_Node_Str", userJson)) {
        user.setEmail(userJson.getString("String_Node_Str"));
    }
    if (existsAndNotNull("String_Node_Str", userJson)) {
        user.setImages(createImages(userJson.getJSONArray("String_Node_Str")));
    }
    if (existsAndNotNull("String_Node_Str", userJson)) {
        user.setProduct(createProductType(userJson.getString("String_Node_Str")));
    }
    if (existsAndNotNull("String_Node_Str", userJson)) {
        user.setCountry(userJson.getString("String_Node_Str"));
    }
    if (existsAndNotNull("String_Node_Str", userJson)) {
        user.setBirthdate(userJson.getString("String_Node_Str"));
    }
    return user;
}

Output:
     if (existsAndNotNull("String_Node_Str", userJson)) {
-        user.setCountry(userJson.getString("String_Node_Str"));
+        user.setCountry(CountryCode.getByCode(userJson.getString("String_Node_Str")));
     }


Input:
public Boolean call() throws Exception {
    s.addEventFilter(WindowEvent.WINDOW_CLOSE_REQUEST, closeHandler);
    return false;
}

Output:
 public Boolean call() throws Exception {
-    s.addEventFilter(WindowEvent.WINDOW_CLOSE_REQUEST, closeHandler);
-    return false;
+    if (s.isShowing()) {
+        s.addEventFilter(WindowEvent.WINDOW_CLOSE_REQUEST, closeHandler);
+        return false;
+    } else {
+        return true;
+    }
 }


Input:
public void handle(Packet packet) {
    if (packet instanceof PacketPlayOutChat) {
        if (!packetHandler.sendPacket(player.getBukkitEntity(), new PacketOutChat_v1_8_R3((PacketPlayOutChat) packet))) {
            oldManager.handle(packet);
        }
    } else if (packet instanceof PacketPlayOutNamedEntitySpawn || packet instanceof PacketPlayOutSpawnEntity || packet instanceof PacketPlayOutSpawnEntityLiving || packet instanceof PacketPlayOutSpawnEntityPainting || packet instanceof PacketPlayOutSpawnEntityExperienceOrb) {
        PacketOutSpawnEntity spawnEntity = new PacketOutSpawnEntity_v1_8_R3(player, packet);
        UUID uuid = spawnEntity.getEntityUuid();
        if (!NMSHandler.getInstance().getEntityHelper().isHidden(player.getBukkitEntity(), uuid)) {
            Entity entity = ((WorldServer) player.getWorld()).getEntity(uuid);
            if (entity instanceof EntityFakePlayer_v1_8_R3) {
                final EntityFakePlayer_v1_8_R3 fakePlayer = (EntityFakePlayer_v1_8_R3) entity;
                handle(new PacketPlayOutPlayerInfo(EnumPlayerInfoAction.ADD_PLAYER, fakePlayer));
                Bukkit.getScheduler().runTaskLater(NMSHandler.getJavaPlugin(), new Runnable() {

                    public void run() {
                        handle(new PacketPlayOutPlayerInfo(EnumPlayerInfoAction.REMOVE_PLAYER, fakePlayer));
                    }
                }, 5);
            }
            oldManager.handle(packet);
        }
    } else if (packet instanceof PacketPlayOutEntityMetadata) {
        if (!packetHandler.sendPacket(player.getBukkitEntity(), new PacketOutEntityMetadata_v1_8_R3((PacketPlayOutEntityMetadata) packet))) {
            oldManager.handle(packet);
        }
    } else {
        oldManager.handle(packet);
    }
}

Output:
             Entity entity = ((WorldServer) player.getWorld()).getEntity(uuid);
-            if (entity instanceof EntityFakePlayer_v1_8_R3) {
-                final EntityFakePlayer_v1_8_R3 fakePlayer = (EntityFakePlayer_v1_8_R3) entity;
-                handle(new PacketPlayOutPlayerInfo(EnumPlayerInfoAction.ADD_PLAYER, fakePlayer));
-                Bukkit.getScheduler().runTaskLater(NMSHandler.getJavaPlugin(), new Runnable() {
+            if (entity != null) {
+                if (entity instanceof EntityFakePlayer_v1_8_R3) {
+                    final EntityFakePlayer_v1_8_R3 fakePlayer = (EntityFakePlayer_v1_8_R3) entity;
+                    handle(new PacketPlayOutPlayerInfo(EnumPlayerInfoAction.ADD_PLAYER, fakePlayer));
+                    Bukkit.getScheduler().runTaskLater(NMSHandler.getJavaPlugin(), new Runnable() {


Input:
private void checkTree() {
    int emptyCount = countChildrenOf(EMPTY);
    if (emptyCount != 0) {
        throw new IllegalStateException("String_Node_Str" + emptyCount);
    }
    int wallCount = countChildrenOf(WALL);
    if (wallCount != 1) {
        throw new IllegalStateException("String_Node_Str" + wallCount);
    }
    for (int i = 0; i < parents.length; i++) {
        int numAncestors = 0;
        int parent = parents[i];
        while (parent != WALL) {
            numAncestors += 1;
            if (numAncestors > parents.length - 1) {
                throw new IllegalStateException("String_Node_Str");
            }
            parent = parents[parent];
        }
    }
    if (nodes.size() != parents.length) {
        throw new IllegalStateException("String_Node_Str");
    }
}

Output:
     }
-    if (nodes.size() != parents.length) {
+    if (nodes.size() - 1 != parents.length) {
         throw new IllegalStateException("String_Node_Str");


Input:
public void handle(WebSocket websocket) {
    JsonObject msg = new JsonObject().putString("String_Node_Str", "String_Node_Str").putString("String_Node_Str", _address);
    websocket.writeTextFrame(msg.encode());
    _websocket = websocket;
    websocket.dataHandler(new Handler<Buffer>() {
        public void handle(Buffer buff) {
            String msg = buff.toString();
            JsonObject received = new JsonObject(msg);
            if (_buffer == null) {
                _buffer = new ArrayList<StringToken>();
            }
            synchronized (_buffer) {
                _buffer.add(new StringToken(received.getField("String_Node_Str").toString()));
            }
            try {
                getDirector().fireAtCurrentRealTime((Actor) subscribe.getContainer());
            } catch (IllegalActionException e) {
                e.printStackTrace();
            }
        }
    });
    websocket.closeHandler(new Handler<Void>() {
        public void handle(final Void event) {
        }
    });
}

Output:
     websocket.closeHandler(new Handler<Void>() {
-        public void handle(final Void event) {
-        }
-    });
+public void handle(Throwable event) {
+    _exception = event;
+    _vertx.cancelTimer(_periodicPing);
 }


Input:
private void fillSoftIRQStateToColor() {
    softIrqStateToColor.put(SoftIRQMode.LTTV_SOFT_IRQ_UNKNOWN.getInName(), StateColor.BLACK);
    softIrqStateToColor.put(SoftIRQMode.LTTV_SOFT_IRQ_IDLE.getInName(), StateColor.BLACK);
    softIrqStateToColor.put(SoftIRQMode.LTTV_SOFT_IRQ_PENDING.getInName(), StateColor.PINK1);
    softIrqStateToColor.put(SoftIRQMode.LTTV_SOFT_IRQ_BUSY.getInName(), StateColor.PURPLE1);
}

Output:
     softIrqStateToColor.put(SoftIRQMode.LTTV_SOFT_IRQ_UNKNOWN.getInName(), StateColor.BLACK);
-    softIrqStateToColor.put(SoftIRQMode.LTTV_SOFT_IRQ_IDLE.getInName(), StateColor.BLACK);
+    softIrqStateToColor.put(SoftIRQMode.LTTV_SOFT_IRQ_IDLE.getInName(), StateColor.GRAY);
     softIrqStateToColor.put(SoftIRQMode.LTTV_SOFT_IRQ_PENDING.getInName(), StateColor.PINK1);


Input:
public SearchStateArc[] getSuccessors() {
    LexTree.UnitLexNode nextCentral = getRight();
    if (isFinal()) {
        return EMPTY_ARC;
    } else if (nextCentral == null) {
        return getArcsToAllWords(this);
    } else {
        int nextLeftID = getCentral().getID();
        LexTree.LexNode[] nextNodes = getNextUnits(nextCentral);
        SearchStateArc[] nextStates = new SearchStateArc[nextNodes.length + 1];
        for (int i = 0; i < nextNodes.length; i++) {
            LexTree.LexNode nextRight = nextNodes[i];
            nextStates[i] = new LexTreeUnitState(nextLeftID, nextCentral, (LexTree.UnitLexNode) nextRight, getWordSequence());
        }
        nextStates[nextStates.length - 1] = createNextWordState(this, finalNode);
        return nextStates;
    }
}

Output:
         }
-        nextStates[nextStates.length - 1] = createNextWordState(this, finalNode);
+        nextStates[nextStates.length - 1] = getEndWord();
         return nextStates;