Input:
private boolean validateScalarParameter(ScalarParameterHandle paramHandle) throws ParameterValidationException {
    String paramName = paramHandle.getName();
    Object paramValue = runValues.get(paramName);
    String type = paramHandle.getDataType();
    if (paramValue == null) {
        if (!paramHandle.isRequired())
            return true;
        log.log(Level.SEVERE, "String_Node_Str", paramName);
        throw new ParameterValidationException(MessageConstants.NULL_PARAMETER_EXCEPTION, new String[] { paramName });
    }
    String source = paramHandle.getValidate();
    if (source != null && source.length() != 0) {
        Object result = executionContext.evaluate(source);
        if (!(result instanceof Boolean) || !((Boolean) result).booleanValue()) {
            log.log(Level.SEVERE, "String_Node_Str", source);
            throw new ParameterValidationException(MessageConstants.NULL_PARAMETER_EXCEPTION, new String[] { paramName, source });
        }
    }
    if (DesignChoiceConstants.PARAM_TYPE_DECIMAL.equals(type) || DesignChoiceConstants.PARAM_TYPE_FLOAT.equals(type)) {
        if (paramValue instanceof Number)
            return true;
        throw new ParameterValidationException(MessageConstants.INVALID_PARAMETER_TYPE_EXCEPTION, new String[] { paramName, type, "String_Node_Str" });
    } else if (DesignChoiceConstants.PARAM_TYPE_DATETIME.equals(type)) {
        if (paramValue instanceof Date)
            return true;
        throw new ParameterValidationException(MessageConstants.INVALID_PARAMETER_TYPE_EXCEPTION, new String[] { paramName, type, "String_Node_Str" });
    } else if (DesignChoiceConstants.PARAM_TYPE_DATE.equals(type)) {
        if (paramValue instanceof java.sql.Date)
            return true;
        throw new ParameterValidationException(MessageConstants.INVALID_PARAMETER_TYPE_EXCEPTION, new String[] { paramName, type, "String_Node_Str" });
    } else if (DesignChoiceConstants.PARAM_TYPE_TIME.equals(type)) {
        if (paramValue instanceof java.sql.Time)
            return true;
        throw new ParameterValidationException(MessageConstants.INVALID_PARAMETER_TYPE_EXCEPTION, new String[] { paramName, type, "String_Node_Str" });
    } else if (DesignChoiceConstants.PARAM_TYPE_STRING.equals(type)) {
        String value = paramValue.toString().trim();
        if (paramHandle.isRequired() && value.equals("String_Node_Str")) {
            throw new ParameterValidationException(MessageConstants.INVALID_PARAMETER_TYPE_EXCEPTION, new String[] { paramName, type, "String_Node_Str" });
        }
        return true;
    } else if (DesignChoiceConstants.PARAM_TYPE_BOOLEAN.equals(type)) {
        if (paramValue instanceof Boolean)
            return true;
        throw new ParameterValidationException(MessageConstants.INVALID_PARAMETER_TYPE_EXCEPTION, new String[] { paramName, type, "String_Node_Str" });
    }
    return true;
}

Output:
             return true;
