Input:
public String[] getGfxFolders() {
    return getFolders("String_Node_Str");
}

Output:
 public String[] getGfxFolders() {
-    return getFolders("String_Node_Str");
+    return getFolders("String_Node_Str", "String_Node_Str", "String_Node_Str");
 }


Input:
public void postCreateUser() {
    Validator validator = getUserValidator();
    if (validator.isValid()) {
        this.userManager.createUser(this.currentUser(), in("String_Node_Str"), in("String_Node_Str"), in("String_Node_Str"));
        redirect(getProperty(APPLICATION_BASE_URL));
    } else {
        out("String_Node_Str", this.currentUser());
        echo();
        invalid(NEW_USER_TPL);
    }
}

Output:
     if (validator.isValid()) {
-        this.userManager.createUser(this.currentUser(), in("String_Node_Str"), in("String_Node_Str"), in("String_Node_Str"));
+        this.userManager.createUser(this.currentUser(), this.in("String_Node_Str", safeString()), this.in("String_Node_Str", safeString()), this.in("String_Node_Str", new SafeStringConverter()));
         redirect(getProperty(APPLICATION_BASE_URL));


Input:
public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    if (controller != null) {
        Set<Card> lands = new HashSet<>();
        for (UUID playerId : game.getState().getPlayersInRange(controller.getId(), game)) {
            Player player = game.getPlayer(playerId);
            if (player != null) {
                for (String landName : new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" }) {
                    FilterLandPermanent filter = new FilterLandPermanent(landName + "String_Node_Str");
                    filter.add(new SubtypePredicate(landName));
                    filter.add(new ControllerPredicate(TargetController.YOU));
                    Target target = new TargetLandPermanent(1, 1, filter, true);
                    if (target.canChoose(source.getSourceId(), player.getId(), game)) {
                        player.chooseTarget(outcome, target, source, game);
                        lands.add(game.getPermanent(target.getFirstTarget()));
                    }
                }
            }
        }
        controller.moveCards(lands, Zone.HAND, source, game);
        return true;
    }
    return false;
}

