Input:
private ArrayList<LayoutElementParcelable> listRecentFiles() {
    ArrayList<LayoutElementParcelable> songs = new ArrayList<>();
    final String[] projection = { MediaStore.Files.FileColumns.DATA, MediaStore.Files.FileColumns.DATE_MODIFIED };
    Calendar c = Calendar.getInstance();
    c.set(Calendar.DAY_OF_YEAR, c.get(Calendar.DAY_OF_YEAR) - 2);
    Date d = c.getTime();
    Cursor cursor = this.c.getContentResolver().query(MediaStore.Files.getContentUri("String_Node_Str"), projection, null, null, null);
    if (cursor == null)
        return songs;
    if (cursor.getCount() > 0 && cursor.moveToFirst()) {
        do {
            String path = cursor.getString(cursor.getColumnIndex(MediaStore.Files.FileColumns.DATA));
            File f = new File(path);
            if (d.compareTo(new Date(f.lastModified())) != 1 && !f.isDirectory()) {
                HybridFileParcelable strings = RootHelper.generateBaseFile(new File(path), showHiddenFiles);
                if (strings != null) {
                    LayoutElementParcelable parcelable = createListParcelables(strings);
                    if (parcelable != null)
                        songs.add(parcelable);
                }
            }
        } while (cursor.moveToNext());
    }
    cursor.close();
    Collections.sort(songs, (lhs, rhs) -> -1 * Long.valueOf(lhs.date).compareTo(rhs.date));
    if (songs.size() > 20)
        for (int i = songs.size() - 1; i > 20; i--) {
            songs.remove(i);
        }
    return songs;
}

Output:
 private ArrayList<LayoutElementParcelable> listRecentFiles() {
-    ArrayList<LayoutElementParcelable> songs = new ArrayList<>();
+    ArrayList<LayoutElementParcelable> recentFiles = new ArrayList<>();
     final String[] projection = { MediaStore.Files.FileColumns.DATA, MediaStore.Files.FileColumns.DATE_MODIFIED };


Input:
private void processSETTINGSFrame() {
    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
        Tr.debug(tc, "String_Node_Str");
    }
    if (!connection_preface_settings_rcvd && !((FrameSettings) currentFrame).flagAckSet()) {
        connection_preface_settings_rcvd = true;
    }
    if (((FrameSettings) currentFrame).flagAckSet()) {
        if (!connection_preface_settings_ack_rcvd) {
            connection_preface_settings_ack_rcvd = true;
        }
    } else {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "String_Node_Str");
        }
        if (((FrameSettings) currentFrame).getInitialWindowSize() != -1) {
            int newSize = ((FrameSettings) currentFrame).getInitialWindowSize();
            muxLink.changeInitialWindowSizeAllStreams(newSize);
        }
        muxLink.getConnectionSettings().updateSettings((FrameSettings) currentFrame);
        currentFrame = new FrameSettings();
        currentFrame.setAckFlag();
        try {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "String_Node_Str" + myID + "String_Node_Str" + currentFrame.getFrameType().toString() + "String_Node_Str" + Direction.WRITING_OUT + "String_Node_Str" + muxLink.hashCode());
            }
            writeFrameSync();
        } catch (FlowControlException e) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "String_Node_Str" + e);
            }
        }
    }
    if (connection_preface_settings_rcvd && connection_preface_settings_ack_rcvd) {
        if (muxLink.checkInitAndOpen()) {
            muxLink.initLock.countDown();
        }
    }
}

Output:
     if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
-        Tr.debug(tc, "String_Node_Str");
+        Tr.debug(tc, "String_Node_Str" + currentFrame.toString());
     }


Input:
public ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {
    List<ICompletionProposal> proposals = new ArrayList<ICompletionProposal>();
    if (keyWordProvider != null) {
        String[] keyWords = keyWordProvider.getCurrentKeyWords();
        if (keyWords != null) {
            for (int i = 0; i < keyWords.length; i++) {
                String entityName = keyWords[i];
                String replacementString = "String_Node_Str" + entityName + "String_Node_Str" + entityName + "String_Node_Str";
                CompletionProposal proposal = new CompletionProposal(replacementString, offset - 1, 1, entityName.length() + 2);
                proposals.add(proposal);
            }
        }
    }
    return proposals.toArray(new ICompletionProposal[0]);
}

