Input:
public void encodeEnd(FacesContext context, UIComponent component) throws IOException {
    if (!component.isRendered()) {
        return;
    }
    Panel panel = (Panel) component;
    ResponseWriter rw = context.getResponseWriter();
    String clientId = panel.getClientId();
    rw.endElement(H.DIV);
    UIComponent foot = panel.getFacet("String_Node_Str");
    if (foot != null) {
        rw.startElement(H.DIV, panel);
        rw.writeAttribute(H.CLASS, "String_Node_Str", H.CLASS);
        foot.encodeAll(context);
        rw.endElement(H.DIV);
    }
    rw.endElement(H.DIV);
    boolean isCollapsible = panel.isCollapsible();
    if (isCollapsible) {
        String jQueryClientID = clientId.replace("String_Node_Str", "String_Node_Str");
        rw.endElement(H.DIV);
        rw.startElement("String_Node_Str", panel);
        rw.writeAttribute("String_Node_Str", "String_Node_Str", null);
        String hiddenInputFieldID = jQueryClientID + "String_Node_Str";
        rw.writeAttribute("String_Node_Str", hiddenInputFieldID, "String_Node_Str");
        rw.writeAttribute("String_Node_Str", hiddenInputFieldID, "String_Node_Str");
        rw.writeAttribute("String_Node_Str", panel.isCollapsed(), "String_Node_Str");
        rw.endElement("String_Node_Str");
        rw.startElement("String_Node_Str", panel);
        rw.writeText("String_Node_Str", null);
        rw.writeText("String_Node_Str" + "String_Node_Str" + jQueryClientID + "String_Node_Str" + "String_Node_Str" + hiddenInputFieldID + "String_Node_Str", null);
        rw.writeText("String_Node_Str", null);
        rw.writeText("String_Node_Str" + "String_Node_Str" + jQueryClientID + "String_Node_Str" + "String_Node_Str" + hiddenInputFieldID + "String_Node_Str", null);
        rw.writeText("String_Node_Str", null);
        rw.endElement("String_Node_Str");
    }
    Tooltip.activateTooltips(context, panel.getAttributes(), panel);
}

Output:
         rw.writeAttribute("String_Node_Str", hiddenInputFieldID, "String_Node_Str");
-        rw.writeAttribute("String_Node_Str", panel.isCollapsed(), "String_Node_Str");
+        rw.writeAttribute("String_Node_Str", String.valueOf(panel.isCollapsed()), "String_Node_Str");
         rw.endElement("String_Node_Str");


Input:
public boolean yield() {
    if (status == STATUS_ACTIVE)
        status = STATUS_SUSPENDED;
    return true;
}

