Input:
private static void start() {
    if (conf == null) {
        logger.error("String_Node_Str");
        System.exit(-1);
    }
    if (!conf.isHttpsListener() && !conf.isHttpListener() && !conf.isAjpListener()) {
        logger.error("String_Node_Str");
        System.exit(-1);
    }
    IdentityManager identityManager = null;
    if (conf.getIdmImpl() == null) {
        logger.warn("String_Node_Str");
        identityManager = null;
    } else {
        try {
            Object idm = Class.forName(conf.getIdmImpl()).getConstructor(Map.class).newInstance(conf.getIdmArgs());
            identityManager = (IdentityManager) idm;
        } catch (ClassCastException | NoSuchMethodException | SecurityException | ClassNotFoundException | IllegalArgumentException | InstantiationException | IllegalAccessException | InvocationTargetException ex) {
            logger.error("String_Node_Str", conf.getIdmImpl(), ex);
            System.exit(-3);
        }
    }
    AccessManager accessManager = null;
    if (conf.getAmImpl() == null && conf.getIdmImpl() != null) {
        logger.warn("String_Node_Str");
        accessManager = null;
    } else if (conf.getAmImpl() == null && conf.getIdmImpl() == null) {
        logger.warn("String_Node_Str");
        accessManager = null;
    } else {
        try {
            Object am = Class.forName(conf.getAmImpl()).getConstructor(Map.class).newInstance(conf.getAmArgs());
            accessManager = (AccessManager) am;
        } catch (ClassCastException | NoSuchMethodException | SecurityException | ClassNotFoundException | IllegalArgumentException | InstantiationException | IllegalAccessException | InvocationTargetException ex) {
            logger.error("String_Node_Str", conf.getAmImpl(), ex);
            System.exit(-3);
        }
    }
    SSLContext sslContext = null;
    try {
        KeyManagerFactory kmf;
        KeyStore ks;
        if (conf.isUseEmbeddedKeystore()) {
            char[] storepass = "String_Node_Str".toCharArray();
            char[] keypass = "String_Node_Str".toCharArray();
            String storename = "String_Node_Str";
            sslContext = SSLContext.getInstance("String_Node_Str");
            kmf = KeyManagerFactory.getInstance("String_Node_Str");
            ks = KeyStore.getInstance("String_Node_Str");
            ks.load(Bootstrapper.class.getClassLoader().getResourceAsStream(storename), storepass);
            kmf.init(ks, keypass);
            sslContext.init(kmf.getKeyManagers(), null, null);
        } else {
            sslContext = SSLContext.getInstance("String_Node_Str");
            kmf = KeyManagerFactory.getInstance("String_Node_Str");
            ks = KeyStore.getInstance("String_Node_Str");
            FileInputStream fis = new FileInputStream(new File(conf.getKeystoreFile()));
            ks.load(fis, conf.getKeystorePassword().toCharArray());
            kmf.init(ks, conf.getCertPassword().toCharArray());
            sslContext.init(kmf.getKeyManagers(), null, null);
        }
    } catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException | CertificateException | UnrecoverableKeyException ex) {
        logger.error("String_Node_Str", ex);
        System.exit(-1);
    } catch (FileNotFoundException ex) {
        logger.error("String_Node_Str", ex);
        System.exit(-1);
    } catch (IOException ex) {
        logger.error("String_Node_Str", ex);
        System.exit(-1);
    }
    try {
        browserRootFile = ResourcesExtractor.extract("String_Node_Str");
    } catch (URISyntaxException | IOException ex) {
        logger.error("String_Node_Str", ex);
        System.exit(-1);
    }
    logger.info("String_Node_Str", browserRootFile.toString());
    Builder builder = Undertow.builder();
    if (conf.isHttpsListener()) {
        builder.addHttpsListener(conf.getHttpsPort(), conf.getHttpHost(), sslContext);
        logger.info("String_Node_Str", conf.getHttpsHost(), conf.getHttpsPort());
    }
    if (conf.isHttpListener()) {
        builder.addHttpListener(conf.getHttpPort(), conf.getHttpsHost());
        logger.info("String_Node_Str", conf.getHttpHost(), conf.getHttpPort());
    }
    if (conf.isAjpListener()) {
        builder.addAjpListener(conf.getAjpPort(), conf.getAjpHost());
        logger.info("String_Node_Str", conf.getAjpHost(), conf.getAjpPort());
    }
    if (conf.isLocalCacheEnabled()) {
        LocalCachesSingleton.init(conf);
        logger.info("String_Node_Str");
    }
    hanldersPipe = getHandlersPipe(identityManager, accessManager);
    builder.setIoThreads(conf.getIoThreads()).setWorkerThreads(conf.getWorkerThreads()).setDirectBuffers(conf.isDirectBuffers()).setBufferSize(conf.getBufferSize()).setBuffersPerRegion(conf.getBuffersPerRegion()).setHandler(hanldersPipe);
    builder.build().start();
}

Output:
     }
-    if (conf.isLocalCacheEnabled()) {
-        LocalCachesSingleton.init(conf);
+    LocalCachesSingleton.init(conf);
+    if (conf.isLocalCacheEnabled())
+        logger.info("String_Node_Str");
+    else
         logger.info("String_Node_Str");


Input:
Action parse_preferences(SymbolImpl id, RhsValue attr, RhsValue value) throws IOException, ParserException {
    boolean saw_plus_sign = (currentType() == LexemeType.PLUS);
    PreferenceType preference_type = parse_preference_specifier_without_referent();
    if ((preference_type == PreferenceType.ACCEPTABLE) && (!saw_plus_sign)) {
        consumeComma();
    }
    Action prev_a = null;
    while (true) {
        final RhsValue referent;
        if (preference_type.isBinary()) {
            referent = parse_rhs_value();
            consumeComma();
        } else {
            referent = null;
        }
        final MakeAction a = new MakeAction();
        a.preference_type = preference_type;
        a.next = prev_a;
        prev_a = a;
        a.id = new RhsSymbolValue(id);
        a.attr = attr.copy();
        a.value = value.copy();
        if (preference_type.isBinary()) {
            a.referent = referent;
        }
        saw_plus_sign = (currentType() == LexemeType.PLUS);
        preference_type = parse_preference_specifier_without_referent();
        if ((preference_type == PreferenceType.ACCEPTABLE) && (!saw_plus_sign)) {
            return prev_a;
        }
    }
}

Output:
         prev_a = a;
-        a.id = new RhsSymbolValue(id);
+        a.id = id.toRhsValue();
         a.attr = attr.copy();


Input:
public boolean cleanExit(final boolean silent) {
    if (silent) {
        disableConfirmations = true;
    }
    if (!disableConfirmations) {
        disableConfirmations = true;
        for (final Bot bot : bots) {
            if (bot.getAccountName() != null) {
                disableConfirmations = true;
                break;
            }
        }
    }
    boolean doExit = true;
    if (!disableConfirmations) {
        final String message = "String_Node_Str";
        final int result = JOptionPane.showConfirmDialog(this, message, Messages.EXIT, JOptionPane.OK_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE);
        if (result != JOptionPane.OK_OPTION) {
            doExit = false;
        }
    }
    WebQueue.Destroy();
    setVisible(false);
    Monitoring.pushState(Type.ENVIRONMENT, "String_Node_Str", "String_Node_Str", Boolean.toString(showAds));
    if (doExit) {
        menuBar.savePrefs();
        Monitoring.stop();
        System.exit(0);
    } else {
        setVisible(true);
    }
    return doExit;
}

Output:
     }
-    WebQueue.Destroy();
+    try {
+        WebQueue.Destroy();
+    } catch (NoClassDefFoundError ncdfe) {
+    }
     setVisible(false);


Input:
private void initRunning() {
    if (!isStart()) {
        return;
    }
    byte[] bytes = JsonUtils.marshalToByte(serverData);
    try {
        mutex.set(false);
        zkClient.create(path, bytes, CreateMode.EPHEMERAL);
        activeData = serverData;
        processActiveEnter();
        mutex.set(true);
    } catch (ZkNodeExistsException e) {
        bytes = zkClient.readData(path, true);
        if (bytes == null) {
            initRunning();
        } else {
            activeData = JsonUtils.unmarshalFromByte(bytes, ServerRunningData.class);
        }
    } catch (ZkNoNodeException e) {
        zkClient.createPersistent(path, true);
        initRunning();
    }
}

Output:
     } catch (ZkNoNodeException e) {
-        zkClient.createPersistent(path, true);
-        initRunning();
+        if (path.lastIndexOf(File.separator) > 0) {
+            String fatherPath = path.substring(0, path.lastIndexOf(File.separator));
+            zkClient.createPersistent(fatherPath, true);
+            initRunning();
+        } else {
+            LOGGER.error("String_Node_Str" + path + "String_Node_Str", e);
+        }
     }