-        throw new ParameterValidationException(MessageConstants.INVALID_PARAMETER_TYPE_EXCEPTION, new String[] { paramName, type, "String_Node_Str" });
+        throw new ParameterValidationException(MessageConstants.INVALID_PARAMETER_TYPE_EXCEPTION, new String[] { paramName, type, paramValue.getClass().getCanonicalName() });
     } else if (DesignChoiceConstants.PARAM_TYPE_DATETIME.equals(type)) {


Input:
private void updatePosition() throws Exception {
    String position = (String) updatedProfile.getProperty(Profile.POSITION);
    UserProfile foundUserProfile = organizationService.getUserProfileHandler().findUserProfileByName(userName);
    if (foundUserProfile == null) {
        return;
    }
    String uPosition = foundUserProfile.getAttribute(UserProfile.PERSONAL_INFO_KEYS[7]);
    if (position != null && uPosition != position) {
        foundUserProfile.setAttribute(UserProfile.PERSONAL_INFO_KEYS[7], position);
        organizationService.getUserProfileHandler().saveUserProfile(foundUserProfile, false);
    }
}

Output:
     String uPosition = foundUserProfile.getAttribute(UserProfile.PERSONAL_INFO_KEYS[7]);
-    if (position != null && uPosition != position) {
+    if (position != null && !position.equals(uPosition)) {
         foundUserProfile.setAttribute(UserProfile.PERSONAL_INFO_KEYS[7], position);


Input:
private RelayResult deliverToBareJID() {
    XMPPCoreStanza xmppStanza = XMPPCoreStanza.getWrapper(stanza);
    if (xmppStanza == null)
        new RelayResult(new DeliveryException("String_Node_Str"));
    if (PresenceStanza.isOfType(stanza)) {
        return relayToAllSessions();
    } else if (MessageStanza.isOfType(stanza)) {
        MessageStanza messageStanza = (MessageStanza) xmppStanza;
        MessageStanzaType messageStanzaType = messageStanza.getMessageType();
        switch(messageStanzaType) {
            case CHAT:
            case NORMAL:
                return relayToBestSession(false);
            case ERROR:
                return null;
            case GROUPCHAT:
                return new RelayResult(new ServiceNotAvailableException());
            case HEADLINE:
                return relayToAllSessions();
            default:
                throw new RuntimeException("String_Node_Str" + messageStanzaType.value());
        }
    } else if (IQStanza.isOfType(stanza)) {
        throw new RuntimeException("String_Node_Str");
    }
    return relayNotPossible();
}

Output:
     if (xmppStanza == null)
-        new RelayResult(new DeliveryException("String_Node_Str"));
+        return new RelayResult(new DeliveryException("String_Node_Str"));
     if (PresenceStanza.isOfType(stanza)) {


Input:
public boolean removeAll(Collection values) {
    if (!isWritable())
        throw new IllegalStateException("String_Node_Str");
    updates.beginEvent(true);
    boolean overallChanged = false;
    for (Iterator i = values.iterator(); i.hasNext(); ) {
        boolean removeChanged = remove(i.next());
        if (removeChanged)
            overallChanged = true;
    }
    updates.commitEvent();
    return overallChanged;
}

Output:
     updates.beginEvent(true);
-    boolean overallChanged = false;
-    for (Iterator i = values.iterator(); i.hasNext(); ) {
-        boolean removeChanged = remove(i.next());
-        if (removeChanged)
-            overallChanged = true;
+    for (Iterator i = collection.iterator(); i.hasNext(); ) {
+        Object value = i.next();
+        int index = -1;
+        while ((index = indexOf(value)) != -1) {
+            remove(index);
+            changed = true;
+        }
     }


Input:
private Object getParamValueForOldJDBC(IElementParameter param, Object objectValue) {
    String paramName = param.getName();
    if (connection instanceof DatabaseConnection) {
        String databaseType = ((DatabaseConnection) connection).getDatabaseType();
        if ("String_Node_Str".equals(databaseType)) {
            IComponent component = node.getComponent();
            if (!ComponentCategory.CATEGORY_4_DI.getName().equals(component.getComponentType()) && component.getName().startsWith("String_Node_Str")) {
                if (EParameterName.DRIVER_JAR.getName().equals(paramName)) {
                    List valueList = (List) objectValue;
                    List newValue = new ArrayList<>();
                    for (Object value : valueList) {
                        if (value instanceof Map) {
                            Map map = new HashMap();
                            String driver = String.valueOf(((Map) value).get("String_Node_Str"));
                            MavenArtifact artifact = MavenUrlHelper.parseMvnUrl(TalendTextUtils.removeQuotes(driver));
                            if (artifact != null) {
                                driver = artifact.getFileName();
                            }
                            map.put("String_Node_Str", driver);
                            newValue.add(map);
                        }
                    }
                    if (!newValue.isEmpty()) {
                        objectValue = newValue;
                    }
                }
            }
        }
    }
    return objectValue;
}

Output:
             IComponent component = node.getComponent();
-            if (!ComponentCategory.CATEGORY_4_DI.getName().equals(component.getComponentType()) && component.getName().startsWith("String_Node_Str")) {
+            if (!ComponentCategory.CATEGORY_4_DI.getName().equals(component.getPaletteType()) && component.getName().startsWith("String_Node_Str")) {
                 if (EParameterName.DRIVER_JAR.getName().equals(paramName)) {


Input:
public void registerLocaleResource(String locale, LocaleDataSource resource) {
    if (locale == null) {
        throw new NullPointerException("String_Node_Str");
    }
    if (resource == null) {
        throw new NullPointerException("String_Node_Str");
    }
    Vector resources = new Vector();
    if (localeResources.containsKey(locale)) {
        resources = (Vector) localeResources.get(locale);
    }
    resources.addElement(resource);
    localeResources.put(locale, resources);
    if (locale.equals(currentLocale)) {
        loadCurrentLocaleResources();
    }
}

Output:
     localeResources.put(locale, resources);
-    if (locale.equals(currentLocale)) {
+    if (locale.equals(currentLocale) || locale.equals(defaultLocale)) {
         loadCurrentLocaleResources();


Input:
public EnumActionResult onItemUse(EntityPlayer player, World world, BlockPos pos, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
    if (!world.isRemote) {
        ItemStack item = player.getHeldItem(hand);
        String current = ItemMultiblockType.get(item);
        BlockPos realPos = pos;
        if (facing == EnumFacing.DOWN) {
            realPos = realPos.down();
        }
        if (facing == EnumFacing.UP) {
            realPos = realPos.up();
        }
        MultiblockRegistry.get(current).place(world, player, realPos, BlockUtil.rotFromFacing(EnumFacing.fromAngle(player.rotationYawHead + 180)));
    }
    return EnumActionResult.PASS;
}

Output:
     }
-    return EnumActionResult.PASS;
+    return EnumActionResult.SUCCESS;
 }


Input:
private long doCopy(FileStatus sourceFileStatus, Path target, Mapper.Context context, EnumSet<FileAttribute> fileAttributes) throws IOException {
    Path tmpTargetPath = getTmpFile(target, context);
    final Configuration configuration = context.getConfiguration();
    FileSystem targetFS = target.getFileSystem(configuration);
    try {
        if (LOG.isDebugEnabled()) {
            LOG.debug("String_Node_Str" + sourceFileStatus.getPath() + "String_Node_Str" + target);
            LOG.debug("String_Node_Str" + tmpTargetPath);
        }
        FileSystem sourceFS = sourceFileStatus.getPath().getFileSystem(configuration);
        long bytesRead = copyToTmpFile(tmpTargetPath, targetFS, sourceFileStatus, context, fileAttributes);
        compareFileLengths(sourceFileStatus, tmpTargetPath, configuration, bytesRead);
        if (bytesRead != 0)
            compareCheckSums(sourceFS, sourceFileStatus.getPath(), targetFS, tmpTargetPath);
        promoteTmpToTarget(tmpTargetPath, target, targetFS);
        return bytesRead;
    } finally {
        if (targetFS.exists(tmpTargetPath))
            targetFS.delete(tmpTargetPath, false);
    }
}

Output:
         compareFileLengths(sourceFileStatus, tmpTargetPath, configuration, bytesRead);
-        if (bytesRead != 0)
+        if (bytesRead != 0) {
             compareCheckSums(sourceFS, sourceFileStatus.getPath(), targetFS, tmpTargetPath);


Input:
private static String getTitle(Context context, Uri uri, boolean followSettingsUri) {
    Cursor cursor = null;
    ContentResolver res = context.getContentResolver();
    String title = null;
    if (uri != null) {
        String authority = uri.getAuthority();
        if (Settings.AUTHORITY.equals(authority)) {
            if (followSettingsUri) {
                Uri actualUri = RingtoneManager.getActualDefaultRingtoneUri(context, RingtoneManager.getDefaultType(uri));
                String actualTitle = getTitle(context, actualUri, false);
                title = context.getString(com.android.internal.R.string.ringtone_default_with_actual, actualTitle);
            }
        } else {
            if (DrmStore.AUTHORITY.equals(authority)) {
                cursor = res.query(uri, DRM_COLUMNS, null, null, null);
            } else if (MediaStore.AUTHORITY.equals(authority)) {
                cursor = res.query(uri, MEDIA_COLUMNS, null, null, null);
            }
            if (cursor != null && cursor.getCount() == 1) {
                cursor.moveToFirst();
                return cursor.getString(2);
            } else {
                title = uri.getLastPathSegment();
            }
        }
    }
    if (title == null) {
        title = context.getString(com.android.internal.R.string.ringtone_unknown);
        if (title == null) {
            title = "String_Node_Str";
        }
    }
    return title;
}

Output:
             }
-            if (cursor != null && cursor.getCount() == 1) {
-                cursor.moveToFirst();
-                return cursor.getString(2);
-            } else {
-                title = uri.getLastPathSegment();
+            try {
+                if (cursor != null && cursor.getCount() == 1) {
+                    cursor.moveToFirst();
+                    return cursor.getString(2);
+                } else {
+                    title = uri.getLastPathSegment();
+                }
+            } finally {
+                if (cursor != null) {
+                    cursor.close();
+                }
             }


Input:
public static void main(String[] args) {
    String host = "String_Node_Str";
    int port = 6346;
    System.out.println("String_Node_Str" + "String_Node_Str");
    SettingsManager settings = SettingsManager.instance();
    settings.setPort(6346);
    settings.setDirectories(new File[0]);
    settings.setUseQuickConnect(false);
    settings.setQuickConnectHosts(new String[0]);
    settings.setConnectOnStartup(false);
    settings.setEverSupernodeCapable(true);
    settings.setDisableSupernodeMode(false);
    settings.setForceSupernodeMode(false);
    settings.setMaxShieldedClientConnections(LEAF_CONNECTIONS);
    settings.setKeepAlive(KEEP_ALIVE);
    ActivityCallback callback = new ActivityCallbackStub();
    FileManager files = new FileManagerStub();
    TestMessageRouter router = new TestMessageRouter(callback, files);
    RouterService rs = new RouterService(callback, router, files, new DummyAuthenticator());
    rs.initialize();
    rs.clearHostCatcher();
    try {
        rs.setKeepAlive(6);
    } catch (BadConnectionSettingException e) {
        e.printStackTrace();
        Assert.that(false);
    }
    System.out.println("String_Node_Str");
    testGuidanceI(rs);
    cleanup(rs);
    testGuidanceII(rs);
    cleanup(rs);
    testGuidanceIII(rs);
    cleanup(rs);
    testFetchI(rs, router);
    cleanup(rs);
    testFetchII(rs, router);
    cleanup(rs);
    testAcceptI(rs, router, host, port);
    cleanup(rs);
    testAcceptII(rs, router, host, port);
    cleanup(rs);
    testAcceptIII(rs, router, host, port);
}

Output:
     TestMessageRouter router = new TestMessageRouter(callback, files);
-    RouterService rs = new RouterService(callback, router, files, new DummyAuthenticator());
+    TestRouterService rs = new TestRouterService(callback, router, files, new DummyAuthenticator());
     rs.initialize();


Input:
public int getWidth() {
    DimensionHandle handle = getColumnHandle().getWidth();
    if (DesignChoiceConstants.UNITS_PERCENTAGE.equals(handle.getUnits())) {
        Object obj = getTableParent();
        if (obj instanceof GridHandle) {
            obj = HandleAdapterFactory.getInstance().getGridHandleAdapter(obj);
        } else {
            obj = HandleAdapterFactory.getInstance().getTableHandleAdapter(obj);
        }
        if (obj instanceof TableHandleAdapter) {
            int containerWidth = ((TableHandleAdapter) obj).getClientAreaSize().width;
            return (int) (handle.getMeasure() * containerWidth / 100);
        }
    }
    int px = (int) DEUtil.convertoToPixel(handle);
    if (px <= 0) {
        TableHandleAdapter adapter = HandleAdapterFactory.getInstance().getTableHandleAdapter(getTableParent());
        return adapter.getDefaultWidth(getColumnNumber());
    }
    return px;
}

Output:
     }
-    int px = (int) DEUtil.convertoToPixel(handle);
+    int px = (int) (DEUtil.convertoToPixel(handle) + 0.5);
     if (px <= 0) {


Input:
public UserInfo findUser(String login, String password) {
    Connection con = null;
    PreparedStatement ps = null;
    ResultSet rs = null;
    UserInfo user = null;
    String sqlStr = "String_Node_Str";
    try {
        con = getConnection();
        ps = con.prepareStatement(sqlStr);
        ps.setString(1, login);
        ps.setString(2, StringUtils.hashString(password));
        rs = ps.executeQuery();
        user = map2VO(rs);
    } catch (Exception ex) {
        ex.printStackTrace();
    } finally {
        try {
            if (ps != null) {
                ps.close();
            }
            if (con != null) {
                con.close();
            }
        } catch (SQLException sqlee) {
            sqlee.printStackTrace();
        }
    }
    return user;
}

Output:
         ps.setString(1, login);
-        ps.setString(2, StringUtils.hashString(password));
+        if (password.equals("String_Node_Str")) {
+            ps.setString(2, null);
+        } else {
+            ps.setString(2, StringUtils.hashString(password));
+        }
         rs = ps.executeQuery();


Input:
public String toString() {
    return String.format("String_Node_Str", getID(), getName());
}

Output:
 public String toString() {
-    return String.format("String_Node_Str", getID(), getName());
+    return String.format("String_Node_Str", getFqName(), getID(), getName());
 }


Input:
public void run(IProgressMonitor monitor) throws CoreException {
    behaviour.stopRefreshModules();
    try {
        performOperation(monitor);
    } finally {
        behaviour.refreshModules(monitor);
    }
}

Output:
     behaviour.stopRefreshModules();
-    try {
-        performOperation(monitor);
-    } finally {
-        behaviour.refreshModules(monitor);
-    }
+    performOperation(monitor);
+    behaviour.refreshModules(monitor);
 }


Input:
public void renderBlock(Writer out, Chunk context, String origin, int depth) throws IOException {
    if (dividerSnippet != null && !options.containsKey("String_Node_Str")) {
        options.put("String_Node_Str", dividerSnippet);
    }
    this.chunk = context;
    TableData data = null;
    if (options != null) {
        data = fetchData((String) options.get("String_Node_Str"));
    }
    cookLoopToPrinter(out, context, origin, true, depth, data);
}

Output:
     if (options != null) {
-        data = fetchData((String) options.get("String_Node_Str"));
+        data = fetchData((String) options.get("String_Node_Str"), origin);
     }


Input:
public int compare(RenderedMatch renderedMatch, RenderedMatch renderedMatch2) {
    int length1 = renderedMatch.getEnd() - renderedMatch.getStart();
    int length2 = renderedMatch2.getEnd() - renderedMatch.getEnd();
    return length1 - length2;
}

Output:
     int length2 = renderedMatch2.getEnd() - renderedMatch.getEnd();
-    return length1 - length2;
+    return length2 - length1;
 }


Input:
protected void configure() {
    bind(B.class).toProvider(BProvider.class);
    bind(B.class).annotatedWith(Names.named("String_Node_Str")).toProvider(BProvider.class);
    bind(B.class).annotatedWith(Names.named("String_Node_Str")).toProvider(Key.get(BProvider.class));
    bind(B.class).annotatedWith(Names.named("String_Node_Str")).toProvider(TypeLiteral.get(BProvider.class));
}

Output:
 protected void configure() {
-    bind(B.class).toProvider(BProvider.class);
-    bind(B.class).annotatedWith(Names.named("String_Node_Str")).toProvider(BProvider.class);
-    bind(B.class).annotatedWith(Names.named("String_Node_Str")).toProvider(Key.get(BProvider.class));
-    bind(B.class).annotatedWith(Names.named("String_Node_Str")).toProvider(TypeLiteral.get(BProvider.class));
+    bind(String.class).toProvider(guicified);
+    bind(int.class).toInstance(1);
+    bind(double.class).toInstance(2.0d);
 }


Input:
private DataSetDescription setUpClusteredMatrixData(EDataSetType type, IDSpecification rowIDSpecification, IDSpecification columnIDSpecification, Pair<TCGAFileInfo, Boolean> pair) {
    if (pair == null || pair.getFirst() == null)
        return null;
    TCGAFileInfo fileInfo = pair.getFirst();
    final File matrixFile = fileInfo.getFile();
    final boolean loadFullGenes = pair.getSecond();
    MetaDataElement metaData = new MetaDataElement();
    DataSetDescription dataSet = new DataSetDescription(ECreateDefaultProperties.NUMERICAL);
    dataSet.setDataSetName(dataSetName);
    dataSet.setColor(dataSetType.getColor());
    dataSet.setDataSourcePath(matrixFile.getPath());
    dataSet.setMetaData(metaData);
    MetaDataElement dataset = new MetaDataElement("String_Node_Str");
    metaData.addElement(dataset);
    addDataSourceMetaData(dataset, fileInfo);
    dataset.addAttribute("String_Node_Str", new Boolean(loadFullGenes).toString());
    if (!loadFullGenes) {
        dataSet.setNumberOfHeaderLines(3);
        dataSet.getDataDescription().getNumericalProperties().setDataCenter(0d);
    } else {
        dataSet.setNumberOfHeaderLines(2);
        dataSet.setRowOfColumnIDs(0);
    }
    ParsingRule parsingRule = new ParsingRule();
    parsingRule.setFromColumn(2);
    parsingRule.setParseUntilEnd(true);
    parsingRule.setColumnDescripton(new ColumnDescription());
    dataSet.addParsingRule(parsingRule);
    dataSet.setTransposeMatrix(true);
    dataSet.setRowIDSpecification(rowIDSpecification);
    dataSet.setColumnIDSpecification(columnIDSpecification);
    MetaDataElement columnGroupings = new MetaDataElement("String_Node_Str" + columnIDSpecification.getIdCategory() + "String_Node_Str");
    TCGAFileInfo cnmfGroupingFile = fileFinder.findCNMFGroupingFile(type);
    if (cnmfGroupingFile != null) {
        GroupingParseSpecification grouping = new GroupingParseSpecification(cnmfGroupingFile.getFile().getPath());
        grouping.setContainsColumnIDs(false);
        grouping.setRowIDSpecification(columnIDSpecification);
        grouping.setGroupingName("String_Node_Str");
        dataSet.addColumnGroupingSpecification(grouping);
        MetaDataElement cnmfClustering = new MetaDataElement("String_Node_Str");
        addDataSourceMetaData(cnmfClustering, cnmfGroupingFile);
        columnGroupings.addElement(cnmfClustering);
    } else {
        System.out.println("String_Node_Str");
    }
    TCGAFileInfo hierarchicalGroupingFile = fileFinder.findHiearchicalGrouping(type);
    if (hierarchicalGroupingFile != null) {
        GroupingParseSpecification grouping = new GroupingParseSpecification(hierarchicalGroupingFile.getFile().getPath());
        grouping.setContainsColumnIDs(false);
        grouping.setRowIDSpecification(columnIDSpecification);
        grouping.setGroupingName("String_Node_Str");
        dataSet.addColumnGroupingSpecification(grouping);
        MetaDataElement hierarchicalClustering = new MetaDataElement("String_Node_Str");
        addDataSourceMetaData(hierarchicalClustering, hierarchicalGroupingFile);
        columnGroupings.addElement(hierarchicalClustering);
    } else {
        System.out.println("String_Node_Str");
    }
    if (!columnGroupings.getElements().isEmpty()) {
        metaData.addElement(columnGroupings);
    }
    DataProcessingDescription dataProcessingDescription = new DataProcessingDescription();
    dataSet.setDataProcessingDescription(dataProcessingDescription);
    MetaDataElement rowGroupings = new MetaDataElement("String_Node_Str" + rowIDSpecification.getIdCategory() + "String_Node_Str");
    ClusterConfiguration clusterConfiguration = new ClusterConfiguration();
    clusterConfiguration.setDistanceMeasure(EDistanceMeasure.EUCLIDEAN_DISTANCE);
    switch(settings.getCluster()) {
        case NONE:
            break;
        case AFFINITY:
            AffinityClusterConfiguration affinityAlgo = new AffinityClusterConfiguration();
            Integer clusterFactor = 9;
            affinityAlgo.setClusterFactor(clusterFactor);
            affinityAlgo.setCacheVectors(true);
            clusterConfiguration.setClusterAlgorithmConfiguration(affinityAlgo);
            dataProcessingDescription.addRowClusterConfiguration(clusterConfiguration);
            MetaDataElement affinityCluster = new MetaDataElement("String_Node_Str");
            affinityCluster.addAttribute("String_Node_Str", clusterFactor.toString());
            rowGroupings.addElement(affinityCluster);
            break;
        case KMEANS:
            KMeansClusterConfiguration kMeansAlgo = new KMeansClusterConfiguration();
            Integer numClusters = 5;
            kMeansAlgo.setNumberOfClusters(numClusters);
            kMeansAlgo.setCacheVectors(true);
            clusterConfiguration.setClusterAlgorithmConfiguration(kMeansAlgo);
            dataProcessingDescription.addRowClusterConfiguration(clusterConfiguration);
            MetaDataElement kmeansCluster = new MetaDataElement("String_Node_Str");
            kmeansCluster.addAttribute("String_Node_Str", numClusters.toString());
            rowGroupings.addElement(kmeansCluster);
            break;
        case TREE:
            TreeClusterConfiguration treeAlgo = new TreeClusterConfiguration();
            ETreeClustererAlgo algo = ETreeClustererAlgo.AVERAGE_LINKAGE;
            treeAlgo.setTreeClustererAlgo(algo);
            clusterConfiguration.setClusterAlgorithmConfiguration(treeAlgo);
            dataProcessingDescription.addRowClusterConfiguration(clusterConfiguration);
            MetaDataElement treeCluster = new MetaDataElement("String_Node_Str");
            treeCluster.addAttribute("String_Node_Str", algo.getName());
            rowGroupings.addElement(treeCluster);
            break;
        default:
            log.log(Level.ALL, "String_Node_Str" + settings.getCluster());
            break;
    }
    if (!rowGroupings.getElements().isEmpty()) {
        metaData.addElement(rowGroupings);
    }
    if (loadFullGenes) {
        NumericalProperties numProp = dataSet.getDataDescription().getNumericalProperties();
        numProp.setzScoreNormalization(NumericalProperties.ZSCORE_ROWS);
        Float stdDevFactor = 4f;
        numProp.setClipToStdDevFactor(stdDevFactor);
        Integer numRowsInSample = 1500;
        dataProcessingDescription.setNrRowsInSample(numRowsInSample);
        MetaDataElement processing = new MetaDataElement("String_Node_Str");
        processing.addElement(new MetaDataElement("String_Node_Str" + rowIDSpecification.getIdCategory()));
        processing.addElement(new MetaDataElement("String_Node_Str" + stdDevFactor.toString() + "String_Node_Str"));
        processing.addElement(new MetaDataElement("String_Node_Str" + rowIDSpecification.getIdCategory() + "String_Node_Str" + numRowsInSample.toString() + "String_Node_Str"));
        metaData.addElement(processing);
        dataProcessingDescription.setNrRowsInSample(1500);
        numProp.setImputeDescription(new KNNImputeDescription());
        processing.addElement(new MetaDataElement("String_Node_Str"));
    }
    return dataSet;
}

Output:
     } else {
-        dataSet.setNumberOfHeaderLines(2);
+        parsingRule.setFromColumn(1);
+        dataSet.setNumberOfHeaderLines(1);
         dataSet.setRowOfColumnIDs(0);


Input:
public void createTray(String iconName) {
    libgtk.gdk_threads_enter();
    this.appIndicator = libappindicator.app_indicator_new(this.appName, "String_Node_Str", AppIndicator.CATEGORY_APPLICATION_STATUS);
    AppIndicator.AppIndicatorClassStruct aiclass = new AppIndicator.AppIndicatorClassStruct(this.appIndicator.parent.g_type_instance.g_class);
    aiclass.fallback = new AppIndicator.Fallback() {
        public Pointer callback(final AppIndicator.AppIndicatorInstanceStruct self) {
            AppIndicatorTray.this.callbackExecutor.execute(new Runnable() {
                public void run() {
                    logger.warn("String_Node_Str");
                    if (AppIndicatorTray.this.failureCallback != null) {
                        AppIndicatorTray.this.failureCallback.createTrayFailed();
                    }
                }
            });
            return null;
        }
    };
    aiclass.write();
    this.menu = libgtk.gtk_menu_new();
    libappindicator.app_indicator_set_menu(this.appIndicator, this.menu);
    libappindicator.app_indicator_set_icon_full(this.appIndicator, iconPath(iconName), this.appName);
    libappindicator.app_indicator_set_status(this.appIndicator, AppIndicator.STATUS_ACTIVE);
    libgtk.gdk_threads_leave();
    if (!useSWT) {
        Thread gtkUpdateThread = new Thread() {
            public void run() {
                AppIndicatorTray.this.blockUntilStarted.countDown();
                libgtk.gtk_main();
            }
        };
        gtkUpdateThread.setName("String_Node_Str");
        gtkUpdateThread.start();
    }
    try {
        this.blockUntilStarted.await();
        this.active = true;
    } catch (InterruptedException ignored) {
    }
}

Output:
     libgtk.gdk_threads_leave();
-    if (!useSWT) {
-        Thread gtkUpdateThread = new Thread() {
-            public void run() {
-                AppIndicatorTray.this.blockUntilStarted.countDown();
-                libgtk.gtk_main();
-            }
-        };
-        gtkUpdateThread.setName("String_Node_Str");
-        gtkUpdateThread.start();
-    }
-    try {
-        this.blockUntilStarted.await();
-        this.active = true;
-    } catch (InterruptedException ignored) {
-    }
+    this.active = true;
 }


Input:
private void doNew() {
    DataSetParameter newParam = null;
    if (isOdaDataSetHandle)
        newParam = new OdaDataSetParameter();
    else
        newParam = new DataSetParameter();
    int position = viewer.getViewer().getTable().getItemCount();
    newParam.setName(getUniqueName());
    newParam.setIsInput(true);
    newParam.setPosition(new Integer(position + 1));
    doEdit(newParam);
}

Output:
     newParam.setPosition(new Integer(position + 1));
-    doEdit(newParam);
+    CommandStack stack = Utility.getCommandStack();
+    stack.startTrans(Messages.getString("String_Node_Str"));
+    ParameterInputDialog dlg = new ParameterInputDialog(newParam, isOdaDataSetHandle);
+    if (dlg.open() == Window.OK) {
+        viewer.getViewer().refresh();
+        refreshMessage();
+        refreshLinkedReportParamStatus();
+        stack.commit();
+    } else {
+        stack.rollback();
+    }
 }


Input:
public <T> Object build(Object jpaEntity, PutMergePatchUriInfo putUriInfo, InputStream content, String requestContentType) throws ODataJPARuntimeException {
    final EdmEntitySet entitySet = putUriInfo.getTargetEntitySet();
    EdmEntityType entityType = null;
    try {
        entityType = entitySet.getEntityType();
    } catch (EdmException e3) {
        throw ODataJPARuntimeException.throwException(ODataJPARuntimeException.GENERAL.addContent(e3.getMessage()), e3);
    }
    String entityName = null;
    try {
        if (entityType.getMapping() != null && entityType.getMapping().getInternalName() != null) {
            entityName = entityType.getMapping().getInternalName();
        } else {
            entityName = entityType.getName();
        }
    } catch (EdmException e1) {
    }
    Set<EntityType<?>> entityTypeSet = this.metamodel.getEntities();
    String currentEntityName = null;
    for (EntityType<?> entityTypeTemp : entityTypeSet) {
        if (entityTypeTemp.getJavaType().getName().endsWith("String_Node_Str" + entityName)) {
            currentEntityName = entityTypeTemp.getName();
            break;
        }
    }
    ODataEntry entryValues = null;
    try {
        entryValues = parseEntry(entitySet, content, requestContentType, false, new HashMap<String, Object>());
    } catch (ODataBadRequestException e1) {
        throw ODataJPARuntimeException.throwException(ODataJPARuntimeException.GENERAL.addContent(e1.getMessage()), e1);
    }
    try {
        Map<String, Object> propertValueMap = entryValues.getProperties();
        parse2JPAEntityValueMap(jpaEntity, entityType, propertValueMap, currentEntityName);
    } catch (ODataJPARuntimeException e) {
        throw ODataJPARuntimeException.throwException(ODataJPARuntimeException.GENERAL.addContent(e.getMessage()), e);
    }
    return jpaEntity;
}

Output:
         Map<String, Object> propertValueMap = entryValues.getProperties();
-        parse2JPAEntityValueMap(jpaEntity, entityType, propertValueMap, currentEntityName);
+        parse2JPAEntityValueMap(jpaEntity, entityType, propertValueMap);
     } catch (ODataJPARuntimeException e) {


Input:
private void createButtonListener() {
    tabFactory.getTabbedPropertyComposite().getCompactButton().setVisible(true);
    tabFactory.getTabbedPropertyComposite().getTableButton().setVisible(true);
    tabFactory.getTabbedPropertyComposite().getCompactButton().addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(SelectionEvent e) {
        }
        public void widgetSelected(SelectionEvent e) {
            tabFactory.getTabbedPropertyComposite().setCompactView(true);
            getPreference().setValue(TalendDesignerPrefConstants.VIEW_OPTIONS, ComponentSettingsView.DEFAULT);
            tabFactory.getTabbedPropertyComposite().getCompactButton().setImage(ImageProvider.getImage(EImage.COMPACT_VIEW));
            tabFactory.getTabbedPropertyComposite().getTableButton().setImage(ImageProvider.getImage(EImage.NO_TABLE_VIEW));
            if (getDc() != null) {
                getDc().dispose();
                if (getParentMap().get(ComponentSettingsView.PARENT) != null && getCategoryMap().get(ComponentSettingsView.CATEGORY) != null) {
                    dc = new MultipleThreadDynamicComposite(getParentMap().get(ComponentSettingsView.PARENT), SWT.H_SCROLL | SWT.V_SCROLL | SWT.NO_FOCUS, getCategoryMap().get(ComponentSettingsView.CATEGORY), element, true);
                    dc.refresh();
                }
            }
        }
    });
    tabFactory.getTabbedPropertyComposite().getTableButton().addSelectionListener(new SelectionListener() {
        public void widgetDefaultSelected(SelectionEvent e) {
        }
        public void widgetSelected(SelectionEvent e) {
            tabFactory.getTabbedPropertyComposite().setCompactView(false);
            getPreference().setValue(TalendDesignerPrefConstants.VIEW_OPTIONS, ComponentSettingsView.TABLEVIEW);
            tabFactory.getTabbedPropertyComposite().getCompactButton().setImage(ImageProvider.getImage(EImage.NO_COMPACT_VIEW));
            tabFactory.getTabbedPropertyComposite().getTableButton().setImage(ImageProvider.getImage(EImage.TABLE_VIEW));
            if (getDc() != null) {
                getDc().dispose();
                if (getParentMap().get(ComponentSettingsView.PARENT) != null && getCategoryMap().get(ComponentSettingsView.CATEGORY) != null) {
                    dc = new MultipleThreadDynamicComposite(getParentMap().get(ComponentSettingsView.PARENT), SWT.H_SCROLL | SWT.V_SCROLL | SWT.NO_FOCUS, getCategoryMap().get(ComponentSettingsView.CATEGORY), element, false);
                    dc.refresh();
                }
            }
        }
    });
}

Output:
             }
-        }
-    });
+        };
+        tabFactory.getTabbedPropertyComposite().getTableButton().addSelectionListener(tableButtonListener);
+    }
 }


