Input:
public void hostedVirtLimitWithHostLimitedCreatesBonusPoolsOnBind() {
    when(config.getBoolean(ConfigProperties.STANDALONE)).thenReturn(false);
    Subscription s = createVirtLimitSub("String_Node_Str", 10, "String_Node_Str");
    s.getProduct().setAttribute("String_Node_Str", "String_Node_Str");
    List<Pool> pools = poolRules.createPools(s);
    assertEquals(2, pools.size());
    Pool physicalPool = pools.get(0);
    physicalPool.setId("String_Node_Str");
    assertEquals(new Long(10), physicalPool.getQuantity());
    assertEquals(0, physicalPool.getAttributes().size());
    Entitlement e = new Entitlement(physicalPool, consumer, 1);
    PoolHelper postHelper = new PoolHelper(poolManagerMock, productCache, e);
    enforcer.postEntitlement(consumer, postHelper, e);
    verify(poolManagerMock).createPool(any(Pool.class));
}

Output:
     Entitlement e = new Entitlement(physicalPool, consumer, 1);
-    PoolHelper postHelper = new PoolHelper(poolManagerMock, productCache, e);
+    PoolHelper postHelper = new PoolHelper(poolManagerMock, e);
     enforcer.postEntitlement(consumer, postHelper, e);


Input:
public void end() {
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println(("String_Node_Str" + (pageWidth * 8) + "String_Node_Str" + (pageHeight * 8) + "String_Node_Str"));
    for (int i = 0; i < currentPageNum; i++) {
        println(("String_Node_Str" + (i + 1) + "String_Node_Str" + (i + 1) + "String_Node_Str"));
    }
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    for (int i = 0; i < currentPageNum; i++) {
        println(("String_Node_Str" + (i + 1) + "String_Node_Str"));
        if (fileNamesLists.containsKey(new Integer(i + 1))) {
            List filenames = (List) fileNamesLists.get(new Integer(i + 1));
            for (Iterator ite = filenames.iterator(); ite.hasNext(); ) {
                println(("String_Node_Str" + (String) ite.next() + "String_Node_Str"));
            }
        }
    }
    println("String_Node_Str");
    println("String_Node_Str");
    println("String_Node_Str");
    writer.close();
    writer = null;
}

Output:
     println("String_Node_Str");