Input:
private void setData() {
    RealmResults<RealmDemoData> result = mRealm.allObjects(RealmDemoData.class);
    RealmBarDataSet<RealmDemoData> set = new RealmBarDataSet<RealmDemoData>(result, "String_Node_Str", "String_Node_Str");
    System.out.println("String_Node_Str" + set.getStackSize());
    set.setValueTextSize(9f);
    set.setColors(getColors(set.getStackSize()));
    set.setLabel("String_Node_Str");
    set.setStackLabels(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" });
    System.out.println("String_Node_Str" + set.getStackSize());
    ArrayList<IBarDataSet> dataSets = new ArrayList<IBarDataSet>();
    dataSets.add(set);
    BarData data = new BarData(result, "String_Node_Str", dataSets);
    mChart.setData(data);
    mChart.animateY(1400, Easing.EasingOption.EaseInOutQuart);
}

Output:
     RealmResults<RealmDemoData> result = mRealm.allObjects(RealmDemoData.class);
-    RealmBarDataSet<RealmDemoData> set = new RealmBarDataSet<RealmDemoData>(result, "String_Node_Str", "String_Node_Str");
-    System.out.println("String_Node_Str" + set.getStackSize());
+    RealmBarDataSet<RealmDemoData> set = new RealmBarDataSet<RealmDemoData>(result, "String_Node_Str", "String_Node_Str", "String_Node_Str");
     set.setValueTextSize(9f);


Input:
public void run() {
    channel.unbind().awaitUninterruptibly();
    bootstrap.releaseExternalResources();
    remotingServerExecutor.shutdown();
    bossServerExecutor.shutdown();
    clientServerExecutor.shutdown();
    clientBossServerExecutor.shutdown();
    remotingServerExecutor.shutdownNow();
    bossServerExecutor.shutdownNow();
    clientServerExecutor.shutdownNow();
    clientBossServerExecutor.shutdownNow();
    remotingServerExecutor = Executors.newCachedThreadPool();
    bossServerExecutor = Executors.newCachedThreadPool();
    clientServerExecutor = Executors.newCachedThreadPool();
    clientBossServerExecutor = Executors.newCachedThreadPool();
}

Output:
 public void run() {
-    channel.unbind().awaitUninterruptibly();
-    bootstrap.releaseExternalResources();
-    remotingServerExecutor.shutdown();
-    bossServerExecutor.shutdown();
-    clientServerExecutor.shutdown();
-    clientBossServerExecutor.shutdown();
-    remotingServerExecutor.shutdownNow();
-    bossServerExecutor.shutdownNow();
-    clientServerExecutor.shutdownNow();
-    clientBossServerExecutor.shutdownNow();
+    try {
+        channel.unbind().awaitUninterruptibly();
+    } catch (Throwable t) {
+    }
+    try {
+        bootstrap.releaseExternalResources();
+    } catch (Throwable t) {
+    }
+    try {
+        remotingServerExecutor.shutdown();
+        bossServerExecutor.shutdown();
+        clientServerExecutor.shutdown();
+        clientBossServerExecutor.shutdown();
+        remotingServerExecutor.shutdownNow();
+        bossServerExecutor.shutdownNow();
+        clientServerExecutor.shutdownNow();
+        clientBossServerExecutor.shutdownNow();
+    } catch (Throwable t) {
+    }
     remotingServerExecutor = Executors.newCachedThreadPool();


Input:
public String toString() {
    StringBuilder builder = new StringBuilder();
    builder.append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append(this.getTitle()).append(Options.QUOTE);
    builder.append("String_Node_Str");
    builder.append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append(this.getField()).append(Options.QUOTE);
    builder.append("String_Node_Str");
    builder.append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append("String_Node_Str").append(!this.isVisible());
    if (this.getWidth() > 0) {
        builder.append("String_Node_Str");
        builder.append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append("String_Node_Str").append(this.getWidth());
    }
    if (this.getFormat() != null) {
        builder.append("String_Node_Str");
        builder.append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append(this.getFormat()).append(Options.QUOTE);
    }
    if (this.getGroupHeaderTemplate() != null) {
        builder.append("String_Node_Str");
        builder.append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append(this.getGroupHeaderTemplate()).append(Options.QUOTE);
    }
    if (this.getGroupFooterTemplate() != null) {
        builder.append("String_Node_Str");
        builder.append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append(this.getGroupFooterTemplate()).append(Options.QUOTE);
    }
    if (this.getMenu() != null) {
        builder.append("String_Node_Str");
        builder.append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append("String_Node_Str").append(this.getMenu());
    }
    if (this.getAggregates() != null) {
        builder.append("String_Node_Str");
        builder.append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append("String_Node_Str").append(this.getAggregatesAsString());
    }
    if (this.getFilterable() != null) {
        builder.append("String_Node_Str");
        builder.append(Options.QUOTE).append("String_Node_Str").append(Options.QUOTE).append("String_Node_Str").append(this.getFilterable());
    }
    return builder.toString();
}

Output:
     }
-    if (this.getAggregates() != null) {
+    if (!this.getAggregates().isEmpty()) {
         builder.append("String_Node_Str");


Input:
public static DefaultSyncConfig of(ConfigurationParameters params) {
    DefaultSyncConfig cfg = new DefaultSyncConfig().setName(params.getConfigValue(PARAM_NAME, PARAM_NAME_DEFAULT));
    cfg.user().setMembershipExpirationTime(ConfigurationParameters.Milliseconds.of(params.getConfigValue(PARAM_USER_MEMBERSHIP_EXPIRATION_TIME, PARAM_USER_MEMBERSHIP_EXPIRATION_TIME_DEFAULT)).value).setMembershipNestingDepth(params.getConfigValue(PARAM_USER_MEMBERSHIP_NESTING_DEPTH, PARAM_USER_MEMBERSHIP_NESTING_DEPTH_DEFAULT)).setExpirationTime(ConfigurationParameters.Milliseconds.of(params.getConfigValue(PARAM_USER_EXPIRATION_TIME, PARAM_USER_EXPIRATION_TIME_DEFAULT)).value).setPathPrefix(params.getConfigValue(PARAM_USER_PATH_PREFIX, PARAM_USER_PATH_PREFIX_DEFAULT)).setAutoMembership(params.getConfigValue(PARAM_USER_AUTO_MEMBERSHIP, PARAM_USER_AUTO_MEMBERSHIP_DEFAULT)).setPropertyMapping(createMapping(params.getConfigValue(PARAM_USER_PROPERTY_MAPPING, PARAM_USER_PROPERTY_MAPPING_DEFAULT)));
    cfg.group().setExpirationTime(ConfigurationParameters.Milliseconds.of(params.getConfigValue(PARAM_GROUP_EXPIRATION_TIME, PARAM_GROUP_EXPIRATION_TIME_DEFAULT)).value).setPathPrefix(params.getConfigValue(PARAM_GROUP_PATH_PREFIX, PARAM_GROUP_PATH_PREFIX_DEFAULT)).setAutoMembership(params.getConfigValue(PARAM_GROUP_AUTO_MEMBERSHIP, PARAM_GROUP_AUTO_MEMBERSHIP_DEFAULT)).setPropertyMapping(createMapping(params.getConfigValue(PARAM_GROUP_PROPERTY_MAPPING, PARAM_GROUP_PROPERTY_MAPPING_DEFAULT)));
    return cfg;
}

Output:
     DefaultSyncConfig cfg = new DefaultSyncConfig().setName(params.getConfigValue(PARAM_NAME, PARAM_NAME_DEFAULT));
-    cfg.user().setMembershipExpirationTime(ConfigurationParameters.Milliseconds.of(params.getConfigValue(PARAM_USER_MEMBERSHIP_EXPIRATION_TIME, PARAM_USER_MEMBERSHIP_EXPIRATION_TIME_DEFAULT)).value).setMembershipNestingDepth(params.getConfigValue(PARAM_USER_MEMBERSHIP_NESTING_DEPTH, PARAM_USER_MEMBERSHIP_NESTING_DEPTH_DEFAULT)).setExpirationTime(ConfigurationParameters.Milliseconds.of(params.getConfigValue(PARAM_USER_EXPIRATION_TIME, PARAM_USER_EXPIRATION_TIME_DEFAULT)).value).setPathPrefix(params.getConfigValue(PARAM_USER_PATH_PREFIX, PARAM_USER_PATH_PREFIX_DEFAULT)).setAutoMembership(params.getConfigValue(PARAM_USER_AUTO_MEMBERSHIP, PARAM_USER_AUTO_MEMBERSHIP_DEFAULT)).setPropertyMapping(createMapping(params.getConfigValue(PARAM_USER_PROPERTY_MAPPING, PARAM_USER_PROPERTY_MAPPING_DEFAULT)));
-    cfg.group().setExpirationTime(ConfigurationParameters.Milliseconds.of(params.getConfigValue(PARAM_GROUP_EXPIRATION_TIME, PARAM_GROUP_EXPIRATION_TIME_DEFAULT)).value).setPathPrefix(params.getConfigValue(PARAM_GROUP_PATH_PREFIX, PARAM_GROUP_PATH_PREFIX_DEFAULT)).setAutoMembership(params.getConfigValue(PARAM_GROUP_AUTO_MEMBERSHIP, PARAM_GROUP_AUTO_MEMBERSHIP_DEFAULT)).setPropertyMapping(createMapping(params.getConfigValue(PARAM_GROUP_PROPERTY_MAPPING, PARAM_GROUP_PROPERTY_MAPPING_DEFAULT)));
+    cfg.user().setMembershipExpirationTime(getMilliSeconds(params, PARAM_USER_MEMBERSHIP_EXPIRATION_TIME, PARAM_USER_MEMBERSHIP_EXPIRATION_TIME_DEFAULT, ONE_HOUR)).setMembershipNestingDepth(params.getConfigValue(PARAM_USER_MEMBERSHIP_NESTING_DEPTH, PARAM_USER_MEMBERSHIP_NESTING_DEPTH_DEFAULT)).setExpirationTime(getMilliSeconds(params, PARAM_USER_EXPIRATION_TIME, PARAM_USER_EXPIRATION_TIME_DEFAULT, ONE_HOUR)).setPathPrefix(params.getConfigValue(PARAM_USER_PATH_PREFIX, PARAM_USER_PATH_PREFIX_DEFAULT)).setAutoMembership(params.getConfigValue(PARAM_USER_AUTO_MEMBERSHIP, PARAM_USER_AUTO_MEMBERSHIP_DEFAULT)).setPropertyMapping(createMapping(params.getConfigValue(PARAM_USER_PROPERTY_MAPPING, PARAM_USER_PROPERTY_MAPPING_DEFAULT)));
+    cfg.group().setExpirationTime(getMilliSeconds(params, PARAM_GROUP_EXPIRATION_TIME, PARAM_GROUP_EXPIRATION_TIME_DEFAULT, ONE_DAY)).setPathPrefix(params.getConfigValue(PARAM_GROUP_PATH_PREFIX, PARAM_GROUP_PATH_PREFIX_DEFAULT)).setAutoMembership(params.getConfigValue(PARAM_GROUP_AUTO_MEMBERSHIP, PARAM_GROUP_AUTO_MEMBERSHIP_DEFAULT)).setPropertyMapping(createMapping(params.getConfigValue(PARAM_GROUP_PROPERTY_MAPPING, PARAM_GROUP_PROPERTY_MAPPING_DEFAULT)));
     return cfg;


Input:
public void lessThan() {
    final int TEST_OBJECTS_COUNT = 200;
    populateTestRealm(realm, TEST_OBJECTS_COUNT);
    RealmResults<AllTypes> resultList = realm.where(AllTypes.class).lessThan(AllTypes.FIELD_FLOAT, 31.234567f).findAll();
    assertEquals(30, resultList.size());
    RealmQuery<AllTypes> query = realm.where(AllTypes.class).lessThan(AllTypes.FIELD_FLOAT, 31.234567f);
    resultList = query.between(AllTypes.FIELD_LONG, 1, 10).findAll();
    assertEquals(10, resultList.size());
}

Output:
     populateTestRealm(realm, TEST_OBJECTS_COUNT);
-    RealmResults<AllTypes> resultList = realm.where(AllTypes.class).lessThan(AllTypes.FIELD_FLOAT, 31.234567f).findAll();
+    RealmResults<AllTypes> resultList = realm.where(AllTypes.class).lessThan(AllTypes.FIELD_FLOAT, 31.2345f).findAll();
     assertEquals(30, resultList.size());


Input:
protected void processPublish(PublishEvent evt) {
    LOG.debug("String_Node_Str");
    final String topic = evt.getTopic();
    final QOSType qos = evt.getQos();
    final byte[] message = evt.getMessage();
    boolean retain = evt.isRetain();
    CleanInFlightEvent cleanEvt = null;
    if (qos == QOSType.LEAST_ONE) {
        String publishKey = String.format("String_Node_Str", evt.getClientID(), evt.getMessageID());
        m_storageService.addInFlight(evt, publishKey);
        cleanEvt = new CleanInFlightEvent(publishKey);
    }
    for (final Subscription sub : subscriptions.matches(topic)) {
        if (qos == QOSType.MOST_ONE) {
            notify(new NotifyEvent(sub.clientId, topic, qos, message, false));
        } else {
            if (!sub.isCleanSession() && !sub.isActive()) {
                m_storageService.storePublishForFuture(evt);
            }
            notify(new NotifyEvent(sub.clientId, topic, qos, message, false));
        }
    }
    if (cleanEvt != null) {
        refill(cleanEvt);
        sendPubAck(new PubAckEvent(evt.getMessageID(), evt.getClientID()));
    }
    if (retain) {
        m_storageService.storeRetained(topic, message, qos);
    }
}

Output:
 protected void processPublish(PublishEvent evt) {
-    LOG.debug("String_Node_Str");
+    LOG.debug("String_Node_Str" + evt);
     final String topic = evt.getTopic();


Input:
public static int getGroupIndex(List groups, int dimensionIndex, int levelIndex) {
    if (levelIndex < 0) {
        for (int i = groups.size() - 1; i >= 0; i--) {
            EdgeGroup gp = (EdgeGroup) groups.get(i);
            if (gp.dimensionIndex == dimensionIndex) {
                return i;
            }
        }
    } else {
        for (int i = 0; i < groups.size(); i++) {
            EdgeGroup gp = (EdgeGroup) groups.get(i);
            if (gp.dimensionIndex == dimensionIndex && gp.levelIndex == levelIndex) {
                return i;
            }
        }
    }
    return -1;
}

Output:
         for (int i = groups.size() - 1; i >= 0; i--) {
-            EdgeGroup gp = (EdgeGroup) groups.get(i);
+            EdgeGroup gp = groups.get(i);
             if (gp.dimensionIndex == dimensionIndex) {


Input:
public void generateFireCode(StringBuffer stream) throws IllegalActionException {
    ptolemy.actor.lib.AddSubtract actor = (ptolemy.actor.lib.AddSubtract) getComponent();
    StringBuffer tmpStream = new StringBuffer();
    tmpStream.append("String_Node_Str");
    for (int i = 0; i < actor.plus.getWidth(); i++) {
        tmpStream.append("String_Node_Str" + i + "String_Node_Str");
        if (i < actor.plus.getWidth() - 1)
            tmpStream.append("String_Node_Str");
        else if (actor.minus.getWidth() > 0)
            tmpStream.append("String_Node_Str");
    }
    for (int i = 0; i < actor.minus.getWidth(); i++) {
        tmpStream.append("String_Node_Str" + i + "String_Node_Str");
        if (i < actor.minus.getWidth() - 1)
            tmpStream.append("String_Node_Str");
        else
            tmpStream.append("String_Node_Str");
    }
    stream.append(processCode(tmpStream.toString()));
}

Output:
         tmpStream.append("String_Node_Str" + i + "String_Node_Str");
-        if (i < actor.plus.getWidth() - 1)
+        if (i < actor.plus.getWidth() - 1) {
             tmpStream.append("String_Node_Str");


Input:
public void handle(Either<String, JsonObject> s) {
    if (s.isRight()) {
        JsonObject j = new JsonObject().putString("String_Node_Str", "String_Node_Str").putString("String_Node_Str", s.right().getValue().getString("String_Node_Str"));
        eb.send("String_Node_Str", j);
    }
}

Output:
         JsonObject j = new JsonObject().putString("String_Node_Str", "String_Node_Str").putString("String_Node_Str", s.right().getValue().getString("String_Node_Str"));
-        eb.send("String_Node_Str", j);
+        eb.send("String_Node_Str", j, new Handler<Message<JsonObject>>() {
+            public void handle(Message<JsonObject> event) {
+                if ("String_Node_Str".equals(event.body().getString("String_Node_Str", "String_Node_Str"))) {
+                    log.error("String_Node_Str");
+                } else if (welcomeMessage) {
+                    JsonObject params = new JsonObject();
+                    conversationNotification.notify(request, "String_Node_Str", userIds, null, "String_Node_Str", "String_Node_Str", params, new Handler<Either<String, JsonObject>>() {
+                        public void handle(Either<String, JsonObject> r) {
+                            if (r.isLeft()) {
+                                log.error(r.left().getValue());
+                            }
+                        }
+                    });
+                }
+            }
+        });
     }


Input:
public String getLadiesRanking() {
    url.append("String_Node_Str");
    return YoubuyService.handleGet(YoubuyService.handleArguments(url, vc));
}

Output:
     url.append("String_Node_Str");
-    return YoubuyService.handleGet(YoubuyService.handleArguments(url, vc));
+    String result = YoubuyService.handleGet(YoubuyService.handleArguments(url, vc));
+    url = new StringBuffer(url.substring(0, 21));
+    return result;
 }


Input:
private String prefKey(final ModuleItem<?> item) {
    final String persistKey = item.getPersistKey();
    return persistKey == null || persistKey.isEmpty() ? persistKey : item.getName();
}

Output:
     final String persistKey = item.getPersistKey();
-    return persistKey == null || persistKey.isEmpty() ? persistKey : item.getName();
+    return persistKey == null || persistKey.isEmpty() ? item.getName() : persistKey;
 }


Input:
public void adjust(Mechanism mechanism) {
    if (mechanism.matches("String_Node_Str")) {
        ((Creeper) (powered.getBukkitEntity())).setPowered(mechanism.getValue().asBoolean());
    }
}

Output:
     if (mechanism.matches("String_Node_Str")) {
-        ((Creeper) (powered.getBukkitEntity())).setPowered(mechanism.getValue().asBoolean());
+        setPowered(mechanism.getValue().asBoolean());
     }


Input:
public void exportAllModelsToJson(VisWebSocket socket) {
    Object[] models = OpenSimDB.getInstance().getAllModels();
    for (int i = 0; i < models.length; i++) {
        Model model = (Model) models[i];
        ModelVisualizationJson vizJson = null;
        if (getInstance().mapModelsToJsons.containsKey(model)) {
            vizJson = getInstance().mapModelsToJsons.get(model);
        } else {
            vizJson = new ModelVisualizationJson(jsondb, model);
            getInstance().addModelVisuals(model, vizJson);
        }
        exportModelJsonToVisualizer(vizJson, socket);
    }
}

Output:
         } else {
-            vizJson = new ModelVisualizationJson(jsondb, model);
-            getInstance().addModelVisuals(model, vizJson);
+            vizJson = createJsonFroModel(jsondb, model);
         }


Input:
public Integer get(Player player) {
    return get(player.getInetAddress()).group;
}

Output:
 public Integer get(Player player) {
-    return get(player.getInetAddress()).group;
+    return contains(player.getInetAddress()) ? get(player.getInetAddress()).group : null;
 }


Input:
protected void flushRememberedSets() throws InlinePragma {
    logMessage(5, "String_Node_Str");
    remset.flushLocal();
    while (!traceRemset.isEmpty()) {
        Address loc = traceRemset.pop();
        traceObjectLocation(loc, false);
    }
    logMessage(5, "String_Node_Str");
    arrayRemset.flushLocal();
    while (!arrayRemset.isEmpty()) {
        Address start = arrayRemset.pop1();
        Address guard = arrayRemset.pop2();
        while (start.LT(guard)) {
            traceObjectLocation(start, false);
            start = start.plus(BYTES_IN_ADDRESS);
        }
    }
}

Output:
     logMessage(5, "String_Node_Str");
-    remset.flushLocal();
-    while (!traceRemset.isEmpty()) {
-        Address loc = traceRemset.pop();
+    while (!remset.isEmpty()) {
+        Address loc = remset.pop();
         traceObjectLocation(loc, false);


Input:
public void changed(ChangeEvent event, Actor actor) {
    int pos = list.getSelectedIndex();
    Element e2 = null;
    pos++;
    if (pos != 0 && pos < list.getItems().size)
        e2 = list.getItems().get(pos);
    Element e = ((EditElementDialog) actor).getElement();
    list.getItems().insert(pos, e);
    Node parent = e.getParentNode();
    parent.removeChild(e);
    parent.insertBefore(e, e2);
    int i = getItems().indexOf(e, true);
    if (i != -1)
        list.setSelectedIndex(i);
    list.invalidateHierarchy();
}

Output:
 public void changed(ChangeEvent event, Actor actor) {
-    int pos = list.getSelectedIndex();
+    int pos = list.getSelectedIndex() + 1;
     Element e2 = null;


Input:
public void testSendAndReceive() throws InterruptedException {
    SyncTasksPacketSchedulerMock taskReceiver = new SyncTasksPacketSchedulerMock();
    TaskPacketListener listener = new TaskPacketListener(taskReceiver);
    c1.registerListener(listener);
    TaskPacket testPacket1 = new TestTaskPacket("String_Node_Str", 23424, (byte) -2);
    TaskPacket testPacket2 = new TestTaskPacket("String_Node_Str", -2342342, (byte) -67);
    int lockstep = 23;
    SyncTasksPacket syncTasksPacket = new SyncTasksPacket(lockstep, Arrays.asList(testPacket1, testPacket2));
    c2.sendPacket(NetworkConstants.ENetworkKey.SYNCHRONOUS_TASK, syncTasksPacket);
    Thread.sleep(30);
    List<SyncTasksPacket> packets = taskReceiver.popBufferedPackets();
    assertEquals(1, packets.size());
    assertEquals(lockstep, packets.get(0).getLockstepNumber());
    List<TaskPacket> tasks = packets.get(0).getTasks();
    assertEquals(2, tasks.size());
    assertEquals(testPacket1, tasks.get(0));
    assertEquals(testPacket2, tasks.get(1));
}

Output:
     c2.sendPacket(NetworkConstants.ENetworkKey.SYNCHRONOUS_TASK, syncTasksPacket);
-    Thread.sleep(30);
+    Thread.sleep(30L);
     List<SyncTasksPacket> packets = taskReceiver.popBufferedPackets();


Input:
public void assignFields() {
    WPM = Integer.parseInt(sharedPreferences.getString(Constants.Preferences.WPM, Constants.DEFAULT_WPM));
    typeface = Integer.parseInt(sharedPreferences.getString(Constants.Preferences.TYPEFACE, "String_Node_Str"));
    swipesEnabled = sharedPreferences.getBoolean(Constants.Preferences.SWIPE, true);
    showingContextEnabled = sharedPreferences.getBoolean(Constants.Preferences.SHOW_CONTEXT, true);
    punctuationSpeedDiffers = sharedPreferences.getBoolean(Constants.Preferences.PUNCTUATION_DIFFERS, true);
    delayCoefficients = buildDelayListCoefficients();
}

Output:
     typeface = Integer.parseInt(sharedPreferences.getString(Constants.Preferences.TYPEFACE, "String_Node_Str"));
-    swipesEnabled = sharedPreferences.getBoolean(Constants.Preferences.SWIPE, true);
+    swipesEnabled = sharedPreferences.getBoolean(Constants.Preferences.SWIPE, false);
     showingContextEnabled = sharedPreferences.getBoolean(Constants.Preferences.SHOW_CONTEXT, true);


Input:
private static void parseInstance(FormDef f, Element e) {
    int numChildElements = 0;
    for (int i = 0; i < e.getChildCount(); i++) {
        if (e.getType(i) == Node.ELEMENT) {
            numChildElements++;
        }
    }
    if (numChildElements > 1) {
        throw new XFormParseException("String_Node_Str");
    }
    TreeElement root = parseInstanceNodes(e, "String_Node_Str").getRoot();
    DataModelTree instanceModel = new DataModelTree(root);
    f.setDataModel(instanceModel);
}

Output:
 private static void parseInstance(FormDef f, Element e) {
-    int numChildElements = 0;
+    Element dataElement = null;
     for (int i = 0; i < e.getChildCount(); i++) {


Input:
public void testRiskIndex() {
    try {
        Risk risk = new Risk();
        risk.setName("String_Node_Str");
        risk.setDescription("String_Node_Str");
        risk.setIdentifiedOn(new Date());
        risk.setIdentifiedBy("String_Node_Str");
        risk.setCategory("String_Node_Str");
        risk.setNotes("String_Node_Str");
        risk.setPreMitigationProbability(4);
        risk.setPreMitigationImpact(4);
        risk.setPreMitigationSeverity(16);
        risk.setPreMitigationSeverityLevel(SEVERITY_LEVEL.HIGH);
        risk.setPreMitigationNotes("String_Node_Str");
        risk.setPostMitigationProbability(3);
        risk.setPostMitigationImpact(2);
        risk.setPostMitigationSeverity(6);
        risk.setPostMitigationSeverityLevel(SEVERITY_LEVEL.MODERATE);
        risk.setPostMitigationNotes("String_Node_Str");
        risk.setMitigationStrategy("String_Node_Str");
        risk.setMitigationOwnerType("String_Node_Str");
        risk.setMitigationOwner("String_Node_Str");
        risk.setMitigationRelatedEventIdentifierType("String_Node_Str");
        risk.setMitigationRelatedEventIdentifierValue("String_Node_Str");
        risk.setCreatedOn(new Date());
        risk.setCreatedBy("String_Node_Str");
        risk.setUpdatedOn(new Date());
        risk.setUpdatedBy("String_Node_Str");
        model.createRisk(risk, false);
        index.commit(IndexedRisk.class);
        Risk risk2 = model.retrieveRisk(risk.getId());
        assertNotNull(risk2);
        assertEquals(risk.getId(), risk2.getId());
        assertEquals(risk.getName(), risk2.getName());
        IndexResult<IndexedRisk> find = index.find(IndexedRisk.class, null, null, new Sublist(0, 10), Collections.emptyList());
        assertEquals(1, find.getTotalCount());
        Risk risk3 = index.retrieve(IndexedRisk.class, risk.getId(), new ArrayList<>());
        assertNotNull(risk3);
        assertEquals(risk.getId(), risk3.getId());
        assertEquals(risk.getName(), risk3.getName());
        risk3.setName("String_Node_Str");
        Map<String, String> properties = new HashMap<>();
        properties.put(RodaConstants.VERSION_ACTION, RodaConstants.VersionAction.UPDATED.toString());
        model.updateRisk(risk3, properties, false, 0);
        Risk risk4 = index.retrieve(IndexedRisk.class, risk.getId(), new ArrayList<>());
        assertNotNull(risk4);
        assertEquals(risk.getId(), risk4.getId());
        assertEquals(risk4.getName(), "String_Node_Str");
        model.deleteRisk(risk.getId(), false);
    } catch (GenericException | RequestNotValidException | NotFoundException | AuthorizationDeniedException e) {
        e.printStackTrace();
        assertTrue(false);
    }
}

Output:
     } catch (GenericException | RequestNotValidException | NotFoundException | AuthorizationDeniedException e) {
-        e.printStackTrace();
+        e.printStackTrace(System.err);
         assertTrue(false);


Input:
public static void generateIndex(String[] components, String[] indexFiles, String libraryName, String outputFile) throws IOException {
    Element root = new Element("String_Node_Str");
    root.setAttribute("String_Node_Str", libraryName);
    root.setAttribute("String_Node_Str", "String_Node_Str");
    Element configure = new Element("String_Node_Str");
    root.addContent(configure);
    DocType plot = new DocType("String_Node_Str", "String_Node_Str", "String_Node_Str");
    Document doc = new Document();
    String comment = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    doc.addContent(new Comment(comment));
    doc.setRootElement(root);
    doc.setDocType(plot);
    Element group = new Element("String_Node_Str");
    for (int i = 0; i < indexFiles.length; i++) {
        Element input = new Element("String_Node_Str");
        if (File.separator.equals("String_Node_Str")) {
            indexFiles[i] = indexFiles[i].replace('\\', '/');
        }
        input.setAttribute("String_Node_Str", FileUtilities.nameToURL(indexFiles[i], null, null).toString());
        group.addContent(input);
    }
    for (int i = 0; i < components.length; i++) {
        try {
            String c = components[i];
            if (File.separator.equals("String_Node_Str")) {
                c = c.replace('\\', '/');
            }
            String[] subNames = c.split("String_Node_Str");
            String componentName = subNames[subNames.length - 1];
            String className = c.replaceAll("String_Node_Str", "String_Node_Str");
            Element entity = new Element("String_Node_Str");
            entity.setAttribute("String_Node_Str", componentName);
            entity.setAttribute("String_Node_Str", className);
            group.addContent(entity);
        } catch (PatternSyntaxException e) {
            System.err.println("String_Node_Str" + e);
            e.printStackTrace();
        }
    }
    XMLOutputter serializer = new XMLOutputter(Format.getPrettyFormat());
    Format format = serializer.getFormat();
    format.setOmitEncoding(true);
    format.setLineSeparator("String_Node_Str");
    serializer.setFormat(format);
    ProcessingInstruction moml = new ProcessingInstruction("String_Node_Str", "String_Node_Str" + serializer.outputString(group) + "String_Node_Str");
    configure.addContent(moml);
    FileOutputStream out = null;
    try {
        if (outputFile != null) {
            out = new FileOutputStream(outputFile);
        }
        if (out != null) {
            serializer.output(doc, out);
        } else {
            serializer.output(doc, System.out);
        }
    } catch (IOException ex) {
        IOException ioException = new IOException("String_Node_Str" + outputFile + "String_Node_Str");
        ioException.initCause(ex);
        throw ioException;
    } finally {
        if (out != null) {
            try {
                out.close();
            } catch (IOException ex) {
                System.err.println("String_Node_Str" + outputFile + "String_Node_Str" + ex);
            }
        }
    }
}

Output:
         }
-        input.setAttribute("String_Node_Str", FileUtilities.nameToURL(indexFiles[i], null, null).toString());
+        try {
+            input.setAttribute("String_Node_Str", FileUtilities.nameToURL(indexFiles[i], null, null).toString());
+        } catch (MalformedURLException e) {
+            input.setAttribute("String_Node_Str", indexFiles[i]);
+        }
         group.addContent(input);


Input:
public static List<IEcosComponent> getAvailableComponentExtensions(String version, IEcosCategory categry, boolean reload) {
    List<IEcosComponent> extensions = new ArrayList<IEcosComponent>();
    try {
        List<RevisionInfo> revisions = EcosystemService.getRevisionList(categry.getId(), version);
        Map<String, IEcosComponent> extensionsMap = new HashMap<String, IEcosComponent>();
        for (RevisionInfo revision : revisions) {
            IEcosComponent extension = extensionsMap.get(revision.getExtension_name());
            if (extension == null) {
                extension = new EcosComponent();
                extension.setName(revision.getExtension_name());
                extension.setAuthor(revision.getAuthor_name());
                extension.setCategry(categry);
                extension.setDescription(revision.getExtension_description());
                extensionsMap.put(extension.getName(), extension);
                extensions.add(extension);
            }
            IRevision rev = convertRevision(revision);
            extension.getRevisions().add(rev);
            if (extension.getLatestRevision() == null || extension.getLatestRevision().getDate().before(rev.getDate())) {
                extension.setLatestRevision(rev);
            }
        }
    } catch (Exception e) {
        log.error(e, e);
    }
    return extensions;
}

Output:
         for (RevisionInfo revision : revisions) {
-            IEcosComponent extension = extensionsMap.get(revision.getExtension_name());
+            IEcosComponent extension = extensionsMap.get(revision.getExtensOnName());
             if (extension == null) {


Input:
public void run() {
    emotionOverlayFiller(1, newBottles, happyOverlay);
    emotionOverlayFiller(0, newBottles, sadOverlay);
    map.invalidate();
}

Output:
 public void run() {
-    emotionOverlayFiller(1, newBottles, happyOverlay);
-    emotionOverlayFiller(0, newBottles, sadOverlay);
+    emotionOverlayAdder(1, newBottles, happyOverlay);
+    emotionOverlayAdder(0, newBottles, sadOverlay);
     map.invalidate();


Input:
private void setFrame(int frame, boolean unschedule, boolean animate) {
    if (frame >= mAnimationState.getChildCount()) {
        return;
    }
    mCurFrame = frame;
    selectDrawable(frame);
    if (unschedule) {
        unscheduleSelf(this);
    }
    if (animate) {
        mCurFrame = frame;
        scheduleSelf(this, SystemClock.uptimeMillis() + mAnimationState.mDurations[frame]);
    }
}

Output:
     selectDrawable(frame);
-    if (unschedule) {
+    if (unschedule || animate) {
         unscheduleSelf(this);


Input:
public int clampViewPositionHorizontal(View child, int left, int dx) {
    int result = 0;
    if (dragEdge == DragEdge.LEFT && left > 0) {
        final int leftBound = getPaddingLeft();
        final int rightBound = horizontalDragRange;
        result = Math.min(Math.max(left, leftBound), rightBound);
    } else if (dragEdge == DragEdge.RIGHT && left < 0) {
        final int leftBound = -horizontalDragRange;
        final int rightBound = getPaddingLeft();
        result = Math.min(Math.max(left, leftBound), rightBound);
    }
    return result;
}

Output:
     int result = 0;
-    if (dragEdge == DragEdge.LEFT && left > 0) {
+    if (dragEdge == DragEdge.LEFT && !canChildScrollRight() && left > 0) {
         final int leftBound = getPaddingLeft();


Input:
public ItemToItemMap getSourceToTargetMap(MappableItem sourceItem, MappableItem targetItem) {
    Iterator<ItemToItemMap> iterator = sourceToTargetMaps.iterator();
    while (iterator.hasNext()) {
        ItemToItemMap sourceToTargetMap = iterator.next();
        if (sourceToTargetMap.getSourceItem().equals(sourceItem) && sourceToTargetMap.getTargetItem().equals(targetItem))
            return sourceToTargetMap;
    }
    return null;
}

Output:
 public ItemToItemMap getSourceToTargetMap(MappableItem sourceItem, MappableItem targetItem) {
-    Iterator<ItemToItemMap> iterator = sourceToTargetMaps.iterator();
+    Iterator<ItemToItemMap> iterator = sourceToCdmMaps.iterator();
     while (iterator.hasNext()) {


Input:
private Object decorateWidget(Field field) {
    Class<?> type = field.getType();
    if (!Widget.class.isAssignableFrom(type) && !List.class.isAssignableFrom(type)) {
        return null;
    }
    Class<? extends Widget> widgetType;
    boolean isAlist = false;
    if (List.class.isAssignableFrom(type)) {
        isAlist = true;
        Type genericType = field.getGenericType();
        if (!(genericType instanceof ParameterizedType)) {
            return null;
        }
        Type listType = ((ParameterizedType) genericType).getActualTypeArguments()[0];
        if (ParameterizedType.class.isAssignableFrom(listType.getClass())) {
            listType = ((ParameterizedType) listType).getRawType();
        }
        if (listType instanceof Class) {
            if (!Widget.class.isAssignableFrom((Class) listType)) {
                return null;
            }
            widgetType = Class.class.cast(listType);
        } else {
            return null;
        }
    } else {
        widgetType = (Class<? extends Widget>) field.getType();
    }
    CacheableLocator locator = widgetLocatorFactory.createLocator(field);
    Map<ContentType, Constructor<? extends Widget>> map = OverrideWidgetReader.read(widgetType, field, platform, automation);
    if (isAlist) {
        return getEnhancedProxy(ArrayList.class, new WidgetListInterceptor(locator, originalDriver, map, widgetType, timeOutDuration));
    }
    Constructor<? extends Widget> constructor = WidgetConstructorUtil.findConvenientConstructor(widgetType);
    return getEnhancedProxy(widgetType, new Class[] { constructor.getParameterTypes()[0] }, new Object[] { proxyForAnElement(locator) }, new WidgetInterceptor(locator, originalDriver, null, map, timeOutDuration));
}

Output:
     if (isAlist) {
-        return getEnhancedProxy(ArrayList.class, new WidgetListInterceptor(locator, originalDriver, map, widgetType, timeOutDuration));
+        return getEnhancedProxy(ArrayList.class, new WidgetListInterceptor(locator, originalDriver, map, widgetType, duration));
     }


Input:
public int runJob() throws Exception {
    final Configuration conf = super.getConf();
    GeoWaveConfiguratorBase.setRemoteInvocationParams(kdeCommandLineOptions.getHdfsHostPort(), kdeCommandLineOptions.getJobTrackerOrResourceManHostPort(), conf);
    conf.setInt(MAX_LEVEL_KEY, kdeCommandLineOptions.getMaxLevel());
    conf.setInt(MIN_LEVEL_KEY, kdeCommandLineOptions.getMinLevel());
    conf.set(COVERAGE_NAME_KEY, kdeCommandLineOptions.getCoverageName());
    conf.setInt(TILE_SIZE_KEY, kdeCommandLineOptions.getTileSize());
    if (kdeCommandLineOptions.getCqlFilter() != null) {
        conf.set(GaussianCellMapper.CQL_FILTER_KEY, kdeCommandLineOptions.getCqlFilter());
    }
    preJob1Setup(conf);
    final Job job = new Job(conf);
    job.setJarByClass(this.getClass());
    addJobClasspathDependencies(job, conf);
    job.setJobName(getJob1Name());
    job.setMapperClass(getJob1Mapper());
    job.setCombinerClass(CellSummationCombiner.class);
    job.setReducerClass(getJob1Reducer());
    job.setMapOutputKeyClass(LongWritable.class);
    job.setMapOutputValueClass(DoubleWritable.class);
    job.setOutputKeyClass(DoubleWritable.class);
    job.setOutputValueClass(LongWritable.class);
    job.setInputFormatClass(GeoWaveInputFormat.class);
    job.setOutputFormatClass(SequenceFileOutputFormat.class);
    job.setNumReduceTasks(8);
    job.setSpeculativeExecution(false);
    final AdapterStore adapterStore = inputAdapterStoreOptions.createStore();
    GeoWaveInputFormat.addDataAdapter(job.getConfiguration(), adapterStore.getAdapter(new ByteArrayId(kdeCommandLineOptions.getFeatureType())));
    GeoWaveInputFormat.setMinimumSplitCount(job.getConfiguration(), kdeCommandLineOptions.getMinSplits());
    GeoWaveInputFormat.setMaximumSplitCount(job.getConfiguration(), kdeCommandLineOptions.getMaxSplits());
    GeoWaveInputFormat.setDataStoreName(job.getConfiguration(), inputDataStoreOptions.getFactory().getName());
    GeoWaveInputFormat.setStoreConfigOptions(job.getConfiguration(), ConfigUtils.valuesToStrings(inputDataStoreOptions.getConfigOptions(), inputDataStoreOptions.getFactory().getOptions()));
    GeoWaveInputFormat.setGeoWaveNamespace(job.getConfiguration(), inputDataStoreOptions.getNamespace());
    if (kdeCommandLineOptions.getCqlFilter() != null) {
        final Filter filter = ECQL.toFilter(kdeCommandLineOptions.getCqlFilter());
        final Geometry bbox = (Geometry) filter.accept(ExtractGeometryFilterVisitor.GEOMETRY_VISITOR, null);
        if ((bbox != null) && !bbox.equals(GeometryUtils.infinity())) {
            GeoWaveInputFormat.setQuery(job.getConfiguration(), new SpatialQuery(bbox));
        }
    }
    final FileSystem fs = FileSystem.get(conf);
    fs.delete(new Path("String_Node_Str" + inputDataStoreOptions.getNamespace() + "String_Node_Str" + kdeCommandLineOptions.getMinLevel() + "String_Node_Str" + kdeCommandLineOptions.getMaxLevel() + "String_Node_Str" + kdeCommandLineOptions.getCoverageName()), true);
    FileOutputFormat.setOutputPath(job, new Path("String_Node_Str" + inputDataStoreOptions.getNamespace() + "String_Node_Str" + kdeCommandLineOptions.getMinLevel() + "String_Node_Str" + kdeCommandLineOptions.getMaxLevel() + "String_Node_Str" + kdeCommandLineOptions.getCoverageName() + "String_Node_Str"));
    final boolean job1Success = job.waitForCompletion(true);
    boolean job2Success = false;
    boolean postJob2Success = false;
    if (job1Success) {
        setupEntriesPerLevel(job, conf);
        final Job statsReducer = new Job(conf);
        statsReducer.setJarByClass(this.getClass());
        addJobClasspathDependencies(statsReducer, conf);
        statsReducer.setJobName(getJob2Name());
        statsReducer.setMapperClass(IdentityMapper.class);
        statsReducer.setPartitionerClass(getJob2Partitioner());
        statsReducer.setReducerClass(getJob2Reducer());
        statsReducer.setNumReduceTasks(getJob2NumReducers((kdeCommandLineOptions.getMaxLevel() - kdeCommandLineOptions.getMinLevel()) + 1));
        statsReducer.setMapOutputKeyClass(DoubleWritable.class);
        statsReducer.setMapOutputValueClass(LongWritable.class);
        statsReducer.setOutputKeyClass(getJob2OutputKeyClass());
        statsReducer.setOutputValueClass(getJob2OutputValueClass());
        statsReducer.setInputFormatClass(SequenceFileInputFormat.class);
        statsReducer.setOutputFormatClass(getJob2OutputFormatClass());
        FileInputFormat.setInputPaths(statsReducer, new Path("String_Node_Str" + inputDataStoreOptions.getNamespace() + "String_Node_Str" + kdeCommandLineOptions.getMinLevel() + "String_Node_Str" + kdeCommandLineOptions.getMaxLevel() + "String_Node_Str" + kdeCommandLineOptions.getCoverageName() + "String_Node_Str"));
        setupJob2Output(conf, statsReducer, outputDataStoreOptions.getNamespace());
        job2Success = statsReducer.waitForCompletion(true);
        if (job2Success) {
            postJob2Success = postJob2Actions(conf, outputDataStoreOptions.getNamespace());
        }
    } else {
        job2Success = false;
    }
    fs.delete(new Path("String_Node_Str" + inputDataStoreOptions.getNamespace() + "String_Node_Str" + kdeCommandLineOptions.getMinLevel() + "String_Node_Str" + kdeCommandLineOptions.getMaxLevel() + "String_Node_Str" + kdeCommandLineOptions.getCoverageName()), true);
    return (job1Success && job2Success && postJob2Success) ? 0 : 1;
}

Output:
 public int runJob() throws Exception {
-    final Configuration conf = super.getConf();
+    Configuration conf = super.getConf();
+    if (conf == null) {
+        conf = new Configuration();
+        setConf(conf);
+    }
     GeoWaveConfiguratorBase.setRemoteInvocationParams(kdeCommandLineOptions.getHdfsHostPort(), kdeCommandLineOptions.getJobTrackerOrResourceManHostPort(), conf);


Input:
public JSObjectMetaData getReturn() {
    return new ExtensionClassJSObject(method.getClassReturnType());
}

Output:
 public JSObjectMetaData getReturn() {
-    return new ExtensionClassJSObject(method.getClassReturnType());
+    IClassInfo rtInfo = method.getClassReturnType();
+    if (rtInfo != null) {
+        return new ExtensionClassJSObject(method.getClassReturnType());
+    }
+    return null;
 }


Input:
protected void sendOnTerminateErrorMessageInInitialContext(int code, String description) throws IOException {
    if (useControlProtocol) {
        protocolManager.sendJsonError(initialAsyncCtx, JsonRpcResponse.newError(code, description, initialJsonRequest.getId()));
    } else {
        ((HttpServletResponse) initialAsyncCtx.getResponse()).sendError(code, description);
    }
}

Output:
     } else {
-        ((HttpServletResponse) initialAsyncCtx.getResponse()).sendError(code, description);
+        ((HttpServletResponse) initialAsyncCtx.getResponse()).sendError(500, description);
     }


Input:
private void deleteRepositoryNode(IRepositoryNode repositoryNode, IProxyRepositoryFactory factory) throws PersistenceException, BusinessException {
    if (repositoryNode.getType() == ENodeType.SIMPLE_FOLDER) {
        IPath path = RepositoryNodeUtilities.getPath((RepositoryNode) repositoryNode);
        ERepositoryObjectType objectType = (ERepositoryObjectType) repositoryNode.getProperties(EProperties.CONTENT_TYPE);
        List<IRepositoryNode> repositoryList = repositoryNode.getChildren();
        PersistenceException pex = null;
        BusinessException bex = null;
        for (IRepositoryNode repositoryNode2 : repositoryList) {
            try {
                deleteRepositoryNode(repositoryNode2, factory);
            } catch (PersistenceException e) {
                pex = e;
            } catch (BusinessException e) {
                bex = e;
            }
        }
        if (pex != null) {
            throw pex;
        }
        if (bex != null) {
            throw bex;
        }
        FolderItem folderItem = factory.getFolderItem(ProjectManager.getInstance().getCurrentProject(), objectType, path);
        folderItem.getState().setDeleted(true);
        String fullPath = "String_Node_Str";
        FolderItem curItem = folderItem;
        while (curItem.getParent() instanceof FolderItem && ((Item) curItem.getParent()).getParent() instanceof FolderItem) {
            FolderItem parentFolder = (FolderItem) curItem.getParent();
            if ("String_Node_Str".equals(fullPath)) {
                fullPath = parentFolder.getProperty().getLabel() + fullPath;
            } else {
                fullPath = parentFolder.getProperty().getLabel() + "String_Node_Str" + fullPath;
            }
            curItem = parentFolder;
        }
        folderItem.getState().setPath(fullPath);
    } else {
        IRepositoryViewObject objToDelete = repositoryNode.getObject();
        IDesignerCoreService coreService = (IDesignerCoreService) GlobalServiceRegister.getDefault().getService(IDesignerCoreService.class);
        if (coreService != null && objToDelete != null && objToDelete.getProperty() != null) {
            Item item = objToDelete.getProperty().getItem();
            IProcess iProcess = coreService.getProcessFromItem(item);
            if (iProcess != null && iProcess instanceof IProcess2) {
                IProcess2 process = (IProcess2) iProcess;
                process.removeProblems4ProcessDeleted();
            }
        }
        factory.deleteObjectLogical(objToDelete);
    }
}

Output:
         IRepositoryViewObject objToDelete = repositoryNode.getObject();
-        IDesignerCoreService coreService = (IDesignerCoreService) GlobalServiceRegister.getDefault().getService(IDesignerCoreService.class);
-        if (coreService != null && objToDelete != null && objToDelete.getProperty() != null) {
-            Item item = objToDelete.getProperty().getItem();
-            IProcess iProcess = coreService.getProcessFromItem(item);
-            if (iProcess != null && iProcess instanceof IProcess2) {
-                IProcess2 process = (IProcess2) iProcess;
-                process.removeProblems4ProcessDeleted();
+        if (GlobalServiceRegister.getDefault().isServiceRegistered(IDesignerCoreService.class)) {
+            IDesignerCoreService coreService = (IDesignerCoreService) GlobalServiceRegister.getDefault().getService(IDesignerCoreService.class);
+            if (coreService != null && objToDelete != null && objToDelete.getProperty() != null) {
+                Item item = objToDelete.getProperty().getItem();
+                IProcess iProcess = coreService.getProcessFromItem(item);
+                if (iProcess != null && iProcess instanceof IProcess2) {
+                    IProcess2 process = (IProcess2) iProcess;
+                    process.removeProblems4ProcessDeleted();
+                }
             }


Input:
private void appendRuntimeNode(final RuntimeNode node, final String draw, final boolean isLast, final Writer writer) throws IOException {
    if (node.className != null) {
        writer.append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(draw).append(isLast ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(node.className).append("String_Node_Str").append("String_Node_Str").append(node.methodName).append("String_Node_Str").append("String_Node_Str");
        long time = node.timeStopped == 0 ? 0 : (node.timeStopped - node.timeStarted) / 1000;
        writer.append("String_Node_Str").append(time == 0 ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str").append(time == 0 ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str").append(time == 0 ? "String_Node_Str" : Long.toString(time) + "String_Node_Str").append("String_Node_Str");
    }
    if (!node.children.isEmpty()) {
        writer.append("String_Node_Str");
        for (final RuntimeNode childNode : node.children) {
            appendRuntimeNode(childNode, node.className == null ? draw : draw + (isLast ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str", node.children.indexOf(childNode) == node.children.size() - 1, writer);
        }
        writer.append("String_Node_Str");
    }
    if (node.className != null) {
        writer.append("String_Node_Str");
    }
}

Output:
         writer.append("String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(draw).append(isLast ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str").append("String_Node_Str").append(node.className).append("String_Node_Str").append("String_Node_Str").append(node.methodName).append("String_Node_Str").append("String_Node_Str");
-        long time = node.timeStopped == 0 ? 0 : (node.timeStopped - node.timeStarted) / 1000;
+        long time = node.timeStopped == 0 ? 0 : (node.timeStopped - node.timeStarted) / TO_MILLIS_DIVISOR;
         writer.append("String_Node_Str").append(time == 0 ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str").append(time == 0 ? "String_Node_Str" : "String_Node_Str").append("String_Node_Str").append(time == 0 ? "String_Node_Str" : Long.toString(time) + "String_Node_Str").append("String_Node_Str");


Input:
protected ID extractId(T entity) {
    Class<?> entityClass = TypeHelper.getTypeArguments(JpaBaseRepository.class, this.getClass()).get(0);
    SessionFactory sf = ((HibernateEntityManagerFactory) getEntityManager().getEntityManagerFactory()).getSessionFactory();
    ClassMetadata cmd = sf.getClassMetadata(entityClass);
    ID result = (ID) cmd.getIdentifier(entity, (SessionImplementor) ((HibernateEntityManagerFactory) getEntityManager().getDelegate()));
    return result;
}

Output:
 protected ID extractId(T entity) {
-    Class<?> entityClass = TypeHelper.getTypeArguments(JpaBaseRepository.class, this.getClass()).get(0);
-    SessionFactory sf = ((HibernateEntityManagerFactory) getEntityManager().getEntityManagerFactory()).getSessionFactory();
-    ClassMetadata cmd = sf.getClassMetadata(entityClass);
-    ID result = (ID) cmd.getIdentifier(entity, (SessionImplementor) ((HibernateEntityManagerFactory) getEntityManager().getDelegate()));
+    final Class<?> entityClass = TypeHelper.getTypeArguments(JpaBaseRepository.class, this.getClass()).get(0);
+    final SessionFactory sf = ((HibernateEntityManagerFactory) getEntityManager().getEntityManagerFactory()).getSessionFactory();
+    final ClassMetadata cmd = sf.getClassMetadata(entityClass);
+    final SessionImplementor si = (SessionImplementor) (getEntityManager().getDelegate());
+    final ID result = (ID) cmd.getIdentifier(entity, si);
     return result;


Input:
private void closeCamera() {
    Log.v(TAG, "String_Node_Str");
    if (mCameraDevice != null) {
        mCameraDevice.setZoomChangeListener(null);
        mCameraDevice.setFaceDetectionCallback(null, null);
        mCameraDevice.setErrorCallback(null);
        if (mActivity.isSecureCamera() && !CameraActivity.isFirstStartAfterScreenOn()) {
            CameraHolder.instance().strongRelease();
        } else {
            CameraHolder.instance().release();
        }
        mFaceDetectionStarted = false;
        mCameraDevice = null;
        setCameraState(PREVIEW_STOPPED);
        if (mFocusManager != null) {
            mFocusManager.onCameraReleased();
        }
    }
}

Output:
         mCameraDevice.setErrorCallback(null);
-        if (mActivity.isSecureCamera() && !CameraActivity.isFirstStartAfterScreenOn()) {
+        if (mActivity.isSecureCamera()) {
             CameraHolder.instance().strongRelease();


Input:
public void onResume() {
    super.onResume();
    mProgressHandler = new Handler() {
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch(msg.what) {
                case FILEBROWSER_MESSAGE_UPDATE_LIST:
                    if (mListLoaded == false) {
                        break;
                    }
                    mListView.setAdapter(getFileListAdapterSorted(mCurrentPath, mSortType));
                    mListLoaded = false;
                    break;
                default:
                    break;
            }
        }
    };
    if (mListLoaded == true) {
        mListLoaded = false;
    }
    if (mCurrentPath.equals(ROOT)) {
        DeviceScan();
    } else {
        mListView.setAdapter(getFileListAdapterSorted(mCurrentPath, mSortType));
    }
    mListView.setSelectionFromTop(mItemSelected, mItemTop);
}

Output:
     super.onResume();
-    mProgressHandler = new Handler() {
-        public void handleMessage(Message msg) {
-            super.handleMessage(msg);
-            switch(msg.what) {
-                case FILEBROWSER_MESSAGE_UPDATE_LIST:
-                    if (mListLoaded == false) {
-                        break;
-                    }
-                    mListView.setAdapter(getFileListAdapterSorted(mCurrentPath, mSortType));
-                    mListLoaded = false;
-                    break;
-                default:
-                    break;
-            }
-        }
-    };
-    if (mListLoaded == true) {
-        mListLoaded = false;
-    }
+    mLoadCancel = false;
+    Log.i(TAG, "String_Node_Str");
     if (mCurrentPath.equals(ROOT)) {


Input:
public void replayExport(ActionRequest request, ActionResponse response) {
    MoveLineReport moveLineReport = request.getContext().asType(MoveLineReport.class);
    moveLineReport = moveLineReportRepo.find(moveLineReport.getId());
    MoveLineExportService moveLineExportService = Beans.get(MoveLineExportService.class);
    try {
        switch(moveLineReport.getTypeSelect()) {
            case 6:
                moveLineExportService.exportMoveLineTypeSelect6(moveLineReport, true);
                break;
            case 7:
                moveLineExportService.exportMoveLineTypeSelect7(moveLineReport, true);
                break;
            case 8:
                moveLineExportService.exportMoveLineTypeSelect8(moveLineReport, true);
                break;
            case 9:
                moveLineExportService.exportMoveLineTypeSelect9(moveLineReport, true);
                break;
            default:
                break;
        }
    } catch (Exception e) {
        TraceBackService.trace(response, e);
    }
}

Output:
         switch(moveLineReport.getTypeSelect()) {
-            case 6:
-                moveLineExportService.exportMoveLineTypeSelect6(moveLineReport, true);
+            case MoveLineReportRepository.EXPORT_SALES:
+                moveLineExportService.exportMoveLineTypeSelect1006(moveLineReport, true);
                 break;


Input:
protected void doCommit() {
    dataSource.getWriteLock();
    try {
        for (Map.Entry<IndexIdentifier, CommandList> entry : this.commandMap.entrySet()) {
            IndexIdentifier identifier = entry.getKey();
            IndexType type = dataSource.getType(identifier);
            IndexWriter writer = null;
            IndexSearcher searcher = null;
            CommandList commandList = entry.getValue();
            Map<Long, DocumentContext> documents = new HashMap<Long, DocumentContext>();
            for (LuceneCommand command : commandList.commands) {
                if (writer == null) {
                    writer = dataSource.getIndexWriter(identifier);
                    writer.setMaxBufferedDocs(commandList.addCount + 100);
                    writer.setMaxBufferedDeleteTerms(commandList.removeCount + 100);
                    searcher = dataSource.getIndexSearcher(identifier).getSearcher();
                }
                long entityId = command.getEntityId();
                DocumentContext context = documents.get(entityId);
                if (context == null) {
                    Document document = LuceneDataSource.findDocument(type, searcher, entityId);
                    context = document == null ? new DocumentContext(type.newDocument(entityId), false, entityId) : new DocumentContext(document, true, entityId);
                    documents.put(entityId, context);
                }
                String key = command.getKey();
                String value = command.getValue();
                if (command instanceof AddCommand) {
                    type.addToDocument(context.document, key, value);
                    dataSource.invalidateCache(identifier, key, value);
                } else if (command instanceof RemoveCommand) {
                    type.removeFromDocument(context.document, key, value);
                    dataSource.invalidateCache(identifier, key, value);
                } else if (command instanceof ClearCommand) {
                    documents.clear();
                    dataSource.closeWriter(writer);
                    writer = null;
                    dataSource.closeIndexSearcher(identifier);
                    dataSource.invalidateCache(identifier);
                } else {
                    throw new RuntimeException("String_Node_Str" + command + "String_Node_Str" + command.getClass());
                }
            }
            applyDocuments(writer, type, documents);
            if (writer != null) {
                dataSource.closeWriter(writer);
            }
            dataSource.invalidateIndexSearcher(identifier);
        }
        closeTxData();
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        dataSource.releaseWriteLock();
    }
}

Output:
                     writer = null;
-                    dataSource.closeIndexSearcher(identifier);
+                    dataSource.deleteIndex(identifier);
                     dataSource.invalidateCache(identifier);


Input:
public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event) {
    long start = Util.timeMS();
    String Contrib = event.getMessage();
    Contrib = Contrib.replaceAll("String_Node_Str", "String_Node_Str");
    if (!ZBukkitContrib.checkCommand(Contrib)) {
        String[] split = event.getMessage().split("String_Node_Str");
        Player player = event.getPlayer();
        if (split[0].equalsIgnoreCase(Config.commands_login) || split[0].equalsIgnoreCase(Config.aliases_login)) {
            if (ZPermissions.isAllowed(player, Permission.command_login)) {
                if (this.plugin.isRegistered("String_Node_Str", player.getName()) == false || this.plugin.isRegistered("String_Node_Str", Util.checkOtherName(player.getName())) == false) {
                    Messages.sendMessage(Message.login_notregistered, player, null);
                } else if (plugin.isAuthorized(player)) {
                    Messages.sendMessage(Message.login_authorized, player, null);
                } else if (split.length < 2) {
                    Messages.sendMessage(Message.login_usage, player, null);
                } else if (this.plugin.checkPassword(player.getName(), split[1])) {
                    Processes.Login(player);
                    Messages.sendMessage(Message.login_success, player, null);
                } else {
                    if (Config.authdb_enabled) {
                        Messages.sendMessage(Message.login_failure, player, null);
                    } else {
                        Messages.sendMessage(Message.login_offline, player, null);
                    }
                }
                Util.logging.Debug(player.getName() + "String_Node_Str");
                event.setMessage(Config.commands_login + "String_Node_Str");
                event.setCancelled(true);
            } else {
                Messages.sendMessage(Message.protection_denied, player, null);
            }
        } else if (split[0].equalsIgnoreCase(Config.commands_link) || split[0].equalsIgnoreCase(Config.aliases_link)) {
            if (Config.link_enabled) {
                if (ZPermissions.isAllowed(player, Permission.command_link)) {
                    if (split.length == 3) {
                        if (!player.getName().equals(split[1])) {
                            if (this.plugin.isRegistered("String_Node_Str", player.getName()) == false) {
                                if (Util.checkOtherName(player.getName()).equals(player.getName())) {
                                    EBean eBeanClass = EBean.checkPlayer(split[1], true);
                                    String linkedname = eBeanClass.getLinkedname();
                                    if (linkedname != null) {
                                        Messages.sendMessage(Message.link_duplicate, player, null);
                                    } else if (this.plugin.checkPassword(split[1], split[2])) {
                                        Processes.Link(player, split[1]);
                                        Messages.sendMessage(Message.link_success, player, null);
                                    } else {
                                        Messages.sendMessage(Message.link_failure, player, null);
                                    }
                                } else {
                                    Messages.sendMessage(Message.link_exists, player, null);
                                }
                            } else {
                                Messages.sendMessage(Message.link_registred, player, null);
                            }
                        } else {
                            Messages.sendMessage(Message.link_invaliduser, player, null);
                        }
                    } else {
                        Messages.sendMessage(Message.link_usage, player, null);
                    }
                    Util.logging.Debug(player.getName() + "String_Node_Str");
                    event.setMessage(Config.commands_link + "String_Node_Str");
                    event.setCancelled(true);
                } else {
                    Messages.sendMessage(Message.protection_denied, player, null);
                }
            }
        } else if (split[0].equalsIgnoreCase(Config.commands_unlink) || split[0].equalsIgnoreCase(Config.aliases_unlink)) {
            if (Config.unlink_enabled) {
                if (ZPermissions.isAllowed(player, Permission.command_unlink)) {
                    if (split.length == 3) {
                        if (Util.checkOtherName(player.getName()).equals(player.getDisplayName())) {
                            EBean eBeanClass = EBean.checkPlayer(player, true);
                            String linkedname = eBeanClass.getLinkedname();
                            if (linkedname.equals(split[1])) {
                                if (this.plugin.checkPassword(split[1], split[2])) {
                                    Processes.Unlink(player, split[1]);
                                    Messages.sendMessage(Message.unlink_success, player, null);
                                } else {
                                    Messages.sendMessage(Message.unlink_invalidpass, player, null);
                                }
                            } else {
                                Messages.sendMessage(Message.unlink_invaliduser, player, null);
                            }
                        } else {
                            Messages.sendMessage(Message.unlink_nonexist, player, null);
                        }
                    } else {
                        Messages.sendMessage(Message.unlink_usage, player, null);
                    }
                    Util.logging.Debug(player.getName() + "String_Node_Str");
                    event.setMessage(Config.commands_unlink + "String_Node_Str");
                    event.setCancelled(true);
                } else {
                    Messages.sendMessage(Message.protection_denied, player, null);
                }
            }
        } else if (split[0].equalsIgnoreCase(Config.commands_register) || split[0].equalsIgnoreCase(Config.aliases_register)) {
            if (ZPermissions.isAllowed(player, Permission.command_register)) {
                Boolean email = true;
                if (Config.custom_enabled) {
                    email = Config.custom_emailrequired;
                }
                if (Config.custom_emailfield == null || Config.custom_emailfield == "String_Node_Str") {
                    email = false;
                }
                if (!Config.register_enabled) {
                    Messages.sendMessage(Message.register_disabled, player, null);
                } else if (this.plugin.isRegistered("String_Node_Str", player.getName()) || this.plugin.isRegistered("String_Node_Str", Util.checkOtherName(player.getName()))) {
                    Messages.sendMessage(Message.register_exists, player, null);
                } else if (split.length < 2) {
                    Messages.sendMessage(Message.register_usage, player, null);
                } else if (split.length < 3 && email) {
                    Messages.sendMessage(Message.email_required, player, null);
                } else if ((split.length >= 3 && email) && (!this.plugin.checkEmail(split[2]))) {
                    Messages.sendMessage(Message.email_invalid, player, null);
                } else {
                    try {
                        if (split.length >= 3 || (!email && split.length >= 2)) {
                            String themail = null;
                            if (!email) {
                                themail = null;
                            } else {
                                themail = split[2];
                            }
                            if (this.plugin.register(player, split[1], themail, Util.craftFirePlayer.getIP(player))) {
                                if (Processes.Login(player)) {
                                    Messages.sendMessage(Message.register_success, player, null);
                                } else {
                                    Messages.sendMessage(Message.register_failure, player, null);
                                    Util.logging.Debug("String_Node_Str");
                                }
                            }
                        }
                    } catch (IOException e) {
                        Messages.sendMessage(Message.register_failure, player, null);
                        Util.logging.StackTrace(e.getStackTrace(), Thread.currentThread().getStackTrace()[1].getMethodName(), Thread.currentThread().getStackTrace()[1].getLineNumber(), Thread.currentThread().getStackTrace()[1].getClassName(), Thread.currentThread().getStackTrace()[1].getFileName());
                    } catch (SQLException e) {
                        Messages.sendMessage(Message.register_failure, player, null);
                        Util.logging.StackTrace(e.getStackTrace(), Thread.currentThread().getStackTrace()[1].getMethodName(), Thread.currentThread().getStackTrace()[1].getLineNumber(), Thread.currentThread().getStackTrace()[1].getClassName(), Thread.currentThread().getStackTrace()[1].getFileName());
                    }
                }
                Util.logging.Debug(player.getName() + "String_Node_Str");
                event.setMessage(Config.commands_register + "String_Node_Str");
                event.setCancelled(true);
            } else {
                Messages.sendMessage(Message.protection_denied, player, null);
            }
        } else if (!plugin.isAuthorized(player)) {
            if (!checkGuest(player, Config.guests_commands)) {
                event.setMessage("String_Node_Str");
                event.setCancelled(true);
            }
        }
    } else {
        Util.logging.Debug("String_Node_Str" + event.getMessage());
    }
    long stop = Util.timeMS();
    Util.logging.timeUsage(stop - start, "String_Node_Str");
}

Output:
         Player player = event.getPlayer();
-        if (split[0].equalsIgnoreCase(Config.commands_login) || split[0].equalsIgnoreCase(Config.aliases_login)) {
+        if (split[0].equalsIgnoreCase(Config.commands_user_login) || split[0].equalsIgnoreCase(Config.aliases_user_login)) {
             if (ZPermissions.isAllowed(player, Permission.command_login)) {


Input:
public List<Object[]> executeQuery(DataManager connection, List<ModelElement> analysedElements) throws SQLException {
    dataFromTable.clear();
    try {
        beginQuery();
    } catch (Exception e1) {
        log.error(e1.getMessage(), e1);
        return dataFromTable;
    }
    int columnListSize = analysedElements.size();
    TypedReturnCode<java.sql.Connection> sqlconnection = JavaSqlFactory.createConnection((Connection) connection);
    if (!sqlconnection.isOk()) {
        MessageDialogWithToggle.openWarning(Display.getCurrent().getActiveShell(), Messages.getString("String_Node_Str"), sqlconnection.getMessage());
        throw new SQLException(sqlconnection.getMessage());
    }
    Statement statement = null;
    ResultSet resultSet = null;
    try {
        statement = sqlconnection.getObject().createStatement();
        statement.execute(createSqlStatement(connection, analysedElements));
        resultSet = statement.getResultSet();
        while (resultSet.next()) {
            Object[] oneRow = new Object[columnListSize];
            for (int i = 0; i < columnListSize; i++) {
                oneRow[i] = resultSet.getObject(i + 1);
            }
            handleRow(oneRow);
        }
    } catch (Exception e) {
        log.error(e, e);
    } finally {
        if (resultSet != null) {
            resultSet.close();
        }
        if (statement != null) {
            statement.close();
        }
        ReturnCode closed = ConnectionUtils.closeConnection(sqlconnection.getObject());
        if (!closed.isOk()) {
            log.error(closed.getMessage());
        }
    }
    try {
        endQuery();
    } catch (Exception e) {
        log.error(e.getMessage(), e);
    }
    return dataFromTable;
}

Output:
     int columnListSize = analysedElements.size();
-    TypedReturnCode<java.sql.Connection> sqlconnection = JavaSqlFactory.createConnection((Connection) connection);
-    if (!sqlconnection.isOk()) {
-        MessageDialogWithToggle.openWarning(Display.getCurrent().getActiveShell(), Messages.getString("String_Node_Str"), sqlconnection.getMessage());
-        throw new SQLException(sqlconnection.getMessage());
-    }
+    TypedReturnCode<java.sql.Connection> sqlconnection = getSQLConnection(connection);
     Statement statement = null;


Input:
public boolean checkStatus(AzureResourcePollerObject t) {
    List<HttpResponseDecorator> responses = t.getResponses();
    boolean result = true;
    Iterator<HttpResponseDecorator> iterator = responses.iterator();
    while (iterator.hasNext()) {
        HttpResponseDecorator response = iterator.next();
        String requestId = getRequestId(response);
        String requestStatus = String.valueOf(t.getAzureClient().getRequestStatus(requestId));
        JsonNode jsonFromString = jsonHelper.createJsonFromString(requestStatus);
        String status = jsonFromString.get("String_Node_Str").get("String_Node_Str").asText();
        if ("String_Node_Str".equals(status)) {
            result = false;
            break;
        } else if ("String_Node_Str".equals(status)) {
            throw new AzureResourceException(jsonFromString.get("String_Node_Str").get("String_Node_Str").get("String_Node_Str").asText());
        } else {
            iterator.remove();
        }
    }
    return result;
}

Output:
         } else if ("String_Node_Str".equals(status)) {
-            throw new AzureResourceException(jsonFromString.get("String_Node_Str").get("String_Node_Str").get("String_Node_Str").asText());
+            String error = jsonFromString.get("String_Node_Str").get("String_Node_Str").get("String_Node_Str").asText();
+            throw new AzureResourceException(error);
         } else {


Input:
public ArrayList<Property> getPropertyPropertiesForClass(JavaClass cls, TypeInfo info, boolean onlyPublic) {
    ArrayList properties = new ArrayList();
    if (cls == null) {
        return properties;
    }
    ArrayList<JavaMethod> getMethods = new ArrayList<JavaMethod>();
    for (JavaMethod next : new ArrayList<JavaMethod>(cls.getDeclaredMethods())) {
        if ((next.getName().startsWith("String_Node_Str") && next.getName().length() > 3) || (next.getName().startsWith("String_Node_Str") && next.getName().length() > 2)) {
            int modifiers = next.getModifiers();
            if (!Modifier.isStatic(modifiers) && !Modifier.isTransient(modifiers) && ((onlyPublic && Modifier.isPublic(next.getModifiers())) || !onlyPublic)) {
                getMethods.add(next);
            }
        }
    }
    boolean hasAnyAttribteProperty = false;
    for (int i = 0; i < getMethods.size(); i++) {
        JavaMethod getMethod = getMethods.get(i);
        String propertyName = "String_Node_Str";
        if (getMethod.getName().startsWith("String_Node_Str")) {
            propertyName = getMethod.getName().substring(3);
        } else if (getMethod.getName().startsWith("String_Node_Str")) {
            propertyName = getMethod.getName().substring(2);
        }
        String setMethodName = "String_Node_Str" + propertyName;
        propertyName = Character.toLowerCase(propertyName.charAt(0)) + propertyName.substring(1);
        JavaClass[] paramTypes = { (JavaClass) getMethod.getReturnType() };
        JavaMethod setMethod = cls.getMethod(setMethodName, paramTypes);
        JavaMethod propertyMethod = null;
        if (setMethod != null && !setMethod.getAnnotations().isEmpty()) {
            if (!helper.isAnnotationPresent(setMethod, XmlTransient.class)) {
                propertyMethod = setMethod;
            }
        } else {
            if (!helper.isAnnotationPresent(getMethod, XmlTransient.class)) {
                propertyMethod = getMethod;
            }
        }
        Property property = null;
        if (helper.isAnnotationPresent(propertyMethod, XmlElements.class)) {
            property = new ChoiceProperty(helper);
        } else if (helper.isAnnotationPresent(propertyMethod, XmlAnyElement.class)) {
            property = new AnyProperty(helper);
        } else if (helper.isAnnotationPresent(propertyMethod, XmlElementRef.class) || helper.isAnnotationPresent(propertyMethod, XmlElementRefs.class)) {
            property = new ReferenceProperty(helper);
        } else {
            property = new Property(helper);
        }
        property.setElement(propertyMethod);
        property.setSchemaName(getQNameForProperty(propertyName, propertyMethod, getNamespaceInfoForPackage(cls.getPackage())));
        property.setPropertyName(propertyName);
        JavaClass returnClass = (JavaClass) getMethod.getReturnType();
        if (!helper.isAnnotationPresent(returnClass, XmlTransient.class)) {
            property.setType(returnClass);
        } else {
            JavaClass parent = returnClass.getSuperclass();
            while (parent != null) {
                if (parent.getClass().getName().equals("String_Node_Str")) {
                    property.setType(parent);
                    break;
                }
                if (!helper.isAnnotationPresent(parent, XmlTransient.class)) {
                    property.setType(parent);
                    break;
                }
                parent = parent.getSuperclass();
            }
        }
        property.setGenericType(helper.getGenericReturnType(getMethod));
        property.setGetMethodName(getMethod.getName());
        property.setSetMethodName(setMethodName);
        property.setMethodProperty(true);
        JavaClass ptype = property.getType();
        if (helper.isAnnotationPresent(property.getElement(), XmlJavaTypeAdapter.class)) {
            XmlJavaTypeAdapter adapter = (XmlJavaTypeAdapter) helper.getAnnotation(property.getElement(), XmlJavaTypeAdapter.class);
            property.setAdapterClass(adapter.value());
        } else if (info.getAdaptersByClass().get(ptype) != null) {
            property.setAdapterClass(info.getAdaptersByClass().get(ptype));
        }
        if (property.hasAdapterClass()) {
            ptype = property.getValueType();
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlSchemaType.class)) {
            XmlSchemaType schemaType = (XmlSchemaType) helper.getAnnotation(property.getElement(), XmlSchemaType.class);
            QName schemaTypeQname = new QName(schemaType.namespace(), schemaType.name());
            property.setSchemaType(schemaTypeQname);
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlAttachmentRef.class) && areEquals(ptype, JAVAX_ACTIVATION_DATAHANDLER)) {
            property.setIsSwaAttachmentRef(true);
            property.setSchemaType(XMLConstants.SWA_REF_QNAME);
        } else if (areEquals(ptype, JAVAX_ACTIVATION_DATAHANDLER) || areEquals(ptype, byte[].class) || areEquals(ptype, Byte[].class) || areEquals(ptype, Image.class) || areEquals(ptype, Source.class) || areEquals(ptype, JAVAX_MAIL_INTERNET_MIMEMULTIPART)) {
            property.setIsMtomAttachment(true);
            property.setSchemaType(XMLConstants.BASE_64_BINARY_QNAME);
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlMimeType.class)) {
            property.setMimeType(((XmlMimeType) helper.getAnnotation(property.getElement(), XmlMimeType.class)).value());
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlJavaTypeAdapter.class)) {
            XmlJavaTypeAdapter adapter = (XmlJavaTypeAdapter) helper.getAnnotation(property.getElement(), XmlJavaTypeAdapter.class);
            property.setAdapterClass(adapter.value());
        } else if (info.getAdaptersByClass().get(ptype) != null) {
            property.setAdapterClass(info.getAdaptersByClass().get(ptype));
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlAttribute.class)) {
            property.setIsAttribute(true);
            property.setIsRequired(((XmlAttribute) helper.getAnnotation(property.getElement(), XmlAttribute.class)).required());
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlAnyAttribute.class)) {
            if (hasAnyAttribteProperty) {
                throw org.eclipse.persistence.exceptions.JAXBException.multipleAnyAttributeMapping(cls.getName());
            }
            if (!ptype.getName().equals("String_Node_Str")) {
                throw org.eclipse.persistence.exceptions.JAXBException.anyAttributeOnNonMap(property.getPropertyName());
            }
            property.setIsAttribute(true);
            hasAnyAttribteProperty = true;
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlElements.class)) {
            XmlElements xmlElements = (XmlElements) helper.getAnnotation(property.getElement(), XmlElements.class);
            XmlElement[] elements = xmlElements.value();
            ArrayList<Property> choiceProperties = new ArrayList<Property>(elements.length);
            for (int j = 0; j < elements.length; j++) {
                XmlElement next = elements[j];
                Property choiceProp = new Property();
                String name = next.name();
                String namespace = next.namespace();
                QName qName = null;
                if (!namespace.equals("String_Node_Str")) {
                    qName = new QName(namespace, name);
                } else {
                    qName = new QName(name);
                }
                choiceProp.setPropertyName(property.getPropertyName());
                choiceProp.setType(helper.getJavaClass(next.type()));
                choiceProp.setSchemaName(qName);
                choiceProp.setSchemaType(getSchemaTypeFor(helper.getJavaClass(next.type())));
                choiceProp.setElement(property.getElement());
                choiceProperties.add(choiceProp);
            }
            ((ChoiceProperty) property).setChoiceProperties(choiceProperties);
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlAnyElement.class)) {
            XmlAnyElement anyElement = (XmlAnyElement) helper.getAnnotation(property.getElement(), XmlAnyElement.class);
            ((AnyProperty) property).setDomHandlerClass(anyElement.value());
            ((AnyProperty) property).setLax(anyElement.lax());
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlElementRef.class) || helper.isAnnotationPresent(property.getElement(), XmlElementRefs.class)) {
            XmlElementRef[] elementRefs;
            XmlElementRef ref = (XmlElementRef) helper.getAnnotation(property.getElement(), XmlElementRef.class);
            if (ref != null) {
                elementRefs = new XmlElementRef[] { ref };
            } else {
                XmlElementRefs refs = (XmlElementRefs) helper.getAnnotation(property.getElement(), XmlElementRefs.class);
                elementRefs = refs.value();
                info.setHasElementRefs(true);
            }
            for (XmlElementRef nextRef : elementRefs) {
                JavaClass type = ptype;
                String typeName = type.getQualifiedName();
                property.setType(type);
                if (isCollectionType(property)) {
                    if (type.hasActualTypeArguments()) {
                        type = (JavaClass) type.getActualTypeArguments().toArray()[0];
                        typeName = type.getQualifiedName();
                    }
                }
                if (nextRef.type() != XmlElementRef.DEFAULT.class) {
                    typeName = helper.getJavaClass(nextRef.type()).getQualifiedName();
                }
                ElementDeclaration referencedElement = this.xmlRootElements.get(typeName);
                if (referencedElement != null) {
                    addReferencedElement((ReferenceProperty) property, referencedElement);
                } else {
                    String name = nextRef.name();
                    String namespace = nextRef.namespace();
                    if (namespace.equals("String_Node_Str")) {
                        namespace = "String_Node_Str";
                    }
                    QName qname = new QName(namespace, name);
                    referencedElement = this.globalElements.get(qname);
                    if (referencedElement != null) {
                        addReferencedElement((ReferenceProperty) property, referencedElement);
                    } else {
                        throw org.eclipse.persistence.exceptions.JAXBException.invalidElementRef(property.getPropertyName(), cls.getName());
                    }
                }
            }
        }
        if (!helper.isAnnotationPresent(property.getElement(), XmlTransient.class)) {
            properties.add(property);
        }
        if (helper.isAnnotationPresent(property.getElement(), XmlElement.class)) {
            property.setIsRequired(((XmlElement) helper.getAnnotation(property.getElement(), XmlElement.class)).required());
        }
    }
    return properties;
}

Output:
         JavaClass[] paramTypes = { (JavaClass) getMethod.getReturnType() };
-        JavaMethod setMethod = cls.getMethod(setMethodName, paramTypes);
+        JavaMethod setMethod = cls.getDeclaredMethod(setMethodName, paramTypes);
         JavaMethod propertyMethod = null;


Input:
public static AVFile withFile(String name, File file) throws FileNotFoundException {
    if (file == null) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (!file.exists() || !file.isFile()) {
        throw new FileNotFoundException();
    }
    AVFile avFile = new AVFile();
    avFile.setLocalPath(file.getAbsolutePath());
    avFile.setName(name);
    avFile.dirty = true;
    avFile.name = name;
    long fileSize = file.length();
    String fileMD5 = "String_Node_Str";
    try {
        InputStream is = AVPersistenceUtils.getInputStreamFromFile(file);
        MessageDigest md = MessageDigest.getInstance("String_Node_Str");
        if (null != is) {
            byte[] buf = new byte[(int) MAX_FILE_BUF_SIZE];
            int readCnt = is.read(buf);
            while (readCnt > 0) {
                md.update(buf, 0, readCnt);
            }
            byte[] md5bytes = md.digest();
            fileMD5 = AVUtils.hexEncodeBytes(md5bytes);
            is.close();
        }
    } catch (Exception ex) {
        fileMD5 = "String_Node_Str";
    }
    avFile.metaData.put("String_Node_Str", fileSize);
    avFile.metaData.put(FILE_SUM_KEY, fileMD5);
    AVUser currentUser = AVUser.getCurrentUser();
    avFile.metaData.put("String_Node_Str", currentUser != null ? currentUser.getObjectId() : "String_Node_Str");
    avFile.metaData.put(FILE_NAME_KEY, name);
    return avFile;
}

Output:
             byte[] buf = new byte[(int) MAX_FILE_BUF_SIZE];
-            int readCnt = is.read(buf);
-            while (readCnt > 0) {
-                md.update(buf, 0, readCnt);
+            int len;
+            while ((len = is.read(buf)) != -1) {
+                md.update(buf, 0, len);
             }


Input:
public LayerDTO createLayer(String workspaceId, String ciId, LayerDTO layer) {
    try {
        ConfigurationItemKey ciKey = new ConfigurationItemKey(workspaceId, ciId);
        Layer l = productService.createLayer(ciKey, layer.getName());
        return new LayerDTO(l.getId(), l.getName());
    } catch (ApplicationException ex) {
        throw new RestApiException(ex.toString(), ex.getMessage());
    }
}

Output:
         ConfigurationItemKey ciKey = new ConfigurationItemKey(workspaceId, ciId);
-        Layer l = productService.createLayer(ciKey, layer.getName());
-        return new LayerDTO(l.getId(), l.getName());
+        Layer l = productService.createLayer(ciKey, layer.getName(), layer.getColor());
+        return new LayerDTO(l.getId(), l.getName(), l.getColor());
     } catch (ApplicationException ex) {


Input:
public void testNavigatorOnSubCursor() throws DataException, OLAPException, IOException {
    ICubeQueryDefinition cqd = creator.createQueryDefinition();
    IBinding rowGrandTotal = new Binding("String_Node_Str");
    rowGrandTotal.setAggrFunction(IBuildInAggregation.TOTAL_SUM_FUNC);
    rowGrandTotal.setExpression(new ScriptExpression("String_Node_Str"));
    rowGrandTotal.addAggregateOn("String_Node_Str");
    rowGrandTotal.addAggregateOn("String_Node_Str");
    IBinding columnGrandTotal = new Binding("String_Node_Str");
    columnGrandTotal.setAggrFunction(IBuildInAggregation.TOTAL_SUM_FUNC);
    columnGrandTotal.setExpression(new ScriptExpression("String_Node_Str"));
    columnGrandTotal.addAggregateOn("String_Node_Str");
    columnGrandTotal.addAggregateOn("String_Node_Str");
    columnGrandTotal.addAggregateOn("String_Node_Str");
    columnGrandTotal.addAggregateOn("String_Node_Str");
    cqd.addBinding(rowGrandTotal);
    cqd.addBinding(columnGrandTotal);
    BirtCubeView cubeView = new BirtCubeView(new CubeQueryExecutor(null, cqd, de.getSession(), this.scope, de.getContext()));
    CubeCursor dataCursor = cubeView.getCubeCursor(new StopSign(), cube);
    EdgeCursor rowCursor = cubeView.getRowEdgeView().getEdgeCursor();
    EdgeCursor columnCursor = cubeView.getColumnEdgeView().getEdgeCursor();
    BirtCubeView subCubeView = new BirtCubeView(cubeView.getCubeQueryExecutor(), null);
    columnCursor.beforeFirst();
    rowCursor.next();
    columnCursor.setPosition(8);
    CubeCursor subCursor = subCubeView.getCubeCursor(new StopSign(), "String_Node_Str", "String_Node_Str", cubeView);
    EdgeCursor subRowCursor = subCubeView.getRowEdgeView().getEdgeCursor();
    EdgeCursor subColumnCursor = subCubeView.getColumnEdgeView().getEdgeCursor();
    subRowCursor.beforeFirst();
    subColumnCursor.beforeFirst();
    assertTrue(subRowCursor.isBeforeFirst());
    assertTrue(subColumnCursor.isBeforeFirst());
    subRowCursor.first();
    subColumnCursor.first();
    assertTrue(subRowCursor.isFirst());
    assertTrue(subColumnCursor.isFirst());
    assertTrue(subRowCursor.getPosition() == 0);
    assertTrue(subColumnCursor.getPosition() == 0);
    subColumnCursor.setPosition(3);
    assertTrue(subColumnCursor.getPosition() == 3);
    subRowCursor.beforeFirst();
    subRowCursor.next();
    subColumnCursor.setPosition(3);
    DimensionCursor c1 = (DimensionCursor) subColumnCursor.getDimensionCursor().get(0);
    DimensionCursor c2 = (DimensionCursor) subColumnCursor.getDimensionCursor().get(1);
    DimensionCursor c3 = (DimensionCursor) subColumnCursor.getDimensionCursor().get(2);
    DimensionCursor c4 = (DimensionCursor) subColumnCursor.getDimensionCursor().get(3);
    assertTrue(c1.getObject(0).toString().equals("String_Node_Str"));
    assertTrue(c2.getObject(0).toString().equals("String_Node_Str"));
    assertTrue(c3.getObject(0).toString().equals("String_Node_Str"));
    assertTrue(c4.getObject(0).toString().equals("String_Node_Str"));
    columnCursor.setPosition(5);
    subCursor = subCubeView.getCubeCursor(new StopSign(), "String_Node_Str", "String_Node_Str", cubeView);
    subRowCursor = subCubeView.getRowEdgeView().getEdgeCursor();
    subColumnCursor = subCubeView.getColumnEdgeView().getEdgeCursor();
    subColumnCursor.setPosition(7);
    c1 = (DimensionCursor) subColumnCursor.getDimensionCursor().get(0);
    c2 = (DimensionCursor) subColumnCursor.getDimensionCursor().get(1);
    c3 = (DimensionCursor) subColumnCursor.getDimensionCursor().get(2);
    c4 = (DimensionCursor) subColumnCursor.getDimensionCursor().get(3);
    assertTrue(c1.getObject(0).toString().equals("String_Node_Str"));
    assertTrue(c2.getObject(0).toString().equals("String_Node_Str"));
    assertTrue(c3.getObject(0).toString().equals("String_Node_Str"));
    assertTrue(c4.getObject(0).toString().equals("String_Node_Str"));
    close(dataCursor);
}

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