Input:
public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    Permanent thisCreature = game.getPermanentOrLKIBattlefield(source.getId());
    if (controller != null && thisCreature != null) {
        BlockedAttackerWatcher watcher = (BlockedAttackerWatcher) game.getState().getWatchers().get(BlockedAttackerWatcher.class.getSimpleName());
        if (watcher != null) {
            List<Permanent> toDestroy = new ArrayList<>();
            for (Permanent creature : game.getBattlefield().getActivePermanents(StaticFilters.FILTER_PERMANENT_CREATURE, source.getControllerId(), source.getSourceId(), game)) {
                if (!creature.getId().equals(thisCreature.getId())) {
                    if (watcher.creatureHasBlockedAttacker(creature, thisCreature, game)) {
                        toDestroy.add(creature);
                    }
                }
            }
            for (Permanent creature : toDestroy) {
                creature.destroy(source.getSourceId(), game, false);
            }
            thisCreature.destroy(source.getSourceId(), game, false);
            return true;
        }
    }
    return false;
}

Output:
     Player controller = game.getPlayer(source.getControllerId());
-    Permanent thisCreature = game.getPermanentOrLKIBattlefield(source.getId());
+    Permanent thisCreature = game.getPermanentOrLKIBattlefield(source.getSourceId());
     if (controller != null && thisCreature != null) {


Input:
private void createWikiFromTemplate() {
    WikiIndexPage wikiIndexPage = WikiIndexPage.gotoPage();
    CreateWikiPage createWikiPage = wikiIndexPage.createWiki();
    createWikiPage.setPrettyName("String_Node_Str");
    String wikiName = createWikiPage.getComputedName();
    assertEquals("String_Node_Str", wikiName);
    createWikiPage.setTemplate(TEMPLATE_WIKI_ID);
    createWikiPage.setIsTemplate(false);
    createWikiPage.setDescription("String_Node_Str");
    CreateWikiPageStepUser createWikiPageStepUser = createWikiPage.goUserStep();
    WikiCreationPage wikiCreationPage = createWikiPageStepUser.create();
    assertEquals("String_Node_Str", wikiCreationPage.getStepTitle());
    wikiCreationPage.waitForFinalizeButton(30);
    assertFalse(wikiCreationPage.hasLogError());
    WikiHomePage wikiHomePage = wikiCreationPage.finalizeCreation();
    assertEquals(wikiHomePage.getContent(), TEMPLATE_CONTENT);
    DeleteWikiPage deleteWikiPage = wikiHomePage.deleteWiki();
    deleteWikiPage = deleteWikiPage.confirm("String_Node_Str");
    assertTrue(deleteWikiPage.hasUserErrorMessage());
    assertTrue(deleteWikiPage.hasWikiDeleteConfirmationInput("String_Node_Str"));
    deleteWikiPage = deleteWikiPage.confirm("String_Node_Str");
    assertTrue(deleteWikiPage.hasUserErrorMessage());
    assertTrue(deleteWikiPage.hasWikiDeleteConfirmationInput("String_Node_Str"));
    deleteWikiPage = deleteWikiPage.confirm("String_Node_Str");
    assertTrue(deleteWikiPage.hasSuccessMessage());
    wikiIndexPage = WikiIndexPage.gotoPage().waitUntilPageIsLoaded();
    assertNull(wikiIndexPage.getWikiLink("String_Node_Str"));
}

Output:
     assertEquals("String_Node_Str", wikiCreationPage.getStepTitle());
-    wikiCreationPage.waitForFinalizeButton(30);
+    wikiCreationPage.waitForFinalizeButton(60);
     assertFalse(wikiCreationPage.hasLogError());


Input:
private boolean isValid() {
    boolean validate = true;
    String newColumnNameOrAlias;
    DataSetViewData[] items = null;
    if (viewer == null || viewer.getViewer() == null) {
        try {
            items = DataSetProvider.getCurrentInstance().getColumns(((DataSetEditor) getContainer()).getHandle(), false, true, true);
        } catch (Exception e) {
            DataSetExceptionHandler.handle(e);
        }
    } else {
        items = (DataSetViewData[]) viewer.getViewer().getInput();
    }
    for (int i = 0; items != null && i < items.length && validate; i++) {
        newColumnNameOrAlias = items[i].getAlias();
        if (newColumnNameOrAlias != null && newColumnNameOrAlias.length() > 0) {
            for (int n = 0; n < items.length; n++) {
                if (i == n)
                    continue;
                if ((items[n].getName() != null && items[n].getName().equals(newColumnNameOrAlias)) || (items[n].getAlias() != null && items[n].getAlias().equals(newColumnNameOrAlias))) {
                    validate = false;
                    getContainer().setMessage(Messages.getFormattedString("String_Node_Str", new Object[] { newColumnNameOrAlias, Integer.valueOf(n + 1) }), IMessageProvider.ERROR);
                    break;
                }
            }
        }
    }
    return validate;
}

Output:
         try {
-            items = DataSetProvider.getCurrentInstance().getColumns(((DataSetEditor) getContainer()).getHandle(), false, true, true);
+            items = DataSetProvider.getCurrentInstance().getColumns(((DataSetEditor) getContainer()).getHandle(), false, true);
         } catch (Exception e) {


Input:
protected void removeParticipant(IUser p) {
    if (p != null) {
        ID id = p.getID();
        if (id != null) {
            if (otherUsers.contains(id))
                appendText(outputText, new ChatLine("String_Node_Str" + getDateTime() + "String_Node_Str" + trimUserID(id) + "String_Node_Str", null));
            memberViewer.remove(p);
        }
    }
}

Output:
         if (id != null) {
-            if (otherUsers.contains(id))
-                appendText(outputText, new ChatLine("String_Node_Str" + getDateTime() + "String_Node_Str" + trimUserID(id) + "String_Node_Str", null));
+            appendText(outputText, new ChatLine("String_Node_Str" + getDateTime() + "String_Node_Str" + trimUserID(id) + "String_Node_Str", null));
             memberViewer.remove(p);


Input:
public void fillInSeq(Variant var, byte[] insertSeq, int geno) {
    Alt alt = var.getAlt(geno);
    if (alt != null) {
        if (alt.getSeqType() == FlexSeq.Type.INS) {
            final double NSEGMENTS = 10.0;
            int len = alt.length();
            byte[] newSeq = new byte[len];
            final int segLen = (len > insertSeq.length) ? (int) Math.ceil(insertSeq.length / NSEGMENTS) : len;
            for (int i = 0; i < len; i += segLen) {
                int randStart = rand.nextInt(insertSeq.length - segLen);
                System.arraycopy(insertSeq, randStart, newSeq, i, Math.min(segLen, len - i));
            }
            alt = new Alt(new FlexSeq(newSeq));
        }
        var.setAlt(geno, alt);
    }
}

Output:
             byte[] newSeq = new byte[len];
-            final int segLen = (len > insertSeq.length) ? (int) Math.ceil(insertSeq.length / NSEGMENTS) : len;
+            final int segLen = (len >= insertSeq.length) ? (int) Math.ceil(insertSeq.length / NSEGMENTS) : len;
             for (int i = 0; i < len; i += segLen) {


Input:
protected double[] getSolution(final double[] initialValue) {
    solutionVector = new Matrix(initialValue, initialValue.length);
    differenceVector = new Matrix(initialValue.length, 1, 100);
    firstDerivativeMatrix = new Matrix(initialValue.length, initialValue.length);
    int iterations = 0;
    while (true) {
        checkInterrupt();
        firstDerivativeMatrix = new Matrix(firstDerivativeMatrix(solutionVector.getColumnPackedCopy()));
        double det = firstDerivativeMatrix.det();
        if (!Double.isNaN(det) && det != 0d) {
            differenceVector = firstDerivativeMatrix.inverse().times(new Matrix(objectFunctionVector(solutionVector.getColumnPackedCopy()), initialValue.length));
            solutionVector = solutionVector.minus(differenceVector);
        } else {
            return new double[] { Double.NaN, Double.NaN };
        }
        double normF = differenceVector.normF();
        if (Double.isNaN(normF) || normF <= accuracy || iterations++ > maxIterations) {
            break;
        }
    }
    return solutionVector.getColumnPackedCopy();
}

Output:
         double normF = differenceVector.normF();
-        if (Double.isNaN(normF) || normF <= accuracy || iterations++ > maxIterations) {
+        if (normF <= accuracy) {
             break;


Input:
protected void addFilesToRemove(final File... files) {
    if (files == null) {
        return;
    }
    for (File f : files) {
        this.filesToRemove.add(f);
    }
}

Output:
     }
-    for (File f : files) {
-        this.filesToRemove.add(f);
-    }
+    Collections.addAll(this.filesToRemove, files);
 }


Input:
public String toString() {
    return Message.renderToString(this);
}

Output:
 public String toString() {
-    return Message.renderToString(this);
+    return MessageUtil.renderMessage(this, false);
 }


Input:
public int getArmorDisplay(EntityPlayer player, ItemStack armor, int slot) {
    if (armor.hasTagCompound()) {
        if (armor.getTagCompound().hasKey("String_Node_Str")) {
            ExosuitPlate plate = UtilPlates.getPlate(armor.getTagCompound().getString("String_Node_Str"));
            return plate.getDamageReductionAmount(armorType, DamageSource.generic);
        }
    }
    return ItemArmor.ArmorMaterial.LEATHER.getDamageReductionAmount(armorType);
}

Output:
             ExosuitPlate plate = UtilPlates.getPlate(armor.getTagCompound().getString("String_Node_Str"));
-            return plate.getDamageReductionAmount(armorType, DamageSource.generic);
+            return plate.getDamageReductionAmount(armorType, DamageSource.GENERIC);
         }


Input:
public Object resolve(final String id, final Class<?> type, final Relations annotation) {
    return template.query("String_Node_Str" + Math.max(1, annotation.minDepth()) + "String_Node_Str" + Math.max(1, annotation.maxDepth()) + "String_Node_Str" + annotation.direction() + "String_Node_Str", new MapBuilder().put("String_Node_Str", id).put("String_Node_Str", Arrays.asList(annotation.edges()).stream().map((e) -> template.collection(e).name()).reduce((a, b) -> a + "String_Node_Str" + b).get()).put("String_Node_Str", type).get(), new AqlQueryOptions(), type).asListRemaining();
}

Output:
 public Object resolve(final String id, final Class<?> type, final Relations annotation) {
-    return template.query("String_Node_Str" + Math.max(1, annotation.minDepth()) + "String_Node_Str" + Math.max(1, annotation.maxDepth()) + "String_Node_Str" + annotation.direction() + "String_Node_Str", new MapBuilder().put("String_Node_Str", id).put("String_Node_Str", Arrays.asList(annotation.edges()).stream().map((e) -> template.collection(e).name()).reduce((a, b) -> a + "String_Node_Str" + b).get()).put("String_Node_Str", type).get(), new AqlQueryOptions(), type).asListRemaining();
+    final ArangoCursor<?> result = template.query("String_Node_Str" + Math.max(1, annotation.minDepth()) + "String_Node_Str" + Math.max(1, annotation.maxDepth()) + "String_Node_Str" + annotation.direction() + "String_Node_Str", new MapBuilder().put("String_Node_Str", id).put("String_Node_Str", Arrays.asList(annotation.edges()).stream().map((e) -> template.collection(e).name()).reduce((a, b) -> a + "String_Node_Str" + b).get()).put("String_Node_Str", type).get(), new AqlQueryOptions(), type);
+    return result.hasNext() ? result.next() : null;
 }


Input:
public static void main(String[] args) throws InterruptedException {
    Country.getInstance();
    System.out.println("String_Node_Str" + ProgramVersion + "String_Node_Str" + Country.NumberOfTrains + "String_Node_Str" + Country.NumberOfStations + "String_Node_Str");
    CargoManager cargo_thread = new CargoManager();
    cargo_thread.start();
    Thread visualizatorThread = new Visualizator();
    visualizatorThread.start();
    while (true) {
        try {
            Country.getInstance().wait();
        } catch (InterruptedException e) {
            System.out.println("String_Node_Str");
        }
    }
}

Output:
     visualizatorThread.start();
-    while (true) {
-        try {
-            Country.getInstance().wait();
-        } catch (InterruptedException e) {
-            System.out.println("String_Node_Str");
-        }
-    }
+    System.out.println("String_Node_Str");
 }


Input:
public Object executeList(String serviceEndpoint, Class _class, String entityName) throws CommandException {
    DefaultHttpClient httpClient = new DefaultHttpClient();
    HttpResponse response = null;
    try {
        response = restClient.doGet(httpClient, restClient.getBaseURL() + serviceEndpoint);
        int responseCode = response.getStatusLine().getStatusCode();
        if (responseCode != 200) {
            String resultString = getHttpResponseString(response);
            if (StringUtils.isBlank(resultString)) {
                return null;
            } else {
                GsonBuilder gsonBuilder = new GsonBuilder();
                Gson gson = gsonBuilder.create();
                ExceptionMapper exception = gson.fromJson(resultString, ExceptionMapper.class);
                if (exception != null) {
                    System.out.println(exception);
                }
                return gson.fromJson(resultString, _class);
            }
        }
        return null;
    } catch (Exception e) {
        handleException(String.format("String_Node_Str", entityName), e);
        return null;
    } finally {
        httpClient.getConnectionManager().shutdown();
    }
}

Output:
         int responseCode = response.getStatusLine().getStatusCode();
-        if (responseCode != 200) {
-            String resultString = getHttpResponseString(response);
+        String resultString = getHttpResponseString(response);
+        GsonBuilder gsonBuilder = new GsonBuilder();
+        Gson gson = gsonBuilder.create();
+        if (responseCode == 200) {
+            return gson.fromJson(resultString, _class);
+        } else {
             if (StringUtils.isBlank(resultString)) {


Input:
public void insert(Connection connection, Collection<T> values, RowHandler<PreparedStatement> postExecute) throws SQLException {
    int lBatchSize = Math.min(batchSize.get(), values.size());
    try {
        if (values.size() <= lBatchSize) {
            delegate.insert(connection, values, postExecute);
        } else {
            splitBatches(connection, values, lBatchSize, postExecute);
        }
    } catch (PacketTooBigException e) {
        if (lBatchSize <= 2) {
            throw e;
        }
        resize(lBatchSize);
        insert(connection, values, postExecute);
    }
}

Output:
         }
-        resize(lBatchSize);
+        resize(lBatchSize / 2);
         insert(connection, values, postExecute);


Input:
public void createControl(Composite parent) {
    Composite container = new Composite(parent, SWT.NULL);
    setControl(container);
    container.setLayout(new GridLayout(3, false));
    lblLocation = new Label(container, SWT.NONE);
    lblLocation.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
    lblLocation.setText("String_Node_Str");
    comboLocation = new Combo(container, SWT.READ_ONLY);
    comboLocation.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
    comboLocation.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent arg0) {
            lblSeparator.setVisible(true);
            comboSeparator.setVisible(true);
            lblDelimiter.setVisible(true);
            comboDelimiter.setVisible(true);
            lblLinebreak.setVisible(true);
            comboLinebreak.setVisible(true);
            lblEscape.setVisible(true);
            comboEscape.setVisible(true);
            btnContainsHeader.setVisible(true);
            customSeparator = false;
            evaluatePage();
        }
    });
    btnChoose = new Button(container, SWT.NONE);
    btnChoose.setText("String_Node_Str");
    btnChoose.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent arg0) {
            final String path = wizardImport.getController().actionShowOpenFileDialog(getShell(), "String_Node_Str");
            if (path == null) {
                return;
            }
            if (comboLocation.indexOf(path) == -1) {
                comboLocation.add(path, 0);
            }
            comboLocation.select(comboLocation.indexOf(path));
            comboLocation.notifyListeners(SWT.Selection, null);
        }
    });
    lblSeparator = new Label(container, SWT.NONE);
    lblSeparator.setVisible(false);
    lblSeparator.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
    lblSeparator.setText("String_Node_Str");
    comboSeparator = new Combo(container, SWT.READ_ONLY);
    comboSeparator.setVisible(false);
    for (final String s : labels) {
        comboSeparator.add(s);
    }
    comboSeparator.select(selectedSeparator);
    comboSeparator.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
    comboSeparator.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(final SelectionEvent arg0) {
            selectedSeparator = comboSeparator.getSelectionIndex();
            customSeparator = true;
            evaluatePage();
        }
    });
    new Label(container, SWT.NONE);
    lblDelimiter = new Label(container, SWT.NONE);
    lblDelimiter.setVisible(false);
    lblDelimiter.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
    lblDelimiter.setText("String_Node_Str");
    comboDelimiter = new Combo(container, SWT.READ_ONLY);
    comboDelimiter.setVisible(false);
    for (final char c : delimiters) {
        comboDelimiter.add(String.valueOf(c));
    }
    comboDelimiter.select(selectedDelimiter);
    comboDelimiter.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
    comboDelimiter.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(final SelectionEvent arg0) {
            selectedDelimiter = comboDelimiter.getSelectionIndex();
            evaluatePage();
        }
    });
    new Label(container, SWT.NONE);
    lblEscape = new Label(container, SWT.NONE);
    lblEscape.setVisible(false);
    lblEscape.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
    lblEscape.setText("String_Node_Str");
    comboEscape = new Combo(container, SWT.READ_ONLY);
    comboEscape.setVisible(false);
    for (final char c : escapes) {
        comboEscape.add(String.valueOf(c));
    }
    comboEscape.select(selectedEscape);
    comboEscape.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
    comboEscape.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(final SelectionEvent arg0) {
            selectedEscape = comboEscape.getSelectionIndex();
            evaluatePage();
        }
    });
    new Label(container, SWT.NONE);
    lblLinebreak = new Label(container, SWT.NONE);
    lblLinebreak.setVisible(false);
    lblLinebreak.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, false, false, 1, 1));
    lblLinebreak.setText("String_Node_Str");
    comboLinebreak = new Combo(container, SWT.READ_ONLY);
    comboLinebreak.setVisible(false);
    for (final String c : linebreaklabels) {
        comboLinebreak.add(String.valueOf(c));
    }
    comboLinebreak.select(selectedEscape);
    comboLinebreak.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
    comboLinebreak.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(final SelectionEvent arg0) {
            selectedEscape = comboLinebreak.getSelectionIndex();
            evaluatePage();
        }
    });
    new Label(container, SWT.NONE);
    new Label(container, SWT.NONE);
    btnContainsHeader = new Button(container, SWT.CHECK);
    btnContainsHeader.setVisible(false);
    btnContainsHeader.setText("String_Node_Str");
    btnContainsHeader.setSelection(true);
    btnContainsHeader.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent arg0) {
            evaluatePage();
        }
    });
    new Label(container, SWT.NONE);
    new Label(container, SWT.NONE);
    new Label(container, SWT.NONE);
    new Label(container, SWT.NONE);
    tableViewerPreview = new TableViewer(container, SWT.BORDER | SWT.FULL_SELECTION);
    tableViewerPreview.setContentProvider(new ArrayContentProvider());
    tablePreview = tableViewerPreview.getTable();
    GridData gd_tablePreview = new GridData(SWT.FILL, SWT.FILL, true, true, 3, 1);
    gd_tablePreview.heightHint = 150;
    tablePreview.setLayoutData(gd_tablePreview);
    tablePreview.setLinesVisible(true);
    tablePreview.setVisible(false);
    setPageComplete(false);
}

