Input:
public boolean equals(final Object other) {
    if (other == this) {
        return true;
    }
    FontKey ors;
    try {
        ors = (FontKey) other;
    } catch (ClassCastException cce) {
        return false;
    }
    return (this.fontSize == ors.fontSize) && (this.fontFamily == ors.fontFamily) && (this.fontStyle == ors.fontStyle) && (this.fontWeight == ors.fontWeight) && (this.fontVariant == ors.fontVariant) && (this.superscript == ors.superscript) && Objects.equals(this.locales, ors.locales);
}

Output:
     }
-    return (this.fontSize == ors.fontSize) && (this.fontFamily == ors.fontFamily) && (this.fontStyle == ors.fontStyle) && (this.fontWeight == ors.fontWeight) && (this.fontVariant == ors.fontVariant) && (this.superscript == ors.superscript) && Objects.equals(this.locales, ors.locales);
+    return (this.fontSize == ors.fontSize) && (this.fontFamily.equals(ors.fontFamily)) && (this.fontStyle.equals(ors.fontStyle)) && (this.fontWeight.equals(ors.fontWeight)) && (this.fontVariant.equals(ors.fontVariant)) && (this.superscript.intValue() == ors.superscript.intValue()) && Objects.equals(this.locales, ors.locales);
 }


Input:
public void handle(TableColumn.CellEditEvent<Profile.PairLogoRelativeRectangle, String> t) {
    try {
        Profile.PairLogoRelativeRectangle p = ((Profile.PairLogoRelativeRectangle) t.getTableView().getItems().get(t.getTablePosition().getRow()));
        if (t.getNewValue().compareTo("String_Node_Str") != 0) {
        } else {
            refreshTableLogo(pservice.getAllLogosOfProfile(((Profile) profilList.getSelectionModel().getSelectedItem())));
        }
    } catch (ServiceException e) {
        try {
            refreshTableProfiles(pservice.getAllProfiles());
        } catch (ServiceException e1) {
            LOGGER.debug("String_Node_Str" + e1.getMessage());
        }
    }
}

Output:
         } else {
-            refreshTableLogo(pservice.getAllLogosOfProfile(((Profile) profilList.getSelectionModel().getSelectedItem())));
+            refreshTableLogo(pservice.getAllPairLogoRelativeRectangle(((Profile) profilList.getSelectionModel().getSelectedItem()).getId()));
         }


Input:
public void onAttached(MultiblockControllerBase newController) {
    super.onAttached(newController);
    if (isConnected()) {
        checkForConnections(this.worldObj, xCoord, yCoord, zCoord);
    }
}

Output:
     super.onAttached(newController);
-    if (isConnected()) {
-        checkForConnections(this.worldObj, xCoord, yCoord, zCoord);
-    }
+    checkForConnections(this.worldObj, xCoord, yCoord, zCoord);
 }


Input:
public void loadWarpList() {
    plugin.getLogger().info("String_Node_Str");
    welcomeWarps = Util.loadYamlFile("String_Node_Str");
    if (welcomeWarps.getConfigurationSection("String_Node_Str") == null) {
        welcomeWarps.createSection("String_Node_Str");
    }
    HashMap<String, Object> temp = (HashMap<String, Object>) welcomeWarps.getConfigurationSection("String_Node_Str").getValues(true);
    for (String s : temp.keySet()) {
        try {
            UUID playerUUID = UUID.fromString(s);
            if (playerUUID != null) {
                Location l = Util.getLocationString((String) temp.get(s));
                Block b = l.getBlock();
                if (b.getType().equals(Material.SIGN_POST) || b.getType().equals(Material.WALL_SIGN)) {
                    warpList.put(playerUUID, l);
                } else {
                    plugin.getLogger().warning("String_Node_Str" + temp.get(s) + "String_Node_Str");
                    if (DEBUG) {
                        String name = plugin.getTinyDB().getPlayerName(playerUUID);
                        warpList.put(playerUUID, l);
                        b.getRelative(BlockFace.DOWN).setType(Material.DIRT);
                        b.setType(Material.SIGN_POST);
                        Sign sign = (Sign) b.getState();
                        sign.setLine(0, ChatColor.GREEN + plugin.myLocale().warpswelcomeLine);
                        sign.setLine(1, name);
                        sign.setLine(2, "String_Node_Str");
                        sign.update(true, false);
                    }
                }
            }
        } catch (Exception e) {
            plugin.getLogger().severe("String_Node_Str" + temp.get(s) + "String_Node_Str");
            e.printStackTrace();
        }
    }
}

Output:
                 Location l = Util.getLocationString((String) temp.get(s));