-    println(("String_Node_Str" + (pageWidth * 8) + "String_Node_Str" + (pageHeight * 8) + "String_Node_Str"));
+    println(("String_Node_Str" + slidesizex + "String_Node_Str" + slidesizey + "String_Node_Str"));
     for (int i = 0; i < currentPageNum; i++) {


Input:
public String toString() {
    return String.valueOf(getHash()) + "String_Node_Str" + inputs.length + "String_Node_Str" + outputs.length;
}

Output:
 public String toString() {
-    return String.valueOf(getHash()) + "String_Node_Str" + inputs.length + "String_Node_Str" + outputs.length;
+    return String.valueOf(getId()) + "String_Node_Str" + inputs.length + "String_Node_Str" + outputs.length;
 }


Input:
protected void drawImage(IImageArea image) {
    Image img = null;
    TranscoderInput ti = null;
    cb.saveState();
    ContainerPosition curPos;
    if (!containerStack.isEmpty())
        curPos = (ContainerPosition) containerStack.peek();
    else
        curPos = new ContainerPosition(0, 0);
    int imageX = curPos.x + image.getX();
    int imageY = curPos.y + image.getY();
    IImageContent imageContent = ((IImageContent) image.getContent());
    try {
        boolean isSvg = false;
        switch(imageContent.getImageSource()) {
            case IImageContent.IMAGE_FILE:
                if (null == imageContent.getURI())
                    return;
                URL url = reportDesign.findResource(imageContent.getURI(), IResourceLocator.IMAGE);
                InputStream in = url.openStream();
                if (imageContent.getURI().endsWith("String_Node_Str")) {
                    isSvg = true;
                    ti = new TranscoderInput(in);
                } else {
                    try {
                        byte[] buffer = new byte[in.available()];
                        in.read(buffer);
                        img = Image.getInstance(buffer);
                    } catch (Exception ex) {
                        logger.log(Level.WARNING, ex.getMessage(), ex);
                    } finally {
                        in.close();
                    }
                }
                break;
            case IImageContent.IMAGE_URL:
                if (null == imageContent.getURI())
                    return;
                if (imageContent.getURI().endsWith("String_Node_Str")) {
                    isSvg = true;
                    ti = new TranscoderInput(imageContent.getURI());
                } else {
                    img = Image.getInstance(imageContent.getURI());
                }
                break;
            case IImageContent.IMAGE_NAME:
            case IImageContent.IMAGE_EXPRESSION:
                if (null == imageContent.getData())
                    return;
                isSvg = ((imageContent.getMIMEType() != null) && imageContent.getMIMEType().equalsIgnoreCase("String_Node_Str")) || ((imageContent.getURI() != null) && imageContent.getURI().toLowerCase().endsWith("String_Node_Str")) || ((imageContent.getExtension() != null) && imageContent.getExtension().toLowerCase().endsWith("String_Node_Str"));
                if (isSvg) {
                    ti = new TranscoderInput(new ByteArrayInputStream(imageContent.getData()));
                } else {
                    img = Image.getInstance(imageContent.getData());
                }
        }
        if (!isSvg) {
            cb.addImage(img, pdfMeasure(image.getWidth()), 0f, 0f, pdfMeasure(image.getHeight()), layoutAreaX2PDF(imageX), layoutAreaY2PDF(imageY, image.getHeight()));
        } else {
            try {
                if (ti != null) {
                    double width = pdfMeasure(image.getWidth());
                    double height = pdfMeasure(image.getHeight());
                    double x = layoutAreaX2PDF(imageX);
                    double y = layoutAreaY2PDF(imageY, image.getHeight());
                    PdfTemplate template = cb.createTemplate(new Float(width).floatValue(), new Float(height).floatValue());
                    Graphics2D g2 = template.createGraphics(new Float(width).floatValue(), new Float(height).floatValue());
                    PrintTranscoder prm = new PrintTranscoder();
                    prm.addTranscodingHint(PrintTranscoder.KEY_SCALE_TO_PAGE, new Boolean(true));
                    prm.transcode(ti, null);
                    PageFormat pg = new PageFormat();
                    Paper pp = new Paper();
                    pp.setSize(width, height);
                    pp.setImageableArea(0, 0, width, height);
                    pg.setPaper(pp);
                    prm.print(g2, pg, 0);
                    g2.dispose();
                    cb.addTemplate(template, new Float(x).floatValue(), new Float(y).floatValue());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    } catch (BadElementException bee) {
        logger.log(Level.WARNING, bee.getMessage(), bee);
    } catch (IOException ioe) {
        logger.log(Level.WARNING, ioe.getMessage(), ioe);
    } catch (DocumentException de) {
        logger.log(Level.WARNING, de.getMessage(), de);
    } catch (Throwable t) {
        logger.log(Level.WARNING, t.getMessage(), t);
    }
    cb.restoreState();
    makeBookmark(image, curPos);
    handleHyperlinkAction(image, curPos);
}

Output:
         if (!isSvg) {
-            cb.addImage(img, pdfMeasure(image.getWidth()), 0f, 0f, pdfMeasure(image.getHeight()), layoutAreaX2PDF(imageX), layoutAreaY2PDF(imageY, image.getHeight()));
+            cb.addImage(img, width, 0f, 0f, height, x, y);
+            String helpText = imageContent.getHelpText();
+            if (helpText != null) {
+                showHelpText(x, y, width, height, helpText);
+            }
         } else {


Input:
public FactTable saveFactTable(String factTableName, String[][] keyColumnNames, IDatasetIterator iterator, Dimension[] dimensions, String[] measureColumnName, StopSign stopSign) throws BirtException, IOException {
    DiskSortedStack sortedFactTableRows = getSortedFactTableRows(iterator, keyColumnNames, measureColumnName, stopSign);
    int segmentCount = getSegmentCount(sortedFactTableRows.size());
    DimensionInfo[] dimensionInfo = getDimensionInfo(dimensions);
    MeasureInfo[] measureInfo = getMeasureInfo(iterator, measureColumnName);
    saveFactTableMetadata(factTableName, dimensionInfo, measureInfo, segmentCount);
    DimensionDivision[] subDimensions = calculateDimensionDivision(getDimensionMemberCount(dimensions), segmentCount);
    int[][][] columnIndex = getColumnIndex(keyColumnNames, dimensions);
    DimensionPositionSeeker[] dimensionSeekers = new DimensionPositionSeeker[dimensions.length];
    for (int i = 0; i < dimensionSeekers.length; i++) {
        dimensionSeekers[i] = new DimensionPositionSeeker(getDimCombinatedKey(columnIndex[i], dimensions[i].getAllRows()));
    }
    FactTableRow currentRow = null;
    FactTableRow lastRow = null;
    int[] dimensionPosition = new int[dimensions.length];
    DocumentObjectCache documentObjectManager = new DocumentObjectCache(documentManager);
    CombinedPositionContructor combinedPositionCalculator = new CombinedPositionContructor(subDimensions);
    FTSUNameSaveHelper helper = new FTSUNameSaveHelper(documentManager, factTableName);
    Object popObject = sortedFactTableRows.pop();
    while (popObject != null && !stopSign.isStopped()) {
        currentRow = (FactTableRow) popObject;
        if (lastRow != null && currentRow.equals(lastRow)) {
            throw new DataException(ResourceConstants.FACTTABLE_ROW_NOT_DISTINCT, currentRow.toString());
        }
        for (int i = 0; i < dimensionPosition.length; i++) {
            dimensionPosition[i] = dimensionSeekers[i].find(currentRow.getDimensionKeys()[i]);
            if (dimensionPosition[i] < 0) {
                String[] args = new String[2];
                args[0] = currentRow.toString();
                args[1] = dimensions[i].getName();
                throw new DataException(ResourceConstants.INVALID_DIMENSIONPOSITION_OF_FACTTABLEROW, args);
            }
        }
        int[] subDimensionIndex = getSubDimensionIndex(dimensionPosition, subDimensions);
        String FTSUDocName = FTSUDocumentObjectNamingUtil.getDocumentObjectName(NamingUtil.getFactTableName(factTableName), subDimensionIndex);
        helper.add(FTSUDocName);
        IDocumentObject documentObject = documentObjectManager.getIDocumentObject(FTSUDocName);
        documentObject.writeBytes(new Bytes(combinedPositionCalculator.calculateCombinedPosition(subDimensionIndex, dimensionPosition).toByteArray()));
        for (int i = 0; i < measureInfo.length; i++) {
            DocumentObjectUtil.writeValue(documentObject, measureInfo[i].dataType, currentRow.getMeasures()[i]);
        }
        popObject = sortedFactTableRows.pop();
        lastRow = currentRow;
    }
    helper.save();
    documentObjectManager.closeAll();
    documentManager.flush();
    return new FactTable(factTableName, documentManager, dimensionInfo, measureInfo, segmentCount, subDimensions);
}

Output:
     DimensionDivision[] subDimensions = calculateDimensionDivision(getDimensionMemberCount(dimensions), segmentCount);
-    int[][][] columnIndex = getColumnIndex(keyColumnNames, dimensions);
+    int[][][] columnIndex = getColumnIndex(DimJointColumnNames, dimensions);
     DimensionPositionSeeker[] dimensionSeekers = new DimensionPositionSeeker[dimensions.length];


Input:
public boolean getIsNew() {
    return _m_bIsNew;
}

Output:
 public boolean getIsNew() {
-    return _m_bIsNew;
+    return _isNew;
 }


Input:
public void onCompleted(Exception e, PopcornTimeRpcClient.RpcResponse result) {
    try {
        if (result != null && e == null) {
            mFullscreen = (Boolean) result.getMapResult().get("String_Node_Str");
            updateViews();
        }
    } catch (Exception exception) {
        exception.printStackTrace();
    }
    mHandler.postDelayed(mFullscreenRunnable, 1000);
}

Output:
             mFullscreen = (Boolean) result.getMapResult().get("String_Node_Str");
-            updateViews();
+            mHandler.post(new Runnable() {
+                public void run() {
+                    updateViews();
+                }
+            });
         }


Input:
public void testCallbackMethods() {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory("String_Node_Str");
    EntityManager em = emf.createEntityManager();
    EntityMetadata m = KunderaMetadataManager.getEntityMetadata(PersonEventDispatch.class);
    Assert.assertNotNull(m.toString());
    em.close();
    emf.close();
}

Output:
 public void testCallbackMethods() {
-    EntityManagerFactory emf = Persistence.createEntityManagerFactory("String_Node_Str");
+    Map<String, Object> props = new HashMap<String, Object>();
+    props.put("String_Node_Str", "String_Node_Str");
+    EntityManagerFactory emf = Persistence.createEntityManagerFactory("String_Node_Str", props);
     EntityManager em = emf.createEntityManager();


Input:
public PriorFunction getPriorFunction() {
    return config.getPriorFunction();
}

Output:
 public PriorFunction getPriorFunction() {
-    return config.getPriorFunction();
+    return getConfig().getPriorFunction();
 }


Input:
private boolean parseDefaultStatement() {
    PsiBuilder.Marker mark = mark();
    match(DEFAULT_KEYWORD, "String_Node_Str");
    match(COLON, "String_Node_Str");
    mark.done(DEFAULT_STATEMENT);
    return true;
}

Output:
 private boolean parseDefaultStatement() {
-    PsiBuilder.Marker mark = mark();
+    PsiBuilder.Marker mark = b.mark();
     match(DEFAULT_KEYWORD, "String_Node_Str");


Input:
public void didUpdateUserLocation(final MKMapView mapView, final MKUserLocation userLocation) {
    final MachineSizedSIntPtr centerMapFirstTime = new MachineSizedSIntPtr();
    if ((userLocation.getCoordinate().getLatitude() != 0.0) && (userLocation.getCoordinate().getLongitude() != 0.0)) {
        Dispatch.once(centerMapFirstTime, new Runnable() {

            public void run() {
                mapView.setCenterCoordinate(userLocation.getCoordinate(), true);
            }
        });
    }
    geocoder.reverseGeocodeLocation(mapView.getUserLocation().getLocation(), new VoidBlock2<NSArray<CLPlacemark>, NSError>() {
        public void invoke(NSArray<CLPlacemark> placemarks, NSError error) {
            if (placemarks != null && placemarks.size() > 0) {
                placemark = placemarks.get(0);
                getAddressButton.setEnabled(true);
            } else {
            }
        }
    });
}

Output:
     if ((userLocation.getCoordinate().getLatitude() != 0.0) && (userLocation.getCoordinate().getLongitude() != 0.0)) {
-        Dispatch.once(centerMapFirstTime, new Runnable() {
+        Dispatch.once(new Runnable() {


Input:
public boolean apply(Game game, Ability source) {
    Player player = game.getPlayer(source.getControllerId());
    MageObject sourceObject = game.getObject(source.getSourceId());
    int boost = amount.calculate(game, source, this);
    if (player != null) {
        Choice typeChoice = new ChoiceImpl(true);
        typeChoice.setMessage("String_Node_Str");
        typeChoice.setChoices(CardRepository.instance.getCreatureTypes());
        while (!player.choose(outcome, typeChoice, game)) {
            if (!player.canRespond()) {
                return false;
            }
        }
        if (typeChoice.getChoice() != null) {
            game.informPlayers(sourceObject.getLogName() + "String_Node_Str" + typeChoice.getChoice());
        }
        FilterCreaturePermanent filterCreaturePermanent = new FilterCreaturePermanent();
        filterCreaturePermanent.add(new SubtypePredicate(typeChoice.getChoice()));
        game.addEffect(new BoostAllOfChosenSubtypeEffect(boost, boost, Duration.EndOfTurn, filterCreaturePermanent, false), source);
        return true;
    }
    return false;
}

Output:
         filterCreaturePermanent.add(new SubtypePredicate(typeChoice.getChoice()));
-        game.addEffect(new BoostAllOfChosenSubtypeEffect(boost, boost, Duration.EndOfTurn, filterCreaturePermanent, false), source);
+        game.addEffect(new BoostAllEffect(boost, boost, Duration.EndOfTurn, filterCreaturePermanent, false), source);
         return true;


Input:
public ItemStack craft(ItemStack input, List<ItemStack> expansions, boolean preview) {
    PipeWire wire = null;
    ItemStack facade = null;
    for (ItemStack stack : expansions) {
        if (wire == null && stack.getItem() instanceof ItemPipeWire) {
            wire = PipeWire.fromOrdinal(stack.getItemDamage());
            if (!preview) {
                stack.stackSize--;
            }
        } else if (facade == null && (stack.getItem() instanceof ItemFacade || stack.getItem() == BuildCraftTransport.pipeWire)) {
            facade = stack;
            if (!preview) {
                stack.stackSize--;
            }
        }
    }
    if (wire != null && facade != null) {
        ItemFacade.FacadeState[] states = ItemFacade.getFacadeStates(input);
        ItemFacade.FacadeState additionalState;
        if (facade.getItem() == BuildCraftTransport.plugItem) {
            additionalState = ItemFacade.FacadeState.createTransparent(wire);
        } else {
            additionalState = ItemFacade.getFacadeStates(facade)[0];
            additionalState = ItemFacade.FacadeState.create(additionalState.block, additionalState.metadata, wire);
        }
        for (int i = 0; i < states.length; i++) {
            if (states[i].wire == wire) {
                states[i] = additionalState;
                return ItemFacade.getFacade(states);
            }
        }
        return ItemFacade.getFacade(JavaTools.concat(states, new ItemFacade.FacadeState[] { additionalState }));
    } else {
        return null;
    }
}

Output:
             additionalState = ItemFacade.getFacadeStates(facade)[0];
-            additionalState = ItemFacade.FacadeState.create(additionalState.block, additionalState.metadata, wire);
+            additionalState = new ItemFacade.FacadeState(additionalState.block, additionalState.metadata, wire, additionalState.hollow);
         }


Input:
private ValidationResult verifyCodeExternal(ValueSet vs, CodeableConcept cc, boolean tryCache) throws Exception {
    ValidationResult res = handleByCache(vs, cc, tryCache);
    if (res != null)
        return res;
    Parameters pin = new Parameters();
    pin.addParameter().setName("String_Node_Str").setValue(cc);
    pin.addParameter().setName("String_Node_Str").setResource(vs);
    res = serverValidateCode(pin, false);
    Map<String, ValidationResult> cache = validationCache.get(vs.getUrl());
    cache.put(cacheId(cc), res);
    return res;
}

Output:
     pin.addParameter().setName("String_Node_Str").setResource(vs);
-    res = serverValidateCode(pin, false);
+    res = serverValidateCode(pin, tryCache);
     Map<String, ValidationResult> cache = validationCache.get(vs.getUrl());


Input:
public int compareTo(GenomeSJ o) {
    if (chromosome == o.chromosome) {
        if (firstBaseIntron == o.firstBaseIntron)
            return lastBaseIntron - o.lastBaseIntron;
        else
            return firstBaseIntron - o.firstBaseIntron;
    } else
        return chromosome - o.chromosome;
}

Output:
 public int compareTo(GenomeSJ o) {
-    if (chromosome == o.chromosome) {
-        if (firstBaseIntron == o.firstBaseIntron)
-            return lastBaseIntron - o.lastBaseIntron;
-        else
-            return firstBaseIntron - o.firstBaseIntron;
+    if (type == o.type) {
+        return secondary_key - o.secondary_key;
     } else


Input:
private void handleConnectorException(ServerContext context, Request request, ConnectorException exception, String resourceId, JsonValue before, JsonValue after, ResultHandler<?> handler, ActivityLogger connectorExceptionActivityLogger) {
    String message = MessageFormat.format("String_Node_Str", request.getRequestType(), exception.getClass().getSimpleName(), resourceId);
    try {
        throw exception;
    } catch (AlreadyExistsException e) {
        message = MessageFormat.format("String_Node_Str", request.getResourceName());
        handler.handleError(new ConflictException(message, exception));
    } catch (ConfigurationException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new InternalServerErrorException(message, exception));
    } catch (ConnectionBrokenException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new ServiceUnavailableException(message, exception));
    } catch (ConnectionFailedException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new ServiceUnavailableException(message, exception));
    } catch (ConnectorIOException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new ServiceUnavailableException(message, exception));
    } catch (OperationTimeoutException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new ServiceUnavailableException(message, exception));
    } catch (PasswordExpiredException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new ForbiddenException(message, exception));
    } catch (InvalidPasswordException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(ResourceException.getException(UNAUTHORIZED_ERROR_CODE, message, exception));
    } catch (UnknownUidException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), request.getResourceName(), resourceId);
        handler.handleError(new NotFoundException(message, exception).setDetail(new JsonValue(new HashMap<String, Object>())));
    } catch (InvalidCredentialException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(ResourceException.getException(UNAUTHORIZED_ERROR_CODE, message, exception));
    } catch (PermissionDeniedException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new ForbiddenException(message, exception));
    } catch (ConnectorSecurityException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new InternalServerErrorException(message, exception));
    } catch (InvalidAttributeValueException e) {
        message = MessageFormat.format("String_Node_Str" + "String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new BadRequestException(e));
    } catch (PreconditionFailedException e) {
        message = MessageFormat.format("String_Node_Str" + "String_Node_Str", request.getResourceName(), request.getRequestType().toString(), resourceId);
        handler.handleError(new org.forgerock.json.resource.PreconditionFailedException(e));
    } catch (PreconditionRequiredException e) {
        message = MessageFormat.format("String_Node_Str", request.getResourceName(), request.getRequestType().toString(), resourceId);
        handler.handleError(new org.forgerock.json.resource.PreconditionRequiredException(e));
    } catch (RetryableException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new ServiceUnavailableException(e));
    } catch (UnsupportedOperationException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new NotFoundException(e));
    } catch (IllegalArgumentException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new InternalServerErrorException(e));
    } catch (RemoteWrappedException e) {
        handleRemoteWrappedException(context, request, exception, resourceId, before, after, handler, connectorExceptionActivityLogger);
    } catch (ConnectorException e) {
        message = MessageFormat.format("String_Node_Str", request.getRequestType().toString(), resourceId);
        handler.handleError(new InternalServerErrorException(message, exception));
    } finally {
        logger.debug(message, exception);
        try {
            connectorExceptionActivityLogger.log(context, request.getRequestType(), message, resourceId, before, after, Status.FAILURE);
        } catch (ResourceException e) {
            logger.warn("String_Node_Str", e);
        }
    }
}

Output:
         message = MessageFormat.format("String_Node_Str" + "String_Node_Str", request.getRequestType().toString(), resourceId);