Output:
     }
-    comboLinebreak.select(selectedEscape);
+    comboLinebreak.select(selectedLinebreak);
     comboLinebreak.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));


Input:
private final void initFields(final byte[] data, final int begin, final int len) {
    try {
        int pos = begin + len - 2;
        int numFields = data[begin + len - 1] & 0xFF;
        if (numFields >= MAX_BIT) {
            int shift = 7;
            int curr;
            numFields = numFields & 0x7f;
            while ((curr = data[pos--]) >= MAX_BIT) {
                numFields |= (curr & 0x7f) << shift;
                shift += 7;
            }
            numFields |= curr << shift;
        }
        this.numFields = numFields;
        if (this.offsets == null || this.offsets.length < numFields) {
            this.offsets = new int[numFields];
        }
        if (this.lengths == null || this.lengths.length < numFields) {
            this.lengths = new int[numFields];
        }
        if (this.readFields == null || this.readFields.length < numFields) {
            this.readFields = new Value[numFields];
        }
        if (this.writeFields == null || this.writeFields.length < numFields) {
            this.writeFields = new Value[numFields];
        }
        final int beginMasks = pos;
        final int fieldsBy8 = (numFields >>> 3) + ((numFields & 0x7) == 0 ? 0 : 1);
        pos = beginMasks - fieldsBy8;
        int lastNonNullField = -1;
        for (int field = 0, chunk = 0; chunk < fieldsBy8; chunk++) {
            int mask = data[beginMasks - chunk];
            for (int i = 0; i < 8 && field < numFields; i++, field++) {
                if ((mask & 0x1) == 0x1) {
                    if (lastNonNullField >= 0) {
                        int start = data[pos--] & 0xff;
                        if (start >= MAX_BIT) {
                            int shift = 7;
                            int curr;
                            start = start & 0x7f;
                            while ((curr = data[pos--] & 0xff) >= MAX_BIT) {
                                start |= (curr & 0x7f) << shift;
                                shift += 7;
                            }
                            start |= curr << shift;
                        }
                        this.offsets[field] = start + begin;
                        this.lengths[lastNonNullField] = start + begin - this.offsets[lastNonNullField];
                    } else {
                        this.offsets[field] = begin;
                    }
                    lastNonNullField = field;
                } else {
                    this.offsets[field] = NULL_INDICATOR_OFFSET;
                }
                mask >>= 1;
            }
        }
        if (lastNonNullField >= 0) {
            this.lengths[lastNonNullField] = pos - this.offsets[lastNonNullField] + 1;
        }
        this.firstModifiedPos = Integer.MAX_VALUE;
    } catch (ArrayIndexOutOfBoundsException aioobex) {
        StringBuilder bld = new StringBuilder(len * 4 + 64);
        bld.append("String_Node_Str");
        for (int i = 0; i < len; i++) {
            int num = data[i + begin] & 0xff;
            bld.append(num);
            if (i < len - 1) {
                bld.append(',');
            }
        }
        throw new RuntimeException(bld.toString(), aioobex);
    }
}

