Input:
boolean shouldAnimateMove() {
    return mContentChanged && !mExiting && !mWinAnimator.mLastHidden && mService.okToDisplay() && (mFrame.top != mLastFrame.top || mFrame.left != mLastFrame.left) && (mAttachedWindow == null || !mAttachedWindow.shouldAnimateMove());
}

Output:
 boolean shouldAnimateMove() {
-    return mContentChanged && !mExiting && !mWinAnimator.mLastHidden && mService.okToDisplay() && (mFrame.top != mLastFrame.top || mFrame.left != mLastFrame.left) && (mAttachedWindow == null || !mAttachedWindow.shouldAnimateMove());
+    return mContentChanged && !mExiting && !mWinAnimator.mLastHidden && mService.okToDisplay() && (mFrame.top != mLastFrame.top || mFrame.left != mLastFrame.left) && (mAttrs.privateFlags & PRIVATE_FLAG_NO_MOVE_ANIMATION) == 0 && (mAttachedWindow == null || !mAttachedWindow.shouldAnimateMove());
 }


Input:
public boolean skipFully(int length) throws IOException, InterruptedException {
    int remaining = length;
    while (remaining > 0) {
        if (Thread.interrupted()) {
            throw new InterruptedException();
        }
        int bytesRead = dataSource.read(SCRATCH_SPACE, 0, remaining);
        if (bytesRead == -1) {
            isEnded = true;
            return true;
        }
        remaining -= bytesRead;
    }
    position += length;
    return false;
}

Output:
         }