-        handler.handleError(new BadRequestException(e));
+        handler.handleError(new BadRequestException(message, exception));
     } catch (PreconditionFailedException e) {


Input:
public void testCrossReferencesPdb() throws IOException, StructureException {
    AtomCache cache = new AtomCache();
    cache.setUseMmCif(false);
    FileParsingParameters params = new FileParsingParameters();
    params.setAlignSeqRes(false);
    cache.setFileParsingParams(params);
    StructureIO.setAtomCache(cache);
    Structure structure = StructureIO.getStructure("String_Node_Str");
    System.out.println("String_Node_Str");
    doFullTest(structure);
}

Output:
     StructureIO.setAtomCache(cache);
-    Structure structure = StructureIO.getStructure("String_Node_Str");
+    Structure structure = StructureIO.getStructure(PDBCODE1);
     System.out.println("String_Node_Str");


Input:
public ScriptInfo generateScriptInfo(SourceGeneratorLocalData localData, List<GraphTargetItem> commands, int classPos) throws AVM2ParseException, CompilationException {
    Reference<Integer> class_index = new Reference<>(classPos);
    ScriptInfo si = new ScriptInfo();
    localData.currentScript = si;
    Trait[] traitArr = generateTraitsPhase1(null, null, false, localData, commands, si.traits, class_index);
    generateTraitsPhase2(new ArrayList<String>(), null, commands, traitArr, new ArrayList<Integer>(), localData);
    MethodInfo mi = new MethodInfo(new int[0], 0, 0, 0, new ValueKind[0], new int[0]);
    MethodBody mb = new MethodBody();
    mb.method_info = abc.addMethodInfo(mi);
    mb.setCode(new AVM2Code());
    List<AVM2Instruction> mbCode = mb.getCode().code;
    mbCode.add(ins(new GetLocal0Ins()));
    mbCode.add(ins(new PushScopeIns()));
    int traitScope = 2;
    Map<Trait, Integer> initScopes = new HashMap<>();
    for (Trait t : si.traits.traits) {
        if (t instanceof TraitClass) {
            TraitClass tc = (TraitClass) t;
            List<Integer> parents = new ArrayList<>();
            if (localData.documentClass) {
                mbCode.add(ins(new GetScopeObjectIns(), 0));
                traitScope++;
            } else {
                NamespaceSet nsset = new NamespaceSet(new int[] { abc.constants.constant_multiname.get(tc.name_index).namespace_index });
                mbCode.add(ins(new FindPropertyStrictIns(), abc.constants.getMultinameId(new Multiname(Multiname.MULTINAME, abc.constants.constant_multiname.get(tc.name_index).name_index, 0, abc.constants.getNamespaceSetId(nsset, true), 0, new ArrayList<Integer>()), true)));
            }
            if (abc.instance_info.get(tc.class_info).isInterface()) {
                mbCode.add(ins(new PushNullIns()));
            } else {
                parentNamesAddNames(abc, allABCs, abc.instance_info.get(tc.class_info).name_index, parents, new ArrayList<String>(), new ArrayList<String>());
                for (int i = parents.size() - 1; i >= 1; i--) {
                    mbCode.add(ins(new GetLexIns(), parents.get(i)));
                    mbCode.add(ins(new PushScopeIns()));
                    traitScope++;
                }
                mbCode.add(ins(new GetLexIns(), parents.get(1)));
            }
            mbCode.add(ins(new NewClassIns(), tc.class_info));
            if (!abc.instance_info.get(tc.class_info).isInterface()) {
                for (int i = parents.size() - 1; i >= 1; i--) {
                    mbCode.add(ins(new PopScopeIns()));
                }
            }
            mbCode.add(ins(new InitPropertyIns(), tc.name_index));
            initScopes.put(t, traitScope);
            traitScope = 1;
        }
    }
    mbCode.add(ins(new ReturnVoidIns()));
    mb.autoFillStats(abc, 1, false);
    abc.addMethodBody(mb);
    si.init_index = mb.method_info;
    localData.pkg = null;
    generateTraitsPhase3(1, false, null, null, false, localData, commands, si.traits, traitArr, initScopes, class_index);
    return si;
}

Output:
     localData.currentScript = si;
-    Trait[] traitArr = generateTraitsPhase1(null, null, false, localData, commands, si.traits, class_index);
+    Trait[] traitArr = generateTraitsPhase1(null, null, true, localData, commands, si.traits, class_index);
     generateTraitsPhase2(new ArrayList<String>(), null, commands, traitArr, new ArrayList<Integer>(), localData);


Input:
public void close(String volumePath) {
    Shell.SH.run("String_Node_Str", volumePath);
}

Output:
 public void close(String volumePath) {
-    Shell.SH.run("String_Node_Str", volumePath);
+    List<String> result = suRun("String_Node_Str", volumePath);
 }


Input:
public IMessage onMessage(PacketGetAdjacentBlocks message, MessageContext ctx) {
    MinecraftServer.getServer().addScheduledTask(() -> handle(message, ctx));
    return null;
}

Output:
 public IMessage onMessage(PacketGetAdjacentBlocks message, MessageContext ctx) {
-    MinecraftServer.getServer().addScheduledTask(() -> handle(message, ctx));
+    FMLCommonHandler.instance().getWorldThread(ctx.netHandler).addScheduledTask(() -> handle(message, ctx));
     return null;


Input:
public void testCreateFolderViewObject() throws Exception {
    boolean isSystem = false;
    String folderName = "String_Node_Str";
    PowerMockito.mockStatic(ProjectManager.class);
    ProjectManager mockProjectManager = mock(ProjectManager.class);
    Project mockProject = mock(Project.class);
    IProject mockIProject = mock(IProject.class);
    when(ProjectManager.getInstance()).thenReturn(mockProjectManager);
    when(ProjectManager.getInstance().getCurrentProject()).thenReturn(mockProject);
    IFolder mockFolder = mock(IFolder.class);
    PowerMockito.mockStatic(ResourceModelUtils.class);
    when(ResourceModelUtils.getProject(mockProject)).thenReturn(mockIProject);
    when(mockIProject.getFolder(Mockito.anyString())).thenReturn(mockFolder);
    when(mockFolder.exists()).thenReturn(false);
    PowerMockito.mockStatic(ResourceUtils.class);
    PowerMockito.doNothing().when(ResourceUtils.class, "String_Node_Str", mockFolder);
    ItemState mockItemState = mock(ItemState.class);
    when(mockItemState.getPath()).thenReturn("String_Node_Str");
    Item mockParentItem = mock(Item.class);
    when(mockParentItem.getState()).thenReturn(mockItemState);
    String processFolder = "String_Node_Str";
    PowerMockito.mockStatic(ERepositoryObjectType.class);
    ERepositoryObjectType mockType = mock(ERepositoryObjectType.class);
    when(mockType.getType()).thenReturn("String_Node_Str");
    when(ERepositoryObjectType.getFolderName(mockType)).thenReturn(processFolder);
    IRepositoryViewObject folderViewObject = RepositoryResourceUtil.createFolderViewObject(mockType, folderName, mockParentItem, isSystem);
    assertNotNull(folderViewObject);
    PowerMockito.verifyStatic(Mockito.times(1));
    ResourceUtils.createFolder(mockFolder);
}

Output:
     IFolder mockFolder = mock(IFolder.class);
-    PowerMockito.mockStatic(ResourceModelUtils.class);
-    when(ResourceModelUtils.getProject(mockProject)).thenReturn(mockIProject);
+    PowerMockito.mockStatic(ResourceUtils.class);
+    when(ResourceUtils.getProject(mockProject)).thenReturn(mockIProject);
     when(mockIProject.getFolder(Mockito.anyString())).thenReturn(mockFolder);


Input:
private void expandPronunciation(UnitContext leftContext, Pronunciation pronunciation, int which) {
    UnitContext startingContext = getStartingContext(pronunciation);
    String pname = "String_Node_Str" + pronunciation.getWord() + "String_Node_Str" + leftContext + "String_Node_Str" + startingContext + "String_Node_Str";
    PronunciationState ps = new PronunciationState(pname, pronunciation, which);
    T("String_Node_Str" + ps.getPronunciation() + "String_Node_Str" + leftContext);
    ContextPair cp = ContextPair.get(leftContext, startingContext);
    List epList = (List) entryPoints.get(cp);
    if (epList == null) {
        throw new Error("String_Node_Str" + cp);
    } else {
        epList.add(ps);
    }
    Unit[] units = pronunciation.getUnits();
    int fanOutPoint = units.length - getRightContextSize();
    if (fanOutPoint < 0) {
        fanOutPoint = 0;
    }
    SentenceHMMState tail = ps;
    for (int i = 0; tail != null && i < fanOutPoint; i++) {
        tail = attachUnit(ps, tail, units, i, leftContext, UnitContext.EMPTY);
    }
    SentenceHMMState branchTail = tail;
    for (Iterator iter = rightContexts.iterator(); iter.hasNext(); ) {
        UnitContext finalRightContext = (UnitContext) iter.next();
        tail = branchTail;
        for (int i = fanOutPoint; tail != null && i < units.length; i++) {
            tail = attachUnit(ps, tail, units, i, leftContext, finalRightContext);
        }
    }
}

Output:
     UnitContext startingContext = getStartingContext(pronunciation);
-    String pname = "String_Node_Str" + pronunciation.getWord() + "String_Node_Str" + leftContext + "String_Node_Str" + startingContext + "String_Node_Str";
+    String pname = "String_Node_Str" + pronunciation.getWord() + "String_Node_Str" + leftContext + "String_Node_Str" + startingContext + "String_Node_Str" + getNode().getID();
     PronunciationState ps = new PronunciationState(pname, pronunciation, which);


Input:
public String createdDocumentsSea() {
    List<Documents> documentsList = new ArrayList<Documents>();
    List<String> vendorCodeDocument = new ArrayList<String>();
    List<OrderItems> orderItemsList = new ArrayList<OrderItems>();
    Orders orderEntity = orderService.findOrdersById(orderIdParam);
    order = transformToOrderFormBean(orderEntity);
    orderItemsList = operationsService.findAllOrderItemsByOrderId(orderIdParam);
    for (OrderItems everyItem : orderItemsList) {
        if (vendorCodeDocument.isEmpty()) {
            vendorCodeDocument.add(everyItem.getVendorSea());
        } else {
            if (!vendorCodeDocument.contains(everyItem.getVendorSea())) {
                vendorCodeDocument.add(everyItem.getVendorSea());
            }
        }
    }
    List<Documents> proforma = documentsService.findDocumentNameAndId("String_Node_Str", orderIdParam);
    List<Documents> houseWayBill = documentsService.findDocumentNameAndId("String_Node_Str", orderIdParam);
    for (String itemVendor : vendorCodeDocument) {
        if (proforma.size() == 0) {
            Documents documentEntityProforma = new Documents();
            Client client = clientService.findClientById(getClientId().toString());
            documentEntityProforma.setClient(client);
            documentEntityProforma.setDocumentName(DocumentsConstants.PROFORMA_BILL_OF_LADING);
            documentEntityProforma.setReferenceId(orderEntity.getOrderId());
            documentEntityProforma.setReferenceTable("String_Node_Str");
            documentEntityProforma.setOrderNumber(orderEntity.getOrderNumber());
            documentEntityProforma.setCreatedDate(new Date());
            documentEntityProforma.setDocumentStatus("String_Node_Str");
            documentEntityProforma.setVendorCode(itemVendor);
            documentEntityProforma.setOutboundStage(1);
            documentEntityProforma.setDocumentProcessed(0);
            documentsService.addDocuments(documentEntityProforma);
        } else {
            clearErrorsAndMessages();
            addActionError("String_Node_Str");
            for (OrderItems orderItemsElem : orderItemsList) {
                orderItems.add(transformToOrderItemFormBean(orderItemsElem));
            }
            return INPUT;
        }
    }
    if (houseWayBill.size() == 0) {
        Documents documentEntityHouse = new Documents();
        Client client = clientService.findClientById(getClientId().toString());
        documentEntityHouse.setClient(client);
        documentEntityHouse.setDocumentName(DocumentsConstants.HOUSE_BILL_OF_LADING);
        documentEntityHouse.setReferenceId(orderEntity.getOrderId());
        documentEntityHouse.setReferenceTable("String_Node_Str");
        documentEntityHouse.setOrderNumber(orderEntity.getOrderNumber());
        documentEntityHouse.setCreatedDate(new Date());
        documentEntityHouse.setDocumentStatus("String_Node_Str");
        documentEntityHouse.setVendorCode("String_Node_Str");
        documentEntityHouse.setOutboundStage(1);
        documentEntityHouse.setDocumentProcessed(0);
        documentsService.addDocuments(documentEntityHouse);
    } else {
        clearErrorsAndMessages();
        addActionError("String_Node_Str");
        for (OrderItems orderItemsElem : orderItemsList) {
            orderItems.add(transformToOrderItemFormBean(orderItemsElem));
        }
        return INPUT;
    }
    clearErrorsAndMessages();
    addActionMessage("String_Node_Str");
    for (OrderItems orderItemsElem : orderItemsList) {
        orderItems.add(transformToOrderItemFormBean(orderItemsElem));
    }
    return SUCCESS;
}

Output:
     for (String itemVendor : vendorCodeDocument) {
-        if (proforma.size() == 0) {
-            Documents documentEntityProforma = new Documents();
-            Client client = clientService.findClientById(getClientId().toString());
-            documentEntityProforma.setClient(client);
-            documentEntityProforma.setDocumentName(DocumentsConstants.PROFORMA_BILL_OF_LADING);
-            documentEntityProforma.setReferenceId(orderEntity.getOrderId());
-            documentEntityProforma.setReferenceTable("String_Node_Str");
-            documentEntityProforma.setOrderNumber(orderEntity.getOrderNumber());
-            documentEntityProforma.setCreatedDate(new Date());
-            documentEntityProforma.setDocumentStatus("String_Node_Str");
-            documentEntityProforma.setVendorCode(itemVendor);
-            documentEntityProforma.setOutboundStage(1);
-            documentEntityProforma.setDocumentProcessed(0);
-            documentsService.addDocuments(documentEntityProforma);
+        if (itemVendor != null) {
+            if (proforma.size() == 0) {
+                Documents documentEntityProforma = new Documents();
+                Client client = clientService.findClientById(getClientId().toString());
+                documentEntityProforma.setClient(client);
+                documentEntityProforma.setDocumentName(DocumentsConstants.PROFORMA_BILL_OF_LADING);
+                documentEntityProforma.setReferenceId(orderEntity.getOrderId());
+                documentEntityProforma.setReferenceTable("String_Node_Str");
+                documentEntityProforma.setOrderNumber(orderEntity.getOrderNumber());
+                documentEntityProforma.setCreatedDate(new Date());
+                documentEntityProforma.setDocumentStatus("String_Node_Str");
+                documentEntityProforma.setVendorCode(itemVendor);
+                documentEntityProforma.setOutboundStage(1);
+                documentEntityProforma.setDocumentProcessed(0);
+                documentsService.addDocuments(documentEntityProforma);
+            } else {
+                clearErrorsAndMessages();
+                addActionError("String_Node_Str");
+                for (OrderItems orderItemsElem : orderItemsList) {
+                    orderItems.add(transformToOrderItemFormBean(orderItemsElem));
+                }
+                return INPUT;
+            }
         } else {


Input:
public AxisSpace reserveSpace(Graphics2D g2, Plot plot, Rectangle2D plotArea, RectangleEdge edge, AxisSpace space) {
    if (space == null) {
        space = new AxisSpace();
    }
    if (!isVisible()) {
        return space;
    }
    double dimension = getFixedDimension();
    if (dimension > 0.0) {
        space.ensureAtLeast(dimension, edge);
    }
    double tickLabelHeight = 0.0;
    double tickLabelWidth = 0.0;
    if (isTickLabelsVisible()) {
        g2.setFont(getTickLabelFont());
        List ticks = refreshTicks(g2, new AxisState(), plotArea, edge);
        if (RectangleEdge.isTopOrBottom(edge)) {
            tickLabelHeight = findMaximumTickLabelHeight(ticks, g2, plotArea, isVerticalTickLabels());
        } else if (RectangleEdge.isLeftOrRight(edge)) {
            tickLabelWidth = findMaximumTickLabelWidth(ticks, g2, plotArea, isVerticalTickLabels());
        }
    }
    Rectangle2D labelEnclosure = getLabelEnclosure(g2, edge);
    double labelHeight = 0.0;
    double labelWidth = 0.0;
    if (RectangleEdge.isTopOrBottom(edge)) {
        labelHeight = labelEnclosure.getHeight();
        space.add(labelHeight + tickLabelHeight, edge);
    } else if (RectangleEdge.isLeftOrRight(edge)) {
        labelWidth = labelEnclosure.getWidth();
        space.add(labelWidth + tickLabelWidth, edge);
    }
    return space;
}

Output:
     if (dimension > 0.0) {
-        space.ensureAtLeast(dimension, edge);
+        space.add(dimension, edge);
+        return space;
     }


Input:
public void validateCDHVersion(List<String> warningMsgList) {
    if (this.getDistroVendor().equalsIgnoreCase(Constants.CDH_VENDOR) && (compare(this.getDistroVersion(), "String_Node_Str") > 0)) {
        warningMsgList.add(Constants.MUST_CONFIGURE_FQDN);
    }
}

Output:
 public void validateCDHVersion(List<String> warningMsgList) {
-    if (this.getDistroVendor().equalsIgnoreCase(Constants.CDH_VENDOR) && (compare(this.getDistroVersion(), "String_Node_Str") > 0)) {
-        warningMsgList.add(Constants.MUST_CONFIGURE_FQDN);
+    if (this.getDistroVendor().equalsIgnoreCase(Constants.CDH_VENDOR)) {
+        Pattern pattern = Pattern.compile(Constants.CDH4_PATTERN);
+        if (!pattern.matcher(this.getDistroVersion()).matches()) {
+            return;
+        }
+        if (compare(this.getDistroVersion(), "String_Node_Str") > 0) {
+            warningMsgList.add(Constants.MUST_CONFIGURE_FQDN);
+        }
     }


Input:
public void handleEvent(AEvent event) {
    if (event instanceof SelectionCommandEvent) {
        SelectionCommandEvent selectionCommandEvent = (SelectionCommandEvent) event;
        SelectionCommand selectionCommand = selectionCommandEvent.getSelectionCommand();
        EIDCategory category = selectionCommandEvent.getCategory();
        String dataDomainType = selectionCommandEvent.getDataDomainType();
        handler.handleForeignSelectionCommand(dataDomainType, category, selectionCommand);
    }
}

Output:
         SelectionCommand selectionCommand = selectionCommandEvent.getSelectionCommand();
-        EIDCategory category = selectionCommandEvent.getCategory();
+        IDType idType = selectionCommandEvent.getIDType();
         String dataDomainType = selectionCommandEvent.getDataDomainType();


Input:
public void centerOnScreen() {
    VideoMode mode = Monitor.getPrimaryMonitor().getVideoMode();
    Vector2 windowPosition = window.getPosition();
    windowPosition.x = (mode.getWidth() - windowPosition.x) / 2;
    windowPosition.y = (mode.getHeight() - windowPosition.y) / 2;
    window.setPosition(windowPosition);
}

Output:
     VideoMode mode = Monitor.getPrimaryMonitor().getVideoMode();
-    Vector2 windowPosition = window.getPosition();
+    Vector2 windowPosition = window.getSize();
     windowPosition.x = (mode.getWidth() - windowPosition.x) / 2;


Input:
public void cassandra_process_should_be_started() {
    createStructure();
    ColumnFamilyTemplate<String, String> columnFamilyTemplate = columnFamilyTemplate("String_Node_Str", "String_Node_Str", "String_Node_Str");
    Mutator<String> mutator = columnFamilyTemplate.createMutator();
    mutator.insert("String_Node_Str", "String_Node_Str", HFactory.createStringColumn("String_Node_Str", "String_Node_Str"));
    ColumnFamilyResult<String, String> res = columnFamilyTemplate.queryColumns("String_Node_Str");
    String value = res.getString("String_Node_Str");
    assertThat(value, is("String_Node_Str"));
    dropStructure();
}

Output:
 public void cassandra_process_should_be_started() {
-    createStructure();
-    ColumnFamilyTemplate<String, String> columnFamilyTemplate = columnFamilyTemplate("String_Node_Str", "String_Node_Str", "String_Node_Str");
-    Mutator<String> mutator = columnFamilyTemplate.createMutator();
-    mutator.insert("String_Node_Str", "String_Node_Str", HFactory.createStringColumn("String_Node_Str", "String_Node_Str"));
-    ColumnFamilyResult<String, String> res = columnFamilyTemplate.queryColumns("String_Node_Str");
-    String value = res.getString("String_Node_Str");
-    assertThat(value, is("String_Node_Str"));
-    dropStructure();
+    try {
+        CassandraOperation cassandraOperation = new CassandraOperation(new CassandraConfiguration("String_Node_Str", "String_Node_Str", 9160));
+        cassandraOperation.insert(new ByteArrayInputStream(INSERT_DATA.getBytes()));
+        cassandraOperation.deleteAll();
+    } catch (Throwable t) {
+        t.printStackTrace();
+        Assert.fail();
+    }
 }


Input:
public List<CommodityActionValue> fetchCommodityActionValues(List<Commodity> commodities, User user) {
    Dhis2Endpoint service = dhis2EndPointFactory.create(user);
    DataValueSet valueSet = new DataValueSet();
    try {
        String dataSet2 = getDataSetId(commodities, DataElementType.AMC.getActivity());
        String dataSetId = getDataSetId(commodities, DataElementType.STOCK_ON_HAND.getActivity());
        valueSet = service.fetchDataValuesEx(dataSetId, user.getFacilityCode(), twoMonthsAgo(), today(), dataSet2);
    } catch (LmisException exception) {
        e(SYNC, "String_Node_Str");
    }
    return convertDataValuesToCommodityActions(valueSet.getDataValues());
}

Output:
         String dataSetId = getDataSetId(commodities, DataElementType.STOCK_ON_HAND.getActivity());
-        valueSet = service.fetchDataValuesEx(dataSetId, user.getFacilityCode(), twoMonthsAgo(), today(), dataSet2);
+        valueSet = service.fetchDataValuesEx(dataSetId, user.getFacilityCode(), threeMonthsAgo(), today(), dataSet2);
     } catch (LmisException exception) {


Input:
public void startRequest(DIRRequest rq) {
    final xtreemfs_service_deregisterRequest request = (xtreemfs_service_deregisterRequest) rq.getRequestMessage();
    BabuDBInsertGroup ig;
    try {
        ig = database.createInsertGroup();
    } catch (BabuDBException ex) {
        if (ex.getErrorCode() == ErrorCode.NO_ACCESS && dbsReplicationManager != null)
            rq.sendRedirectException(dbsReplicationManager.getMaster());
        else
            rq.sendInternalServerError(ex);
        return;
    }
    ig.addDelete(DIRRequestDispatcher.INDEX_ID_SERVREG, request.getUuid().getBytes());
    database.insert(ig, rq).registerListener(new BabuDBRequestListener<Object>() {
        public void finished(Object arg0, Object context) {
            ((DIRRequest) context).sendSuccess(request.createDefaultResponse());
        }
        public void failed(BabuDBException e, Object context) {
            Logging.logError(Logging.LEVEL_ERROR, this, e);
            if (e.getErrorCode() == ErrorCode.NO_ACCESS && dbsReplicationManager != null)
                ((DIRRequest) context).sendRedirectException(dbsReplicationManager.getMaster());
            else
                ((DIRRequest) context).sendInternalServerError(e);
        }
    });
}

Output:
 public void startRequest(DIRRequest rq) {
-    final xtreemfs_service_deregisterRequest request = (xtreemfs_service_deregisterRequest) rq.getRequestMessage();
+    xtreemfs_service_deregisterRequest request = (xtreemfs_service_deregisterRequest) rq.getRequestMessage();
     BabuDBInsertGroup ig;


Input:
public void testCursorModel3() throws OLAPException, BirtException {
    ICubeQueryDefinition cqd = new CubeQueryDefinition(CubeUtility.cubeName);
    cqd.createMeasure("String_Node_Str");
    IEdgeDefinition rowEdge = cqd.createEdge(ICubeQueryDefinition.ROW_EDGE);
    IDimensionDefinition dim1 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier1 = dim1.createHierarchy("String_Node_Str");
    hier1.createLevel("String_Node_Str");
    IDimensionDefinition dim2 = rowEdge.createDimension("String_Node_Str");
    IHierarchyDefinition hier2 = dim2.createHierarchy("String_Node_Str");
    hier2.createLevel("String_Node_Str");
    BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(null, cqd, de.getSession(), this.scope, de.getContext()));
    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube);
    EdgeCursor rowCursor = cubeView.getRowEdgeView().getEdgeCursor();
    DimensionCursor productCursor1 = (DimensionCursor) rowCursor.getDimensionCursor().get(0);
    DimensionCursor productCursor2 = (DimensionCursor) rowCursor.getDimensionCursor().get(1);
    testOut.print(creator.printCubeAlongDimension(dataCursor, null, null, null, null, productCursor1, productCursor2));
    try {
        this.checkOutputFile();
    } catch (Exception e) {
        fail("String_Node_Str");
    }
}

Output:
     BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(null, cqd, de.getSession(), this.scope, de.getContext()));
-    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube);
+    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube, false);
     EdgeCursor rowCursor = cubeView.getRowEdgeView().getEdgeCursor();


Input:
public void filterBases(ObjectArrayList<PositionBaseInfo> list, SampleCountInfo[] sampleCounts, ObjectArrayList<PositionBaseInfo> filteredList) {
    resetCounters();
    Arrays.fill(removed, 0);
    for (PositionBaseInfo info : list) {
        numScreened++;
        if (!info.matchesReference && info.qualityScore < scoreThreshold) {
            filteredList.add(info);
            final SampleCountInfo countInfo = sampleCounts[info.readerIndex];
            final int baseIndex = countInfo.baseIndex(info.to);
            countInfo.counts[baseIndex]--;
            removed[baseIndex]++;
            numFiltered++;
        }
    }
    adjustRefVarCounts(sampleCounts, removed);
}

Output:
     }
-    adjustRefVarCounts(sampleCounts, removed);
+    adjustRefVarCounts(sampleCounts);
 }


Input:
public void setSizeFactor(TextDataImpl text, ModelImpl model) {
    float factor = textModel.sizeFactor / FACTOR * model.getCameraDistance();
    text.setSizeFactor(factor);
}

Output:
 public void setSizeFactor(TextDataImpl text, ModelImpl model) {
-    float factor = textModel.sizeFactor / FACTOR * model.getCameraDistance();
+    float factor = FACTOR * textModel.sizeFactor / model.getCameraDistance();
     text.setSizeFactor(factor);


Input:
private String getBaseUri() throws BatchException {
    String baseUri = "String_Node_Str";
    if (batchRequestPathInfo != null && batchRequestPathInfo.getServiceRoot() != null) {
        final String uri = batchRequestPathInfo.getServiceRoot().toASCIIString();
        baseUri = addPathSegements(removeLastSlash(uri));
    }
    return baseUri;
}

Output:
         final String uri = batchRequestPathInfo.getServiceRoot().toASCIIString();
-        baseUri = addPathSegements(removeLastSlash(uri));
+        baseUri = removeLastSlash(uri);
     }


Input:
public static boolean sequenceExists(Connection connection, String sequenceName) {
    boolean exists = false;
    PreparedStatement statement = null;
    ResultSet results = null;
    boolean schemaFilter = false;
    try {
        String schema = getSchemaName(connection);
        schema = canonicalize(connection, schema);
        sequenceName = canonicalize(connection, sequenceName);
        String dbtype = findDbKeyword(connection.getMetaData());
        String sequenceSQL = null;
        switch(dbtype) {
            case DBMS_POSTGRES:
                if (schema == null) {
                    schema = "String_Node_Str";
                }
                sequenceSQL = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
                schemaFilter = true;
                break;
            case DBMS_ORACLE:
                sequenceSQL = "String_Node_Str";
                break;
            case DBMS_H2:
                sequenceSQL = "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
                break;
            default:
                throw new SQLException("String_Node_Str" + dbtype + "String_Node_Str");
        }
        if (sequenceSQL != null) {
            statement = connection.prepareStatement(sequenceSQL);
            statement.setString(1, sequenceName);
            if (schemaFilter) {
                statement.setString(2, schema);
            }
            results = statement.executeQuery();
            if (results != null && results.next() && results.getInt(1) > 0) {
                exists = true;
            }
        }
    } catch (SQLException e) {
        log.error("String_Node_Str" + sequenceName + "String_Node_Str", e);
    } finally {
        try {
            if (statement != null && !statement.isClosed())
                statement.close();
            if (results != null && !results.isClosed())
                results.close();
        } catch (SQLException e) {
        }
    }
    return exists;
}

Output:
         sequenceName = canonicalize(connection, sequenceName);
-        String dbtype = findDbKeyword(connection.getMetaData());
+        String dbtype = getDbType(connection);
         String sequenceSQL = null;


Input:
public void onStop() {
    super.onStop();
    mScrollHandler.removeMessages(KEY_MESSAGE_SCROLL_TO_PAGE);
}

Output:
     super.onStop();
-    mScrollHandler.removeMessages(KEY_MESSAGE_SCROLL_TO_PAGE);
+    mUiHandler.removeMessages(KEY_MESSAGE_SCROLL_TO_PAGE);
 }