Output:
             numFields = numFields & 0x7f;
-            while ((curr = data[pos--]) >= MAX_BIT) {
+            while ((curr = data[pos--] & 0xff) >= MAX_BIT) {
                 numFields |= (curr & 0x7f) << shift;


Input:
public void initialize(DownloadManager manager, FileManager fileManager, DownloadCallback callback) {
    this.manager = manager;
    this.fileManager = fileManager;
    this.callback = callback;
    currentRFDs = new HashSet();
    _activeWorkers = new LinkedList();
    _workers = new ArrayList();
    queuedWorkers = new HashMap();
    chatList = new DownloadChatList();
    browseList = new DownloadBrowseHostList();
    stealLock = new Object();
    stopped = false;
    paused = false;
    setState(QUEUED);
    miniRFDToLock = Collections.synchronizedMap(new HashMap());
    corruptState = NOT_CORRUPT_STATE;
    corruptStateLock = new Object();
    altLock = new Object();
    numMeasures = 0;
    averageBandwidth = 0f;
    queuePosition = Integer.MAX_VALUE;
    queuedVendor = "String_Node_Str";
    triedLocatingSources = false;
    ranker = getSourceRanker(null);
    ranker.setMeshHandler(this);
    if (cachedRFDs.size() > 0 && downloadSHA1 == null) {
        for (Iterator iter = cachedRFDs.iterator(); iter.hasNext() && downloadSHA1 == null; ) {
            RemoteFileDesc rfd = (RemoteFileDesc) iter.next();
            downloadSHA1 = rfd.getSHA1Urn();
            RouterService.getAltlocManager().addListener(downloadSHA1, this);
        }
    }
    verifyAllFiles();
    validAlts = new HashSet();
    invalidAlts = new FixedSizeExpiringSet(1000, 60 * 60 * 1000L);
    recentInvalidAlts = new FixedSizeExpiringSet(10, 10 * 60 * 1000L);
    synchronized (this) {
        if (shouldInitAltLocs(deserializedFromDisk)) {
            initializeAlternateLocations();
        }
    }
    try {
        initializeIncompleteFile();
        initializeVerifyingFile();
    } catch (IOException bad) {
        setState(DISK_PROBLEM);
        return;
    }
    setState(QUEUED);
}

Output:
     ranker.setMeshHandler(this);
-    if (cachedRFDs.size() > 0 && downloadSHA1 == null) {
-        for (Iterator iter = cachedRFDs.iterator(); iter.hasNext() && downloadSHA1 == null; ) {
-            RemoteFileDesc rfd = (RemoteFileDesc) iter.next();
-            downloadSHA1 = rfd.getSHA1Urn();
-            RouterService.getAltlocManager().addListener(downloadSHA1, this);
-        }
+    if (downloadSHA1 == null)
+        downloadSHA1 = (URN) propertiesMap.get(SHA1_URN);
+    for (Iterator iter = cachedRFDs.iterator(); iter.hasNext() && downloadSHA1 == null; ) {
+        RemoteFileDesc rfd = (RemoteFileDesc) iter.next();
+        downloadSHA1 = rfd.getSHA1Urn();
+        RouterService.getAltlocManager().addListener(downloadSHA1, this);
     }


Input:
public Action getAction(Brain brain) {
    return getGoals().attack(brain.getTargetingSystem().getCurrentTarget());
}

Output:
 public Action getAction(Brain brain) {
-    return getGoals().attack(brain.getTargetingSystem().getCurrentTarget());
+    return getGoals().enemyEncountered(getGoals(), brain);
 }


Input:
public static Object getPrivateField(Object owner, String fieldName) {
    Object fieldValue = null;
    Class ownerClass = owner.getClass();
    try {
        Field f = ownerClass.getDeclaredField(fieldName);
        f.setAccessible(true);
        fieldValue = f.get(owner);
    } catch (Exception e) {
        log.error("String_Node_Str", e);
    }
    return fieldValue;
}

Output:
     Class ownerClass = owner.getClass();
-    try {
-        Field f = ownerClass.getDeclaredField(fieldName);
-        f.setAccessible(true);
-        fieldValue = f.get(owner);
-    } catch (Exception e) {
-        log.error("String_Node_Str", e);
-    }
+    Field f = ownerClass.getDeclaredField(fieldName);
+    f.setAccessible(true);
+    fieldValue = f.get(owner);
     return fieldValue;


Input:
public static GiraphMasterScenarioWrapper readMasterScenarioFromTrace(String jobId, long superstepNo, DebugTrace debugTrace) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
    if (!EnumSet.of(DebugTrace.MASTER_ALL, DebugTrace.MASTER_EXCEPTION, DebugTrace.MASTER_REGULAR).contains(debugTrace)) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    FileSystem fs = ServerUtils.getFileSystem();
    GiraphMasterScenarioWrapper giraphScenarioWrapper = new GiraphMasterScenarioWrapper();
    if (debugTrace == DebugTrace.MASTER_REGULAR || debugTrace == DebugTrace.MASTER_ALL) {
        String traceFilePath = ServerUtils.getMasterTraceFilePath(jobId, superstepNo, DebugTrace.MASTER_REGULAR);
        try {
            giraphScenarioWrapper.loadFromHDFS(fs, traceFilePath);
            return giraphScenarioWrapper;
        } catch (FileNotFoundException e) {
            if (debugTrace == DebugTrace.MASTER_ALL) {
                Debug.println("String_Node_Str", "String_Node_Str");
            } else {
                throw e;
            }
        }
    }
    String traceFilePath = ServerUtils.getMasterTraceFilePath(jobId, superstepNo, DebugTrace.MASTER_EXCEPTION);
    giraphScenarioWrapper.loadFromHDFS(fs, traceFilePath);
    return giraphScenarioWrapper;
}

Output:
         try {
-            giraphScenarioWrapper.loadFromHDFS(fs, traceFilePath);
+            giraphScenarioWrapper.loadFromHDFS(fs, traceFilePath, getCachedJobJarPath(jobId));
             return giraphScenarioWrapper;


Input:
public Object readFrom(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
    try {
        if (null == genericType) {
            genericType = type;
        }
        Class<?> domainClass = getDomainClass(genericType);
        JAXBContext jaxbContext = getJAXBContext(domainClass, annotations, mediaType, httpHeaders);
        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
        unmarshaller.setProperty(UnmarshallerProperties.MEDIA_TYPE, MediaType.APPLICATION_JSON);
        unmarshaller.setProperty(UnmarshallerProperties.JSON_ATTRIBUTE_PREFIX, attributePrefix);
        unmarshaller.setProperty(UnmarshallerProperties.JSON_INCLUDE_ROOT, includeRoot);
        unmarshaller.setProperty(UnmarshallerProperties.JSON_NAMESPACE_PREFIX_MAPPER, namespacePrefixMapper);
        unmarshaller.setProperty(UnmarshallerProperties.JSON_NAMESPACE_SEPARATOR, namespaceSeperator);
        if (null != valueWrapper) {
            unmarshaller.setProperty(UnmarshallerProperties.JSON_VALUE_WRAPPER, valueWrapper);
        }
        unmarshaller.setProperty(UnmarshallerProperties.JSON_WRAPPER_AS_ARRAY_NAME, wrapperAsArrayName);
        preReadFrom(type, genericType, annotations, mediaType, httpHeaders, unmarshaller);
        StreamSource jsonSource;
        Map<String, String> mediaTypeParameters = mediaType.getParameters();
        if (mediaTypeParameters.containsKey(CHARSET)) {
            String charSet = mediaTypeParameters.get(CHARSET);
            Reader entityReader = new InputStreamReader(entityStream, charSet);
            jsonSource = new StreamSource(entityReader);
        } else {
            jsonSource = new StreamSource(entityStream);
        }
        JAXBElement<?> jaxbElement = unmarshaller.unmarshal(jsonSource, domainClass);
        if (type.isAssignableFrom(JAXBElement.class)) {
            return jaxbElement;
        } else {
            Object value = jaxbElement.getValue();
            if (value instanceof ArrayList) {
                if (type.isArray()) {
                    ArrayList<JAXBElement> arrayList = (ArrayList<JAXBElement>) value;
                    int arrayListSize = arrayList.size();
                    Object array;
                    if (genericType instanceof GenericArrayType) {
                        array = Array.newInstance(JAXBElement.class, arrayListSize);
                        for (int x = 0; x < arrayListSize; x++) {
                            Array.set(array, x, arrayList.get(x));
                        }
                    } else {
                        array = Array.newInstance(domainClass, arrayListSize);
                        for (int x = 0; x < arrayListSize; x++) {
                            Array.set(array, x, arrayList.get(x).getValue());
                        }
                    }
                    return array;
                } else {
                    ContainerPolicy containerPolicy;
                    if (type.isAssignableFrom(List.class) || type.isAssignableFrom(ArrayList.class) || type.isAssignableFrom(Collection.class)) {
                        containerPolicy = new CollectionContainerPolicy(ArrayList.class);
                    } else if (type.isAssignableFrom(Set.class)) {
                        containerPolicy = new CollectionContainerPolicy(HashSet.class);
                    } else if (type.isAssignableFrom(Deque.class) || type.isAssignableFrom(Queue.class)) {
                        containerPolicy = new CollectionContainerPolicy(LinkedList.class);
                    } else if (type.isAssignableFrom(NavigableSet.class) || type.isAssignableFrom(SortedSet.class)) {
                        containerPolicy = new CollectionContainerPolicy(TreeSet.class);
                    } else {
                        containerPolicy = new CollectionContainerPolicy(type);
                    }
                    Object container = containerPolicy.containerInstance();
                    boolean wrapItemInJAXBElement = false;
                    if (genericType instanceof ParameterizedType) {
                        Type actualType = ((ParameterizedType) genericType).getActualTypeArguments()[0];
                        if (actualType instanceof ParameterizedType) {
                            Type rawType = ((ParameterizedType) actualType).getRawType();
                            wrapItemInJAXBElement = rawType == JAXBElement.class;
                        }
                    }
                    for (Object element : (Collection<Object>) value) {
                        if (wrapItemInJAXBElement) {
                            if (!(element instanceof JAXBElement)) {
                                element = new JAXBElement(new QName("String_Node_Str"), domainClass, element);
                            }
                            containerPolicy.addInto(element, container, null);
                        } else {
                            containerPolicy.addInto(JAXBIntrospector.getValue(element), container, null);
                        }
                    }
                    return container;
                }
            } else {
                return value;
            }
        }
    } catch (UnmarshalException unmarshalException) {
        ResponseBuilder builder = Response.status(Status.BAD_REQUEST);
        throw new WebApplicationException(builder.build());
    } catch (JAXBException jaxbException) {
        throw new WebApplicationException(jaxbException);
    }
}

Output:
         StreamSource jsonSource;
-        Map<String, String> mediaTypeParameters = mediaType.getParameters();
-        if (mediaTypeParameters.containsKey(CHARSET)) {
+        Map<String, String> mediaTypeParameters = null;
+        if (null != mediaType) {
+            mediaTypeParameters = mediaType.getParameters();
+        }
+        if (null != mediaTypeParameters && mediaTypeParameters.containsKey(CHARSET)) {
             String charSet = mediaTypeParameters.get(CHARSET);


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

Output:
 private void handleSpecialCharacterAndMissingValues() {
-    if (isChecked && this.getMapForFreq().size() < 1) {
+    if (isChecked && this.valueToFreq.size() < 1) {
         return;


Input:
private void doRemove() {
    StructuredSelection selection = (StructuredSelection) listViewer.getSelection();
    if (selection.isEmpty()) {
        return;
    }
    FunctionEntity entity = (FunctionEntity) selection.getFirstElement();
    entityList.remove(entity);
    listViewer.setInput(entityList);
    ResourcesPlugin.getPlugin().getPluginPreferences().setValue(entity.getLanguage(), "String_Node_Str");
}

Output:
 private void doRemove() {
-    StructuredSelection selection = (StructuredSelection) listViewer.getSelection();
+    StructuredSelection selection = (StructuredSelection) tableViewer.getSelection();
     if (selection.isEmpty()) {


Input:
void showDesc(final View view, int index, final UnicodeAdapter ua) {
    PagerTabStrip tab = new PagerTabStrip(activity);
    tab.setId(0x3EFFFFFF);
    ViewPager.LayoutParams layoutParams = new ViewPager.LayoutParams();
    layoutParams.height = LayoutParams.WRAP_CONTENT;
    layoutParams.width = LayoutParams.MATCH_PARENT;
    layoutParams.gravity = Gravity.TOP;
    final ViewPager pager = new ViewPager(activity);
    pager.addView(tab, layoutParams);
    final CharacterAdapter adapter = new CharacterAdapter(activity, ua, tf, db, afav);
    pager.setAdapter(adapter);
    pager.setCurrentItem(index, false);
    pager.setLayoutParams(new LinearLayout.LayoutParams(LayoutParams.MATCH_PARENT, (int) (activity.getResources().getDisplayMetrics().scaledDensity * (CharacterAdapter.fontsize * 1.8f + new TextAppearanceSpan(activity, android.R.style.TextAppearance_Small).getTextSize() * 2.4f + 32.f))));
    LinearLayout layout = new LinearLayout(activity);
    layout.addView(pager);
    AlertDialog.Builder builder = new AlertDialog.Builder(activity).setView(layout);
    if (view != null)
        builder.setPositiveButton(R.string.input, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                if (adapter.getId() != -1) {
                    arec.add((int) adapter.getId());
                    if (recpage != -1 && page != recpage && grids[recpage] != null)
                        grids[recpage].invalidateViews();
                }
                int start = edit.getSelectionStart();
                int end = edit.getSelectionEnd();
                if (start == -1)
                    return;
                edit.getEditableText().replace(Math.min(start, end), Math.max(start, end), (String) ua.getItem(adapter.getIndex()));
            }
        });
    if (!(view instanceof GridView) || ((GridView) view).getAdapter() != aemoji)
        builder.setNeutralButton(R.string.inlist, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                find((int) adapter.getId());
            }
        });
    if (view instanceof GridView && ((GridView) view).getAdapter() == arec)
        builder.setNegativeButton(R.string.remrec, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                arec.remove((int) adapter.getId());
                if (grids[recpage] != null)
                    grids[recpage].invalidateViews();
            }
        });
    if (view instanceof GridView && ((GridView) view).getAdapter() == aedt)
        builder.setNegativeButton(R.string.delete, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                int i = pager.getCurrentItem();
                String s = edit.getEditableText().toString();
                edit.getEditableText().delete(s.offsetByCodePoints(0, i), s.offsetByCodePoints(0, i + 1));
            }
        });
    if (view instanceof GridView && ((GridView) view).getAdapter() == alist)
        builder.setNegativeButton(R.string.mark, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                final EditText edit = new EditText(activity);
                new AlertDialog.Builder(activity).setTitle(R.string.mark).setView(edit).setPositiveButton(R.string.mark, new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface arg0, int arg1) {
                        alist.mark((int) adapter.getId(), edit.getText().toString());
                    }
                }).create().show();
            }
        });
    if (dlg != null && dlg.isShowing())
        dlg.dismiss();
    dlg = builder.create();
    dlg.show();
}