Output:
 public boolean yield() {
-    if (status == STATUS_ACTIVE)
+    if (status == STATUS_RUNNING)
         status = STATUS_SUSPENDED;


Input:
public ModelAndView onSubmit(HttpServletRequest request, HttpServletResponse response, Object command, BindException errors) throws Exception {
    if (log.isDebugEnabled()) {
        log.debug("String_Node_Str");
    }
    User user = (User) command;
    String algorithm = (String) getConfiguration().get(Constants.ENC_ALGORITHM);
    if (algorithm == null) {
        if (log.isDebugEnabled()) {
            log.debug("String_Node_Str");
        }
        algorithm = "String_Node_Str";
    }
    user.setPassword(StringUtil.encodePassword(user.getPassword(), algorithm));
    user.addRole(roleManager.getRole(Constants.USER_ROLE));
    try {
        mgr.saveUser(user);
    } catch (UserExistsException e) {
        log.warn(e.getMessage());
        errors.rejectValue("String_Node_Str", "String_Node_Str", new Object[] { user.getUsername(), user.getEmail() }, "String_Node_Str");
        user.setPassword(user.getConfirmPassword());
        return showForm(request, response, errors);
    }
    String loginCookie = mgr.createLoginCookie(user.getUsername());
    RequestUtil.setCookie(response, Constants.LOGIN_COOKIE, loginCookie, request.getContextPath());
    saveMessage(request, getText("String_Node_Str", user.getUsername()));
    request.getSession().setAttribute(Constants.REGISTERED, Boolean.TRUE);
    if (log.isDebugEnabled()) {
        log.debug("String_Node_Str" + user.getUsername() + "String_Node_Str");
    }
    message.setSubject(getText("String_Node_Str"));
    sendUserMessage(user, getText("String_Node_Str"), RequestUtil.getAppURL(request));
    return new ModelAndView(new RedirectView(getSuccessView()));
}

Output:
     RequestUtil.setCookie(response, Constants.LOGIN_COOKIE, loginCookie, request.getContextPath());
-    saveMessage(request, getText("String_Node_Str", user.getUsername()));
+    saveMessage(request, getText("String_Node_Str", user.getUsername(), locale));
     request.getSession().setAttribute(Constants.REGISTERED, Boolean.TRUE);


Input:
public void tick(World parWorld) {
    if (!parWorld.isRemote) {
        if (parWorld.getTotalWorldTime() % queueProcessRate == 0) {
            for (BlockUpdateSnapshot snapshot : listBlockUpdateQueue) {
                World world = DimensionManager.getWorld(snapshot.getDimID());
                if (world != null) {
                    world.setBlockState(snapshot.getPos(), snapshot.getState(), 3);
                }
            }
            listBlockUpdateQueue.clear();
        }
    }
    if (storm == null)
        return;
    boolean seesLight = false;
    tickGrabCount = 0;
    removeCount = 0;
    tryRipCount = 0;
    int tryRipMax = 300;
    tornadoBaseSize = getTornadoBaseSize();
    if (storm.stormType == storm.TYPE_WATER) {
        tornadoBaseSize *= 3;
    }
    forceRotate(parWorld);
    Random rand = new Random();
    int spawnYOffset = (int) storm.posBaseFormationPos.yCoord;
    if (!parWorld.isRemote && ConfigMisc.Storm_Tornado_grabBlocks) {
        int yStart = 00;
        int yEnd = (int) storm.pos.yCoord;
        int yInc = 1;
        BiomeGenBase bgb = parWorld.getBiomeGenForCoords(new BlockPos(MathHelper.floor_double(storm.pos.xCoord), 0, MathHelper.floor_double(storm.pos.zCoord)));
        if (bgb != null && bgb.minHeight + bgb.maxHeight <= 0.7) {
            for (int i = yStart; i < yEnd; i += yInc) {
                int YRand = i;
                int ii = YRand / 4;
                if (i > 20 && rand.nextInt(2) != 0) {
                    continue;
                }
                if (tryRipCount > tryRipMax) {
                    break;
                }
                int extraTry = (int) ((storm.levelCurIntensityStage + 1 - storm.levelStormIntensityFormingStartVal) * 5);
                int loopAmount = 5 + ii + extraTry;
                if (storm.stormType == StormObject.TYPE_WATER) {
                    loopAmount = 1 + ii / 2;
                }
                for (int k = 0; k < loopAmount; k++) {
                    if (tryRipCount > tryRipMax) {
                        break;
                    }
                    int tryY = (int) (spawnYOffset + YRand - 1.5D);
                    if (tryY > 255) {
                        tryY = 255;
                    }
                    int tryX = (int) storm.pos.xCoord + rand.nextInt(tornadoBaseSize + (ii)) - ((tornadoBaseSize / 2) + (ii / 2));
                    int tryZ = (int) storm.pos.zCoord + rand.nextInt(tornadoBaseSize + (ii)) - ((tornadoBaseSize / 2) + (ii / 2));
                    double d0 = storm.pos.xCoord - tryX;
                    double d2 = storm.pos.zCoord - tryZ;
                    double dist = (double) MathHelper.sqrt_double(d0 * d0 + d2 * d2);
                    if (dist < tornadoBaseSize / 2 + ii / 2 && tryRipCount < tryRipMax) {
                        Block blockID = parWorld.getBlockState(new BlockPos(tryX, tryY, tryZ)).getBlock();
                        boolean performed = false;
                        if (!CoroUtilBlock.isAir(blockID) && canGrab(parWorld, blockID)) {
                            tryRipCount++;
                            seesLight = tryRip(parWorld, tryX, tryY, tryZ);
                            performed = seesLight;
                        }
                        if (!performed && ConfigMisc.Storm_Tornado_RefinedGrabRules) {
                            if (blockID == Blocks.grass) {
                                listBlockUpdateQueue.add(new BlockUpdateSnapshot(parWorld.provider.getDimensionId(), Blocks.dirt.getDefaultState(), new BlockPos(tryX, tryY, tryZ)));
                            }
                        }
                    }
                }
            }
            for (int k = 0; k < 10; k++) {
                int randSize = 40;
                int tryX = (int) storm.pos.xCoord + rand.nextInt(randSize) - 20;
                int tryY = (int) spawnYOffset - 2 + rand.nextInt(8);
                int tryZ = (int) storm.pos.zCoord + rand.nextInt(randSize) - 20;
                double d0 = storm.pos.xCoord - tryX;
                double d2 = storm.pos.zCoord - tryZ;
                double dist = (double) MathHelper.sqrt_double(d0 * d0 + d2 * d2);
                if (dist < tornadoBaseSize / 2 + randSize / 2 && tryRipCount < tryRipMax) {
                    Block blockID = parWorld.getBlockState(new BlockPos(tryX, tryY, tryZ)).getBlock();
                    if (!CoroUtilBlock.isAir(blockID) && canGrab(parWorld, blockID)) {
                        tryRipCount++;
                        tryRip(parWorld, tryX, tryY, tryZ);
                    }
                }
            }
        }
    } else {
        seesLight = true;
    }
    if (Math.abs((spawnYOffset - storm.pos.yCoord)) > 5) {
        seesLight = true;
    }
}

Output:
         if (parWorld.getTotalWorldTime() % queueProcessRate == 0) {
-            for (BlockUpdateSnapshot snapshot : listBlockUpdateQueue) {
+            Iterator<BlockUpdateSnapshot> it = listBlockUpdateQueue.values().iterator();
+            while (it.hasNext()) {
+                BlockUpdateSnapshot snapshot = it.next();
                 World world = DimensionManager.getWorld(snapshot.getDimID());


Input:
public static org.hl7.fhir.dstu2016may.model.CodeableConcept convertCodeableConcept(org.hl7.fhir.dstu3.model.CodeableConcept src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2016may.model.CodeableConcept tgt = new org.hl7.fhir.dstu2016may.model.CodeableConcept();
    copyElement(src, tgt);
    for (org.hl7.fhir.dstu3.model.Coding t : src.getCoding()) tgt.addCoding(convertCoding(t));
    tgt.setText(src.getText());
    return tgt;
}

Output:
 public static org.hl7.fhir.dstu2016may.model.CodeableConcept convertCodeableConcept(org.hl7.fhir.dstu3.model.CodeableConcept src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
public boolean applies(GameEvent event, Ability source, Game game) {
    if (event.getType() == EventType.DRAW_CARD) {
        if (game.getActivePlayerId().equals(event.getPlayerId())) {
            CardsDrawnDuringDrawStepWatcher watcher = (CardsDrawnDuringDrawStepWatcher) game.getState().getWatchers().get("String_Node_Str");
            if (watcher != null && watcher.getAmountCardsDrawn(event.getPlayerId()) > 0) {
                return true;
            }
        } else {
            return true;
        }
    }
    return false;
}

Output:
     if (event.getType() == EventType.DRAW_CARD) {
-        if (game.getActivePlayerId().equals(event.getPlayerId())) {
+        if (game.getActivePlayerId().equals(event.getPlayerId()) && game.getPhase().getStep().getType().equals(PhaseStep.DRAW)) {
             CardsDrawnDuringDrawStepWatcher watcher = (CardsDrawnDuringDrawStepWatcher) game.getState().getWatchers().get("String_Node_Str");


Input:
protected boolean _transferOutputs(IOPort port) throws IllegalActionException {
    if (!port.isOutput() || !port.isOpaque()) {
        throw new IllegalActionException(this, port, "String_Node_Str" + "String_Node_Str");
    }
    if (port instanceof RefinementPort) {
        return super._transferOutputs(port);
    }
    boolean result = false;
    Time physicalTime = getPhysicalTime();
    int compare = 0;
    while (true) {
        if (_realTimeOutputEventQueue.isEmpty()) {
            break;
        }
        RealTimeEvent tokenEvent = (RealTimeEvent) _realTimeOutputEventQueue.peek();
        compare = tokenEvent.deliveryTime.compareTo(physicalTime);
        if (compare > 0) {
            break;
        } else if (compare == 0) {
            if (_isNetworkPort(tokenEvent.port)) {
                throw new IllegalActionException("String_Node_Str" + "String_Node_Str");
            }
            _realTimeOutputEventQueue.poll();
            tokenEvent.port.send(tokenEvent.channel, tokenEvent.token);
            if (_debugging) {
                _debug(getName(), "String_Node_Str" + tokenEvent.token + "String_Node_Str" + tokenEvent.port.getName());
            }
            result = true;
        } else if (compare < 0) {
            throw new IllegalActionException(tokenEvent.port, "String_Node_Str" + tokenEvent.deliveryTime + "String_Node_Str" + physicalTime);
        }
    }
    if (_isNetworkPort(port) || _transferImmediately(port)) {
        while (true) {
            if (!super._transferOutputs(port)) {
                break;
            } else {
                result = true;
            }
        }
    }
    compare = _currentTime.compareTo(physicalTime);
    if (compare == 0) {
        result = result || super._transferOutputs(port);
    } else if (compare < 0) {
        for (int i = 0; i < port.getWidthInside(); i++) {
            if (port.hasTokenInside(i)) {
                throw new IllegalActionException(port, "String_Node_Str" + "String_Node_Str" + _currentTime + "String_Node_Str" + physicalTime);
            }
        }
    } else {
        for (int i = 0; i < port.getWidthInside(); i++) {
            try {
                if (port.hasTokenInside(i)) {
                    Token t = port.getInside(i);
                    RealTimeEvent tokenEvent = new RealTimeEvent(port, i, t, _currentTime);
                    _realTimeOutputEventQueue.add(tokenEvent);
                    Actor container = (Actor) getContainer();
                    container.getExecutiveDirector().fireAt((Actor) container, _currentTime);
                }
            } catch (NoTokenException ex) {
                throw new InternalErrorException(this, ex, null);
            }
        }
    }
    return result;
}

Output:
     boolean result = false;
-    Time physicalTime = getPhysicalTime();
+    Tag physicalTag = getPhysicalTag();
     int compare = 0;


Input:
private void handleCharacter(final int primaryCode, final Key key, final int multiTapIndex, int[] nearByKeyCodes) {
    if (BuildConfig.DEBUG)
        Logger.d(TAG, "String_Node_Str", primaryCode, isPredictionOn(), mPredicting);
    mExpectingSelectionUpdateBy = SystemClock.uptimeMillis() + MAX_TIME_TO_EXPECT_SELECTION_UPDATE;
    if (!mPredicting && isPredictionOn() && isAlphabet(primaryCode) && !isCursorTouchingWord()) {
        mPredicting = true;
        mUndoCommitCursorPosition = UNDO_COMMIT_NONE;
        mWord.reset();
        mAutoCorrectOn = mAutoComplete;
    }
    mLastCharacterWasShifted = (getInputView() != null) && getInputView().isShifted();
    final int primaryCodeToOutput;
    if (mShiftKeyState.isActive()) {
        if (key != null) {
            primaryCodeToOutput = key.getCodeAtIndex(multiTapIndex, true);
        } else {
            primaryCodeToOutput = Character.toUpperCase(primaryCode);
        }
    } else {
        if (getKeyboardSwitcher().isRightToLeftMode()) {
            if (primaryCode == (int) ')')
                primaryCodeToOutput = (int) '(';
            else if (primaryCode == (int) '(')
                primaryCodeToOutput = (int) ')';
            else
                primaryCodeToOutput = primaryCode;
        } else {
            primaryCodeToOutput = primaryCode;
        }
    }
    if (mPredicting) {
        if (mShiftKeyState.isActive() && mWord.cursorPosition() == 0) {
            mWord.setFirstCharCapitalized(true);
        }
        final InputConnection ic = getCurrentInputConnection();
        mWord.add(primaryCodeToOutput, nearByKeyCodes);
        ChewbaccaOnTheDrums.onKeyTyped(mWord, getApplicationContext());
        if (ic != null) {
            final int cursorPosition;
            if (mWord.cursorPosition() != mWord.length()) {
                cursorPosition = mGlobalCursorPosition + 1;
                ic.beginBatchEdit();
            } else {
                cursorPosition = -1;
            }
            ic.setComposingText(mWord.getTypedWord(), 1);
            if (cursorPosition > 0) {
                ic.setSelection(cursorPosition, cursorPosition);
                ic.endBatchEdit();
            }
        }
        if (Character.isLetter((char) primaryCodeToOutput)) {
            postUpdateSuggestions();
        } else {
            if (mCandidateView != null)
                mCandidateView.replaceTypedWord(mWord.getTypedWord());
        }
    } else {
        sendKeyChar((char) primaryCodeToOutput);
    }
    TextEntryState.typedCharacter((char) primaryCodeToOutput, false);
    mJustAutoAddedWord = false;
}

Output:
     } else {
-        if (getKeyboardSwitcher().isRightToLeftMode()) {
-            if (primaryCode == (int) ')')
-                primaryCodeToOutput = (int) '(';
-            else if (primaryCode == (int) '(')
-                primaryCodeToOutput = (int) ')';
-            else
-                primaryCodeToOutput = primaryCode;
-        } else {
-            primaryCodeToOutput = primaryCode;
-        }
+        primaryCodeToOutput = primaryCode;
     }


Input:
void putString(String cacheName, String propertyName, String value) {
    try {
        startSuperTenantFlow();
        Cache<String, String> cache = cacheManager.getCache(cacheName);
        cache.put(propertyName, value);
        if (log.isDebugEnabled()) {
            log.debug(String.format("String_Node_Str", cacheName, propertyName, value));
        }
    } finally {
        endSuperTenantFlow();
    }
}

Output:
         startSuperTenantFlow();
-        Cache<String, String> cache = cacheManager.getCache(cacheName);
+        Cache<String, String> cache = getCacheManager().getCache(cacheName);
         cache.put(propertyName, value);


Input:
private void writeUsingStatements(CompilationUnit compilationUnit) {
    forEach(compilationUnit.imports(), (ImportDeclaration importDeclaration) -> {
        Name importDeclarationName = importDeclaration.getName();
        if (isThisName(importDeclarationName, "String_Node_Str")) {
            setPositionToEndOfNode(importDeclaration);
            return;
        }
        if (importDeclaration.isStatic())
            throw sourceNotSupported("String_Node_Str");
        copySpaceAndComments();
        matchAndWrite("String_Node_Str", "String_Node_Str");
        if (importDeclaration.isOnDemand()) {
            copySpaceAndComments();
            writeNode(importDeclarationName);
        } else {
            if (!(importDeclarationName instanceof QualifiedName))
                throw sourceNotSupported("String_Node_Str");
            QualifiedName qualifiedName = (QualifiedName) importDeclarationName;
            copySpaceAndComments();
            writeNodeAtDifferentPosition(qualifiedName.getName());
            write("String_Node_Str");
            writeNode(qualifiedName);
        }
        copySpaceAndComments();
        matchAndWrite("String_Node_Str");
    });
    for (String extraUsing : getContext().getExtraUsings()) {
        write("String_Node_Str");
        write(extraUsing);
        writeln("String_Node_Str");
    }
}

Output:
         } else {
-            if (!(importDeclarationName instanceof QualifiedName))
-                throw sourceNotSupported("String_Node_Str");
-            QualifiedName qualifiedName = (QualifiedName) importDeclarationName;
-            copySpaceAndComments();
-            writeNodeAtDifferentPosition(qualifiedName.getName());
-            write("String_Node_Str");
-            writeNode(qualifiedName);
+            if (namespaceToImportForGenericClass != null) {
+                write(namespaceToImportForGenericClass);
+                genericUsings.add(namespaceToImportForGenericClass);
+                setPositionToEndOfNode(qualifiedName);
+            } else {
+                writeNodeAtDifferentPosition(qualifiedName.getName());
+                write("String_Node_Str");
+                writeNode(qualifiedName);
+            }
         }


Input:
public void initalize(PageDef page) {
    axis = new AxisProcessor();
    axis.addCoordinate(page.contentwidth);
    setCacheSize();
    ContainerSizeInfo rule = new ContainerSizeInfo(0, page.contentwidth);
    cache = createDataCache(maxCol, maxRow);
    engine = new StyleEngine(this);
    containers.push(createContainer(rule, page.style, null));
}

Output:
     axis = new AxisProcessor();
-    axis.addCoordinate(page.contentwidth);
+    axis.addCoordinate(contentWidth);
     setCacheSize();


Input:
public void put(K key, T persistent) {
    Key recordKey = getAerospikeKey(key);
    List<Field> fields = persistent.getSchema().getFields();
    for (int i = 0; i < fields.size(); i++) {
        if (persistent.isDirty(i)) {
            Object persistentValue = persistent.get(i);
            if (persistentValue == null && aerospikeClient.exists(null, recordKey)) {
                this.delete(key);
            }
        }
    }
    for (int i = 0; i < fields.size(); i++) {
        if (!persistent.isDirty(i)) {
            continue;
        }
        Object persistentValue = persistent.get(i);
        if (persistentValue != null) {
            String mappingBinName = aerospikeParameters.getAerospikeMapping().getBinMapping().get(fields.get(i).name());
            if (mappingBinName == null) {
                LOG.error("String_Node_Str", persistent.getClass().getName(), fields.get(i).name());
                throw new RuntimeException("String_Node_Str" + persistent.getClass().getName() + "String_Node_Str" + fields.get(i).name() + "String_Node_Str");
            }
            Bin bin = new Bin(mappingBinName, getSerializableValue(persistentValue, fields.get(i).schema()));
            aerospikeClient.put(aerospikeParameters.getAerospikeMapping().getWritePolicy(), recordKey, bin);
        }
    }
}

Output:
         if (persistentValue != null) {
-            String mappingBinName = aerospikeParameters.getAerospikeMapping().getBinMapping().get(fields.get(i).name());
-            if (mappingBinName == null) {
-                LOG.error("String_Node_Str", persistent.getClass().getName(), fields.get(i).name());
-                throw new RuntimeException("String_Node_Str" + persistent.getClass().getName() + "String_Node_Str" + fields.get(i).name() + "String_Node_Str");
-            }
-            Bin bin = new Bin(mappingBinName, getSerializableValue(persistentValue, fields.get(i).schema()));
-            aerospikeClient.put(aerospikeParameters.getAerospikeMapping().getWritePolicy(), recordKey, bin);
+            bin = new Bin(mappingBinName, getSerializableValue(persistentValue, fields.get(i).schema()));
+        } else {
+            bin = Bin.asNull(mappingBinName);
         }


Input:
public String toString() {
    return "String_Node_Str" + "String_Node_Str" + name + '\'' + "String_Node_Str" + operation + "String_Node_Str" + redoCount + '\'' + "String_Node_Str" + callId + '\'' + "String_Node_Str" + lockThreadId + '\'' + '}';
}

Output:
 public String toString() {
-    return "String_Node_Str" + "String_Node_Str" + name + '\'' + "String_Node_Str" + operation + "String_Node_Str" + redoCount + '\'' + "String_Node_Str" + callId + '\'' + "String_Node_Str" + lockThreadId + '\'' + '}';
+    return "String_Node_Str" + "String_Node_Str" + name + '\'' + "String_Node_Str" + operation + "String_Node_Str" + redoCount + '\'' + "String_Node_Str" + callId + '\'' + "String_Node_Str" + lockThreadId + '\'' + "String_Node_Str" + target + '\'' + "String_Node_Str" + local + '\'' + '}';
 }


Input:
public void text(Pcdata value, boolean needsSeparatingWhitespace) throws IOException, SAXException, XMLStreamException {
    if (needsSeparatingWhitespace)
        out.writeCharacters("String_Node_Str");
    int len = value.length();
    if (len < buf.length) {
        value.writeTo(buf, len);
        out.writeCharacters(buf, 0, len);
    } else {
        out.writeCharacters(value.toString());
    }
}

Output:
     if (len < buf.length) {
-        value.writeTo(buf, len);
+        value.writeTo(buf, 0);
         out.writeCharacters(buf, 0, len);


Input:
private FactTable createFactTable(String factName, String[] storages, String[] updatePeriods) {
    FactTable f = cubeObjectFactory.createFactTable();
    f.setName(factName);
    f.setWeight(10.0);
    f.setCubeName("String_Node_Str");
    Columns cols = cubeObjectFactory.createColumns();
    Column c1 = cubeObjectFactory.createColumn();
    c1.setName("String_Node_Str");
    c1.setType("String_Node_Str");
    c1.setComment("String_Node_Str");
    cols.getColumns().add(c1);
    Column c2 = cubeObjectFactory.createColumn();
    c2.setName("String_Node_Str");
    c2.setType("String_Node_Str");
    c2.setComment("String_Node_Str");
    cols.getColumns().add(c2);
    f.setColumns(cols);
    Map<String, String> properties = new HashMap<String, String>();
    properties.put("String_Node_Str", "String_Node_Str");
    f.setProperties(JAXBUtils.xPropertiesFromMap(properties));
    UpdatePeriods upd = cubeObjectFactory.createUpdatePeriods();
    for (int i = 0; i < storages.length; i++) {
        UpdatePeriodElement uel = cubeObjectFactory.createUpdatePeriodElement();
        uel.setStorageName(storages[i]);
        uel.getUpdatePeriods().add(updatePeriods[i]);
        upd.getUpdatePeriodElement().add(uel);
    }
    f.setStorageUpdatePeriods(upd);
    return f;
}

Output:
     f.setWeight(10.0);
-    f.setCubeName("String_Node_Str");
+    f.setCubeName(cubeName);
     Columns cols = cubeObjectFactory.createColumns();


Input:
public void run() {
    handler.removeCallbacks(this);
    Set<Map.Entry<EventInfo, Bundle>> eventsToDispatch = eventsBuffer.entrySet();
    for (Map.Entry<EventInfo, Bundle> entry : eventsToDispatch) {
        String event = entry.getKey().event;
        Bundle extras = entry.getValue();
        eventsToDispatch.remove(entry);
        dispatchAttributeEvent(event, extras);
    }
    if (isEventsBufferingEnabled()) {
        handler.postDelayed(this, connectionParams.getEventsDispatchingPeriod());
    }
}

Output:
 public void run() {
-    handler.removeCallbacks(this);
-    Set<Map.Entry<EventInfo, Bundle>> eventsToDispatch = eventsBuffer.entrySet();
-    for (Map.Entry<EventInfo, Bundle> entry : eventsToDispatch) {
-        String event = entry.getKey().event;
-        Bundle extras = entry.getValue();
-        eventsToDispatch.remove(entry);
-        dispatchAttributeEvent(event, extras);
+    eventsFilter.clear();
+    EventInfo eventInfo = eventsBuffer.poll();
+    while (eventInfo != null) {
+        eventsFilter.put(eventInfo.event, eventInfo.extras);
+        EventInfo.recycle(eventInfo);
+        eventInfo = eventsBuffer.poll();
+    }
+    for (Map.Entry<String, Bundle> entry : eventsFilter.entrySet()) {
+        dispatchAttributeEvent(entry.getKey(), entry.getValue());
     }


Input:
public void resetZoom() {
    Log.d(LOG_TAG, "String_Node_Str" + mDrawMatrix.toShortString());
    mDrawMatrixValues = new float[] { 1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f };
    mDrawMatrix.setValues(mDrawMatrixValues);
    recalculateXCoordinates(mGraphWidth * mDrawMatrixValues[0]);
    if (calculateLegendBounds())
        Utils.calculateLegendInformation(mSeries.get(0).getSeries(), 0, mGraphWidth * mDrawMatrixValues[0], mLegendPaint);
    calculateValueTextHeight();
    invalidateGlobal();
}

Output:
     mDrawMatrix.setValues(mDrawMatrixValues);
-    recalculateXCoordinates(mGraphWidth * mDrawMatrixValues[0]);
-    if (calculateLegendBounds())
-        Utils.calculateLegendInformation(mSeries.get(0).getSeries(), 0, mGraphWidth * mDrawMatrixValues[0], mLegendPaint);
-    calculateValueTextHeight();
+    if (!mSeries.isEmpty()) {
+        recalculateXCoordinates(mGraphWidth * mDrawMatrixValues[0]);
+        if (calculateLegendBounds())
+            Utils.calculateLegendInformation(mSeries.get(0).getSeries(), 0, mGraphWidth * mDrawMatrixValues[0], mLegendPaint);
+        calculateValueTextHeight();
+    }
     invalidateGlobal();


Input:
private boolean tableExists(String sname, String tableName) {
    if (sname == null || sname.equals("String_Node_Str")) {
        return tablesCount.containsKey(tableName);
    } else {
        Iterator i = schemas.iterator();
        while (i.hasNext()) {
            DbSchema s = (DbSchema) i.next();
            if (s.name.equals(sname)) {
                Iterator ti = s.tables.iterator();
                while (ti.hasNext()) {
                    DbTable d = (DbTable) ti.next();
                    if (d.name.equals(tableName)) {
                        return true;
                    }
                }
                break;
            }
        }
    }
    return false;
}

Output:
     } else {
-        Iterator i = schemas.iterator();
-        while (i.hasNext()) {
-            DbSchema s = (DbSchema) i.next();
+        for (DbSchema s : schemas) {
             if (s.name.equals(sname)) {


Input:
public int getCalibrationVectorIndex(final int y) {
    for (int i = 0; i < count; i++) {
        if (y < calibrationVectorList[i].line) {
            return i - 1;
        }
    }
    return -1;
}

Output:
 public int getCalibrationVectorIndex(final int y) {
-    for (int i = 0; i < count; i++) {
+    for (int i = 1; i < count; i++) {
         if (y < calibrationVectorList[i].line) {


Input:
private void retrieveBuddyList() throws IOException {
    write("String_Node_Str", "String_Node_Str");
    BufferedReader reader = new BufferedReader(new InputStreamReader(getInputStream(), "String_Node_Str"));
    String input = reader.readLine();
    while (input == null || !input.startsWith("String_Node_Str")) {
        input = reader.readLine();
    }
    String[] split = StringUtils.splitOnSpace(input);
    int contacts = Integer.parseInt(split[4]);
    while (!input.startsWith("String_Node_Str")) {
        if (input.startsWith("String_Node_Str")) {
            client.internalSetDisplayName(StringUtils.splitSubstring(input, "String_Node_Str", 2));
        } else if (input.startsWith("String_Node_Str")) {
            split = StringUtils.splitOnSpace(input);
            list.addGroup(split[2], new Group(URLDecoder.decode(split[1])));
        }
        input = reader.readLine();
    }
    int count = 0;
    while (true) {
        if (input.startsWith("String_Node_Str")) {
            count++;
            String[] contact = StringUtils.splitOnSpace(input);
            String email = contact[1].substring(2);
            switch(contact.length) {
                case 3:
                    list.internalAddContact(email, email);
                    break;
                case 5:
                    list.addContact(email, email, contact[3].substring(2));
                    break;
                default:
                    list.addContact(contact[2].substring(2), email, contact[3].substring(2), contact[5]);
                    break;
            }
            if (count == contacts) {
                break;
            }
        }
        input = reader.readLine();
    }
    write("String_Node_Str", client.getStatus().getLiteral() + "String_Node_Str");
    idle();
    ping();
}

Output:
             String email = contact[1].substring(2);
-            switch(contact.length) {
-                case 3:
-                    list.internalAddContact(email, email);
-                    break;
-                case 5:
-                    list.addContact(email, email, contact[3].substring(2));
-                    break;
-                default:
-                    list.addContact(contact[2].substring(2), email, contact[3].substring(2), contact[5]);
-                    break;
+            if (email.indexOf('@') != -1) {
+                switch(contact.length) {
+                    case 3:
+                        list.internalAddContact(email, email);
+                        break;
+                    case 5:
+                        list.addContact(email, email, contact[3].substring(2));
+                        break;
+                    default:
+                        list.addContact(contact[2].substring(2), email, contact[3].substring(2), contact[5]);
+                        break;
+                }
             }


Input:
public void onReset() {
    mCubicValueLineChart.resetZoom();
}

Output:
 public void onReset() {
-    mCubicValueLineChart.resetZoom();
+    mCubicValueLineChart.resetZoom(true);
 }


Input:
public void exportFile(RepositoryFile repositoryFile, OutputStream outputStream, String filePath) throws ExportException, IOException {
    ZipOutputStream zos = (ZipOutputStream) outputStream;
    for (ExportHandler exportHandler : exportHandlerList) {
        InputStream is = exportHandler.doExport(repositoryFile, filePath);
        if (is != null) {
            addToManifest(repositoryFile);
            ZipEntry entry = new ZipEntry(ExportFileNameEncoder.encodeZipPathName(getZipEntryName(repositoryFile, filePath)));
            zos.putNextEntry(entry);
            IOUtils.copy(is, outputStream);
            zos.closeEntry();
            is.close();
            createLocales(repositoryFile, filePath, repositoryFile.isFolder(), outputStream);
        }
    }
}

Output:
             addToManifest(repositoryFile);
-            ZipEntry entry = new ZipEntry(ExportFileNameEncoder.encodeZipPathName(getZipEntryName(repositoryFile, filePath)));
+            String zipEntryName = getZipEntryName(repositoryFile, filePath);
+            if (this.withManifest) {
+                zipEntryName = ExportFileNameEncoder.encodeZipPathName(zipEntryName);
+            }
+            ZipEntry entry = new ZipEntry(zipEntryName);
             zos.putNextEntry(entry);


Input:
public synchronized UserException getCause() {
    return (UserException) super.getCause();
}

Output:
 public synchronized UserException getCause() {
-    return (UserException) super.getCause();
+    Exception cause = super.getCause();
+    if (cause instanceof UserException) {
+        return (UserException) cause;
+    }
+    return null;
 }


Input:
private void buildSPARQLQueryString(QueryTree<N> tree, List<QueryTreeChange> changes, StringBuilder triples, List<String> filters) {
    Object subject = null;
    if (tree.getUserObject().equals("String_Node_Str")) {
        subject = "String_Node_Str" + tree.getId();
    } else {
        subject = "String_Node_Str" + tree.getUserObject() + "String_Node_Str";
    }
    Object predicate;
    Object object;
    if (!tree.isLeaf()) {
        for (QueryTree<N> child : tree.getChildren()) {
            predicate = tree.getEdge(child);
            object = child.getUserObject();
            boolean objectIsResource = !object.equals("String_Node_Str");
            boolean addFilter = false;
            boolean removed = false;
            String uri = null;
            if (!objectIsResource) {
                object = "String_Node_Str" + child.getId();
            } else if (((String) object).startsWith("String_Node_Str")) {
                QueryTreeChange c = getChange(changes, child.getId());
                if (c != null) {
                    if (c.getType() == ChangeType.REPLACE_LABEL) {
                        uri = (String) object;
                        child.setUserObject((N) "String_Node_Str");
                        object = "String_Node_Str" + child.getId();
                        addFilter = true;
                    } else {
                        removed = true;
                        triples.append("String_Node_Str").append(subject).append("String_Node_Str").append(predicate).append("String_Node_Str").append("String_Node_Str").append(child.getId()).append("String_Node_Str");
                        filters.add("String_Node_Str" + child.getId() + "String_Node_Str");
                        child.getParent().removeChild((QueryTreeImpl<N>) child);
                    }
                } else {
                    object = "String_Node_Str" + object + "String_Node_Str";
                }
            }
            if (!removed) {
                triples.append(subject).append("String_Node_Str").append(predicate).append("String_Node_Str").append(object).append("String_Node_Str");
            }
            if (addFilter) {
                filters.add("String_Node_Str" + child.getId() + "String_Node_Str" + uri + "String_Node_Str");
            }
            if (!objectIsResource) {
                buildSPARQLQueryString(child, changes, triples, filters);
            }
        }
    }
}

Output:
             String uri = null;
-            if (!objectIsResource) {
-                object = "String_Node_Str" + child.getId();
-            } else if (((String) object).startsWith("String_Node_Str")) {
-                QueryTreeChange c = getChange(changes, child.getId());
-                if (c != null) {
-                    if (c.getType() == ChangeType.REPLACE_LABEL) {
-                        uri = (String) object;
-                        child.setUserObject((N) "String_Node_Str");
-                        object = "String_Node_Str" + child.getId();
-                        addFilter = true;
-                    } else {
-                        removed = true;
-                        triples.append("String_Node_Str").append(subject).append("String_Node_Str").append(predicate).append("String_Node_Str").append("String_Node_Str").append(child.getId()).append("String_Node_Str");
-                        filters.add("String_Node_Str" + child.getId() + "String_Node_Str");
-                        child.getParent().removeChild((QueryTreeImpl<N>) child);
-                    }
+            QueryTreeChange c = getChange(changes, child.getId());
+            if (c != null) {
+                if (c.getType() == ChangeType.REPLACE_LABEL) {
+                    uri = (String) object;
+                    filters.add("String_Node_Str" + child.getId() + "String_Node_Str" + uri + "String_Node_Str");
+                    child.setUserObject((N) "String_Node_Str");
+                    object = "String_Node_Str" + child.getId();
                 } else {


Input:
protected DimLevel[] populateAggrLevels() throws DataException {
    String bindingName = OlapExpressionCompiler.getReferencedScriptObject(expr, "String_Node_Str");
    if (bindingName == null)
        return null;
    for (Iterator it = queryDefn.getBindings().iterator(); it.hasNext(); ) {
        IBinding binding = (IBinding) it.next();
        if (binding.getBindingName().equals(bindingName)) {
            List aggrs = binding.getAggregatOns();
            if (aggrs.size() == 0) {
                if (OlapExpressionCompiler.getReferencedScriptObject(binding.getExpression(), "String_Node_Str") != null)
                    return null;
                List levelList = new ArrayList();
                IEdgeDefinition rowEdge = queryDefn.getEdge(ICubeQueryDefinition.ROW_EDGE);
                List rowDims = rowEdge.getDimensions();
                for (Iterator i = rowDims.iterator(); i.hasNext(); ) {
                    IDimensionDefinition dim = (IDimensionDefinition) i.next();
                    IHierarchyDefinition hirarchy = (IHierarchyDefinition) dim.getHierarchy().get(0);
                    for (Iterator j = hirarchy.getLevels().iterator(); j.hasNext(); ) {
                        ILevelDefinition level = (ILevelDefinition) j.next();
                        levelList.add(new DimLevel(dim.getName(), level.getName()));
                    }
                }
                IEdgeDefinition colEdge = queryDefn.getEdge(ICubeQueryDefinition.COLUMN_EDGE);
                List colDims = colEdge.getDimensions();
                for (Iterator i = colDims.iterator(); i.hasNext(); ) {
                    IDimensionDefinition dim = (IDimensionDefinition) i.next();
                    IHierarchyDefinition hirarchy = (IHierarchyDefinition) dim.getHierarchy().get(0);
                    for (Iterator j = hirarchy.getLevels().iterator(); j.hasNext(); ) {
                        ILevelDefinition level = (ILevelDefinition) j.next();
                        levelList.add(new DimLevel(dim.getName(), level.getName()));
                    }
                }
                DimLevel[] levels = new DimLevel[levelList.size()];
                levelList.toArray(levels);
                return levels;
            } else {
                DimLevel[] levels = new DimLevel[aggrs.size()];
                for (int i = 0; i < aggrs.size(); i++) {
                    levels[i] = OlapExpressionUtil.getTargetDimLevel(aggrs.get(i).toString());
                }
                return levels;
            }
        }
    }
    return null;
}

Output:
                 IEdgeDefinition rowEdge = queryDefn.getEdge(ICubeQueryDefinition.ROW_EDGE);
-                List rowDims = rowEdge.getDimensions();
-                for (Iterator i = rowDims.iterator(); i.hasNext(); ) {
-                    IDimensionDefinition dim = (IDimensionDefinition) i.next();
-                    IHierarchyDefinition hirarchy = (IHierarchyDefinition) dim.getHierarchy().get(0);
-                    for (Iterator j = hirarchy.getLevels().iterator(); j.hasNext(); ) {
-                        ILevelDefinition level = (ILevelDefinition) j.next();
-                        levelList.add(new DimLevel(dim.getName(), level.getName()));
-                    }
-                }
+                populateDimLevel(levelList, rowEdge);
                 IEdgeDefinition colEdge = queryDefn.getEdge(ICubeQueryDefinition.COLUMN_EDGE);


Input:
public final CountDownLatch onEvent(final RequestID id, final Event<?> event, final Channel channel) {
    Iterator<Page> it = application.iterator();
    CountDownLatch latch = new CountDownLatch(1);
    Closables closables = new Closables(channel, application);
    PageRunner pageRunner = new PageRunner(application, it, latch, id, event, channel, scheduler, closables);
    application.getWorkerThreadPool().submit(pageRunner);
    return latch;
}

Output:
     CountDownLatch latch = new CountDownLatch(1);
-    Closables closables = new Closables(channel, application);
+    Closables closables = new Closables(channel, application.control());
     PageRunner pageRunner = new PageRunner(application, it, latch, id, event, channel, scheduler, closables);


Input:
public void run() {
    Tuple2<Thread, Runner.BoxedBool> threadData = new Tuple2(this, interrupt);
    ExperimentAction.addThisThread(survey, threadData);
    while (!interrupt.getInterrupt()) {
        try {
            Runner.run(survey, interrupt);
            System.out.println("String_Node_Str");
        } catch (AccessKeyException ake) {
            Experiment.updateStatusLabel(String.format("String_Node_Str", ake.getMessage()));
            (new File(MturkLibrary.CONFIG)).delete();
            SurveyMan.LOGGER.fatal(ake);
            System.exit(-1);
        } catch (SurveyException se) {
            SurveyMan.LOGGER.warn(se);
            Experiment.updateStatusLabel(String.format("String_Node_Str", se.getMessage()));
            interrupt.setInterrupt(true);
        } catch (InsufficientFundsException ife) {
            SurveyMan.LOGGER.warn(ife);
            int opt = JOptionPane.showConfirmDialog(Display.frame, "String_Node_Str");
            if (opt == JOptionPane.NO_OPTION) {
                Experiment.updateStatusLabel(String.format("String_Node_Str", survey.sourceName));
                interrupt.setInterrupt(true);
            } else if (opt == JOptionPane.CANCEL_OPTION) {
                Experiment.updateStatusLabel(String.format("String_Node_Str", survey.sourceName));
                Runner.saveJob(survey);
                interrupt.setInterrupt(true);
            }
        } catch (ServiceException mturkse) {
            SurveyMan.LOGGER.warn(mturkse);
            Experiment.updateStatusLabel(String.format("String_Node_Str", mturkse.getMessage()));
        } catch (IOException io) {
            SurveyMan.LOGGER.warn(io);
            Experiment.updateStatusLabel(String.format("String_Node_Str", io.getMessage()));
            interrupt.setInterrupt(true);
        }
    }
    ExperimentAction.removeThisThread(survey, threadData);
}

Output:
                 Experiment.updateStatusLabel(String.format("String_Node_Str", survey.sourceName));
-                Runner.saveJob(survey);
-                interrupt.setInterrupt(true);
+                try {
+                    Runner.saveJob(survey, MturkLibrary.JobStatus.INTERRUPTED);
+                    interrupt.setInterrupt(true);
+                } catch (SurveyException se) {
+                    SurveyMan.LOGGER.info(se);
+                } catch (IOException io) {
+                    SurveyMan.LOGGER.warn(io);
+                }
             }


Input:
private void initializeIndicator(Indicator indicator, ModelElement modelElement) {
    indicator.setAnalyzedElement(modelElement);
    if (indicator.getIndicatorDefinition() == null) {
        DefinitionHandler.getInstance().setDefaultIndicatorDefinition(indicator);
    }
    if (indicator instanceof CompositeIndicator) {
        for (Indicator child : ((CompositeIndicator) indicator).getChildIndicators()) {
            initializeIndicator(child, modelElement);
        }
    }
}

Output:
         for (Indicator child : ((CompositeIndicator) indicator).getChildIndicators()) {
-            initializeIndicator(child, modelElement);
+            initializeIndicator(child);
         }


Input:
private Expression findStaticFieldOrPropAccessorImportFromModule(String name) {
    ModuleNode module = currentClass.getModule();
    if (module == null)
        return null;
    Map<String, ImportNode> importNodes = module.getStaticImports();
    Expression expression = null;
    String accessorName = getAccessorName(name);
    if (importNodes.containsKey(accessorName)) {
        ImportNode importNode = importNodes.get(accessorName);
        expression = findStaticPropertyAccessorByFullName(importNode.getType(), importNode.getFieldName());
        if (expression != null)
            return expression;
        expression = findStaticPropertyAccessor(importNode.getType(), getPropNameForAccessor(importNode.getFieldName()));
        if (expression != null)
            return expression;
    }
    if (accessorName.startsWith("String_Node_Str")) {
        accessorName = "String_Node_Str" + accessorName.substring(3);
        if (importNodes.containsKey(accessorName)) {
            ImportNode importNode = importNodes.get(accessorName);
            expression = findStaticPropertyAccessorByFullName(importNode.getType(), importNode.getFieldName());
            if (expression != null)
                return expression;
            expression = findStaticPropertyAccessor(importNode.getType(), getPropNameForAccessor(importNode.getFieldName()));
            if (expression != null)
                return expression;
        }
    }
    if (importNodes.containsKey(name)) {
        ImportNode importNode = importNodes.get(name);
        try {
            if (!isReconcile) {
                expression = findStaticPropertyAccessor(importNode.getType(), importNode.getFieldName());
                if (expression != null)
                    return expression;
            }
            expression = findStaticField(importNode.getType(), importNode.getFieldName());
            if (expression != null)
                return expression;
        } finally {
            if (expression != null)
                expression.setNodeMetaData("String_Node_Str", name);
        }
    }
    for (ImportNode importNode : module.getStaticStarImports().values()) {
        ClassNode node = importNode.getType();
        expression = findStaticPropertyAccessor(node, name);
        if (expression != null)
            return expression;
        expression = findStaticField(node, name);
        if (expression != null)
            return expression;
    }
    return null;
}

Output:
             if (expression != null)
-                expression.setNodeMetaData("String_Node_Str", name);
+                expression.putNodeMetaData("String_Node_Str", name);
         }


Input:
protected final void killedEvent() {
    setSelected(false);
    if (occupiedArea) {
        MapCircle occupied = getOccupyablePositions();
        super.getGrid().freeOccupiedArea(occupied, super.getPos());
        int idx = 0;
        for (TowerOccupyer curr : occupiers) {
            curr.soldier.leaveOccupyableBuilding(super.getBuildingArea().get(idx));
            idx++;
        }
        occupiers.clear();
    }
    allOccupyingBuildings.remove(this);
}

Output:
         for (TowerOccupyer curr : occupiers) {
-            curr.soldier.leaveOccupyableBuilding(super.getBuildingArea().get(idx));
-            idx++;
+            curr.soldier.leaveOccupyableBuilding();
         }


Input:
public StringBuffer toCanonicalString(Context cx, StringBuffer buf) {
    {
        buf.append("String_Node_Str");
        ParameterNode firstItem = items.get(0);
        for (ParameterNode item : items) {
            if (item != firstItem)
                buf.append("String_Node_Str");
            buf.append(item.ref != null ? item.ref.name : "String_Node_Str");
        }
        buf.append("String_Node_Str");
    }
    {
        buf.append("String_Node_Str");
        ParameterNode firstItem = items.get(0);
        for (ParameterNode item : items) {
            if (item != firstItem)
                buf.append("String_Node_Str");
            if (item instanceof RestParameterNode)
                buf.append("String_Node_Str");
            else if (item.typeref != null) {
                Slot s = item.typeref.getSlot(cx, GET_TOKEN);
                buf.append((s == null || s.getDebugName().length() == 0) ? item.typeref.name : s.getDebugName());
            }
        }
        buf.append("String_Node_Str");
    }
    {
        buf.append("String_Node_Str");
        ParameterNode firstItem = items.get(0);
        for (ParameterNode item : items) {
            if (item != firstItem)
                buf.append("String_Node_Str");
            if (item.init == null)
                buf.append("String_Node_Str");
            else {
                if (item.init instanceof LiteralNumberNode) {
                    buf.append(((LiteralNumberNode) (item.init)).value);
                } else if (item.init instanceof LiteralStringNode) {
                    buf.append(DocCommentNode.escapeXml(((LiteralStringNode) (item.init)).value));
                } else if (item.init instanceof LiteralNullNode) {
                    buf.append("String_Node_Str");
                } else if (item.init instanceof LiteralBooleanNode) {
                    buf.append((((LiteralBooleanNode) (item.init)).value) ? "String_Node_Str" : "String_Node_Str");
                } else {
                    buf.append("String_Node_Str");
                }
            }
        }
        buf.append("String_Node_Str");
    }
    return buf;
}

Output:
             else if (item.typeref != null) {
-                Slot s = item.typeref.getSlot(cx, GET_TOKEN);
-                buf.append((s == null || s.getDebugName().length() == 0) ? item.typeref.name : s.getDebugName());
+                buf.append(DocCommentNode.getRefName(cx, item.typeref));
             }


Input:
public void dataEngineShutdown() {
    Map<ConnectionProp, Set<CacheConnection>> odaConnectionsMap = DataSource.dataEngineLevelConnectionPool.remove(this.session);
    if (odaConnectionsMap == null)
        return;
    ConnectionProp connProp = new ConnectionProp(DataSource.this.driverName, DataSource.this.connectionProps, DataSource.this.appContext);
    Set<CacheConnection> odaConnections = odaConnectionsMap.get(connProp);
    if (odaConnections == null)
        return;
    for (CacheConnection conn : odaConnections) {
        try {
            conn.odaConn.close();
        } catch (DataException e) {
            e.printStackTrace();
        }
    }
}

Output:
         return;
-    ConnectionProp connProp = new ConnectionProp(DataSource.this.driverName, DataSource.this.connectionProps, DataSource.this.appContext);
-    Set<CacheConnection> odaConnections = odaConnectionsMap.get(connProp);
-    if (odaConnections == null)
-        return;
-    for (CacheConnection conn : odaConnections) {
-        try {
-            conn.odaConn.close();
-        } catch (DataException e) {
-            e.printStackTrace();
+    for (Set<CacheConnection> set : odaConnectionsMap.values()) {
+        for (CacheConnection conn : set) {
+            try {
+                conn.odaConn.close();
+            } catch (DataException e) {
+                e.printStackTrace();
+            }
         }


Input:
public boolean performFinish() {
    if (((NewProjectImportDataPage) getPage(NewProjectImportDataPage.PAGE_NAME)).isPageComplete()) {
        ((NewProjectImportDataPage) getPage(NewProjectImportDataPage.PAGE_NAME)).getFileLoadDataAction().execute();
        Application.applicationMode = EApplicationMode.STANDARD;
        return true;
    }
    return false;
}

Output:
     if (((NewProjectImportDataPage) getPage(NewProjectImportDataPage.PAGE_NAME)).isPageComplete()) {
-        ((NewProjectImportDataPage) getPage(NewProjectImportDataPage.PAGE_NAME)).getFileLoadDataAction().execute();
+        if (!((NewProjectImportDataPage) getPage(NewProjectImportDataPage.PAGE_NAME)).getFileLoadDataAction().execute()) {
+            return false;
+        }
         Application.applicationMode = EApplicationMode.STANDARD;


Input:
public void select(TablePerspective strat, Group group, IReactions reactions) {
    AGSEAAlgorithm algorithm;
    if (createGSEA)
        algorithm = new GSEAAlgorithm(strat.getRecordPerspective(), group, 1.0f);
    else
        algorithm = new PGSEAAlgorithm(strat.getRecordPerspective(), group);
    IScore gsea = new GeneSetScore(strat.getRecordPerspective().getLabel(), algorithm, false);
    IScore pValue = new GeneSetScore(gsea.getLabel() + "String_Node_Str", algorithm.asPValue(), true);
    reactions.addScoreToTourGuide(EDataDomainQueryMode.PATHWAYS, gsea, pValue);
    target.setUnderlying(strat.getRecordPerspective());
    reactions.switchTo(target);
}

Output:
 public void select(TablePerspective strat, Group group, IReactions reactions) {
-    AGSEAAlgorithm algorithm;
-    if (createGSEA)
-        algorithm = new GSEAAlgorithm(strat.getRecordPerspective(), group, 1.0f);
-    else
-        algorithm = new PGSEAAlgorithm(strat.getRecordPerspective(), group);
-    IScore gsea = new GeneSetScore(strat.getRecordPerspective().getLabel(), algorithm, false);
-    IScore pValue = new GeneSetScore(gsea.getLabel() + "String_Node_Str", algorithm.asPValue(), true);
-    reactions.addScoreToTourGuide(EDataDomainQueryMode.PATHWAYS, gsea, pValue);
+    MultiScore score = createScore(strat, group, createGSEA);
+    reactions.addScoreToTourGuide(EDataDomainQueryMode.PATHWAYS, score);
     target.setUnderlying(strat.getRecordPerspective());


Input:
private void cancelAutoCorrect(final InputConnection ic) {
    mWordComposer.resumeSuggestionOnKeptWord();
    final String originallyTypedWord = mWordComposer.getTypedWord();
    final CharSequence autoCorrectedTo = mWordComposer.getAutoCorrectionOrNull();
    final int cancelLength = autoCorrectedTo.length();
    final CharSequence separator = ic.getTextBeforeCursor(1, 0);
    if (DEBUG) {
        final String wordBeforeCursor = ic.getTextBeforeCursor(cancelLength + 1, 0).subSequence(0, cancelLength).toString();
        if (!autoCorrectedTo.equals(wordBeforeCursor)) {
            throw new RuntimeException("String_Node_Str" + "String_Node_Str" + autoCorrectedTo + "String_Node_Str" + wordBeforeCursor + "String_Node_Str");
        }
        if (originallyTypedWord.equals(wordBeforeCursor)) {
            throw new RuntimeException("String_Node_Str" + "String_Node_Str" + originallyTypedWord + "String_Node_Str");
        }
    }
    ic.deleteSurroundingText(cancelLength + 1, 0);
    ic.commitText(originallyTypedWord, 1);
    ic.commitText(separator, 1);
    mWordComposer.deleteAutoCorrection();
    mWordComposer.onCommitWord();
    Utils.Stats.onSeparator(separator.charAt(0), WordComposer.NOT_A_COORDINATE, WordComposer.NOT_A_COORDINATE);
    mHandler.cancelUpdateBigramPredictions();
    mHandler.postUpdateSuggestions();
}

Output:
     mWordComposer.deleteAutoCorrection();
-    mWordComposer.onCommitWord();
+    mWordComposer.onCommitWord(WordComposer.COMMIT_TYPE_CANCEL_AUTO_CORRECT);
     Utils.Stats.onSeparator(separator.charAt(0), WordComposer.NOT_A_COORDINATE, WordComposer.NOT_A_COORDINATE);


Input:
public void removeTypingNotification() {
    conversationPanel.removeTypingNotification();
}

Output:
 public void removeTypingNotification() {
-    conversationPanel.removeTypingNotification();
+    addTypingNotification("String_Node_Str");
 }


Input:
public void run() {
    MessageDialog.openError(Display.getCurrent().getActiveShell(), "String_Node_Str", Message);
}

Output:
 public void run() {
-    MessageDialog.openError(Display.getCurrent().getActiveShell(), "String_Node_Str", Message);
+    MessageDialog.openError(Display.getDefault().getActiveShell(), "String_Node_Str", Message);
 }


Input:
public String toString() {
    return "String_Node_Str" + pkValue + "String_Node_Str";
}

Output:
 public String toString() {
-    return "String_Node_Str" + pkValue + "String_Node_Str";
+    return "String_Node_Str" + value + "String_Node_Str";
 }


Input:
protected void configure() {
    bind(ServiceAnnouncer.class).to(DiscoveryServiceAnnouncer.class);
    bind(QueueReaderFactory.class).in(Scopes.SINGLETON);
    bind(ProgramStateWriter.class).to(DirectStoreProgramStateWriter.class);
    MapBinder<ProgramType, ProgramRunner> runnerFactoryBinder = MapBinder.newMapBinder(binder(), ProgramType.class, ProgramRunner.class);
    runnerFactoryBinder.addBinding(ProgramType.FLOW).to(InMemoryFlowProgramRunner.class);
    runnerFactoryBinder.addBinding(ProgramType.MAPREDUCE).to(MapReduceProgramRunner.class);
    runnerFactoryBinder.addBinding(ProgramType.WORKFLOW).to(WorkflowProgramRunner.class);
    runnerFactoryBinder.addBinding(ProgramType.WEBAPP).to(WebappProgramRunner.class);
    runnerFactoryBinder.addBinding(ProgramType.WORKER).to(InMemoryWorkerRunner.class);
    runnerFactoryBinder.addBinding(ProgramType.SERVICE).to(InMemoryServiceProgramRunner.class);
    bind(FlowletProgramRunner.class);
    bind(ServiceProgramRunner.class);
    bind(WorkerProgramRunner.class);
    bind(ProgramRuntimeProvider.Mode.class).toInstance(ProgramRuntimeProvider.Mode.LOCAL);
    bind(ProgramRunnerFactory.class).to(DefaultProgramRunnerFactory.class).in(Scopes.SINGLETON);
    expose(ProgramRunnerFactory.class);
    bind(ProgramRuntimeService.class).to(InMemoryProgramRuntimeService.class).in(Scopes.SINGLETON);
    expose(ProgramRuntimeService.class);
    install(new DataFabricFacadeModule());
    install(new FactoryModuleBuilder().implement(JarHttpHandler.class, IntactJarHttpHandler.class).build(WebappHttpHandlerFactory.class));
    install(new FactoryModuleBuilder().implement(StreamWriter.class, streamWriterClass).build(StreamWriterFactory.class));
}

Output:
     bind(QueueReaderFactory.class).in(Scopes.SINGLETON);
-    bind(ProgramStateWriter.class).to(DirectStoreProgramStateWriter.class);
+    bind(ProgramStateWriter.class).to(MessagingProgramStateWriter.class);
     MapBinder<ProgramType, ProgramRunner> runnerFactoryBinder = MapBinder.newMapBinder(binder(), ProgramType.class, ProgramRunner.class);


Input:
private void canTestFloatError(BaseTestLog f, float[] d, float[] logD) {
    FPair pair = new FPair();
    if (!next(f, pair, d))
        return;
    float v = logD[pair.i - 1];
    double delta = v - pair.f;
    delta = Math.abs(delta);
    Stats s1 = new Stats(delta, d[pair.i - 1]);
    Stats s2 = new Stats(Math.abs(delta / v), d[pair.i - 1]);
    while (next(f, pair, d)) {
        v = logD[pair.i - 1];
        delta = v - pair.f;
        delta = Math.abs(delta);
        s1.add(delta, d[pair.i - 1]);
        s2.add(Math.abs(delta / v), d[pair.i - 1]);
    }
    System.out.printf("String_Node_Str", f.name, f.getN(), s1.n, s1.summary(), s2.summary());
}

Output:
     Stats s1 = new Stats(delta, d[pair.i - 1]);
-    Stats s2 = new Stats(Math.abs(delta / v), d[pair.i - 1]);
+    Stats s2 = (v != 0) ? new Stats(Math.abs(delta / v), d[pair.i - 1]) : new Stats(0, d[pair.i - 1]);
     while (next(f, pair, d)) {


Input:
public void onNext(CapabilitiesOverall capabilitiesOverall) {
    if (capabilitiesOverall.getOcs().getData().getCapabilities().getSpreedCapability() != null && capabilitiesOverall.getOcs().getData().getCapabilities().getSpreedCapability().getFeatures() != null && capabilitiesOverall.getOcs().getData().getCapabilities().getSpreedCapability().getFeatures().contains("String_Node_Str")) {
        if (room.isHasPassword() && room.isGuest()) {
            eventBus.post(new BottomSheetLockEvent(true, 0, true, false));
            Bundle bundle = new Bundle();
            bundle.putParcelable(BundleKeys.KEY_ROOM, Parcels.wrap(room));
            bundle.putString(BundleKeys.KEY_CALL_URL, callUrl);
            bundle.putInt(BundleKeys.KEY_OPERATION_CODE, 99);
            getRouter().pushController(RouterTransaction.with(new EntryMenuController(bundle)).pushChangeHandler(new HorizontalChangeHandler()).popChangeHandler(new HorizontalChangeHandler()));
        } else {
            initiateCall();
        }
    } else {
        showResultImage(false, true);
    }
}

Output:
         } else {
-            initiateCall();
+            initiateCall(false);
         }


Input:
public int addPseudoFilesToFolder(SrvSession sess, TreeConnection tree, String path) {
    int pseudoCnt = 0;
    ContentContext ctx = (ContentContext) tree.getContext();
    FileState fstate = getStateForPath(ctx, path);
    if (fstate.hasPseudoFiles())
        return 0;
    boolean isCIFS = sess instanceof SMBSrvSession;
    if (isCIFS && ctx.hasDragAndDropApp()) {
        if (fstate == null)
            ctx.getStateTable().findFileState(path, true, true);
        String[] allPaths = FileName.splitAllPaths(path);
        String lastPath = allPaths[allPaths.length - 1].toUpperCase();
        if (lastPath.startsWith("String_Node_Str") && fstate.hasPseudoFiles() == false) {
            fstate.addPseudoFile(ctx.getDragAndDropApp());
            pseudoCnt++;
            if (logger.isInfoEnabled())
                logger.info("String_Node_Str" + path);
        }
    }
    if (isCIFS && ctx.hasURLFile() && fstate.getNodeRef() != null) {
        StringBuilder urlStr = new StringBuilder();
        urlStr.append("String_Node_Str");
        urlStr.append("String_Node_Str");
        urlStr.append(ctx.getURLPrefix());
        urlStr.append("String_Node_Str");
        urlStr.append(fstate.getNodeRef().getId());
        urlStr.append("String_Node_Str");
        byte[] urlData = urlStr.toString().getBytes();
        MemoryPseudoFile urlFile = new MemoryPseudoFile(ctx.getURLFileName(), urlData);
        fstate.addPseudoFile(urlFile);
        pseudoCnt++;
        if (logger.isInfoEnabled())
            logger.info("String_Node_Str" + path);
    }
    return pseudoCnt;
}

Output:
     }
-    if (isCIFS && ctx.hasURLFile() && fstate.getNodeRef() != null) {
-        StringBuilder urlStr = new StringBuilder();
-        urlStr.append("String_Node_Str");
-        urlStr.append("String_Node_Str");
-        urlStr.append(ctx.getURLPrefix());
-        urlStr.append("String_Node_Str");
-        urlStr.append(fstate.getNodeRef().getId());
-        urlStr.append("String_Node_Str");
-        byte[] urlData = urlStr.toString().getBytes();
-        MemoryPseudoFile urlFile = new MemoryPseudoFile(ctx.getURLFileName(), urlData);
-        fstate.addPseudoFile(urlFile);
-        pseudoCnt++;
-        if (logger.isInfoEnabled())
-            logger.info("String_Node_Str" + path);
+    if (isCIFS && ctx.hasURLFile()) {
+        if (fstate.getNodeRef() != null) {
+            StringBuilder urlStr = new StringBuilder();
+            urlStr.append("String_Node_Str");
+            urlStr.append("String_Node_Str");
+            urlStr.append(ctx.getURLPrefix());
+            urlStr.append("String_Node_Str");
+            urlStr.append(fstate.getNodeRef().getId());
+            urlStr.append("String_Node_Str");
+            byte[] urlData = urlStr.toString().getBytes();
+            MemoryPseudoFile urlFile = new MemoryPseudoFile(ctx.getURLFileName(), urlData);
+            fstate.addPseudoFile(urlFile);
+            pseudoCnt++;
+            if (logger.isInfoEnabled())
+                logger.info("String_Node_Str" + path);
+        }
     }


Input:
protected void createInsets(Composite cmpRight, boolean bEnableUI) {
    icInsets = new InsetsComposite(cmpRight, SWT.NONE, getSeriesForProcessing().getLabel().getInsets(), getChart().getUnits(), getContext().getUIServiceProvider());
    {
        GridData gdICInsets = new GridData(GridData.FILL_HORIZONTAL);
        gdICInsets.grabExcessVerticalSpace = false;
        icInsets.setLayoutData(gdICInsets);
        icInsets.addListener(this);
        icInsets.setDefaultInsetsValue(DefaultValueProvider.defSeries().getLabel().getInsets());
        icInsets.setEnabled(bEnableUI);
    }
}

Output:
 protected void createInsets(Composite cmpRight, boolean bEnableUI) {
-    icInsets = new InsetsComposite(cmpRight, SWT.NONE, getSeriesForProcessing().getLabel().getInsets(), getChart().getUnits(), getContext().getUIServiceProvider());
+    icInsets = new InsetsComposite(cmpRight, SWT.NONE, getSeriesForProcessing().getLabel().getInsets(), getChart().getUnits(), getContext().getUIServiceProvider(), getContext());
     {


Input:
public void onInitialization(PreInitializationEvent event) {
    instance = this;
    logger.info("String_Node_Str");
    initializeEventHandlers();
    server = new PoreServer(event.getGame(), logger);
}

Output:
     initializeEventHandlers();
-    server = new PoreServer(event.getGame(), logger);
+    server = new PoreServer(game, logger);
 }


Input:
public void refreshFigure() {
    int color = getBackgroundColor((MasterPageHandle) getModel());
    getFigure().setBackgroundColor(getBackGroundColor(color));
    Dimension size = getMasterPageSize((MasterPageHandle) getModel());
    Rectangle bounds = new Rectangle(0, 0, size.width - 1, size.height - 1);
    ((AbstractPageFlowLayout) getFigure().getLayoutManager()).setInitSize(bounds);
    ReportDesignMarginBorder reportDesignMarginBorder = new ReportDesignMarginBorder(getMasterPageInsets((MasterPageHandle) getModel()));
    reportDesignMarginBorder.setBackgroundColor(((MasterPageHandle) getModel()).getPropertyHandle(StyleHandle.BACKGROUND_COLOR_PROP).getIntValue());
    refreshMarginBorder(reportDesignMarginBorder);
    refreshBackground((MasterPageHandle) getModel());
    ((ReportElementFigure) getFigure()).setBackGroundImageSize(getModelAdapter().getBackgroundImageWidth((MasterPageHandle) getModel()), getModelAdapter().getBackgroundImageHeight((MasterPageHandle) getModel()));
}

Output:
     refreshBackground((MasterPageHandle) getModel());
-    ((ReportElementFigure) getFigure()).setBackGroundImageSize(getModelAdapter().getBackgroundImageWidth((MasterPageHandle) getModel()), getModelAdapter().getBackgroundImageHeight((MasterPageHandle) getModel()));
+    ((ReportElementFigure) getFigure()).setBackGroundImageSize(getModelAdapter().getBackgroundImageWidth((MasterPageHandle) getModel(), size, getBackImage((MasterPageHandle) getModel())), getModelAdapter().getBackgroundImageHeight((MasterPageHandle) getModel(), size, getBackImage((MasterPageHandle) getModel())));
 }


Input:
public void init() {
    inputs.getInput("String_Node_Str").bind(Player.playing.o);
    loadSkin("String_Node_Str", root);
    mainImage.setBorderVisible(true);
    mainImage.setBorderToImage(true);
    layAnchor(root, mainImage.getPane(), 0d);
    thumbAnim = new Anim(millis(500), thumb_root::setOpacity);
    thumb_root.visibleProperty().bind(thumb_root.opacityProperty().isNotEqualTo(0));
    thumb_root.toFront();
    Icon nextB = new Icon(ARROW_RIGHT, 18, "String_Node_Str", this::nextImage);
    nextB.setMouseTransparent(true);
    Pane nextP = new StackPane(nextB);
    nextP.setOnMouseClicked(nextB.getOnMouseClicked());
    nextP.getStyleClass().setAll("String_Node_Str");
    nextP.prefWidthProperty().bind(root.widthProperty().divide(10));
    nextP.setMinWidth(20);
    nextP.visibleProperty().bind(nextP.opacityProperty().isNotEqualTo(0));
    nextP.setBackground(bgr(Color.color(0, 0, 0, 0.2)));
    Icon prevB = new Icon(ARROW_LEFT, 18, "String_Node_Str", this::prevImage);
    prevB.setMouseTransparent(true);
    Pane prevP = new StackPane(prevB);
    prevP.setOnMouseClicked(prevB.getOnMouseClicked());
    prevP.getStyleClass().setAll("String_Node_Str");
    prevP.prefWidthProperty().bind(root.widthProperty().divide(10));
    prevP.setMinWidth(20);
    prevP.visibleProperty().bind(prevP.opacityProperty().isNotEqualTo(0));
    prevP.setBackground(bgr(Color.color(0, 0, 0, 0.2)));
    layAnchor(root, prevP, 0d, null, 0d, 0d);
    layAnchor(root, nextP, 0d, 0d, 0d, null);
    Anim navanim = new Anim(millis(500), p -> {
        prevP.setOpacity(p);
        nextP.setOpacity(p);
        prevB.setTranslateX(+40 * (p - 1));
        nextB.setTranslateX(-40 * (p - 1));
    });
    navanim.affector.accept(0d);
    EventReducer inactive = toLast(1500, navanim::playClose);
    EventReducer active = toFirstDelayed(500, navanim::playOpen);
    root.addEventFilter(MOUSE_MOVED, e -> {
        if (thumb_root.getOpacity() == 0) {
            if (prevP.getOpacity() != 1)
                active.push(e);
            else
                inactive.push(e);
        }
    });
    setAnchors(thumb_root, 0d);
    root.heightProperty().addListener((o, ov, nv) -> setBottomAnchor(thumb_root, nv.doubleValue() * 0.3));
    root.setOnMouseClicked(e -> {
        if (e.getButton() == PRIMARY) {
            if (e.getY() > 0.8 * root.getHeight() && e.getX() > 0.7 * root.getWidth()) {
                theater_mode.setCycledNapplyValue();
            } else {
                showThumbnails.setCycledNapplyValue();
            }
            e.consume();
        }
    });
    thumb_root.setOnMouseClicked(e -> {
        if (e.getButton() == PRIMARY) {
            showThumbnails.setCycledNapplyValue();
            e.consume();
        }
    });
    ChangeListener<File> locationChange = (o, ov, nv) -> readThumbnails();
    folder.addListener(locationChange);
    d(() -> folder.removeListener(locationChange));
    root.setOnDragOver(DragUtil.audioDragAccepthandler);
    root.setOnDragOver(DragUtil.imageFileDragAccepthandler);
    root.setOnDragOver(DragUtil.fileDragAccepthandler);
    root.setOnDragDropped(e -> {
        if (e.getDragboard().hasFiles()) {
            dataChanged(e.getDragboard().getFiles().get(0));
            e.setDropCompleted(true);
            e.consume();
            return;
        }
        if (e.getGestureSource().equals(mainImage.getPane()))
            return;
        if (DragUtil.hasAudio(e.getDragboard())) {
            List<Item> items = DragUtil.getAudioItems(e);
            if (!items.isEmpty())
                dataChanged(items.get(0));
            e.setDropCompleted(true);
            e.consume();
        } else if (DragUtil.hasImage(e.getDragboard())) {
            DragUtil.getImages(e).use(this::showImages, FX).showProgress(App.getWindow().taskAdd()).run();
            e.setDropCompleted(true);
            e.consume();
        }
    });
    thumb_root.setOnScroll(Event::consume);
}

Output:
     layAnchor(root, nextP, 0d, 0d, 0d, null);
-    Anim navanim = new Anim(millis(500), p -> {
+    navigAnim = new Anim(millis(500), p -> {
         prevP.setOpacity(p);


Input:
protected ValidationResult doValidate() {
    ProtoConstraint.validateNotNull(timeZone, "String_Node_Str");
    TimeZone tz = TimeZone.getTimeZone(timeZone);
    Calendar calendar = Calendar.getInstance(tz);
    DateFormat formatter = new SimpleDateFormat("String_Node_Str");
    formatter.setTimeZone(tz);
    Date startDate, endDate;
    try {
        startDate = formatter.parse(startTime);
    } catch (ParseException e) {
        throw new IllegalArgumentException(String.format("String_Node_Str", startTime), e);
    }
    try {
        endDate = formatter.parse(endTime);
    } catch (ParseException e) {
        throw new IllegalArgumentException(String.format("String_Node_Str", endTime), e);
    }
    if (startDate.compareTo(endDate) >= 0) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    return new ValidationResult(calendar, startDate, endDate);
}

Output:
     }
-    if (startDate.compareTo(endDate) >= 0) {
-        throw new IllegalArgumentException("String_Node_Str");
+    if (startDate.compareTo(endDate) == 0) {
+        throw new IllegalArgumentException(String.format("String_Node_Str", startTime, endTime));
     }


Input:
public void onClosedToLeft() {
    tvShowSelected = null;
    getSupportActionBar().setTitle(R.string.tv_shows_sample_activity_title);
}

Output:
 public void onClosedToLeft() {
-    tvShowSelected = null;
-    getSupportActionBar().setTitle(R.string.tv_shows_sample_activity_title);
+    resetActionBarTitle();
 }


Input:
public static void setLocale(ULocale locale) {
    currentLocale = locale;
    if (resourceBundle != null) {
        synchronized (Thread.currentThread()) {
            if (resourceBundle == null)
                return;
            if ((locale == null && !ULocale.getDefault().toLocale().equals(resourceBundle.getLocale())) || (locale != null && !locale.toLocale().equals(resourceBundle.getLocale()))) {
                resourceBundle = null;
            }
        }
    }
}

Output:
     if (resourceBundle != null) {
-        synchronized (Thread.currentThread()) {
+        synchronized (DataException.class) {
             if (resourceBundle == null)


Input:
boolean checkEquivalenceHelper(final JSType that, EquivalenceMethod eqMethod, EqCache eqCache) {
    if (this == that) {
        return true;
    }
    if (this.isNoResolvedType() && that.isNoResolvedType()) {
        if (this.isNamedType() && that.isNamedType()) {
            return Objects.equals(((NamedType) this).getReferenceName(), ((NamedType) that).getReferenceName());
        } else {
            return true;
        }
    }
    boolean thisUnknown = isUnknownType();
    boolean thatUnknown = that.isUnknownType();
    if (thisUnknown || thatUnknown) {
        if (eqMethod == EquivalenceMethod.INVARIANT) {
            return true;
        } else if (eqMethod == EquivalenceMethod.DATA_FLOW) {
            return thisUnknown && thatUnknown;
        } else if (thisUnknown && thatUnknown && (isNominalType() ^ that.isNominalType())) {
            return false;
        }
    }
    if (isUnionType() && that.isUnionType()) {
        return toMaybeUnionType().checkUnionEquivalenceHelper(that.toMaybeUnionType(), eqMethod, eqCache);
    }
    if (isFunctionType() && that.isFunctionType()) {
        return toMaybeFunctionType().checkFunctionEquivalenceHelper(that.toMaybeFunctionType(), eqMethod, eqCache);
    }
    if (!getTemplateTypeMap().checkEquivalenceHelper(that.getTemplateTypeMap(), eqMethod, eqCache, SubtypingMode.NORMAL)) {
        return false;
    }
    if (eqCache.isStructuralTyping() && this.isStructuralType() && that.isStructuralType()) {
        return toMaybeObjectType().checkStructuralEquivalenceHelper(that.toMaybeObjectType(), eqMethod, eqCache);
    }
    if (isNominalType() && that.isNominalType()) {
        return getConcreteNominalTypeName(this.toObjectType()).equals(getConcreteNominalTypeName(that.toObjectType()));
    }
    if (isTemplateType() && that.isTemplateType()) {
        return false;
    }
    if (this instanceof ProxyObjectType) {
        return ((ProxyObjectType) this).getReferencedTypeInternal().checkEquivalenceHelper(that, eqMethod, eqCache);
    }
    if (that instanceof ProxyObjectType) {
        return checkEquivalenceHelper(((ProxyObjectType) that).getReferencedTypeInternal(), eqMethod, eqCache);
    }
    return false;
}

Output:
 boolean checkEquivalenceHelper(final JSType that, EquivalenceMethod eqMethod, EqCache eqCache) {
-    if (this == that) {
+    if (areIdentical(this, that)) {
         return true;


Input:
private void switchUI() {
    switch(getTriggerIndex()) {
        case INDEX_1_URL_REDIRECT:
            Trigger trigger = (Trigger) triggersMap.get(cmbTriggerType.getText());
            if (trigger == null || trigger.getAction() == null) {
                multiHyperlinksComposite.populateUIValues(MultiURLValuesImpl.create());
                this.slValues.topControl = multiHyperlinksComposite;
            } else {
                this.slValues.topControl = cmpURL;
            }
            break;
        case INDEX_2_TOOLTIP:
            this.slValues.topControl = cmpTooltip;
            break;
        case INDEX_3_TOOGLE_VISABILITY:
            this.slValues.topControl = cmpVisiblity;
            break;
        case INDEX_4_SCRIPT:
            this.slValues.topControl = cmpScript;
            break;
        case INDEX_5_HIGHLIGHT:
            this.slValues.topControl = cmpHighlight;
            break;
        case INDEX_6_CALLBACK:
            this.slValues.topControl = cmpCallback;
            break;
        case INDEX_7_TOOGLE_DATAPOINT:
            this.slValues.topControl = cmpDPVisibility;
            break;
        default:
            this.slValues.topControl = cmpDefault;
            break;
    }
    grpValue.layout();
}

Output:
             Trigger trigger = (Trigger) triggersMap.get(cmbTriggerType.getText());
-            if (trigger == null || trigger.getAction() == null) {
+            if (trigger == null || !(trigger.getAction().getValue() instanceof MultiURLValues)) {
                 multiHyperlinksComposite.populateUIValues(MultiURLValuesImpl.create());


Input:
public Object convertArray(PropertyType propertyType, java.sql.Array array) throws SQLException {
    switch(propertyType) {
        case BOOLEAN_ARRAY:
            return array.getArray();
        case boolean_ARRAY:
            return SqlgUtil.convertObjectArrayToBooleanPrimitiveArray((Object[]) array.getArray());
        case SHORT_ARRAY:
            return SqlgUtil.convertObjectOfIntegersArrayToShortArray((Object[]) array.getArray());
        case short_ARRAY:
            return SqlgUtil.convertObjectOfIntegersArrayToShortPrimitiveArray((Object[]) array.getArray());
        case INTEGER_ARRAY:
            return array.getArray();
        case int_ARRAY:
            return SqlgUtil.convertObjectOfIntegersArrayToIntegerPrimitiveArray((Object[]) array.getArray());
        case LONG_ARRAY:
            return array.getArray();
        case long_ARRAY:
            return SqlgUtil.convertObjectOfLongsArrayToLongPrimitiveArray((Object[]) array.getArray());
        case DOUBLE_ARRAY:
            return array.getArray();
        case double_ARRAY:
            return SqlgUtil.convertObjectOfDoublesArrayToDoublePrimitiveArray((Object[]) array.getArray());
        case FLOAT_ARRAY:
            return array.getArray();
        case float_ARRAY:
            return SqlgUtil.convertObjectOfFloatsArrayToFloatPrimitiveArray((Object[]) array.getArray());
        case STRING_ARRAY:
            return array.getArray();
        case LOCALDATETIME_ARRAY:
            Timestamp[] timestamps = (Timestamp[]) array.getArray();
            return SqlgUtil.copyToLocalDateTime(timestamps, new LocalDateTime[timestamps.length]);
        case LOCALDATE_ARRAY:
            Date[] dates = (Date[]) array.getArray();
            return SqlgUtil.copyToLocalDate(dates, new LocalDate[dates.length]);
        case LOCALTIME_ARRAY:
            Time[] times = (Time[]) array.getArray();
            LocalTime[] lts = SqlgUtil.copyToLocalTime(times, new LocalTime[times.length]);
            for (int a = 0; a < times.length; a++) {
                lts[a] = shiftDST(lts[a]).toLocalTime();
            }
            return lts;
        case JSON_ARRAY:
            String arrayAsString = array.toString();
            arrayAsString = arrayAsString.substring(1);
            arrayAsString = arrayAsString.substring(0, arrayAsString.length() - 1);
            arrayAsString = StringEscapeUtils.unescapeJava(arrayAsString);
            arrayAsString = arrayAsString.substring(1);
            arrayAsString = arrayAsString.substring(0, arrayAsString.length() - 1);
            String[] jsons = arrayAsString.split("String_Node_Str");
            JsonNode[] jsonNodes = new JsonNode[jsons.length];
            ObjectMapper objectMapper = new ObjectMapper();
            int count = 0;
            for (String json : jsons) {
                try {
                    JsonNode jsonNode = objectMapper.readTree(json);
                    jsonNodes[count++] = jsonNode;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return jsonNodes;
        default:
            throw new IllegalStateException("String_Node_Str" + propertyType.name());
    }
}

Output:
             Time[] times = (Time[]) array.getArray();
-            LocalTime[] lts = SqlgUtil.copyToLocalTime(times, new LocalTime[times.length]);
-            for (int a = 0; a < times.length; a++) {
-                lts[a] = shiftDST(lts[a]).toLocalTime();
-            }
-            return lts;
+            return SqlgUtil.copyToLocalTime(times, new LocalTime[times.length]);
         case JSON_ARRAY:


Input:
void maybeRescheduleSync(SyncResult syncResult, SyncOperation operation) {
    boolean isLoggable = Log.isLoggable(TAG, Log.DEBUG);
    if (isLoggable) {
        Log.d(TAG, "String_Node_Str" + syncResult + "String_Node_Str" + operation);
    }
    operation = new SyncOperation(operation);
    if (operation.extras.getBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_BACKOFF, false)) {
        operation.extras.remove(ContentResolver.SYNC_EXTRAS_IGNORE_BACKOFF);
    }
    if (operation.extras.getBoolean(ContentResolver.SYNC_EXTRAS_DO_NOT_RETRY, false)) {
        Log.d(TAG, "String_Node_Str" + operation);
    } else if (operation.extras.getBoolean(ContentResolver.SYNC_EXTRAS_UPLOAD, false)) {
        operation.extras.remove(ContentResolver.SYNC_EXTRAS_UPLOAD);
        Log.d(TAG, "String_Node_Str" + "String_Node_Str" + operation);
        scheduleSyncOperation(operation);
    } else if (syncResult.tooManyRetries) {
        Log.d(TAG, "String_Node_Str" + operation);
    } else if (syncResult.madeSomeProgress()) {
        if (isLoggable) {
            Log.d(TAG, "String_Node_Str" + "String_Node_Str");
        }
        scheduleSyncOperation(operation);
    } else if (syncResult.syncAlreadyInProgress) {
        if (isLoggable) {
            Log.d(TAG, "String_Node_Str" + "String_Node_Str" + operation);
        }
        scheduleSyncOperation(new SyncOperation(operation.account, operation.syncSource, operation.authority, operation.extras, DELAY_RETRY_SYNC_IN_PROGRESS_IN_SECONDS));
    } else if (syncResult.hasSoftError()) {
        if (isLoggable) {
            Log.d(TAG, "String_Node_Str" + operation);
        }
        scheduleSyncOperation(operation);
    } else {
        Log.d(TAG, "String_Node_Str" + operation);
    }
}

Output:
         }
-        scheduleSyncOperation(new SyncOperation(operation.account, operation.syncSource, operation.authority, operation.extras, DELAY_RETRY_SYNC_IN_PROGRESS_IN_SECONDS));
+        scheduleSyncOperation(new SyncOperation(operation.account, operation.syncSource, operation.authority, operation.extras, DELAY_RETRY_SYNC_IN_PROGRESS_IN_SECONDS * 1000));
     } else if (syncResult.hasSoftError()) {


Input:
public void run() {
    try {
        _writer.set(new BlurIndexWriter(_directory, _conf.clone()));
        synchronized (_writer) {
            _writer.notify();
        }
        _indexImporter = new IndexImporter(_writer.get(), _lock, _shardContext, TimeUnit.SECONDS, 10);
    } catch (IOException e) {
        LOG.error("String_Node_Str", e);
    }
}

Output:
         }
-        _indexImporter = new IndexImporter(_writer.get(), _lock, _shardContext, TimeUnit.SECONDS, 10);
+        _indexImporter = new IndexImporter(BlurIndexSimpleWriter.this, _shardContext, TimeUnit.SECONDS, 10);
     } catch (IOException e) {


Input:
public static Log get() {
    return LogFactory.get();
}

Output:
 public static Log get() {
-    return LogFactory.get();
+    return LogFactory.indirectGet();
 }


Input:
static String modifyForSpecialCnapCases(Context context, CallerInfo ci, String number, int presentation) {
    if (ci == null || number == null)
        return number;
    if (DBG)
        log("String_Node_Str" + number + "String_Node_Str" + presentation);
    if (number.equals(context.getString(R.string.absent_num))) {
        number = context.getString(R.string.unknown);
        ci.numberPresentation = Connection.PRESENTATION_UNKNOWN;
    }
    if (ci.numberPresentation == Connection.PRESENTATION_ALLOWED || ci.numberPresentation != presentation) {
        int cnapSpecialCase = checkCnapSpecialCases(number);
        if (cnapSpecialCase != CNAP_SPECIAL_CASE_NO) {
            if (cnapSpecialCase == Connection.PRESENTATION_RESTRICTED) {
                number = context.getString(R.string.private_num);
            } else if (cnapSpecialCase == Connection.PRESENTATION_UNKNOWN) {
                number = context.getString(R.string.unknown);
            }
            if (DBG)
                log("String_Node_Str" + number + "String_Node_Str" + cnapSpecialCase);
            ci.numberPresentation = cnapSpecialCase;
        }
    }
    if (DBG)
        log("String_Node_Str" + number);
    return number;
}

Output:
         log("String_Node_Str" + number + "String_Node_Str" + presentation);
-    if (number.equals(context.getString(R.string.absent_num))) {
+    if (number.equals(context.getString(R.string.absent_num)) && presentation == Connection.PRESENTATION_ALLOWED) {
         number = context.getString(R.string.unknown);


Input:
public void writeToParcel(Parcel dest, int flags) {
    super.writeToParcel(dest, flags);
    dest.writeInt(num);
}

Output:
 public void writeToParcel(Parcel dest, int flags) {
-    super.writeToParcel(dest, flags);
+    dest.writeString(owner);
+    dest.writeString(repo);
     dest.writeInt(num);


Input:
static void aastore(Object[] arrayRef, int index, Object value) throws ArrayStoreException, ArrayIndexOutOfBoundsException {
    checkstore(arrayRef, value);
    int nelts = ObjectModel.getArrayLength(arrayRef);
    if (index < nelts) {
        Services.setArrayUninterruptible(arrayRef, index, value);
    } else {
        throw new ArrayIndexOutOfBoundsException(index);
    }
}

Output:
     int nelts = ObjectModel.getArrayLength(arrayRef);
-    if (index < nelts) {
+    if (index >= 0 && index < nelts) {
         Services.setArrayUninterruptible(arrayRef, index, value);


Input:
public Pair<double[], double[]> episodeResult(int num) {
    double[] fitness = new double[numObjectives()];
    int index = 0;
    if (tetrisTimeSteps)
        fitness[index++] = rlNumSteps[num];
    if (tetrisBlocksOnScreen) {
        TetrisAfterStateAgent<T> tasa = (TetrisAfterStateAgent<T>) agent;
        int numberOfBlocksInState;
        if (rlNumSteps[num] == maxStepsPerEpisode) {
            numberOfBlocksInState = TetrisState.worldHeight * TetrisState.worldWidth;
        } else {
            numberOfBlocksInState = tasa.getNumberOfBlocksInLastState();
        }
        fitness[index++] = numberOfBlocksInState;
    }
    Tetris game = (Tetris) environment;
    if (tetrisAvgEmptySpaces)
        fitness[index++] = game.getAverageNumEmptySpaces();
    if (tetrisLinesNotScore) {
        fitness[index++] = game.getLinesCleared();
    } else {
        fitness[index++] = rlReturn[num];
    }
    double[] rowCounts = game.getNumberOfRowsCleared();
    double[] otherScores = new double[numOtherScores()];
    otherScores[0] = rowCounts[0];
    otherScores[1] = rowCounts[1];
    otherScores[2] = rowCounts[2];
    otherScores[3] = rowCounts[3];
    otherScores[4] = game.getLinesCleared();
    otherScores[3] = rlReturn[num];
    Pair<double[], double[]> p = new Pair<double[], double[]>(fitness, otherScores);
    return p;
}

Output:
     otherScores[4] = game.getLinesCleared();
-    otherScores[3] = rlReturn[num];
+    otherScores[5] = rlReturn[num];
     Pair<double[], double[]> p = new Pair<double[], double[]>(fitness, otherScores);


Input:
private boolean doWrite(SelectionKey selectionKey) {
    boolean result = false;
    SocketChannel channel = (SocketChannel) selectionKey.channel();
    RpcNioConnector connector = connectorCache.get(channel);
    if (connector.isNeedToSend()) {
        try {
            RpcNioBuffer connectorWriteBuf = connector.getRpcNioWriteBuffer();
            ByteBuffer channelWriteBuf = connector.getChannelWriteBuffer();
            while (connector.isNeedToSend()) {
                RpcObject rpc = connector.getToSend();
                connectorWriteBuf.writeRpcObject(rpc);
                channelWriteBuf.put(connectorWriteBuf.readBytes());
                channelWriteBuf.flip();
                int wantWrite = channelWriteBuf.limit() - channelWriteBuf.position();
                int write = 0;
                while (write < wantWrite) {
                    write += channel.write(channelWriteBuf);
                }
                channelWriteBuf.clear();
                result = true;
            }
            if (!connector.isNeedToSend()) {
                selectionKey.interestOps(READ_OP);
            }
        } catch (Exception e) {
            connector.handleNetException(e);
        }
    }
    return result;
}

Output:
         } catch (Exception e) {
-            connector.handleNetException(e);
+            this.handSelectionKeyException(selectionKey, e);
         }


Input:
public static MumblerRootNode create(FrameSlot[] argumentNames, MumblerNode[] bodyNodes) {
    MumblerNode[] allNodes = new MumblerNode[argumentNames.length + bodyNodes.length];
    for (int i = 0; i < argumentNames.length; i++) {
        allNodes[i] = DefineNodeFactory.create(new ReadArgumentNode(i), argumentNames[i]);
    }
    System.arraycopy(bodyNodes, bodyNodes.length, allNodes, argumentNames.length, bodyNodes.length);
    return new MumblerRootNode(bodyNodes);
}

Output:
     }
-    System.arraycopy(bodyNodes, bodyNodes.length, allNodes, argumentNames.length, bodyNodes.length);
-    return new MumblerRootNode(bodyNodes);
+    System.arraycopy(bodyNodes, 0, allNodes, argumentNames.length, bodyNodes.length);
+    return new MumblerRootNode(allNodes, frameDescriptor);
 }


Input:
public void testCursorOnPageEdge() throws Exception {
    ICubeQueryDefinition cqd = creator.createMirroredQueryDefinitionWithPage();
    IBinding rowGrandTotal = new Binding("String_Node_Str");
    rowGrandTotal.setAggrFunction(IBuildInAggregation.TOTAL_SUM_FUNC);
    rowGrandTotal.setExpression(new ScriptExpression("String_Node_Str"));
    rowGrandTotal.addAggregateOn("String_Node_Str");
    rowGrandTotal.addAggregateOn("String_Node_Str");
    IBinding columnGrandTotal = new Binding("String_Node_Str");
    columnGrandTotal.setAggrFunction(IBuildInAggregation.TOTAL_AVE_FUNC);
    columnGrandTotal.setExpression(new ScriptExpression("String_Node_Str"));
    columnGrandTotal.addAggregateOn("String_Node_Str");
    columnGrandTotal.addAggregateOn("String_Node_Str");
    columnGrandTotal.addAggregateOn("String_Node_Str");
    columnGrandTotal.addAggregateOn("String_Node_Str");
    columnGrandTotal.addAggregateOn("String_Node_Str");
    IBinding totalGrandTotal = new Binding("String_Node_Str");
    totalGrandTotal.setAggrFunction(IBuildInAggregation.TOTAL_SUM_FUNC);
    totalGrandTotal.setExpression(new ScriptExpression("String_Node_Str"));
    totalGrandTotal.addAggregateOn("String_Node_Str");
    cqd.addBinding(rowGrandTotal);
    cqd.addBinding(columnGrandTotal);
    cqd.addBinding(totalGrandTotal);
    BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(null, cqd, de.getSession(), this.scope, de.getContext()));
    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube1);
    List columnEdgeBindingNames = new ArrayList();
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    columnEdgeBindingNames.add("String_Node_Str");
    List rowEdgeBindingNames = new ArrayList();
    rowEdgeBindingNames.add("String_Node_Str");
    List measureBindingNames = new ArrayList();
    measureBindingNames.add("String_Node_Str");
    List rowGrandTotalNames = new ArrayList();
    rowGrandTotalNames.add("String_Node_Str");
    List pageBindingNames = new ArrayList();
    pageBindingNames.add("String_Node_Str");
    testOut.print(creator.printCubeAlongPageEdge(dataCursor, pageBindingNames, columnEdgeBindingNames, rowEdgeBindingNames, measureBindingNames, rowGrandTotalNames, "String_Node_Str", "String_Node_Str", null));
    this.checkOutputFile();
}

Output:
     BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(null, cqd, de.getSession(), this.scope, de.getContext()));
-    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube1);
+    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube1, false);
     List columnEdgeBindingNames = new ArrayList();


Input:
public boolean equals(Object o) {
    if (this == o)
        return true;
    if (o == null || getClass() != o.getClass())
        return false;
    RIEntry<?, ?> e2 = (RIEntry<?, ?>) o;
    return this.getKey().equals(e2.getKey()) && this.getValue().equals(e2.getValue());
}

Output:
         return true;
-    if (o == null || getClass() != o.getClass())
+    if (o == null || ((Object) this).getClass() != o.getClass())
         return false;


Input:
public CloseableIterator<RawMessage> fetch() throws IOException, TopicNotFoundException {
    GenericRecord record = new GenericData.Record(Schemas.V1.ConsumeRequest.SCHEMA);
    if (getStartOffset() != null) {
        record.put("String_Node_Str", ByteBuffer.wrap(getStartOffset()));
    }
    if (getStartTime() != null) {
        record.put("String_Node_Str", getStartTime());
    }
    record.put("String_Node_Str", isIncludeStart());
    record.put("String_Node_Str", getLimit());
    if (getTransaction() != null) {
        record.put("String_Node_Str", ByteBuffer.wrap(TRANSACTION_CODEC.encode(getTransaction())));
    }
    URL url = remoteClient.resolve(createTopicPath(topicId) + "String_Node_Str");
    final HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
    urlConn.setConnectTimeout(HTTP_REQUEST_CONFIG.getConnectTimeout());
    urlConn.setReadTimeout(HTTP_REQUEST_CONFIG.getReadTimeout());
    urlConn.setRequestMethod("String_Node_Str");
    urlConn.setRequestProperty(HttpHeaders.CONTENT_TYPE, "String_Node_Str");
    urlConn.setDoInput(true);
    urlConn.setDoOutput(true);
    Encoder encoder = EncoderFactory.get().directBinaryEncoder(urlConn.getOutputStream(), null);
    DatumWriter<GenericRecord> datumWriter = new GenericDatumWriter<>(Schemas.V1.ConsumeRequest.SCHEMA);
    datumWriter.write(record, encoder);
    int responseCode = urlConn.getResponseCode();
    if (responseCode == HttpURLConnection.HTTP_NOT_FOUND) {
        throw new TopicNotFoundException(topicId.getNamespace(), topicId.getTopic());
    }
    handleError(responseCode, new Supplier<String>() {
        public String get() {
            InputStream errorStream = urlConn.getErrorStream();
            try {
                return errorStream == null ? "String_Node_Str" : new String(ByteStreams.toByteArray(errorStream), StandardCharsets.UTF_8);
            } catch (IOException e) {
                return "String_Node_Str";
            }
        }
    }, "String_Node_Str" + topicId);
    verifyContentType(urlConn.getHeaderFields(), "String_Node_Str");
    final Decoder decoder = DecoderFactory.get().binaryDecoder(urlConn.getInputStream(), null);
    final long initialItemCount = decoder.readArrayStart();
    return new AbstractCloseableIterator<RawMessage>() {
        private long itemCount = initialItemCount;
        protected RawMessage computeNext() {
            if (initialItemCount == 0) {
                return endOfData();
            }
            try {
                if (itemCount == 0) {
                    itemCount = decoder.arrayNext();
                    if (itemCount == 0) {
                        return endOfData();
                    }
                }
                itemCount--;
                messageRecord = messageReader.read(messageRecord, decoder);
                return new RawMessage(Bytes.toBytes((ByteBuffer) messageRecord.get("String_Node_Str")), Bytes.toBytes((ByteBuffer) messageRecord.get("String_Node_Str")));
            } catch (IOException e) {
                throw Throwables.propagate(e);
            }
        }
        public void close() {
            urlConn.disconnect();
        }
    };
}

Output:
     verifyContentType(urlConn.getHeaderFields(), "String_Node_Str");
-    final Decoder decoder = DecoderFactory.get().binaryDecoder(urlConn.getInputStream(), null);
+    final InputStream inputStream = urlConn.getInputStream();
+    final Decoder decoder = DecoderFactory.get().binaryDecoder(inputStream, null);
     final long initialItemCount = decoder.readArrayStart();


Input:
public boolean clearCache() {
    for (File file : cacheFolder.listFiles()) file.delete();
    if (cacheFolder.listFiles().length == 0)
        return true;
    else
        return false;
}

Output:
 public boolean clearCache() {
-    for (File file : cacheFolder.listFiles()) file.delete();
-    if (cacheFolder.listFiles().length == 0)
+    for (File file : cacheFolder.listFiles()) {
+        file.delete();
+    }
+    if (cacheFolder.listFiles().length == 0) {
         return true;


Input:
protected void _computeToConsumeProduct(BillOfMaterial billOfMaterial, int bomLevel, CostSheetLine parentCostSheetLine) throws AxelorException {
    if (billOfMaterial.getBillOfMaterialSet() != null) {
        for (BillOfMaterial billOfMaterialLine : billOfMaterial.getBillOfMaterialSet()) {
            Product product = billOfMaterialLine.getProduct();
            if (product != null) {
                CostSheetLine costSheetLine = costSheetLineService.createConsumedProductCostSheetLine(product, billOfMaterialLine.getUnit(), bomLevel, parentCostSheetLine, billOfMaterialLine.getQty());
                BigDecimal wasteRate = billOfMaterialLine.getWasteRate();
                if (wasteRate != null && wasteRate.compareTo(BigDecimal.ZERO) > 0) {
                    costSheetLineService.createConsumedProductWasteCostSheetLine(product, billOfMaterialLine.getUnit(), bomLevel, parentCostSheetLine, billOfMaterialLine.getQty(), wasteRate);
                }
                if (!billOfMaterialLine.getDefineSubBillOfMaterial()) {
                    this._computeCostPrice(billOfMaterialLine, bomLevel, costSheetLine);
                }
            }
        }
    }
}

Output:
                 }
-                if (!billOfMaterialLine.getDefineSubBillOfMaterial()) {
+                if (billOfMaterialLine.getDefineSubBillOfMaterial()) {
                     this._computeCostPrice(billOfMaterialLine, bomLevel, costSheetLine);