Input:
public void resolveTypes(MarkerList markers, IContext context) {
    if (this.lowerBound != null) {
        this.lowerBound = this.lowerBound.resolve(markers, context);
    }
    if (this.upperBoundCount > 0) {
        IType type = this.upperBounds[0];
        IClass iclass = type.getTheClass();
        if (iclass != null) {
            if (iclass.hasModifier(Modifiers.INTERFACE_CLASS)) {
                if (++this.upperBoundCount > this.upperBounds.length) {
                    IType[] temp = new IType[this.upperBoundCount];
                    temp[0] = Type.OBJECT;
                    System.arraycopy(this.upperBounds, 0, temp, 1, this.upperBoundCount - 1);
                    this.upperBounds = temp;
                } else {
                    System.arraycopy(this.upperBounds, 0, this.upperBounds, 1, this.upperBoundCount - 1);
                    this.upperBounds[0] = Type.OBJECT;
                }
            }
        }
        for (int i = 1; i < this.upperBoundCount; i++) {
            type = this.upperBounds[i];
            iclass = type.getTheClass();
            if (iclass != null && !iclass.hasModifier(Modifiers.INTERFACE_CLASS)) {
                System.arraycopy(this.upperBounds, i + 1, this.upperBounds, i, this.upperBoundCount - i - 1);
                this.upperBoundCount--;
                i--;
            }
        }
    }
    this.captureClass = new CaptureClass(this, this.upperBounds, this.upperBoundCount, this.lowerBound);
}