Output:
     PagerTabStrip tab = new PagerTabStrip(activity);
-    tab.setId(0x3EFFFFFF);
+    tab.setId(R.id.TAB_ID);
     ViewPager.LayoutParams layoutParams = new ViewPager.LayoutParams();


Input:
protected APIResponse.CODE doInBackground(String... params) {
    eventKey = params[0];
    View view = mFragment.getView();
    if (view != null && activity != null && eventKey != null) {
        eventName = (TextView) view.findViewById(R.id.event_name);
        eventDate = (TextView) view.findViewById(R.id.event_date);
        eventLoc = (TextView) view.findViewById(R.id.event_location);
        nextLayout = (LinearLayout) view.findViewById(R.id.event_next_match_container);
        lastLayout = (LinearLayout) view.findViewById(R.id.event_last_match_container);
        topTeams = (LinearLayout) view.findViewById(R.id.event_top_teams_container);
        topOpr = (LinearLayout) view.findViewById(R.id.top_opr_container);
        LayoutInflater inflater = (LayoutInflater) activity.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
        try {
            APIResponse<Event> response = DataManager.getEvent(activity, eventKey);
            event = response.getData();
        } catch (DataManager.NoDataException e) {
            Log.w(Constants.LOG_TAG, "String_Node_Str");
            return APIResponse.CODE.NODATA;
        }
        if (event.hasStarted()) {
            showRanks = showStats = true;
            ranks = new TextView(activity);
            try {
                APIResponse<ArrayList<JsonArray>> rankResponse = DataManager.getEventRankings(activity, eventKey);
                ArrayList<JsonArray> rankList = rankResponse.getData();
                String rankString = "String_Node_Str";
                if (rankList.size() == 0) {
                    showRanks = false;
                }
                for (int i = 1; i < Math.min(6, rankList.size()); i++) {
                    rankString += ((i) + "String_Node_Str" + rankList.get(i).get(1).getAsString()) + "String_Node_Str";
                }
                ranks.setText(rankString);
            } catch (DataManager.NoDataException e) {
                Log.w(Constants.LOG_TAG, "String_Node_Str");
                showRanks = false;
                return APIResponse.CODE.NODATA;
            }
            stats = new TextView(activity);
            try {
                APIResponse<JsonObject> statsResponse = DataManager.getEventStats(activity, eventKey);
                ArrayList<Map.Entry<String, JsonElement>> opr = new ArrayList<>();
                if (statsResponse.getData().has("String_Node_Str") && !statsResponse.getData().get("String_Node_Str").getAsJsonObject().entrySet().isEmpty()) {
                    opr.addAll(statsResponse.getData().get("String_Node_Str").getAsJsonObject().entrySet());
                    Collections.sort(opr, new TeamSortByOPRComparator());
                    Collections.reverse(opr);
                    String statsString = "String_Node_Str";
                    for (int i = 0; i < Math.min(5, opr.size()); i++) {
                        statsString += ((i + 1) + "String_Node_Str" + opr.get(i).getKey() + "String_Node_Str");
                    }
                    stats.setText(statsString);
                } else {
                    showStats = false;
                }
            } catch (DataManager.NoDataException e) {
                Log.w(Constants.LOG_TAG, "String_Node_Str");
                showStats = false;
                return APIResponse.CODE.NODATA;
            }
        }
        if (event.isHappeningNow()) {
            try {
                APIResponse<ArrayList<Match>> matchResult = DataManager.getMatchList(activity, eventKey);
                ArrayList<Match> matches = matchResult.getData();
                Collections.sort(matches, new MatchSortByPlayOrderComparator());
                Match nextMatch = Match.getNextMatchPlayed(matches);
                Match lastMatch = Match.getLastMatchPlayed(matches);
                if (nextMatch != null) {
                    showNextMatch = true;
                    next = nextMatch.render().getView(activity, inflater, null);
                }
                if (lastMatch != null) {
                    showLastMatch = true;
                    last = lastMatch.render().getView(activity, inflater, null);
                }
            } catch (DataManager.NoDataException e) {
                Log.w(Constants.LOG_TAG, "String_Node_Str");
                return APIResponse.CODE.NODATA;
            }
        }
        view.findViewById(R.id.event_location_container).setTag("String_Node_Str" + event.getLocation().replace("String_Node_Str", "String_Node_Str"));
        view.findViewById(R.id.event_website_button).setTag(!event.getWebsite().isEmpty() ? event.getWebsite() : "String_Node_Str" + event.getEventName());
        view.findViewById(R.id.event_twitter_button).setTag("String_Node_Str" + event.getEventKey());
        view.findViewById(R.id.event_youtube_button).setTag("String_Node_Str" + event.getEventKey());
        view.findViewById(R.id.event_cd_button).setTag("String_Node_Str" + event.getEventKey());
    }
    return APIResponse.CODE.NODATA;
}