Output:
             if (player != null) {
-                for (String landName : new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str", "String_Node_Str" }) {
+                for (String landName : SubType.getBasicLands(false)) {
                     FilterLandPermanent filter = new FilterLandPermanent(landName + "String_Node_Str");


Input:
public void run() {
    if (context.isActive()) {
        preProcessClose(context);
        try {
            context.close();
        } finally {
            postProcessClose(context);
        }
    }
}

Output:
 public void run() {
-    if (context.isActive()) {
-        preProcessClose(context);
-        try {
-            context.close();
-        } finally {
-            postProcessClose(context);
-        }
-    }
+    closeApplicationContext(context);
 }


Input:
private static int parseInt0(CharSequence sequence, final int p, int lim) throws NumericException {
    if (lim == p) {
        throw NumericException.INSTANCE;
    }
    boolean negative = sequence.charAt(p) == '-';
    int i = p;
    if (negative) {
        i++;
    }
    if (i >= lim) {
        throw NumericException.INSTANCE;
    }
    int val = 0;
    for (; i < lim; i++) {
        int c = sequence.charAt(i);
        if (c < '0' || c > '9') {
            throw NumericException.INSTANCE;
        }
        int r = (val << 3) + (val << 1) - (c - '0');
        if (r > val) {
            throw NumericException.INSTANCE;
        }
        val = r;
    }
    if (val == Integer.MIN_VALUE && !negative) {
        throw NumericException.INSTANCE;
    }
    return negative ? val : -val;
}

Output:
     for (; i < lim; i++) {
-        int c = sequence.charAt(i);
+        char c = sequence.charAt(i);
         if (c < '0' || c > '9') {


Input:
public void roomListUpdated(Vector<Room> rooms) {
    for (Room r : rooms) {
        RoomsInfo info = RoomsInfo.getRoomsInfo(r);
        if (info.isProjectRoom()) {
            return;
        }
        showLoading();
        proxy.refreshRoomReservations(r);
    }
    hideLoading();
}

Output:
         if (info.isProjectRoom()) {
-            return;
+            continue;
         }


Input:
public void handleDelete(ServerContext context, DeleteRequest request, ResultHandler<Resource> handler) {
    try {
        String rev = request.getRevision();
        delete(request.getResourceNameObject(), rev);
        Resource resource = new Resource(request.getResourceName(), null, new JsonValue(null));
        handler.handleResult(resource);
    } catch (ResourceException e) {
        handler.handleError(e);
    } catch (Exception e) {
        handler.handleError(new InternalServerErrorException(e.getMessage(), e));
    }
}

Output:
         String rev = request.getRevision();
-        delete(request.getResourceNameObject(), rev);
-        Resource resource = new Resource(request.getResourceName(), null, new JsonValue(null));
+        Resource resource = new Resource(request.getResourceName(), null, delete(request.getResourceNameObject(), rev));
         handler.handleResult(resource);


Input:
public ClientResponse handle(final ClientRequest request) throws ClientHandlerException {
    if (!request.getHeaders().containsKey("String_Node_Str")) {
        switch(state) {
            case MANAGED:
                if (parameters.getToken() == null) {
                    state = State.UNMANAGED;
                    try {
                        ClientResponse cr = handle(ClientRequest.create().build(requestTokenUri, HttpMethod.POST));
                        Form response = cr.getEntity(Form.class);
                        String token = response.getFirst(OAuthParameters.TOKEN);
                        parameters.token(token);
                        secrets.tokenSecret(response.getFirst(OAuthParameters.TOKEN_SECRET));
                        state = State.REQUEST_TOKEN;
                        parameters.verifier(handler.authorize(getAuthorizationUri()));
                        return handle(request);
                    } finally {
                        if (state == State.UNMANAGED) {
                            parameters.setToken(null);
                            secrets.setTokenSecret(null);
                        }
                        state = State.MANAGED;
                    }
                }
                break;
            case REQUEST_TOKEN:
                if (parameters.getVerifier() == null) {
                    throw new UnauthorizedRequestException(parameters, getAuthorizationUri());
                }
                state = State.UNMANAGED;
                try {
                    ClientResponse cr = handle(ClientRequest.create().build(accessTokenUri, HttpMethod.POST));
                    Form response = cr.getEntity(Form.class);
                    String token = response.getFirst(OAuthParameters.TOKEN);
                    String secret = response.getFirst(OAuthParameters.TOKEN_SECRET);
                    if (token == null) {
                        throw new UnauthorizedRequestException(parameters, null);
                    }
                    parameters.token(token);
                    secrets.tokenSecret(secret);
                    handler.authorized(parameters.getToken(), secrets.getTokenSecret());
                    state = State.MANAGED;
                } finally {
                    parameters.remove(OAuthParameters.VERIFIER);
                    if (state == State.UNMANAGED) {
                        parameters.remove(OAuthParameters.TOKEN);
                        secrets.tokenSecret(null);
                        state = State.MANAGED;
                    }
                }
        }
        final OAuthParameters p = (OAuthParameters) parameters.clone();
        if (p.getTimestamp() == null) {
            p.setTimestamp();
        }
        if (p.getNonce() == null) {
            p.setNonce();
        }
        try {
            OAuthSignature.sign(new RequestWrapper(request, providers), p, secrets);
        } catch (OAuthSignatureException se) {
            throw new ClientHandlerException(se);
        }
    }
    ClientResponse response;
    UniformInterfaceException uie = null;
    try {
        response = getNext().handle(request);
    } catch (UniformInterfaceException e) {
        response = e.getResponse();
        uie = e;
    }
    if (state == State.MANAGED && response.getClientResponseStatus() == ClientResponse.Status.UNAUTHORIZED) {
        request.getHeaders().remove("String_Node_Str");
        parameters.remove(OAuthParameters.TOKEN);
        secrets.tokenSecret(null);
        uie = null;
        return handle(request);
    }
    if (uie != null) {
        throw uie;
    }
    return response;
}

Output:
                         }
-                        state = State.MANAGED;
+                        if (state != State.REQUEST_TOKEN) {
+                            state = State.MANAGED;
+                        }
                     }


Input:
public Node visitForField(MxParser.ForFieldContext ctx) {
    ExprNode vardecl = null;
    ExprNode condition = null;
    ExprNode step = null;
    BlockNode body = (BlockNode) visit(ctx.body());
    Location vardeclPos = null;
    Location conditionPos = null;
    Location stepPos = null;
    if (ctx.vardecl != null) {
        vardecl = (ExprNode) visit(ctx.vardecl);
        vardeclPos = new Location(ctx.vardecl);
    }
    if (ctx.cond != null) {
        condition = (ExprNode) visit(ctx.cond);
        conditionPos = new Location(ctx.cond);
    }
    if (ctx.step != null) {
        step = (ExprNode) visit(ctx.step);
        stepPos = new Location(ctx.step);
    }
    return new LoopNode(vardecl, condition, step, body, vardeclPos, conditionPos, stepPos);
}

Output:
 public Node visitForField(MxParser.ForFieldContext ctx) {
-    ExprNode vardecl = null;
+    Node vardecl = null;
     ExprNode condition = null;


Input:
public Key find(String search) throws BookException {
    checkActive();
    SearchModifier modifier = getSearchModifier();
    Key results = null;
    if (search != null) {
        try {
            Analyzer analyzer = new SimpleAnalyzer();
            Query query = QueryParser.parse(search, LuceneIndex.FIELD_BODY, analyzer);
            Hits hits = searcher.search(query);
            if (modifier != null && modifier.isRanked()) {
                PassageTally tally = new PassageTally();
                results = tally;
                for (int i = 0; i < hits.length(); i++) {
                    Verse verse = VerseFactory.fromString(hits.doc(i).get(LuceneIndex.FIELD_NAME));
                    int score = (int) (hits.score(i) * 100);
                    tally.add(verse, score);
                }
            } else {
                results = book.createEmptyKeyList();
                for (int i = 0; i < hits.length(); i++) {
                    Verse verse = VerseFactory.fromString(hits.doc(i).get(LuceneIndex.FIELD_NAME));
                    results.addAll(verse);
                }
            }
        } catch (Exception ex) {
            throw new BookException(Msg.SEARCH_FAILED, ex);
        } finally {
            Activator.deactivate(this);
        }
    }
    if (results == null) {
        if (modifier != null && modifier.isRanked()) {
            results = new PassageTally();
        } else {
            results = book.createEmptyKeyList();
        }
    }
    return results;
}

Output:
                     Verse verse = VerseFactory.fromString(hits.doc(i).get(LuceneIndex.FIELD_NAME));
-                    int score = (int) (hits.score(i) * 100);
+                    int score = (int) (hits.score(i) * 100 + 1);
                     tally.add(verse, score);


Input:
private void getAppDetails(HttpRequest request, HttpResponder responder, String appid) {
    if (appid != null && appid.isEmpty()) {
        responder.sendString(HttpResponseStatus.BAD_REQUEST, "String_Node_Str");
        return;
    }
    try {
        String accountId = getAuthenticatedAccountId(request);
        Id.Account accId = Id.Account.from(accountId);
        List<Map<String, String>> result = Lists.newArrayList();
        List<ApplicationSpecification> specList;
        if (appid == null) {
            specList = new ArrayList<ApplicationSpecification>(store.getAllApplications(accId));
        } else {
            ApplicationSpecification appSpec = store.getApplication(new Id.Application(accId, appid));
            if (appSpec == null) {
                responder.sendStatus(HttpResponseStatus.NOT_FOUND);
                return;
            }
            specList = Collections.singletonList(store.getApplication(new Id.Application(accId, appid)));
        }
        for (ApplicationSpecification appSpec : specList) {
            result.add(makeAppRecord(appSpec));
        }
        String json = new Gson().toJson(result);
        responder.sendByteArray(HttpResponseStatus.OK, json.getBytes(Charsets.UTF_8), ImmutableMultimap.of(HttpHeaders.Names.CONTENT_TYPE, "String_Node_Str"));
    } catch (SecurityException e) {
        responder.sendStatus(HttpResponseStatus.UNAUTHORIZED);
    } catch (Throwable e) {
        LOG.error("String_Node_Str", e);
        responder.sendStatus(HttpResponseStatus.INTERNAL_SERVER_ERROR);
    }
}

Output:
         }
-        String json = new Gson().toJson(result);
+        String json;
+        if (appid == null) {
+            json = new Gson().toJson(result);
+        } else {
+            json = new Gson().toJson(result.get(0));
+        }
         responder.sendByteArray(HttpResponseStatus.OK, json.getBytes(Charsets.UTF_8), ImmutableMultimap.of(HttpHeaders.Names.CONTENT_TYPE, "String_Node_Str"));


Input:
protected UriComponentsBuilder buildSearchUrl(SearchRequest searchRequest) {
    UriComponentsBuilder componentsBuilder = getBaseUri().queryParam("String_Node_Str", searchRequest.getSearchType().name().toLowerCase());
    if (searchRequest.getQuery() != null) {
        componentsBuilder.queryParam("String_Node_Str", searchRequest.getQuery());
    }
    componentsBuilder = extendQueryWithSearchIds(searchRequest, componentsBuilder);
    if (searchRequest.getSeason() != null) {
        componentsBuilder.queryParam("String_Node_Str", searchRequest.getSeason());
    }
    if (searchRequest.getEpisode() != null) {
        componentsBuilder.queryParam("String_Node_Str", searchRequest.getEpisode());
    }
    if (searchRequest.getMinage() != null) {
        componentsBuilder.queryParam("String_Node_Str", searchRequest.getMinage());
    }
    if (searchRequest.getMaxage() != null) {
        componentsBuilder.queryParam("String_Node_Str", searchRequest.getMaxage());
    }
    if (searchRequest.getMinsize() != null) {
        componentsBuilder.queryParam("String_Node_Str", searchRequest.getMinsize());
    }
    if (searchRequest.getMaxsize() != null) {
        componentsBuilder.queryParam("String_Node_Str", searchRequest.getMaxsize());
    }
    if (searchRequest.getTitle() != null) {
        componentsBuilder.queryParam("String_Node_Str", searchRequest.getTitle());
    }
    if (searchRequest.getMaxsize() != null) {
        componentsBuilder.queryParam("String_Node_Str", searchRequest.getAuthor());
    }
    return componentsBuilder;
}

Output:
     UriComponentsBuilder componentsBuilder = getBaseUri().queryParam("String_Node_Str", searchRequest.getSearchType().name().toLowerCase());
-    if (searchRequest.getQuery() != null) {
-        componentsBuilder.queryParam("String_Node_Str", searchRequest.getQuery());
+    if (searchRequest.getQuery().isPresent()) {
+        componentsBuilder.queryParam("String_Node_Str", searchRequest.getQuery().get());
     }


Input:
public void reduce(LongWritable userID, Iterator<ItemPrefWritable> itemPrefs, OutputCollector<LongWritable, VectorWritable> output, Reporter reporter) throws IOException {
    if (itemPrefs.hasNext()) {
        RandomAccessSparseVector userVector = new RandomAccessSparseVector(Integer.MAX_VALUE, 100);
        while (itemPrefs.hasNext()) {
            ItemPrefWritable itemPref = itemPrefs.next();
            int index = ItemIDIndexMapper.idToIndex(itemPref.getItemID());
            userVector.set(index, itemPref.getPrefValue());
        }
        if (userVector.getNumNondefaultElements() > ToUserVectorReducer.MAX_PREFS_CONSIDERED) {
            double cutoff = ToUserVectorReducer.findTopNPrefsCutoff(ToUserVectorReducer.MAX_PREFS_CONSIDERED, userVector);
            RandomAccessSparseVector filteredVector = new RandomAccessSparseVector(Integer.MAX_VALUE, ToUserVectorReducer.MAX_PREFS_CONSIDERED);
            Iterator<Vector.Element> it = userVector.iterateNonZero();
            while (it.hasNext()) {
                Vector.Element element = it.next();
                if (element.get() >= cutoff) {
                    filteredVector.set(element.index(), element.get());
                }
            }
            userVector = filteredVector;
        }
        vectorWritable.set(userVector);
        output.collect(userID, vectorWritable);
    }
}

Output:
         }
-        if (userVector.getNumNondefaultElements() > ToUserVectorReducer.MAX_PREFS_CONSIDERED) {
-            double cutoff = ToUserVectorReducer.findTopNPrefsCutoff(ToUserVectorReducer.MAX_PREFS_CONSIDERED, userVector);
-            RandomAccessSparseVector filteredVector = new RandomAccessSparseVector(Integer.MAX_VALUE, ToUserVectorReducer.MAX_PREFS_CONSIDERED);
+        if (userVector.getNumNondefaultElements() > MAX_PREFS_CONSIDERED) {
+            double cutoff = findTopNPrefsCutoff(MAX_PREFS_CONSIDERED, userVector);
+            RandomAccessSparseVector filteredVector = new RandomAccessSparseVector(Integer.MAX_VALUE, MAX_PREFS_CONSIDERED);
             Iterator<Vector.Element> it = userVector.iterateNonZero();


Input:
protected void parseDeploymentOverlays(final XMLExtendedStreamReader reader, final Namespace namespace, final ModelNode baseAddress, final List<ModelNode> list) throws XMLStreamException {
    requireNoAttributes(reader);
    while (reader.nextTag() != END_ELEMENT) {
        requireNamespace(reader, namespace);
        final Element element = Element.forName(reader.getLocalName());
        switch(element) {
            case DEPLOYMENT_OVERLAY:
                parseDeploymentOverlay(reader, baseAddress, list);
                break;
            default:
                throw unexpectedElement(reader);
        }
    }
}

Output:
             case DEPLOYMENT_OVERLAY:
-                parseDeploymentOverlay(reader, baseAddress, list);
+                parseDeploymentOverlay(reader, baseAddress, list, allowContent, allowDeployment);
                 break;


Input:
int offer(Request req) {
    if (req.value == null) {
        throw new RuntimeException("String_Node_Str" + req.local);
    }
    if (req.value.size() == 0) {
        throw new RuntimeException("String_Node_Str" + req.local);
    }
    try {
        int addIndex = blCurrentPut.add(req.value);
        doFireEntryEvent(true, req.value, req.caller);
        sendBackup(true, req.caller, req.value, blCurrentPut.blockId, addIndex);
        req.longValue = addIndex;
        if (blCurrentPut.isFull()) {
            fireBlockFullEvent(blCurrentPut);
            blCurrentPut = null;
            setCurrentPut();
        }
        return addIndex;
    } finally {
        boolean consumed = false;
        while (!consumed && lsScheduledPollActions.size() > 0) {
            ScheduledAction pollAction = lsScheduledPollActions.remove(0);
            if (!pollAction.expired()) {
                consumed = pollAction.consume();
                node.clusterManager.deregisterScheduledAction(pollAction);
            }
        }
    }
}

Output:
     try {
-        int addIndex = blCurrentPut.add(req.value);
+        int addIndex = (first) ? blCurrentTake.addFirst(req.value) : blCurrentPut.add(req.value);
         doFireEntryEvent(true, req.value, req.caller);


Input:
public boolean performFinish() {
    try {
        doImport();
        hideServerView(view);
    } catch (InvocationTargetException e) {
        log.error(e);
        return false;
    } catch (InterruptedException e) {
        log.error(e);
        return false;
    }
    return true;
}

Output:
         doImport();
-        hideServerView(view);
+        if (hideView) {
+            hideServerView(view);
+        }
     } catch (InvocationTargetException e) {


Input:
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
    super.onCreateOptionsMenu(menu, inflater);
    if (hasOptionsMenu()) {
        inflater.inflate(R.menu.add_on_selector_menu, menu);
        menu.findItem(R.id.add_on_market_search_menu_option).setVisible(getMarketSearchTitle() != 0);
        menu.findItem(R.id.tweaks_menu_option).setVisible(mHasTweaksOption);
    }
}

Output:
     super.onCreateOptionsMenu(menu, inflater);
-    if (hasOptionsMenu()) {
-        inflater.inflate(R.menu.add_on_selector_menu, menu);
-        menu.findItem(R.id.add_on_market_search_menu_option).setVisible(getMarketSearchTitle() != 0);
-        menu.findItem(R.id.tweaks_menu_option).setVisible(mHasTweaksOption);
-    }
+    inflater.inflate(R.menu.add_on_selector_menu, menu);
+    menu.findItem(R.id.add_on_market_search_menu_option).setVisible(getMarketSearchTitle() != 0);
+    menu.findItem(R.id.tweaks_menu_option).setVisible(mHasTweaksOption);
 }


Input:
public ExpressionDef visitExpressionDefinition(cqlParser.ExpressionDefinitionContext ctx) {
    String identifier = parseString(ctx.identifier());
    ExpressionDef def = translatedLibrary.resolveExpressionRef(identifier);
    if (def == null) {
        pushExpressionDefinition(identifier);
        pushExpressionContext(currentContext);
        try {
            def = of.createExpressionDef().withAccessLevel(parseAccessModifier(ctx.accessModifier())).withName(identifier).withContext(currentContext).withExpression((Expression) visit(ctx.expression()));
            def.setResultType(def.getExpression().getResultType());
            addToLibrary(def);
        } finally {
            popExpressionDefinition();
            popExpressionContext();
        }
    }
    return def;
}

Output:
 public ExpressionDef visitExpressionDefinition(cqlParser.ExpressionDefinitionContext ctx) {
-    String identifier = parseString(ctx.identifier());
-    ExpressionDef def = translatedLibrary.resolveExpressionRef(identifier);
-    if (def == null) {
-        pushExpressionDefinition(identifier);
-        pushExpressionContext(currentContext);
-        try {
-            def = of.createExpressionDef().withAccessLevel(parseAccessModifier(ctx.accessModifier())).withName(identifier).withContext(currentContext).withExpression((Expression) visit(ctx.expression()));
-            def.setResultType(def.getExpression().getResultType());
-            addToLibrary(def);
-        } finally {
-            popExpressionDefinition();
-            popExpressionContext();
-        }
+    ExpressionDef expressionDef = internalVisitExpressionDefinition(ctx);
+    if (definedExpressionDefinitions.contains(expressionDef.getName())) {
+        throw new IllegalArgumentException(String.format("String_Node_Str", expressionDef.getName()));
     }


Input:
public void setLearningAlgorithm() {
    try {
        this.la = cm.learningAlgorithm(ExampleBasedROLComponent.class, lp, rs);
    } catch (LearningProblemUnsupportedException e) {
        e.printStackTrace();
    }
    System.out.println("String_Node_Str" + view.getPosAndNegSelectPanel().getOptionPanel().getMaxExecutionTime());
    cm.applyConfigEntry(la, "String_Node_Str", view.getPosAndNegSelectPanel().getOptionPanel().getMaxExecutionTime());
    try {
        la.init();
    } catch (ComponentInitException e) {
        e.printStackTrace();
    }
    alreadyLearned = true;
}

Output:
     try {
-        this.la = cm.learningAlgorithm(ExampleBasedROLComponent.class, lp, rs);
+        this.la = cm.learningAlgorithm(ExampleBasedROLComponent.class, lp, reasoner);
     } catch (LearningProblemUnsupportedException e) {


Input:
public int executeBatch() {
    String persistenceUnit = null;
    Cassandra.Client conn = null;
    Object pooledConnection = null;
    Map<ByteBuffer, Map<String, List<Mutation>>> mutationMap = new HashMap<ByteBuffer, Map<String, List<Mutation>>>();
    try {
        for (Node node : nodes) {
            if (node.isDirty()) {
                Object entity = node.getData();
                Object id = node.getEntityId();
                EntityMetadata metadata = KunderaMetadataManager.getEntityMetadata(node.getDataClass());
                persistenceUnit = metadata.getPersistenceUnit();
                isUpdate = node.isUpdate();
                MetamodelImpl metaModel = (MetamodelImpl) KunderaMetadata.INSTANCE.getApplicationMetadata().getMetamodel(metadata.getPersistenceUnit());
                if (node.isInState(RemovedState.class)) {
                    delete(entity, id);
                } else if (metaModel.isEmbeddable(metadata.getIdAttribute().getBindableJavaType())) {
                    List<RelationHolder> relationHolders = getRelationHolders(node);
                    onPersist(metadata, entity, id, relationHolders);
                } else {
                    List<RelationHolder> relationHolders = getRelationHolders(node);
                    mutationMap = prepareMutation(metadata, entity, id, relationHolders, mutationMap);
                    indexNode(node, metadata);
                }
            }
        }
        if (!mutationMap.isEmpty()) {
            pooledConnection = getPooledConection(persistenceUnit);
            conn = getConnection(pooledConnection);
            conn.batch_mutate(mutationMap, consistencyLevel);
        }
    } catch (InvalidRequestException e) {
        log.error("String_Node_Str" + e);
        throw new KunderaException(e);
    } catch (TException e) {
        log.error("String_Node_Str" + e);
        throw new KunderaException(e);
    } catch (UnavailableException e) {
        log.error("String_Node_Str" + e);
        throw new KunderaException(e);
    } catch (TimedOutException e) {
        log.error("String_Node_Str" + e);
        throw new KunderaException(e);
    } finally {
        clear();
        releaseConnection(pooledConnection);
    }
    return mutationMap.size();
}

Output:
     Object pooledConnection = null;
-    Map<ByteBuffer, Map<String, List<Mutation>>> mutationMap = new HashMap<ByteBuffer, Map<String, List<Mutation>>>();
+    Map<Class<?>, Map<ByteBuffer, Map<String, List<Mutation>>>> batchMutationMap = new HashMap<Class<?>, Map<ByteBuffer, Map<String, List<Mutation>>>>();
+    int recordsExecuted = 0;
     try {


Input:
public void moveRecord(final NodeRef nodeRef, final NodeRef targetNodeRef) {
    ParameterCheck.mandatory("String_Node_Str", nodeRef);
    ParameterCheck.mandatory("String_Node_Str", targetNodeRef);
    NodeRef sourceParentNodeRef = null;
    NodeRef originatingLocation = (NodeRef) nodeService.getProperty(nodeRef, PROP_RECORD_ORIGINATING_LOCATION);
    for (ChildAssociationRef parentAssoc : nodeService.getParentAssocs(nodeRef)) {
        if (!parentAssoc.isPrimary() && parentAssoc.getParentRef().equals(originatingLocation)) {
            sourceParentNodeRef = parentAssoc.getParentRef();
            break;
        }
    }
    if (sourceParentNodeRef == null) {
        throw new AlfrescoRuntimeException("String_Node_Str");
    }
    SiteInfo sourceSite = siteService.getSite(sourceParentNodeRef);
    SiteInfo targetSite = siteService.getSite(targetNodeRef);
    if (!sourceSite.equals(targetSite)) {
        throw new AlfrescoRuntimeException("String_Node_Str");
    }
    if (!sourceSite.getSitePreset().equals("String_Node_Str")) {
        throw new AlfrescoRuntimeException("String_Node_Str");
    }
    final NodeRef source = sourceParentNodeRef;
    runAsSystem(new RunAsWork<Void>() {

        public Void doWork() {
            try {
                fileFolderService.moveFrom(nodeRef, source, targetNodeRef, null);
                nodeService.setProperty(nodeRef, PROP_RECORD_ORIGINATING_LOCATION, targetNodeRef);
            } catch (FileExistsException | FileNotFoundException ex) {
                throw new AlfrescoRuntimeException("String_Node_Str" + ex);
            }
            return null;
        }
    });
}

Output:
     final NodeRef source = sourceParentNodeRef;
-    runAsSystem(new RunAsWork<Void>() {
+    authenticationUtil.runAsSystem(new RunAsWork<Void>() {


Input:
private void addContent(IContent content) {
    if (!bufferAllContents) {
        ReportItemDesign design = getGenerateDesign(content);
        if (design != null) {
            if (design.getOnPageBreak() != null || design.getJavaClass() != null) {
                if (!contents.contains(content)) {
                    contents.add(content);
                }
            }
        }
    } else {
        if (!contents.contains(content)) {
            contents.add(content);
        }
    }
}

Output:
         if (design != null) {
-            if (design.getOnPageBreak() != null || design.getJavaClass() != null) {
+            if (ScriptExecutor.needOnPageBreak(design, executionContext)) {
                 if (!contents.contains(content)) {


Input:
boolean expectCanAssignTo(NodeTraversal t, Node n, JSType rightType, JSType leftType, String msg) {
    if (!rightType.canAssignTo(leftType)) {
        if (bothIntrinsics(rightType, leftType)) {
            registerMismatch(rightType, leftType, null);
        } else {
            mismatch(t, n, msg, rightType, leftType);
        }
        return false;
    }
    return true;
}

Output:
     if (!rightType.canAssignTo(leftType)) {
-        if (bothIntrinsics(rightType, leftType)) {
-            registerMismatch(rightType, leftType, null);
-        } else {
-            mismatch(t, n, msg, rightType, leftType);
-        }
+        mismatch(t, n, msg, rightType, leftType);
         return false;


Input:
private void updateRecord(PropertyRecord record, PersistenceWindow window) {
    long id = record.getId();
    Buffer buffer = window.getOffsettedBuffer(id);
    if (record.inUse()) {
        long prevProp = record.getPrevProp();
        short prevModifier = prevProp == Record.NO_NEXT_PROPERTY.intValue() ? 0 : (short) ((prevProp & 0xF00000000L) >> 28);
        long nextProp = record.getNextProp();
        short nextModifier = nextProp == Record.NO_NEXT_PROPERTY.intValue() ? 0 : (short) ((nextProp & 0xF00000000L) >> 16);
        short inUseUnsignedByte = (short) ((Record.IN_USE.byteValue() | prevModifier));
        int typeInt = record.getType().intValue();
        typeInt |= nextModifier;
        buffer.put((byte) inUseUnsignedByte).putInt(typeInt).putInt(record.getKeyIndexId()).putLong(record.getPropBlock()).putInt((int) prevProp).putInt((int) nextProp);
    } else {
        buffer.put(Record.NOT_IN_USE.byteValue());
        if (!isInRecoveryMode()) {
            freeId(id);
        }
    }
}

Output:
         long prevProp = record.getPrevProp();
-        short prevModifier = prevProp == Record.NO_NEXT_PROPERTY.intValue() ? 0 : (short) ((prevProp & 0xF00000000L) >> 28);
+        long prevModifier = prevProp == Record.NO_NEXT_PROPERTY.intValue() ? 0 : (prevProp & 0xF00000000L) >> 28;
         long nextProp = record.getNextProp();


Input:
public void validate(ValidationHandler handler) {
    TypeMetadata type;
    if (instantiable) {
        type = repository.getType(namespace, typeName);
    } else {
        type = repository.getNonInstantiableType(namespace, typeName);
    }
    if (type == null) {
        if (instantiable) {
            handler.error((TypeMetadata) null, "String_Node_Str" + typeName + "String_Node_Str" + namespace + "String_Node_Str", (Integer) additionalData.get(MetadataRepository.XSD_LINE_NUMBER), (Integer) additionalData.get(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.TYPE_DOES_NOT_EXIST);
        } else {
            handler.error((TypeMetadata) null, "String_Node_Str" + typeName + "String_Node_Str" + namespace + "String_Node_Str", (Integer) additionalData.get(MetadataRepository.XSD_LINE_NUMBER), (Integer) additionalData.get(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.TYPE_DOES_NOT_EXIST);
        }
    }
}

Output:
         if (instantiable) {
-            handler.error((TypeMetadata) null, "String_Node_Str" + typeName + "String_Node_Str" + namespace + "String_Node_Str", (Integer) additionalData.get(MetadataRepository.XSD_LINE_NUMBER), (Integer) additionalData.get(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.TYPE_DOES_NOT_EXIST);
+            handler.error((TypeMetadata) null, "String_Node_Str" + typeName + "String_Node_Str" + namespace + "String_Node_Str", (Element) additionalData.get(MetadataRepository.XSD_DOM_ELEMENT), (Integer) additionalData.get(MetadataRepository.XSD_LINE_NUMBER), (Integer) additionalData.get(MetadataRepository.XSD_COLUMN_NUMBER), ValidationError.TYPE_DOES_NOT_EXIST);
         } else {


Input:
public Future write(Request request, Object data) throws IOException {
    if (webSocketTransport != null) {
        Object object = invokeEncoder(request.encoders(), data);
        webSocketWrite(request, object, data);
    } else {
        Object encodedPayload = invokeEncoder(request.encoders(), data);
        if (!(InputStream.class.isAssignableFrom(encodedPayload.getClass()) || Reader.class.isAssignableFrom(encodedPayload.getClass()) || String.class.isAssignableFrom(encodedPayload.getClass()) || byte[].class.isAssignableFrom(encodedPayload.getClass()))) {
            throw new IllegalStateException("String_Node_Str" + data);
        }
        if (serializedSocket.getSerializedFireStage() != null) {
            final SettableFuture<Response> future = SettableFuture.create();
            serializedSocket.getSerializedFireStage().enqueue(encodedPayload, future);
            return new Future() {
                public Future fire(Object data) throws IOException {
                    return serializedSocket.fire(data);
                }
                public Future done() {
                    ListenableFuture.class.cast(future).done(null);
                    return this;
                }
                public boolean cancel(boolean mayInterruptIfRunning) {
                    return future.cancel(mayInterruptIfRunning);
                }
                public boolean isCancelled() {
                    return future.isCancelled();
                }
                public boolean isDone() {
                    return future.isDone();
                }
                public Socket get() throws InterruptedException, ExecutionException {
                    future.get();
                    return serializedSocket;
                }
                public Socket get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
                    future.get(timeout, unit);
                    return serializedSocket;
                }
            };
        } else {
            final ListenableFuture<Response> future = serializedSocket.directWrite(encodedPayload);
            return new Future() {
                public Future fire(Object data) throws IOException {
                    return serializedSocket.fire(data);
                }
                public Future done() {
                    future.done(null);
                    return this;
                }
                public boolean cancel(boolean mayInterruptIfRunning) {
                    return future.cancel(mayInterruptIfRunning);
                }
                public boolean isCancelled() {
                    return future.isCancelled();
                }
                public boolean isDone() {
                    return future.isDone();
                }
                public Socket get() throws InterruptedException, ExecutionException {
                    future.get();
                    return serializedSocket;
                }
                public Socket get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
                    future.get(timeout, unit);
                    return serializedSocket;
                }
            };
        }
    }
    return rootFuture;
}

Output:
 public Future write(Request request, Object data) throws IOException {
-    if (webSocketTransport != null) {
+    if (WebSocketTransport.class.isAssignableFrom(transport.getClass())) {
         Object object = invokeEncoder(request.encoders(), data);


Input:
private Mana getManaTypes(Game game, Ability source) {
    Mana types = new Mana();
    for (Cost cost : source.getCosts()) {
        if (cost instanceof SacrificeTargetCost && !((SacrificeTargetCost) cost).getPermanents().isEmpty()) {
            Permanent land = ((SacrificeTargetCost) cost).getPermanents().get(0);
            if (land != null) {
                Abilities<ActivatedManaAbilityImpl> manaAbilities = land.getAbilities().getActivatedManaAbilities(Zone.BATTLEFIELD);
                for (ActivatedManaAbilityImpl ability : manaAbilities) {
                    if (!ability.equals(source) && ability.definesMana()) {
                        for (Mana netMana : ability.getNetMana(game)) {
                            types.add(netMana);
                        }
                    }
                }
            }
        }
    }
    return types;
}

Output:
                 for (ActivatedManaAbilityImpl ability : manaAbilities) {
-                    if (!ability.equals(source) && ability.definesMana()) {
+                    if (!ability.equals(source) && ability.definesMana(game)) {
                         for (Mana netMana : ability.getNetMana(game)) {


Input:
protected void init() throws BirtException {
    if (PropertyUtil.isInlineElement(image)) {
        root = new ImageInlineContainer(parent, context, image);
    } else {
        root = new ImageBlockContainer(parent, context, image);
    }
    root.initialize();
    root.setAllocatedWidth(parent.getCurrentMaxContentWidth());
    root.setMaxAvaWidth(root.getContentWidth());
    Dimension contentDimension = getSpecifiedDimension(image, root.getContentWidth(), true);
    ImageArea imageArea = createImageArea(image);
    int actualHeight = contentDimension.getHeight();
    int actualWidth = contentDimension.getWidth();
    int maxHeight = root.getMaxAvaHeight();
    int maxWidth = root.getMaxAvaWidth();
    int cHeight = contentDimension.getHeight();
    int cWidth = contentDimension.getWidth();
    if (cHeight > maxHeight || cWidth > maxWidth) {
        if (fitToContainer) {
            float rh = ((float) maxHeight) / cHeight;
            float rw = ((float) maxWidth) / cWidth;
            if (rh > rw) {
                actualHeight = (int) (rw * maxHeight);
                actualWidth = maxWidth;
            } else {
                actualHeight = maxHeight;
                actualWidth = (int) (rh * maxWidth);
            }
        } else {
            root.setNeedClip(true);
            root.setAllocatedHeight(Math.min(maxHeight, cHeight));
            root.setAllocatedWidth(Math.min(maxWidth, cWidth));
        }
        imageArea.setWidth(actualWidth);
        imageArea.setHeight(actualHeight);
    } else {
        imageArea.setWidth(actualWidth);
        imageArea.setHeight(actualHeight);
        root.setContentWidth(imageArea.getWidth());
        root.setContentHeight(imageArea.getHeight());
    }
    root.addChild(imageArea);
    imageArea.setPosition(root.getContentX(), root.getContentY());
    processChartLegend(image, imageArea);
    root.finished = false;
}

Output:
             if (rh > rw) {
-                actualHeight = (int) (rw * maxHeight);
+                actualHeight = (int) ((float) cHeight * maxWidth / cWidth);
                 actualWidth = maxWidth;


Input:
private Collection<Result> collectPolygons(OsmTile osmTile) {
    List<Result> results = new ArrayList<>();
    for (Type type : this.polygonTypes) {
        Collection<MultiPolygon> coverPolygons = osmTile.collectPolygons(type.filter);
        if (!coverPolygons.isEmpty()) {
            results.add(new Result(type.id, coverPolygons));
        }
    }
    return results;
}

Output:
     for (Type type : this.polygonTypes) {
-        Collection<MultiPolygon> coverPolygons = osmTile.collectPolygons(type.filter);
+        Collection<MultiPolygon> coverPolygons = osmTile.collectPolygons(view, this.geoCoordinateState, type.filter);
         if (!coverPolygons.isEmpty()) {


Input:
private synchronized void buildContentData() {
    try {
        MultiValueMap<String, Object> builder = RequestContentDataExtractor.extract(this.request);
        FormHttpOutputMessage data = new FormHttpOutputMessage();
        this.contentType = MediaType.valueOf(this.request.getContentType());
        data.getHeaders().setContentType(this.contentType);
        FormBodyWrapperFilter.this.formHttpMessageConverter.write(builder, this.contentType, data);
        this.contentType = data.getHeaders().getContentType();
        this.contentData = data.getInput();
        this.contentLength = this.contentData.length;
    } catch (Exception e) {
        throw new IllegalStateException("String_Node_Str", e);
    }
}

Output:
         this.contentType = data.getHeaders().getContentType();
-        this.contentData = data.getInput();
-        this.contentLength = this.contentData.length;
+        byte[] input = data.getInput();
+        this.contentLength = input.length;
+        this.contentData = input;
     } catch (Exception e) {


Input:
static Chunk fromHeader(ByteBuffer buff, long start) {
    if (buff.get() != 'c') {
        throw DataUtils.newIllegalStateException("String_Node_Str", start);
    }
    int length = buff.getInt();
    int chunkId = buff.getInt();
    int pageCount = buff.getInt();
    long metaRootPos = buff.getLong();
    long maxLength = buff.getLong();
    long maxLengthLive = buff.getLong();
    Chunk c = new Chunk(chunkId);
    c.length = length;
    c.pageCount = pageCount;
    c.pageCountLive = pageCount;
    c.start = start;
    c.metaRootPos = metaRootPos;
    c.maxLength = maxLength;
    c.maxLengthLive = maxLengthLive;
    return c;
}

Output:
     if (buff.get() != 'c') {
-        throw DataUtils.newIllegalStateException("String_Node_Str", start);
+        throw DataUtils.newIllegalStateException(DataUtils.ERROR_FILE_CORRUPT, "String_Node_Str", start);
     }


Input:
void buildFunctions(String bashScript, BashScriptModel model) {
    scanForIdentifierFollowedByWord(bashScript, model, "String_Node_Str");
}

Output:
 void buildFunctions(String bashScript, BashScriptModel model) {
-    scanForIdentifierFollowedByWord(bashScript, model, "String_Node_Str");
+    String scanString = "String_Node_Str";
+    int pos = 0;
+    while (true) {
+        if (pos >= bashScript.length()) {
+            break;
+        }
+        pos = bashScript.indexOf(scanString, pos);
+        if (pos < 0) {
+            break;
+        }
+        if (pos > 0) {
+            char before = bashScript.charAt(pos - 1);
+            if (!Character.isWhitespace(before)) {
+                pos++;
+                continue;
+            }
+        }
+        int namePos = pos + scanString.length();
+        while (true) {
+            char charAt = bashScript.charAt(namePos);
+            if (namePos >= bashScript.length()) {
+                break;
+            }
+            if (!Character.isWhitespace(charAt)) {
+                break;
+            }
+            namePos++;
+        }
+        StringBuilder sb = new StringBuilder();
+        while (true) {
+            if (namePos >= bashScript.length()) {
+                break;
+            }
+            char charAt = bashScript.charAt(namePos);
+            if (Character.isLetterOrDigit(charAt) || charAt == '_' || charAt == '-') {
+                sb.append(charAt);
+                namePos++;
+            } else {
+                break;
+            }
+        }
+        BashFunction bashFunction = new BashFunction();
+        bashFunction.name = sb.toString();
+        bashFunction.position = pos;
+        bashFunction.length = namePos - pos;
+        model.functions.add(bashFunction);
+        pos = namePos + 1;
+    }
 }


Input:
public GenericSQLHandler replaceAndClause(String whereClause) {
    sqlString = sqlString.replaceAll(AND_WHERE_CLAUSE, whereClause);
    return this;
}

Output:
 public GenericSQLHandler replaceAndClause(String whereClause) {
-    sqlString = sqlString.replaceAll(AND_WHERE_CLAUSE, whereClause);
+    sqlString = sqlString.replace(AND_WHERE_CLAUSE, whereClause);
     return this;


Input:
public void setDayOfMonth(int day) {
    if (day < 1)
        throw new DayOutOfRangeException("String_Node_Str" + day + "String_Node_Str");
    if (day > daysInMonth[getMonth() - 1])
        throw new DayOutOfRangeException("String_Node_Str" + day + "String_Node_Str");
    cal.set(Calendar.DAY_OF_MONTH, day);
}

Output:
         throw new DayOutOfRangeException("String_Node_Str" + day + "String_Node_Str");
-    if (day > daysInMonth[getMonth() - 1])
+    if (day > daysInMonth[month])
         throw new DayOutOfRangeException("String_Node_Str" + day + "String_Node_Str");


Input:
public Response execute() {
    DatabaseAccessor db;
    System.out.println("String_Node_Str" + username);
    try {
        db = initDB();
    } catch (SQLException e) {
        return new ErrorResponse(HttpStatusCode.BAD_REQUEST, "String_Node_Str" + "String_Node_Str" + e.getMessage());
    } catch (IOException e) {
        return new ErrorResponse(HttpStatusCode.BAD_REQUEST, e.getMessage());
    }
    try {
        db.deleteUser(username);
    } catch (SQLException e) {
        return new ErrorResponse(HttpStatusCode.BAD_REQUEST, "String_Node_Str" + "String_Node_Str" + e.getMessage());
    }
    return new MinimalResponse(HttpStatusCode.OK);
}

Output:
         db = initDB();
-    } catch (SQLException e) {
-        return new ErrorResponse(HttpStatusCode.BAD_REQUEST, "String_Node_Str" + "String_Node_Str" + e.getMessage());
-    } catch (IOException e) {
-        return new ErrorResponse(HttpStatusCode.BAD_REQUEST, e.getMessage());
+    } catch (SQLException | IOException e) {
+        Debug.log("String_Node_Str" + username + "String_Node_Str" + e.getMessage());
+        return new ErrorResponse(HttpStatusCode.INTERNAL_SERVER_ERROR, "String_Node_Str" + username + "String_Node_Str");
     }


Input:
public void run() {
    int i = 0;
    while (i < 200 && rollbackQueue.hasNext()) {
        DataEntry entry = rollbackQueue.next();
        if (entry.getType() == null || !entry.getType().canRollback())
            continue;
        World world = HawkEye.server.getWorld(entry.getWorld());
        if (world == null)
            continue;
        Location loc = new Location(world, entry.getX(), entry.getY(), entry.getZ());
        Block block = world.getBlockAt(loc);
        if (rollbackType == RollbackType.GLOBAL && entry.rollback(world.getBlockAt(loc))) {
            undo.add(block.getState());
            if (Config.DeleteDataOnRollback)
                DataManager.deleteEntry(entry.getDataId());
            counter++;
        } else if (rollbackType == RollbackType.LOCAL && entry.rollbackPlayer(block, (Player) session.getSender())) {
            localUndo.add(block);
            counter++;
        }
    }
    if (!rollbackQueue.hasNext()) {
        Bukkit.getServer().getScheduler().cancelTask(timerID);
        if (rollbackType == RollbackType.GLOBAL) {
            session.setRollbackUndo(undo);
            session.setDoingRollback(false);
            Util.sendMessage(session.getSender(), "String_Node_Str" + counter + "String_Node_Str");
            Util.sendMessage(session.getSender(), "String_Node_Str");
        } else {
            session.setLocalRollbackUndo(localUndo);
            Util.sendMessage(session.getSender(), "String_Node_Str" + counter + "String_Node_Str");
            Util.sendMessage(session.getSender(), "String_Node_Str");
        }
        Util.debug("String_Node_Str" + counter + "String_Node_Str");
    }
}

Output:
         if (rollbackType == RollbackType.GLOBAL && entry.rollback(world.getBlockAt(loc))) {
-            undo.add(block.getState());
+            undo.add(state);
             if (Config.DeleteDataOnRollback)


Input:
public void hideBarFor(CPlayer player) {
    if (!enderBars.containsKey(player))
        return;
    EnderBar enderBar = enderBars.get(player);
    if (enderBar.isSpawned())
        enderBar.remove();
}

Output:
         return;
-    EnderBar enderBar = enderBars.get(player);
+    MobNPCEnderDragon enderBar = enderBars.get(player);
     if (enderBar.isSpawned())


Input:
private void modifySourceMethod(CompilationUnit compilationUnit, MethodDeclaration methodDeclaration, TreeSet<PDGNode> removableNodes, TreeSet<PDGNode> remainingNodesMovableBefore, TreeSet<PDGNode> remainingNodesMovableAfter, List<VariableDeclaration> returnedVariables, int index) {
    AST ast = methodDeclaration.getAST();
    ASTRewrite methodBodyRewriter = ASTRewrite.create(ast);
    MethodInvocation methodInvocation = ast.newMethodInvocation();
    methodBodyRewriter.set(methodInvocation, MethodInvocation.NAME_PROPERTY, ast.newSimpleName(extractedMethodName), null);
    ListRewrite argumentsRewrite = methodBodyRewriter.getListRewrite(methodInvocation, MethodInvocation.ARGUMENTS_PROPERTY);
    for (String parameterName : originalPassedParameters.keySet()) {
        List<VariableDeclaration> variableDeclarations = originalPassedParameters.get(parameterName);
        argumentsRewrite.insertLast(variableDeclarations.get(index).getName(), null);
    }
    for (ASTNodeDifference difference : parameterizedDifferenceMap.values()) {
        List<Expression> expressions = new ArrayList<Expression>();
        if (difference.getExpression1() != null) {
            Expression expression1 = difference.getExpression1().getExpression();
            expression1 = ASTNodeDifference.getParentExpressionOfMethodNameOrTypeName(expression1);
            expressions.add(expression1);
        } else {
            expressions.add(null);
        }
        if (difference.getExpression2() != null) {
            Expression expression2 = difference.getExpression2().getExpression();
            expression2 = ASTNodeDifference.getParentExpressionOfMethodNameOrTypeName(expression2);
            expressions.add(expression2);
        } else {
            expressions.add(null);
        }
        Expression expression = expressions.get(index);
        boolean isReturnedVariable = false;
        if (expression != null)
            isReturnedVariable = isReturnedVariable(expression, returnedVariables);
        if (!isReturnedVariable) {
            if (expression != null)
                argumentsRewrite.insertLast(expression, null);
            else
                argumentsRewrite.insertLast(ast.newThisExpression(), null);
        }
    }
    Statement firstStatement = removableNodes.first().getASTStatement();
    Block parentBlock = (Block) firstStatement.getParent();
    ListRewrite blockRewrite = methodBodyRewriter.getListRewrite(parentBlock, Block.STATEMENTS_PROPERTY);
    CloneStructureNode root = mapper.getCloneStructureRoot();
    List<CloneStructureNode> processedCloneStructureGapNodes = new ArrayList<CloneStructureNode>();
    Set<PDGNode> remainingNodes = new TreeSet<PDGNode>();
    remainingNodes.addAll(remainingNodesMovableBefore);
    remainingNodes.addAll(remainingNodesMovableAfter);
    List<Statement> statementsToBeMovedBefore = new ArrayList<Statement>();
    List<Statement> statementsToBeMovedAfter = new ArrayList<Statement>();
    for (PDGNode remainingNode : remainingNodes) {
        CloneStructureNode remainingCloneStructureNode = null;
        if (index == 0)
            remainingCloneStructureNode = root.findNodeG1(remainingNode);
        else
            remainingCloneStructureNode = root.findNodeG2(remainingNode);
        if (!processedCloneStructureGapNodes.contains(remainingCloneStructureNode.getParent())) {
            Statement statement = processCloneStructureGapNode(remainingCloneStructureNode, ast, methodBodyRewriter, index);
            if (remainingNodesMovableBefore.contains(remainingNode)) {
                statementsToBeMovedBefore.add(statement);
            } else if (remainingNodesMovableAfter.contains(remainingNode)) {
                statementsToBeMovedAfter.add(statement);
            }
            methodBodyRewriter.remove(remainingNode.getASTStatement(), null);
        }
        processedCloneStructureGapNodes.add(remainingCloneStructureNode);
        for (CloneStructureNode child : remainingCloneStructureNode.getChildren()) {
            if (child.getMapping() instanceof PDGElseGap)
                processedCloneStructureGapNodes.add(child);
        }
    }
    Statement extractedMethodInvocationStatement = null;
    if (returnedVariables.size() == 1) {
        VariableDeclaration variableDeclaration = returnedVariables.get(0);
        Type variableType = extractType(variableDeclaration);
        VariableDeclarationFragment newFragment = ast.newVariableDeclarationFragment();
        methodBodyRewriter.set(newFragment, VariableDeclarationFragment.NAME_PROPERTY, variableDeclaration.getName(), null);
        ITypeBinding returnTypeBinding = findReturnTypeBinding();
        if (returnTypeBinding != null && !returnTypeBinding.isEqualTo(variableType.resolveBinding())) {
            CastExpression castExpression = ast.newCastExpression();
            methodBodyRewriter.set(castExpression, CastExpression.EXPRESSION_PROPERTY, methodInvocation, null);
            methodBodyRewriter.set(castExpression, CastExpression.TYPE_PROPERTY, variableType, null);
            methodBodyRewriter.set(newFragment, VariableDeclarationFragment.INITIALIZER_PROPERTY, castExpression, null);
        } else {
            methodBodyRewriter.set(newFragment, VariableDeclarationFragment.INITIALIZER_PROPERTY, methodInvocation, null);
        }
        VariableDeclarationStatement newVariableDeclarationStatement = ast.newVariableDeclarationStatement(newFragment);
        methodBodyRewriter.set(newVariableDeclarationStatement, VariableDeclarationStatement.TYPE_PROPERTY, variableType, null);
        blockRewrite.insertBefore(newVariableDeclarationStatement, firstStatement, null);
        extractedMethodInvocationStatement = newVariableDeclarationStatement;
    } else {
        ITypeBinding returnTypeBinding = findReturnTypeBinding();
        Statement methodInvocationStatement = null;
        if (returnTypeBinding != null) {
            ReturnStatement returnStatement = ast.newReturnStatement();
            if (returnTypeBinding.isEqualTo(methodDeclaration.getReturnType2().resolveBinding())) {
                methodBodyRewriter.set(returnStatement, ReturnStatement.EXPRESSION_PROPERTY, methodInvocation, null);
            } else {
                CastExpression castExpression = ast.newCastExpression();
                methodBodyRewriter.set(castExpression, CastExpression.EXPRESSION_PROPERTY, methodInvocation, null);
                methodBodyRewriter.set(castExpression, CastExpression.TYPE_PROPERTY, methodDeclaration.getReturnType2(), null);
                methodBodyRewriter.set(returnStatement, ReturnStatement.EXPRESSION_PROPERTY, castExpression, null);
            }
            methodInvocationStatement = returnStatement;
        } else {
            methodInvocationStatement = ast.newExpressionStatement(methodInvocation);
        }
        blockRewrite.insertBefore(methodInvocationStatement, firstStatement, null);
        extractedMethodInvocationStatement = methodInvocationStatement;
    }
    for (Statement movedBefore : statementsToBeMovedBefore) {
        blockRewrite.insertBefore(movedBefore, extractedMethodInvocationStatement, null);
    }
    for (int i = statementsToBeMovedAfter.size() - 1; i >= 0; i--) {
        Statement movedAfter = statementsToBeMovedAfter.get(i);
        blockRewrite.insertAfter(movedAfter, extractedMethodInvocationStatement, null);
    }
    for (PDGNode pdgNode : removableNodes) {
        Statement statement = pdgNode.getASTStatement();
        methodBodyRewriter.remove(statement, null);
    }
    Set<LabeledStatement> labeledStatements = labeledStatementsToBeRemoved.get(index);
    for (LabeledStatement labeled : labeledStatements) {
        methodBodyRewriter.remove(labeled, null);
    }
    try {
        TextEdit sourceEdit = methodBodyRewriter.rewriteAST();
        ICompilationUnit sourceICompilationUnit = (ICompilationUnit) compilationUnit.getJavaElement();
        CompilationUnitChange change = compilationUnitChanges.get(sourceICompilationUnit);
        change.getEdit().addChild(sourceEdit);
        change.addTextEditGroup(new TextEditGroup("String_Node_Str", new TextEdit[] { sourceEdit }));
    } catch (JavaModelException e) {
        e.printStackTrace();
    }
}

Output:
     ListRewrite argumentsRewrite = methodBodyRewriter.getListRewrite(methodInvocation, MethodInvocation.ARGUMENTS_PROPERTY);
-    for (String parameterName : originalPassedParameters.keySet()) {
+    for (VariableBindingKeyPair parameterName : originalPassedParameters.keySet()) {
         List<VariableDeclaration> variableDeclarations = originalPassedParameters.get(parameterName);


Input:
protected void paintTo(GlimpseContext context, GlimpseBounds bounds, Axis2D axis) {
    if (axis == null && !drawInPixelCoords) {
        throw new AxisNotSetException(this, context);
    }
    double x = drawInPixelCoords ? this.x : axis.getAxisX().valueToScreenPixelUnits(this.x);
    double y = drawInPixelCoords ? this.y : axis.getAxisY().valueToScreenPixelUnits(this.y);
    if (icons == null) {
        loadIcons();
    }
    if (newFont != null) {
        updateTextRenderer();
    }
    if (text != null && textLayout == null && textRenderer != null) {
        updateTextLayout();
    }
    if (iconIds == null || iconIds.isEmpty())
        iconSize = 0;
    GL2 gl = context.getGL().getGL2();
    int width = bounds.getWidth();
    int height = bounds.getHeight();
    gl.glMatrixMode(GL2.GL_PROJECTION);
    gl.glLoadIdentity();
    gl.glOrtho(-0.5, width - 1 + 0.5, -0.5, height - 1 + 0.5, -1, 1);
    gl.glMatrixMode(GL2.GL_MODELVIEW);
    gl.glLoadIdentity();
    gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA);
    gl.glEnable(GL2.GL_BLEND);
    double iconHeight = 0;
    if (icons != null)
        iconHeight = iconSize * icons.size() + iconSpacing * (icons.size() - 1);
    double textHeight = 0;
    if (lines != null)
        textHeight = (textLayout.getLineHeight()) * lines.size() + lineSpacing * (lines.size() - 1);
    int boundingHeight = (int) (borderSize * 2 + Math.max(iconHeight, textHeight));
    float textLength = 0;
    if (lines != null)
        for (int k = 0; k < lines.size(); k++) textLength = Math.max(textLength, lines.get(0).width);
    int boundingWidth = (int) (borderSize * 2 + iconSize + textLength);
    if (iconIds != null && !iconIds.isEmpty() && lines != null)
        boundingWidth += textIconSpacing;
    double clampX = offsetX, clampY = offsetY;
    if (clampToScreenEdges) {
        if (x + boundingWidth + offsetX > bounds.getWidth())
            clampX = bounds.getWidth() - boundingWidth - x;
        if (x + offsetX < 0)
            clampX = -x;
        if (y + offsetY > bounds.getHeight())
            clampY = bounds.getHeight() - y;
        if (boundingHeight > y + offsetY)
            clampY = boundingHeight - y;
    }
    if (this.paintBackground || this.paintBorder) {
        if (this.paintBackground) {
            gl.glColor4fv(backgroundColor, 0);
            gl.glBegin(GL2.GL_QUADS);
            try {
                borderVertices(gl, boundingHeight, boundingWidth, x + clampX, y + clampY);
            } finally {
                gl.glEnd();
            }
        }
        if (this.paintBorder) {
            gl.glColor4fv(borderColor, 0);
            gl.glEnable(GL2.GL_LINE_SMOOTH);
            gl.glBegin(GL2.GL_LINE_LOOP);
            try {
                borderVertices(gl, boundingHeight, boundingWidth, x + clampX, y + clampY);
            } finally {
                gl.glEnd();
            }
        }
    }
    gl.glDisable(GL2.GL_BLEND);
    if (lines != null && textRenderer != null) {
        GlimpseColor.setColor(textRenderer, textColor);
        textRenderer.beginRendering(width, height);
        try {
            double posX = x + iconSize + borderSize;
            if (iconIds != null && !iconIds.isEmpty())
                posX += textIconSpacing;
            double posY = y - borderSize - textLayout.getLineHeight();
            double iconPosY = Float.NEGATIVE_INFINITY;
            if (wrapTextAroundIcon && icons != null)
                iconPosY = y - (iconSize * icons.size() + iconSpacing * (icons.size() - 1) + borderSize);
            for (int i = 0; i < lines.size(); i++) {
                if (posY + textLayout.getLineHeight() < iconPosY)
                    posX = x + borderSize;
                textRenderer.draw(lines.get(i).text, (int) (posX + clampX), (int) (posY + clampY));
                posY = posY - lineSpacing - (textLayout.getLineHeight());
            }
        } finally {
            textRenderer.endRendering();
        }
    }
    if (iconIds != null && !iconIds.isEmpty()) {
        atlas.beginRendering();
        try {
            double posY = y - borderSize - iconSize;
            for (int i = 0; i < iconIds.size(); i++) {
                Object iconId = iconIds.get(i);
                ImageData iconData = icons.get(i);
                if (iconId != null && iconData != null) {
                    double iconScale = iconSize / (double) iconData.getWidth();
                    float[] color = defaultIconColor;
                    if (iconColors != null && i < iconColors.size()) {
                        float[] iconColor = iconColors.get(i);
                        if (iconColor != null)
                            color = iconColor;
                    }
                    GlimpseColor.glColor(gl, color);
                    atlas.drawImage(gl, iconId, (int) (x + borderSize + clampX), (int) (posY + clampY), iconScale, iconScale, 0, iconData.getHeight());
                    posY = posY - iconSize - iconSpacing;
                }
            }
        } finally {
            atlas.endRendering();
        }
    }
}

Output:
     double x = drawInPixelCoords ? this.x : axis.getAxisX().valueToScreenPixelUnits(this.x);
-    double y = drawInPixelCoords ? this.y : axis.getAxisY().valueToScreenPixelUnits(this.y);
+    double y = drawInPixelCoords ? bounds.getHeight() - this.y : axis.getAxisY().valueToScreenPixelUnits(this.y);
     if (icons == null) {


Input:
public static void main(String[] args) throws Exception {
    if (args.length < 2) {
        System.out.println("String_Node_Str");
        return;
    }
    String rootFolder = args[0];
    int numberOfCrawlers = Integer.parseInt(args[1]);
    CrawlController controller = new CrawlController(rootFolder);
    controller.addSeed("String_Node_Str");
    controller.setPolitenessDelay(200);
    controller.setMaximumCrawlDepth(1);
    controller.start(MyCrawler.class, numberOfCrawlers);
}

Output:
     controller.setPolitenessDelay(200);
-    controller.setMaximumCrawlDepth(1);
+    controller.setMaximumCrawlDepth(3);
     controller.start(MyCrawler.class, numberOfCrawlers);


Input:
public void run() {
    long start = System.nanoTime();
    FileResourceManager frm = FileResourceManager.getInstance();
    List<RepositoryEntry> entries = repositoryEntryDao.getLastUsedRepositoryEntries(ImsQTI21Resource.TYPE_NAME, 0, 20);
    for (RepositoryEntry entry : entries) {
        try {
            File fUnzippedDirRoot = frm.unzipFileResource(entry.getOlatResource());
            qtiService.loadAndResolveAssessmentTest(fUnzippedDirRoot, false);
        } catch (RuntimeException e) {
            log.error("String_Node_Str" + entry.getKey() + "String_Node_Str" + entry.getDisplayname() + "String_Node_Str", e);
        }
    }
    log.info(entries.size() + "String_Node_Str" + CodeHelper.nanoToMilliTime(start));
}

Output:
             File fUnzippedDirRoot = frm.unzipFileResource(entry.getOlatResource());
-            qtiService.loadAndResolveAssessmentTest(fUnzippedDirRoot, false);
+            qtiService.loadAndResolveAssessmentTest(fUnzippedDirRoot, false, false);
         } catch (RuntimeException e) {


Input:
final byte[][] generateMessage(Object name, int parameterCount, byte[] data, ObjectType interfaceClass, int AttributeOrdinal, Command cmd) {
    if (getLimits().getMaxInfoRX() == null) {
        throw new GXDLMSException("String_Node_Str");
    }
    java.nio.ByteBuffer buff;
    if (name instanceof byte[]) {
        buff = java.nio.ByteBuffer.wrap((byte[]) name);
    } else {
        if (name == null) {
            buff = java.nio.ByteBuffer.wrap(data);
        } else if (getUseLogicalNameReferencing()) {
            int len = data == null ? 0 : data.length;
            buff = java.nio.ByteBuffer.allocate(20 + len);
            if (cmd == Command.GetRequest || cmd == Command.SetRequest || cmd == Command.MethodRequest) {
                buff.putShort((short) interfaceClass.getValue());
                String[] items = ((String) name).split("String_Node_Str", -1);
                if (items.length != 6) {
                    throw new GXDLMSException("String_Node_Str");
                }
                for (String it : items) {
                    buff.put((byte) (Short.parseShort(it) & 0xFF));
                }
                buff.put((byte) AttributeOrdinal);
                if (data == null || data.length == 0) {
                    buff.put((byte) 0);
                } else {
                    buff.put((byte) 1);
                }
            }
        } else {
            int len = data == null ? 0 : data.length;
            buff = java.nio.ByteBuffer.allocate(11 + len);
            if (name.getClass().isArray()) {
                for (int pos = 0; pos != Array.getLength(name); ++pos) {
                    Object it = Array.get(name, pos);
                    buff.put((byte) 2);
                    int base_address = ((Number) it).shortValue() & 0xFFFF;
                    base_address += ((AttributeOrdinal - 1) * 8);
                    buff.putShort((short) base_address);
                }
            } else {
                buff.put((byte) 1);
            }
            if (cmd == Command.ReadResponse || cmd == Command.WriteResponse) {
                buff.put((byte) 0x0);
            } else {
                buff.put((byte) parameterCount);
                int base_address = GXCommon.intValue(name);
                if (cmd == Command.MethodRequest) {
                    base_address += AttributeOrdinal;
                } else {
                    base_address += ((AttributeOrdinal - 1) * 8);
                }
                buff.putShort((short) base_address);
            }
        }
        if (data != null && data.length != 0) {
            buff.put(data);
        }
    }
    return splitToBlocks(buff, cmd);
}

Output:
                 buff.put((byte) AttributeOrdinal);
-                if (data == null || data.length == 0) {
+                if (data == null || data.length == 0 || cmd == Command.SetRequest) {
                     buff.put((byte) 0);


Input:
private void handleServicePublication(ServiceReference reference) {
    Collection svcInterfaces = ServicePropertyUtils.getCollectionProperty(reference, ServicePublication.SERVICE_INTERFACE_NAME);
    if (svcInterfaces == null) {
        logError("String_Node_Str", "String_Node_Str" + reference + "String_Node_Str", null);
        return;
    }
    IServiceProperties discoveryServiceProperties = new ServiceProperties();
    discoveryServiceProperties.setPropertyString(ServicePublication.SERVICE_INTERFACE_NAME, ServicePropertyUtils.createStringFromCollection(svcInterfaces));
    Map servicePublicationServiceProperties = ServicePropertyUtils.getMapProperty(reference, ServicePublication.SERVICE_PROPERTIES);
    if (servicePublicationServiceProperties != null)
        addPropertiesToDiscoveryServiceProperties(discoveryServiceProperties, servicePublicationServiceProperties);
    ID endpointContainerID = (ID) reference.getProperty(RemoteServicePublication.ENDPOINT_CONTAINERID);
    if (endpointContainerID == null) {
        logError("String_Node_Str", "String_Node_Str" + reference + "String_Node_Str", null);
        return;
    }
    discoveryServiceProperties.setPropertyBytes(RemoteServicePublication.ENDPOINT_CONTAINERID, endpointContainerID.toExternalForm().getBytes());
    String endpointNamespace = endpointContainerID.getNamespace().getName();
    discoveryServiceProperties.setPropertyString(RemoteServicePublication.ENDPOINT_CONTAINERID_NAMESPACE, endpointNamespace);
    ID targetContainerID = (ID) reference.getProperty(RemoteServicePublication.TARGET_CONTAINERID);
    if (targetContainerID != null) {
        discoveryServiceProperties.setPropertyBytes(RemoteServicePublication.TARGET_CONTAINERID, targetContainerID.toExternalForm().getBytes());
        String targetNamespace = targetContainerID.getNamespace().getName();
        discoveryServiceProperties.setPropertyString(RemoteServicePublication.TARGET_CONTAINERID_NAMESPACE, targetNamespace);
    }
    String rsnamespace = ServicePropertyUtils.getStringProperty(reference, Constants.SERVICE_NAMESPACE);
    if (rsnamespace != null)
        discoveryServiceProperties.setPropertyString(Constants.SERVICE_NAMESPACE, rsnamespace);
    byte[] remoteServiceIDAsBytes = (byte[]) reference.getProperty(Constants.SERVICE_ID);
    if (remoteServiceIDAsBytes != null)
        discoveryServiceProperties.setPropertyBytes(Constants.SERVICE_ID, remoteServiceIDAsBytes);
    IDiscoveryAdvertiser advertiser2 = getAdvertiser();
    if (advertiser2 == null) {
        logError("String_Node_Str", "String_Node_Str" + reference + "String_Node_Str", null);
        return;
    }
    Namespace advertiserNamespace = advertiser2.getServicesNamespace();
    IServiceInfo svcInfo = null;
    try {
        IServiceTypeID serviceTypeID = createServiceTypeID(servicePublicationServiceProperties, advertiserNamespace);
        URI uri = createURI(endpointContainerID);
        String serviceName = getPropertyWithDefault(servicePublicationServiceProperties, RemoteServicePublication.SERVICE_NAME, (RemoteServicePublication.DEFAULT_SERVICE_NAME_PREFIX + new String(remoteServiceIDAsBytes)));
        svcInfo = new ServiceInfo(uri, serviceName, serviceTypeID, discoveryServiceProperties);
    } catch (IDCreateException e) {
        logError("String_Node_Str", "String_Node_Str", e);
        return;
    } catch (URISyntaxException e) {
        logError("String_Node_Str", "String_Node_Str", e);
        return;
    }
    fireHostPublishUnpublish(reference, svcInfo, true);
    synchronized (serviceInfos) {
        try {
            trace("String_Node_Str", "String_Node_Str" + reference + "String_Node_Str" + svcInfo);
            advertiser2.registerService(svcInfo);
            addServiceInfo(reference, svcInfo);
        } catch (ECFRuntimeException e) {
            logError("String_Node_Str", "String_Node_Str", e);
        }
    }
}

Output:
     if (advertiser2 == null) {
-        logError("String_Node_Str", "String_Node_Str" + reference + "String_Node_Str", null);
+        logInfo("String_Node_Str", "String_Node_Str" + reference + "String_Node_Str", null);
         return;


Input:
public String toString() {
    return "String_Node_Str" + this.host + "String_Node_Str" + CommonExtensions.toString(this.labels) + "String_Node_Str" + this.totalResource + "String_Node_Str" + this.usedResource + "String_Node_Str" + this.requestedResource + "String_Node_Str";
}

Output:
 public String toString() {
-    return "String_Node_Str" + this.host + "String_Node_Str" + CommonExtensions.toString(this.labels) + "String_Node_Str" + this.totalResource + "String_Node_Str" + this.usedResource + "String_Node_Str" + this.requestedResource + "String_Node_Str";
+    return "String_Node_Str" + host + "String_Node_Str" + CommonExtensions.toString(labels) + "String_Node_Str" + totalResource + "String_Node_Str" + usedResource + "String_Node_Str" + requestedResource + "String_Node_Str";
 }


Input:
private void moveConnectionRepNode(IRepositoryNode sourceNode, IRepositoryNode targetNode) throws PersistenceException {
    IRepositoryViewObject objectToMove = sourceNode.getObject();
    ConnectionItem item = (ConnectionItem) objectToMove.getProperty().getItem();
    IPath fullPath = ResourceManager.getReportsFolder().getFullPath();
    if (targetNode.getType() == ENodeType.SIMPLE_FOLDER) {
        moveObject(objectToMove, sourceNode, targetNode, fullPath.makeRelativeTo(ResourceManager.getRootProject().getFullPath()));
    } else if (targetNode.getType() == ENodeType.SYSTEM_FOLDER) {
        moveObject(objectToMove, sourceNode, targetNode, Path.EMPTY);
    }
    CorePlugin.getDefault().refreshDQView(targetNode.getParent());
    this.updateConnectionDependency(item);
}

Output:
     ConnectionItem item = (ConnectionItem) objectToMove.getProperty().getItem();
-    IPath fullPath = ResourceManager.getReportsFolder().getFullPath();
+    IPath fullPath = Path.EMPTY;
+    if (targetNode.getParent() instanceof DBConnectionFolderRepNode) {
+        fullPath = ResourceManager.getConnectionFolder().getFullPath();
+    } else if (targetNode.getParent() instanceof DFConnectionFolderRepNode) {
+        fullPath = ResourceManager.getFileDelimitedFolder().getFullPath();
+    } else if (targetNode.getParent() instanceof MDMConnectionFolderRepNode || targetNode.getParent() instanceof MDMConnectionSubFolderRepNode) {
+        fullPath = ResourceManager.getMDMConnectionFolder().getFullPath();
+    }
     if (targetNode.getType() == ENodeType.SIMPLE_FOLDER) {


Input:
public long getEventCount() {
    return count;
}

Output:
 public long getEventCount() {
-    return count;
+    return count.get();
 }


Input:
public boolean start() {
    _swiftTemplateSyncExecutor.scheduleAtFixedRate(getSwiftTemplateSyncTask(), 120, 300, TimeUnit.SECONDS);
    return true;
}

Output:
 public boolean start() {
-    _swiftTemplateSyncExecutor.scheduleAtFixedRate(getSwiftTemplateSyncTask(), 120, 300, TimeUnit.SECONDS);
+    _swiftTemplateSyncExecutor.scheduleAtFixedRate(getSwiftTemplateSyncTask(), 60, 60, TimeUnit.SECONDS);
     return true;


Input:
public void moveTo(final InternalDataDefinition dataDefinition, final Long entityId, final int position) {
    checkNotNull(dataDefinition, DATA_DEFINITION_MUST_BE_GIVEN);
    checkState(dataDefinition.isPrioritizable(), "String_Node_Str");
    checkState(dataDefinition.isEnabled(), DATA_DEFINITION_BELONGS_TO_DISABLED_PLUGIN);
    checkNotNull(entityId, "String_Node_Str");
    checkState(position > 0, "String_Node_Str");
    Object databaseEntity = getDatabaseEntity(dataDefinition, entityId);
    if (databaseEntity == null) {
        LOG.info("String_Node_Str" + dataDefinition.getPluginIdentifier() + "String_Node_Str" + dataDefinition.getName() + "String_Node_Str" + entityId + "String_Node_Str");
        return;
    }
    priorityService.move(dataDefinition, databaseEntity, position, 0);
    LOG.info("String_Node_Str" + dataDefinition.getPluginIdentifier() + "String_Node_Str" + dataDefinition.getName() + "String_Node_Str" + entityId + "String_Node_Str");
}

Output:
 public void moveTo(final InternalDataDefinition dataDefinition, final Long entityId, final int position) {
-    checkNotNull(dataDefinition, DATA_DEFINITION_MUST_BE_GIVEN);
+    checkNotNull(dataDefinition, L_DATA_DEFINITION_MUST_BE_GIVEN);
     checkState(dataDefinition.isPrioritizable(), "String_Node_Str");


Input:
private MultipleSelectionElement createSelection(boolean selected) {
    String name = "String_Node_Str" + (++counter);
    MultipleSelectionElement selection = uifactory.addCheckboxesHorizontal(name, flc, keys, values);
    selection.setEnabled(!readOnly);
    flc.add(name, selection);
    if (selected) {
        selection.select(keys[0], true);
    }
    return selection;
}

Output:
     String name = "String_Node_Str" + (++counter);
-    MultipleSelectionElement selection = uifactory.addCheckboxesHorizontal(name, flc, keys, values);
+    MultipleSelectionElement selection = uifactory.addCheckboxesHorizontal(name, null, flc, keys, values);
     selection.setEnabled(!readOnly);


Input:
public void insertModel(MLModelNew model) throws DatabaseHandlerException {
    Connection connection = null;
    PreparedStatement insertStatement = null;
    try {
        connection = dbh.getDataSource().getConnection();
        connection.setAutoCommit(false);
        insertStatement = connection.prepareStatement(SQLQueries.INSERT_MODEL);
        insertStatement.setString(1, model.getName());
        insertStatement.setLong(2, model.getAnalysisId());
        insertStatement.setLong(3, model.getVersionSetId());
        insertStatement.setInt(4, model.getTenantId());
        insertStatement.setString(5, model.getUserName());
        insertStatement.setString(6, model.getStorageType());
        insertStatement.setString(7, model.getStorageDirectory());
        insertStatement.setString(8, MLConstants.MODEL_STATUS_NOT_STARTED);
        insertStatement.execute();
        connection.commit();
        if (logger.isDebugEnabled()) {
            logger.debug("String_Node_Str");
        }
    } catch (SQLException e) {
        MLDatabaseUtils.rollBack(connection);
        throw new DatabaseHandlerException("String_Node_Str" + "String_Node_Str" + e.getMessage(), e);
    } finally {
        MLDatabaseUtils.enableAutoCommit(connection);
        MLDatabaseUtils.closeDatabaseResources(connection, insertStatement);
    }
}

Output:
         insertStatement.setString(7, model.getStorageDirectory());
-        insertStatement.setString(8, MLConstants.MODEL_STATUS_NOT_STARTED);
+        insertStatement.setString(8, model.getStatus());
         insertStatement.execute();


Input:
private static void registerItemAndOre(Item item) {
    GameRegistry.register(item);
    OreDictionary.registerOre(item.getRegistryName().getResourceDomain(), item);
}

Output:
     GameRegistry.register(item);
-    OreDictionary.registerOre(item.getRegistryName().getResourceDomain(), item);
+    OreDictionary.registerOre(item.getRegistryName().getResourcePath(), item);
 }


Input:
public static List<TdTable> getTables(Schema schema) {
    TaggedValue tv = TaggedValueHelper.getTaggedValue(TaggedValueHelper.TABLE_FILTER, schema.getTaggedValue());
    String tableFilter = tv == null ? null : tv.getValue();
    return TableHelper.getTables(schema.getOwnedElement(), tableFilter);
}

Output:
 public static List<TdTable> getTables(Schema schema) {
-    TaggedValue tv = TaggedValueHelper.getTaggedValue(TaggedValueHelper.TABLE_FILTER, schema.getTaggedValue());
-    String tableFilter = tv == null ? null : tv.getValue();
-    return TableHelper.getTables(schema.getOwnedElement(), tableFilter);
+    return TableHelper.getTables(schema.getOwnedElement());
 }


Input:
protected void loadBackgroundImage(final URL imageURL) {
    Image image = null;
    String url = imageURL.toString();
    try {
        SSLCertificate.setCertificate();
        URLConnection con = imageURL.openConnection();
        con.setRequestProperty("String_Node_Str", UserAgentContext.DEFAULT_USER_AGENT);
        if (url.endsWith("String_Node_Str")) {
            SVGRasterizer r = new SVGRasterizer(imageURL);
            image = r.bufferedImageToImage();
        } else if (url.startsWith("String_Node_Str")) {
            image = Toolkit.getDefaultToolkit().createImage(ImageIO.read(con.getInputStream()).getSource());
        } else if (url.endsWith("String_Node_Str")) {
            try {
                image = new ImageIcon(imageURL).getImage();
            } catch (Exception e) {
                image = ImageIO.read(con.getInputStream());
            }
        } else if (url.endsWith("String_Node_Str")) {
            image = ImageIO.read(con.getInputStream());
        } else {
            image = ImageIO.read(con.getInputStream());
        }
        BaseElementRenderable.this.backgroundImage = image;
        int w = -1;
        int h = -1;
        if (image != null) {
            w = image.getWidth(BaseElementRenderable.this);
            h = image.getHeight(BaseElementRenderable.this);
        }
        if (w != -1 && h != -1) {
            BaseElementRenderable.this.repaint();
        }
    } catch (FileNotFoundException | IIOException ex) {
        logger.error("String_Node_Str" + url);
    } catch (IOException | TranscoderException thrown) {
        logger.error("String_Node_Str", thrown);
    } catch (Exception e) {
        logger.error("String_Node_Str", e);
    }
}

Output:
         } else if (url.startsWith("String_Node_Str")) {
-            image = Toolkit.getDefaultToolkit().createImage(ImageIO.read(con.getInputStream()).getSource());
+            BufferedImage bi = ImageIO.read(con.getInputStream());
+            if (bi != null)
+                image = Toolkit.getDefaultToolkit().createImage(bi.getSource());
         } else if (url.endsWith("String_Node_Str")) {


Input:
public Bitmap process(Bitmap originalBitmap, Vector<FilterRepresentation> filters, FilterEnvironment environment) {
    Bitmap cacheBitmap = originalBitmap;
    if (filters.size() != mSteps.size()) {
        mSteps.clear();
        for (int i = 0; i < filters.size(); i++) {
            FilterRepresentation representation = filters.elementAt(i);
            CacheStep step = new CacheStep();
            step.representation = representation.copy();
            mSteps.add(step);
        }
    }
    if (DEBUG) {
        displayFilters(filters);
    }
    int similarUpToIndex = 0;
    for (int i = 0; i < filters.size(); i++) {
        FilterRepresentation representation = filters.elementAt(i);
        CacheStep step = mSteps.elementAt(i);
        boolean similar = step.representation.equals(representation);
        if (similar) {
            similarUpToIndex = i;
        } else {
            break;
        }
    }
    if (DEBUG) {
        Log.v(LOGTAG, "String_Node_Str" + similarUpToIndex);
    }
    int findBaseImageIndex = similarUpToIndex;
    while (findBaseImageIndex > 0 && mSteps.elementAt(findBaseImageIndex).cache == null) {
        findBaseImageIndex--;
    }
    cacheBitmap = mSteps.elementAt(findBaseImageIndex).cache;
    boolean emptyStack = false;
    if (cacheBitmap == null) {
        emptyStack = true;
        cacheBitmap = originalBitmap.copy(Bitmap.Config.ARGB_8888, true);
        if (DEBUG) {
            Log.v(LOGTAG, "String_Node_Str");
        }
    }
    if (findBaseImageIndex != similarUpToIndex) {
        if (DEBUG) {
            Log.v(LOGTAG, "String_Node_Str" + findBaseImageIndex + "String_Node_Str" + similarUpToIndex);
        }
        if (!emptyStack) {
            cacheBitmap = cacheBitmap.copy(Bitmap.Config.ARGB_8888, true);
        }
        for (int i = findBaseImageIndex; i <= similarUpToIndex; i++) {
            FilterRepresentation representation = filters.elementAt(i);
            cacheBitmap = environment.applyRepresentation(representation, cacheBitmap);
            if (DEBUG) {
                Log.v(LOGTAG, "String_Node_Str" + i + "String_Node_Str" + representation.getName());
            }
        }
        mSteps.elementAt(similarUpToIndex).cache = cacheBitmap;
    }
    if (DEBUG) {
        Log.v(LOGTAG, "String_Node_Str" + similarUpToIndex + "String_Node_Str" + (filters.size() - 1));
    }
    for (int i = similarUpToIndex + 1; i < filters.size(); i++) {
        FilterRepresentation representation = filters.elementAt(i);
        CacheStep currentStep = mSteps.elementAt(i);
        cacheBitmap = cacheBitmap.copy(Bitmap.Config.ARGB_8888, true);
        cacheBitmap = environment.applyRepresentation(representation, cacheBitmap);
        currentStep.representation = representation.copy();
        currentStep.cache = cacheBitmap;
        if (DEBUG) {
            Log.v(LOGTAG, "String_Node_Str" + i + "String_Node_Str" + representation.getName());
        }
    }
    if (DEBUG) {
        Log.v(LOGTAG, "String_Node_Str");
        displayNbBitmapsInCache();
    }
    for (int i = 0; i < similarUpToIndex; i++) {
        CacheStep currentStep = mSteps.elementAt(i);
        currentStep.cache = null;
    }
    if (DEBUG) {
        Log.v(LOGTAG, "String_Node_Str");
        displayNbBitmapsInCache();
    }
    return cacheBitmap;
}

Output:
 public Bitmap process(Bitmap originalBitmap, Vector<FilterRepresentation> filters, FilterEnvironment environment) {
-    Bitmap cacheBitmap = originalBitmap;
+    if (filters.size() == 0) {
+        return originalBitmap;
+    }
     if (filters.size() != mSteps.size()) {


Input:
private void testDimensionFind2(IDocumentManager documentManager) throws DataException, IOException {
    IDimension dimension;
    IHierarchy hierarchy;
    ILevel[] level;
    Dimension realDimension;
    System.out.println("String_Node_Str");
    dimension = DimensionFactory.loadDimension("String_Node_Str", documentManager);
    System.out.println("String_Node_Str");
    hierarchy = dimension.getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    level = hierarchy.getLevels();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    level = hierarchy.getLevels();
    assertEquals(level[0].getName(), "String_Node_Str");
    assertEquals(level[0].getKeyDataType("String_Node_Str"), DataType.STRING_TYPE);
    assertEquals(level[1].getName(), "String_Node_Str");
    assertEquals(level[1].getKeyDataType("String_Node_Str"), DataType.STRING_TYPE);
    assertEquals(level[2].getName(), "String_Node_Str");
    assertEquals(level[2].getKeyDataType("String_Node_Str"), DataType.STRING_TYPE);
    realDimension = (Dimension) dimension;
    for (int i = 0; i < ThreeLevelDataset.Level1Col.length; i++) {
        IndexKey indexKey = realDimension.findFirst((Level) level[0], new Object[] { ThreeLevelDataset.Level1Col[i] });
        assertEquals(indexKey.key[0], ThreeLevelDataset.Level1Col[i]);
        if (i < 5)
            assertEquals(indexKey.dimensionPos, 0);
        if (i >= 5 && i < 12)
            assertEquals(indexKey.dimensionPos, 5);
        if (i >= 12)
            assertEquals(indexKey.dimensionPos, 12);
        Member levelMember = realDimension.getRowByPosition(indexKey.dimensionPos).getMembers()[0];
        assertEquals(levelMember.getKeyValues()[0], ThreeLevelDataset.Level1Col[i]);
        assertTrue(levelMember.getAttributes() == null);
        levelMember = realDimension.getDimensionRowByOffset(indexKey.offset).getMembers()[0];
        assertEquals(levelMember.getKeyValues()[0], ThreeLevelDataset.Level1Col[i]);
        assertTrue(levelMember.getAttributes() == null);
        indexKey = realDimension.findFirst((Level) level[1], new Object[] { ThreeLevelDataset.Level2Col[i] });
        assertEquals(indexKey.key[0], ThreeLevelDataset.Level2Col[i]);
        levelMember = realDimension.getRowByPosition(indexKey.dimensionPos).getMembers()[1];
        assertEquals(levelMember.getKeyValues()[0], ThreeLevelDataset.Level2Col[i]);
        levelMember = realDimension.getDimensionRowByOffset(indexKey.offset).getMembers()[1];
        assertEquals(levelMember.getKeyValues()[0], ThreeLevelDataset.Level2Col[i]);
        assertTrue(levelMember.getAttributes() == null);
        indexKey = realDimension.findFirst((Level) level[2], new Object[] { ThreeLevelDataset.Level3Col[i] });
        assertEquals(indexKey.key[0], ThreeLevelDataset.Level3Col[i]);
        assertEquals(indexKey.dimensionPos, i);
        levelMember = realDimension.getRowByPosition(indexKey.dimensionPos).getMembers()[2];
        assertEquals(levelMember.getKeyValues()[0], ThreeLevelDataset.Level3Col[i]);
        levelMember = realDimension.getDimensionRowByOffset(indexKey.offset).getMembers()[2];
        assertEquals(levelMember.getKeyValues()[0], ThreeLevelDataset.Level3Col[i]);
    }
}

Output:
         assertTrue(levelMember.getAttributes() == null);
-        levelMember = realDimension.getDimensionRowByOffset(indexKey.offset).getMembers()[0];
+        levelMember = realDimension.getDimensionRowByOffset(indexKey.getOffset()).getMembers()[0];
         assertEquals(levelMember.getKeyValues()[0], ThreeLevelDataset.Level1Col[i]);


Input:
public Duration apply(Response response) {
    Duration maxAge = extractMaxAge(response);
    int statusCode = response.getStatusCode();
    if (OK.getStatusCode() != statusCode && CREATED.getStatusCode() != statusCode && NO_CONTENT.getStatusCode() != statusCode) {
        throw new DiscoveryException(String.format("String_Node_Str", statusCode));
    }
    return maxAge;
}

Output:
     int statusCode = response.getStatusCode();
-    if (OK.getStatusCode() != statusCode && CREATED.getStatusCode() != statusCode && NO_CONTENT.getStatusCode() != statusCode) {
+    if (!isSuccess(statusCode)) {
         throw new DiscoveryException(String.format("String_Node_Str", statusCode));


Input:
private int search(String key) throws IOException {
    if (!checkActive()) {
        return -1;
    }
    String target = external2internal(key);
    int total = getCardinality();
    int low = -1;
    int high = total;
    while (high - low > 1) {
        int mid = (low + high) >>> 1;
        if (normalizeForSearch(getEntry(key, mid).getKey()).compareTo(target) < 0) {
            low = mid;
        } else {
            high = mid;
        }
    }
    if (high < total && normalizeForSearch(getEntry(key, high).getKey()).compareTo(target) == 0) {
        return high;
    }
    if (normalizeForSearch(getEntry(key, 0).getKey()).compareTo(target) == 0) {
        return 0;
    }
    return -(high + 1);
}

Output:
         int mid = (low + high) >>> 1;
-        if (normalizeForSearch(getEntry(key, mid).getKey()).compareTo(target) < 0) {
+        int cmp = normalizeForSearch(getEntry(key, mid).getKey()).compareTo(target);
+        if (cmp < 0) {
             low = mid;


Input:
private void putInInventories(EnumFacing currentSide) {
    List<EnumFacing> sides = Arrays.asList(EnumFacing.values());
    Collections.shuffle(sides, new Random());
    for (EnumFacing side : sides) {
        if (side == currentSide) {
            return;
        }
        TileEntity tile = worldObj.getTileEntity(pos.offset(side));
        IItemTransactor transactor = ItemTransactorHelper.getTransactor(tile, side.getOpposite());
        if (transactor == NoSpaceTransactor.INSTANCE) {
            continue;
        }
        IStackFilter filter = (stack) -> {
            if (stack == null) {
                return false;
            }
            ItemStack leftOver = transactor.insert(stack.copy(), false, true);
            if (leftOver == null) {
                return true;
            }
            return leftOver.getCount() < stack.getCount();
        };
        ItemStack extracted = inv.extract(filter, 1, 1, false);
        transactor.insert(extracted, false, false);
    }
}

Output:
         }
-        TileEntity tile = worldObj.getTileEntity(pos.offset(side));
+        TileEntity tile = world.getTileEntity(pos.offset(side));
         IItemTransactor transactor = ItemTransactorHelper.getTransactor(tile, side.getOpposite());


Input:
public synchronized void run() {
    try {
        while (!isInterrupted()) {
            if (toRemove.isEmpty())
                wait();
            if (minimalWait < 0) {
                long currentTime = System.currentTimeMillis();
                minimalWait = Long.MAX_VALUE;
                sleepUntil = 0;
                synchronized (toRemove) {
                    for (Iterator<Map.Entry<K, ToRemove>> it = toRemove.entrySet().iterator(); it.hasNext(); ) {
                        ToRemove tr = it.next().getValue();
                        long timeleft = tr.timeLeft(currentTime);
                        if (timeleft <= 0) {
                            it.remove();
                            remove(tr.key, false);
                        } else if (timeleft < minimalWait)
                            minimalWait = timeleft;
                    }
                }
            }
            if (minimalWait != Long.MAX_VALUE) {
                long gowait = minimalWait;
                minimalWait = -1;
                sleepUntil = System.currentTimeMillis() + gowait;
                wait(gowait);
            }
        }
    } catch (InterruptedException e) {
    }
}

Output:
         while (!isInterrupted()) {
-            if (toRemove.isEmpty())
+            if (toRemove.isEmpty()) {
+                minimalWait = -1;
                 wait();


Input:
public static String relativeTo(File theFile, File crawlDir) {
    if (!crawlDir.isDirectory()) {
        return null;
    }
    List<String> filePathList = new ArrayList<String>();
    List<String> crawlDirPath = new ArrayList<String>();
    File tempFile = theFile;
    filePathList.add(tempFile.getName());
    while ((tempFile = tempFile.getParentFile()) != null) {
        filePathList.add(tempFile.getName());
    }
    tempFile = crawlDir;
    crawlDirPath.add(tempFile.getName());
    while ((tempFile = tempFile.getParentFile()) != null) {
        crawlDirPath.add(tempFile.getName());
    }
    List sublist = filePathList.subList(crawlDirPath.size() - 2, filePathList.size());
    if (!crawlDirPath.equals(sublist)) {
        return null;
    }
    List<String> relativeList = filePathList.subList(0, crawlDirPath.size() - 2);
    StringBuffer sb = new StringBuffer();
    Collections.reverse(relativeList);
    for (String aRelativeList : relativeList) {
        sb.append(aRelativeList);
        sb.append(File.separatorChar);
    }
    sb.deleteCharAt(sb.length() - 1);
    return sb.toString();
}

Output:
     List<String> crawlDirPath = new ArrayList<String>();
-    File tempFile = theFile;
+    File tempFile = theFile.getAbsoluteFile();
     filePathList.add(tempFile.getName());


Input:
public void close() throws OLAPException {
    if (this.resultSet.getMeasureResult() == null)
        return;
    List errorList = new ArrayList();
    for (int i = 0; i < this.resultSet.getMeasureResult().length; i++) {
        try {
            this.resultSet.getMeasureResult()[i].getQueryResultSet().close();
        } catch (IOException e) {
            errorList.add(e);
        }
    }
    if (!errorList.isEmpty()) {
        throw new OLAPException(((IOException) errorList.get(0)).getLocalizedMessage());
    }
}

Output:
 public void close() throws OLAPException {
-    if (this.resultSet.getMeasureResult() == null)
+    if (this.resultSet == null || this.resultSet.getMeasureResult() == null)
         return;


Input:
private boolean getNewCert(Bundle task) {
    try {
        String type_of_certificate = task.getString(ConfigurationWizard.TYPE_OF_CERTIFICATE);
        JSONObject provider_json = ConfigHelper.getJsonFromSharedPref(Provider.KEY);
        String provider_main_url = provider_json.getString(Provider.API_URL);
        URL new_cert_string_url = new URL(provider_main_url + "String_Node_Str" + provider_json.getString(Provider.API_VERSION) + "String_Node_Str" + EIP.CERTIFICATE);
        boolean danger_on = ConfigHelper.getBoolFromSharedPref(ProviderItem.DANGER_ON);
        String cert_string = downloadWithProviderCA(new_cert_string_url, danger_on);
        if (!cert_string.isEmpty()) {
            if (ConfigHelper.checkErroneousDownload(cert_string)) {
                String reason_to_fail = provider_json.getString(ERRORS);
                return false;
            } else {
                String certificateString = null, keyString = null;
                String[] certAndKey = cert_string.split("String_Node_Str");
                for (int i = 0; i < certAndKey.length - 1; i++) {
                    if (certAndKey[i].contains("String_Node_Str")) {
                        keyString = certAndKey[i++] + certAndKey[i];
                    } else if (certAndKey[i].contains("String_Node_Str")) {
                        certificateString = certAndKey[i++] + certAndKey[i];
                    }
                }
                try {
                    RSAPrivateKey keyCert = ConfigHelper.parseRsaKeyFromString(keyString);
                    keyString = Base64.encodeToString(keyCert.getEncoded(), Base64.DEFAULT);
                    ConfigHelper.saveSharedPref(EIP.PRIVATE_KEY, "String_Node_Str" + keyString + "String_Node_Str");
                    X509Certificate certCert = ConfigHelper.parseX509CertificateFromString(certificateString);
                    certificateString = Base64.encodeToString(certCert.getEncoded(), Base64.DEFAULT);
                    ConfigHelper.saveSharedPref(EIP.CERTIFICATE, "String_Node_Str" + certificateString + "String_Node_Str");
                    return true;
                } catch (CertificateException e) {
                    e.printStackTrace();
                    return false;
                }
            }
        } else {
            return false;
        }
    } catch (IOException e) {
        e.printStackTrace();
        return false;
    } catch (JSONException e) {
        e.printStackTrace();
        return false;
    }
}

Output:
         boolean danger_on = ConfigHelper.getBoolFromSharedPref(ProviderItem.DANGER_ON);
-        String cert_string = downloadWithProviderCA(new_cert_string_url, danger_on);
+        String cert_string = downloadWithProviderCA(new_cert_string_url.toString(), danger_on);
         if (!cert_string.isEmpty()) {


Input:
public String toString() {
    StringBuilder sb = new StringBuilder();
    if (parentContext != null) {
        sb.append(parentContext.toString());
        sb.append("String_Node_Str");
    }
    if (parentField != null) {
        sb.append(parentField.getId());
        sb.append("String_Node_Str");
    }
    sb.append(topic.getId());
    sb.append("String_Node_Str");
    sb.append(view.getId());
    return sb.toString();
}

Output:
     }
-    sb.append(topic.getId());
+    sb.append(topicId);
     sb.append("String_Node_Str");