Output:
     if (this.upperBoundCount > 0) {
-        IType type = this.upperBounds[0];
+        IType type = this.upperBounds[0] = this.upperBounds[0].resolve(markers, context);
         IClass iclass = type.getTheClass();


Input:
public void handle(RpbGetResp resp, String vclock) throws Exception {
    try {
        handler.begin();
        for (RpbContent c : resp.getContentList()) {
            RiakObject<byte[]> ro = convert(location, vclock, c);
            handler.handle(support.newResponse(ro));
        }
    } finally {
        handler.end();
    }
}

Output:
             RiakObject<byte[]> ro = convert(location, vclock, c);
-            handler.handle(support.newResponse(ro));
+            handler.handle(PbcRiakOperations.this.support.newResponse(ro));
         }


Input:
public void shouldErrorOnCreateWithoutName() throws Exception {
    String json = jsonFixture("String_Node_Str");
    ClientResponse response = createResponseFor(json);
    ErrorMessages.assertThat(response.getEntity(String.class)).matches("String_Node_Str", 422, "String_Node_Str");
}

Output:
     String json = jsonFixture("String_Node_Str");
-    ClientResponse response = createResponseFor(json);
+    CreateMetricCommand metric = fromJson(json, CreateMetricCommand.class);
+    metric.timestamp = timestamp;
+    ClientResponse response = createResponseFor(metric);
     ErrorMessages.assertThat(response.getEntity(String.class)).matches("String_Node_Str", 422, "String_Node_Str");


Input:
private void initalize(PageDef page) {
    axis = new AxisProcessor();
    axis.addCoordinate(page.contentwidth);
    setCacheSize();
    ContainerSizeInfo rule = new ContainerSizeInfo(0, page.contentwidth);
    cache = new DataCache(MAX_COLUMN, MAX_ROW, emitter);
    engine = new StyleEngine(this);
    containers.push(createContainer(rule, page.style));
}

Output:
     engine = new StyleEngine(this);
-    containers.push(createContainer(rule, page.style));
+    containers.push(createContainer(rule, page.style, null));
 }


Input:
public UrlParameterMultimap remove(final String key, final String value) {
    if (key == null || value == null) {
        throw new NullPointerException("String_Node_Str");
    }
    for (final Entry<String, String> e : data) {
        if (key.equals(e.getKey()) && value.equals(e.getValue())) {
            data.remove(e);
        }
    }
    return this;
}

Output:
     if (key == null || value == null) {
-        throw new NullPointerException("String_Node_Str");
+        throw new IllegalArgumentException("String_Node_Str");
     }


Input:
private void addWord(StringBuffer sb, Word word, FloatData startFeature, FloatData endFeature) {
    float startTime = ((float) startFeature.getFirstSampleNumber() / startFeature.getSampleRate());
    float endTime = ((float) endFeature.getFirstSampleNumber() / endFeature.getSampleRate());
    if (sb.length() > 0) {
        sb.insert(0, "String_Node_Str");
    }
    sb.insert(0, (word.getSpelling() + "String_Node_Str" + startTime + "String_Node_Str" + endTime + "String_Node_Str"));
}