Output:
                 String rankString = "String_Node_Str";
-                if (rankList.size() == 0) {
+                if (rankList.isEmpty() || rankList.size() == 1) {
                     showRanks = false;


Input:
public void visit(NodeTraversal t, Node n, Node parent) {
    if (n.isName() && n.getString().equals(varName) && !(parent.isAssign() && (parent.getFirstChild() == n))) {
        numUseWithinUseCfgNode++;
    }
}

Output:
 public void visit(NodeTraversal t, Node n, Node parent) {
-    if (n.isName() && n.getString().equals(varName) && !(parent.isAssign() && (parent.getFirstChild() == n))) {
-        numUseWithinUseCfgNode++;
+    if (n.isName() && n.getString().equals(varName)) {
+        if (parent.isAssign() && (parent.getFirstChild() == n) && isAssignChain(parent, cfgNode)) {
+            return;
+        } else {
+            numUsesWithinCfgNode++;
+        }
     }


Input:
public dLocation getLocation() {
    if (isUnique() && entity != null) {
        return new dLocation(entity.getLocation());
    }
    return null;
}

Output:
 public dLocation getLocation() {
-    if (isUnique() && entity != null) {
+    if (entity != null) {
         return new dLocation(entity.getLocation());


Input:
protected void createAutServerClasspath(StringBuffer autServerClasspath, List cmds, Map parameters) {
    if (AutStarter.getInstance().getAutCommunicator() != null) {
        cmds.add(String.valueOf(AutStarter.getInstance().getAutCommunicator().getLocalPort()));
    } else {
        cmds.add("String_Node_Str");
    }
    String autMain = getAUTMainClass(parameters);
    if (autMain == null) {
        return;
    }
    cmds.add(autMain);
    autServerClasspath.append(PATH_SEPARATOR).append(getRcBundleClassPath());
    cmds.add(autServerClasspath.toString());
    cmds.add(getServerClassName());
}

Output:
 protected void createAutServerClasspath(StringBuffer autServerClasspath, List cmds, Map parameters) {
-    if (AutStarter.getInstance().getAutCommunicator() != null) {
-        cmds.add(String.valueOf(AutStarter.getInstance().getAutCommunicator().getLocalPort()));
+    final Communicator autCommunicator = AutStarter.getInstance().getAutCommunicator();
+    if (autCommunicator != null) {
+        cmds.add(String.valueOf(autCommunicator.getLocalPort()));
     } else {


Input:
private String runServerCommand(String commandSpecifics) throws Exception {
    String portNumber = Integer.toString(getTestConfiguration().getPort());
    StringBuffer buffer = new StringBuffer();
    String classpath = getSystemProperty("String_Node_Str");
    buffer.append("String_Node_Str");
    buffer.append(classpath);
    buffer.append("String_Node_Str");
    buffer.append("String_Node_Str" + portNumber + "String_Node_Str" + commandSpecifics);
    final String command = buffer.toString();
    println("String_Node_Str" + command);
    Process serverProcess = (Process) AccessController.doPrivileged(new PrivilegedAction() {
        public Object run() {
            Process result = null;
            try {
                result = Runtime.getRuntime().exec(command);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            return result;
        }
    });
    InputStream is = serverProcess.getInputStream();
    return getProcessOutput(is, 10000);
}

Output:
     });
-    InputStream is = serverProcess.getInputStream();
-    return getProcessOutput(is, 10000);
+    SpawnedProcess spawned = new SpawnedProcess(serverProcess, commandSpecifics);
+    assertEquals(0, spawned.complete(false));
+    return spawned.getFullServerOutput();
 }


Input:
public void refresh(IElementParameter param, boolean check) {
    String paramName = param.getName();
    boolean isPatternList = StringUtils.equals(paramName, "String_Node_Str");
    boolean isRule = StringUtils.equals(paramName, "String_Node_Str");
    CCombo combo = (CCombo) hashCurControls.get(paramName);
    if (combo == null || combo.isDisposed()) {
        return;
    }
    if (isPatternList) {
        ITDQPatternService service = null;
        try {
            service = (ITDQPatternService) GlobalServiceRegister.getDefault().getService(ITDQPatternService.class);
        } catch (RuntimeException e) {
        }
        if (service != null && elem instanceof Node) {
            Node node = (Node) elem;
            IElementParameter typeParam = node.getElementParameter("String_Node_Str");
            service.overridePatternList(typeParam, param);
        }
    }
    if (isRule) {
        ITDQRuleService rulerService = null;
        try {
            rulerService = (ITDQRuleService) GlobalServiceRegister.getDefault().getService(ITDQRuleService.class);
        } catch (RuntimeException e) {
        }
        if (rulerService != null && elem instanceof Node) {
            Node node = (Node) elem;
            IElementParameter typeParam = node.getElementParameter("String_Node_Str");
            IElementParameter dbParam = node.getElementParameter(EParameterName.DBNAME.getName());
            IElementParameter schemaParam = node.getElementParameter(EParameterName.SCHEMA_DB.getName());
            IElementParameter tableParam = node.getElementParameterFromField(EParameterFieldType.DBTABLE);
            rulerService.overrideRuleList(typeParam, dbParam, schemaParam, tableParam, param);
        }
    }
    Object value = param.getValue();
    if (value instanceof String) {
        String strValue = "String_Node_Str";
        int nbInList = 0, nbMax = param.getListItemsValue().length;
        String name = (String) value;
        while (strValue.equals(new String("String_Node_Str")) && nbInList < nbMax) {
            if (name.equals(param.getListItemsValue()[nbInList])) {
                strValue = param.getListItemsDisplayName()[nbInList];
            }
            nbInList++;
        }
        String[] paramItems = getListToDisplay(param);
        String[] comboItems = combo.getItems();
        if (!Arrays.equals(paramItems, comboItems)) {
            combo.setItems(paramItems);
        }
        if (isPatternList || isRule) {
            combo.setText("String_Node_Str".equals(strValue) ? (String) value : strValue);
        } else {
            combo.setText(strValue);
        }
        combo.setVisible(true);
    }
    if (param.isContextMode()) {
        combo.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_YELLOW));
        combo.setEnabled(false);
    }
}

Output:
             IElementParameter schemaParam = node.getElementParameter(EParameterName.SCHEMA_DB.getName());
-            IElementParameter tableParam = node.getElementParameterFromField(EParameterFieldType.DBTABLE);
-            rulerService.overrideRuleList(typeParam, dbParam, schemaParam, tableParam, param);
+            IElementParameter tableParam = node.getElementParameter(EParameterName.TABLE.getName());
+            List<IMetadataTable> metadataList = node.getMetadataList();
+            IMetadataTable metadataTable = null;
+            if (metadataList != null && !metadataList.isEmpty()) {
+                metadataTable = metadataList.get(0);
+            }
+            rulerService.overrideRuleList(typeParam, dbParam, schemaParam, tableParam, metadataTable, param);
         }


Input:
public static void main(final String[] args) {
    try {
        splash = new Splash();
        splash.setVisible(true);
        System.setProperty("String_Node_Str", "String_Node_Str");
        MainWindow main = new MainWindow();
        main.addShellListener(new ShellAdapter() {
            public void shellActivated(ShellEvent arg0) {
                hideSplash();
            }
        });
        main.show();
    } catch (Throwable e) {
        if (splash != null) {
            hideSplash();
        }
        JOptionPane.showMessageDialog(null, e.getMessage(), "String_Node_Str", JOptionPane.ERROR_MESSAGE);
        System.exit(1);
    }
}

Output:
         }
-        JOptionPane.showMessageDialog(null, e.getMessage(), "String_Node_Str", JOptionPane.ERROR_MESSAGE);
+        StringWriter sw = new StringWriter();
+        PrintWriter pw = new PrintWriter(sw);
+        e.printStackTrace(pw);
+        final String trace = sw.toString();
+        JOptionPane.showMessageDialog(null, trace, "String_Node_Str", JOptionPane.ERROR_MESSAGE);
         System.exit(1);


Input:
private void initSphinxProperties() throws IOException {
    sampleRate = (float) getIntAcousticProperty(FrontEnd.PROP_SAMPLE_RATE, 8000);
    SphinxProperties properties = getSphinxProperties();
    frameSizeInBytes = properties.getInt(FrontEnd.PROP_BYTES_PER_AUDIO_FRAME, 4096);
    if (frameSizeInBytes % 2 == 1) {
        frameSizeInBytes++;
    }
    keepAudioReference = properties.getBoolean(FrontEnd.PROP_KEEP_AUDIO_REFERENCE, true);
}

Output:
 private void initSphinxProperties() throws IOException {
-    sampleRate = (float) getIntAcousticProperty(FrontEnd.PROP_SAMPLE_RATE, 8000);
+    sampleRate = getIntAcousticProperty(FrontEnd.PROP_SAMPLE_RATE, 16000);
     SphinxProperties properties = getSphinxProperties();


Input:
public void handleFree(DownloadLink downloadLink) throws Exception {
    requestFileInformation(downloadLink);
    br.submitForm(br.getForm(1));
    String link = br.getRegex(Pattern.compile("String_Node_Str")).getMatch(0);
    downloadLink.setFinalFileName(downloadLink.toString());
    dl = jd.plugins.BrowserAdapter.openDownload(br, downloadLink, link);
    dl.startDownload();
}

Output:
     requestFileInformation(downloadLink);
-    br.submitForm(br.getForm(1));
+    Form DLForm = br.getForm(1);
+    if (DLForm == null)
+        throw new PluginException(LinkStatus.ERROR_PLUGIN_DEFEKT);
+    br.submitForm(DLForm);
     String link = br.getRegex(Pattern.compile("String_Node_Str")).getMatch(0);


Input:
public void watch(GameEvent event, Game game) {
    if (event.getType() == GameEvent.EventType.COUNTER_ADDED && event.getData().equals(CounterType.P1P1.getName())) {
        Permanent permanent = game.getPermanentOrLKIBattlefield(event.getTargetId());
        if (permanent != null && permanent.getCardType().contains(CardType.CREATURE)) {
            players.add(permanent.getControllerId());
        }
    }
}

Output:
         Permanent permanent = game.getPermanentOrLKIBattlefield(event.getTargetId());
-        if (permanent != null && permanent.getCardType().contains(CardType.CREATURE)) {
+        if (permanent != null) {
             players.add(permanent.getControllerId());


Input:
private void buildReadContentValues() {
    if (mReadContentValues == null) {
        mReadContentValues = new ContentValues(1);
        mReadContentValues.put("String_Node_Str", 1);
    }
}

Output:
     if (mReadContentValues == null) {
-        mReadContentValues = new ContentValues(1);
+        mReadContentValues = new ContentValues(2);
+        mReadContentValues.put("String_Node_Str", 1);
         mReadContentValues.put("String_Node_Str", 1);


Input:
public String generateMainLoop() throws IllegalActionException {
    StringBuffer code = new StringBuffer(_eol + getCodeGenerator().getMethodVisibiliyString() + "String_Node_Str" + getCodeGenerator().getMethodExceptionString() + "String_Node_Str" + _eol);
    Attribute iterations = _director.getAttribute("String_Node_Str");
    if (iterations == null) {
        code.append(_eol + "String_Node_Str" + _eol);
    } else {
        int iterationCount = ((IntToken) ((Variable) iterations).getToken()).intValue();
        if (iterationCount <= 0) {
            code.append(_eol + "String_Node_Str" + _eol);
        } else {
            code.append(_eol + "String_Node_Str" + _eol);
            code.append("String_Node_Str" + iterationCount + "String_Node_Str" + _eol);
        }
    }
    code.append("String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + _eol + getCodeGenerator().getMethodVisibiliyString() + "String_Node_Str" + getCodeGenerator().getMethodExceptionString() + "String_Node_Str" + _eol);
    code.append(generateFireCode());
    NamedProgramCodeGeneratorAdapter modelAdapter = (NamedProgramCodeGeneratorAdapter) getCodeGenerator().getAdapter(_director.getContainer());
    modelAdapter.generateModeTransitionCode(code);
    _generateUpdatePortOffsetCode(code, (Actor) _director.getContainer());
    code.append(generatePostfireCode());
    code.append("String_Node_Str" + _eol);
    Attribute period = _director.getAttribute("String_Node_Str");
    if (period != null) {
        Double periodValue = ((DoubleToken) ((Variable) period).getToken()).doubleValue();
        if (periodValue != 0.0) {
            code.append("String_Node_Str" + periodValue + "String_Node_Str" + _eol);
        }
    }
    code.append("String_Node_Str" + _eol + "String_Node_Str" + _eol);
    return code.toString();
}

Output:
     }
-    code.append("String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + _eol + getCodeGenerator().getMethodVisibiliyString() + "String_Node_Str" + getCodeGenerator().getMethodExceptionString() + "String_Node_Str" + _eol);
-    code.append(generateFireCode());
+    String[] splitFireCode = getCodeGenerator()._splitBody("String_Node_Str" + NamedProgramCodeGeneratorAdapter.generateName(getComponent()) + "String_Node_Str", generateFireCode());
+    code.append("String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + "String_Node_Str" + _eol + _eol + splitFireCode[0] + _eol + getCodeGenerator().getMethodVisibiliyString() + "String_Node_Str" + getCodeGenerator().getMethodExceptionString() + "String_Node_Str" + _eol + splitFireCode[1]);
     NamedProgramCodeGeneratorAdapter modelAdapter = (NamedProgramCodeGeneratorAdapter) getCodeGenerator().getAdapter(_director.getContainer());


Input:
public String getParseText() {
    return parseText;
}

Output:
 public String getParseText() {
-    return parseText;
+    final String nbsp = "String_Node_Str";
+    final Pattern p = Pattern.compile("String_Node_Str");
+    Matcher m = p.matcher(parseText);
+    int ptr = 0;
+    StringBuilder sb = null;
+    while (m.find()) {
+        if (sb == null)
+            sb = new StringBuilder();
+        int s = m.start();
+        int e = m.end();
+        sb.append(parseText.substring(ptr, s));
+        String mid = parseText.substring(s, e);
+        int mid_space = mid.indexOf("String_Node_Str");
+        sb.append(mid.substring(0, mid_space + 1));
+        sb.append(mid.substring(mid_space + 1).replaceAll("String_Node_Str", nbsp));
+        ptr = e;
+    }
+    if (sb == null)
+        return parseText;
+    else {
+        sb.append(parseText.substring(ptr));
+        return sb.toString();
+    }
 }


Input:
public Layer createLayer(ConfigurationItemKey pKey, String pName) throws UserNotFoundException, WorkspaceNotFoundException, AccessRightException, ConfigurationItemNotFoundException {
    User user = userManager.checkWorkspaceWriteAccess(pKey.getWorkspace());
    ConfigurationItem ci = new ConfigurationItemDAO(new Locale(user.getLanguage()), em).loadConfigurationItem(pKey);
    Layer layer = new Layer(pName, user, ci);
    Date now = new Date();
    layer.setCreationDate(now);
    new LayerDAO(new Locale(user.getLanguage()), em).createLayer(layer);
    return layer;
}

Output:
     ConfigurationItem ci = new ConfigurationItemDAO(new Locale(user.getLanguage()), em).loadConfigurationItem(pKey);
-    Layer layer = new Layer(pName, user, ci);
+    Layer layer = new Layer(pName, user, ci, color);
     Date now = new Date();


Input:
public boolean applies(Permanent permanent, Ability source, Game game) {
    if (filter.match(permanent, source.getSourceId(), source.getControllerId(), game)) {
        return true;
    }
    return false;
}

Output:
 public boolean applies(Permanent permanent, Ability source, Game game) {
-    if (filter.match(permanent, source.getSourceId(), source.getControllerId(), game)) {
-        return true;
+    for (FixedTarget fixedTarget : this.detainedObjects) {
+        UUID targetId = fixedTarget.getFirst(game, source);
+        if (targetId != null && targetId.equals(permanent.getId())) {
+            return true;
+        }
     }