Output:
     if (keyWordProvider != null) {
-        String[] keyWords = keyWordProvider.getCurrentKeyWords();
-        if (keyWords != null) {
-            for (int i = 0; i < keyWords.length; i++) {
-                String entityName = keyWords[i];
-                String replacementString = "String_Node_Str" + entityName + "String_Node_Str" + entityName + "String_Node_Str";
-                CompletionProposal proposal = new CompletionProposal(replacementString, offset - 1, 1, entityName.length() + 2);
-                proposals.add(proposal);
+        IDocument document = viewer.getDocument();
+        int start = getInputPos(document, offset);
+        String input = null;
+        if (start > 0) {
+            try {
+                input = document.get(start, offset - start);
+            } catch (BadLocationException e) {
+            }
+        }
+        if (input != null) {
+            String[] keyWords = keyWordProvider.getCurrentKeyWords();
+            int len = offset - start;
+            if (keyWords != null) {
+                boolean showAll = input.length() == 0;
+                for (int i = 0; i < keyWords.length; i++) {
+                    String entityName = keyWords[i];
+                    if (showAll || entityName.toLowerCase().startsWith(input)) {
+                        String replacementString = START + entityName + "String_Node_Str" + entityName + "String_Node_Str";
+                        CompletionProposal proposal = new CompletionProposal(replacementString, offset - len - 1, len + 1, entityName.length() + 2);
+                        proposals.add(proposal);
+                    }
+                }
             }


Input:
public void onDetonate(ExplosionEvent.Detonate event) {
    Explosion explosion = event.getExplosion();
    Vec3d explosionVector = explosion.getPosition();
    Collection<GlobalCoordinate> protectors = BlockProtectors.getProtectors(event.getWorld().provider.getDimension(), (int) explosionVector.xCoord, (int) explosionVector.yCoord, (int) explosionVector.zCoord);
    if (protectors.isEmpty()) {
        return;
    }
    List<BlockPos> affectedBlocks = event.getAffectedBlocks();
    List<BlockPos> toremove = new ArrayList<>();
    int rf = 0;
    for (GlobalCoordinate protector : protectors) {
        BlockPos pos = protector.getCoordinate();
        TileEntity te = event.getWorld().getTileEntity(pos);
        if (te instanceof BlockProtectorTileEntity) {
            BlockProtectorTileEntity blockProtectorTileEntity = (BlockProtectorTileEntity) te;
            for (BlockPos block : affectedBlocks) {
                BlockPos relative = blockProtectorTileEntity.absoluteToRelative(block);
                boolean b = blockProtectorTileEntity.isProtected(relative);
                if (b) {
                    Vec3d blockVector = new Vec3d(block);
                    double distanceTo = explosionVector.distanceTo(blockVector);
                    int rfneeded = blockProtectorTileEntity.attemptExplosionProtection((float) (distanceTo / explosion.explosionSize), explosion.explosionSize);
                    if (rfneeded > 0) {
                        toremove.add(block);
                        rf += rfneeded;
                    } else {
                        blockProtectorTileEntity.removeProtection(relative);
                    }
                }
            }
        }
    }
    affectedBlocks.removeAll(toremove);
}

Output:
     Vec3d explosionVector = explosion.getPosition();
-    Collection<GlobalCoordinate> protectors = BlockProtectors.getProtectors(event.getWorld().provider.getDimension(), (int) explosionVector.xCoord, (int) explosionVector.yCoord, (int) explosionVector.zCoord);
+    Collection<GlobalCoordinate> protectors = BlockProtectors.getProtectors(event.getWorld(), (int) explosionVector.xCoord, (int) explosionVector.yCoord, (int) explosionVector.zCoord);
     if (protectors.isEmpty()) {


Input:
public boolean equalsDeep(Base other) {
    return other == this;
}

Output:
 public boolean equalsDeep(Base other) {
-    return other == this;
+    return other != null;
 }


Input:
private Object manufactureAttributeValue(Object pojo, Map<Class<?>, Integer> pojos, Class<?> attributeType, Type genericAttributeType, List<Annotation> annotations, String attributeName, Map<String, Type> typeArgsMap, Type... genericTypeArgs) throws InstantiationException, IllegalAccessException, InvocationTargetException, ClassNotFoundException {
    Object attributeValue = null;
    Class<?> realAttributeType;
    if (Object.class.equals(attributeType) && attributeType != genericAttributeType) {
        AtomicReference<Type[]> elementGenericTypeArgs = new AtomicReference<Type[]>(NO_TYPES);
        realAttributeType = resolveGenericParameter(genericAttributeType, typeArgsMap, elementGenericTypeArgs);
    } else {
        realAttributeType = attributeType;
    }
    AttributeMetadata attributeMetadata = new AttributeMetadata(attributeName, realAttributeType, annotations, pojo.getClass());
    if (realAttributeType.isPrimitive()) {
        attributeValue = resolvePrimitiveValue(realAttributeType, annotations, attributeMetadata);
    } else if (isWrapper(realAttributeType)) {
        attributeValue = resolveWrapperValue(realAttributeType, annotations, attributeMetadata);
    } else if (realAttributeType.equals(String.class)) {
        attributeValue = resolveStringValue(annotations, attributeMetadata);
    } else if (realAttributeType.isArray()) {
        attributeValue = resolveArrayElementValue(realAttributeType, genericAttributeType, pojos, annotations, pojo, attributeName, typeArgsMap);
    } else if (Collection.class.isAssignableFrom(realAttributeType)) {
        attributeValue = resolveCollectionValueWhenCollectionIsPojoAttribute(pojo, pojos, realAttributeType, attributeName, annotations, typeArgsMap, genericTypeArgs);
    } else if (Map.class.isAssignableFrom(realAttributeType)) {
        attributeValue = resolveMapValueWhenMapIsPojoAttribute(pojo, pojos, realAttributeType, attributeName, annotations, typeArgsMap, genericTypeArgs);
    } else if (realAttributeType.isEnum()) {
        int enumConstantsLength = realAttributeType.getEnumConstants().length;
        if (enumConstantsLength > 0) {
            int enumIndex = strategy.getIntegerInRange(0, enumConstantsLength, attributeMetadata) % enumConstantsLength;
            attributeValue = realAttributeType.getEnumConstants()[enumIndex];
        }
    } else if (Type.class.isAssignableFrom(realAttributeType)) {
        if (genericTypeArgs.length > 0 && genericTypeArgs[0] != null) {
            AtomicReference<Type[]> elementGenericTypeArgs = new AtomicReference<Type[]>(NO_TYPES);
            attributeValue = resolveGenericParameter(genericTypeArgs[0], typeArgsMap, elementGenericTypeArgs);
        } else {
            LOG.error("String_Node_Str", genericAttributeType, typeArgsMap, Arrays.toString(genericTypeArgs));
        }
    }
    if (attributeValue == null) {
        TypeVariable<?>[] typeParams = attributeType.getTypeParameters();
        List<Type> resolvedTypes = new ArrayList<Type>();
        for (int i = 0; i < typeParams.length; i++) {
            Type type = typeArgsMap.get(typeParams[i].getName());
            if (type != null) {
                resolvedTypes.add(type);
            }
        }
        Type[] genericTypeArgsAll = mergeTypeArrays(resolvedTypes.toArray(new Type[resolvedTypes.size()]), genericTypeArgs);
        Integer depth = pojos.get(realAttributeType);
        if (depth == null) {
            depth = -1;
        }
        if (depth <= strategy.getMaxDepth(pojo.getClass())) {
            pojos.put(realAttributeType, depth + 1);
            attributeValue = this.manufacturePojoInternal(realAttributeType, pojos, genericTypeArgsAll);
            pojos.put(realAttributeType, depth);
        } else {
            LOG.warn("String_Node_Str", realAttributeType);
            attributeValue = externalFactory.manufacturePojo(realAttributeType, genericTypeArgsAll);
        }
    }
    return attributeValue;
}

Output:
         TypeVariable<?>[] typeParams = attributeType.getTypeParameters();
-        List<Type> resolvedTypes = new ArrayList<Type>();
-        for (int i = 0; i < typeParams.length; i++) {
-            Type type = typeArgsMap.get(typeParams[i].getName());
-            if (type != null) {
-                resolvedTypes.add(type);
-            }
-        }
-        Type[] genericTypeArgsAll = mergeTypeArrays(resolvedTypes.toArray(new Type[resolvedTypes.size()]), genericTypeArgs);
+        Type[] genericTypeArgsAll = mergeActualAndSuppliedGenericTypes(typeParams, genericTypeArgs, typeArgsMap);
         Integer depth = pojos.get(realAttributeType);


Input:
public void addReplyOnATicket(final String cancelTag, final String message, final HSUploadAttachment[] attachments, final HSTicket ticket, final HSUser user, RequestQueue queue, final OnFetchedSuccessListener successListener, ErrorListener errorListener) {
    if (attachments != null && attachments.length > 0) {
        addReplyToTicketWithAttachment(cancelTag, ticket, user, message, attachments, queue, successListener, errorListener);
    } else {
        addReplyToTicket(cancelTag, ticket, user, message, null, queue, successListener, errorListener);
    }
}

Output:
     } else {
-        addReplyToTicket(cancelTag, ticket, user, message, null, queue, successListener, errorListener);
+        addReplyToTicket(cancelTag, ticket, user, message, null, null, queue, successListener, errorListener);
     }


Input:
void setVisibilityAndLicense(InputFile inputFile, RuleVisibility visibility, License license) {
    String filename = inputFile.getName();
    Target cacheInstance = targets.get(filename);
    if (!(cacheInstance instanceof InputFile)) {
        throw new IllegalArgumentException("String_Node_Str" + filename + "String_Node_Str" + pkg.getName() + "String_Node_Str");
    }
    if (!((InputFile) cacheInstance).isVisibilitySpecified() || cacheInstance.getVisibility() != visibility || cacheInstance.getLicense() != license) {
        targets.put(filename, new InputFile(pkg, cacheInstance.getLabel(), cacheInstance.getLocation(), visibility, license));
    }
}

Output:
     }
-    if (!((InputFile) cacheInstance).isVisibilitySpecified() || cacheInstance.getVisibility() != visibility || cacheInstance.getLicense() != license) {
+    if (!((InputFile) cacheInstance).isVisibilitySpecified() || cacheInstance.getVisibility() != visibility || !Objects.equals(cacheInstance.getLicense(), license)) {
         targets.put(filename, new InputFile(pkg, cacheInstance.getLabel(), cacheInstance.getLocation(), visibility, license));


Input:
public void chartBuildFromCsv(String csvFile, String imagesDir, String imageTarget, String chartType, String options) {
    if (Objects.isNull(imageTarget) || Objects.isNull(chartType))
        return;
    getCurrent().currentPath().map(Path::getParent).ifPresent(root -> {
        threadService.runTaskLater(() -> {
            String csvContent = IOHelper.readFile(root.resolve(csvFile));
            threadService.runActionLater(() -> {
                try {
                    Map<String, String> optMap = parseChartOptions(options);
                    optMap.put("String_Node_Str", csvFile);
                    chartProvider.getProvider(chartType).chartBuild(csvContent, imagesDir, imageTarget, optMap);
                } catch (Exception e) {
                    logger.info(e.getMessage(), e);
                }
            });
        });
    });
}

Output:
 public void chartBuildFromCsv(String csvFile, String imagesDir, String imageTarget, String chartType, String options) {
-    if (Objects.isNull(imageTarget) || Objects.isNull(chartType))
-        return;
-    getCurrent().currentPath().map(Path::getParent).ifPresent(root -> {
-        threadService.runTaskLater(() -> {
-            String csvContent = IOHelper.readFile(root.resolve(csvFile));
-            threadService.runActionLater(() -> {
-                try {
-                    Map<String, String> optMap = parseChartOptions(options);
-                    optMap.put("String_Node_Str", csvFile);
-                    chartProvider.getProvider(chartType).chartBuild(csvContent, imagesDir, imageTarget, optMap);
-                } catch (Exception e) {
-                    logger.info(e.getMessage(), e);
-                }
+    threadService.runActionLater(() -> {
+        if (Objects.isNull(imageTarget) || Objects.isNull(chartType))
+            return;
+        current.currentPath().map(Path::getParent).ifPresent(root -> {
+            threadService.runTaskLater(() -> {
+                String csvContent = IOHelper.readFile(root.resolve(csvFile));
+                threadService.runActionLater(() -> {
+                    try {
+                        Map<String, String> optMap = parseChartOptions(options);
+                        optMap.put("String_Node_Str", csvFile);
+                        chartProvider.getProvider(chartType).chartBuild(csvContent, imagesDir, imageTarget, optMap);
+                    } catch (Exception e) {
+                        logger.info(e.getMessage(), e);
+                    }
+                });
             });


Input:
public void testSkipInstrument() throws Exception {
    FileInfo lcov = new FileInfo("String_Node_Str", 0, -1, true, false, "String_Node_Str");
    FileInfo serveOnly = new FileInfo("String_Node_Str", 0, -1, true, true, "String_Node_Str");
    FileInfo excluded = new FileInfo("String_Node_Str", 0, -1, true, false, "String_Node_Str");
    FileInfo remote = new FileInfo("String_Node_Str", 0, -1, true, false, null);
    CoverageInstrumentingProcessor processor = new CoverageInstrumentingProcessor(null, Sets.<String>newHashSet(excluded.getFilePath()), null);
    assertSame(lcov, processor.process(lcov));
    assertSame(serveOnly, processor.process(serveOnly));
    assertSame(remote, processor.process(remote));
    assertSame(excluded, processor.process(excluded));
}

Output:
     FileInfo remote = new FileInfo("String_Node_Str", 0, -1, true, false, null);
-    CoverageInstrumentingProcessor processor = new CoverageInstrumentingProcessor(null, Sets.<String>newHashSet(excluded.getFilePath()), null);
+    CoverageInstrumentingProcessor processor = new CoverageInstrumentingProcessor(null, Sets.<String>newHashSet(excluded.getFilePath()), null, new MockTime(0));
     assertSame(lcov, processor.process(lcov));


Input:
public Integer call(Object object) throws Exception {
    DateTime dt = Utils.toDateTimeObject((String) object);
    if (dt != null) {
        return Integer.parseInt(dt.year().getAsString());
    } else {
        return null;
    }
}

Output:
 public Integer call(Object object) throws Exception {
-    DateTime dt = Utils.toDateTimeObject((String) object);
+    DateTime dt = Utils.toDateTimeObject(object);
     if (dt != null) {


Input:
private static JPanel createSensitivityPanel(final ConfigurationPart dataContext) {
    JPanel panel = new JPanel(new GridBagLayout());
    GridBagConstraints gridConstraints = new GridBagConstraints();
    gridConstraints.fill = GridBagConstraints.HORIZONTAL;
    gridConstraints.insets = new Insets(5, 0, 0, 0);
    gridConstraints.weightx = 1;
    gridConstraints.gridy = 0;
    panel.add(new JLabel("String_Node_Str"), gridConstraints);
    final JSlider lookHorizontalSlider = new JSlider();
    lookHorizontalSlider.setMajorTickSpacing(5);
    lookHorizontalSlider.setMinorTickSpacing(1);
    lookHorizontalSlider.setPaintTicks(true);
    lookHorizontalSlider.setPaintLabels(true);
    lookHorizontalSlider.setSnapToTicks(true);
    lookHorizontalSlider.setValue(dataContext.getMouseMode1SensitivityX());
    lookHorizontalSlider.setMinimum(0);
    lookHorizontalSlider.setMaximum(40);
    lookHorizontalSlider.addChangeListener(new ChangeListener() {
        public void stateChanged(ChangeEvent e) {
            dataContext.setMouseMode1SensitivityX(lookHorizontalSlider.getValue());
        }
    });
    gridConstraints.gridy = 1;
    panel.add(lookHorizontalSlider, gridConstraints);
    final JSlider lookVerticalSlider = new JSlider();
    lookVerticalSlider.setMajorTickSpacing(5);
    lookVerticalSlider.setMinorTickSpacing(1);
    lookVerticalSlider.setPaintTicks(true);
    lookVerticalSlider.setPaintLabels(true);
    lookVerticalSlider.setSnapToTicks(true);
    lookVerticalSlider.setValue(dataContext.getMouseMode1SensitivityY());
    lookVerticalSlider.setMinimum(0);
    lookVerticalSlider.setMaximum(40);
    lookVerticalSlider.addChangeListener(new ChangeListener() {
        public void stateChanged(ChangeEvent e) {
            dataContext.setMouseMode1SensitivityY(lookVerticalSlider.getValue());
        }
    });
    gridConstraints.gridy = 2;
    panel.add(lookVerticalSlider, gridConstraints);
    gridConstraints.gridy = 3;
    panel.add(new JLabel("String_Node_Str"), gridConstraints);
    final JSlider lookMouseHorizontalSlider = new JSlider();
    lookMouseHorizontalSlider.setMajorTickSpacing(5);
    lookMouseHorizontalSlider.setMinorTickSpacing(1);
    lookMouseHorizontalSlider.setPaintTicks(true);
    lookMouseHorizontalSlider.setPaintLabels(true);
    lookMouseHorizontalSlider.setSnapToTicks(true);
    lookMouseHorizontalSlider.setMinimum(1);
    lookMouseHorizontalSlider.setMaximum(40);
    lookMouseHorizontalSlider.addChangeListener(new ChangeListener() {
        public void stateChanged(ChangeEvent e) {
        }
    });
    gridConstraints.gridy = 4;
    panel.add(lookMouseHorizontalSlider, gridConstraints);
    final JSlider lookMouseVerticalSlider = new JSlider();
    lookMouseVerticalSlider.setMajorTickSpacing(5);
    lookMouseVerticalSlider.setMinorTickSpacing(1);
    lookMouseVerticalSlider.setPaintTicks(true);
    lookMouseVerticalSlider.setPaintLabels(true);
    lookMouseVerticalSlider.setSnapToTicks(true);
    lookMouseVerticalSlider.setMinimum(0);
    lookMouseVerticalSlider.setMaximum(40);
    lookMouseVerticalSlider.addChangeListener(new ChangeListener() {
        public void stateChanged(ChangeEvent e) {
        }
    });
    gridConstraints.gridy = 5;
    panel.add(lookMouseVerticalSlider, gridConstraints);
    final JCheckBox invertPitchCheckBox = new JCheckBox();
    invertPitchCheckBox.setAction(new SimpleAction() {
        public void actionPerformed(ActionEvent e) {
            dataContext.setLookInverted(invertPitchCheckBox.isSelected());
        }
    });
    invertPitchCheckBox.setText("String_Node_Str");
    invertPitchCheckBox.setSelected(dataContext.isLookInverted());
    gridConstraints.gridy = 6;
    panel.add(invertPitchCheckBox, gridConstraints);
    JPanel fillerPanel = new JPanel();
    Random rand = new Random(System.currentTimeMillis());
    int niceSettingsssYouHaveThere = rand.nextInt(4);
    if (niceSettingsssYouHaveThere == 0) {
        JLabel iconLabel = new JLabel();
        URL iconUrl = ConfigurationView.class.getClassLoader().getResource(ContentResources.CHROME_SENSITIVITYPANEL_FILLER);
        ImageIcon icon = new ImageIcon(iconUrl);
        Image newimg = icon.getImage().getScaledInstance(120, 120, java.awt.Image.SCALE_SMOOTH);
        iconLabel.setIcon(new ImageIcon(newimg));
        fillerPanel.add(iconLabel, BorderLayout.CENTER);
    }
    gridConstraints.gridy = 7;
    gridConstraints.weighty = 1;
    panel.add(fillerPanel, gridConstraints);
    return panel;
}

Output:
     lookMouseHorizontalSlider.setSnapToTicks(true);
-    lookMouseHorizontalSlider.setMinimum(1);
+    lookMouseHorizontalSlider.setValue(dataContext.getMouseMode2SensitivityX());
+    lookMouseHorizontalSlider.setMinimum(0);
     lookMouseHorizontalSlider.setMaximum(40);


Input:
public boolean isEventOnThisNode() {
    return vm_marker == VM_MARKER;
}

Output:
 public boolean isEventOnThisNode() {
-    return vm_marker == VM_MARKER;
+    return vm_marker == WebappHelper.getNodeId();
 }


Input:
private static <E extends Enum<E>> void enumTests(Class<E> e) {
    E[] enums = e.getEnumConstants();
    EnumMap<E, Integer> numbers = new EnumMap<E, Integer>(e);
    HashMap<E, Integer> numberMap = new HashMap<E, Integer>();
    assertEquals(numberMap, numbers);
    numbers.put(enums[1], 1);
    numberMap.put(enums[1], 1);
    numbers.put(enums[2], 2);
    numberMap.put(enums[2], 2);
    assertEquals(numberMap, numbers);
    numbers.put(enums[23], 23);
    numberMap.put(enums[23], 23);
    assertEquals(numberMap, numbers);
    numbers.remove(enums[1]);
    numberMap.remove(enums[1]);
    assertEquals(numberMap, numbers);
    numbers.put(enums[0], 0);
    numberMap.put(enums[0], 0);
    assertEquals(numberMap, numbers);
    numbers.put(enums[enums.length - 1], enums.length - 1);
    numberMap.put(enums[enums.length - 1], enums.length - 1);
    assertEquals(numberMap, numbers);
    numbers.remove(enums[15]);
    numberMap.remove(enums[15]);
    assertEquals(numberMap, numbers);
    numbers.put(enums[23], 23);
    numberMap.put(enums[23], 23);
    assertEquals(numberMap, numbers);
    numbers.clear();
    numberMap.clear();
    for (E val : enums) {
        numbers.put(val, val.ordinal());
        numberMap.put(val, val.ordinal());
    }
    assertEquals(numberMap, numbers);
    assertEquals(numberMap, numbers.clone());
    assertEquals(numberMap, new EnumMap<E, Integer>(numberMap));
    Set<Map.Entry<E, Integer>> numbersEntrySet = numbers.entrySet();
    Set<Map.Entry<E, Integer>> mapEntrySet = numberMap.entrySet();
    assertEquals(mapEntrySet, numbersEntrySet);
    Map.Entry<E, Integer> entry = numbers.entrySet().iterator().next();
    numbersEntrySet.remove(entry);
    mapEntrySet.remove(entry);
    assertEquals(mapEntrySet, numbersEntrySet);
    assertEquals(numberMap, numbers);
    Set<E> numbersKeySet = numbers.keySet();
    Set<E> mapKeySet = numberMap.keySet();
    assertEquals(mapKeySet, numbersKeySet);
    numbersKeySet.remove(enums[2]);
    mapKeySet.remove(enums[2]);
    assertEquals(mapKeySet, numbersKeySet);
    assertEquals(numberMap, numbers);
    Collection<Integer> numbersValues = numbers.values();
    Collection<Integer> mapValues = numberMap.values();
    assertEquals(sort(mapValues), sort(numbersValues));
    numbersValues.remove(23);
    mapValues.remove(23);
    assertEquals(sort(mapValues), sort(numbersValues));
    assertEquals(numberMap, numbers);
}

Output:
     assertEquals(mapEntrySet, numbersEntrySet);
-    Map.Entry<E, Integer> entry = numbers.entrySet().iterator().next();
+    final Map.Entry<E, Integer> entry = numbers.entrySet().iterator().next();
+    Map.Entry<E, Integer> entryCopy = new Map.Entry<E, Integer>() {
+        E key = entry.getKey();
+        Integer value = entry.getValue();
+        public E getKey() {
+            return key;
+        }
+        public Integer getValue() {
+            return value;
+        }
+        public Integer setValue(Integer value) {
+            Integer oldValue = this.value;
+            this.value = value;
+            return oldValue;
+        }
+    };
     numbersEntrySet.remove(entry);


Input:
protected void save() {
    try {
        MapFileHeader imagedHeader = generateMapHeader();
        data.doPreSaveActions();
        MapList.getDefaultList().saveMap(imagedHeader, data);
    } catch (Throwable e) {
        e.printStackTrace();
        JOptionPane.showMessageDialog(saveButton, e.getMessage());
    }
}

Output:
         data.doPreSaveActions();
-        MapList.getDefaultList().saveMap(imagedHeader, data);
+        MapList.getDefaultList().saveNewMap(imagedHeader, data);
     } catch (Throwable e) {


Input:
public final boolean levelCheck(int itr) {
    if (this.levelChecked >= itr)
        return this.levelCorrect;
    levelChecked = itr;
    this.levelCorrect = true;
    for (int i = 0; i < this.opDefs.length; i++) {
        if ((this.opDefs[i].getKind() != ModuleInstanceKind) && !this.opDefs[i].levelCheck(itr)) {
            this.levelCorrect = false;
        }
    }
    if (!this.body.levelCheck(itr)) {
        this.levelCorrect = false;
    }
    for (int i = 0; i < this.insts.length; i++) {
        if (!this.insts[i].levelCheck(itr)) {
            this.levelCorrect = false;
        }
    }
    this.level = this.body.getLevel();
    this.levelParams = this.body.getLevelParams();
    this.allParams = this.body.getAllParams();
    this.levelConstraints.putAll(this.body.getLevelConstraints());
    for (int i = 0; i < this.opDefs.length; i++) {
        if (this.opDefs[i].getKind() != ModuleInstanceKind) {
            this.levelConstraints.putAll(opDefs[i].getLevelConstraints());
        }
        ;
    }
    this.argLevelConstraints.putAll(this.body.getArgLevelConstraints());
    for (int i = 0; i < this.opDefs.length; i++) {
        if (this.opDefs[i].getKind() != ModuleInstanceKind) {
            this.argLevelConstraints.putAll(opDefs[i].getArgLevelConstraints());
        }
        ;
    }
    this.argLevelParams.addAll(this.body.getArgLevelParams());
    for (int i = 0; i < this.opDefs.length; i++) {
        if (this.opDefs[i].getKind() != ModuleInstanceKind) {
            FormalParamNode[] params = new FormalParamNode[0];
            if (this.opDefs[i].getKind() != ThmOrAssumpDefKind) {
                params = ((OpDefNode) this.opDefs[i]).getParams();
            }
            ;
            Iterator iter = this.opDefs[i].getArgLevelParams().iterator();
            while (iter.hasNext()) {
                ArgLevelParam alp = (ArgLevelParam) iter.next();
                if (!alp.occur(params)) {
                    this.argLevelParams.add(alp);
                }
            }
        }
    }
    for (int i = 0; i < this.insts.length; i++) {
        this.argLevelParams.addAll(this.insts[i].getArgLevelParams());
    }
    return this.levelCorrect;
}

Output:
     this.level = this.body.getLevel();
-    this.levelParams = this.body.getLevelParams();
-    this.allParams = this.body.getAllParams();
+    this.levelParams = (HashSet) this.body.getLevelParams().clone();
+    this.allParams = (HashSet) this.body.getAllParams().clone();
     this.levelConstraints.putAll(this.body.getLevelConstraints());


Input:
void copy(Component component) throws SBOLValidationException {
    ((ComponentInstance) this).copy((ComponentInstance) component);
    if (!component.getMapsTos().isEmpty()) {
        for (MapsTo mapsTo : component.getMapsTos()) {
            String displayId = URIcompliance.findDisplayId(mapsTo);
            String localDisplayId = URIcompliance.findDisplayId(mapsTo.getLocal());
            MapsTo newMapsTo = this.createMapsTo(displayId, mapsTo.getRefinement(), localDisplayId, mapsTo.getRemoteURI());
            newMapsTo.copy(mapsTo);
        }
    }
    for (URI role : component.getRoles()) {
        this.addRole(URI.create(role.toString()));
    }
}

Output:
     ((ComponentInstance) this).copy((ComponentInstance) component);
-    if (!component.getMapsTos().isEmpty()) {
-        for (MapsTo mapsTo : component.getMapsTos()) {
-            String displayId = URIcompliance.findDisplayId(mapsTo);
-            String localDisplayId = URIcompliance.findDisplayId(mapsTo.getLocal());
-            MapsTo newMapsTo = this.createMapsTo(displayId, mapsTo.getRefinement(), localDisplayId, mapsTo.getRemoteURI());
-            newMapsTo.copy(mapsTo);
-        }
-    }
+    this.mapsTos = new HashMap<>();
     for (URI role : component.getRoles()) {


Input:
public void fire() throws IllegalActionException {
    super.fire();
    _omcProxy = OMCProxy.getInstance();
    if (_debugging) {
        _debug("String_Node_Str");
    }
    if (input.getWidth() > 0) {
        IntToken inputPortValue = (IntToken) input.get(0);
        try {
            _omcProxy.loadFile(fileName.getExpression(), modelName.getExpression());
        } catch (ConnectException e) {
            throw new IllegalActionException("String_Node_Str");
        }
        try {
            System.out.println("String_Node_Str");
            _omcProxy.modifyVariables(inputPortValue, modelName.getExpression());
        } catch (ConnectException e) {
            throw new IllegalActionException("String_Node_Str");
        }
    }
    try {
        _omcProxy.simulateModel(fileName.getExpression(), modelName.getExpression(), fileNamePrefix.getExpression(), simulationStartTime.getExpression(), simulationStopTime.getExpression(), Integer.parseInt(numberOfIntervals.getExpression()), tolerance.getExpression(), method.getExpression(), outputFormat.getExpression(), variableFilter.getExpression(), cflags.getExpression(), simflags.getExpression(), processingType.getExpression());
    } catch (Throwable throwable) {
        throw new IllegalActionException(this, throwable, "String_Node_Str" + modelName.getExpression() + "String_Node_Str");
    }
    if ((processingType.getExpression().compareTo("String_Node_Str") == 0) && (outputFormat.getExpression().compareTo("String_Node_Str") == 0)) {
        String simulationResult = null;
        try {
            simulationResult = _omcProxy.displaySimulationResult(fileName.getExpression(), modelName.getExpression());
        } catch (ConnectException e) {
            throw new IllegalActionException("String_Node_Str" + modelName.getExpression() + "String_Node_Str");
        }
        output.send(0, new StringToken(simulationResult));
    }
    if (outputFormat.getExpression().compareTo("String_Node_Str") == 0) {
        try {
            _omcProxy.plotPltFile(fileNamePrefix.getExpression(), modelName.getExpression());
        } catch (ConnectException e) {
            throw new IllegalActionException("String_Node_Str" + modelName.getExpression() + "String_Node_Str");
        }
    }
}

Output:
     _omcProxy = OMCProxy.getInstance();
-    if (_debugging) {
-        _debug("String_Node_Str");
+    try {
+        _omcProxy.loadFile(fileName.getExpression(), modelName.getExpression());
+    } catch (ConnectException e) {
+        throw new IllegalActionException("String_Node_Str");
     }


Input:
private boolean inSafeMode(boolean useCache, String table) {
    String cluster = _clusterStatus.getCluster(true, table);
    return _clusterStatus.isInSafeMode(cluster);
}

Output:
 private boolean inSafeMode(boolean useCache, String table) {
-    String cluster = _clusterStatus.getCluster(true, table);
+    String cluster = _clusterStatus.getCluster(useCache, table);
     return _clusterStatus.isInSafeMode(cluster);


Input:
protected void writeNoReplace(Object value, Class<?> clazz) throws IOException {
    if (clazz.isPrimitive()) {
        writeValue(value, clazz);
        return;
    }
    if (value instanceof String) {
        value = ((String) value).intern();
    }
    Integer objectId = _objectIds.get(value);
    if (objectId != null) {
        Streams.writeVarInt(_out, objectId);
        return;
    }
    Streams.writeVarInt(_out, ++_lastObjectId);
    _objectIds.put(value, _lastObjectId);
    writeValue(value, clazz);
}

Output:
     }
-    Integer objectId = _objectIds.get(value);
-    if (objectId != null) {
-        Streams.writeVarInt(_out, objectId);
-        return;
+    if (track) {
+        Integer objectId = _objectIds.get(value);
+        if (objectId != null) {
+            Streams.writeVarInt(_out, objectId);
+            return;
+        }
     }


Input:
public Sound transform(AbstractFrequencySoundTransformation st, Sound sound) {
    Sound output = st.initSound(sound);
    double freqmax = sound.getSampleRate();
    double threshold = st.getLowThreshold(freqmax);
    int maxlength = st.getWindowLength(freqmax);
    long[] data = sound.getSamples();
    long[] newdata = output.getSamples();
    double[] transformeddata = new double[maxlength];
    FastFourierTransformer fastFourierTransformer = new FastFourierTransformer(DftNormalization.STANDARD);
    for (int i = 0; i < data.length; i += threshold) {
        long maxValue = 0;
        long minValue = Long.MAX_VALUE;
        int length = Math.min(maxlength, data.length - i);
        for (int j = i; j < i + length; j++) {
            if (j - i < threshold) {
                if (maxValue < data[j]) {
                    maxValue = data[j];
                }
                if (minValue > data[j]) {
                    minValue = data[j];
                }
            }
            transformeddata[j - i] = data[j];
        }
        Complex[] complexArray = fastFourierTransformer.transform(transformeddata, TransformType.FORWARD);
        Spectrum fs = new Spectrum(complexArray, (int) freqmax, sound.getNbBytesPerSample());
        Spectrum result = st.transformFrequencies(fs, i, maxlength, length, Math.abs(maxValue - minValue) > Math.pow(256, sound.getNbBytesPerSample()) / 6);
        if (result == null) {
            continue;
        }
        complexArray = fastFourierTransformer.transform(result.getState(), TransformType.INVERSE);
        int k = st.getOffsetFromASimpleLoop(i, freqmax);
        for (int j = 0; j < freqmax; j++) {
            if (i + j + k < newdata.length && newdata[i + j + k] == 0) {
                newdata[i + j + k] = (long) Math.floor(complexArray[j].getReal());
            }
        }
    }
    return output;
}

Output:
         Spectrum fs = new Spectrum(complexArray, (int) freqmax, sound.getNbBytesPerSample());
-        Spectrum result = st.transformFrequencies(fs, i, maxlength, length, Math.abs(maxValue - minValue) > Math.pow(256, sound.getNbBytesPerSample()) / 6);
+        Spectrum result = st.transformFrequencies(fs, i, maxlength, length, Math.abs(maxValue - minValue) > Math.pow(256, sound.getNbBytesPerSample()) / 8);
         if (result == null) {


Input:
private List<String> getColumnNames(final GridComponent grid, final List<String> columns) {
    List<String> columnNames = Lists.newLinkedList();
    columns.forEach(column -> {
        String columnName = grid.getColumnNames().get(column);
        columnNames.add(columnName);
    });
    return columnNames;
}

Output:
         String columnName = grid.getColumnNames().get(column);
-        columnNames.add(columnName);
+        if (!Strings.isNullOrEmpty(columnName)) {
+            columnNames.add(columnName);
+        }
     });


Input:
public float[] generateTransformedValuesBubble(IBubbleDataSet data, float phaseY, int from, int to) {
    final int count = (int) Math.ceil(to - from) * 2;
    float[] valuePoints = new float[count];
    for (int j = 0; j < count; j += 2) {
        Entry e = data.getEntryForIndex(j / 2 + from);
        if (e != null) {
            valuePoints[j] = e.getX();
            valuePoints[j + 1] = e.getY() * phaseY;
        }
    }
    getValueToPixelMatrix().mapPoints(valuePoints);
    return valuePoints;
}

Output:
 public float[] generateTransformedValuesBubble(IBubbleDataSet data, float phaseY, int from, int to) {
-    final int count = (int) Math.ceil(to - from) * 2;
+    final int count = (to - from + 1) * 2;
     float[] valuePoints = new float[count];


Input:
private int getScrollRange() {
    int scrollRange = 0;
    if (getChildCount() > 0) {
        View child = getChildAt(0);
        scrollRange = Math.max(0, child.getWidth() - getWidth() - mPaddingLeft - mPaddingRight);
    }
    return scrollRange;
}

Output:
         View child = getChildAt(0);
-        scrollRange = Math.max(0, child.getWidth() - getWidth() - mPaddingLeft - mPaddingRight);
+        scrollRange = Math.max(0, child.getWidth() - (getWidth() - mPaddingLeft - mPaddingRight));
     }


Input:
public static void persistGraphInDirectory(Graph graph, boolean normalize, String dirName) {
    String fileName = dirName + File.separator + "String_Node_Str" + DATE_FORMATTER.format(new Date() + "String_Node_Str");
    persistGraph(graph, normalize, fileName);
}

Output:
 public static void persistGraphInDirectory(Graph graph, boolean normalize, String dirName) {
-    String fileName = dirName + File.separator + "String_Node_Str" + DATE_FORMATTER.format(new Date() + "String_Node_Str");
+    String fileName = dirName + File.separator + "String_Node_Str" + DATE_FORMATTER.format(new Date()) + "String_Node_Str";
     persistGraph(graph, normalize, fileName);


Input:
public int extractEnergy(ItemStack container, int maxExtract, boolean simulate) {
    if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("String_Node_Str")) {
        return 0;
    }
    int energy = container.stackTagCompound.getInteger("String_Node_Str");
    int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract));
    if (!simulate) {
        energy -= energyExtracted;
        container.stackTagCompound.setInteger("String_Node_Str", energy);
    }
    return energyExtracted;
}

Output:
 public int extractEnergy(ItemStack container, int maxExtract, boolean simulate) {
-    if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("String_Node_Str")) {
+    if (container.getTagCompound() == null || !container.getTagCompound().hasKey("String_Node_Str")) {
         return 0;


Input:
public void changed(ObservableValue ov, Profile t, Profile selectedProfil) {
    try {
        refreshTablePosition(pservice.getAllPositionsOfProfile(selectedProfil));
        refreshTableKameraPosition(pservice.getAllPairCameraPositionOfProfile(selectedProfil.getId()));
        refreshTableLogo(pservice.getAllLogosOfProfile(selectedProfil));
    } catch (ServiceException e) {
        e.printStackTrace();
    }
}

Output:
     try {
-        refreshTablePosition(pservice.getAllPositionsOfProfile(selectedProfil));
-        refreshTableKameraPosition(pservice.getAllPairCameraPositionOfProfile(selectedProfil.getId()));
+        refreshTablePosition(pservice.getAllPositions());
+        int selectedProfilID = ((Profile) profilList.getSelectionModel().getSelectedItem()) == null ? 0 : ((Profile) profilList.getSelectionModel().getSelectedItem()).getId();
+        kamPosList.removeAll(kamPosList);
+        kamPosList.addAll(pservice.getAllPairCameraPositionOfProfile(selectedProfilID));
+        tableKamPos.setItems(kamPosList);
         refreshTableLogo(pservice.getAllLogosOfProfile(selectedProfil));


Input:
public void initialize(Subject subject, CallbackHandler callbackHandler, Map<String, ?> ss, Map<String, ?> opts) {
    super.initialize(subject, callbackHandler, ss, opts);
    if (osgiConfig != null) {
        options = ConfigurationParameters.of(osgiConfig, options);
    }
    Whiteboard whiteboard = getWhiteboard();
    if (whiteboard == null) {
        log.error("String_Node_Str");
        return;
    }
    String idpName = options.getConfigValue(PARAM_IDP_NAME, "String_Node_Str");
    if (idpName.length() == 0) {
        log.error("String_Node_Str");
    } else {
        ExternalIdentityProviderManager idpMgr = WhiteboardUtils.getService(whiteboard, ExternalIdentityProviderManager.class);
        if (idpMgr == null) {
            log.error("String_Node_Str");
        } else {
            idp = idpMgr.getProvider(idpName);
            if (idp == null) {
                log.error("String_Node_Str", idpName);
            }
        }
    }
    String syncHandlerName = options.getConfigValue(PARAM_SYNC_HANDLER_NAME, "String_Node_Str");
    if (syncHandlerName.length() == 0) {
        log.error("String_Node_Str");
    } else {
        SyncManager syncMgr = WhiteboardUtils.getService(whiteboard, SyncManager.class);
        if (syncMgr == null) {
            log.error("String_Node_Str");
        } else {
            syncHandler = syncMgr.getSyncHandler(syncHandlerName);
            if (syncHandler == null) {
                log.error("String_Node_Str", syncHandlerName);
            }
        }
    }
}

Output:
     String idpName = options.getConfigValue(PARAM_IDP_NAME, "String_Node_Str");
-    if (idpName.length() == 0) {
+    if (idpName.isEmpty()) {
         log.error("String_Node_Str");


Input:
private void resetGroupingUnitsCombo(boolean isGroupingEnableUI) {
    NameSet ns;
    ns = LiteralHelper.getGroupingUnitTypeSet(fGrouping.getGroupType());
    if (ns != null) {
        cmbUnit.setItems(ns.getDisplayNames());
        if (isGroupingEnableUI && fGrouping.getGroupType() != null && (fGrouping.getGroupType() == DataType.DATE_TIME_LITERAL || fGrouping.getGroupType() == DataType.TEXT_LITERAL) && fGrouping.getGroupingUnit() != null) {
            String name = ChartUtil.getGroupingUnitName(fGrouping);
            if (name != null) {
                String displayName = ns.getDisplayNameByName(name);
                if (displayName == null) {
                    cmbUnit.select(0);
                } else {
                    cmbUnit.setText(name);
                }
            } else {
                cmbUnit.select(0);
            }
        }
    } else {
        cmbUnit.removeAll();
    }
    lblUnit.setEnabled(isGroupingEnableUI && (isDateTimeGrouping(cmbType.getText()) || isTextGrouping(cmbType.getText())));
    cmbUnit.setEnabled(lblUnit.getEnabled());
}

Output:
                 } else {
-                    cmbUnit.setText(name);
+                    cmbUnit.setText(displayName);
                 }


Input:
private void addRelationName(Relation rField) {
    String relationName = getJoinColumnName(rField.getProperty());
    if (rField.getProperty().isAnnotationPresent(PrimaryKeyJoinColumn.class)) {
        relationName = this.getIdColumn().getName();
    }
    addToRelationNameCollection(relationName);
}

Output:
 private void addRelationName(Relation rField) {
-    String relationName = getJoinColumnName(rField.getProperty());
-    if (rField.getProperty().isAnnotationPresent(PrimaryKeyJoinColumn.class)) {
-        relationName = this.getIdColumn().getName();
+    if (!rField.isRelatedViaJoinTable()) {
+        String relationName = getJoinColumnName(rField.getProperty());
+        if (rField.getProperty().isAnnotationPresent(PrimaryKeyJoinColumn.class)) {
+            relationName = this.getIdColumn().getName();
+        }
+        addToRelationNameCollection(relationName);
     }


Input:
protected void performUpdateUserSuccessAction(Bundle bundle) {
    QBUser user = (QBUser) bundle.getSerializable(QBServiceConsts.EXTRA_USER);
    startMainActivity(SignUpActivity.this, user, true);
    AnalyticsUtils.pushAnalyticsData(SignUpActivity.this, user, "String_Node_Str");
}

Output:
     QBUser user = (QBUser) bundle.getSerializable(QBServiceConsts.EXTRA_USER);
-    startMainActivity(SignUpActivity.this, user, true);
+    AppSession.saveRememberMe(true);
+    startMainActivity(SignUpActivity.this, user);
     AnalyticsUtils.pushAnalyticsData(SignUpActivity.this, user, "String_Node_Str");


Input:
public void testZSS696CopyValidation() {
    Object[] books = _loadBooks(null, "String_Node_Str");
    Book book = (Book) books[0];
    Sheet sheet = book.getSheet("String_Node_Str");
    SSheet ssheet = sheet.getInternalSheet();
    SDataValidation d1dv = ssheet.getDataValidation(0, 3);
    Set<CellRegion> d1regions = d1dv.getRegions();
    Assert.assertEquals("String_Node_Str", 1, d1regions.size());
    Assert.assertTrue("String_Node_Str", d1regions.contains(new CellRegion("String_Node_Str")));
    Range e1 = Ranges.range(sheet, "String_Node_Str");
    e1.paste(Ranges.range(sheet, "String_Node_Str"));
    d1regions = d1dv.getRegions();
    Assert.assertEquals("String_Node_Str", 1, d1regions.size());
    Assert.assertTrue("String_Node_Str", d1regions.contains(new CellRegion("String_Node_Str")));
    Assert.assertTrue("String_Node_Str", Ranges.range(sheet, "String_Node_Str").isMergedCell());
    e1.paste(Ranges.range(sheet, "String_Node_Str"), true);
    d1regions = d1dv.getRegions();
    Assert.assertEquals("String_Node_Str", 3, d1regions.size());
    Assert.assertTrue("String_Node_Str", d1regions.contains(new CellRegion("String_Node_Str")));
    Assert.assertFalse("String_Node_Str", d1regions.contains(new CellRegion("String_Node_Str")));
    Assert.assertTrue("String_Node_Str", d1regions.contains(new CellRegion("String_Node_Str")));
    Assert.assertTrue("String_Node_Str", d1regions.contains(new CellRegion("String_Node_Str")));
    Assert.assertTrue("String_Node_Str", !Ranges.range(sheet, "String_Node_Str").isMergedCell());
}

Output:
 public void testZSS696CopyValidation() {
-    Object[] books = _loadBooks(null, "String_Node_Str");
+    Object[] books = _loadBooks(this, "String_Node_Str");
     Book book = (Book) books[0];


Input:
public boolean equals(Object obj) {
    if (this == obj) {
        return true;
    }
    if (obj == null) {
        return false;
    }
    if (getClass() != obj.getClass()) {
        return false;
    }
    final PathKey other = (PathKey) obj;
    if (endCoord == null) {
        if (other.endCoord != null) {
            return false;
        }
    } else if (!endCoord.equals(other.endCoord)) {
        return false;
    }
    if (startCoord == null) {
        if (other.startCoord != null) {
            return false;
        }
    } else if (!startCoord.equals(other.startCoord)) {
        return false;
    }
    return true;
}

Output:
     }
-    final PathKey other = (PathKey) obj;
-    if (endCoord == null) {
-        if (other.endCoord != null) {
+    VertexPair other = (VertexPair) obj;
+    if (endVertex == null) {
+        if (other.endVertex != null) {
             return false;


Input:
private void initComponentProperties() {
    IComponentIdentifier compId = getNode().getCompIdentifier();
    if (compId != null) {
        Map<String, String> componentProperties = compId.getComponentPropertiesMap();
        if (componentProperties != null) {
            for (String key : componentProperties.keySet()) {
                PropertyDescriptor propDes = new PropertyDescriptor(new ComponentPropertiesController(key, compId), key);
                propDes.setCategory(P_ELEMENT_DISPLAY_PROPERTY_INFORMATION);
                addPropertyDescriptor(propDes);
            }
        }
    }
}

Output:
             for (String key : componentProperties.keySet()) {
-                PropertyDescriptor propDes = new PropertyDescriptor(new ComponentPropertiesController(key, compId), key);
+                JBPropertyDescriptor propDes = new JBPropertyDescriptor(new ComponentPropertiesController(key, compId), key);
                 propDes.setCategory(P_ELEMENT_DISPLAY_PROPERTY_INFORMATION);


Input:
public static void tagSlaveInstances() throws IOException {
    LOGGER.info("String_Node_Str");
    SlaveInstanceManager manager = new SlaveInstanceManager();
    for (JSONObject instance : manager.getInstances()) {
        ElasticBoxSlave slave = manager.getSlave(instance.getString("String_Node_Str"));
        ElasticBoxSlaveHandler.getInstance().tagSlaveInstance(instance, slave);
    }
}

Output:
     LOGGER.info("String_Node_Str");
-    SlaveInstanceManager manager = new SlaveInstanceManager();
-    for (JSONObject instance : manager.getInstances()) {
-        ElasticBoxSlave slave = manager.getSlave(instance.getString("String_Node_Str"));
-        ElasticBoxSlaveHandler.getInstance().tagSlaveInstance(instance, slave);
-    }
+    new Condition() {
+        public boolean satisfied() {
+            return Jenkins.getInstance().getNodes() != null;
+        }
+    }.waitUntilSatisfied(3000);
+    ElasticBoxExecutor.threadPool.submit(new Runnable() {
+        public void run() {
+            try {
+                SlaveInstanceManager manager = new SlaveInstanceManager();
+                for (JSONObject instance : manager.getInstances()) {
+                    ElasticBoxSlave slave = manager.getSlave(instance.getString("String_Node_Str"));
+                    ElasticBoxSlaveHandler.getInstance().tagSlaveInstance(instance, slave);
+                }
+            } catch (IOException ex) {
+                LOGGER.log(Level.SEVERE, "String_Node_Str", ex);
+            }
+        }
+    });
 }


Input:
protected void buildSummary(HSSFSheet worksheet) {
    List<HSSFCellStyle> cellStyles = buildCellStylesForSummary(worksheet);
    buildSummaryRow(worksheet, cellStyles, "String_Node_Str", DateUtil.today().toString("String_Node_Str"));
    buildSummaryRow(worksheet, cellStyles, "String_Node_Str", "String_Node_Str");
    List<String> patientDocumentIds = patientReports.getPatientDocIds();
    for (String patientDocumentId : patientDocumentIds) {
        PatientReport report = patientReports.getPatientReport(patientDocumentId);
        buildSummaryRow(worksheet, cellStyles, "String_Node_Str", report.getPatientId());
        buildSummaryRow(worksheet, cellStyles, "String_Node_Str", report.getClinicName());
        buildSummaryRow(worksheet, cellStyles, "String_Node_Str", DateUtil.newDate(report.getARTStartedOn()).toString(TAMAConstants.DATE_FORMAT));
        buildSummaryRow(worksheet, cellStyles, "String_Node_Str", "String_Node_Str");
        buildSummaryRow(worksheet, cellStyles, "String_Node_Str", "String_Node_Str");
        buildSummaryRow(worksheet, cellStyles, "String_Node_Str", "String_Node_Str");
        List<TreatmentAdvice> treatmentAdvices = allTreatmentAdvices.find_by_patient_id(report.getPatientDocId());
        Collections.sort(treatmentAdvices);
        for (TreatmentAdvice treatmentAdvice : treatmentAdvices) {
            if (treatmentAdvice.getEndDate() == null)
                buildSummaryRow(worksheet, cellStyles, allRegimens.get(treatmentAdvice.getRegimenId()).getDisplayName() + "String_Node_Str" + CURRENT_REGIMEN, DateUtil.newDate(treatmentAdvice.getStartDate()).toString(TAMAConstants.DATE_FORMAT));
            else
                buildSummaryRow(worksheet, cellStyles, allRegimens.get(treatmentAdvice.getRegimenId()).getDisplayName(), DateUtil.newDate(treatmentAdvice.getStartDate()).toString(TAMAConstants.DATE_FORMAT));
        }
        buildSummaryRow(worksheet, cellStyles, "String_Node_Str", "String_Node_Str");
        worksheet.createRow(worksheet.getLastRowNum() + 1);
        buildSummaryRow(worksheet, cellStyles, "String_Node_Str", "String_Node_Str");
    }
}

Output:
         buildSummaryRow(worksheet, cellStyles, "String_Node_Str", report.getClinicName());
-        buildSummaryRow(worksheet, cellStyles, "String_Node_Str", DateUtil.newDate(report.getARTStartedOn()).toString(TAMAConstants.DATE_FORMAT));
+        buildSummaryRow(worksheet, cellStyles, "String_Node_Str", artStartDate);
         buildSummaryRow(worksheet, cellStyles, "String_Node_Str", "String_Node_Str");


Input:
public void fireEvent(HttpServletRequest request, HttpServletResponse response, PortletWindow window, Event event) throws PortletException, IOException {
    ensureInitialized();
    InternalPortletWindow internalPortletWindow = new PortletWindowImpl(servletContext, window);
    debugWithName("String_Node_Str" + window.getPortletName());
    EventRequestImpl eventRequest = new EventRequestImpl(this, internalPortletWindow, request, event);
    EventResponseImpl eventResponse = new EventResponseImpl(this, internalPortletWindow, request, response);
    PortletInvoker invoker = new PortletInvoker(internalPortletWindow);
    invoker.event(eventRequest, eventResponse);
    debugWithName("String_Node_Str" + window.getPortletName());
    String location = eventResponse.getRedirectLocation();
    if (location == null) {
        debugWithName("String_Node_Str");
        PortletURLProvider redirectURL = requiredContainerServices.getPortalCallbackService().getPortletURLProvider(request, internalPortletWindow);
        saveChangedParameters(eventRequest, eventResponse, redirectURL);
        redirectURL.savePortalURL(request);
    }
}

Output:
     ensureInitialized();
-    InternalPortletWindow internalPortletWindow = new PortletWindowImpl(servletContext, window);
+    InternalPortletWindow internalPortletWindow = new InternalPortletWindowImpl(PortletContextManager.getPortletContext(servletContext, window.getContextPath()), window);
     debugWithName("String_Node_Str" + window.getPortletName());


Input:
public void updateGridData(List<ContactRelationship> relationships) {
    grid.getStore().removeAll();
    grid.getStore().add(relationships);
    grid.recalculate();
    resizeGrid(grid, container, false);
}

Output:
     grid.recalculate();
-    resizeGrid(grid, container, false);
+    resizeGrid(grid, container, true);
 }


Input:
private static Instrument readInstrument(ByteReader reader, int index, ModFormat.Type type) {
    final String name = reader.string(22);
    final int length = reader.u2() * 2;
    final int finetune = reader.u1() & 15;
    final int volume = Math.min(64, reader.u1());
    final int loopStart = reader.u2() * (type == ust ? 1 : 2);
    final int loopLength = reader.u2() * (type == ust ? 1 : 2);
    final Instrument instrument = new SampledInstrument(index + 1, length);
    instrument.name(name);
    instrument.volume(volume);
    instrument.fineTune(finetune);
    instrument.loop(loopStart, loopLength);
    return instrument;
}

Output:
     final int finetune = reader.u1() & 15;
-    final int volume = Math.min(64, reader.u1());
+    final int volume = reader.u1();
     final int loopStart = reader.u2() * (type == ust ? 1 : 2);


Input:
public boolean isSuperClassOf(IType type) {
    return type.isArrayType() && this.getElementType().isSuperClassOf(type.getElementType());
}

Output:
 public boolean isSuperClassOf(IType type) {
-    return type.isArrayType() && this.getElementType().isSuperClassOf(type.getElementType());
+    if (!type.isArrayType()) {
+        return false;
+    }
+    IType elementType = type.getElementType();
+    return this.type.isSuperClassOf(elementType) && this.type.isPrimitive() == elementType.isPrimitive();
 }


Input:
public void setStackHeight(float height) {
    mLastSetStackHeight = height;
    setIsExpanded(height > 0.0f);
    int newStackHeight = (int) height;
    int minStackHeight = getMinStackHeight();
    int stackHeight;
    float paddingOffset;
    boolean trackingHeadsUp = mTrackingHeadsUp;
    int normalExpandPositionStart = trackingHeadsUp ? mHeadsUpManager.getTopHeadsUpHeight() : minStackHeight;
    if (newStackHeight - mTopPadding - mTopPaddingOverflow >= normalExpandPositionStart || getNotGoneChildCount() == 0) {
        paddingOffset = mTopPaddingOverflow;
        stackHeight = newStackHeight;
    } else {
        int translationY = (newStackHeight - minStackHeight);
        float partiallyThere = (newStackHeight - mTopPadding - mTopPaddingOverflow) / minStackHeight;
        partiallyThere = Math.max(0, partiallyThere);
        if (!trackingHeadsUp) {
            translationY += (1 - partiallyThere) * (mBottomStackPeekSize + mCollapseSecondCardPadding);
        } else {
            translationY = (int) (height - mHeadsUpManager.getTopHeadsUpHeight());
        }
        paddingOffset = translationY - mTopPadding;
        stackHeight = (int) (height - (translationY - mTopPadding));
    }
    if (stackHeight != mCurrentStackHeight) {
        mCurrentStackHeight = stackHeight;
        updateAlgorithmHeightAndPadding();
        requestChildrenUpdate();
    }
    setPaddingOffset(paddingOffset);
}

Output:
     }
-    setPaddingOffset(paddingOffset);
+    setStackTranslation(paddingOffset);
 }


Input:
public org.hl7.fhir.dstu2.model.BodySite convertBodySite(org.hl7.fhir.dstu3.model.BodySite src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.BodySite tgt = new org.hl7.fhir.dstu2.model.BodySite();
    copyDomainResource(src, tgt);
    tgt.setPatient(convertReference(src.getPatient()));
    for (org.hl7.fhir.dstu3.model.Identifier t : src.getIdentifier()) tgt.addIdentifier(convertIdentifier(t));
    tgt.setCode(convertCodeableConcept(src.getCode()));
    for (org.hl7.fhir.dstu3.model.CodeableConcept t : src.getModifier()) tgt.addModifier(convertCodeableConcept(t));
    tgt.setDescription(src.getDescription());
    for (org.hl7.fhir.dstu3.model.Attachment t : src.getImage()) tgt.addImage(convertAttachment(t));
    return tgt;
}

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


Input:
private SignalAspect determineMyAspect(BlockPos otherCoord) {
    BlockPos myTrack = trackLocator.getTrackLocation();
    if (myTrack == null)
        return SignalAspect.RED;
    BlockPos otherTrack = getOtherTrackLocation(otherCoord);
    if (otherTrack == null)
        return SignalAspect.YELLOW;
    TrackScanner.ScanResult scan = getOrCreateTrackScan(otherTrack);
    if (scan == null)
        return SignalAspect.RED;
    int y1 = scan.minY;
    int y2 = scan.maxY + 1;
    int x1 = Math.min(myTrack.getX(), otherTrack.getX());
    int z1 = Math.min(myTrack.getZ(), otherTrack.getZ());
    int x2 = Math.max(myTrack.getX(), otherTrack.getX()) + 1;
    int z2 = Math.max(myTrack.getZ(), otherTrack.getZ()) + 1;
    boolean zAxis = Math.abs(myTrack.getX() - otherTrack.getX()) < Math.abs(myTrack.getZ() - otherTrack.getZ());
    int xOffset = otherTrack.getX() > myTrack.getX() ? -3 : 3;
    int zOffset = otherTrack.getZ() > myTrack.getZ() ? -3 : 3;
    List<EntityMinecart> carts = CartToolsAPI.getMinecartsIn(tile.getWorld(), new BlockPos(x1, y1, z1), new BlockPos(x2, y2, z2));
    SignalAspect newAspect = SignalAspect.GREEN;
    for (EntityMinecart cart : carts) {
        int cartX = MathHelper.floor_double(cart.posX);
        int cartZ = MathHelper.floor_double(cart.posZ);
        if (Math.abs(cart.motionX) < 0.08 && Math.abs(cart.motionZ) < 0.08)
            return SignalAspect.RED;
        else if (zAxis)
            if (cartZ > myTrack.getZ() + zOffset && cart.motionZ < 0)
                return SignalAspect.RED;
            else if (cartZ < myTrack.getZ() + zOffset && cart.motionZ > 0)
                return SignalAspect.RED;
            else
                newAspect = SignalAspect.YELLOW;
        else if (cartX > myTrack.getX() + xOffset && cart.motionX < 0)
            return SignalAspect.RED;
        else if (cartX < myTrack.getX() + xOffset && cart.motionX > 0)
            return SignalAspect.RED;
        else
            newAspect = SignalAspect.YELLOW;
    }
    return newAspect;
}

Output:
     for (EntityMinecart cart : carts) {
-        int cartX = MathHelper.floor_double(cart.posX);
-        int cartZ = MathHelper.floor_double(cart.posZ);
+        int cartX = MathHelper.floor(cart.posX);
+        int cartZ = MathHelper.floor(cart.posZ);
         if (Math.abs(cart.motionX) < 0.08 && Math.abs(cart.motionZ) < 0.08)


Input:
ParameterValue<?> parameterIfExist(final String name) throws ParameterNotFoundException {
    for (final GeneralParameterValue value : values()) {
        if (value instanceof ParameterValue<?>) {
            if (isHeuristicMatchForName(value.getDescriptor(), name)) {
                return (ParameterValue<?>) value;
            }
        }
    }
    return null;
}

Output:
         if (value instanceof ParameterValue<?>) {
-            if (isHeuristicMatchForName(value.getDescriptor(), name)) {
-                return (ParameterValue<?>) value;
+            final ParameterValue<?> param = (ParameterValue<?>) value;
+            final ParameterDescriptor<?> descriptor = param.getDescriptor();
+            if (name.equals(descriptor.getName().toString())) {
+                return param;
+            }
+            if (isHeuristicMatchForName(descriptor, name)) {
+                if (fallback == null) {
+                    fallback = param;
+                } else {
+                    ambiguity = param;
+                }
             }


Input:
public InformationLossDefault getLowerBound(Node node, IHashGroupify groupify) {
    if (node.getLowerBound() != null) {
        return (InformationLossDefault) node.getLowerBound();
    }
    double lowerBound = 0d;
    HashGroupifyEntry m = groupify.getFirstEntry();
    while (m != null) {
        if (m.count > 0) {
            for (int i = 0; i < height.length; i++) {
                lowerBound += m.count * (height[i] == 0 ? 0 : (double) m.key[i] / (double) height[i]);
            }
        }
        m = m.nextOrdered;
    }
    lowerBound /= cells;
    return new InformationLossDefault(lowerBound);
}

Output:
             for (int i = 0; i < height.length; i++) {
-                lowerBound += m.count * (height[i] == 0 ? 0 : (double) m.key[i] / (double) height[i]);
+                factor += height[i] == 0 ? 0 : (double) m.key[i] / (double) height[i];
             }


Input:
public void testGlazedListsEventList() {
    List<String> list = new ArrayList<String>();
    EventList<String> eventList = GlazedLists.eventList(list);
    assertEquals(list, eventList);
    list.add("String_Node_Str");
    assertTrue(!list.equals(eventList));
    eventList.add("String_Node_Str");
    assertTrue(!list.equals(eventList));
    EventList<String> empty = GlazedLists.eventList((Collection) null);
    assertEquals(Collections.EMPTY_LIST, empty);
}

Output:
 public void testGlazedListsEventList() {
-    List<String> list = new ArrayList<String>();
+    final List<String> list = new ArrayList<String>();
     EventList<String> eventList = GlazedLists.eventList(list);


Input:
final void updateOomAdjLocked() {
    final ActivityRecord TOP_ACT = resumedAppLocked();
    final ProcessRecord TOP_APP = TOP_ACT != null ? TOP_ACT.app : null;
    final long now = SystemClock.uptimeMillis();
    final long oldTime = now - ProcessList.MAX_EMPTY_TIME;
    final int N = mLruProcesses.size();
    if (false) {
        RuntimeException e = new RuntimeException();
        e.fillInStackTrace();
        Slog.i(TAG, "String_Node_Str" + TOP_ACT, e);
    }
    mAdjSeq++;
    mNewNumServiceProcs = 0;
    final int emptyProcessLimit;
    final int cachedProcessLimit;
    if (mProcessLimit <= 0) {
        emptyProcessLimit = cachedProcessLimit = 0;
    } else if (mProcessLimit == 1) {
        emptyProcessLimit = 1;
        cachedProcessLimit = 0;
    } else {
        emptyProcessLimit = ProcessList.computeEmptyProcessLimit(mProcessLimit);
        cachedProcessLimit = mProcessLimit - emptyProcessLimit;
    }
    int numSlots = (ProcessList.CACHED_APP_MAX_ADJ - ProcessList.CACHED_APP_MIN_ADJ + 1) / 2;
    int numEmptyProcs = N - mNumNonCachedProcs - mNumCachedHiddenProcs;
    if (numEmptyProcs > cachedProcessLimit) {
        numEmptyProcs = cachedProcessLimit;
    }
    int emptyFactor = numEmptyProcs / numSlots;
    if (emptyFactor < 1)
        emptyFactor = 1;
    int cachedFactor = (mNumCachedHiddenProcs > 0 ? mNumCachedHiddenProcs : 1) / numSlots;
    if (cachedFactor < 1)
        cachedFactor = 1;
    int stepCached = 0;
    int stepEmpty = 0;
    int numCached = 0;
    int numEmpty = 0;
    int numTrimming = 0;
    mNumNonCachedProcs = 0;
    mNumCachedHiddenProcs = 0;
    int curCachedAdj = ProcessList.CACHED_APP_MIN_ADJ;
    int nextCachedAdj = curCachedAdj + 1;
    int curEmptyAdj = ProcessList.CACHED_APP_MIN_ADJ;
    int nextEmptyAdj = curEmptyAdj + 2;
    int curClientCachedAdj = curEmptyAdj;
    for (int i = 0; i < N; i++) {
        ProcessRecord app = mLruProcesses.get(i);
        if (!app.killedBackground && app.thread != null) {
            app.procStateChanged = false;
            final boolean wasKeeping = app.keeping;
            computeOomAdjLocked(app, ProcessList.UNKNOWN_ADJ, TOP_APP, true, now);
            if (app.curAdj >= ProcessList.UNKNOWN_ADJ) {
                switch(app.curProcState) {
                    case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY:
                        app.curRawAdj = curCachedAdj;
                        app.curAdj = app.modifyRawOomAdj(curCachedAdj);
                        if (curCachedAdj != nextCachedAdj) {
                            stepCached++;
                            if (stepCached >= cachedFactor) {
                                stepCached = 0;
                                curCachedAdj = nextCachedAdj;
                                nextCachedAdj += 2;
                                if (nextCachedAdj > ProcessList.CACHED_APP_MAX_ADJ) {
                                    nextCachedAdj = ProcessList.CACHED_APP_MAX_ADJ;
                                }
                                if (curClientCachedAdj <= curCachedAdj) {
                                    curClientCachedAdj = curCachedAdj + 1;
                                    if (curClientCachedAdj > ProcessList.CACHED_APP_MAX_ADJ) {
                                        curClientCachedAdj = ProcessList.CACHED_APP_MAX_ADJ;
                                    }
                                }
                            }
                        }
                        break;
                    case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT:
                        app.curRawAdj = curClientCachedAdj;
                        app.curAdj = app.modifyRawOomAdj(curClientCachedAdj);
                        curClientCachedAdj++;
                        if (curClientCachedAdj > ProcessList.CACHED_APP_MAX_ADJ) {
                            curClientCachedAdj = ProcessList.CACHED_APP_MAX_ADJ;
                        }
                        break;
                    default:
                        app.curRawAdj = curEmptyAdj;
                        app.curAdj = app.modifyRawOomAdj(curEmptyAdj);
                        if (curEmptyAdj != nextEmptyAdj) {
                            stepEmpty++;
                            if (stepEmpty >= emptyFactor) {
                                stepEmpty = 0;
                                curEmptyAdj = nextEmptyAdj;
                                nextEmptyAdj += 2;
                                if (nextEmptyAdj > ProcessList.CACHED_APP_MAX_ADJ) {
                                    nextEmptyAdj = ProcessList.CACHED_APP_MAX_ADJ;
                                }
                            }
                        }
                        break;
                }
            }
            applyOomAdjLocked(app, wasKeeping, TOP_APP, true, false, now);
            switch(app.curProcState) {
                case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY:
                case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT:
                    mNumCachedHiddenProcs++;
                    numCached++;
                    if (numCached > cachedProcessLimit) {
                        Slog.i(TAG, "String_Node_Str" + app.processName + "String_Node_Str" + app.pid + "String_Node_Str" + numCached);
                        EventLog.writeEvent(EventLogTags.AM_KILL, app.userId, app.pid, app.processName, app.setAdj, "String_Node_Str");
                        app.killedBackground = true;
                        Process.killProcessQuiet(app.pid);
                    }
                    break;
                case ActivityManager.PROCESS_STATE_CACHED_EMPTY:
                    if (numEmpty > ProcessList.TRIM_EMPTY_APPS && app.lastActivityTime < oldTime) {
                        Slog.i(TAG, "String_Node_Str" + app.processName + "String_Node_Str" + app.pid + "String_Node_Str" + ((oldTime + ProcessList.MAX_EMPTY_TIME - app.lastActivityTime) / 1000) + "String_Node_Str");
                        EventLog.writeEvent(EventLogTags.AM_KILL, app.userId, app.pid, app.processName, app.setAdj, "String_Node_Str");
                        app.killedBackground = true;
                        Process.killProcessQuiet(app.pid);
                    } else {
                        numEmpty++;
                        if (numEmpty > emptyProcessLimit) {
                            Slog.i(TAG, "String_Node_Str" + app.processName + "String_Node_Str" + app.pid + "String_Node_Str" + numEmpty);
                            EventLog.writeEvent(EventLogTags.AM_KILL, app.userId, app.pid, app.processName, app.setAdj, "String_Node_Str");
                            app.killedBackground = true;
                            Process.killProcessQuiet(app.pid);
                        }
                    }
                    break;
                default:
                    mNumNonCachedProcs++;
                    break;
            }
            if (app.isolated && app.services.size() <= 0) {
                Slog.i(TAG, "String_Node_Str" + app.processName + "String_Node_Str" + app.pid + "String_Node_Str");
                EventLog.writeEvent(EventLogTags.AM_KILL, app.userId, app.pid, app.processName, app.setAdj, "String_Node_Str");
                app.killedBackground = true;
                Process.killProcessQuiet(app.pid);
            }
            if (app.curProcState >= ActivityManager.PROCESS_STATE_HOME && !app.killedBackground) {
                numTrimming++;
            }
        }
    }
    mNumServiceProcs = mNewNumServiceProcs;
    boolean allChanged;
    if (numCached <= ProcessList.TRIM_CACHED_APPS && numEmpty <= ProcessList.TRIM_EMPTY_APPS) {
        final int numCachedAndEmpty = numCached + numEmpty;
        int factor = numTrimming / 3;
        int minFactor = 2;
        if (mHomeProcess != null)
            minFactor++;
        if (mPreviousProcess != null)
            minFactor++;
        if (factor < minFactor)
            factor = minFactor;
        int step = 0;
        int fgTrimLevel;
        int memFactor;
        if (numCachedAndEmpty <= ProcessList.TRIM_CRITICAL_THRESHOLD) {
            fgTrimLevel = ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL;
            memFactor = ProcessTracker.ADJ_MEM_FACTOR_CRITICAL;
        } else if (numCachedAndEmpty <= ProcessList.TRIM_LOW_THRESHOLD) {
            fgTrimLevel = ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW;
            memFactor = ProcessTracker.ADJ_MEM_FACTOR_LOW;
        } else {
            fgTrimLevel = ComponentCallbacks2.TRIM_MEMORY_RUNNING_MODERATE;
            memFactor = ProcessTracker.ADJ_MEM_FACTOR_MODERATE;
        }
        int curLevel = ComponentCallbacks2.TRIM_MEMORY_COMPLETE;
        allChanged = mProcessTracker.setMemFactorLocked(memFactor, !mSleeping, now);
        for (int i = N - 1; i >= 0; i--) {
            ProcessRecord app = mLruProcesses.get(i);
            if (allChanged || app.procStateChanged) {
                app.setProcessTrackerState(memFactor, now);
            }
            if (app.curProcState >= ActivityManager.PROCESS_STATE_HOME && !app.killedBackground) {
                if (app.trimMemoryLevel < curLevel && app.thread != null) {
                    try {
                        if (DEBUG_SWITCH || DEBUG_OOM_ADJ)
                            Slog.v(TAG, "String_Node_Str" + app.processName + "String_Node_Str" + curLevel);
                        app.thread.scheduleTrimMemory(curLevel);
                    } catch (RemoteException e) {
                    }
                    if (false) {
                        if (curLevel >= ComponentCallbacks2.TRIM_MEMORY_COMPLETE && app != mHomeProcess && app != mPreviousProcess) {
                            mStackSupervisor.scheduleDestroyAllActivities(app, "String_Node_Str");
                        }
                    }
                }
                app.trimMemoryLevel = curLevel;
                step++;
                if (step >= factor) {
                    step = 0;
                    switch(curLevel) {
                        case ComponentCallbacks2.TRIM_MEMORY_COMPLETE:
                            curLevel = ComponentCallbacks2.TRIM_MEMORY_MODERATE;
                            break;
                        case ComponentCallbacks2.TRIM_MEMORY_MODERATE:
                            curLevel = ComponentCallbacks2.TRIM_MEMORY_BACKGROUND;
                            break;
                    }
                }
            } else if (app.curProcState == ActivityManager.PROCESS_STATE_HEAVY_WEIGHT) {
                if (app.trimMemoryLevel < ComponentCallbacks2.TRIM_MEMORY_BACKGROUND && app.thread != null) {
                    try {
                        if (DEBUG_SWITCH || DEBUG_OOM_ADJ)
                            Slog.v(TAG, "String_Node_Str" + app.processName + "String_Node_Str" + ComponentCallbacks2.TRIM_MEMORY_BACKGROUND);
                        app.thread.scheduleTrimMemory(ComponentCallbacks2.TRIM_MEMORY_BACKGROUND);
                    } catch (RemoteException e) {
                    }
                }
                app.trimMemoryLevel = ComponentCallbacks2.TRIM_MEMORY_BACKGROUND;
            } else {
                if ((app.curProcState >= ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND || app.systemNoUi) && app.pendingUiClean) {
                    final int level = ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN;
                    if (app.trimMemoryLevel < level && app.thread != null) {
                        try {
                            if (DEBUG_SWITCH || DEBUG_OOM_ADJ)
                                Slog.v(TAG, "String_Node_Str" + app.processName + "String_Node_Str" + level);
                            app.thread.scheduleTrimMemory(level);
                        } catch (RemoteException e) {
                        }
                    }
                    app.pendingUiClean = false;
                }
                if (app.trimMemoryLevel < fgTrimLevel && app.thread != null) {
                    try {
                        if (DEBUG_SWITCH || DEBUG_OOM_ADJ)
                            Slog.v(TAG, "String_Node_Str" + app.processName + "String_Node_Str" + fgTrimLevel);
                        app.thread.scheduleTrimMemory(fgTrimLevel);
                    } catch (RemoteException e) {
                    }
                }
                app.trimMemoryLevel = fgTrimLevel;
            }
        }
    } else {
        allChanged = mProcessTracker.setMemFactorLocked(ProcessTracker.ADJ_MEM_FACTOR_NORMAL, !mSleeping, now);
        for (int i = N - 1; i >= 0; i--) {
            ProcessRecord app = mLruProcesses.get(i);
            if (allChanged || app.procStateChanged) {
                app.setProcessTrackerState(ProcessTracker.ADJ_MEM_FACTOR_NORMAL, now);
            }
            if ((app.curProcState >= ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND || app.systemNoUi) && app.pendingUiClean) {
                if (app.trimMemoryLevel < ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN && app.thread != null) {
                    try {
                        if (DEBUG_SWITCH || DEBUG_OOM_ADJ)
                            Slog.v(TAG, "String_Node_Str" + app.processName + "String_Node_Str" + ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN);
                        app.thread.scheduleTrimMemory(ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN);
                    } catch (RemoteException e) {
                    }
                }
                app.pendingUiClean = false;
            }
            app.trimMemoryLevel = 0;
        }
    }
    if (mAlwaysFinishActivities) {
        mStackSupervisor.scheduleDestroyAllActivities(null, "String_Node_Str");
    }
    if (allChanged) {
        requestPssAllProcsLocked(now, false);
    }
    if (mProcessTracker.shouldWriteNowLocked(now)) {
        mHandler.post(new Runnable() {
            public void run() {
                synchronized (ActivityManagerService.this) {
                    mProcessTracker.writeStateAsyncLocked();
                }
            }
        });
    }
    if (DEBUG_OOM_ADJ) {
        Slog.d(TAG, "String_Node_Str" + (SystemClock.uptimeMillis() - now) + "String_Node_Str");
    }
}

Output:
     int nextEmptyAdj = curEmptyAdj + 2;
-    int curClientCachedAdj = curEmptyAdj;
-    for (int i = 0; i < N; i++) {
+    for (int i = N - 1; i >= 0; i--) {
         ProcessRecord app = mLruProcesses.get(i);


Input:
private void activityResumedCallback(Activity activity) {
    if (LiquidOnEventListener.class.isInstance(activity)) {
        mInstance.attachLiquidEventListener((LiquidOnEventListener) activity);
    }
    startFlushTimer();
}

Output:
 private void activityResumedCallback(Activity activity) {
-    if (LiquidOnEventListener.class.isInstance(activity)) {
-        mInstance.attachLiquidEventListener((LiquidOnEventListener) activity);
-    }
+    mInstance.attachActivity(activity);
     startFlushTimer();


Input:
public void generateMappings(TypeInfo info, XMLDescriptor descriptor, NamespaceInfo namespaceInfo) {
    if (info.isAnonymousComplexType()) {
        generateInheritedMappingsForAnonymousType(info, descriptor, namespaceInfo);
    }
    List<Property> propertiesInOrder = info.getNonTransientPropertiesInPropOrder();
    for (int i = 0; i < propertiesInOrder.size(); i++) {
        Property next = propertiesInOrder.get(i);
        if (next != null && (!next.isTransient() || (next.isTransient() && next.isXmlLocation()))) {
            DatabaseMapping mapping = generateMapping(next, descriptor, namespaceInfo);
            if (next.isVirtual()) {
                VirtualAttributeAccessor accessor = new VirtualAttributeAccessor();
                accessor.setAttributeName(mapping.getAttributeName());
                String getMethod = info.getXmlVirtualAccessMethods().getGetMethod();
                String setMethod = info.getXmlVirtualAccessMethods().getSetMethod();
                if (mapping.getAttributeAccessor().isMethodAttributeAccessor()) {
                    getMethod = ((MethodAttributeAccessor) mapping.getAttributeAccessor()).getGetMethodName();
                    setMethod = ((MethodAttributeAccessor) mapping.getAttributeAccessor()).getSetMethodName();
                    accessor.setValueType(mapping.getAttributeClassification());
                }
                accessor.setGetMethodName(getMethod);
                accessor.setSetMethodName(setMethod);
                if (mapping.getAttributeAccessor() instanceof JAXBArrayAttributeAccessor) {
                    JAXBArrayAttributeAccessor jaa = (JAXBArrayAttributeAccessor) mapping.getAttributeAccessor();
                    jaa.setNestedAccessor(accessor);
                } else {
                    mapping.setAttributeAccessor(accessor);
                }
            }
            if (mapping != null) {
                descriptor.addMapping(mapping);
            }
            if (next.isSetUserProperties()) {
                mapping.setProperties(next.getUserProperties());
            }
            JavaClass jClass = helper.getJavaClass(info.getJavaClassName());
            AccessorFactoryWrapper accessorFactory = info.getXmlAccessorFactory();
            if (accessorFactory == null) {
                accessorFactory = info.getPackageLevelXmlAccessorFactory();
            }
            if (accessorFactory != null) {
                try {
                    Object accessor = CompilerHelper.createAccessorFor(jClass, next, helper, accessorFactory);
                    if (accessor != null) {
                        CustomAccessorAttributeAccessor attributeAccessor = new CustomAccessorAttributeAccessor(accessor);
                        mapping.setAttributeAccessor(attributeAccessor);
                    }
                } catch (Exception ex) {
                }
            }
        }
        next.postInitialize();
    }
}

Output:
     if (info.isAnonymousComplexType()) {
-        generateInheritedMappingsForAnonymousType(info, descriptor, namespaceInfo);
+        generateInheritedMappingsForAnonymousType(info, descriptor, descriptorJavaClass, namespaceInfo);
     }


Input:
private void execNewPage0(final Execution exec, final PageDefinition pagedef, final Richlet richlet, final Page page, final Writer out) throws IOException {
    final Desktop desktop = exec.getDesktop();
    final DesktopCtrl desktopCtrl = (DesktopCtrl) desktop;
    final LanguageDefinition langdef = pagedef != null ? pagedef.getLanguageDefinition() : richlet != null ? richlet.getLanguageDefinition() : null;
    if (langdef != null)
        desktop.setDeviceType(langdef.getDeviceType());
    final WebApp wapp = desktop.getWebApp();
    final Configuration config = wapp.getConfiguration();
    PerformanceMeter pfmeter = config.getPerformanceMeter();
    final long startTime = pfmeter != null ? System.currentTimeMillis() : 0;
    final Execution oldexec = Executions.getCurrent();
    final ExecutionCtrl oldexecCtrl = (ExecutionCtrl) oldexec;
    final UiVisualizer olduv = oldexecCtrl != null ? (UiVisualizer) oldexecCtrl.getVisualizer() : null;
    final UiVisualizer uv;
    if (olduv != null) {
        uv = doReactivate(exec, olduv);
        pfmeter = null;
    } else {
        uv = doActivate(exec, false, false, null, -1);
    }
    final ExecutionCtrl execCtrl = (ExecutionCtrl) exec;
    final Page old = execCtrl.getCurrentPage();
    final PageDefinition olddef = execCtrl.getCurrentPageDefinition();
    execCtrl.setCurrentPage(page);
    execCtrl.setCurrentPageDefinition(pagedef);
    final String pfReqId = pfmeter != null ? meterLoadStart(pfmeter, exec, startTime) : null;
    AbortingReason abrn = null;
    try {
        config.invokeExecutionInits(exec, oldexec);
        desktopCtrl.invokeExecutionInits(exec, oldexec);
        if (olduv != null) {
            final Component owner = olduv.getOwner();
            if (owner != null) {
                ((PageCtrl) page).setOwner(owner);
            }
        }
        if (pagedef != null) {
            ((PageCtrl) page).preInit();
            pagedef.preInit(page);
            final Initiators inits = Initiators.doInit(pagedef, page, config.getInitiators());
            try {
                pagedef.init(page, !uv.isEverAsyncUpdate() && !uv.isAborting());
                final Component[] comps;
                final String uri = pagedef.getForwardURI(page);
                if (uri != null) {
                    comps = new Component[0];
                    exec.forward(uri);
                } else {
                    comps = uv.isAborting() || exec.isVoided() ? new Component[0] : execCreate(new CreateInfo(((WebAppCtrl) wapp).getUiFactory(), exec, page, config.getComposer(page)), pagedef, null, null);
                }
                inits.doAfterCompose(page, comps);
                afterCreate(exec, comps);
            } catch (Throwable ex) {
                if (!inits.doCatch(ex))
                    throw UiException.Aide.wrap(ex);
            } finally {
                inits.doFinally();
            }
        } else {
            ((PageCtrl) page).preInit();
            final Initiators inits = Initiators.doInit(null, page, config.getInitiators());
            try {
                ((PageCtrl) page).init(new PageConfig() {
                    public String getId() {
                        return null;
                    }
                    public String getUuid() {
                        return null;
                    }
                    public String getTitle() {
                        return null;
                    }
                    public String getStyle() {
                        return null;
                    }
                    public String getViewport() {
                        return "String_Node_Str";
                    }
                    public String getBeforeHeadTags() {
                        return "String_Node_Str";
                    }
                    public String getAfterHeadTags() {
                        return "String_Node_Str";
                    }
                    public Collection<Object[]> getResponseHeaders() {
                        return Collections.emptyList();
                    }
                });
                final Composer composer = config.getComposer(page);
                try {
                    richlet.service(page);
                    for (Component root = page.getFirstRoot(); root != null; root = root.getNextSibling()) {
                        doAfterCompose(composer, root);
                        afterCreate(exec, new Component[] { root });
                    }
                } catch (Throwable t) {
                    if (composer instanceof ComposerExt)
                        if (((ComposerExt) composer).doCatch(t))
                            t = null;
                    if (t != null)
                        throw t;
                } finally {
                    if (composer instanceof ComposerExt)
                        ((ComposerExt) composer).doFinally();
                }
            } catch (Throwable ex) {
                if (!inits.doCatch(ex))
                    throw UiException.Aide.wrap(ex);
            } finally {
                inits.doFinally();
            }
        }
        if (exec.isVoided())
            return;
        final List<Throwable> errs = new LinkedList<Throwable>();
        Event event = nextEvent(uv);
        do {
            for (; event != null; event = nextEvent(uv)) {
                try {
                    process(desktop, event);
                } catch (Throwable ex) {
                    handleError(ex, uv, errs);
                }
            }
            resumeAll(desktop, uv, null);
        } while ((event = nextEvent(uv)) != null);
        abrn = uv.getAbortingReason();
        if (abrn != null)
            abrn.execute();
        List<AuResponse> responses = getResponses(exec, uv, errs, false);
        if (olduv != null && olduv.addToFirstAsyncUpdate(responses))
            responses = null;
        else
            execCtrl.setResponses(responses);
        ((PageCtrl) page).redraw(out);
        afterRenderNewPage(page);
        desktopCtrl.invokeExecutionCleanups(exec, oldexec, errs);
        config.invokeExecutionCleanups(exec, oldexec, errs);
    } catch (Throwable ex) {
        final List<Throwable> errs = new LinkedList<Throwable>();
        errs.add(ex);
        desktopCtrl.invokeExecutionCleanups(exec, oldexec, errs);
        config.invokeExecutionCleanups(exec, oldexec, errs);
        if (!errs.isEmpty()) {
            ex = errs.get(0);
            if (ex instanceof IOException)
                throw (IOException) ex;
            throw UiException.Aide.wrap(ex);
        }
    } finally {
        if (abrn != null) {
            try {
                abrn.finish();
            } catch (Throwable t) {
                log.warning(t);
            }
        }
        execCtrl.setCurrentPage(old);
        execCtrl.setCurrentPageDefinition(olddef);
        if (olduv != null)
            doDereactivate(exec, olduv);
        else
            doDeactivate(exec);
        if (pfmeter != null)
            meterLoadServerComplete(pfmeter, pfReqId, exec);
    }
}

Output:
                     comps = new Component[0];
-                    exec.forward(uri);
+                    try {
+                        exec.forward(uri);
+                    } finally {
+                        final List<Throwable> errs = new LinkedList<Throwable>();
+                        desktopCtrl.invokeExecutionCleanups(exec, oldexec, errs);
+                        config.invokeExecutionCleanups(exec, oldexec, errs);
+                    }
                 } else {


Input:
public void setMethod(Method method) {
    setExpression(getExpression(method, _attributeName, _modifiedDate, _unit, _documentation));
}

Output:
 public void setMethod(Method method) {
-    setExpression(getExpression(method, _attributeName, _modifiedDate, _unit, _documentation));
+    setExpression(formatExpression(method, _attributeName, _modifiedDate, _unit, _documentation));
 }


Input:
public PageInfo getPageInfo(String streamId, long pageNum) {
    Connection conn = null;
    try {
        conn = getConnection();
        PreparedStatement ps = conn.prepareStatement(getGetPageInfoSQL(streamId, pageNum));
        ResultSet rs = ps.executeQuery();
        if (!rs.next()) {
            ps.close();
            return null;
        }
        PageInfo pi = new PageInfo();
        pi.setPageNumber(rs.getLong(1));
        pi.setByteOffset(rs.getLong(2));
        pi.setTimeOffset(rs.getLong(3));
        pi.setLength(rs.getLong(4));
        ps.close();
        return pi;
    } catch (SQLException e) {
        log.error("String_Node_Str", e);
        return null;
    } finally {
        if (conn != null)
            returnConnection(conn);
    }
}

Output:
         conn = getConnection();
-        PreparedStatement ps = conn.prepareStatement(getGetPageInfoSQL(streamId, pageNum));
+        PreparedStatement ps = conn.prepareStatement(GET_PAGE_INFO_SQL);
+        ps.setString(1, streamId);
+        ps.setLong(2, pageNum);
         ResultSet rs = ps.executeQuery();


Input:
public Mapping<S, D> withSkipWhenNull(Transform<RS, RD> transformation) {
    denyNull("String_Node_Str", transformation);
    ReplaceTransformation<RS, RD> replace = new ReplaceTransformation<>(mapping, sourceProperty.property, destProperty.property, transformation, true);
    mapping.addMapping(sourceProperty.property, destProperty.property, replace);
    return mapping;
}

Output:
     denyNull("String_Node_Str", transformation);
-    ReplaceTransformation<RS, RD> replace = new ReplaceTransformation<>(mapping, sourceProperty.property, destProperty.property, transformation, true);
+    ReplaceCollectionTransformation<RS, RD> replace = new ReplaceCollectionTransformation<>(mapping, sourceProperty.property, destProperty.property, transformation, true);
     mapping.addMapping(sourceProperty.property, destProperty.property, replace);


Input:
public static void newStepStatus(ProofStepStatus status) {
    if (status == null) {
        return;
    }
    Location location = status.getLocation();
    IResource module = ResourceHelper.getResourceByModuleName(location.source());
    if (module != null && module instanceof IFile && module.exists()) {
        IMarker sanyMarker = findSANYMarker(module, location);
        try {
            IMarker newMarker = module.createMarker(statusStringToMarkerType(status.getStatus()));
            Map markerAttributes = new HashMap(2);
            int newCharStart;
            int newCharEnd;
            if (sanyMarker != null) {
                newCharStart = sanyMarker.getAttribute(IMarker.CHAR_START, 0);
                newCharEnd = sanyMarker.getAttribute(IMarker.CHAR_END, 0);
            } else {
                ProverUIActivator.logDebug("String_Node_Str" + location + "String_Node_Str");
                IRegion messageRegion = AdapterFactory.locationToRegion(location);
                newCharStart = messageRegion.getOffset();
                newCharEnd = messageRegion.getOffset() + messageRegion.getLength() - 1;
            }
            IMarker[] existingMarkers = module.findMarkers(ProverHelper.STEP_STATUS_MARKER, true, IResource.DEPTH_ZERO);
            for (int i = 0; i < existingMarkers.length; i++) {
                IMarker existingMarker = existingMarkers[i];
                int existingCharStart = existingMarker.getAttribute(IMarker.CHAR_START, -1);
                int existingCharEnd = existingMarker.getAttribute(IMarker.CHAR_END, -1);
                if (existingCharStart < newCharEnd && existingCharEnd > newCharStart) {
                    existingMarker.delete();
                }
            }
            markerAttributes.put(IMarker.CHAR_START, new Integer(newCharStart));
            markerAttributes.put(IMarker.CHAR_END, new Integer(newCharEnd));
            newMarker.setAttributes(markerAttributes);
        } catch (CoreException e) {
            ProverUIActivator.logError("String_Node_Str", e);
        }
    } else {
        ProverUIActivator.logDebug("String_Node_Str" + "String_Node_Str" + status.getStatus() + "String_Node_Str" + location);
    }
}

Output:
         try {
-            IMarker newMarker = module.createMarker(statusStringToMarkerType(status.getStatus()));
+            String markerType = statusStringToMarkerType(status.getStatus());
+            if (markerType == null) {
+                ProverUIActivator.logDebug("String_Node_Str" + status.getStatus());
+                return;
+            }
+            IMarker newMarker = module.createMarker(markerType);
             Map markerAttributes = new HashMap(2);


Input:
protected void okPressed() {
    IMPORTType type = ComponentFactory.eINSTANCE.createIMPORTType();
    type.setMESSAGE(desText.getText());
    String modelName = "String_Node_Str";
    boolean libExists = true;
    ILibraryManagerService libManager = (ILibraryManagerService) GlobalServiceRegister.getDefault().getService(ILibraryManagerService.class);
    if (typeNameRadioButton.getSelection()) {
        modelName = nameText.getText();
        if (libManager.contains(modelName)) {
            final String name = modelName;
            libExists = false;
            Display.getDefault().asyncExec(new Runnable() {
                public void run() {
                    MessageDialog.openError(getParentShell(), Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str", name));
                }
            });
        }
    } else {
        file = new File(fileField.getStringValue());
        modelName = file.getName();
    }
    if (libExists) {
        type.setMODULE(modelName);
        type.setREQUIRED(requiredButton.getSelection());
        type.setUrlPath(fileField.getStringValue());
        this.importType = type;
        super.okPressed();
    }
}

Output:
         modelName = nameText.getText();
-        if (libManager.contains(modelName)) {
+        if (!libManager.contains(modelName)) {
             final String name = modelName;