Output:
 private void addWord(StringBuffer sb, Word word, FloatData startFeature, FloatData endFeature) {
-    float startTime = ((float) startFeature.getFirstSampleNumber() / startFeature.getSampleRate());
-    float endTime = ((float) endFeature.getFirstSampleNumber() / endFeature.getSampleRate());
+    float startTime = startFeature == null ? -1 : ((float) startFeature.getFirstSampleNumber() / startFeature.getSampleRate());
+    float endTime = endFeature == null ? -1 : ((float) endFeature.getFirstSampleNumber() / endFeature.getSampleRate());
     if (sb.length() > 0) {


Input:
public boolean onPreferenceClick(Preference preference) {
    new AlertDialog.Builder(getActivity()).setTitle("String_Node_Str").setMessage("String_Node_Str").setPositiveButton("String_Node_Str", new DialogInterface.OnClickListener() {
        public void onClick(DialogInterface dialog, int which) {
            SettingsHelper.resetToDefaults(sharedPref);
            Toast.makeText(getActivity(), "String_Node_Str", Toast.LENGTH_SHORT).show();
        }
    }).setNegativeButton("String_Node_Str", new DialogInterface.OnClickListener() {

        public void onClick(DialogInterface dialog, int which) {
        }
    }).setIcon(android.R.drawable.ic_dialog_alert).show();
    return true;
}

Output:
         }
-    }).setNegativeButton("String_Node_Str", new DialogInterface.OnClickListener() {
+    }).setNegativeButton(R.string.dialog_cancel, new DialogInterface.OnClickListener() {


Input:
public boolean checkFlight(Player player, Distance distance) {
    if (distance.getYDifference() > 400) {
        return false;
    }
    String name = player.getName();
    double y1 = distance.fromY();
    double y2 = distance.toY();
    if (!isMovingExempt(player) && !Utilities.isInWater(player) && !Utilities.canStand(player.getLocation().getBlock()) && Utilities.cantStandAt(player.getLocation().add(0, -1, 0).getBlock()) && Utilities.cantStandAt(player.getLocation().add(0, -2, 0).getBlock())) {
        Block block = player.getLocation().getBlock();
        if (block.getRelative(BlockFace.NORTH).isLiquid() || block.getRelative(BlockFace.SOUTH).isLiquid() || block.getRelative(BlockFace.EAST).isLiquid() || block.getRelative(BlockFace.WEST).isLiquid()) {
            if (y1 < y2) {
                return distance.getYDifference() > magic.WATER_CLIMB_MAX;
            }
        } else if (y1 == y2 || y1 < y2) {
            if (y1 == y2) {
                if (block.getRelative(BlockFace.NORTH).getTypeId() == 43 || block.getRelative(BlockFace.NORTH).getTypeId() == 44 || block.getRelative(BlockFace.SOUTH).getTypeId() == 43 || block.getRelative(BlockFace.SOUTH).getTypeId() == 44 || block.getRelative(BlockFace.EAST).getTypeId() == 43 || block.getRelative(BlockFace.EAST).getTypeId() == 44 || block.getRelative(BlockFace.WEST).getTypeId() == 43 || block.getRelative(BlockFace.WEST).getTypeId() == 44) {
                    return false;
                } else if (player.isSneaking() && (Utilities.isStair(block.getRelative(BlockFace.NORTH)) || Utilities.isStair(block.getRelative(BlockFace.SOUTH)) || Utilities.isStair(block.getRelative(BlockFace.EAST)) || Utilities.isStair(block.getRelative(BlockFace.WEST)) || Utilities.isStair(block.getRelative(BlockFace.NORTH_EAST)) || Utilities.isStair(block.getRelative(BlockFace.SOUTH_EAST)) || Utilities.isStair(block.getRelative(BlockFace.SOUTH_WEST)) || Utilities.isStair(block.getRelative(BlockFace.NORTH_WEST)))) {
                    return false;
                }
            }
            int violation = flightViolation.containsKey(name) ? flightViolation.get(name) + 1 : 1;
            increment(player, flightViolation, violation);
            if (violation > magic.FLIGHT_LIMIT) {
                return true;
            } else {
                return false;
            }
        }
    }
    flightViolation.put(name, 0);
    return false;
}

Output:
             if (y1 == y2) {
-                if (block.getRelative(BlockFace.NORTH).getTypeId() == 43 || block.getRelative(BlockFace.NORTH).getTypeId() == 44 || block.getRelative(BlockFace.SOUTH).getTypeId() == 43 || block.getRelative(BlockFace.SOUTH).getTypeId() == 44 || block.getRelative(BlockFace.EAST).getTypeId() == 43 || block.getRelative(BlockFace.EAST).getTypeId() == 44 || block.getRelative(BlockFace.WEST).getTypeId() == 43 || block.getRelative(BlockFace.WEST).getTypeId() == 44) {
+                if (block.getRelative(BlockFace.NORTH).getTypeId() == 43 || block.getRelative(BlockFace.NORTH).getTypeId() == 44 || block.getRelative(BlockFace.SOUTH).getTypeId() == 43 || block.getRelative(BlockFace.SOUTH).getTypeId() == 44 || block.getRelative(BlockFace.EAST).getTypeId() == 43 || block.getRelative(BlockFace.EAST).getTypeId() == 44 || block.getRelative(BlockFace.WEST).getTypeId() == 43 || block.getRelative(BlockFace.WEST).getTypeId() == 44 || block.getRelative(BlockFace.SOUTH_EAST).getTypeId() == 43 || block.getRelative(BlockFace.SOUTH_EAST).getTypeId() == 44 || block.getRelative(BlockFace.SOUTH_WEST).getTypeId() == 43 || block.getRelative(BlockFace.SOUTH_WEST).getTypeId() == 44 || block.getRelative(BlockFace.NORTH_EAST).getTypeId() == 43 || block.getRelative(BlockFace.NORTH_EAST).getTypeId() == 44 || block.getRelative(BlockFace.NORTH_WEST).getTypeId() == 43 || block.getRelative(BlockFace.NORTH_WEST).getTypeId() == 44) {
                     return false;


Input:
private boolean saveHistory() {
    if (config.isReducedHistory()) {
        List<Record> records = history.getRecords();
        Calendar limitCal = Calendar.getInstance();
        limitCal.add(Calendar.DAY_OF_MONTH, -config.getReducedHistoryCount());
        Date limit = limitCal.getTime();
        logger.fine("String_Node_Str" + limit);
        ListIterator<Record> iter = records.listIterator();
        while (iter.hasNext()) {
            Record record = iter.next();
            if (record.getDate().before(limit)) {
                iter.remove();
            } else {
                break;
            }
        }
    }
    try {
        persistenceManager.saveHistory();
        return true;
    } catch (Exception ex) {
        logger.log(Level.WARNING, "String_Node_Str", ex);
        return false;
    }
}

Output:
         Date limit = limitCal.getTime();
-        logger.fine("String_Node_Str" + limit);
-        ListIterator<Record> iter = records.listIterator();
-        while (iter.hasNext()) {
-            Record record = iter.next();
-            if (record.getDate().before(limit)) {
-                iter.remove();
-            } else {
-                break;
-            }
-        }
+        history.removeRecordsOlderThan(limit);
     }


Input:
public void loadEvent(WorldEvent.Load evt) {
    if (evt.world.isRemote) {
        return;
    }
    if (MinecraftServer.getServer().isDedicatedServer()) {
        if (evt.world.provider.dimensionId == 0 && !KnownDimletConfiguration.isInitialized()) {
            RFTools.log("String_Node_Str");
            KnownDimletConfiguration.initServer(evt.world);
            KnownDimletConfiguration.initCrafting(evt.world);
        }
    } else {
        if (!KnownDimletConfiguration.isInitialized()) {
            RFTools.log("String_Node_Str");
            KnownDimletConfiguration.initClient(evt.world);
            KnownDimletConfiguration.initCrafting(evt.world);
        }
    }
}

Output:
             RFTools.log("String_Node_Str");
-            KnownDimletConfiguration.initServer(evt.world);
+            KnownDimletConfiguration.init(evt.world);
             KnownDimletConfiguration.initCrafting(evt.world);


Input:
protected void reportConnected(boolean ready) {
    Util.runOnUI(new Runnable() {

        public void run() {
            if (listener != null)
                listener.onConnectionSuccess(DeviceService.this);
        }
    });
}

Output:
 protected void reportConnected(boolean ready) {
-    Util.runOnUI(new Runnable() {
+    if (listener == null)
+        return;
+    if (listener instanceof ConnectableDevice)
+        listener.onConnectionSuccess(this);
+    else {
+        Util.runOnUI(new Runnable() {


Input:
public Iterator<MetricValue> getMetaMetrics() {
    long currentTimeMs = System.currentTimeMillis();
    long currentTimeSec = TimeUnit.MILLISECONDS.toSeconds(currentTimeMs);
    MetricValue delayAvg = new MetricValue(ImmutableMap.of(Constants.Metrics.Tag.NAMESPACE, "String_Node_Str"), "String_Node_Str", currentTimeSec, currentTimeMs - TimeUnit.SECONDS.toMillis((long) processDelayStats.getAverage()), MetricType.GAUGE);
    MetricValue delayMin = new MetricValue(ImmutableMap.of(Constants.Metrics.Tag.NAMESPACE, "String_Node_Str"), "String_Node_Str", currentTimeSec, currentTimeMs - TimeUnit.SECONDS.toMillis(processDelayStats.getMin()), MetricType.GAUGE);
    MetricValue delayMax = new MetricValue(ImmutableMap.of(Constants.Metrics.Tag.NAMESPACE, "String_Node_Str"), "String_Node_Str", currentTimeSec, currentTimeMs - TimeUnit.SECONDS.toMillis(processDelayStats.getMax()), MetricType.GAUGE);
    MetricValue count = new MetricValue(ImmutableMap.of(Constants.Metrics.Tag.NAMESPACE, "String_Node_Str"), "String_Node_Str", currentTimeSec, processDelayStats.getCount(), MetricType.COUNTER);
    return ImmutableList.of(delayAvg, delayMin, delayMax, count).iterator();
}

Output:
     long currentTimeSec = TimeUnit.MILLISECONDS.toSeconds(currentTimeMs);
-    MetricValue delayAvg = new MetricValue(ImmutableMap.of(Constants.Metrics.Tag.NAMESPACE, "String_Node_Str"), "String_Node_Str", currentTimeSec, currentTimeMs - TimeUnit.SECONDS.toMillis((long) processDelayStats.getAverage()), MetricType.GAUGE);
+    MetricValue delayAvg = new MetricValue(ImmutableMap.of(Constants.Metrics.Tag.NAMESPACE, "String_Node_Str"), "String_Node_Str", currentTimeSec, currentTimeMs - TimeUnit.SECONDS.toMillis(processDelayStats.getAverage()), MetricType.GAUGE);
     MetricValue delayMin = new MetricValue(ImmutableMap.of(Constants.Metrics.Tag.NAMESPACE, "String_Node_Str"), "String_Node_Str", currentTimeSec, currentTimeMs - TimeUnit.SECONDS.toMillis(processDelayStats.getMin()), MetricType.GAUGE);


Input:
private void processClassVariable(VariableExpression expression) {
    String name = expression.getName();
    if (passingParams && controller.isInScriptBody()) {
        MethodVisitor mv = controller.getMethodVisitor();
        mv.visitTypeInsn(NEW, "String_Node_Str");
        mv.visitInsn(DUP);
        loadThisOrOwner();
        mv.visitLdcInsn(name);
        mv.visitMethodInsn(INVOKESPECIAL, "String_Node_Str", "String_Node_Str", "String_Node_Str", false);
    } else {
        PropertyExpression pexp = new PropertyExpression(new VariableExpression("String_Node_Str", ClassHelper.DYNAMIC_TYPE), name);
        pexp.getObjectExpression().setSourcePosition(expression);
        pexp.getProperty().setSourcePosition(expression);
        pexp.setImplicitThis(true);
        visitPropertyExpression(pexp);
    }
}

Output:
         loadThisOrOwner();
-        mv.visitLdcInsn(name);
+        mv.visitLdcInsn(expression.getName());
         mv.visitMethodInsn(INVOKESPECIAL, "String_Node_Str", "String_Node_Str", "String_Node_Str", false);


Input:
public Collection<EntityType> getOutcome() {
    Collection<EntityType> types = new ArrayList<EntityType>();
    for (int i = 0; i < nextAmount(); i++) {
        types.add(type);
    }
    return types;
}

Output:
     Collection<EntityType> types = new ArrayList<EntityType>();
-    for (int i = 0; i < nextAmount(); i++) {
+    int amount = nextAmount();
+    for (int i = 0; i < amount; i++) {
         types.add(type);


Input:
private RuleProps buildRuleProps(TaskProps props) {
    Expression priority = TclUtil.argToExpr(props.get(TaskPropKey.PRIORITY), true);
    TclTarget target = TclTarget.fromArg(props.get(TaskPropKey.LOCATION));
    Expression parallelism = TclUtil.argToExpr(props.get(TaskPropKey.PARALLELISM), true);
    RuleProps ruleProps = new RuleProps(target, parallelism, priority);
    return ruleProps;
}

Output:
     Expression priority = TclUtil.argToExpr(props.get(TaskPropKey.PRIORITY), true);
-    TclTarget target = TclTarget.fromArg(props.get(TaskPropKey.LOCATION));
+    TclTarget target = TclTarget.fromArg(props.getWithDefault(TaskPropKey.LOCATION));
     Expression parallelism = TclUtil.argToExpr(props.get(TaskPropKey.PARALLELISM), true);


Input:
public TaskSchedulePlan schedule(DataFlowTaskGraph graph, WorkerPlan workerPlan) {
    Set<TaskSchedulePlan.ContainerPlan> containerPlans = new HashSet<>();
    LinkedHashSet<Vertex> taskVertexSet = graph.getTaskVertexSet();
    Map<Integer, List<InstanceId>> datalocalityAwareContainerInstanceMap = DataLocalityAwareScheduling.DataLocalityAwareSchedulingAlgorithm(taskVertexSet, workerPlan.getNumberOfWorkers(), workerPlan, this.cfg);
    TaskInstanceMapCalculation instanceMapCalculation = new TaskInstanceMapCalculation(this.instanceRAM, this.instanceCPU, this.instanceDisk);
    Map<Integer, Map<InstanceId, Double>> instancesRamMap = instanceMapCalculation.getInstancesRamMapInContainer(datalocalityAwareContainerInstanceMap, taskVertexSet);
    Map<Integer, Map<InstanceId, Double>> instancesDiskMap = instanceMapCalculation.getInstancesDiskMapInContainer(datalocalityAwareContainerInstanceMap, taskVertexSet);
    Map<Integer, Map<InstanceId, Double>> instancesCPUMap = instanceMapCalculation.getInstancesCPUMapInContainer(datalocalityAwareContainerInstanceMap, taskVertexSet);
    for (int containerId : datalocalityAwareContainerInstanceMap.keySet()) {
        Double containerRAMValue = TaskSchedulerContext.containerRamPadding(cfg);
        Double containerDiskValue = TaskSchedulerContext.containerDiskPadding(cfg);
        Double containerCpuValue = TaskSchedulerContext.containerCpuPadding(cfg);
        List<InstanceId> taskInstanceIds = datalocalityAwareContainerInstanceMap.get(containerId);
        Map<InstanceId, TaskSchedulePlan.TaskInstancePlan> taskInstancePlanMap = new HashMap<>();
        for (InstanceId id : taskInstanceIds) {
            double instanceRAMValue = instancesRamMap.get(containerId).get(id);
            double instanceDiskValue = instancesDiskMap.get(containerId).get(id);
            double instanceCPUValue = instancesCPUMap.get(containerId).get(id);
            Resource instanceResource = new Resource(instanceRAMValue, instanceDiskValue, instanceCPUValue);
            taskInstancePlanMap.put(id, new TaskSchedulePlan.TaskInstancePlan(id.getTaskName(), id.getTaskId(), id.getTaskIndex(), instanceResource));
            containerRAMValue += instanceRAMValue;
            containerDiskValue += instanceDiskValue;
            containerCpuValue += instanceDiskValue;
        }
        Worker worker = workerPlan.getWorker(containerId);
        Resource containerResource;
        if (worker != null && worker.getCpu() > 0 && worker.getDisk() > 0 && worker.getRam() > 0) {
            containerResource = new Resource((double) worker.getRam(), (double) worker.getDisk(), (double) worker.getCpu());
            LOG.fine(String.format("String_Node_Str" + containerId + "String_Node_Str" + worker.getRam() + "String_Node_Str" + worker.getDisk() + "String_Node_Str" + worker.getCpu()));
        } else {
            containerResource = new Resource(containerRAMValue, containerDiskValue, containerCpuValue);
            LOG.fine(String.format("String_Node_Str" + containerId + "String_Node_Str" + containerRAMValue + "String_Node_Str" + containerDiskValue + "String_Node_Str" + containerCpuValue));
        }
        TaskSchedulePlan.ContainerPlan taskContainerPlan = new TaskSchedulePlan.ContainerPlan(containerId, new HashSet<>(taskInstancePlanMap.values()), containerResource);
        containerPlans.add(taskContainerPlan);
    }
    return new TaskSchedulePlan(taskSchedulePlanId, containerPlans);
}

Output:
     Set<TaskSchedulePlan.ContainerPlan> containerPlans = new HashSet<>();
-    LinkedHashSet<Vertex> taskVertexSet = graph.getTaskVertexSet();
+    Set<Vertex> taskVertexSet = graph.getTaskVertexSet();
     Map<Integer, List<InstanceId>> datalocalityAwareContainerInstanceMap = DataLocalityAwareScheduling.DataLocalityAwareSchedulingAlgorithm(taskVertexSet, workerPlan.getNumberOfWorkers(), workerPlan, this.cfg);


Input:
public void testCoverage() {
    File file0 = new File("String_Node_Str");
    File file1 = new File("String_Node_Str");
    File aspect1 = new File("String_Node_Str");
    File file2 = new File("String_Node_Str");
    File file3 = new File("String_Node_Str");
    File file4 = new File("String_Node_Str");
    File file5 = new File("String_Node_Str");
    File file6 = new File("String_Node_Str");
    File file7 = new File("String_Node_Str");
    File file8 = new File("String_Node_Str");
    File outdir = new File("String_Node_Str");
    String[] args = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", outdir.getAbsolutePath(), aspect1.getAbsolutePath(), file0.getAbsolutePath(), file1.getAbsolutePath(), file2.getAbsolutePath(), file3.getAbsolutePath(), file4.getAbsolutePath(), file5.getAbsolutePath(), file6.getAbsolutePath(), file7.getAbsolutePath(), file8.getAbsolutePath() };
    org.aspectj.tools.ajdoc.Main.main(args);
}

Output:
 public void testCoverage() {
-    File file0 = new File("String_Node_Str");
-    File file1 = new File("String_Node_Str");
-    File aspect1 = new File("String_Node_Str");
-    File file2 = new File("String_Node_Str");
-    File file3 = new File("String_Node_Str");
-    File file4 = new File("String_Node_Str");
-    File file5 = new File("String_Node_Str");
-    File file6 = new File("String_Node_Str");
-    File file7 = new File("String_Node_Str");
-    File file8 = new File("String_Node_Str");
-    File outdir = new File("String_Node_Str");
-    String[] args = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", outdir.getAbsolutePath(), aspect1.getAbsolutePath(), file0.getAbsolutePath(), file1.getAbsolutePath(), file2.getAbsolutePath(), file3.getAbsolutePath(), file4.getAbsolutePath(), file5.getAbsolutePath(), file6.getAbsolutePath(), file7.getAbsolutePath(), file8.getAbsolutePath() };
+    outdir.delete();
+    String[] args = { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", outdir.getAbsolutePath(), aspect1.getAbsolutePath(), file0.getAbsolutePath(), file1.getAbsolutePath(), file2.getAbsolutePath(), file3.getAbsolutePath(), file4.getAbsolutePath(), file5.getAbsolutePath(), file6.getAbsolutePath(), file7.getAbsolutePath(), file8.getAbsolutePath(), file9.getAbsolutePath() };
     org.aspectj.tools.ajdoc.Main.main(args);


Input:
public void performancesChanged(String connId, int exchangesCompleted) {
    long duration = 100;
    final IConnection conn = traceConnectionsManager.finConnectionByUniqueName(connId);
    final PerformanceData perfData = new PerformanceData(connId + "String_Node_Str" + exchangesCompleted + "String_Node_Str" + duration);
    processPerformances(connId + "String_Node_Str" + exchangesCompleted + "String_Node_Str" + duration, perfData, conn);
    startTime = System.currentTimeMillis();
}

Output:
 public void performancesChanged(String connId, int exchangesCompleted) {
-    long duration = 100;
+    long duration = System.currentTimeMillis() - startTime;
     final IConnection conn = traceConnectionsManager.finConnectionByUniqueName(connId);


Input:
public List<ScriptPack> getPacks(ABC abc, int scriptIndex, String packagePrefix) {
    List<ScriptPack> ret = new ArrayList<>();
    List<Integer> otherTraits = new ArrayList<>();
    for (int j = 0; j < traits.traits.size(); j++) {
        Trait t = traits.traits.get(j);
        Multiname name = t.getName(abc);
        Namespace ns = name.getNamespace(abc.constants);
        if (!((ns.kind == Namespace.KIND_PACKAGE_INTERNAL) || (ns.kind == Namespace.KIND_PACKAGE))) {
            otherTraits.add(j);
        }
    }
    for (int j = 0; j < traits.traits.size(); j++) {
        Trait t = traits.traits.get(j);
        Multiname name = t.getName(abc);
        Namespace ns = name.getNamespace(abc.constants);
        if ((ns.kind == Namespace.KIND_PACKAGE_INTERNAL) || (ns.kind == Namespace.KIND_PACKAGE)) {
            String packageName = ns.getName(abc.constants, false);
            String objectName = name.getName(abc.constants, null, false);
            List<Integer> traitIndices = new ArrayList<>();
            traitIndices.add(j);
            if (!otherTraits.isEmpty()) {
                traitIndices.addAll(otherTraits);
                otherTraits.clear();
            }
            if (packagePrefix == null || packageName.startsWith(packagePrefix)) {
                ClassPath cp = new ClassPath(packageName, objectName);
                ret.add(new ScriptPack(cp, abc, scriptIndex, traitIndices));
            }
        }
    }
    return ret;
}

Output:
                 ClassPath cp = new ClassPath(packageName, objectName);
-                ret.add(new ScriptPack(cp, abc, scriptIndex, traitIndices));
+                ret.add(new ScriptPack(cp, abc, allAbcs, scriptIndex, traitIndices));
             }


Input:
protected void keyTyped(char eventCharacter, int eventKey) {
    if (this.address.isFocused()) {
        if (eventKey == Keyboard.KEY_RETURN) {
            this.address.setFocused(false);
        } else {
            this.address.textboxKeyTyped(eventCharacter, eventKey);
        }
        return;
    }
    super.keyTyped(eventCharacter, eventKey);
}

Output:
 protected void keyTyped(char eventCharacter, int eventKey) {
-    if (this.address.isFocused()) {
-        if (eventKey == Keyboard.KEY_RETURN) {
-            this.address.setFocused(false);
-        } else {
-            this.address.textboxKeyTyped(eventCharacter, eventKey);
-        }
-        return;
+    if (!address.textboxKeyTyped(eventCharacter, eventKey)) {
+        super.keyTyped(eventCharacter, eventKey);
     }


Input:
protected boolean hasNextRow() throws DataException {
    this.odiResult.last(lowestGroupLevel);
    return odiResult.next();
}

Output:
     this.odiResult.last(lowestGroupLevel);
-    return odiResult.next();
+    boolean result = odiResult.next();
+    if (result)
+        cachedStartingGroupLevel = odiResult.getStartingGroupLevel();
+    return result;
 }


Input:
public static <S extends Sequence> MergeResult<S> merge(SequenceComparator<S> cmp, S base, S ours, S theirs) {
    List<S> sequences = new ArrayList<S>(3);
    sequences.add(base);
    sequences.add(ours);
    sequences.add(theirs);
    MergeResult result = new MergeResult<S>(sequences);
    EditList oursEdits = MyersDiff.INSTANCE.diff(cmp, base, ours);
    Iterator<Edit> baseToOurs = oursEdits.iterator();
    EditList theirsEdits = MyersDiff.INSTANCE.diff(cmp, base, theirs);
    Iterator<Edit> baseToTheirs = theirsEdits.iterator();
    int current = 0;
    Edit oursEdit = nextEdit(baseToOurs);
    Edit theirsEdit = nextEdit(baseToTheirs);
    while (theirsEdit != END_EDIT || oursEdit != END_EDIT) {
        if (oursEdit.getEndA() <= theirsEdit.getBeginA()) {
            if (current != oursEdit.getBeginA()) {
                result.add(0, current, oursEdit.getBeginA(), ConflictState.NO_CONFLICT);
            }
            result.add(1, oursEdit.getBeginB(), oursEdit.getEndB(), ConflictState.NO_CONFLICT);
            current = oursEdit.getEndA();
            oursEdit = nextEdit(baseToOurs);
        } else if (theirsEdit.getEndA() <= oursEdit.getBeginA()) {
            if (current != theirsEdit.getBeginA()) {
                result.add(0, current, theirsEdit.getBeginA(), ConflictState.NO_CONFLICT);
            }
            result.add(2, theirsEdit.getBeginB(), theirsEdit.getEndB(), ConflictState.NO_CONFLICT);
            current = theirsEdit.getEndA();
            theirsEdit = nextEdit(baseToTheirs);
        } else {
            if (oursEdit.getBeginA() != current && theirsEdit.getBeginA() != current) {
                result.add(0, current, Math.min(oursEdit.getBeginA(), theirsEdit.getBeginA()), ConflictState.NO_CONFLICT);
            }
            int oursBeginB = oursEdit.getBeginB();
            int theirsBeginB = theirsEdit.getBeginB();
            if (oursEdit.getBeginA() < theirsEdit.getBeginA()) {
                theirsBeginB -= theirsEdit.getBeginA() - oursEdit.getBeginA();
            } else {
                oursBeginB -= oursEdit.getBeginA() - theirsEdit.getBeginA();
            }
            Edit nextOursEdit = nextEdit(baseToOurs);
            Edit nextTheirsEdit = nextEdit(baseToTheirs);
            for (; ; ) {
                if (oursEdit.getEndA() > nextTheirsEdit.getBeginA()) {
                    theirsEdit = nextTheirsEdit;
                    nextTheirsEdit = nextEdit(baseToTheirs);
                } else if (theirsEdit.getEndA() > nextOursEdit.getBeginA()) {
                    oursEdit = nextOursEdit;
                    nextOursEdit = nextEdit(baseToOurs);
                } else {
                    break;
                }
            }
            int oursEndB = oursEdit.getEndB();
            int theirsEndB = theirsEdit.getEndB();
            if (oursEdit.getEndA() < theirsEdit.getEndA()) {
                oursEndB += theirsEdit.getEndA() - oursEdit.getEndA();
            } else {
                theirsEndB += oursEdit.getEndA() - theirsEdit.getEndA();
            }
            int conflictLen = Math.min(oursEndB - oursBeginB, theirsEndB - theirsBeginB);
            int commonPrefix = 0;
            while (commonPrefix < conflictLen && cmp.equals(ours, oursBeginB + commonPrefix, theirs, theirsBeginB + commonPrefix)) commonPrefix++;
            conflictLen -= commonPrefix;
            int commonSuffix = 0;
            while (commonSuffix < conflictLen && cmp.equals(ours, oursEndB - commonSuffix - 1, theirs, theirsEndB - commonSuffix - 1)) commonSuffix++;
            conflictLen -= commonSuffix;
            if (commonPrefix > 0)
                result.add(1, oursBeginB, oursBeginB + commonPrefix, ConflictState.NO_CONFLICT);
            if (conflictLen > 0) {
                result.add(1, oursBeginB + commonPrefix, oursEndB - commonSuffix, ConflictState.FIRST_CONFLICTING_RANGE);
                result.add(2, theirsBeginB + commonPrefix, theirsEndB - commonSuffix, ConflictState.NEXT_CONFLICTING_RANGE);
            }
            if (commonSuffix > 0)
                result.add(1, oursEndB - commonSuffix, oursEndB, ConflictState.NO_CONFLICT);
            current = Math.max(oursEdit.getEndA(), theirsEdit.getEndA());
            oursEdit = nextOursEdit;
            theirsEdit = nextTheirsEdit;
        }
    }
    if (current < base.size()) {
        result.add(0, current, base.size(), ConflictState.NO_CONFLICT);
    }
    return result;
}

Output:
             }
-            int conflictLen = Math.min(oursEndB - oursBeginB, theirsEndB - theirsBeginB);
+            int minBSize = oursEndB - oursBeginB;
+            int BSizeDelta = minBSize - (theirsEndB - theirsBeginB);
+            if (BSizeDelta > 0)
+                minBSize -= BSizeDelta;
             int commonPrefix = 0;


Input:
public void initialize(GraphDatabaseService database) {
    new IterableInputBatchTransactionExecutor<>(database, BATCH_SIZE, new AllNodes(database, BATCH_SIZE), (db, node, batchNumber, stepNumber) -> {
        if (getConfiguration().getInclusionPolicies().getNodeInclusionPolicy().include(node)) {
            assignUuid(node);
        }
    }).execute();
    new IterableInputBatchTransactionExecutor<>(database, BATCH_SIZE, new AllRelationships(database, BATCH_SIZE), (db, rel, batchNumber, stepNumber) -> {
        if (getConfiguration().getInclusionPolicies().getRelationshipInclusionPolicy().include(rel)) {
            assignUuid(rel);
        }
    }).execute();
}

Output:
 public void initialize(GraphDatabaseService database) {
-    new IterableInputBatchTransactionExecutor<>(database, BATCH_SIZE, new AllNodes(database, BATCH_SIZE), (db, node, batchNumber, stepNumber) -> {
-        if (getConfiguration().getInclusionPolicies().getNodeInclusionPolicy().include(node)) {
-            assignUuid(node);
-        }
-    }).execute();
-    new IterableInputBatchTransactionExecutor<>(database, BATCH_SIZE, new AllRelationships(database, BATCH_SIZE), (db, rel, batchNumber, stepNumber) -> {
-        if (getConfiguration().getInclusionPolicies().getRelationshipInclusionPolicy().include(rel)) {
-            assignUuid(rel);
-        }
-    }).execute();
+    if (new InstanceRoleUtils(database).getInstaceRole().isWritable()) {
+        new IterableInputBatchTransactionExecutor<>(database, BATCH_SIZE, new AllNodes(database, BATCH_SIZE), (db, node, batchNumber, stepNumber) -> {
+            if (getConfiguration().getInclusionPolicies().getNodeInclusionPolicy().include(node)) {
+                assignUuid(node);
+            }
+        }).execute();
+        new IterableInputBatchTransactionExecutor<>(database, BATCH_SIZE, new AllRelationships(database, BATCH_SIZE), (db, rel, batchNumber, stepNumber) -> {
+            if (getConfiguration().getInclusionPolicies().getRelationshipInclusionPolicy().include(rel)) {
+                assignUuid(rel);
+            }
+        }).execute();
+    }
 }


Input:
public View getView(Context c, LayoutInflater inflater, View convertView) {
    ViewHolder holder;
    if (convertView == null || !(convertView.getTag() instanceof ViewHolder)) {
        convertView = inflater.inflate(R.layout.list_item_stats, null);
        holder = new ViewHolder();
        holder.teamNumber = (TextView) convertView.findViewById(R.id.team_number);
        holder.teamName = (TextView) convertView.findViewById(R.id.team_name);
        holder.teamStat = (TextView) convertView.findViewById(R.id.team_stat);
        convertView.setTag(holder);
    } else {
        holder = (ViewHolder) convertView.getTag();
    }
    holder.teamNumber.setText("String_Node_Str" + teamNumber);
    if (!teamName.isEmpty()) {
        holder.teamName.setText(teamName);
    } else {
        holder.teamName.setText("String_Node_Str" + teamNumber);
    }
    holder.teamStat.setText(teamStat);
    return convertView;
}

Output:
     holder.teamNumber.setText("String_Node_Str" + teamNumber);
-    if (!teamName.isEmpty()) {
-        holder.teamName.setText(teamName);
-    } else {
-        holder.teamName.setText("String_Node_Str" + teamNumber);
-    }
+    holder.teamName.setText(TextUtils.isEmpty(teamName) ? "String_Node_Str" + teamNumber : teamName);
     holder.teamStat.setText(teamStat);


Input:
public void qualifierSystemPropertyTest() {
    System.setProperty("String_Node_Str", "String_Node_Str");
    System.setProperty("String_Node_Str", "String_Node_Str");
    System.setProperty("String_Node_Str", "String_Node_Str");
    System.setProperty("String_Node_Str", "String_Node_Str");
    MockDroneConfiguration configuration = ConfigurationMapper.fromSystemConfiguration(new MockDroneConfiguration(), DifferentMock.class);
    validateConfiguration(configuration, 0, false, "String_Node_Str");
}

Output:
 public void qualifierSystemPropertyTest() {
-    System.setProperty("String_Node_Str", "String_Node_Str");
-    System.setProperty("String_Node_Str", "String_Node_Str");
-    System.setProperty("String_Node_Str", "String_Node_Str");
-    System.setProperty("String_Node_Str", "String_Node_Str");
-    MockDroneConfiguration configuration = ConfigurationMapper.fromSystemConfiguration(new MockDroneConfiguration(), DifferentMock.class);
-    validateConfiguration(configuration, 0, false, "String_Node_Str");
+    try {
+        System.setProperty("String_Node_Str", "String_Node_Str");
+        System.setProperty("String_Node_Str", "String_Node_Str");
+        System.setProperty("String_Node_Str", "String_Node_Str");
+        System.setProperty("String_Node_Str", "String_Node_Str");
+        MockDroneConfiguration configuration = ConfigurationMapper.fromSystemConfiguration(new MockDroneConfiguration(), DifferentMock.class);
+        validateConfiguration(configuration, 0, false, "String_Node_Str");
+    } finally {
+        System.clearProperty("String_Node_Str");
+        System.clearProperty("String_Node_Str");
+        System.clearProperty("String_Node_Str");
+    }
 }


Input:
private void resolveChanges() {
    boolean changed = false;
    for (Map.Entry<T, Boolean> entry : selectionChanges.entrySet()) {
        T object = entry.getKey();
        boolean selected = entry.getValue();
        boolean defaultSelected = isDefaultSelected(object);
        Object key = getKey(object);
        Boolean previousException = exceptions.get(key);
        if (defaultSelected == selected) {
            if (previousException != null) {
                exceptions.remove(key);
                changed = true;
            }
        } else {
            if (previousException != Boolean.valueOf(selected)) {
                exceptions.put(key, selected);
                changed = true;
            }
        }
    }
    selectionChanges.clear();
    if (changed) {
        SelectionChangeEvent.fire(this);
    }
}

Output:
     boolean changed = false;
-    for (Map.Entry<T, Boolean> entry : selectionChanges.entrySet()) {
-        T object = entry.getKey();
-        boolean selected = entry.getValue();
-        boolean defaultSelected = isDefaultSelected(object);
-        Object key = getKey(object);
+    for (Map.Entry<Object, SelectionChange<T>> entry : selectionChanges.entrySet()) {
+        Object key = entry.getKey();
+        SelectionChange<T> value = entry.getValue();
+        T item = value.getItem();
+        boolean selected = value.isSelected();
+        boolean defaultSelected = isDefaultSelected(item);
         Boolean previousException = exceptions.get(key);


Input:
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
    if (reason.equals(UnregisterReason.EXPLODE))
        return false;
    BlockMenu inv = BlockStorage.getInventory(b);
    if (inv != null) {
        for (int slot : getSoulSandSlots()) {
            if (inv.getItemInSlot(slot) != null)
                b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
        }
        for (int slot : getWitherSkullSlots()) {
            if (inv.getItemInSlot(slot) != null)
                b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
        }
    }
    return true;
}

Output:
         for (int slot : getSoulSandSlots()) {
-            if (inv.getItemInSlot(slot) != null)
+            if (inv.getItemInSlot(slot) != null) {
                 b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));


Input:
public void testNoArgs() {
    final String testMsg = "String_Node_Str";
    ReusableParameterizedMessage msg = new ReusableParameterizedMessage();
    msg.set(testMsg, null);
    String result = msg.getFormattedMessage();
    assertEquals(testMsg, result);
    msg.set(testMsg, null, null);
    result = msg.getFormattedMessage();
    assertEquals("String_Node_Str", result);
}

Output:
     ReusableParameterizedMessage msg = new ReusableParameterizedMessage();
-    msg.set(testMsg, null);
+    msg.set(testMsg, (Object[]) null);
     String result = msg.getFormattedMessage();


Input:
public static void runClustering(String input, String stateIn, String output) {
    Configurable client = new JobClient();
    JobConf conf = new JobConf(DirichletDriver.class);
    conf.setOutputKeyClass(Text.class);
    conf.setOutputValueClass(Text.class);
    FileInputFormat.setInputPaths(conf, new Path(input));
    Path outPath = new Path(output);
    FileOutputFormat.setOutputPath(conf, outPath);
    conf.setMapperClass(DirichletMapper.class);
    conf.setNumReduceTasks(0);
    client.setConf(conf);
    try {
        JobClient.runJob(conf);
    } catch (IOException e) {
        log.warn(e.toString(), e);
    }
}

Output:
     JobConf conf = new JobConf(DirichletDriver.class);
-    conf.setOutputKeyClass(Text.class);
-    conf.setOutputValueClass(Text.class);
+    conf.setJobName("String_Node_Str");
+    conf.setOutputKeyClass(IntWritable.class);
+    conf.setOutputValueClass(VectorWritable.class);
     FileInputFormat.setInputPaths(conf, new Path(input));


Input:
public ModelAndView getStatus(Long userId) throws NotFoundException {
    SyncopeUser user = syncopeUserDAO.find(userId);
    if (user == null) {
        log.error("String_Node_Str" + userId + "String_Node_Str");
        throw new NotFoundException(String.valueOf(userId));
    }
    List<Step> currentSteps = userWorkflow.getCurrentSteps(user.getWorkflowEntryId());
    if (currentSteps == null || currentSteps.isEmpty()) {
        return null;
    }
    ModelAndView mav = new ModelAndView();
    mav.addObject(currentSteps.iterator().next().getStatus());
    return mav;
}

Output:
     }
-    List<Step> currentSteps = userWorkflow.getCurrentSteps(user.getWorkflowEntryId());
+    List<Step> currentSteps = userWorkflow.getCurrentSteps(user.getWorkflowId());
     if (currentSteps == null || currentSteps.isEmpty()) {


Input:
public void paintComponent(Graphics g) {
    super.paintComponent(g);
    Graphics2D g2 = (Graphics2D) g;
    try {
        Rectangle rectClip = g.getClipBounds();
        if (rectClip == null) {
            return;
        }
        Iterator it = hexes.iterator();
        while (it.hasNext()) {
            GUIHex hex = (GUIHex) it.next();
            if (!hex.getBattleHexModel().isEntrance() && rectClip.intersects(hex.getBounds())) {
                hex.paint(g);
            }
        }
        Object oldantialias = g2.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        Font oldFont = g.getFont();
        FontMetrics fm;
        String dn = null;
        String bn = null;
        String sub = null;
        if (sub == null) {
            sub = (dn.equals(bn) ? null : bn);
        }
        fm = g.getFontMetrics();
        int tma = fm.getMaxAscent();
        g.drawString(dn, 80, 4 + tma);
        if (sub != null) {
            fm = g.getFontMetrics();
            int tma2 = fm.getMaxAscent();
            g.drawString(sub, 80, 4 + tma + 8 + tma2);
        }
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, oldantialias);
        g.setFont(oldFont);
    } catch (NullPointerException ex) {
    }
}

Output:
         FontMetrics fm;
-        String dn = null;
+        String dn = "String_Node_Str";
         String bn = null;


Input:
public Object getFieldValue(_Fields field) {
    switch(field) {
        case ID:
            return Long.valueOf(getId());
        case RSV:
            return Double.valueOf(getRsv());
        case SCREEN_NAME:
            return getScreen_name();
        case CREATED_AT:
            return getCreated_at();
        case TEXT:
            return getText();
    }
    throw new IllegalStateException();
}

Output:
             return getScreen_name();
-        case CREATED_AT:
-            return getCreated_at();
+        case EPOCH:
+            return Long.valueOf(getEpoch());
         case TEXT:


Input:
public static String fromMillis(long mi) {
    return _fromMillis(mi, TIME_S_EN, TIME_M_EN, TIME_H_EN, TIME_D_EN);
}

Output:
 public static String fromMillis(long mi) {
-    return _fromMillis(mi, TIME_S_EN, TIME_M_EN, TIME_H_EN, TIME_D_EN);
+    return _fromMillis(mi, true);
 }