-        int bytesRead = dataSource.read(SCRATCH_SPACE, 0, remaining);
+        int bytesRead = dataSource.read(SCRATCH_SPACE, 0, Math.min(SCRATCH_SPACE.length, remaining));
         if (bytesRead == -1) {


Input:
private boolean hasSameNameContextParameters(String name) {
    boolean has = false;
    IContextManager contextManager = parentModel.getContextModelManager().getContextManager();
    IContext context = contextManager.getDefaultContext();
    if (context instanceof JobContext) {
        JobContext jobContext = (JobContext) context;
        int size = jobContext.getSameNameContextParameterSize(name);
        if (size > 1)
            has = true;
    }
    return has;
}

Output:
         int size = jobContext.getSameNameContextParameterSize(name);
-        if (size > 1)
+        if (size > 1) {
             has = true;


Input:
public void createMelFilter(double leftEdge, double centerFreq, double rightEdge, double initialFreq, double deltaFreq, int samplingRate) {
    double filterHeight;
    double leftSlope;
    double rightSlope;
    double currentFreq;
    int indexFilterWeight;
    int numberElementsWeightField;
    numberElementsWeightField = (int) Math.round((rightEdge - leftEdge) / deltaFreq + 1);
    weight = new double[numberElementsWeightField];
    filterHeight = 2.0f / (rightEdge - leftEdge);
    leftSlope = filterHeight / (centerFreq - leftEdge);
    rightSlope = filterHeight / (rightEdge - centerFreq);
    for (currentFreq = initialFreq, indexFilterWeight = 0; currentFreq <= rightEdge; currentFreq += deltaFreq, indexFilterWeight++) {
        if (currentFreq < centerFreq) {
            weight[indexFilterWeight] = leftSlope * (currentFreq - leftEdge);
        } else {
            weight[indexFilterWeight] = filterHeight + rightSlope * (currentFreq - centerFreq);
        }
    }
    this.initialFreqIndex = (int) Math.round(initialFreq / deltaFreq);
}

Output:
     leftSlope = filterHeight / (centerFreq - leftEdge);
-    rightSlope = filterHeight / (rightEdge - centerFreq);
+    rightSlope = filterHeight / (centerFreq - rightEdge);
     for (currentFreq = initialFreq, indexFilterWeight = 0; currentFreq <= rightEdge; currentFreq += deltaFreq, indexFilterWeight++) {


Input:
protected void recoverServices(final OperationContext context, final ModelNode operation, final ModelNode model) throws OperationFailedException {
    final PathAddress address = PathAddress.pathAddress(operation.get(OP_ADDR));
    final String name = address.getLastElement().getValue();
    final String deploymentOverlay = address.getElement(address.size() - 2).getValue();
    final Boolean regularExpression = DeploymentOverlayDeploymentDefinition.REGULAR_EXPRESSION.resolveModelAttribute(context, model).asBoolean();
    DeploymentOverlayDeploymentAdd.installServices(context, null, null, name, deploymentOverlay, regularExpression, priority);
}

Output:
     final String deploymentOverlay = address.getElement(address.size() - 2).getValue();
-    final Boolean regularExpression = DeploymentOverlayDeploymentDefinition.REGULAR_EXPRESSION.resolveModelAttribute(context, model).asBoolean();
-    DeploymentOverlayDeploymentAdd.installServices(context, null, null, name, deploymentOverlay, regularExpression, priority);
+    DeploymentOverlayDeploymentAdd.installServices(context, null, null, name, deploymentOverlay, priority);
 }


Input:
private List<Subnet> createDeviceSubnets(DiscoveredDeviceData discoveredDeviceData) {
    List<ObjectType> objList1 = discoveredDeviceData.getObject();
    List<Subnet> result = new ArrayList<Subnet>();
    for (ObjectType objectType1 : objList1) {
        String objectType = objectType1.getObjectType();
        if (objectType.equals("String_Node_Str")) {
            String interfaceName = objectType1.getName();
            List<ObjectType> objList2 = objectType1.getObject();
            for (ObjectType objectType2 : objList2) {
                String objectTypeType2 = objectType2.getObjectType();
                if (objectTypeType2.equals("String_Node_Str")) {
                    ParametersType params2 = objectType2.getParameters();
                    HashMap<String, String> params2Map = new HashMap<String, String>();
                    for (ParameterType params2Param : params2.getParameter()) {
                        params2Map.put(params2Param.getName(), params2Param.getValue());
                    }
                    String subnetType = "String_Node_Str";
                    String ipSubnetMask = params2Map.get("String_Node_Str");
                    String ipv4Subnet = params2Map.get("String_Node_Str");
                    Subnet subnet = new Subnet(ipv4Subnet + "String_Node_Str" + ipSubnetMask, ipv4Subnet, ipSubnetMask, interfaceName, subnetType);
                    result.add(subnet);
                    continue;
                }
                if (objectTypeType2.equals("String_Node_Str")) {
                    ParametersType params2 = objectType2.getParameters();
                    HashMap<String, String> params2Map = new HashMap<String, String>();
                    for (ParameterType params2Param : params2.getParameter()) {
                        params2Map.put(params2Param.getName(), params2Param.getValue());
                    }
                    String subnetType = "String_Node_Str";
                    String ipSubnetMask = params2Map.get("String_Node_Str");
                    String ipv6Subnet = params2Map.get("String_Node_Str");
                    Subnet subnet = new Subnet(ipv6Subnet + "String_Node_Str" + ipSubnetMask, ipv6Subnet, ipSubnetMask, interfaceName, subnetType);
                    result.add(subnet);
                    continue;
                }
            }
        }
    }
    return result;
}

Output:
     List<ObjectType> objList1 = discoveredDeviceData.getObject();
-    List<Subnet> result = new ArrayList<Subnet>();
+    Set<Subnet> result = new HashSet<>();
     for (ObjectType objectType1 : objList1) {


Input:
public void buildContextMenu(IMenuManager menu) {
    if (Policy.TRACING_MENU_SHOW) {
        System.out.println("String_Node_Str");
    }
    resetActionStatus();
    menu.removeAll();
    menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
    menu.add(new Separator());
    IStructuredSelection selection = (IStructuredSelection) page.getSelection();
    if (selection != null && selection.getFirstElement() != null) {
        Object selected = selection.getFirstElement();
        if (selected instanceof ReportResourceEntry) {
            selected = ((ReportResourceEntry) selected).getReportElement();
        }
        if (selected instanceof ResourceEntryWrapper) {
            int type = ((ResourceEntryWrapper) selected).getType();
            if (type == ResourceEntryWrapper.LIBRARY) {
                menu.add(useLibraryAction);
            } else if (type == ResourceEntryWrapper.CSS_STYLE_SHEET) {
                menu.add(new UseCssInReportDesignAction(page));
                menu.add(new UseCssInThemeAction(page));
            }
            if (((ResourceEntryWrapper) selected).getParent() instanceof PathResourceEntry) {
                menu.add(new Separator());
                menu.add(newMenuGroup);
                menu.add(addResourceAction);
            }
            menu.add(new Separator());
            menu.add(copyLibraryandCssAction);
            if (((ResourceEntryWrapper) selected).getParent() instanceof PathResourceEntry) {
                menu.add(pasteLibraryandCssAction);
                menu.add(deleteLibraryandCssAction);
                menu.add(moveLibraryandCssAction);
                menu.add(renameLibraryandCssAction);
                menu.add(new Separator());
            }
        } else if (selected instanceof LibraryHandle) {
            menu.add(useLibraryAction);
            menu.add(new Separator());
        } else if (selected instanceof CssStyleSheetHandle) {
            menu.add(new UseCssInReportDesignAction(page));
            menu.add(new UseCssInThemeAction(page));
            menu.add(new Separator());
        } else if (selected instanceof PathResourceEntry) {
            menu.add(newMenuGroup);
            menu.add(addResourceAction);
            menu.add(new Separator());
            menu.add(copyLibraryandCssAction);
            menu.add(pasteLibraryandCssAction);
            menu.add(deleteLibraryandCssAction);
            menu.add(moveLibraryandCssAction);
            menu.add(renameLibraryandCssAction);
            menu.add(new Separator());
        } else if (selected instanceof FragmentResourceEntry) {
            if (copyLibraryandCssAction.isEnabled()) {
                menu.add(copyLibraryandCssAction);
                menu.add(new Separator());
            }
        }
        if (canAddtoReport(selected)) {
            if (selection.size() == 1) {
                AddElementtoReport addElementAction = new AddElementtoReport((StructuredViewer) getViewer());
                addElementAction.setSelectedElement(selected);
                menu.add(addElementAction);
                menu.add(new Separator());
            }
        }
        menu.add(new Separator());
        menu.add(refreshExplorerAction);
    } else {
        menu.add(addResourceAction);
        menu.add(new Separator());
        menu.add(refreshExplorerAction);
    }
}

Output:
             menu.add(new Separator());
-            menu.add(copyLibraryandCssAction);
+            menu.add(copyResourceAction);
             if (((ResourceEntryWrapper) selected).getParent() instanceof PathResourceEntry) {


Input:
public static int[] getUncompressedStripByteCounts(IFD ifd, int strips) {
    TiffField<?> tiffField = ifd.getField(TiffTag.IMAGE_WIDTH.getValue());
    int imageWidth = tiffField.getDataAsLong()[0];
    tiffField = ifd.getField(TiffTag.IMAGE_LENGTH.getValue());
    int imageHeight = tiffField.getDataAsLong()[0];
    int samplesPerPixel = 1;
    tiffField = ifd.getField(TiffTag.SAMPLES_PER_PIXEL.getValue());
    if (tiffField != null) {
        samplesPerPixel = tiffField.getDataAsLong()[0];
    }
    int bitsPerSample = 1;
    tiffField = ifd.getField(TiffTag.BITS_PER_SAMPLE.getValue());
    if (tiffField != null) {
        bitsPerSample = tiffField.getDataAsLong()[0];
    }
    int tileWidth = -1;
    int tileLength = -1;
    TiffField<?> f_tileLength = ifd.getField(TiffTag.TILE_LENGTH.getValue());
    TiffField<?> f_tileWidth = ifd.getField(TiffTag.TILE_WIDTH.getValue());
    if (f_tileWidth != null) {
        tileWidth = f_tileWidth.getDataAsLong()[0];
        tileLength = f_tileLength.getDataAsLong()[0];
    }
    int rowsPerStrip = imageHeight;
    int rowWidth = imageWidth;
    TiffField<?> f_rowsPerStrip = ifd.getField(TiffTag.ROWS_PER_STRIP.getValue());
    if (f_rowsPerStrip != null)
        rowsPerStrip = f_rowsPerStrip.getDataAsLong()[0];
    if (rowsPerStrip > imageHeight)
        rowsPerStrip = imageHeight;
    if (tileWidth > 0) {
        rowsPerStrip = tileLength;
        rowWidth = tileWidth;
    }
    int bytesPerRow = ((bitsPerSample * rowWidth + 7) / 8) * samplesPerPixel;
    int planaryConfiguration = 1;
    tiffField = ifd.getField(TiffTag.PLANAR_CONFIGURATTION.getValue());
    if (tiffField != null)
        planaryConfiguration = tiffField.getDataAsLong()[0];
    if (planaryConfiguration == 2) {
        bytesPerRow = (bitsPerSample * rowWidth + 7) / 8;
    }
    int bytesPerStrip = bytesPerRow * rowsPerStrip;
    int[] counts = new int[strips];
    int photoMetric = ifd.getField(TiffTag.PHOTOMETRIC_INTERPRETATION.getValue()).getDataAsLong()[0];
    if (photoMetric != TiffFieldEnum.PhotoMetric.YCbCr.getValue()) {
        Arrays.fill(counts, bytesPerStrip);
        if (tileWidth < 0) {
            int lastStripBytes = bytesPerRow * imageHeight - bytesPerStrip * (strips - 1);
            counts[counts.length - 1] = lastStripBytes;
            if (planaryConfiguration == 2) {
                int stripsPerSample = strips / samplesPerPixel;
                lastStripBytes = bytesPerRow * imageHeight - bytesPerStrip * (stripsPerSample - 1);
                if (lastStripBytes > 0) {
                    for (int i = 0, stripOffset = stripsPerSample - 1; i < samplesPerPixel; i++) {
                        counts[stripOffset] = lastStripBytes;
                        stripOffset += stripsPerSample;
                    }
                }
            }
        }
    } else {
        int horizontalSampleFactor = 2;
        int verticalSampleFactor = 2;
        TiffField<?> f_YCbCrSubSampling = ifd.getField(TiffTag.YCbCr_SUB_SAMPLING.getValue());
        if (f_YCbCrSubSampling != null) {
            int[] sampleFactors = f_YCbCrSubSampling.getDataAsLong();
            horizontalSampleFactor = sampleFactors[0];
            verticalSampleFactor = sampleFactors[1];
        }
        if (samplesPerPixel != 3)
            samplesPerPixel = 3;
        int[] sampleBytesPerRow = new int[samplesPerPixel];
        sampleBytesPerRow[0] = (bitsPerSample * rowWidth + 7) / 8;
        sampleBytesPerRow[1] = (bitsPerSample * rowWidth / horizontalSampleFactor + 7) / 8;
        sampleBytesPerRow[2] = sampleBytesPerRow[1];
        int[] sampleRowsPerStrip = new int[samplesPerPixel];
        sampleRowsPerStrip[0] = rowsPerStrip;
        sampleRowsPerStrip[1] = rowsPerStrip / verticalSampleFactor;
        sampleRowsPerStrip[2] = sampleRowsPerStrip[1];
        if (planaryConfiguration == 1) {
            bytesPerStrip = sampleBytesPerRow[0] * sampleRowsPerStrip[0] + sampleBytesPerRow[1] * sampleRowsPerStrip[1] + sampleBytesPerRow[2] * sampleRowsPerStrip[2];
            Arrays.fill(counts, bytesPerStrip);
            if (tileWidth < 0) {
                int lastStripBytes = (sampleBytesPerRow[0] + sampleBytesPerRow[1] + sampleBytesPerRow[2]) * imageHeight - bytesPerStrip * (strips - 1);
                counts[counts.length - 1] = lastStripBytes;
            }
        } else {
            int[] sampleBytesPerStrip = new int[samplesPerPixel];
            sampleBytesPerStrip[0] = sampleRowsPerStrip[0] * sampleBytesPerRow[0];
            sampleBytesPerStrip[1] = sampleRowsPerStrip[1] * sampleBytesPerRow[1];
            sampleBytesPerStrip[2] = sampleBytesPerStrip[1];
            int stripsPerSample = strips / samplesPerPixel;
            int startOffset = 0;
            int endOffset = stripsPerSample;
            for (int i = 0; i < samplesPerPixel; i++) {
                Arrays.fill(counts, startOffset, endOffset, sampleBytesPerStrip[i]);
                startOffset = endOffset;
                endOffset += stripsPerSample;
            }
            if (tileWidth < 0) {
                int[] lastStripBytes = new int[samplesPerPixel];
                lastStripBytes[0] = sampleBytesPerRow[0] * imageHeight - sampleBytesPerStrip[0] * (stripsPerSample - 1);
                lastStripBytes[1] = sampleBytesPerRow[1] * imageHeight - sampleBytesPerStrip[1] * (stripsPerSample - 1);
                lastStripBytes[2] = lastStripBytes[1];
                startOffset = stripsPerSample - 1;
                for (int i = 0; i < samplesPerPixel; i++) {
                    counts[startOffset] = lastStripBytes[i];
                    startOffset = stripsPerSample;
                }
            }
        }
    }
    return counts;
}

Output:
             if (tileWidth < 0) {
-                int lastStripBytes = (sampleBytesPerRow[0] + sampleBytesPerRow[1] + sampleBytesPerRow[2]) * imageHeight - bytesPerStrip * (strips - 1);
+                int lastStripBytes = (sampleBytesPerRow[0] * columnHeight[0] + sampleBytesPerRow[1] * columnHeight[1] + sampleBytesPerRow[2] * columnHeight[2]) - bytesPerStrip * (strips - 1);
                 counts[counts.length - 1] = lastStripBytes;


Input:
private RowHandleAdapter getRowAdapter(DesignElementHandle handle) {
    return (RowHandleAdapter) HandleAdapterFactory.getInstance().getRowHandleAdapter(handle);
}

Output:
 private RowHandleAdapter getRowAdapter(DesignElementHandle handle) {
-    return (RowHandleAdapter) HandleAdapterFactory.getInstance().getRowHandleAdapter(handle);
+    return HandleAdapterFactory.getInstance().getRowHandleAdapter(handle);
 }


Input:
private static List<URL> getWorkspaceProjectURLs() {
    List<URL> urls = new ArrayList<URL>();
    String classPath = System.getProperty("String_Node_Str");
    if (classPath == null || classPath.length() == 0)
        return urls;
    String[] classPathArray = classPath.split(File.pathSeparator, -1);
    int count = classPathArray.length;
    for (int i = 0; i < count; i++) {
        File file = new File(classPathArray[i]);
        try {
            urls.add(file.toURL());
        } catch (MalformedURLException e) {
        }
    }
    return urls;
}

Output:
     List<URL> urls = new ArrayList<URL>();
-    String classPath = System.getProperty("String_Node_Str");
+    String classPath = DatasetClassPathHelper.getWorkspaceClassPath();
     if (classPath == null || classPath.length() == 0)


Input:
public void T_setByte_2() throws IOException {
    IColumn column = new PrimitiveColumn(ColumnType.BYTE, "String_Node_Str");
    column.add(ColumnType.BYTE, new ByteObj((byte) 100), 0);
    column.add(ColumnType.BYTE, new ByteObj((byte) 200), 1);
    column.add(ColumnType.BYTE, new ByteObj((byte) 255), 5);
    ColumnBinaryMakerConfig defaultConfig = new ColumnBinaryMakerConfig();
    ColumnBinaryMakerCustomConfigNode configNode = new ColumnBinaryMakerCustomConfigNode("String_Node_Str", defaultConfig);
    IColumnBinaryMaker maker = new UniqByteColumnBinaryMaker();
    ColumnBinary columnBinary = maker.toBinary(defaultConfig, null, column);
    BufferAllocator allocator = new RootAllocator(1024 * 1024 * 10);
    SchemaChangeCallBack callBack = new SchemaChangeCallBack();
    MapVector parent = new MapVector("String_Node_Str", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack);
    parent.allocateNew();
    IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromMapVector(ColumnType.BYTE, "String_Node_Str", allocator, parent);
    maker.loadInMemoryStorage(columnBinary, memoryAllocator);
    MapReader rootReader = parent.getReader();
    FieldReader reader = rootReader.reader("String_Node_Str");
    reader.setPosition(0);
    assertEquals(reader.readByte().byteValue(), (byte) 100);
    reader.setPosition(1);
    assertEquals(reader.readByte().byteValue(), (byte) 200);
    reader.setPosition(5);
    assertEquals(reader.readByte().byteValue(), (byte) 255);
    reader.setPosition(2);
    assertEquals(reader.readByte(), null);
    reader.setPosition(3);
    assertEquals(reader.readByte(), null);
    reader.setPosition(4);
    assertEquals(reader.readByte(), null);
}

Output:
     ColumnBinaryMakerCustomConfigNode configNode = new ColumnBinaryMakerCustomConfigNode("String_Node_Str", defaultConfig);
-    IColumnBinaryMaker maker = new UniqByteColumnBinaryMaker();
+    IColumnBinaryMaker maker = new OptimizeLongColumnBinaryMaker();
     ColumnBinary columnBinary = maker.toBinary(defaultConfig, null, column);


Input:
protected void createGLCanvas() {
    GLProfile profile = GLProfile.get(GLProfile.GL2);
    GLCapabilities glCapabilities = new GLCapabilities(profile);
    glCapabilities.setStencilBits(1);
    glCapabilities.setDoubleBuffered(true);
    glCanvas = new GLCanvas(glCapabilities);
    GeneralManager.get().getViewManager().registerGLCanvasToAnimator(glCanvas);
}

Output:
     GLProfile profile = GLProfile.get(GLProfile.GL2);
-    GLCapabilities glCapabilities = new GLCapabilities(profile);
+    final GLCapabilities glCapabilities = new GLCapabilities(profile);
     glCapabilities.setStencilBits(1);


Input:
public SimpleFeature next() {
    SimpleFeature next = super.next();
    SimpleFeatureBuilder builder = new SimpleFeatureBuilder(featureType);
    for (Property property : next.getProperties()) {
        if (property instanceof GeometryAttribute) {
            builder.set(featureType.getGeometryDescriptor().getName(), property.getValue());
        } else {
            builder.set(property.getName().getLocalPart(), property.getValue());
        }
    }
    Map<Object, Object> userData = next.getUserData();
    for (Entry<Object, Object> entry : userData.entrySet()) {
        builder.featureUserData(entry.getKey(), entry.getValue());
    }
    String oldFeatureId = next.getIdentifier().getID();
    String featureId;
    if (fidMappings.containsKey(oldFeatureId)) {
        featureId = fidMappings.get(oldFeatureId);
    } else {
        featureId = SimpleFeatureBuilder.createDefaultFeatureId();
    }
    return builder.buildFeature(featureId);
}

Output:
     SimpleFeatureBuilder builder = new SimpleFeatureBuilder(featureType);
-    for (Property property : next.getProperties()) {
-        if (property instanceof GeometryAttribute) {
-            builder.set(featureType.getGeometryDescriptor().getName(), property.getValue());
-        } else {
-            builder.set(property.getName().getLocalPart(), property.getValue());
-        }
-    }
-    Map<Object, Object> userData = next.getUserData();
-    for (Entry<Object, Object> entry : userData.entrySet()) {
-        builder.featureUserData(entry.getKey(), entry.getValue());
-    }
+    builder.init(next);
     String oldFeatureId = next.getIdentifier().getID();


Input:
public static String getBodyForUpdateChatNotificationMessage(Context context, QBMessage chatMessage) {
    String occupantsIds = chatMessage.getProperty(PROPERTY_OCCUPANTS_IDS);
    String dialogName = chatMessage.getProperty(PROPERTY_ROOM_NAME);
    String photoUrl = chatMessage.getProperty(PROPERTY_ROOM_PHOTO);
    String leave = chatMessage.getProperty(PROPERTY_ROOM_LEAVE);
    String notificationType = chatMessage.getProperty(PROPERTY_NOTIFICATION_TYPE);
    Resources resources = context.getResources();
    String resultMessage = resources.getString(R.string.cht_notification_message);
    QBUser user = AppSession.getSession().getUser();
    boolean ownMessage = user.getId().equals(chatMessage.getSenderId());
    if (notificationType.equals(PROPERTY_TYPE_TO_PRIVATE_CHAT__GROUP_CHAT_CREATE)) {
        resultMessage = ownMessage ? resources.getString(R.string.user_created_room, user.getFullName()) : resources.getString(R.string.user_created_room, ChatUtils.getFullNameById(context, chatMessage.getSenderId()));
        return resultMessage;
    }
    if (!TextUtils.isEmpty(occupantsIds)) {
        String fullNames = ChatUtils.getFullNamesFromOpponentIds(context, occupantsIds);
        resultMessage = ownMessage ? resources.getString(R.string.cht_update_group_added_message, user.getFullName(), fullNames) : resources.getString(R.string.cht_update_group_added_message, ChatUtils.getFullNameById(context, chatMessage.getSenderId()), fullNames);
    }
    if (!TextUtils.isEmpty(dialogName)) {
        resultMessage = ownMessage ? resources.getString(R.string.cht_update_group_name_message, user.getFullName(), dialogName) : resources.getString(R.string.cht_update_group_name_message, ChatUtils.getFullNameById(context, chatMessage.getSenderId()), dialogName);
    }
    if (!TextUtils.isEmpty(photoUrl)) {
        resultMessage = ownMessage ? resources.getString(R.string.cht_update_group_photo_message, user.getFullName()) : resources.getString(R.string.cht_update_group_photo_message, ChatUtils.getFullNameById(context, chatMessage.getSenderId()));
    }
    if (!TextUtils.isEmpty(leave)) {
        resultMessage = ownMessage ? resources.getString(R.string.cht_update_group_leave_message, user.getFullName()) : resources.getString(R.string.cht_update_group_leave_message, ChatUtils.getFullNameById(context, chatMessage.getSenderId()));
    }
    return resultMessage;
}

Output:
     boolean ownMessage = user.getId().equals(chatMessage.getSenderId());
-    if (notificationType.equals(PROPERTY_TYPE_TO_PRIVATE_CHAT__GROUP_CHAT_CREATE)) {
-        resultMessage = ownMessage ? resources.getString(R.string.user_created_room, user.getFullName()) : resources.getString(R.string.user_created_room, ChatUtils.getFullNameById(context, chatMessage.getSenderId()));
+    if (notificationType.equals(PROPERTY_TYPE_TO_GROUP_CHAT__GROUP_CHAT_CREATE)) {
+        String fullNames = ChatUtils.getFullNamesFromOpponentIds(context, occupantsIds);
+        resultMessage = ownMessage ? resources.getString(R.string.cht_update_group_added_message, user.getFullName(), fullNames) : resources.getString(R.string.cht_update_group_added_message, ChatUtils.getFullNameById(context, chatMessage.getSenderId()), fullNames);
         return resultMessage;


Input:
public void append1() {
    int blockIndex = size / BITS_IN_BLOCK;
    int indexInBlock = size % BITS_IN_BLOCK;
    int cacheBlockIndex = size / BITS_IN_COUNTCACHE0;
    if (blockIndex >= longs.length) {
        extendLongsAndCountCache0();
    }
    if (size % BITS_IN_COUNTCACHE0 == 0 && cacheBlockIndex > 0) {
        countCache0[cacheBlockIndex] = countCache0[cacheBlockIndex - 1];
    }
    longs[blockIndex] |= 0x8000000000000000L >>> (size % BITS_IN_BLOCK);
    if (indexInBlock == 0) {
        prevBsC = currentBsC;
        currentBsC = false;
        arS[arSSize - 1]++;
    }
    size++;
    if (size % BITS_IN_BLOCK == 0) {
        first0bitInBlock = true;
    }
}

Output:
     longs[blockIndex] |= 0x8000000000000000L >>> (size % BITS_IN_BLOCK);
-    if (indexInBlock == 0) {
+    if ((size % 8) == 0) {
         prevBsC = currentBsC;


Input:
public String toJson() {
    String json = "String_Node_Str";
    json = gson.toJson(this);
    System.out.println(json);
    return json;
}

Output:
     String json = "String_Node_Str";
-    json = gson.toJson(this);
+    json = mGson.toJson(this);
     System.out.println(json);


Input:
public void normalize(BooleanAlgebra<CharPred, Character> ba) throws TimeoutException {
    ArrayList<Pair<CharPred, CharPred>> newNotEqual = new ArrayList<Pair<CharPred, CharPred>>();
    ArrayList<CharPred> firstProj = new ArrayList<>();
    for (Pair<CharPred, CharPred> pair : notEqual) firstProj.add(pair.first);
    Collection<Pair<CharPred, ArrayList<Integer>>> minterms = ba.GetMinterms(firstProj);
    for (Pair<CharPred, ArrayList<Integer>> minterm : minterms) {
        CharPred currA = minterm.first;
        CharPred currB = ba.False();
        for (int bit = 0; bit < notEqual.size(); bit++) if (minterm.second.get(bit) == 1)
            currB = ba.MkOr(notEqual.get(bit).second, notEqual.get(bit).second);
        newNotEqual.add(new Pair<>(currA, currB));
    }
    notEqual = newNotEqual;
}

Output:
         for (int bit = 0; bit < notEqual.size(); bit++) if (minterm.second.get(bit) == 1)
-            currB = ba.MkOr(notEqual.get(bit).second, notEqual.get(bit).second);
+            currB = ba.MkOr(currB, notEqual.get(bit).second);
         newNotEqual.add(new Pair<>(currA, currB));


Input:
public String getMarketUrl() {
    StringBuilder builder = new StringBuilder();
    builder.append("String_Node_Str");
    builder.append(getAppName());
    return builder.toString();
}

Output:
     StringBuilder builder = new StringBuilder();
-    builder.append("String_Node_Str");
-    builder.append(getAppName());
+    String appStore = config.getProperty(SocializeConfig.REDIRECT_APP_STORE);
+    if (!StringUtils.isEmpty(appStore) && appStore.equalsIgnoreCase("String_Node_Str")) {
+        builder.append("String_Node_Str");
+    } else {
+        builder.append("String_Node_Str");
+    }
+    builder.append(getPackageName());
     return builder.toString();


Input:
private Intent encryptAndSignImpl(Intent data, InputStream inputStream, OutputStream outputStream, boolean sign) {
    try {
        boolean asciiArmor = data.getBooleanExtra(OpenPgpApi.EXTRA_REQUEST_ASCII_ARMOR, true);
        String originalFilename = data.getStringExtra(OpenPgpApi.EXTRA_ORIGINAL_FILENAME);
        if (originalFilename == null) {
            originalFilename = "String_Node_Str";
        }
        boolean enableCompression = data.getBooleanExtra(OpenPgpApi.EXTRA_ENABLE_COMPRESSION, true);
        int compressionId;
        if (enableCompression) {
            compressionId = PgpSecurityConstants.OpenKeychainCompressionAlgorithmTags.USE_DEFAULT;
        } else {
            compressionId = PgpSecurityConstants.OpenKeychainCompressionAlgorithmTags.UNCOMPRESSED;
        }
        PgpSignEncryptData pgpData = new PgpSignEncryptData();
        pgpData.setEnableAsciiArmorOutput(asciiArmor).setVersionHeader(null).setCompressionAlgorithm(compressionId);
        if (sign) {
            Intent signKeyIdIntent = getSignKeyMasterId(data);
            if (signKeyIdIntent.getIntExtra(OpenPgpApi.RESULT_CODE, OpenPgpApi.RESULT_CODE_ERROR) != OpenPgpApi.RESULT_CODE_SUCCESS) {
                return signKeyIdIntent;
            }
            long signKeyId = signKeyIdIntent.getLongExtra(OpenPgpApi.EXTRA_SIGN_KEY_ID, Constants.key.none);
            if (signKeyId == Constants.key.none) {
                throw new Exception("String_Node_Str");
            }
            long signSubKeyId = mKeyRepository.getCachedPublicKeyRing(signKeyId).getSecretSignId();
            pgpData.setSignatureMasterKeyId(signKeyId).setSignatureSubKeyId(signSubKeyId).setAdditionalEncryptId(signKeyId);
        }
        KeyIdResult keyIdResult = mKeyIdExtractor.returnKeyIdsFromIntent(data, false, mApiPermissionHelper.getCurrentCallingPackage());
        boolean isDryRun = data.getBooleanExtra(OpenPgpApi.EXTRA_DRY_RUN, false);
        boolean isOpportunistic = data.getBooleanExtra(OpenPgpApi.EXTRA_OPPORTUNISTIC_ENCRYPTION, false);
        KeyIdResultStatus keyIdResultStatus = keyIdResult.getStatus();
        if (isDryRun) {
            return getDryRunStatusResult(keyIdResult);
        }
        if (keyIdResult.hasKeySelectionPendingIntent()) {
            if ((keyIdResultStatus == KeyIdResultStatus.MISSING || keyIdResultStatus == KeyIdResultStatus.NO_KEYS || keyIdResultStatus == KeyIdResultStatus.NO_KEYS_ERROR) && isOpportunistic) {
                return createErrorResultIntent(OpenPgpError.OPPORTUNISTIC_MISSING_KEYS, "String_Node_Str");
            }
            Intent result = new Intent();
            result.putExtra(OpenPgpApi.RESULT_CODE, OpenPgpApi.RESULT_CODE_USER_INTERACTION_REQUIRED);
            result.putExtra(OpenPgpApi.RESULT_INTENT, keyIdResult.getKeySelectionPendingIntent());
            return result;
        }
        pgpData.setEncryptionMasterKeyIds(keyIdResult.getKeyIds());
        PgpSignEncryptInputParcel pseInput = new PgpSignEncryptInputParcel(pgpData);
        pseInput.setAllowedKeyIds(getAllowedKeyIds());
        CryptoInputParcel inputParcel = CryptoInputParcelCacheService.getCryptoInputParcel(this, data);
        if (inputParcel == null) {
            inputParcel = new CryptoInputParcel(new Date());
        }
        if (data.hasExtra(OpenPgpApi.EXTRA_PASSPHRASE)) {
            inputParcel.mPassphrase = new Passphrase(data.getCharArrayExtra(OpenPgpApi.EXTRA_PASSPHRASE));
        }
        long inputLength = inputStream.available();
        InputData inputData = new InputData(inputStream, inputLength, originalFilename);
        PgpSignEncryptOperation op = new PgpSignEncryptOperation(this, mKeyRepository, null);
        PgpSignEncryptResult pgpResult = op.execute(pseInput, inputParcel, inputData, outputStream);
        if (pgpResult.isPending()) {
            RequiredInputParcel requiredInput = pgpResult.getRequiredInputParcel();
            PendingIntent pIntent = mApiPendingIntentFactory.requiredInputPi(data, requiredInput, pgpResult.mCryptoInputParcel);
            Intent result = new Intent();
            result.putExtra(OpenPgpApi.RESULT_INTENT, pIntent);
            result.putExtra(OpenPgpApi.RESULT_CODE, OpenPgpApi.RESULT_CODE_USER_INTERACTION_REQUIRED);
            return result;
        } else if (pgpResult.success()) {
            Intent result = new Intent();
            result.putExtra(OpenPgpApi.RESULT_CODE, OpenPgpApi.RESULT_CODE_SUCCESS);
            return result;
        } else {
            LogEntryParcel errorMsg = pgpResult.getLog().getLast();
            throw new Exception(getString(errorMsg.mType.getMsgId()));
        }
    } catch (Exception e) {
        Log.d(Constants.TAG, "String_Node_Str", e);
        return createErrorResultIntent(OpenPgpError.GENERIC_ERROR, e.getMessage());
    }
}

Output:
             Intent signKeyIdIntent = getSignKeyMasterId(data);
-            if (signKeyIdIntent.getIntExtra(OpenPgpApi.RESULT_CODE, OpenPgpApi.RESULT_CODE_ERROR) != OpenPgpApi.RESULT_CODE_SUCCESS) {
+            if (signKeyIdIntent.getIntExtra(OpenPgpApi.RESULT_CODE, OpenPgpApi.RESULT_CODE_ERROR) == OpenPgpApi.RESULT_CODE_USER_INTERACTION_REQUIRED) {
                 return signKeyIdIntent;


Input:
private void updateIncludingMenus() {
    WalletAccount account = accountListAdapter.getFocusedAccount();
    boolean isBch = account.getType() == WalletAccount.Type.BCHSINGLEADDRESS || account.getType() == WalletAccount.Type.BCHBIP44;
    final List<Integer> menus = Lists.newArrayList();
    if (!(account instanceof ColuAccount) && !Utils.checkIsLinked(account, _mbwManager.getColuManager().getAccounts().values())) {
        menus.add(R.menu.record_options_menu);
    }
    if ((account instanceof SingleAddressAccount) || (account.isDerivedFromInternalMasterseed())) {
        menus.add(R.menu.record_options_menu_backup);
    }
    if (account instanceof SingleAddressAccount) {
        menus.add(R.menu.record_options_menu_backup_verify);
    }
    if (account instanceof ColuAccount) {
        menus.add(R.menu.record_options_menu_backup);
        menus.add(R.menu.record_options_menu_backup_verify);
    }
    if (!account.isDerivedFromInternalMasterseed() && !isBch) {
        menus.add(R.menu.record_options_menu_delete);
    }
    if (account.isActive() && account.canSpend() && !(account instanceof Bip44PubOnlyAccount) && !isBch) {
        menus.add(R.menu.record_options_menu_sign);
    }
    if (account.isActive() && !isBch) {
        menus.add(R.menu.record_options_menu_active);
    }
    if (account.isActive() && !(account instanceof CoinapultAccount) && !isBch) {
        menus.add(R.menu.record_options_menu_outputs);
    }
    if (account instanceof CoinapultAccount) {
        menus.add(R.menu.record_options_menu_set_coinapult_mail);
    }
    if (account.isArchived()) {
        menus.add(R.menu.record_options_menu_archive);
    }
    if (account.isActive() && account instanceof ExportableAccount && !isBch) {
        menus.add(R.menu.record_options_menu_export);
    }
    if (account.isActive() && account instanceof Bip44Account && !(account instanceof Bip44PubOnlyAccount) && AccountManager.INSTANCE.getBTCMasterSeedAccounts().size() > 1 && !isBch) {
        if (!((Bip44Account) account).hasHadActivity()) {
            menus.add(R.menu.record_options_menu_hide_unused);
        }
    }
    if (RecordRowBuilder.showLegacyAccountWarning(account, _mbwManager)) {
        menus.add(R.menu.record_options_menu_ignore_warning);
    }
    if (account.getId().equals(_mbwManager.getLocalTraderManager().getLocalTraderAccountId())) {
        menus.add(R.menu.record_options_menu_detach);
    }
    AppCompatActivity parent = (AppCompatActivity) getActivity();
    Callback actionMode = new Callback() {
        public boolean onCreateActionMode(ActionMode actionMode, Menu menu) {
            for (Integer res : menus) {
                actionMode.getMenuInflater().inflate(res, menu);
            }
            return true;
        }
        public boolean onPrepareActionMode(ActionMode actionMode, Menu menu) {
            return true;
        }
        public boolean onActionItemClicked(ActionMode actionMode, MenuItem menuItem) {
            if (_mbwManager.getWalletManager(false).getState() == WalletManager.State.SYNCHRONIZING || _mbwManager.getColuManager().getState() == WalletManager.State.SYNCHRONIZING) {
                _toaster.toast(R.string.synchronizing_please_wait, false);
                return true;
            }
            int id = menuItem.getItemId();
            if (id == R.id.miActivate) {
                activateSelected();
                return true;
            } else if (id == R.id.miSetLabel) {
                setLabelOnAccount(accountListAdapter.getFocusedAccount(), "String_Node_Str", true);
                return true;
            } else if (id == R.id.miDeleteRecord) {
                deleteSelected();
                return true;
            } else if (id == R.id.miArchive) {
                archiveSelected();
                return true;
            } else if (id == R.id.miHideUnusedAccount) {
                hideSelected();
                return true;
            } else if (id == R.id.miExport) {
                exportSelectedPrivateKey();
                return true;
            } else if (id == R.id.miIgnoreWarnings) {
                ignoreSelectedPrivateKey();
                return true;
            } else if (id == R.id.miSignMessage) {
                signMessage();
                return true;
            } else if (id == R.id.miDetach) {
                detachFromLocalTrader();
                return true;
            } else if (id == R.id.miShowOutputs) {
                showOutputs();
                return true;
            } else if (id == R.id.miMakeBackup) {
                makeBackup();
                return true;
            } else if (id == R.id.miSingleKeyBackupVerify) {
                verifySingleKeyBackup();
                return true;
            } else if (id == R.id.miRescan) {
                rescan();
                return true;
            } else if (id == R.id.miSetMail) {
                setCoinapultMail();
                return true;
            } else if (id == R.id.miVerifyMail) {
                verifyCoinapultMail();
                return true;
            }
            return false;
        }
        public void onDestroyActionMode(ActionMode actionMode) {
            currentActionMode = null;
            if (accountListAdapter.getFocusedAccount() != null) {
                accountListAdapter.setFocusedAccount(null);
                update();
            }
        }
    };
    currentActionMode = parent.startSupportActionMode(actionMode);
    accountListAdapter.setFocusedAccount(account);
    update();
}

Output:
     }
-    if (account.isArchived()) {
+    if (account.getType() != WalletAccount.Type.BCHBIP44 && account.getType() != WalletAccount.Type.BCHSINGLEADDRESS && account.isArchived()) {
         menus.add(R.menu.record_options_menu_archive);


Input:
private void close(final String failureMessage) {
    connected = false;
    if (failureMessage != null) {
        logger.info("String_Node_Str" + failureMessage);
    }
    boolean wasOpen = false;
    synchronized (this) {
        if (softphoneOutputStream != null) {
            logger.finer("String_Node_Str");
            sendCommandToSoftphone("String_Node_Str");
        }
        softphoneAddress = null;
        if (softphoneOutputStream != null) {
            try {
                softphoneOutputStream.close();
            } catch (IOException ioe) {
            }
        }
        logger.finer("String_Node_Str");
        softphoneOutputStream = null;
        if (stdOutListener != null) {
            stdOutListener.stop();
            stdOutListener = null;
        }
        if (stdErrListener != null) {
            stdErrListener.stop();
            stdErrListener = null;
        }
        if (pinger != null) {
            pinger.interrupt();
            pinger = null;
        }
        softphoneProcess = null;
    }
    notifyListeners(State.EXITED);
}

Output:
 private void close(final String failureMessage) {
-    connected = false;
+    if (closed) {
+        return;
+    }
+    closed = true;
     if (failureMessage != null) {


Input:
public void diff(ArrayList<Configuration> configs) throws IOException {
    if (!quiet) {
        System.out.println("String_Node_Str");
        System.out.println("String_Node_Str");
        System.out.println("String_Node_Str");
    }
    MergedConfiguration mc = new MergedConfiguration();
    TreeSet<String> prevKeys = null;
    Configuration prevConf = null;
    if (!quiet)
        System.out.println("String_Node_Str");
    for (Configuration conf : configs) {
        TreeSet<String> keys = new TreeSet<String>();
        for (Property p : conf.getProperties()) {
            mc.addProperty(p);
            keys.add(p.getKey());
        }
        String currentVersion = conf.getProperties().first().getSource();
        if (prevKeys != null) {
            TreeSet<String> addedKeys = new TreeSet<String>(keys);
            addedKeys.removeAll(prevKeys);
            if (addedKeys.size() > 0) {
                if (!quiet)
                    System.out.println("String_Node_Str" + currentVersion + "String_Node_Str");
                for (String key : addedKeys) {
                    Property p = conf.getProperty(key);
                    Property p2 = prevConf.getPropertyByDescription(p.getDescription());
                    boolean renamed = !Property.NULL.equals(p.getDescription()) && p2 != null;
                    printProperty(p, p2, renamed ? Action.Renamed : Action.Added);
                }
                System.out.println();
            }
            TreeSet<String> removedKeys = new TreeSet<String>(prevKeys);
            removedKeys.removeAll(keys);
            if (removedKeys.size() > 0) {
                System.out.println("String_Node_Str" + currentVersion + "String_Node_Str");
                for (String key : removedKeys) {
                    Property p = prevConf.getProperty(key);
                    printProperty(p, null, Action.Removed);
                }
                System.out.println();
            }
        }
        prevKeys = keys;
        prevConf = conf;
    }
    if (!quiet)
        System.out.println("String_Node_Str");
    if (!quiet)
        System.out.println("String_Node_Str");
    int diffCount = 0;
    for (String key : mc.getProperties().keySet()) {
        TreeSet<Property> merged = mc.getProperties().get(key);
        if (merged.size() > 1) {
            if (!quiet)
                System.out.println("String_Node_Str" + key);
            diffCount++;
            for (Property p : merged) {
                printProperty(p, null, Action.Changed);
            }
            System.out.println();
        }
    }
    if (!quiet)
        System.out.println("String_Node_Str" + diffCount + "String_Node_Str");
    if (!quiet)
        System.out.println("String_Node_Str");
}

Output:
         }
-        String currentVersion = conf.getProperties().first().getSource();
-        if (prevKeys != null) {
-            TreeSet<String> addedKeys = new TreeSet<String>(keys);
-            addedKeys.removeAll(prevKeys);
-            if (addedKeys.size() > 0) {
-                if (!quiet)
-                    System.out.println("String_Node_Str" + currentVersion + "String_Node_Str");
-                for (String key : addedKeys) {
-                    Property p = conf.getProperty(key);
-                    Property p2 = prevConf.getPropertyByDescription(p.getDescription());
-                    boolean renamed = !Property.NULL.equals(p.getDescription()) && p2 != null;
-                    printProperty(p, p2, renamed ? Action.Renamed : Action.Added);
+        if (conf.getProperties().size() > 0) {
+            String currentVersion = conf.getProperties().first().getSource();
+            if (prevKeys != null) {
+                TreeSet<String> addedKeys = new TreeSet<String>(keys);
+                addedKeys.removeAll(prevKeys);
+                if (addedKeys.size() > 0) {
+                    if (!quiet)
+                        System.out.println("String_Node_Str" + currentVersion + "String_Node_Str");
+                    int addedCount = 0, renamedCount = 0;
+                    for (String key : addedKeys) {
+                        Property p = conf.getProperty(key);
+                        Property p2 = prevConf.getPropertyByDescription(p.getDescription());
+                        boolean renamed = !Property.NULL.equals(p.getDescription()) && p2 != null;
+                        if (renamed)
+                            renamedCount++;
+                        else
+                            addedCount++;
+                        printProperty(p, p2, renamed ? Action.Renamed : Action.Added);
+                    }
+                    if (!quiet)
+                        System.out.println("String_Node_Str" + currentVersion + "String_Node_Str" + addedCount + "String_Node_Str" + renamedCount + "String_Node_Str");
+                    System.out.println();
                 }


Input:
public void run() {
    Object clipBoardContent;
    try {
        clipBoardContent = Clipboard.getDefault().getContents();
    } catch (RuntimeException e) {
        return;
    }
    org.eclipse.swt.dnd.Clipboard systemClipboard = new org.eclipse.swt.dnd.Clipboard(Display.getCurrent());
    Object systemObject = systemClipboard.getContents(TextTransfer.getInstance());
    if (clipBoardContent instanceof List) {
        List<EditPart> partsList = (List<EditPart>) clipBoardContent;
        if (partsList == null || partsList.isEmpty()) {
            return;
        }
        List<NodePart> nodeParts = new ArrayList<NodePart>();
        List<NoteEditPart> noteParts = new ArrayList<NoteEditPart>();
        List<SubjobContainerPart> subjobParts = new ArrayList<SubjobContainerPart>();
        for (Object o : partsList) {
            if (o instanceof NodePart) {
                if (!nodeParts.contains(o)) {
                    nodeParts.add((NodePart) o);
                }
            } else if (o instanceof NoteEditPart) {
                noteParts.add((NoteEditPart) o);
            } else if (o instanceof SubjobContainerPart) {
                SubjobContainerPart subjob = (SubjobContainerPart) o;
                for (Iterator iterator = subjob.getChildren().iterator(); iterator.hasNext(); ) {
                    NodeContainerPart nodeContainerPart = (NodeContainerPart) iterator.next();
                    NodePart nodePart = nodeContainerPart.getNodePart();
                    if (nodePart != null) {
                        if (!nodeParts.contains(nodePart)) {
                            nodeParts.add(nodePart);
                        }
                        subjobParts.add(subjob);
                    }
                }
            }
        }
        AbstractTalendEditor editor = (AbstractTalendEditor) this.getWorkbenchPart();
        org.eclipse.draw2d.geometry.Point gefPoint = getCursorLocation();
        AbstractProcessProvider findProcessProviderFromPID = AbstractProcessProvider.findProcessProviderFromPID(IComponent.JOBLET_PID);
        if (findProcessProviderFromPID != null) {
            for (NodePart copiedNodePart : nodeParts) {
                Node copiedNode = (Node) copiedNodePart.getModel();
                if (findProcessProviderFromPID.isJobletInputOrOutputComponent(copiedNode)) {
                    if (!findProcessProviderFromPID.isExtensionProcess(editor.getProcess())) {
                        MessageBox messagebox = new MessageBox(PlatformUI.getWorkbench().getDisplay().getActiveShell(), SWT.ICON_WARNING);
                        messagebox.setText(Messages.getString("String_Node_Str"));
                        messagebox.setMessage(Messages.getString("String_Node_Str"));
                        messagebox.open();
                        return;
                    }
                }
                if (copiedNode.getJobletNode() != null) {
                    boolean canP = canPasteJobletNode(editor.getProcess(), copiedNode);
                    if (!canP) {
                        return;
                    }
                }
            }
        }
        if (nodeParts.size() != 0 && noteParts.size() != 0) {
            MultiplePasteCommand mpc = new MultiplePasteCommand(nodeParts, noteParts, (org.talend.designer.core.ui.editor.process.Process) editor.getProcess(), gefPoint);
            mpc.setSelectedSubjobs(subjobParts);
            execute(mpc);
        } else if (nodeParts.size() != 0) {
            NodesPasteCommand cmd = new NodesPasteCommand(nodeParts, (org.talend.designer.core.ui.editor.process.Process) editor.getProcess(), gefPoint);
            cmd.setSelectedSubjobs(subjobParts);
            execute(cmd);
        } else if (noteParts.size() != 0) {
            NotesPasteCommand cmd = new NotesPasteCommand(noteParts, (org.talend.designer.core.ui.editor.process.Process) editor.getProcess(), gefPoint, false, null);
            execute(cmd);
        }
        setCursorLocation(null);
    } else if (clipBoardContent instanceof String) {
        List objects = getSelectedObjects();
        if (objects.size() == 1) {
            String content = (String) clipBoardContent;
            if (objects.get(0) instanceof NoteEditPart && ((NoteEditPart) objects.get(0)).getDirectEditManager() != null) {
                Text text = ((NoteEditPart) objects.get(0)).getDirectEditManager().getTextControl();
                if (text != null) {
                    text.insert(content);
                }
            } else if (objects.get(0) instanceof ConnLabelEditPart && ((ConnLabelEditPart) objects.get(0)).getDirectEditManager() != null) {
                Text text = ((ConnLabelEditPart) objects.get(0)).getDirectEditManager().getTextControl();
                if (text != null) {
                    text.insert(content);
                }
            } else if (objects.get(0) instanceof NodeLabelEditPart && ((NodeLabelEditPart) objects.get(0)).getDirectEditManager() != null) {
                {
                    Text text = (Text) ((NodeLabelEditPart) objects.get(0)).getDirectEditManager().getCellEditor().getControl();
                    if (text != null) {
                        text.insert(content);
                    }
                }
            }
        }
    } else if (systemObject != null && systemObject instanceof String) {
        List objects = getSelectedObjects();
        if (objects.size() == 1) {
            String content = (String) systemObject;
            if (objects.get(0) instanceof NoteEditPart && ((NoteEditPart) objects.get(0)).getDirectEditManager() != null) {
                Text text = ((NoteEditPart) objects.get(0)).getDirectEditManager().getTextControl();
                if (text != null) {
                    text.insert(content);
                }
            } else if (objects.get(0) instanceof ConnLabelEditPart && ((ConnLabelEditPart) objects.get(0)).getDirectEditManager() != null) {
                Text text = ((ConnLabelEditPart) objects.get(0)).getDirectEditManager().getTextControl();
                if (text != null) {
                    text.insert(content);
                }
            } else if (objects.get(0) instanceof NodeLabelEditPart && ((NodeLabelEditPart) objects.get(0)).getDirectEditManager() != null) {
                {
                    Text text = (Text) ((NodeLabelEditPart) objects.get(0)).getDirectEditManager().getCellEditor().getControl();
                    if (text != null) {
                        text.insert(content);
                    }
                }
            }
        }
    }
}

Output:
         } else if (nodeParts.size() != 0) {
-            NodesPasteCommand cmd = new NodesPasteCommand(nodeParts, (org.talend.designer.core.ui.editor.process.Process) editor.getProcess(), gefPoint);
+            NodesPasteCommand cmd = new NodesPasteCommand(nodeParts, editor.getProcess(), gefPoint);
             cmd.setSelectedSubjobs(subjobParts);


Input:
private void checkUpdate() {
    try {
        URL pluginInfo = new URL("String_Node_Str");
        BufferedReader in = new BufferedReader(new InputStreamReader(pluginInfo.openStream()));
        String strLine;
        while ((strLine = in.readLine()) != null) {
            if (strLine.contains("String_Node_Str")) {
                String[] tokens = strLine.split("String_Node_Str");
                String version = tokens[1];
                if (isDouble(version) && isDouble(pdfFile.getVersion())) {
                    if (Double.parseDouble(version) > Double.parseDouble(pdfFile.getVersion())) {
                        if (JOptionPane.showConfirmDialog(null, "String_Node_Str", "String_Node_Str", JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION) {
                            getServer().dispatchCommand(new ConsoleCommandSender(getServer()), "String_Node_Str");
                        }
                    } else {
                        JOptionPane.showMessageDialog(null, "String_Node_Str");
                    }
                } else {
                    log.severe("String_Node_Str");
                }
            }
        }
    } catch (MalformedURLException e) {
        log.severe("String_Node_Str");
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Output:
     try {
-        URL pluginInfo = new URL("String_Node_Str");
+        pluginInfo = new URL("String_Node_Str");
         BufferedReader in = new BufferedReader(new InputStreamReader(pluginInfo.openStream()));


Input:
private void listen() {
    if (timeToHear <= 0) {
        this.sounds.clear();
        List<SoundEmittedEvent> emittedSounds = world.getSoundEvents();
        if (!emittedSounds.isEmpty()) {
            this.entity.getHeardSounds(emittedSounds, this.sounds);
        }
        memory.store(HEARING, this.sounds);
        this.timeToHear = REFRESH_TIME;
    }
}

Output:
         this.sounds.clear();
-        List<SoundEmittedEvent> emittedSounds = world.getSoundEvents();
-        if (!emittedSounds.isEmpty()) {
+        SoundEventPool emittedSounds = world.getSoundEvents();
+        if (emittedSounds.hasSounds()) {
             this.entity.getHeardSounds(emittedSounds, this.sounds);


Input:
public synchronized void reset() {
    if (getCommunicator() != null) {
        getCommunicator().clearListeners();
    }
    getCommunicator().close();
    instance = null;
}

Output:
 public synchronized void reset() {
-    if (getCommunicator() != null) {
-        getCommunicator().clearListeners();
+    Communicator communicator = getCommunicator();
+    if (communicator != null) {
+        communicator.interruptAllTimeouts();
+        communicator.clearListeners();
+        communicator.close();
     }


Input:
public void sourceUpdated(String newSource) {
    chartData.setChartSource(newSource);
    updateChart();
}

Output:
     chartData.setChartSource(newSource);
-    updateChart();
+    updatePanel(chartData.getTop());
 }


Input:
protected Set<Content> refreshContent(Owner owner, Collection<Subscription> subs) {
    Map<String, ContentData> content = new HashMap<String, ContentData>();
    log.info("String_Node_Str", subs.size());
    for (Subscription sub : subs) {
        this.addProductContentToMap(content, sub.getProduct());
        this.addProductContentToMap(content, sub.getDerivedProduct());
        for (ProductData product : sub.getProvidedProducts()) {
            this.addProductContentToMap(content, product);
        }
        for (ProductData product : sub.getDerivedProvidedProducts()) {
            this.addProductContentToMap(content, product);
        }
    }
    Set<Content> changed = this.getChangedContent(owner, content);
    this.contentCurator.flush();
    return changed;
}

Output:
     log.info("String_Node_Str", subs.size());
-    for (Subscription sub : subs) {
-        this.addProductContentToMap(content, sub.getProduct());
-        this.addProductContentToMap(content, sub.getDerivedProduct());
-        for (ProductData product : sub.getProvidedProducts()) {
-            this.addProductContentToMap(content, product);
-        }
-        for (ProductData product : sub.getDerivedProvidedProducts()) {
-            this.addProductContentToMap(content, product);
+    if (subs != null) {
+        for (Subscription sub : subs) {
+            this.addProductContentToMap(content, sub.getProduct());
+            this.addProductContentToMap(content, sub.getDerivedProduct());
+            for (ProductData product : sub.getProvidedProducts()) {
+                this.addProductContentToMap(content, product);
+            }
+            for (ProductData product : sub.getDerivedProvidedProducts()) {
+                this.addProductContentToMap(content, product);
+            }
         }


Input:
public void testExtendingJavaWithGroovyAndThenJava() {
    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
}

Output:
 public void testExtendingJavaWithGroovyAndThenJava() {
-    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
+    runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
 }


Input:
private boolean isEqualParameters(List params1, List params2) {
    if (params1 == params2)
        return true;
    if (isEqualBasicCol(params1, params2) == false)
        return false;
    Iterator it = params1.iterator();
    Iterator it2 = params2.iterator();
    while (it.hasNext()) {
        IParameterDefinition pd = (IParameterDefinition) it.next();
        IParameterDefinition pd2 = (IParameterDefinition) it2.next();
        if (isEqualParameter(pd, pd2) == false)
            return false;
    }
    return true;
}

Output:
         return true;
-    if (isEqualBasicCol(params1, params2) == false)
+    int basicCol = isEqualBasicCol(params1, params2);
+    if (basicCol == B_TRUE)
+        return true;
+    else if (basicCol == B_FALSE)
         return false;


Input:
public void onReceive(Context context, final Intent intent) {
    final String action = intent.getAction();
    return;
}

Output:
 public void onReceive(Context context, final Intent intent) {
-    final String action = intent.getAction();
-    return;
+    if (intent.getAction().equals(QBServiceConsts.LOGIN_CHAT_COMPOSITE_SUCCESS_ACTION)) {
+        saveOpeningDialogData(true);
+    } else if (intent.getAction().equals(QBServiceConsts.LOGIN_CHAT_COMPOSITE_FAIL_ACTION)) {
+        saveOpeningDialogData(false);
+    }
+    sendNotification();
 }


Input:
public void inject2Store(String fileName, DisconfValue disconfValue) {
    DisconfCenterFile disconfCenterFile = DisconfCenterStore.getInstance().getConfFileMap().get(fileName);
    if (disconfCenterFile == null) {
        LOGGER.error("String_Node_Str" + fileName + "String_Node_Str");
        return;
    }
    if (disconfValue == null || disconfValue.getProperties() == null) {
        LOGGER.error("String_Node_Str", fileName);
        return;
    }
    Map<String, FileItemValue> keMap = disconfCenterFile.getKeyMaps();
    for (String fileItem : keMap.keySet()) {
        Object object = disconfValue.getProperties().get(fileItem);
        if (object == null) {
            LOGGER.error("String_Node_Str", fileItem, disconfValue.getProperties().toString());
            continue;
        }
        try {
            Object value = ClassUtils.getValeByType(keMap.get(fileItem).getField().getType(), (String) object);
            keMap.get(fileItem).setValue(value);
            if (disconfCenterFile.getObject() != null) {
                keMap.get(fileItem).getField().set(disconfCenterFile.getObject(), keMap.get(fileItem).getValue());
            }
        } catch (Exception e) {
            LOGGER.error(e.toString(), e);
        }
    }
}

Output:
         try {
-            Object value = ClassUtils.getValeByType(keMap.get(fileItem).getField().getType(), (String) object);
+            Object value = ClassUtils.getValeByType(keMap.get(fileItem).getField().getType(), object);
             keMap.get(fileItem).setValue(value);


Input:
public static String encodeObject(java.io.Serializable serializableObject, int options) throws java.io.IOException {
    if (serializableObject == null) {
        throw new NullPointerException("String_Node_Str");
    }
    java.io.ByteArrayOutputStream baos = null;
    java.io.OutputStream b64os = null;
    java.io.ObjectOutputStream oos = null;
    try {
        baos = new java.io.ByteArrayOutputStream();
        b64os = new Base64.OutputStream(baos, ENCODE | options);
        oos = new java.io.ObjectOutputStream(b64os);
        oos.writeObject(serializableObject);
    } catch (java.io.IOException e) {
        throw e;
    } finally {
        try {
            oos.close();
        } catch (Exception e) {
        }
        try {
            b64os.close();
        } catch (Exception e) {
        }
        try {
            baos.close();
        } catch (Exception e) {
        }
    }
    try {
        return new String(baos.toByteArray(), PREFERRED_ENCODING);
    } catch (java.io.UnsupportedEncodingException uue) {
        return new String(baos.toByteArray());
    }
}

Output:
         try {
-            oos.close();
-        } catch (Exception e) {
+            if (oos != null) {
+                oos.close();
+            }
+        } catch (Exception ignored) {
         }


Input:
public void registerIcons(IIconRegister iconRegister) {
    iconArray = new IIcon[totalIcons];
    for (int a = 0; a < 10; a++) iconArray[a] = iconRegister.registerIcon("String_Node_Str" + a);
    char c = 'a';
    for (int a = 10; a < 18; a++) iconArray[a] = iconRegister.registerIcon("String_Node_Str" + (c++));
    iconArray[18] = iconRegister.registerIcon("String_Node_Str");
    iconArray[19] = iconRegister.registerIcon("String_Node_Str");
    iconArray[23] = iconRegister.registerIcon("String_Node_Str");
    iconArray[24] = iconRegister.registerIcon("String_Node_Str");
    itemIcon = iconArray[0];
}

Output:
     iconArray[19] = iconRegister.registerIcon("String_Node_Str");
-    iconArray[23] = iconRegister.registerIcon("String_Node_Str");
-    iconArray[24] = iconRegister.registerIcon("String_Node_Str");
+    iconArray[20] = iconRegister.registerIcon("String_Node_Str");
+    iconArray[21] = iconRegister.registerIcon("String_Node_Str");
     itemIcon = iconArray[0];


Input:
public void testWithTinkeyEciesAesCtrHmacAead() throws Exception {
    final String PRIVATE_KEYSET = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    final String PUBLIC_KEYSET = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    HybridDecrypt hybridDecrypt = HybridDecryptFactory.getPrimitive(CleartextKeysetHandle.parseFrom(base64().decode(PRIVATE_KEYSET)));
    HybridEncrypt hybridEncrypt = HybridEncryptFactory.getPrimitive(CleartextKeysetHandle.parseFrom(base64().decode(PUBLIC_KEYSET)));
    byte[] plaintext = Random.randBytes(20);
    byte[] contextInfo = Random.randBytes(20);
    byte[] ciphertext = hybridEncrypt.encrypt(plaintext, contextInfo);
    assertArrayEquals(plaintext, hybridDecrypt.decrypt(ciphertext, contextInfo));
}

Output:
 public void testWithTinkeyEciesAesCtrHmacAead() throws Exception {
-    final String PRIVATE_KEYSET = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
-    final String PUBLIC_KEYSET = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
-    HybridDecrypt hybridDecrypt = HybridDecryptFactory.getPrimitive(CleartextKeysetHandle.parseFrom(base64().decode(PRIVATE_KEYSET)));
-    HybridEncrypt hybridEncrypt = HybridEncryptFactory.getPrimitive(CleartextKeysetHandle.parseFrom(base64().decode(PUBLIC_KEYSET)));
+    final String privateKeyset = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
+    final String publicKeyset = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
+    HybridDecrypt hybridDecrypt = HybridDecryptFactory.getPrimitive(CleartextKeysetHandle.parseFrom(base64().decode(privateKeyset)));
+    HybridEncrypt hybridEncrypt = HybridEncryptFactory.getPrimitive(CleartextKeysetHandle.parseFrom(base64().decode(publicKeyset)));
     byte[] plaintext = Random.randBytes(20);


Input:
public void clear() {
    layeredEffects.clear();
    replacementEffects.clear();
    preventionEffects.clear();
    requirementEffects.clear();
    restrictionEffects.clear();
    asThoughEffects.clear();
    costModificationEffects.clear();
}

Output:
 public void clear() {
-    layeredEffects.clear();
-    replacementEffects.clear();
-    preventionEffects.clear();
-    requirementEffects.clear();
-    restrictionEffects.clear();
-    asThoughEffects.clear();
-    costModificationEffects.clear();
+    for (ContinuousEffectsList effectsList : allEffectsLists) {
+        effectsList.clear();
+    }
 }


Input:
private boolean _matchPort(Port patternPort, Port hostPort) {
    int matchSize = _match.size();
    boolean success = true;
    NamedObj patternContainer = null;
    NamedObj hostContainer = null;
    _match.put(patternPort, hostPort);
    if (!_shallowMatchPort(patternPort, hostPort)) {
        success = false;
    }
    if (success) {
        patternContainer = patternPort.getContainer();
        hostContainer = hostPort.getContainer();
        Object patternObject = _match.get(patternContainer);
        if (patternObject != null && patternObject != hostContainer) {
            success = false;
        } else {
            Object hostMatch = _match.getKey(hostContainer);
            if (hostMatch != null && hostMatch != patternContainer) {
                success = false;
            }
        }
    }
    if (success) {
        ObjectList patternList = new ObjectList();
        patternList.add(patternContainer);
        ObjectList hostList = new ObjectList();
        hostList.add(hostContainer);
        Token collapsingToken = _getAttribute(patternContainer.getContainer(), RelationCollapsingAttribute.class);
        boolean collapsing = collapsingToken == null ? true : ((BooleanToken) collapsingToken).booleanValue();
        if (collapsing) {
            _temporaryMatch.put(patternContainer, hostContainer);
            Path patternPath = new Path(patternPort);
            Set<Relation> visitedRelations = new HashSet<Relation>();
            Set<Port> visitedPorts = new HashSet<Port>();
            boolean foundPath = findFirstPath(patternPort, patternPath, visitedRelations, visitedPorts);
            while (foundPath) {
                patternList.add(patternPath.clone());
                foundPath = findNextPath(patternPath, visitedRelations, visitedPorts);
            }
            Path hostPath = new Path(hostPort);
            visitedRelations = new HashSet<Relation>();
            visitedPorts = new HashSet<Port>();
            foundPath = findFirstPath(hostPort, hostPath, visitedRelations, visitedPorts);
            while (foundPath) {
                hostList.add(hostPath.clone());
                foundPath = findNextPath(hostPath, visitedRelations, visitedPorts);
            }
            _temporaryMatch.remove(patternContainer);
        } else {
            patternList.addAll((Collection<?>) patternPort.linkedRelationList());
            hostList.addAll((Collection<?>) hostPort.linkedRelationList());
        }
        success = _matchObject(patternList, hostList);
    }
    if (!success) {
        _match.retain(matchSize);
    }
    return success;
}

Output:
         hostList.add(hostContainer);
-        Token collapsingToken = _getAttribute(patternContainer.getContainer(), RelationCollapsingAttribute.class);
+        Token collapsingToken = _getAttribute(patternContainer.getContainer(), "String_Node_Str", RelationCollapsingAttribute.class);
         boolean collapsing = collapsingToken == null ? true : ((BooleanToken) collapsingToken).booleanValue();


Input:
static Instance createInstance(int sequenceType, int orientationType, Gesture gesture, String label) {
    float[] pts;
    Instance instance;
    if (sequenceType == GestureLibrary.SEQUENCE_SENSITIVE) {
        pts = temporalSampler(orientationType, gesture);
        instance = new Instance(gesture.getID(), pts, label);
        instance.normalize();
    } else {
        pts = spatialSampler(gesture);
        instance = new Instance(gesture.getID(), pts, label);
    }
    return instance;
}

Output:
     Instance instance;
-    if (sequenceType == GestureLibrary.SEQUENCE_SENSITIVE) {
-        pts = temporalSampler(orientationType, gesture);
+    if (samplingType == GestureLibrary.SEQUENCE_SENSITIVE) {
+        pts = temporalSampler(samplingType, gesture);
         instance = new Instance(gesture.getID(), pts, label);


Input:
private void runShadowProcess(final Property property, final Node inputNode, final IContext selectContext, final IElementParameter switchParam) {
    DatabaseConnection connt = TracesConnectionUtils.createConnection(connParameters);
    String dbmsId = connt.getDbmsId();
    if (dbmsId == null) {
        Shell shell = Display.getCurrent().getActiveShell();
        MessageDialog.openError(shell, "String_Node_Str", "String_Node_Str");
        MappingFileSelectDialog dialog = new MappingFileSelectDialog(shell);
        dialog.open();
        dbmsId = dialog.getSelectId();
    }
    GuessSchemaProcess gsp = new GuessSchemaProcess(property, inputNode, selectContext, memoSQL, info, part.getProcess());
    try {
        List<Integer> indexsForSameNamedColumn = new ArrayList<Integer>();
        CsvArray array = gsp.run();
        List<String[]> schemaContent = array.getRows();
        List<String> columnLabels = new ArrayList<String>();
        if (columns != null) {
            columns.clear();
        }
        if (!schemaContent.isEmpty()) {
            int numbOfColumn = schemaContent.get(0).length;
            for (int i = 1; i <= numbOfColumn; i++) {
                indexsForSameNamedColumn.clear();
                Boolean b = false;
                IMetadataColumn oneColum = new MetadataColumn();
                String labelName = (schemaContent.get(0))[i - 1];
                String name = labelName;
                String sub = "String_Node_Str";
                String sub2 = "String_Node_Str";
                if (labelName != null && labelName.length() > 0 && labelName.startsWith("String_Node_Str")) {
                    sub = labelName.substring(1);
                    if (sub != null && sub.length() > 0) {
                        sub2 = sub.substring(1);
                    }
                }
                if (KeywordsValidator.isKeyword(labelName) || KeywordsValidator.isKeyword(sub) || KeywordsValidator.isKeyword(sub2)) {
                    labelName = "String_Node_Str" + labelName;
                    b = true;
                }
                oneColum.setLabel(MetadataToolHelper.validateColumnName(labelName, i, columnLabels));
                oneColum.setOriginalDbColumnName(name);
                if (schemaContent.size() > 5) {
                    oneColum.setPrecision(Integer.parseInt(schemaContent.get(2)[i - 1]));
                    oneColum.setLength(Integer.parseInt(schemaContent.get(3)[i - 1]));
                }
                try {
                    String talendType = null;
                    if (LanguageManager.getCurrentLanguage() == ECodeLanguage.JAVA) {
                        if (schemaContent.size() >= 5) {
                            talendType = MetadataTalendType.getMappingTypeRetriever(dbmsId).getDefaultSelectedTalendType(schemaContent.get(4)[i - 1]);
                        } else {
                            talendType = JavaTypesManager.STRING.getId();
                        }
                    } else {
                        if (schemaContent.size() >= 5) {
                            talendType = PerlDataTypeHelper.getNewTalendTypeOfValue(schemaContent.get(4)[i - 1]);
                        } else {
                            talendType = PerlTypesManager.STRING;
                        }
                    }
                    oneColum.setTalendType(talendType);
                } catch (Exception e) {
                    ExceptionHandler.process(e);
                }
                oneColum.setNullable((schemaContent.get(1))[i - 1].equals(Boolean.TRUE.toString()) ? true : false);
                columns.add(oneColum);
                columnLabels.add(oneColum.getLabel());
            }
            if (columns.size() > 0) {
                IElementParameter dqRule = elem.getElementParameter("String_Node_Str");
                if (dqRule != null) {
                    ITDQRuleService ruleService = null;
                    try {
                        ruleService = (ITDQRuleService) GlobalServiceRegister.getDefault().getService(ITDQRuleService.class);
                    } catch (RuntimeException e) {
                    }
                    IElementParameter queryParam = elem.getElementParameter("String_Node_Str");
                    if (ruleService != null && queryParam != null) {
                        ruleService.updateOriginalColumnNames(columns, queryParam);
                    }
                }
            }
            IMetadataTable tempMetatable = new MetadataTable();
            if (tempMetatable.getTableName() == null) {
                tempMetatable.setTableName(inputNode.getUniqueName());
            }
            IMetadataTable outputMetaCopy, originaleOutputTable;
            String propertyName = (String) btn.getData(PARAMETER_NAME);
            IElementParameter param = inputNode.getElementParameter(propertyName);
            for (IElementParameter eParam : elem.getElementParameters()) {
                if (eParam.getContext() != null) {
                    param = eParam;
                }
            }
            originaleOutputTable = inputNode.getMetadataFromConnector(param.getContext());
            if (originaleOutputTable != null) {
                outputMetaCopy = originaleOutputTable.clone();
            }
            tempMetatable.setListColumns(columns);
            MetadataDialog metaDialog = new MetadataDialog(composite.getShell(), tempMetatable, inputNode, getCommandStack());
            if (metaDialog != null) {
                metaDialog.setText(Messages.getString("String_Node_Str") + inputNode.getLabel());
            }
            if (metaDialog.open() == MetadataDialog.OK) {
                outputMetaCopy = metaDialog.getOutputMetaData();
                boolean modified = false;
                if (!outputMetaCopy.sameMetadataAs(originaleOutputTable, IMetadataColumn.OPTIONS_NONE)) {
                    modified = true;
                }
                if (modified) {
                    if (switchParam != null) {
                        switchParam.setValue(Boolean.FALSE);
                    }
                    changeMetadataCommand = new ChangeMetadataCommand(inputNode, param, originaleOutputTable, outputMetaCopy);
                }
            }
        }
    } catch (ProcessorException e) {
        ExtractMetaDataUtils.closeConnection();
        final String strExcepton = e.getMessage();
        Display.getDefault().asyncExec(new Runnable() {
            public void run() {
                MessageDialog.openWarning(composite.getShell(), Messages.getString("String_Node_Str"), strExcepton);
            }
        });
        ExceptionHandler.process(e);
    }
}

Output:
     } catch (ProcessorException e) {
-        ExtractMetaDataUtils.closeConnection();
+        ExtractMetaDataUtils.getInstance().closeConnection();
         final String strExcepton = e.getMessage();


Input:
private Interval<T> getIntervalUpperSnap(IndexNode index, DataTypeWithRatioScale<T> type, T tValue) {
    int shift = (int) Math.floor(type.ratio(type.subtract(tValue, index.min), type.subtract(index.max, index.min)));
    T offset = type.multiply(type.subtract(index.max, index.min), shift);
    T value = type.subtract(tValue, offset);
    Interval<T> interval = null;
    for (int j = 0; j < intervals.size(); j++) {
        Interval<T> i = intervals.get(j);
        if (type.compare(i.min, value) <= 0 && type.compare(i.max, value) > 0) {
            if (type.compare(value, i.min) == 0) {
                if (j > 0) {
                    interval = intervals.get(j - 1);
                    break;
                } else {
                    interval = intervals.get(intervals.size() - 1);
                    offset = type.multiply(type.subtract(index.max, index.min), shift - 1);
                    break;
                }
            } else {
                interval = i;
                break;
            }
        }
    }
    if (interval == null && intervals.size() == 1) {
        interval = intervals.get(0);
    }
    if (interval == null) {
        throw new IllegalStateException("String_Node_Str");
    }
    T lower = type.add(interval.min, offset);
    T upper = type.add(interval.max, offset);
    return new Interval<T>(this, (DataType<T>) type, lower, upper, interval.function);
}

Output:
 private Interval<T> getIntervalUpperSnap(IndexNode index, DataTypeWithRatioScale<T> type, T tValue) {
-    int shift = (int) Math.floor(type.ratio(type.subtract(tValue, index.min), type.subtract(index.max, index.min)));
+    double shift = Math.floor(type.ratio(type.subtract(tValue, index.min), type.subtract(index.max, index.min)));
     T offset = type.multiply(type.subtract(index.max, index.min), shift);


Input:
private void addDevice(String deviceId) throws IoTFCReSTException {
    try {
        String deviceToBeAdded = "String_Node_Str" + deviceId + "String_Node_Str";
        System.out.println(deviceToBeAdded);
        JsonParser parser = new JsonParser();
        JsonElement input = parser.parse(deviceToBeAdded);
        JsonObject response = this.apiClient.registerDeviceUnderGateway(DEVICE_TYPE, this.mgdGateway.getGWDeviceId(), this.mgdGateway.getGWTypeId(), input);
        System.out.println(response);
    } catch (IoTFCReSTException e) {
        if (e.getHttpCode() != 409) {
            System.out.println("String_Node_Str" + e.getHttpCode() + "String_Node_Str" + e.getMessage());
            System.out.println(e.getResponse());
        }
    }
}

Output:
         JsonElement input = parser.parse(deviceToBeAdded);
-        JsonObject response = this.apiClient.registerDeviceUnderGateway(DEVICE_TYPE, this.mgdGateway.getGWDeviceId(), this.mgdGateway.getGWTypeId(), input);
+        JsonObject response = this.apiClient.registerDeviceUnderGateway(deviceType, this.mgdGateway.getGWDeviceId(), this.mgdGateway.getGWTypeId(), input);
         System.out.println(response);


Input:
protected void update(List<TableInfo> tableInfos) {
    for (TableInfo tableInfo : tableInfos) {
        DBObject options = setCollectionProperties(tableInfo);
        getDBName();
        DB db = mongo.getDB(databaseName);
        DBCollection collection = null;
        if (!db.collectionExists(tableInfo.getTableName())) {
            collection = db.createCollection(tableInfo.getTableName(), options);
        }
        collection = collection != null ? collection : db.getCollection(tableInfo.getTableName());
        boolean isCappedCollection = isCappedCollection(tableInfo);
        if (tableInfo.isIndexable() && !isCappedCollection) {
            createIndexes(tableInfo, collection);
        }
    }
}

Output:
         boolean isCappedCollection = isCappedCollection(tableInfo);
-        if (tableInfo.isIndexable() && !isCappedCollection) {
+        if (!isCappedCollection) {
             createIndexes(tableInfo, collection);


Input:
public void setActivePart(IAction action, IWorkbenchPart targetPart) {
    m_shell = targetPart.getSite().getShell();
    m_projectLocation = getCurrectProjectLocation(targetPart);
}

Output:
     m_shell = targetPart.getSite().getShell();
-    m_projectLocation = getCurrectProjectLocation(targetPart);
+    m_projectLocation = getCurrentProjectLocation(targetPart);
 }


Input:
public org.hl7.fhir.dstu2.model.TestScript.TestScriptTeardownComponent convertTestScriptTeardownComponent(org.hl7.fhir.dstu3.model.TestScript.TestScriptTeardownComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.TestScript.TestScriptTeardownComponent tgt = new org.hl7.fhir.dstu2.model.TestScript.TestScriptTeardownComponent();
    copyElement(src, tgt);
    for (org.hl7.fhir.dstu3.model.TestScript.TeardownActionComponent t : src.getAction()) tgt.addAction(convertTeardownActionComponent(t));
    return tgt;
}

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


Input:
public Location call() throws Exception {
    ProgramType type = ProgramTypes.fromSpecification(spec);
    String name = String.format(Locale.ENGLISH, "String_Node_Str", applicationName, type);
    Location programDir = newOutputDir.append(name);
    if (!programDir.exists()) {
        programDir.mkdirs();
    }
    Location output = programDir.append(String.format("String_Node_Str", spec.getName()));
    return ProgramBundle.create(input.getId(), bundler, output, spec.getName(), spec.getClassName(), type, appSpec);
}

Output:
     String name = String.format(Locale.ENGLISH, "String_Node_Str", applicationName, type);
-    Location programDir = newOutputDir.append(name);
+    Location programDir = appFabricDir.append(name);
     if (!programDir.exists()) {


Input:
public void pickSuggestionManually(int index, CharSequence suggestion) {
    SuggestedWords suggestions = mCandidateView.getSuggestions();
    mVoiceProxy.flushAndLogAllTextModificationCounters(index, suggestion, mWordSeparators);
    final boolean recorrecting = TextEntryState.isRecorrecting();
    InputConnection ic = getCurrentInputConnection();
    if (ic != null) {
        ic.beginBatchEdit();
    }
    if (mApplicationSpecifiedCompletionOn && mApplicationSpecifiedCompletions != null && index >= 0 && index < mApplicationSpecifiedCompletions.length) {
        CompletionInfo ci = mApplicationSpecifiedCompletions[index];
        if (ic != null) {
            ic.commitCompletion(ci);
        }
        mCommittedLength = suggestion.length();
        if (mCandidateView != null) {
            mCandidateView.clear();
        }
        mKeyboardSwitcher.updateShiftState();
        if (ic != null) {
            ic.endBatchEdit();
        }
        return;
    }
    if (suggestion.length() == 1 && (isWordSeparator(suggestion.charAt(0)) || isSuggestedPunctuation(suggestion.charAt(0)))) {
        LatinImeLogger.logOnManualSuggestion("String_Node_Str", suggestion.toString(), index, suggestions.mWords);
        final char primaryCode = suggestion.charAt(0);
        final int toLeft = (ic == null) ? 0 : ic.getTextBeforeCursor(1, 0).charAt(0);
        if (Keyboard.CODE_SPACE == toLeft)
            mJustAddedMagicSpace = true;
        onCodeInput(primaryCode, new int[] { primaryCode }, KeyboardActionListener.NOT_A_TOUCH_COORDINATE, KeyboardActionListener.NOT_A_TOUCH_COORDINATE);
        mJustAddedMagicSpace = false;
        if (ic != null) {
            ic.endBatchEdit();
        }
        return;
    }
    if (!mHasUncommittedTypedChars) {
        mWord.reset();
    }
    mJustAccepted = true;
    pickSuggestion(suggestion);
    if (index == 0) {
        addToAutoAndUserBigramDictionaries(suggestion, AutoDictionary.FREQUENCY_FOR_PICKED);
    } else {
        addToOnlyBigramDictionary(suggestion, 1);
    }
    LatinImeLogger.logOnManualSuggestion(mComposing.toString(), suggestion.toString(), index, suggestions.mWords);
    TextEntryState.acceptedSuggestion(mComposing.toString(), suggestion);
    if (mShouldInsertMagicSpace && !recorrecting) {
        sendMagicSpace();
    }
    final boolean showingAddToDictionaryHint = index == 0 && mSuggest != null && (!mHasDictionary || !AutoCorrection.isValidWord(mSuggest.getUnigramDictionaries(), suggestion, true));
    if (!recorrecting) {
        TextEntryState.typedCharacter((char) Keyboard.CODE_SPACE, true, WordComposer.NOT_A_COORDINATE, WordComposer.NOT_A_COORDINATE);
    } else if (!showingAddToDictionaryHint) {
        clearSuggestions();
        mHandler.postUpdateOldSuggestions();
    }
    if (showingAddToDictionaryHint) {
        mCandidateView.showAddToDictionaryHint(suggestion);
    }
    if (ic != null) {
        ic.endBatchEdit();
    }
}

Output:
         onCodeInput(primaryCode, new int[] { primaryCode }, KeyboardActionListener.NOT_A_TOUCH_COORDINATE, KeyboardActionListener.NOT_A_TOUCH_COORDINATE);
-        mJustAddedMagicSpace = false;
+        mJustAddedMagicSpace = oldMagicSpace;
         if (ic != null) {


Input:
public boolean equals(Object o) {
    if (this == o)
        return true;
    if (o == null || !(o instanceof XMLElement))
        return false;
    final XMLElement that = (XMLElement) o;
    if (attributes != null ? !attributes.equals(that.attributes) : that.attributes != null)
        return false;
    if (innerFragments != null ? !innerFragments.equals(that.innerFragments) : that.innerFragments != null) {
        return false;
    }
    if (name != null ? !name.equals(that.name) : that.name != null)
        return false;
    if (namespacePrefix != null ? !namespacePrefix.equals(that.namespacePrefix) : that.namespacePrefix != null)
        return false;
    return true;
}

Output:
     final XMLElement that = (XMLElement) o;
-    if (attributes != null ? !attributes.equals(that.attributes) : that.attributes != null)
+    if (attributes != null && that.attributes != null) {
+        if (attributes.size() != that.attributes.size())
+            return false;
+        for (Attribute attribute : attributes) {
+            boolean found = false;
+            for (Attribute thatAttribute : that.attributes) {
+                if (thatAttribute.equals(attribute)) {
+                    found = true;
+                    break;
+                }
+            }
+            if (!found)
+                return false;
+        }
+    } else if (attributes == null && that.attributes == null) {
+    } else {
         return false;


Input:
private List<EvaluatedAxiom> buildBestAxioms(Map<Individual, Set<NamedClass>> individual2Types) {
    List<EvaluatedAxiom> axioms = new ArrayList<EvaluatedAxiom>();
    Map<NamedClass, Integer> result = new HashMap<NamedClass, Integer>();
    for (Entry<Individual, Set<NamedClass>> entry : individual2Types.entrySet()) {
        for (NamedClass nc : entry.getValue()) {
            Integer cnt = result.get(nc);
            if (cnt == null) {
                cnt = Integer.valueOf(1);
            }
            result.put(nc, Integer.valueOf(cnt + 1));
        }
    }
    EvaluatedAxiom evalAxiom;
    for (Entry<NamedClass, Integer> entry : sortByValues(result)) {
        evalAxiom = new EvaluatedAxiom(new ObjectPropertyRangeAxiom(propertyToDescribe, entry.getKey()), new AxiomScore(entry.getValue() / (double) individual2Types.keySet().size()));
        axioms.add(evalAxiom);
    }
    return axioms;
}

Output:
             }
-            result.put(nc, Integer.valueOf(cnt + 1));
+            result.put(nc, cnt);
         }


Input:
public void run() {
    Collection<ConceptStepImpl> conceptSteps = getConceptSteps(searchParameters.getElementToSearch(), searchParameters.getScopeDeterminedByUser().getDisplayName());
    Collection<SpecStep> specSteps = getSpecSteps(searchParameters.getElementToSearch(), searchParameters.getScopeDeterminedByUser().getDisplayName());
    Class<? extends PsiElement> elementClass = searchParameters.getElementToSearch().getClass();
    if (elementClass.equals(ConceptStepImpl.class))
        handleConceptStep(conceptSteps, specSteps, searchParameters, processor);
    else if (elementClass.equals(PsiAnnotationImpl.class) || elementClass.equals(PsiMethodImpl.class))
        handleAnnotation(conceptSteps, specSteps, searchParameters, processor);
    else if (elementClass.equals(SpecStepImpl.class))
        handleSpecStep(conceptSteps, specSteps, searchParameters, processor);
}

Output:
 public void run() {
-    Collection<ConceptStepImpl> conceptSteps = getConceptSteps(searchParameters.getElementToSearch(), searchParameters.getScopeDeterminedByUser().getDisplayName());
-    Collection<SpecStep> specSteps = getSpecSteps(searchParameters.getElementToSearch(), searchParameters.getScopeDeterminedByUser().getDisplayName());
+    Collection<ConceptStepImpl> conceptSteps = getConceptSteps(searchParameters.getElementToSearch());
+    Collection<SpecStep> specSteps = getSpecSteps(searchParameters.getElementToSearch());
     Class<? extends PsiElement> elementClass = searchParameters.getElementToSearch().getClass();


Input:
public void shouldSetMapping() throws Exception {
    final DatasetManifest manifest = new DatasetManifest("String_Node_Str", "String_Node_Str", asList(new DatasetManifest.Part("String_Node_Str", "String_Node_Str", asList("String_Node_Str"), 1, null), new DatasetManifest.Part("String_Node_Str", "String_Node_Str", asList("String_Node_Str"), 1, null)));
    manifest.setMapping("String_Node_Str", "String_Node_Str");
    manifest.setMapping("String_Node_Str", "String_Node_Str");
    assertThat(manifest.getParts().get(0).getColumnName(), is("String_Node_Str"));
    assertThat(manifest.getParts().get(1).getColumnName(), is("String_Node_Str"));
}

Output:
 public void shouldSetMapping() throws Exception {
-    final DatasetManifest manifest = new DatasetManifest("String_Node_Str", "String_Node_Str", asList(new DatasetManifest.Part("String_Node_Str", "String_Node_Str", asList("String_Node_Str"), 1, null), new DatasetManifest.Part("String_Node_Str", "String_Node_Str", asList("String_Node_Str"), 1, null)));
+    final DatasetManifest manifest = new DatasetManifest("String_Node_Str", "String_Node_Str", asList(new DatasetManifest.Part("String_Node_Str", "String_Node_Str", asList("String_Node_Str"), true, null), new DatasetManifest.Part("String_Node_Str", "String_Node_Str", asList("String_Node_Str"), true, null)));
     manifest.setMapping("String_Node_Str", "String_Node_Str");


Input:
public static void show(String content) {
    if (toast == null) {
        toast = Toast.makeText(App.getAppContetxt(), content, Toast.LENGTH_SHORT);
    } else {
        toast.setText(content);
    }
    toast.show();
}

Output:
     if (toast == null) {
-        toast = Toast.makeText(App.getAppContetxt(), content, Toast.LENGTH_SHORT);
+        toast = Toast.makeText(App.getAppContext(), content, Toast.LENGTH_SHORT);
     } else {