-                Block b = l.getBlock();
-                if (b.getType().equals(Material.SIGN_POST) || b.getType().equals(Material.WALL_SIGN)) {
-                    warpList.put(playerUUID, l);
-                } else {
-                    plugin.getLogger().warning("String_Node_Str" + temp.get(s) + "String_Node_Str");
-                    if (DEBUG) {
-                        String name = plugin.getTinyDB().getPlayerName(playerUUID);
+                if (l != null) {
+                    Block b = l.getBlock();
+                    if (b.getType().equals(Material.SIGN_POST) || b.getType().equals(Material.WALL_SIGN)) {
                         warpList.put(playerUUID, l);


Input:
private void resolveConfigurationPropertiesWithDockerServerIp(ContainerDef containerDef, CubeConfiguration cubeConfiguration) {
    for (Entry<String, String> entry : containerDef.getContainerProperties().entrySet()) {
        if (hostPattern.matcher(entry.getKey()).matches() || addressPattern.matcher(entry.getKey()).matches()) {
            if (entry.getValue().contains(CubeConfiguration.DOCKER_SERVER_IP)) {
                containerDef.overrideProperty(entry.getKey(), entry.getValue().replaceAll(CubeConfiguration.DOCKER_SERVER_IP, cubeConfiguration.getDockerServerIp()));
            }
        }
    }
}

Output:
     for (Entry<String, String> entry : containerDef.getContainerProperties().entrySet()) {
-        if (hostPattern.matcher(entry.getKey()).matches() || addressPattern.matcher(entry.getKey()).matches()) {
+        if ((hostPattern.matcher(entry.getKey()).matches() || addressPattern.matcher(entry.getKey()).matches())) {
+            foundAttribute = true;
             if (entry.getValue().contains(CubeConfiguration.DOCKER_SERVER_IP)) {


Input:
protected void generateDisplayName() {
    this.displayName = getParent().getName() + "String_Node_Str" + index + "String_Node_Str" + (++rep) + "String_Node_Str" + TalendTextUtils.LBRACKET + type.getName() + TalendTextUtils.RBRACKET;
}

Output:
 protected void generateDisplayName() {
-    this.displayName = getParent().getName() + "String_Node_Str" + index + "String_Node_Str" + (++rep) + "String_Node_Str" + TalendTextUtils.LBRACKET + type.getName() + TalendTextUtils.RBRACKET;
+    String typeDispaly = type == null ? "String_Node_Str" : TalendTextUtils.LBRACKET + this.type.getName() + TalendTextUtils.RBRACKET;
+    this.displayName = getParent().getName() + "String_Node_Str" + index + "String_Node_Str" + (++rep) + "String_Node_Str" + typeDispaly;
 }


Input:
public void start(Stage stage) throws IOException {
    initCSS();
    sessionConfig = ConfigFileHandler.loadSessionConfig();
    mainStage = stage;
    stage.setMaximized(true);
    Scene scene = new Scene(createRoot(), 800, 600);
    setupMainStage(scene);
    loadFonts();
    applyCSS(scene);
    getUserCredentials();
}

Output:
     stage.setMaximized(true);
-    Scene scene = new Scene(createRoot(), 800, 600);
+    Scene scene = new Scene(createRoot());
     setupMainStage(scene);


Input:
public void testRemoveMessageListener() throws Exception {
    MessageListenerManager manager = new MessageListenerManager();
    String name = "String_Node_Str";
    assertTrue(manager.noListenerRegistered(name));
    MessageListener listener = new MessageListener() {

        public void onMessage(Object message) {
        }
    };
    manager.registerListener(name, listener);
    assertFalse(manager.noListenerRegistered(name));
    manager.removeListener(name, listener);
    assertTrue(manager.noListenerRegistered(name));
    manager.removeListener(name, listener);
    assertTrue(manager.noListenerRegistered(name));
}

Output:
     assertTrue(manager.noListenerRegistered(name));
-    MessageListener listener = new MessageListener() {
+    MessageListener listener = new MessageListener<Object>() {


Input:
public void handleRequest(HttpServerExchange exchange, RequestContext context) throws Exception {
    if (context.getDBName().isEmpty() || context.getDBName().startsWith("String_Node_Str")) {
        ResponseHelper.endExchangeWithMessage(exchange, HttpStatus.SC_NOT_ACCEPTABLE, "String_Node_Str");
        return;
    }
    DBObject content = context.getContent();
    if (content == null)
        content = new BasicDBObject();
    if (content instanceof BasicDBList) {
        ResponseHelper.endExchangeWithMessage(exchange, HttpStatus.SC_NOT_ACCEPTABLE, "String_Node_Str");
        return;
    }
    ObjectId etag = RequestHelper.getUpdateEtag(exchange);
    int SC = DBDAO.upsertDB(context.getDBName(), content, etag, false);
    exchange.setResponseCode(SC);
    if (context.getWarnings() != null && !context.getWarnings().isEmpty()) {
        DocumentRepresentationFactory.sendDocument(exchange.getRequestPath(), exchange, context, new BasicDBObject());
    }
    exchange.endExchange();
    LocalCachesSingleton.getInstance().invalidateDb(context.getDBName());
}

Output:
     }
-    ObjectId etag = RequestHelper.getUpdateEtag(exchange);
+    ObjectId etag = RequestHelper.getWriteEtag(exchange);
     int SC = DBDAO.upsertDB(context.getDBName(), content, etag, false);


Input:
public TupleList evaluateList(Evaluator evaluator) {
    return new UnaryTupleList(FunUtil.getNonEmptyMemberChildren(evaluator, ((RolapEvaluator) evaluator).getExpanding()));
}

Output:
 public TupleList evaluateList(Evaluator evaluator) {
-    return new UnaryTupleList(FunUtil.getNonEmptyMemberChildren(evaluator, ((RolapEvaluator) evaluator).getExpanding()));
+    return new UnaryTupleList(getLowestMembersForAccess(evaluator, hierarchyAccess, null));
 }


Input:
public V remove(Object key) {
    V result = null;
    synchronized (this) {
        if (!_cache.containsKey(key) && !_moreInWriteCache)
            return null;
        result = syncToWriteCache().remove(key);
        if (_cache.containsKey(key))
            syncToReadCache();
    }
    return result;
}

Output:
     synchronized (this) {
-        if (!_cache.containsKey(key) && !_moreInWriteCache)
+        if (!_cache.containsKeyWithoutExpunge(key) && !_moreInWriteCache)
             return null;


Input:
public NodeController getNodeController(Object object) {
    NodeController result = super.getNodeController(object);
    if (result != null) {
        return result;
    }
    if (object instanceof Vertex) {
        return _relationController;
    } else if (object instanceof Locatable) {
        Object semanticObject = getGraphModel().getSemanticObject(object);
        if (semanticObject instanceof Entity) {
            if (((Entity) semanticObject).isClassDefinition()) {
                return _classDefinitionController;
            } else {
                return _entityController;
            }
        } else if (semanticObject instanceof Attribute) {
            return _attributeController;
        } else if (semanticObject instanceof Port) {
            return _portController;
        } else {
            throw new RuntimeException("String_Node_Str" + semanticObject);
        }
    } else if (object instanceof Port) {
        return _entityPortController;
    }
    throw new RuntimeException("String_Node_Str" + object);
}

Output:
         if (semanticObject instanceof Entity) {
-            if (((Entity) semanticObject).isClassDefinition()) {
+            if (_classDefinitionController != null && ((Entity) semanticObject).isClassDefinition()) {
                 return _classDefinitionController;


Input:
public Design read() throws EoulsanIOException {
    Map<String, List<String>> data = new HashMap<String, List<String>>();
    List<String> fieldnames = new ArrayList<String>();
    try {
        setBufferedReader(new BufferedReader(new InputStreamReader(getInputStream(), Globals.DEFAULT_FILE_ENCODING)));
        BufferedReader br = getBufferedReader();
        final String separator = getSeparatorField();
        String line = null;
        boolean firstLine = true;
        while ((line = br.readLine()) != null) {
            final String empty = line.trim();
            if ("String_Node_Str".equals(empty) || empty.startsWith("String_Node_Str"))
                continue;
            final String[] fields = line.split(separator);
            if (firstLine) {
                for (int i = 0; i < fields.length; i++) {
                    final String field = fields[i].trim();
                    data.put(field, new ArrayList<String>());
                    fieldnames.add(field);
                }
                firstLine = false;
            } else {
                for (int i = 0; i < fields.length; i++) {
                    final String field = fields[i].trim();
                    final String fieldName = fieldnames.get(i);
                    List<String> l = data.get(fieldName);
                    if ((SLIDENUMBER_FIELD.equals(fieldName) || NAME_FIELD.equals(fieldName)) && l.contains(field))
                        throw new EoulsanIOException("String_Node_Str" + "String_Node_Str");
                    l.add(field);
                }
            }
        }
    } catch (IOException e) {
        throw new EoulsanIOException("String_Node_Str");
    }
    try {
        getBufferedReader().close();
    } catch (IOException e) {
        throw new EoulsanIOException("String_Node_Str" + e.getMessage());
    }
    if (!data.containsKey(SLIDENUMBER_FIELD))
        throw new EoulsanIOException("String_Node_Str");
    if (!data.containsKey(FILENAME_FIELD))
        throw new EoulsanIOException("String_Node_Str");
    Design design = DesignFactory.createEmptyDesign();
    boolean refName = data.containsKey(NAME_FIELD);
    List<String> ids = data.get(refName ? NAME_FIELD : SLIDENUMBER_FIELD);
    final int count = ids.size();
    for (final String id : ids) design.addSample(id);
    if (refName) {
        design.addMetadataField(SampleMetadata.SLIDE_NUMBER_FIELD);
        List<String> slides = data.get(SLIDENUMBER_FIELD);
        for (int i = 0; i < count; i++) design.getSampleMetadata(ids.get(i)).setSlideNumber(Integer.parseInt(slides.get(i)));
    }
    List<String> filenames = data.get(FILENAME_FIELD);
    for (int i = 0; i < count; i++) {
        DataSource source = DataSourceUtils.identifyDataSource(this.baseDir, filenames.get(i));
        design.setSource(ids.get(i), source);
    }
    for (String fd : fieldnames) {
        if (SLIDENUMBER_FIELD.equals(fd) || NAME_FIELD.equals(fd) || FILENAME_FIELD.equals(fd))
            continue;
        design.addMetadataField(fd);
        List<String> descriptions = data.get(fd);
        int k = 0;
        for (String desc : descriptions) design.setMetadata(ids.get(k++), fd, desc);
    }
    return design;
}

Output:
         DataSource source = DataSourceUtils.identifyDataSource(this.baseDir, filenames.get(i));
-        design.setSource(ids.get(i), source);
+        design.setSource(ids.get(i), source.toString());
     }


Input:
public SashForm createSash(Composite parent) {
    sash = new SashForm(parent, SWT.HORIZONTAL | SWT.SMOOTH);
    sash.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));
    ((GridData) sash.getLayoutData()).heightHint = 1000;
    GridLayout layout = new GridLayout();
    sash.setLayout(layout);
    sash.setBackground(sash.getDisplay().getSystemColor(SWT.COLOR_WHITE));
    createSchemaTree(sash);
    createButton();
    createTypeTree(sash);
    sash.setWeights(new int[] { 28, 1, 0 });
    return sash;
}

Output:
 public SashForm createSash(Composite parent) {
-    sash = new SashForm(parent, SWT.HORIZONTAL | SWT.SMOOTH);
+    sash = new SashForm(parent, SWT.HORIZONTAL);
     sash.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1));


Input:
NativeEvaluator createEvaluator(RolapEvaluator evaluator, FunDef fun, Exp[] args) {
    boolean ascending;
    if (!isEnabled()) {
        return null;
    }
    if (!TopCountConstraint.isValidContext(evaluator)) {
        return null;
    }
    String funName = fun.getName();
    if ("String_Node_Str".equalsIgnoreCase(funName)) {
        ascending = false;
    } else if ("String_Node_Str".equalsIgnoreCase(funName)) {
        ascending = true;
    } else {
        return null;
    }
    if (args.length < 2 || args.length > 3) {
        return null;
    }
    CrossJoinArg[] cargs = checkCrossJoinArg(evaluator, args[0]);
    if (cargs == null) {
        return null;
    }
    if (isPreferInterpreter(cargs, false)) {
        return null;
    }
    if (!(args[1] instanceof Literal)) {
        return null;
    }
    int count = ((Literal) args[1]).getIntValue();
    SchemaReader schemaReader = evaluator.getSchemaReader();
    DataSource ds = schemaReader.getDataSource();
    SqlQuery sqlQuery = SqlQuery.newQuery(ds, "String_Node_Str");
    RolapNativeSql sql = new RolapNativeSql(sqlQuery, null);
    Exp orderByExpr = null;
    if (args.length == 3) {
        orderByExpr = args[2];
        String orderBySQL = sql.generateTopCountOrderBy(args[2]);
        if (orderBySQL == null) {
            return null;
        }
    }
    LOGGER.debug("String_Node_Str");
    evaluator = overrideContext(evaluator, cargs, sql.getStoredMeasure());
    TupleConstraint constraint = new TopCountConstraint(cargs, evaluator, orderByExpr, ascending);
    SetEvaluator sev = new SetEvaluator(cargs, schemaReader, constraint);
    sev.setMaxRows(count);
    return sev;
}

Output:
     evaluator = overrideContext(evaluator, cargs, sql.getStoredMeasure());
-    TupleConstraint constraint = new TopCountConstraint(cargs, evaluator, orderByExpr, ascending);
+    TupleConstraint constraint = new TopCountConstraint(count, cargs, evaluator, orderByExpr, ascending);
     SetEvaluator sev = new SetEvaluator(cargs, schemaReader, constraint);


Input:
private static void _loadSemanticFiles(StringBuffer buffer, boolean inline) throws IllegalActionException {
    if (inline) {
        ClassLoader loader = RTMaudeUtility.class.getClassLoader();
        InputStream stream = loader.getResourceAsStream(SEMANTIC_FILE_PATH + "String_Node_Str");
        BufferedReader reader = null;
        Stack<BufferedReader> readerStack = null;
        try {
            reader = new BufferedReader(new InputStreamReader(stream));
            readerStack = new Stack<BufferedReader>();
            readerStack.push(null);
            while (!readerStack.isEmpty()) {
                try {
                    String line = reader.readLine();
                    boolean skip = false;
                    while (line != null) {
                        String trim = line.trim();
                        if (trim.startsWith("String_Node_Str")) {
                            trim = trim.substring(5).trim();
                            stream = loader.getResourceAsStream(SEMANTIC_FILE_PATH + "String_Node_Str" + trim + "String_Node_Str");
                            if (stream != null) {
                                readerStack.push(reader);
                                reader = new BufferedReader(new InputStreamReader(stream));
                                skip = true;
                            }
                        }
                        if (skip) {
                            skip = false;
                        } else {
                            buffer.append(line);
                            buffer.append("String_Node_Str");
                        }
                        line = reader.readLine();
                    }
                } catch (IOException e) {
                    throw new IllegalActionException("String_Node_Str");
                } finally {
                    try {
                        if (reader != null) {
                            reader.close();
                            reader = null;
                        }
                    } catch (IOException e) {
                        throw new IllegalActionException("String_Node_Str" + reader);
                    }
                }
                reader = readerStack.pop();
            }
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException ex) {
                    throw new IllegalActionException("String_Node_Str" + reader);
                }
            }
            if (readerStack != null) {
                while (!readerStack.isEmpty()) {
                    reader = readerStack.pop();
                    if (reader != null) {
                        try {
                            reader.close();
                        } catch (IOException ex) {
                            throw new IllegalActionException("String_Node_Str" + reader);
                        }
                    }
                }
            }
        }
    } else {
        buffer.append("String_Node_Str");
    }
}

Output:
         try {
-            reader = new BufferedReader(new InputStreamReader(stream));
+            reader = new BufferedReader(new InputStreamReader(stream, java.nio.charset.Charset.defaultCharset()));
             readerStack = new Stack<BufferedReader>();


Input:
public void testInvokeResourceWithAuthTypeApplication() throws Exception {
    APICreationRequestBean apiCreationRequestBean = new APICreationRequestBean(API_NAME, API_CONTEXT, API_VERSION_1_0_0, providerName, new URL(apiEndPointUrl));
    apiCreationRequestBean.setTags(API_TAGS);
    apiCreationRequestBean.setDescription(API_DESCRIPTION);
    apiCreationRequestBean.setVisibility("String_Node_Str");
    List<APIResourceBean> apiResourceBeansList = new ArrayList<APIResourceBean>();
    APIResourceBean apiResourceBeanGET = new APIResourceBean(APIMIntegrationConstants.HTTP_VERB_GET, APIMIntegrationConstants.RESOURCE_AUTH_TYPE_APPLICATION, APIMIntegrationConstants.RESOURCE_TIER.UNLIMITED, "String_Node_Str");
    apiResourceBeansList.add(apiResourceBeanGET);
    apiCreationRequestBean.setResourceBeanList(apiResourceBeansList);
    HttpResponse updateAPIHTTPResponse = apiPublisherClientUser1.updateAPI(apiCreationRequestBean);
    assertEquals(updateAPIHTTPResponse.getResponseCode(), HTTP_RESPONSE_CODE_OK, "String_Node_Str");
    assertEquals(getValueFromJSON(updateAPIHTTPResponse, "String_Node_Str"), "String_Node_Str", "String_Node_Str");
    HttpResponse httpResponseGet = HttpRequestUtil.doGet(getAPIInvocationURLHttp(API_CONTEXT, API_VERSION_1_0_0) + "String_Node_Str" + API_GET_ENDPOINT_METHOD, requestHeadersGet);
    assertEquals(httpResponseGet.getResponseCode(), HTTP_RESPONSE_CODE_OK, "String_Node_Str" + "String_Node_Str");
    assertTrue(httpResponseGet.getData().contains(RESPONSE_GET), "String_Node_Str" + "String_Node_Str" + RESPONSE_GET + "String_Node_Str" + httpResponseGet.getData() + "String_Node_Str");
}

Output:
     assertEquals(getValueFromJSON(updateAPIHTTPResponse, "String_Node_Str"), "String_Node_Str", "String_Node_Str");
-    HttpResponse httpResponseGet = HttpRequestUtil.doGet(getAPIInvocationURLHttp(API_CONTEXT, API_VERSION_1_0_0) + "String_Node_Str" + API_GET_ENDPOINT_METHOD, requestHeadersGet);
+    HttpResponse httpResponseGet = HTTPSClientUtils.doGet(getAPIInvocationURLHttp(API_CONTEXT, API_VERSION_1_0_0) + "String_Node_Str" + API_GET_ENDPOINT_METHOD, requestHeadersGet);
     assertEquals(httpResponseGet.getResponseCode(), HTTP_RESPONSE_CODE_OK, "String_Node_Str" + "String_Node_Str");


Input:
public Pair<Vector2D, SquareMatrix2D> evaluate(Vector2D input) {
    Vector2D object = new Vector2D();
    SquareMatrix2D derivatives = new SquareMatrix2D();
    double t = input.x;
    double a = input.y;
    double val0 = u - 1d;
    double val1 = Gamma.digamma(val0 + (t / a) + 1d);
    double val2 = Gamma.trigamma((a + t + (a * val0)) / a);
    double val3 = Gamma.trigamma((t / a) + 1d);
    double val4 = Gamma.digamma((t / a) + 1);
    double val5 = a * a;
    double d1 = (val3 - val2) / (val5);
    double d2 = (((a * val1) + (t * val2)) - (a * val4) - (t * val3)) / (val5 * a);
    double d3 = (((((val5 * val0) - (t * t * val2)) + (t * t * val3)) - (2 * a * t * val1)) + (2 * a * t * val4)) / (val5 * val5);
    double o2 = (val1 - val4) / a;
    double o3 = ((-t * val1) + (a * val0) + (t * val4)) / (a * a);
    double o4 = Gamma.digamma(n + t) - Gamma.digamma(t + 1d);
    checkInterrupt();
    double d4 = 0;
    double d5 = 0;
    double o1 = 0;
    double val6 = Gamma.digamma(1d - a);
    double val7 = Gamma.trigamma(1d - a);
    for (int i = 0; i < classes.length; i += 2) {
        int key = classes[i];
        int value = classes[i + 1];
        double val8 = t + key;
        d4 += 1d / (val8 * val8);
        d5 += key != 1 ? value * (val7 - Gamma.trigamma(key - a)) : 0;
        o1 += key == 1 ? 0 : value * (Gamma.digamma(key - a) - val6);
        checkInterrupt();
    }
    derivatives.x1 = d4 - d1;
    derivatives.x2 = 0 - d2;
    derivatives.y1 = 0 - d2;
    derivatives.y2 = 0 - d3 - d5;
    object.x = o2 - o4;
    object.y = o3 - o1;
    return new Pair<Vector2D, SquareMatrix2D>(object, derivatives);
}

Output:
     double val3 = Gamma.trigamma((t / a) + 1d);
-    double val4 = Gamma.digamma((t / a) + 1);
+    double val4 = Gamma.digamma((t / a) + 1d);
     double val5 = a * a;


Input:
private void setAttributeOnHold(MediaDescription mediaDescription, byte onHold) throws SdpException {
    String attribute;
    if (ON_HOLD_LOCALLY == (onHold | ON_HOLD_LOCALLY))
        attribute = (ON_HOLD_REMOTELY == (onHold | ON_HOLD_REMOTELY)) ? "String_Node_Str" : "String_Node_Str";
    else
        attribute = (ON_HOLD_REMOTELY == (onHold | ON_HOLD_REMOTELY)) ? "String_Node_Str" : null;
    if (attribute != null)
        mediaDescription.setAttribute(attribute, null);
}

Output:
     String attribute;
-    if (ON_HOLD_LOCALLY == (onHold | ON_HOLD_LOCALLY))
-        attribute = (ON_HOLD_REMOTELY == (onHold | ON_HOLD_REMOTELY)) ? "String_Node_Str" : "String_Node_Str";
+    if (ON_HOLD_LOCALLY == (onHold & ON_HOLD_LOCALLY))
+        attribute = (ON_HOLD_REMOTELY == (onHold & ON_HOLD_REMOTELY)) ? "String_Node_Str" : "String_Node_Str";
     else


Input:
public static TableIndicatorUnit createIndicatorUnit(IFile fe, TableIndicator tableIndicator, Analysis analysis) {
    WhereRule whereRule = DQRuleResourceFileHelper.getInstance().findWhereRule(fe);
    for (Indicator indicator : tableIndicator.getIndicators()) {
        if (whereRule.getName().equals(indicator.getName())) {
            return null;
        }
    }
    WhereRuleIndicator wrIndicator = IndicatorSqlFactory.eINSTANCE.createWhereRuleIndicator();
    wrIndicator.setAnalyzedElement(tableIndicator.getColumnSet());
    wrIndicator.setIndicatorDefinition(whereRule);
    IndicatorEnum type = IndicatorEnum.findIndicatorEnum(wrIndicator.eClass());
    TableIndicatorUnit addIndicatorUnit = tableIndicator.addSpecialIndicator(fe, type, wrIndicator);
    DependenciesHandler.getInstance().setUsageDependencyOn(analysis, whereRule);
    return addIndicatorUnit;
}

Output:
     }
-    WhereRuleIndicator wrIndicator = IndicatorSqlFactory.eINSTANCE.createWhereRuleIndicator();
-    wrIndicator.setAnalyzedElement(tableIndicator.getColumnSet());
-    wrIndicator.setIndicatorDefinition(whereRule);
-    IndicatorEnum type = IndicatorEnum.findIndicatorEnum(wrIndicator.eClass());
-    TableIndicatorUnit addIndicatorUnit = tableIndicator.addSpecialIndicator(fe, type, wrIndicator);
+    WhereRuleIndicator[] compositeWhereRuleIndicator = createCompositeWhereRuleIndicator(tableIndicator.getColumnSet(), whereRule);
+    IndicatorEnum type = IndicatorEnum.findIndicatorEnum(compositeWhereRuleIndicator[0].eClass());
+    TableIndicatorUnit addIndicatorUnit = tableIndicator.addSpecialIndicator(fe, type, compositeWhereRuleIndicator[0]);
     DependenciesHandler.getInstance().setUsageDependencyOn(analysis, whereRule);


Input:
public void setPositiveConcept() {
    SortedSet<Individual> individuals = null;
    hasIndividuals = false;
    if (!current.getRootObject().toString().equals("String_Node_Str")) {
        for (Iterator<NamedClass> i = reasoner.getAtomicConceptsList().iterator(); i.hasNext(); ) {
            if (individuals == null) {
                NamedClass concept = i.next();
                if (concept.toString().endsWith(current.getRootObject().toString())) {
                    currentConcept = concept;
                    if (reasoner.getIndividuals(concept) != null) {
                        if (reasoner.getIndividuals(concept).size() > 0) {
                            hasIndividuals = true;
                        }
                        individual = reasoner.getIndividuals(concept);
                        break;
                    }
                }
            }
        }
    } else {
        if (reasoner.getIndividuals().size() > 0) {
            hasIndividuals = true;
        }
        individual = reasoner.getIndividuals();
    }
}

Output:
                 NamedClass concept = i.next();
-                if (concept.toString().endsWith(current.getRootObject().toString())) {
-                    currentConcept = concept;
-                    if (reasoner.getIndividuals(concept) != null) {
-                        if (reasoner.getIndividuals(concept).size() > 0) {
-                            hasIndividuals = true;
+                if (concept.toString().contains("String_Node_Str")) {
+                    if (concept.toString().endsWith("String_Node_Str" + current.getRootObject().toString())) {
+                        currentConcept = concept;
+                        if (reasoner.getIndividuals(concept) != null) {
+                            if (reasoner.getIndividuals(concept).size() > 0) {
+                                hasIndividuals = true;
+                            }
+                            individual = reasoner.getIndividuals(concept);
+                            break;
+                        }
+                    }
+                } else {
+                    if (concept.toString().endsWith(current.getRootObject().toString())) {
+                        currentConcept = concept;
+                        if (reasoner.getIndividuals(concept) != null) {
+                            if (reasoner.getIndividuals(concept).size() > 0) {
+                                hasIndividuals = true;
+                            }
+                            individual = reasoner.getIndividuals(concept);
+                            break;
                         }


Input:
public Object[] getChildren(Object parentElement) {
    List<File> objects = new ArrayList<File>();
    if (parentElement instanceof File) {
        File[] files = ((File) parentElement).listFiles();
        if (files != null) {
            for (File file : files) {
                if (isValidFile(file) && isTOPFile(file)) {
                    objects.add(file);
                }
            }
        }
    }
    return objects.toArray();
}

Output:
             for (File file : files) {
-                if (isValidFile(file) && isTOPFile(file)) {
+                if (file.isDirectory() && isValidDirectory(file)) {
+                    objects.add(file);
+                }
+                if (file.isFile() && isValidFile(file)) {
                     objects.add(file);


Input:
public static RxJavaSchedulersHook schedulerHook(Context context) {
    return io.vertx.rx.java.RxHelper.schedulerHook(context.delegate);
}

Output:
 public static RxJavaSchedulersHook schedulerHook(Context context) {
-    return io.vertx.rx.java.RxHelper.schedulerHook(context.delegate);
+    return io.vertx.rx.java.RxHelper.schedulerHook(context.getDelegate());
 }


Input:
public boolean hasChildren(Object element) {
    if (element instanceof IEcosCategory) {
        return true;
    }
    if (element instanceof RecycleBin) {
        return getRecycleBinChildren().size() > 0 ? true : false;
    } else if (element instanceof DQRecycleBinNode) {
        DQRecycleBinNode rbn = (DQRecycleBinNode) element;
        Object obj = rbn.getObject();
        if (obj instanceof IFolder) {
            try {
                if (((IFolder) obj).members().length > 0)
                    return true;
            } catch (CoreException e) {
                log.error(e);
            }
        }
        return false;
    }
    return super.hasChildren(element);
}

Output:
     }
-    if (element instanceof RecycleBin) {
+    if (element instanceof IFolder) {
+        List<Object> obsLs = Arrays.asList(super.getChildren(element));
+        if (obsLs.size() == 1) {
+            Object obj = (Object) obsLs.get(0);
+            if (obj instanceof IFolder && ((IFolder) obj).getName().equals(PluginConstant.SVN_SUFFIX))
+                return false;
+        }
+    } else if (element instanceof RecycleBin) {
         return getRecycleBinChildren().size() > 0 ? true : false;


Input:
public float getRequest(ForgeDirection direction) {
    if (this.getTurret(false) != null) {
        if (this.getEnergyStored() < this.getTurret(false).getFiringRequest()) {
            Math.max(turret.getFiringRequest(), 0);
        }
    }
    return 0;
}

Output:
 public float getRequest(ForgeDirection direction) {
-    if (this.getTurret(false) != null) {
-        if (this.getEnergyStored() < this.getTurret(false).getFiringRequest()) {
-            Math.max(turret.getFiringRequest(), 0);
+    if (this.getTurret() != null) {
+        if (this.getEnergyStored() < this.getTurret().getFiringRequest()) {
+            return Math.max(this.getTurret().getFiringRequest(), 0);
         }


Input:
public void fire() throws IllegalActionException {
    super.fire();
    title.update();
    String titleValue = ((StringToken) title.getToken()).stringValue();
    for (int i = 0; i < input.getWidth(); i++) {
        if (input.hasToken(i)) {
            synchronized (this) {
                ActorToken token = (ActorToken) input.get(i);
                Entity model = token.getEntity();
                Effigy effigy = Configuration.findEffigy(toplevel());
                Configuration configuration = (Configuration) effigy.toplevel();
                try {
                    _parser.reset();
                    NamedObj newModel = _parser.parse(model.exportMoML());
                    Tableau tableau = _tableaus[i];
                    boolean reopen = ((BooleanToken) reopenWindow.getToken()).booleanValue();
                    if (tableau == null || reopen || !(tableau.getFrame() instanceof BasicGraphFrame)) {
                        if (tableau != null) {
                            tableau.close();
                        }
                        tableau = configuration.openModel(newModel, effigy);
                        _tableaus[i] = tableau;
                    } else {
                        GTFrameTools.changeModel((BasicGraphFrame) tableau.getFrame(), (CompositeEntity) newModel, true);
                    }
                    JFrame frame = tableau.getFrame();
                    RecordToken location = (RecordToken) screenLocation.getToken();
                    int x = ((IntToken) location.get("String_Node_Str")).intValue();
                    int y = ((IntToken) location.get("String_Node_Str")).intValue();
                    Point newLocation = frame.getLocation();
                    if (x >= 0) {
                        newLocation.x = x;
                    }
                    if (y >= 0) {
                        newLocation.y = y;
                    }
                    Dimension size = frame.getSize();
                    Toolkit toolkit = Toolkit.getDefaultToolkit();
                    Dimension screenSize = toolkit.getScreenSize();
                    newLocation.x = Math.min(newLocation.x, screenSize.width - size.width);
                    newLocation.y = Math.min(newLocation.y, screenSize.height - size.height);
                    frame.setLocation(newLocation);
                    frame.addWindowListener(this);
                    String titleString = null;
                    String modelName = newModel.getName();
                    URI modelURI = null;
                    URI uri = URIAttribute.getModelURI(newModel);
                    if (uri != null) {
                        String fileName;
                        if (modelName.equals("String_Node_Str")) {
                            fileName = "String_Node_Str";
                        } else {
                            fileName = modelName + "String_Node_Str";
                        }
                        modelURI = new URI(uri.getScheme(), uri.getUserInfo(), uri.getHost(), uri.getPort(), uri.getPath() + fileName, null, null);
                        Effigy newEffigy = (Effigy) tableau.getContainer();
                        newEffigy.uri.setURI(modelURI);
                    }
                    if (titleValue.equals("String_Node_Str")) {
                        if (uri != null) {
                            if (modelName.equals("String_Node_Str")) {
                                titleString = "String_Node_Str";
                            } else {
                                titleString = modelURI.toString();
                            }
                        }
                        titleString += "String_Node_Str" + getName() + "String_Node_Str";
                    } else {
                        titleString = titleValue;
                    }
                    tableau.setTitle(titleString);
                    output.send(i, token);
                } catch (NameDuplicationException e) {
                    throw new IllegalActionException(this, e, "String_Node_Str");
                } catch (Exception e) {
                    throw new IllegalActionException(this, e, "String_Node_Str");
                }
            }
        }
    }
}

Output:
                         }
-                        tableau = configuration.openModel(newModel, effigy);
+                        tableau = configuration.openModel(model, effigy);
                         _tableaus[i] = tableau;


Input:
private void loadChildState(List<C> values, int start, Map<Object, CellTreeNodeView<?>> savedViews) {
    int len = values.size();
    int end = start + len;
    int childCount = nodeView.getChildCount();
    ProvidesKey<C> keyProvider = nodeInfo.getProvidesKey();
    Element container = nodeView.ensureChildContainer();
    Element childElem = container.getChild(start).cast();
    CellTreeNodeView<?> keyboardSelected = nodeView.tree.getKeyboardSelectedNode();
    for (int i = start; i < end; i++) {
        C childValue = values.get(i - start);
        CellTreeNodeView<C> child = nodeView.createTreeNodeView(nodeInfo, childElem, childValue, null);
        CellTreeNodeView<?> savedChild = savedViews.remove(keyProvider.getKey(childValue));
        if (savedChild != null) {
            child.animationFrame = savedChild.animationFrame;
            child.contentContainer = savedChild.contentContainer;
            child.childContainer = savedChild.childContainer;
            child.children = savedChild.children;
            child.emptyMessageElem = savedChild.emptyMessageElem;
            child.nodeInfo = savedChild.nodeInfo;
            child.nodeInfoLoaded = savedChild.nodeInfoLoaded;
            child.open = savedChild.open;
            child.showMoreElem = savedChild.showMoreElem;
            child.treeNode = savedChild.treeNode;
            if (child.treeNode != null) {
                child.treeNode.nodeView = child;
            }
            child.listView = savedChild.listView;
            if (child.listView != null) {
                child.listView.nodeView = child;
            }
            if (child.children != null) {
                for (CellTreeNodeView<?> grandchild : child.children) {
                    grandchild.parentNode = child;
                }
            }
            if (keyboardSelected == savedChild) {
                keyboardSelected = child;
            }
            child.getElement().appendChild(savedChild.ensureAnimationFrame());
            savedChild.isDestroyed = true;
        }
        if (childCount > i) {
            nodeView.children.set(i, child);
        } else {
            nodeView.children.add(child);
        }
        childElem = childElem.getNextSiblingElement();
    }
    CellTreeNodeView<?> curNode = keyboardSelected;
    while (curNode != null) {
        if (curNode == nodeView) {
            nodeView.tree.keyboardSelect(keyboardSelected, false);
            break;
        }
        curNode = curNode.parentNode;
    }
}

Output:
     Element container = nodeView.ensureChildContainer();
-    Element childElem = container.getChild(start).cast();
+    Element childElem = (values.size() == 0) ? null : Element.as(container.getChild(start));
     CellTreeNodeView<?> keyboardSelected = nodeView.tree.getKeyboardSelectedNode();


Input:
public void shutdown() {
    if (mode != NetworkMode.NONE) {
        allChannels.close().awaitUninterruptibly();
        factory.releaseExternalResources();
    }
    processPendingDisconnects();
    clientList.forEach(this::processRemovedClient);
    server = null;
    nextNetId = 1;
    netIdToEntityId.clear();
    if (mode != NetworkMode.CLIENT) {
        if (this.entityManager != null) {
            for (EntityRef entity : entityManager.getEntitiesWith(NetworkComponent.class)) {
                NetworkComponent netComp = entity.getComponent(NetworkComponent.class);
                netComp.setNetworkId(0);
                entity.saveComponent(netComp);
            }
            this.entityManager.unsubscribe(this);
        }
    }
    mode = NetworkMode.NONE;
    entityManager = null;
    eventLibrary = null;
    componentLibrary = null;
    eventSerializer = null;
    entitySerializer = null;
    clientList.clear();
    netClientList.clear();
    blockManager = null;
    biomeManager = null;
    ownerLookup.clear();
    ownedLookup.clear();
    ownershipHelper = null;
    storageManager = null;
    logger.info("String_Node_Str");
}

Output:
 public void shutdown() {
-    if (mode != NetworkMode.NONE) {
-        allChannels.close().awaitUninterruptibly();
-        factory.releaseExternalResources();
-    }
+    allChannels.close().awaitUninterruptibly();
+    factory.releaseExternalResources();
     processPendingDisconnects();


Input:
public void onViewCreated(View view, Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    int headerHeight = getResources().getDimensionPixelSize(R.dimen.header_height);
    int indicatorHeight = QuickReturnUtils.dp2px(getActivity(), 5);
    int headerTranslation = -headerHeight + QuickReturnUtils.getActionBarHeight(getActivity()) + indicatorHeight;
    int footerTranslation = -headerHeight + QuickReturnUtils.getActionBarHeight(getActivity());
    QuickReturnListViewOnScrollListener scrollListener = new QuickReturnListViewOnScrollListener(QuickReturnType.BOTH, mCoordinator.getTabs(), headerTranslation, mQuickReturnFooterLinearLayout, -footerTranslation);
    scrollListener.setCanSlideInIdleScrollState(true);
    mListView.setOnScrollListener(scrollListener);
    mPlaceHolderView = getActivity().getLayoutInflater().inflate(R.layout.view_header_placeholder, mListView, false);
    mListView.addHeaderView(mPlaceHolderView);
    ArrayList<Tweet> tweets = new ArrayList<Tweet>();
    for (int i = 0; i < 23; i++) {
        Tweet tweet = new Tweet();
        tweet.setAvatarUrl(mAvatarUrls[i]);
        tweet.setDisplayName(mDisplayNames[i]);
        tweet.setUsername(mUsernames[i]);
        tweet.setTimestamp(mTimestamps[i]);
        tweet.setStarCount(mStars[i]);
        tweet.setRetweetCount(mRetweets[i]);
        tweet.setMessage(mMessages[i]);
        tweets.add(tweet);
    }
    TwitterAdapter adapter = new TwitterAdapter(getActivity(), tweets);
    mListView.setAdapter(adapter);
}

Output:
     super.onViewCreated(view, savedInstanceState);
-    int headerHeight = getResources().getDimensionPixelSize(R.dimen.header_height);
+    int headerHeight = getResources().getDimensionPixelSize(R.dimen.twitter_header_height);
+    int footerHeight = getResources().getDimensionPixelSize(R.dimen.twitter_footer_height);
     int indicatorHeight = QuickReturnUtils.dp2px(getActivity(), 5);


Input:
public void addRole(String name, Role<? extends Agent> role, Agent agent) {
    RoleAgent roleAgent = new RoleAgent(name, role, agent);
    boolean first = roleAgent.isFirst();
    boolean last = roleAgent.isLast();
    String after = roleAgent.getAfter();
    if (first) {
        roleList.add(0, roleAgent);
    } else if (last) {
        roleList.add(roleList.size(), roleAgent);
    } else if (after != "String_Node_Str") {
        int afterIndex = findRole(after);
        if (afterIndex >= 0) {
            afterIndex++;
            if (afterIndex >= roleList.size()) {
                roleList.add(roleAgent);
            } else {
                roleList.add(afterIndex, roleAgent);
            }
        } else {
            roleList.add(roleAgent);
        }
    } else {
        int position = findRoleAfterMe(name);
        if (position >= 0) {
            roleList.add(position, roleAgent);
        } else {
            int size = roleList.size();
            boolean isLastRole = true;
            while (size > 0 && isLastRole) {
                RoleAgent lastRole = roleList.get(size - 1);
                isLastRole = lastRole.isLast();
                if (isLastRole)
                    size--;
            }
            roleList.add(size, roleAgent);
        }
    }
}

Output:
         } else {
-            roleList.add(roleAgent);
+            int size = roleList.size();
+            boolean isLastRole = true;
+            while (size > 0 && isLastRole) {
+                RoleAgent lastRole = roleList.get(size - 1);
+                isLastRole = lastRole.isLast();
+                if (isLastRole)
+                    size--;
+            }
+            roleList.add(size, roleAgent);
         }


Input:
public void enable() {
    PlotMeCoreManager.getInstance().setPlugin(this);
    configFile = new ConfigAccessor(getServerBridge().getDataFolder(), "String_Node_Str");
    setupConfigFiles();
    setupSQL();
    serverBridge.setupHooks();
    if (getConfig().getInt("String_Node_Str") > 0) {
        serverBridge.runTaskTimerAsynchronously(new PlotExpireCleanup(this), 20L * 60 * 30, 20L * 60 * getConfig().getInt("String_Node_Str"));
    }
}

Output:
     serverBridge.setupHooks();
-    if (getConfig().getInt("String_Node_Str") > 0) {
+    if (getConfig().getBoolean("String_Node_Str")) {
         serverBridge.runTaskTimerAsynchronously(new PlotExpireCleanup(this), 20L * 60 * 30, 20L * 60 * getConfig().getInt("String_Node_Str"));


Input:
public List<Artifact> getOppositeArtifacts() {
    List<Artifact> oppositeArtifacts = new ArrayList<>();
    for (RelationLink link : artifact.getRelationsAll(DeletionFlag.EXCLUDE_DELETED)) {
        if (link.getRelationType().getName().equals(relationTypeName)) {
            if (link.getAArtifactId() == artifactId) {
                oppositeArtifacts.add(link.getArtifactB());
            } else {
                oppositeArtifacts.add(link.getArtifactA());
            }
        }
    }
    return oppositeArtifacts;
}

Output:
     List<Artifact> oppositeArtifacts = new ArrayList<>();
-    for (RelationLink link : artifact.getRelationsAll(DeletionFlag.EXCLUDE_DELETED)) {
-        if (link.getRelationType().getName().equals(relationTypeName)) {
-            if (link.getAArtifactId() == artifactId) {
-                oppositeArtifacts.add(link.getArtifactB());
-            } else {
-                oppositeArtifacts.add(link.getArtifactA());
-            }
-        }
-    }
+    RelationTypeSide relationSide = new RelationTypeSide(relationType, parentIsOnSideA ? RelationSide.SIDE_B : RelationSide.SIDE_A);
+    oppositeArtifacts.addAll(artifact.getRelatedArtifacts(relationSide, DeletionFlag.EXCLUDE_DELETED));
     return oppositeArtifacts;


Input:
public static void includeIntegrations(HandlerContext handlerCtx) {
    String type = (String) handlerCtx.getInputValue("String_Node_Str");
    UIComponent root = (UIComponent) handlerCtx.getInputValue("String_Node_Str");
    FacesContext ctx = handlerCtx.getFacesContext();
    List<IntegrationPoint> points = getIntegrationPoints(ctx, type);
    includeIntegrationPoints(ctx, root, getSortedIntegrationPoints(points));
}

Output:
     UIComponent root = (UIComponent) handlerCtx.getInputValue("String_Node_Str");
-    FacesContext ctx = handlerCtx.getFacesContext();
-    List<IntegrationPoint> points = getIntegrationPoints(ctx, type);
-    includeIntegrationPoints(ctx, root, getSortedIntegrationPoints(points));
+    try {
+        FacesContext ctx = handlerCtx.getFacesContext();
+        List<IntegrationPoint> points = getIntegrationPoints(ctx, type);
+        includeIntegrationPoints(ctx, root, getSortedIntegrationPoints(points));
+    } catch (Exception ex) {
+        GuiUtil.getLogger().severe("String_Node_Str" + type + "String_Node_Str" + root.toString());
+        if (GuiUtil.getLogger().isLoggable(Level.FINE)) {
+            ex.printStackTrace();
+        }
+    }
 }


Input:
public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
    Map<InstanceIdentifier<?>, DataObject> dataOriginalConfigurationObject = change.getOriginalData();
    for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dataOriginalConfigurationObject.entrySet()) {
        if (entry.getValue() instanceof AccessListEntries) {
            AccessListEntries originalAccessListEntries = (AccessListEntries) entry.getValue();
            AclServiceFunctionPath action = (AclServiceFunctionPath) (SfcAction) originalAccessListEntries.getActions();
            Long pathId = 1L;
            Matches matches;
            AceIp aceIp;
            AceIpv4 aceIpv4;
            matches = originalAccessListEntries.getMatches();
            aceIp = (AceIp) matches.getAceType();
            aceIpv4 = (AceIpv4) aceIp.getAceIpVersion();
            String srcIpAddress = aceIpv4.getSourceIpv4Address().getValue();
            String dstIpAddress = aceIpv4.getDestinationIpv4Address().getValue();
            Short srcPort = aceIp.getSourcePortRange().getLowerPort().getValue().shortValue();
            Short dstPort = aceIp.getDestinationPortRange().getLowerPort().getValue().shortValue();
            byte protocol = aceIp.getIpProtocol().byteValue();
            OpenflowSfcFlowProgrammer.getInstance().writeClassificationFlow(srcIpAddress, (short) 32, dstIpAddress, (short) 32, srcPort, dstPort, protocol, pathId);
        }
    }
}

Output:
 public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
-    Map<InstanceIdentifier<?>, DataObject> dataOriginalConfigurationObject = change.getOriginalData();
-    for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dataOriginalConfigurationObject.entrySet()) {
+    Map<InstanceIdentifier<?>, DataObject> dataOriginalConfigurationObject;
+    dataOriginalConfigurationObject = change.getOriginalData();
+    Map<InstanceIdentifier<?>, DataObject> dataCreatedConfigurationObject;
+    dataCreatedConfigurationObject = change.getCreatedData();
+    for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dataCreatedConfigurationObject.entrySet()) {
         if (entry.getValue() instanceof AccessListEntries) {


Input:
public View getView(final int position, View convertView, final ViewGroup parent) {
    switch(getItemViewType(position)) {
        case VIEW_TYPE_ITEM:
            {
                if (convertView == null) {
                    convertView = LayoutInflater.from(context).inflate(R.layout.board_select_spinner, null);
                }
                TextView textView = (TextView) convertView;
                textView.setText(getItem(position));
                return textView;
            }
        case VIEW_TYPE_ADD:
            {
                if (convertView == null) {
                    convertView = LayoutInflater.from(context).inflate(R.layout.board_select_add, null);
                }
                TextView textView = (TextView) convertView;
                textView.setText(getItem(position));
                return textView;
            }
    }
    return null;
}

Output:
             {
-                if (convertView == null) {
+                if (convertView == null || (Integer) convertView.getTag() != VIEW_TYPE_ITEM) {
                     convertView = LayoutInflater.from(context).inflate(R.layout.board_select_spinner, null);


Input:
public void run() {
    int exitCode = waitForExit();
    ji.setExitCode(exitCode);
    ReentrantReadWriteLock rwl = PersistenceManager.getDbLock();
    try {
        rwl.writeLock().lock();
        JobInfoElement dbJI = pm.getEntity(ji.getJobID(), JobInfoElement.class);
        if ((dbJI.getStatus() != null) && !dbJI.getStatus().equalsIgnoreCase("String_Node_Str")) {
            GenieNodeStatistics stats = GenieNodeStatistics.getInstance();
            if (exitCode != SubprocessStatus.SUCCESS.code()) {
                logger.error("String_Node_Str" + exitCode);
                String errMsg = Types.SubprocessStatus.message(exitCode);
                if ((errMsg == null) || (errMsg.isEmpty())) {
                    errMsg = "String_Node_Str";
                }
                ji.setJobStatus(JobStatus.FAILED, "String_Node_Str" + errMsg);
                stats.incrGenieFailedJobs();
            } else {
                ji.setJobStatus(JobStatus.SUCCEEDED, "String_Node_Str");
                stats.incrGenieSuccessfulJobs();
            }
            if (!ji.getDisableLogArchival()) {
                ji.setArchiveLocation(NetUtil.getArchiveURI(ji.getJobID()));
            }
            pm.updateEntity(ji);
            rwl.writeLock().unlock();
        } else {
            logger.debug("String_Node_Str" + ji.getJobID());
            rwl.writeLock().unlock();
        }
        if (config.getBoolean("String_Node_Str", false) == false) {
            logger.info("String_Node_Str");
        } else {
            logger.info("String_Node_Str");
            if (sendEmail() != 0) {
                logger.warn("String_Node_Str");
            }
        }
    } finally {
        if (rwl.writeLock().isHeldByCurrentThread()) {
            rwl.writeLock().unlock();
        }
    }
}

Output:
         }
-        if (config.getBoolean("String_Node_Str", false) == false) {
-            logger.info("String_Node_Str");
-        } else {
+        if (config.getBoolean("String_Node_Str", false)) {
             logger.info("String_Node_Str");


Input:
protected Class<?> resolveKeyType() {
    Class<?> attributeType = ReflectionUtils.getResolvedMethodReturnType(entityViewClass, method);
    Class<?>[] typeArguments = ReflectionUtils.getResolvedMethodReturnTypeArguments(entityViewClass, method);
    if (typeArguments.length == 0 || AnnotationUtils.findAnnotation(method, MappingSingular.class) != null || !Map.class.isAssignableFrom(attributeType)) {
        return null;
    }
    return typeArguments[0];
}

Output:
     Class<?>[] typeArguments = ReflectionUtils.getResolvedMethodReturnTypeArguments(entityViewClass, method);
-    if (typeArguments.length == 0 || AnnotationUtils.findAnnotation(method, MappingSingular.class) != null || !Map.class.isAssignableFrom(attributeType)) {
+    if (typeArguments.length == 0 || AnnotationUtils.findAnnotation(method, MappingSingular.class) != null || AnnotationUtils.findAnnotation(method, MappingParameter.class) != null || !Map.class.isAssignableFrom(attributeType)) {
         return null;


Input:
public void addTab(Path path) {
    ObservableList<String> recentFiles = controller.getRecentFiles();
    if (Files.notExists(path)) {
        recentFiles.remove(path.toString());
        return;
    }
    AnchorPane anchorPane = new AnchorPane();
    WebView webView = webviewService.createWebView();
    WebEngine webEngine = webView.getEngine();
    webEngine.getLoadWorker().stateProperty().addListener((observableValue1, state, state2) -> {
        if (state2 == Worker.State.SUCCEEDED) {
            threadService.runTaskLater(() -> {
                String normalize = IOHelper.normalize(IOHelper.readFile(path));
                threadService.runActionLater(() -> {
                    webEngine.executeScript(String.format("String_Node_Str", normalize));
                });
            });
        }
    });
    Node editorVBox = editorService.createEditorVBox(webView);
    controller.fitToParent(editorVBox);
    anchorPane.getChildren().add(editorVBox);
    MyTab tab = createTab();
    ((Label) tab.getGraphic()).setText(path.getFileName().toString());
    tab.setContent(anchorPane);
    tab.setPath(path);
    tab.setWebView(webView);
    TabPane tabPane = controller.getTabPane();
    tabPane.getTabs().add(tab);
    Tooltip tip = new Tooltip(path.toString());
    Tooltip.install(tab.getGraphic(), tip);
    Tab lastTab = tabPane.getTabs().get(tabPane.getTabs().size() - 1);
    tabPane.getSelectionModel().select(lastTab);
    recentFiles.remove(path.toString());
    recentFiles.add(0, path.toString());
    webView.requestFocus();
}

Output:
                 String normalize = IOHelper.normalize(IOHelper.readFile(path));
-                threadService.runActionLater(() -> {
-                    webEngine.executeScript(String.format("String_Node_Str", normalize));
+                threadService.runActionLater(new Runnable() {
+                    public void run() {
+                        try {
+                            webEngine.executeScript(String.format("String_Node_Str", normalize));
+                        } catch (Exception e) {
+                            threadService.runActionLater(this);
+                        }
+                    }
                 });


Input:
public void run() {
    if (getListView().getAdapter() == null)
        getListView().setAdapter(getCommentAdapter());
    if (mWebView.getVisibility() != View.VISIBLE) {
        mWebView.setVisibility(View.VISIBLE);
        AppLog.w(T.READER, "String_Node_Str");
    }
}

Output:
 public void run() {
-    if (getListView().getAdapter() == null)
-        getListView().setAdapter(getCommentAdapter());
-    if (mWebView.getVisibility() != View.VISIBLE) {
-        mWebView.setVisibility(View.VISIBLE);
-        AppLog.w(T.READER, "String_Node_Str");
-    }
+    if (hasActivity())
+        getListView().setVisibility(View.VISIBLE);
 }


Input:
public void migrate(Module jcrModule, AssetItem jcrAssetItem) {
    if (!AssetFormats.DECISION_TABLE_GUIDED.equals(jcrAssetItem.getFormat())) {
        throw new IllegalArgumentException("String_Node_Str" + jcrAssetItem.getName() + "String_Node_Str" + jcrAssetItem.getFormat() + "String_Node_Str");
    }
    Path path = migrationPathManager.generatePathForAsset(jcrModule, jcrAssetItem);
    final org.kie.commons.java.nio.file.Path nioPath = paths.convert(path);
    Map<String, Object> attrs;
    try {
        attrs = ioService.readAttributes(nioPath);
    } catch (final NoSuchFileException ex) {
        attrs = new HashMap<String, Object>();
    }
    GuidedDecisionTable52 model = GuidedDTXMLPersistence.getInstance().unmarshal(jcrAssetItem.getContent());
    final String requiredPackageName = projectService.resolvePackage(path).getPackageName();
    if (requiredPackageName != null && !"String_Node_Str".equals(requiredPackageName)) {
        model.setPackageName(requiredPackageName);
    }
    if (packageHeaderInfo.getHeader() != null) {
        final Imports imports = ImportsParser.parseImports(packageHeaderInfo.getHeader());
        if (imports != null) {
            model.setImports(imports);
        }
    }
    String sourceContent = GuidedDTXMLPersistence.getInstance().marshal(model);
    ioService.write(nioPath, sourceContent, attrs, new CommentedOption(jcrAssetItem.getLastContributor(), null, jcrAssetItem.getCheckinComment(), jcrAssetItem.getLastModified().getTime()));
}

Output:
     }
-    GuidedDecisionTable52 model = GuidedDTXMLPersistence.getInstance().unmarshal(jcrAssetItem.getContent());
+    String content = jcrAssetItem.getContent();
+    content = content.replaceAll("String_Node_Str", "String_Node_Str");
+    GuidedDecisionTable52 model = GuidedDTXMLPersistence.getInstance().unmarshal(content);
     final String requiredPackageName = projectService.resolvePackage(path).getPackageName();


Input:
public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();
    if (action.equalsIgnoreCase(Intent.ACTION_PACKAGE_ADDED) || action.equalsIgnoreCase(Intent.ACTION_PACKAGE_REPLACED)) {
        RouterServiceValidator.invalidateList(context);
        return;
    }
    if (!(action.equalsIgnoreCase(BOOT_COMPLETE) || action.equalsIgnoreCase(ACL_CONNECTED) || action.equalsIgnoreCase(STATE_CHANGED) || action.equalsIgnoreCase(USBTransport.ACTION_USB_ACCESSORY_ATTACHED) || action.equalsIgnoreCase(TransportConstants.START_ROUTER_SERVICE_ACTION))) {
        return;
    }
    if (action.equalsIgnoreCase(USBTransport.ACTION_USB_ACCESSORY_ATTACHED)) {
        Log.d(TAG, "String_Node_Str");
        intent.setAction(null);
        onSdlEnabled(context, intent);
        return;
    }
    boolean didStart = false;
    if (localRouterClass == null) {
        localRouterClass = defineLocalSdlRouterClass();
        ResolveInfo info = context.getPackageManager().resolveService(new Intent(context, localRouterClass), PackageManager.GET_META_DATA);
        if (info == null || info.serviceInfo.metaData == null || !info.serviceInfo.metaData.containsKey(context.getString(R.string.sdl_router_service_version_name))) {
            Log.w(TAG, "String_Node_Str");
        }
    }
    if (action.equalsIgnoreCase(TransportConstants.START_ROUTER_SERVICE_ACTION)) {
        if (intent.hasExtra(TransportConstants.START_ROUTER_SERVICE_SDL_ENABLED_EXTRA)) {
            if (intent.getBooleanExtra(TransportConstants.START_ROUTER_SERVICE_SDL_ENABLED_EXTRA, false)) {
                String packageName = intent.getStringExtra(TransportConstants.START_ROUTER_SERVICE_SDL_ENABLED_APP_PACKAGE);
                final ComponentName componentName = intent.getParcelableExtra(TransportConstants.START_ROUTER_SERVICE_SDL_ENABLED_CMP_NAME);
                if (componentName != null) {
                    final Intent finalIntent = intent;
                    final Context finalContext = context;
                    RouterServiceValidator.createTrustedListRequest(context, false, new TrustedListCallback() {
                        public void onListObtained(boolean successful) {
                            queuedService = componentName;
                            finalIntent.setAction("String_Node_Str");
                            onSdlEnabled(finalContext, finalIntent);
                        }
                    });
                }
            } else {
            }
            return;
        } else if (intent.getBooleanExtra(TransportConstants.PING_ROUTER_SERVICE_EXTRA, false)) {
            boolean altServiceWake = intent.getBooleanExtra(TransportConstants.BIND_REQUEST_TYPE_ALT_TRANSPORT, false);
            didStart = wakeUpRouterService(context, false, altServiceWake);
        }
    }
    if (intent.getAction().contains("String_Node_Str")) {
        int state = intent.getIntExtra("String_Node_Str", -1);
        if (state == BluetoothAdapter.STATE_OFF || state == BluetoothAdapter.STATE_TURNING_OFF) {
            return;
        }
    }
    Log.d(TAG, "String_Node_Str");
    if (localRouterClass != null) {
        if (!didStart) {
            Log.d(TAG, "String_Node_Str");
            didStart = wakeUpRouterService(context, true, false);
        }
        Intent serviceIntent = new Intent(context, localRouterClass);
        SdlRouterService.LocalRouterService self = SdlRouterService.getLocalRouterService(serviceIntent, serviceIntent.getComponent());
        Intent restart = new Intent(SdlRouterService.REGISTER_NEWER_SERVER_INSTANCE_ACTION);
        restart.putExtra(LOCAL_ROUTER_SERVICE_EXTRA, self);
        restart.putExtra(LOCAL_ROUTER_SERVICE_DID_START_OWN, didStart);
        context.sendBroadcast(restart);
    }
}

Output:
         ResolveInfo info = context.getPackageManager().resolveService(new Intent(context, localRouterClass), PackageManager.GET_META_DATA);
-        if (info == null || info.serviceInfo.metaData == null || !info.serviceInfo.metaData.containsKey(context.getString(R.string.sdl_router_service_version_name))) {
-            Log.w(TAG, "String_Node_Str");
+        if (info != null) {
+            if (info.filter == null || !info.filter.hasAction(TransportConstants.ROUTER_SERVICE_ACTION)) {
+                Log.e(TAG, "String_Node_Str");
+            }
+            if (info.serviceInfo.metaData == null || !info.serviceInfo.metaData.containsKey(context.getString(R.string.sdl_router_service_version_name))) {
+                Log.e(TAG, "String_Node_Str");
+            }
+        } else {
+            Log.e(TAG, "String_Node_Str");
         }


Input:
public ScoreObject score(MLDataPair pair, Map<String, String> rawDataMap) {
    if (pair == null) {
        return null;
    }
    List<Integer> scores = new ArrayList<Integer>();
    for (BasicML model : models) {
        if (model instanceof BasicNetwork) {
            BasicNetwork network = (BasicNetwork) model;
            if (network.getInputCount() != pair.getInput().size()) {
                log.error("String_Node_Str" + network.getInputCount() + "String_Node_Str" + pair.getInput().size());
                continue;
            }
            MLData score = network.compute(pair.getInput());
            if (modelConfig.isBinaryClassification()) {
                scores.add(toScore(score.getData(0)));
            } else {
                double[] outputs = score.getData();
                for (double d : outputs) {
                    scores.add(toScore(d));
                }
            }
        } else if (model instanceof SVM) {
            SVM svm = (SVM) model;
            if (svm.getInputCount() != pair.getInput().size()) {
                log.error("String_Node_Str" + svm.getInputCount() + "String_Node_Str" + pair.getInput().size());
                continue;
            }
            MLData score = svm.compute(pair.getInput());
            scores.add(toScore(score.getData(0)));
        } else if (model instanceof LR) {
            LR lr = (LR) model;
            if (lr.getInputCount() != pair.getInput().size()) {
                log.error("String_Node_Str" + lr.getInputCount() + "String_Node_Str" + pair.getInput().size());
                continue;
            }
            MLData score = lr.compute(pair.getInput());
            scores.add(toScore(score.getData(0)));
        } else {
            throw new RuntimeException("String_Node_Str");
        }
    }
    Integer tag = (int) pair.getIdeal().getData(0);
    if (scores.size() == 0) {
        log.error("String_Node_Str");
        return null;
    }
    return new ScoreObject(scores, tag);
}

Output:
             MLData score = network.compute(pair.getInput());
-            if (modelConfig.isBinaryClassification()) {
+            if (modelConfig != null && modelConfig.isBinaryClassification()) {
                 scores.add(toScore(score.getData(0)));


Input:
protected void updateEntityActionState() {
    if (lastAttacker != null && (lastAttacker.isDead || !lastAttacker.playerNetServerHandler.func_147362_b().isChannelOpen()))
        lastAttacker = null;
    float health = getHealth();
    if (health <= 0)
        return;
    if (lightningTarget == null && --healthRegenTimer < 0 && health < getMaxHealth())
        setHealth(health + 1);
    if (healthRegenTimer < 0)
        healthRegenTimer = 9;
    if (lightningStartCounter <= 0) {
        lightningStartCounter = 40;
        lightningCounter = 0;
        lightningTarget = lastAttacker == null ? worldObj.getClosestPlayerToEntity(this, 512D) : lastAttacker;
    }
    if (lightningTarget != null) {
        if (ticksExisted % 18 == 0) {
            double xx = lightningTarget.posX + (rand.nextDouble() - 0.5D) * 1.5D, yy = lightningTarget.posY, zz = lightningTarget.posZ + (rand.nextDouble() - 0.5D) * 1.5D;
            lightningTarget.attackEntityFrom(new DamageSourceMobUnscaled(this), DamageSourceMobUnscaled.getDamage(ModCommonProxy.opMobs ? 7F : 4F, worldObj.difficultySetting));
            EntityWeatherEffect bolt = new EntityWeatherLightningBoltDemon(worldObj, xx, yy, zz, this, false);
            worldObj.weatherEffects.add(bolt);
            PacketPipeline.sendToAllAround(bolt, 512D, new C05CustomWeather(bolt, (byte) 0));
            if (++lightningCounter >= 6)
                lightningTarget = null;
        }
    } else {
        if (--endermanSpawnTimer < -100) {
            endermanSpawnTimer = (byte) (125 - rand.nextInt(40));
            if (obsidianSpawnTimer < -105)
                obsidianSpawnTimer += 20;
            for (EntityPlayer player : (List<EntityPlayer>) worldObj.getEntitiesWithinAABB(EntityPlayer.class, boundingBox.expand(128D, 64D, 128D))) {
                int attempt, ix, iy, iz;
                for (attempt = 0; attempt < 40; attempt++) {
                    double ang = rand.nextDouble() * Math.PI * 2D, len = 3.5D + rand.nextDouble() * 2D;
                    ix = MathUtil.floor(player.posX + Math.cos(ang) * len);
                    iz = MathUtil.floor(player.posZ + Math.sin(ang) * len);
                    for (iy = MathUtil.floor(player.posY) - 2; iy < player.posY + 3; iy++) {
                        if (worldObj.isAirBlock(ix, iy, iz) && worldObj.isAirBlock(ix, iy + 1, iz) && worldObj.isAirBlock(ix, iy + 2, iz)) {
                            for (int a = 0; a < (ModCommonProxy.opMobs ? 4 : 3); a++) {
                                EntityMobAngryEnderman enderman = new EntityMobAngryEnderman(worldObj, ix + rand.nextDouble(), iy, iz + rand.nextDouble());
                                enderman.rotationYaw = rand.nextFloat() * 360F;
                                enderman.setTarget(player);
                                enderman.addPotionEffect(endermanStrength);
                                worldObj.spawnEntityInWorld(enderman);
                                attempt = 999;
                            }
                            EntityWeatherEffect bolt = new EntityWeatherLightningBoltDemon(worldObj, ix + 0.5D, iy, iz + 0.5D, this, false);
                            worldObj.addWeatherEffect(bolt);
                            PacketPipeline.sendToAllAround(bolt, 512D, new C05CustomWeather(bolt, (byte) 0));
                            break;
                        }
                    }
                }
            }
        }
        if (--obsidianSpawnTimer < -120) {
            obsidianSpawnTimer = (byte) (20 + rand.nextInt(80));
            List<EntityPlayer> list = worldObj.getEntitiesWithinAABB(EntityPlayer.class, boundingBox.expand(128D, 64D, 128D));
            if (!list.isEmpty()) {
                EntityPlayer player = list.get(rand.nextInt(list.size()));
                for (int attempt = 0, placed = 0, xx, yy, zz; attempt < 25 && placed < 12 + worldObj.difficultySetting.getDifficultyId() * 2; attempt++) {
                    xx = MathUtil.floor(player.posX) + rand.nextInt(9) - 4;
                    yy = MathUtil.floor(player.posY) + 9 + rand.nextInt(6);
                    zz = MathUtil.floor(player.posZ) + rand.nextInt(9) - 4;
                    if (worldObj.isAirBlock(xx, yy, zz) && worldObj.isAirBlock(xx, yy - 1, zz)) {
                        worldObj.setBlock(xx, yy, zz, BlockList.obsidian_falling, 0, 3);
                        ++placed;
                    }
                    if (placed > 5 && rand.nextInt(15) <= 1)
                        break;
                }
            }
        }
    }
    if (worldObj.isRemote)
        return;
    boolean hasBlockBelow = false;
    for (int ix = MathUtil.floor(posX), iz = MathUtil.floor(posZ), yy = MathUtil.floor(posY); yy > posY - 22; yy--) {
        if (!worldObj.isAirBlock(ix, yy, iz)) {
            hasBlockBelow = true;
            break;
        }
    }
    if (hasBlockBelow) {
        motionY *= 0.9D;
        if (Math.abs(motionY) < 0.04D)
            motionY = 0D;
    } else {
        motionY = -0.3D;
        ++endermanSpawnTimer;
        ++obsidianSpawnTimer;
        rotationPitch = -90F;
        lastAttacker = (EntityPlayerMP) worldObj.getClosestPlayerToEntity(this, 512D);
    }
    if (lastAttacker != null) {
        double diffX = posX - lastAttacker.posX;
        double diffY = posY - lastAttacker.posY;
        double diffZ = posZ - lastAttacker.posZ;
        double distance = Math.sqrt(diffX * diffX + diffZ * diffZ);
        rotationYaw = DragonUtil.rotateSmoothly(rotationYaw, (float) (Math.atan2(diffZ, diffX) * 180D / Math.PI) - 270F, 2F);
        rotationPitch = DragonUtil.rotateSmoothly(rotationPitch, (float) (-(Math.atan2(diffY, distance) * 180D / Math.PI)), 8F);
    } else if (rotationPitch < 0F)
        rotationPitch -= 2F;
}

Output:
             obsidianSpawnTimer = (byte) (20 + rand.nextInt(80));
-            List<EntityPlayer> list = worldObj.getEntitiesWithinAABB(EntityPlayer.class, boundingBox.expand(128D, 64D, 128D));
-            if (!list.isEmpty()) {
-                EntityPlayer player = list.get(rand.nextInt(list.size()));
+            EntityPlayer player = CollectionUtil.<EntityPlayer>randomOrNull(worldObj.getEntitiesWithinAABB(EntityPlayer.class, boundingBox.expand(128D, 64D, 128D)), rand);
+            if (player != null) {
                 for (int attempt = 0, placed = 0, xx, yy, zz; attempt < 25 && placed < 12 + worldObj.difficultySetting.getDifficultyId() * 2; attempt++) {


Input:
public void updateWifiStateLocked(final WifiActivityEnergyInfo info) {
    if (DEBUG_ENERGY) {
        Slog.d(TAG, "String_Node_Str");
    }
    final long elapsedRealtimeMs = SystemClock.elapsedRealtime();
    NetworkStats delta = null;
    try {
        if (!ArrayUtils.isEmpty(mWifiIfaces)) {
            delta = getNetworkStatsDeltaLocked(mWifiIfaces, mWifiNetworkStats);
        }
    } catch (IOException e) {
        Slog.wtf(TAG, "String_Node_Str", e);
        return;
    }
    if (!mOnBatteryInternal) {
        return;
    }
    SparseLongArray rxPackets = new SparseLongArray();
    SparseLongArray txPackets = new SparseLongArray();
    long totalTxPackets = 0;
    long totalRxPackets = 0;
    if (delta != null) {
        final int size = delta.size();
        for (int i = 0; i < size; i++) {
            final NetworkStats.Entry entry = delta.getValues(i, mTmpNetworkStatsEntry);
            if (DEBUG_ENERGY) {
                Slog.d(TAG, "String_Node_Str" + entry.uid + "String_Node_Str" + entry.rxBytes + "String_Node_Str" + entry.txBytes + "String_Node_Str" + entry.rxPackets + "String_Node_Str" + entry.txPackets);
            }
            if (entry.rxBytes == 0 || entry.txBytes == 0) {
                continue;
            }
            final Uid u = getUidStatsLocked(mapUid(entry.uid));
            if (entry.rxBytes != 0) {
                u.noteNetworkActivityLocked(NETWORK_WIFI_RX_DATA, entry.rxBytes, entry.rxPackets);
                mNetworkByteActivityCounters[NETWORK_WIFI_RX_DATA].addCountLocked(entry.rxBytes);
                mNetworkPacketActivityCounters[NETWORK_WIFI_RX_DATA].addCountLocked(entry.rxPackets);
                rxPackets.put(u.getUid(), entry.rxPackets);
                totalRxPackets += entry.rxPackets;
            }
            if (entry.txBytes != 0) {
                u.noteNetworkActivityLocked(NETWORK_WIFI_TX_DATA, entry.txBytes, entry.txPackets);
                mNetworkByteActivityCounters[NETWORK_WIFI_TX_DATA].addCountLocked(entry.txBytes);
                mNetworkPacketActivityCounters[NETWORK_WIFI_TX_DATA].addCountLocked(entry.txPackets);
                txPackets.put(u.getUid(), entry.txPackets);
                totalTxPackets += entry.txPackets;
            }
        }
    }
    if (info != null) {
        mHasWifiReporting = true;
        final long txTimeMs = info.getControllerTxTimeMillis();
        final long rxTimeMs = info.getControllerRxTimeMillis();
        final long idleTimeMs = info.getControllerIdleTimeMillis();
        final long totalTimeMs = txTimeMs + rxTimeMs + idleTimeMs;
        long leftOverRxTimeMs = rxTimeMs;
        long leftOverTxTimeMs = txTimeMs;
        if (DEBUG_ENERGY) {
            Slog.d(TAG, "String_Node_Str");
            Slog.d(TAG, "String_Node_Str" + txTimeMs + "String_Node_Str");
            Slog.d(TAG, "String_Node_Str" + rxTimeMs + "String_Node_Str");
            Slog.d(TAG, "String_Node_Str" + idleTimeMs + "String_Node_Str");
            Slog.d(TAG, "String_Node_Str" + totalTimeMs + "String_Node_Str");
        }
        long totalWifiLockTimeMs = 0;
        long totalScanTimeMs = 0;
        final int uidStatsSize = mUidStats.size();
        for (int i = 0; i < uidStatsSize; i++) {
            final Uid uid = mUidStats.valueAt(i);
            totalScanTimeMs += uid.mWifiScanTimer.getTimeSinceMarkLocked(elapsedRealtimeMs * 1000) / 1000;
            totalWifiLockTimeMs += uid.mFullWifiLockTimer.getTimeSinceMarkLocked(elapsedRealtimeMs * 1000) / 1000;
        }
        if (DEBUG_ENERGY && totalScanTimeMs > rxTimeMs) {
            Slog.d(TAG, "String_Node_Str" + totalScanTimeMs + "String_Node_Str" + rxTimeMs + "String_Node_Str");
        }
        if (DEBUG_ENERGY && totalScanTimeMs > txTimeMs) {
            Slog.d(TAG, "String_Node_Str" + totalScanTimeMs + "String_Node_Str" + txTimeMs + "String_Node_Str");
        }
        for (int i = 0; i < uidStatsSize; i++) {
            final Uid uid = mUidStats.valueAt(i);
            long scanTimeSinceMarkMs = uid.mWifiScanTimer.getTimeSinceMarkLocked(elapsedRealtimeMs * 1000) / 1000;
            if (scanTimeSinceMarkMs > 0) {
                uid.mWifiScanTimer.setMark(elapsedRealtimeMs);
                long scanRxTimeSinceMarkMs = scanTimeSinceMarkMs;
                long scanTxTimeSinceMarkMs = scanTimeSinceMarkMs;
                if (totalScanTimeMs > rxTimeMs) {
                    scanRxTimeSinceMarkMs = (rxTimeMs * scanRxTimeSinceMarkMs) / totalScanTimeMs;
                }
                if (totalScanTimeMs > txTimeMs) {
                    scanTxTimeSinceMarkMs = (txTimeMs * scanTxTimeSinceMarkMs) / totalScanTimeMs;
                }
                if (DEBUG_ENERGY) {
                    Slog.d(TAG, "String_Node_Str" + uid.getUid() + "String_Node_Str" + scanRxTimeSinceMarkMs + "String_Node_Str" + scanTxTimeSinceMarkMs + "String_Node_Str");
                }
                ControllerActivityCounterImpl activityCounter = uid.getOrCreateWifiControllerActivityLocked();
                activityCounter.getRxTimeCounter().addCountLocked(scanRxTimeSinceMarkMs);
                activityCounter.getTxTimeCounters()[0].addCountLocked(scanTxTimeSinceMarkMs);
                leftOverRxTimeMs -= scanRxTimeSinceMarkMs;
                leftOverTxTimeMs -= scanTxTimeSinceMarkMs;
            }
            final long wifiLockTimeSinceMarkMs = uid.mFullWifiLockTimer.getTimeSinceMarkLocked(elapsedRealtimeMs * 1000) / 1000;
            if (wifiLockTimeSinceMarkMs > 0) {
                uid.mFullWifiLockTimer.setMark(elapsedRealtimeMs);
                final long myIdleTimeMs = (wifiLockTimeSinceMarkMs * idleTimeMs) / totalWifiLockTimeMs;
                if (DEBUG_ENERGY) {
                    Slog.d(TAG, "String_Node_Str" + uid.getUid() + "String_Node_Str" + myIdleTimeMs + "String_Node_Str");
                }
                uid.getOrCreateWifiControllerActivityLocked().getIdleTimeCounter().addCountLocked(myIdleTimeMs);
            }
        }
        if (DEBUG_ENERGY) {
            Slog.d(TAG, "String_Node_Str" + leftOverRxTimeMs + "String_Node_Str");
            Slog.d(TAG, "String_Node_Str" + leftOverTxTimeMs + "String_Node_Str");
        }
        for (int i = 0; i < txPackets.size(); i++) {
            final Uid uid = getUidStatsLocked(txPackets.keyAt(i));
            final long myTxTimeMs = (txPackets.valueAt(i) * leftOverTxTimeMs) / totalTxPackets;
            if (DEBUG_ENERGY) {
                Slog.d(TAG, "String_Node_Str" + uid.getUid() + "String_Node_Str" + myTxTimeMs + "String_Node_Str");
            }
            uid.getOrCreateWifiControllerActivityLocked().getTxTimeCounters()[0].addCountLocked(myTxTimeMs);
        }
        for (int i = 0; i < rxPackets.size(); i++) {
            final Uid uid = getUidStatsLocked(rxPackets.keyAt(i));
            final long myRxTimeMs = (rxPackets.valueAt(i) * leftOverRxTimeMs) / totalRxPackets;
            if (DEBUG_ENERGY) {
                Slog.d(TAG, "String_Node_Str" + uid.getUid() + "String_Node_Str" + myRxTimeMs + "String_Node_Str");
            }
            uid.getOrCreateWifiControllerActivityLocked().getRxTimeCounter().addCountLocked(myRxTimeMs);
        }
        mWifiActivity.getRxTimeCounter().addCountLocked(info.getControllerRxTimeMillis());
        mWifiActivity.getTxTimeCounters()[0].addCountLocked(info.getControllerTxTimeMillis());
        mWifiActivity.getIdleTimeCounter().addCountLocked(info.getControllerIdleTimeMillis());
        final double opVolt = mPowerProfile.getAveragePower(PowerProfile.POWER_WIFI_CONTROLLER_OPERATING_VOLTAGE) / 1000.0;
        if (opVolt != 0) {
            mWifiActivity.getPowerCounter().addCountLocked((long) (info.getControllerEnergyUsed() / opVolt));
        }
    }
}

Output:
             }
-            if (entry.rxBytes == 0 || entry.txBytes == 0) {
+            if (entry.rxBytes == 0 && entry.txBytes == 0) {
                 continue;


Input:
protected String properTypeName(FieldDoc field) {
    String fieldType = field.type().simpleTypeName();
    if (field.type().asParameterizedType() != null) {
        fieldType += "String_Node_Str";
        for (Type type : field.type().asParameterizedType().typeArguments()) {
            fieldType += (type.asClassDoc().containingPackage().equals(field.containingPackage()) ? type.simpleTypeName() : type.qualifiedTypeName()) + "String_Node_Str";
        }
        fieldType = fieldType.substring(0, fieldType.length() - 2);
        fieldType += "String_Node_Str";
    }
    if (field.type().isPrimitive() || field.type().asClassDoc().containingPackage().name().equals("String_Node_Str") || field.type().asClassDoc().containingPackage().equals(field.containingClass().containingPackage()) || imports.contains("String_Node_Str" + field.type().qualifiedTypeName() + "String_Node_Str") || imports.contains("String_Node_Str" + field.type().asClassDoc().containingPackage().name() + "String_Node_Str" + "String_Node_Str")) {
        if (field.type().asClassDoc().containingClass() != null) {
            return field.type().asClassDoc().containingClass().simpleTypeName() + "String_Node_Str" + field.type().simpleTypeName();
        }
        return field.type().simpleTypeName();
    } else {
        return field.type().qualifiedTypeName();
    }
}

Output:
     }
-    if (field.type().isPrimitive() || field.type().asClassDoc().containingPackage().name().equals("String_Node_Str") || field.type().asClassDoc().containingPackage().equals(field.containingClass().containingPackage()) || imports.contains("String_Node_Str" + field.type().qualifiedTypeName() + "String_Node_Str") || imports.contains("String_Node_Str" + field.type().asClassDoc().containingPackage().name() + "String_Node_Str" + "String_Node_Str")) {
+    if (field.type().isPrimitive() || field.type().asClassDoc().containingPackage().name().equals("String_Node_Str")) {
+        return field.type().simpleTypeName();
+    } else if (field.type().asClassDoc().containingPackage().equals(field.containingClass().containingPackage()) || imports.contains("String_Node_Str" + field.type().qualifiedTypeName() + "String_Node_Str") || imports.contains("String_Node_Str" + field.type().asClassDoc().containingPackage().name() + "String_Node_Str" + "String_Node_Str")) {
         if (field.type().asClassDoc().containingClass() != null) {


Input:
private void handleHyperlinkAction(IArea area) {
    IContent content = area.getContent();
    if (null != content) {
        IHyperlinkAction hlAction = content.getHyperlinkAction();
        if (null != hlAction)
            try {
                switch(hlAction.getType()) {
                    case IHyperlinkAction.ACTION_BOOKMARK:
                        writer.addAnnotation(new PdfAnnotation(writer, layoutPointX2PDF(area.getAbsoluteX()), layoutPointY2PDF(area.getAbsoluteY() + area.getHeight()), layoutPointX2PDF(area.getAbsoluteX() + area.getWidth()), layoutPointY2PDF(area.getAbsoluteY()), createPdfAction(hlAction.getHyperlink(), hlAction.getBookmark(), hlAction.getTargetWindow())));
                        break;
                    case IHyperlinkAction.ACTION_DRILLTHROUGH:
                        String baseURL = null;
                        if (context != null) {
                            baseURL = context.getBaseURL();
                        }
                        StringBuffer link = new StringBuffer();
                        String reportName = hlAction.getReportName();
                        if (reportName != null && !reportName.equals("String_Node_Str")) {
                            String format = hlAction.getFormat();
                            if ("String_Node_Str".equalsIgnoreCase(format)) {
                                link.append(baseURL.replaceFirst("String_Node_Str", "String_Node_Str"));
                            }
                            link.append("String_Node_Str");
                            try {
                                link.append(URLEncoder.encode(reportName, "String_Node_Str"));
                            } catch (UnsupportedEncodingException e1) {
                            }
                            if (format != null && format.length() > 0) {
                                link.append("String_Node_Str" + format);
                            }
                            if (hlAction.getParameterBindings() != null) {
                                Iterator paramsIte = hlAction.getParameterBindings().entrySet().iterator();
                                while (paramsIte.hasNext()) {
                                    Map.Entry entry = (Map.Entry) paramsIte.next();
                                    try {
                                        link.append("String_Node_Str" + URLEncoder.encode((String) entry.getKey(), "String_Node_Str") + "String_Node_Str" + URLEncoder.encode((String) entry.getValue(), "String_Node_Str"));
                                    } catch (UnsupportedEncodingException e) {
                                    }
                                }
                            }
                        }
                        if (hlAction.getBookmark() != null) {
                            link.append("String_Node_Str");
                            link.append(hlAction.getBookmark());
                        }
                        writer.addAnnotation(new PdfAnnotation(writer, layoutPointX2PDF(area.getAbsoluteX()), layoutPointY2PDF(area.getAbsoluteY() + area.getHeight()), layoutPointX2PDF(area.getAbsoluteX() + area.getWidth()), layoutPointY2PDF(area.getAbsoluteY()), createPdfAction(link.toString(), null, hlAction.getTargetWindow())));
                        break;
                    case IHyperlinkAction.ACTION_HYPERLINK:
                        writer.addAnnotation(new PdfAnnotation(writer, layoutPointX2PDF(area.getAbsoluteX()), layoutPointY2PDF(area.getAbsoluteY() + area.getHeight()), layoutPointX2PDF(area.getAbsoluteX() + area.getWidth()), layoutPointY2PDF(area.getAbsoluteY()), createPdfAction(hlAction.getHyperlink(), null, hlAction.getTargetWindow())));
                        break;
                }
            } catch (Exception e) {
                logger.log(Level.WARNING, e.getMessage(), e);
            }
    }
}

Output:
                     case IHyperlinkAction.ACTION_BOOKMARK:
-                        writer.addAnnotation(new PdfAnnotation(writer, layoutPointX2PDF(area.getAbsoluteX()), layoutPointY2PDF(area.getAbsoluteY() + area.getHeight()), layoutPointX2PDF(area.getAbsoluteX() + area.getWidth()), layoutPointY2PDF(area.getAbsoluteY()), createPdfAction(hlAction.getHyperlink(), hlAction.getBookmark(), hlAction.getTargetWindow())));
+                        writer.addAnnotation(new PdfAnnotation(writer, layoutPointX2PDF(area.getAbsoluteX()), layoutPointY2PDF(area.getAbsoluteY() + area.getHeight()), layoutPointX2PDF(area.getAbsoluteX() + area.getWidth()), layoutPointY2PDF(area.getAbsoluteY()), createPdfAction(hlAction.getHyperlink(), hlAction.getBookmark(), hlAction.getTargetWindow(), IHyperlinkAction.ACTION_BOOKMARK)));
                         break;


Input:
private <T> void getCompatibleReadersWritersMap(MediaType mediaType, Map<MediaType, List<T>> set, Map<MediaType, List<T>> subSet) {
    if (mediaType.isWildcardType()) {
        getCompatibleReadersWritersList(mediaType, set, subSet);
    } else if (mediaType.isWildcardSubtype()) {
        getCompatibleReadersWritersList(mediaType, set, subSet);
        getCompatibleReadersWritersList(MediaTypes.GENERAL_MEDIA_TYPE, set, subSet);
    } else {
        getCompatibleReadersWritersList(mediaType, set, subSet);
        getCompatibleReadersWritersList(new MediaType(mediaType.getType(), MediaType.MEDIA_TYPE_WILDCARD), set, subSet);
        getCompatibleReadersWritersList(MediaTypes.GENERAL_MEDIA_TYPE, set, subSet);
    }
}

Output:
         getCompatibleReadersWritersList(mediaType, set, subSet);
-        getCompatibleReadersWritersList(new MediaType(mediaType.getType(), MediaType.MEDIA_TYPE_WILDCARD), set, subSet);
+        getCompatibleReadersWritersList(MediaTypes.getTypeWildCart(mediaType), set, subSet);
         getCompatibleReadersWritersList(MediaTypes.GENERAL_MEDIA_TYPE, set, subSet);


Input:
public V put(K key, V value) {
    V oldValue = super.put(key, value);
    _reverseMap.put(value, key);
    return oldValue;
}

Output:
 public V put(K key, V value) {
-    V oldValue = super.put(key, value);
-    _reverseMap.put(value, key);
-    return oldValue;
+    if (value == null) {
+        return remove(key);
+    } else {
+        V oldValue = super.put(key, value);
+        _reverseMap.put(value, key);
+        return oldValue;
+    }
 }


Input:
public int get(int address, AccessMode mode) {
    if (address >= MAX_MEM) {
        throw new EmulationException("String_Node_Str" + MSP430Core.this.config.getAddressAsString(address));
    }
    return memorySegments[address >> 8].get(address, mode);
}

Output:
     if (address >= MAX_MEM) {
-        throw new EmulationException("String_Node_Str" + MSP430Core.this.config.getAddressAsString(address));
+        throw new EmulationException("String_Node_Str" + Utils.hex(address, 4));
     }


Input:
public int size() {
    return counters.size();
}

Output:
 public int size() {
-    return counters.size();
+    synchronized (counters) {
+        return counters.size();
+    }
 }


Input:
public MongoDbWpConfig build() {
    return new MongoDbWpConfig(torodBundle, port, genericBundle);
}

Output:
 public MongoDbWpConfig build() {
-    return new MongoDbWpConfig(torodBundle, port, genericBundle);
+    return new MongoDbWpConfig(coreBundle, port, genericBundle);
 }


Input:
private void updateCheckBoxArea() {
    if ((DesignChoiceConstants.PARAM_CONTROL_TEXT_BOX.equals(getSelectedControlType()) || PARAM_CONTROL_LIST.equals(getSelectedControlType())) && DesignChoiceConstants.PARAM_TYPE_STRING.equals(getSelectedDataType())) {
        allowBlank.setEnabled(true);
    } else {
        allowBlank.setEnabled(false);
    }
    if (DesignChoiceConstants.PARAM_CONTROL_TEXT_BOX.equals(getSelectedControlType())) {
        doNotEcho.setEnabled(true);
    } else {
        doNotEcho.setEnabled(false);
    }
    if (DesignChoiceConstants.PARAM_CONTROL_TEXT_BOX.equals(getSelectedControlType()) || DesignChoiceConstants.PARAM_CONTROL_CHECK_BOX.equals(getSelectedControlType())) {
        needSort.setEnabled(false);
    } else {
        needSort.setEnabled(true);
    }
}

Output:
 private void updateCheckBoxArea() {
-    if ((DesignChoiceConstants.PARAM_CONTROL_TEXT_BOX.equals(getSelectedControlType()) || PARAM_CONTROL_LIST.equals(getSelectedControlType())) && DesignChoiceConstants.PARAM_TYPE_STRING.equals(getSelectedDataType())) {
+    if ((DesignChoiceConstants.PARAM_CONTROL_TEXT_BOX.equals(getSelectedControlType()) || PARAM_CONTROL_LIST.equals(getSelectedControlType()) || PARAM_CONTROL_COMBO.equals(getSelectedControlType())) && DesignChoiceConstants.PARAM_TYPE_STRING.equals(getSelectedDataType())) {
         allowBlank.setEnabled(true);


Input:
private static Set<Artifact> differenceWithCoreDependencies(Set<Artifact> dependencies) {
    Set<Artifact> artifacts = Sets.newHashSet();
    for (Artifact d : dependencies) {
        for (Artifact core : coreDependencies) {
            if (d.getGroupId().equals(core.getGroupId()) && d.getArtifactId().equals(core.getArtifactId()) && d.getVersion().equals(core.getVersion())) {
                continue;
            } else {
                artifacts.add(d);
                break;
            }
        }
    }
    return artifacts;
}

Output:
     for (Artifact d : dependencies) {
-        for (Artifact core : coreDependencies) {
-            if (d.getGroupId().equals(core.getGroupId()) && d.getArtifactId().equals(core.getArtifactId()) && d.getVersion().equals(core.getVersion())) {
-                continue;
-            } else {
-                artifacts.add(d);
-                break;
-            }
+        if (!containsInCoreDependencies(d)) {
+            artifacts.add(d);
         }


Input:
public void toString(String prefix, StringBuilder buffer) {
    if (this.annotations != null) {
        this.annotations.toString();
    }
    buffer.append(prefix).append(ModifierTypes.CLASS.toString(this.modifiers));
    buffer.append(ModifierTypes.CLASS_TYPE.toString(this.modifiers)).append(this.name);
    if (this.genericCount > 0) {
        buffer.append('[');
        Util.astToString(prefix, this.generics, this.genericCount, Formatting.Type.genericSeperator, buffer);
        buffer.append(']');
    }
    if (this.parameterCount > 0) {
        buffer.append('(');
        Util.astToString(prefix, this.parameters, this.parameterCount, Formatting.Method.parameterSeperator, buffer);
        buffer.append(')');
    }
    if (this.superType == null) {
        buffer.append("String_Node_Str");
    } else if (this.superType != Types.OBJECT) {
        buffer.append("String_Node_Str");
        this.superType.toString("String_Node_Str", buffer);
    }
    if (this.interfaceCount > 0) {
        buffer.append("String_Node_Str");
        Util.astToString(prefix, this.interfaces, this.interfaceCount, Formatting.Class.superClassesSeperator, buffer);
    }
    if (this.body != null) {
        buffer.append('\n').append(prefix);
        this.body.toString(prefix, buffer);
    } else {
        buffer.append(';');
    }
}

Output:
     if (this.annotations != null) {
-        this.annotations.toString();
+        this.annotations.toString(prefix, buffer);
     }


Input:
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    response.addHeader("String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
}

Output:
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
-    response.addHeader("String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
+    response.addHeader("String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str");
 }


Input:
public static Scheduler scheduler(Context context) {
    return new ContextScheduler(context.delegate, false);
}

Output:
 public static Scheduler scheduler(Context context) {
-    return new ContextScheduler(context.delegate, false);
+    return new ContextScheduler(context.getDelegate(), false);
 }