Input:
protected void onRegistrationError(String errorId) {
    if (!ADMConstants.ERROR_SERVICE_NOT_AVAILABLE.equals(errorId)) {
        Error error = convertError(errorId);
        OpenPushHelper.getInstance(this).onRegistrationEnd(new RegistrationResult(ADMProvider.NAME, error, false));
    }
}

Output:
 protected void onRegistrationError(String errorId) {
-    if (!ADMConstants.ERROR_SERVICE_NOT_AVAILABLE.equals(errorId)) {
-        Error error = convertError(errorId);
-        OpenPushHelper.getInstance(this).onRegistrationEnd(new RegistrationResult(ADMProvider.NAME, error, false));
-    }
+    OpenPushHelper.getInstance(this).onRegistrationEnd(new RegistrationResult(ADMProvider.NAME, convertError(errorId), false));
 }


Input:
public HistoricalWeather getHistoricalWeather(String data) throws WeatherLibException {
    HistoricalWeather histWeather = new HistoricalWeather();
    try {
        JSONObject jObj = new JSONObject(data);
        JSONObject histObj = jObj.getJSONObject("String_Node_Str");
        JSONArray wList = histObj.getJSONArray("String_Node_Str");
        for (int i = 0; i < wList.length(); i++) {
            HistoricalHourWeather hhWeather = new HistoricalHourWeather();
            JSONObject jHour = wList.getJSONObject(i);
            JSONObject utcObj = jHour.getJSONObject("String_Node_Str");
            int y = utcObj.getInt("String_Node_Str");
            int m = utcObj.getInt("String_Node_Str");
            int mday = utcObj.getInt("String_Node_Str");
            int h = utcObj.getInt("String_Node_Str");
            int min = utcObj.getInt("String_Node_Str");
            Calendar cal = GregorianCalendar.getInstance();
            cal.set(y, Calendar.JANUARY, mday, h, min);
            cal.add(Calendar.MONTH, m - 1);
            hhWeather.timestamp = cal.getTimeInMillis();
            String tag = null;
            if (WeatherUtility.isMetric(config.unitSystem))
                tag = "String_Node_Str";
            else
                tag = "String_Node_Str";
            hhWeather.weather.temperature.setTemp((float) jHour.getDouble("String_Node_Str" + tag));
            hhWeather.weather.currentCondition.setDewPoint((float) jHour.getDouble("String_Node_Str" + tag));
            hhWeather.weather.currentCondition.setHumidity((float) jHour.getInt("String_Node_Str"));
            hhWeather.weather.wind.setSpeed((float) jHour.getDouble("String_Node_Str" + tag));
            hhWeather.weather.wind.setGust((float) jHour.getDouble("String_Node_Str" + tag));
            hhWeather.weather.wind.setDeg((float) jHour.getDouble("String_Node_Str"));
            hhWeather.weather.wind.setChill((float) jHour.getDouble("String_Node_Str" + tag));
            hhWeather.weather.currentCondition.setVisibility((float) jHour.getDouble("String_Node_Str" + tag));
            hhWeather.weather.currentCondition.setPressure((float) jHour.getDouble("String_Node_Str" + tag));
            hhWeather.weather.currentCondition.setHeatIndex(jHour.getString("String_Node_Str" + tag));
            hhWeather.weather.rain[0].setAmmount((float) jHour.getDouble("String_Node_Str" + tag));
            hhWeather.weather.currentCondition.setDescr(jHour.getString("String_Node_Str"));
            hhWeather.weather.currentCondition.setIcon(jHour.getString("String_Node_Str"));
            if (codeProvider != null)
                hhWeather.weather.currentCondition.setWeatherCode(codeProvider.getWeatherCode(hhWeather.weather.currentCondition.getIcon()));
            histWeather.addHistoricalHourWeather(hhWeather);
        }
    } catch (JSONException json) {
        throw new WeatherLibException(json);
    }
    histWeather.setUnit(units);
    return histWeather;
}

Output:
             hhWeather.weather.currentCondition.setIcon(jHour.getString("String_Node_Str"));
-            if (codeProvider != null)
-                hhWeather.weather.currentCondition.setWeatherCode(codeProvider.getWeatherCode(hhWeather.weather.currentCondition.getIcon()));
+            if (codeProvider != null) {
+                try {
+                    hhWeather.weather.currentCondition.setWeatherCode(codeProvider.getWeatherCode(hhWeather.weather.currentCondition.getIcon()));
+                } catch (Throwable t) {
+                    hhWeather.weather.currentCondition.setWeatherCode(WeatherCode.NOT_AVAILABLE);
+                }
+            }
             histWeather.addHistoricalHourWeather(hhWeather);


Input:
protected void onDetach() {
    if (!attached) {
        throw new IllegalStateException("String_Node_Str");
    }
    attached = false;
    DOM.setEventListener(getElement(), null);
}

Output:
     }
-    attached = false;
-    DOM.setEventListener(getElement(), null);
+    try {
+        onUnload();
+    } finally {
+        attached = false;
+        DOM.setEventListener(getElement(), null);
+    }
 }


Input:
private Control createDBMetaDataSelectionComposite(Composite parent) {
    boolean supportsSchema = JdbcMetaDataProvider.getInstance().isSupportSchema();
    boolean supportsProcedure = JdbcMetaDataProvider.getInstance().isSupportProcedure();
    Composite tablescomposite = new Composite(parent, SWT.NONE);
    GridLayout layout = new GridLayout();
    tablescomposite.setLayout(layout);
    {
        GridData data = new GridData(GridData.FILL_VERTICAL);
        data.grabExcessVerticalSpace = true;
        tablescomposite.setLayoutData(data);
    }
    Label dataSourceLabel = new Label(tablescomposite, SWT.LEFT);
    dataSourceLabel.setText(JdbcPlugin.getResourceString("String_Node_Str"));
    {
        GridData data = new GridData();
        dataSourceLabel.setLayoutData(data);
    }
    availableDbObjectsTree = new Tree(tablescomposite, SWT.BORDER | SWT.MULTI);
    {
        GridData data = new GridData(GridData.FILL_BOTH);
        data.grabExcessHorizontalSpace = true;
        data.grabExcessVerticalSpace = true;
        data.heightHint = 150;
        availableDbObjectsTree.setLayoutData(data);
    }
    availableDbObjectsTree.addMouseListener(new MouseAdapter() {
        public void mouseDoubleClick(MouseEvent e) {
            String text = getTextToInsert();
            if (text.length() > 0) {
                insertText(text);
            }
        }
    });
    Group selectTableGroup = new Group(tablescomposite, SWT.FILL);
    {
        GridLayout groupLayout = new GridLayout();
        groupLayout.numColumns = 3;
        groupLayout.verticalSpacing = 10;
        selectTableGroup.setLayout(groupLayout);
        GridData data = new GridData(GridData.FILL_HORIZONTAL);
        selectTableGroup.setLayoutData(data);
    }
    schemaLabel = new Label(selectTableGroup, SWT.LEFT);
    schemaLabel.setText(JdbcPlugin.getResourceString("String_Node_Str"));
    schemaCombo = new Combo(selectTableGroup, prefetchSchema ? SWT.READ_ONLY : SWT.DROP_DOWN);
    GridData gd = new GridData(GridData.FILL_HORIZONTAL);
    gd.horizontalSpan = 2;
    schemaCombo.setLayoutData(gd);
    Label FilterLabel = new Label(selectTableGroup, SWT.LEFT);
    FilterLabel.setText(JdbcPlugin.getResourceString("String_Node_Str"));
    searchTxt = new Text(selectTableGroup, SWT.BORDER);
    {
        GridData data = new GridData(GridData.FILL_HORIZONTAL);
        data.horizontalSpan = 2;
        searchTxt.setLayoutData(data);
    }
    Label selectTypeLabel = new Label(selectTableGroup, SWT.NONE);
    selectTypeLabel.setText(JdbcPlugin.getResourceString("String_Node_Str"));
    filterComboViewer = new ComboViewer(selectTableGroup, SWT.READ_ONLY);
    setFilterComboContents(filterComboViewer, supportsProcedure);
    {
        GridData data = new GridData(GridData.FILL_HORIZONTAL);
        data.horizontalSpan = 2;
        filterComboViewer.getControl().setLayoutData(data);
    }
    new Label(selectTableGroup, SWT.LEFT);
    setupShowSystemTableCheckBox(selectTableGroup);
    Button findButton = new Button(selectTableGroup, SWT.NONE);
    {
        GridData data = new GridData(GridData.HORIZONTAL_ALIGN_END);
        data.horizontalSpan = 3;
        findButton.setLayoutData(data);
    }
    findButton.setText(JdbcPlugin.getResourceString("String_Node_Str"));
    findButton.addSelectionListener(new SelectionAdapter() {
        public void widgetSelected(SelectionEvent event) {
            PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
                public void run() {
                    fc = populateFilterConfig();
                    DBNodeUtil.createTreeRoot(availableDbObjectsTree, new RootNode(dataSetDesign.getDataSourceDesign().getName()), fc);
                }
            });
        }
    });
    setupIdentifierQuoteStringCheckBox(selectTableGroup);
    String[] allSchemaNames = null;
    if (supportsSchema) {
        String allFlag = JdbcPlugin.getResourceString("String_Node_Str");
        schemaCombo.add(allFlag);
        if (prefetchSchema) {
            allSchemaNames = JdbcMetaDataProvider.getInstance().getAllSchemaNames();
            for (String name : allSchemaNames) {
                schemaCombo.add(name);
            }
        }
        schemaCombo.select(0);
    } else {
        schemaCombo.removeAll();
        schemaCombo.setEnabled(false);
        schemaLabel.setEnabled(false);
    }
    if (prefetchSchema) {
        fc = populateFilterConfig();
        DBNodeUtil.createTreeRoot(availableDbObjectsTree, new RootNode(dataSetDesign.getDataSourceDesign().getName(), allSchemaNames), fc);
    } else {
        DBNodeUtil.createRootTip(availableDbObjectsTree, new RootNode(dataSetDesign.getDataSourceDesign().getName()));
    }
    addDragSupportToTree();
    addFetchDbObjectListener();
    return tablescomposite;
}

Output:
     Group selectTableGroup = new Group(tablescomposite, SWT.FILL);
-    {
-        GridLayout groupLayout = new GridLayout();
-        groupLayout.numColumns = 3;
-        groupLayout.verticalSpacing = 10;
-        selectTableGroup.setLayout(groupLayout);
-        GridData data = new GridData(GridData.FILL_HORIZONTAL);
-        selectTableGroup.setLayoutData(data);
-    }
+    GridLayout groupLayout = new GridLayout();
+    groupLayout.numColumns = 3;
+    groupLayout.verticalSpacing = 10;
+    selectTableGroup.setLayout(groupLayout);
+    GridData data = new GridData(GridData.FILL_HORIZONTAL);
+    selectTableGroup.setLayoutData(data);
     schemaLabel = new Label(selectTableGroup, SWT.LEFT);


Input:
public void onSendCompleted(int error) {
    if (error != Constants.SEND_RESULT_SUCCESS) {
        announceTimerRecordingResult(CLEAR_TIMER_STATUS_FAIL_TO_CLEAR_SELECTED_SOURCE);
    }
}

Output:
     if (error != Constants.SEND_RESULT_SUCCESS) {
-        announceTimerRecordingResult(CLEAR_TIMER_STATUS_FAIL_TO_CLEAR_SELECTED_SOURCE);
+        announceClearTimerRecordingResult(CLEAR_TIMER_STATUS_FAIL_TO_CLEAR_SELECTED_SOURCE);
     }


Input:
public static void main(String[] args) {
    long time = System.currentTimeMillis();
    FrameworkFactory frameworkFactory = new FrameworkFactory();
    Logger logger = new Logger();
    int port = DISABLE_SCRIPTS_PORT;
    try {
        final File baseDirectory = getBaseDirectory();
        FSHelper.validateFile(baseDirectory, true, true, false, true);
        createKnapsackLayout(baseDirectory, logger);
        Config config = new Config(baseDirectory);
        if (config.containsKey(Config.CONFIG_DISABLE_SCRIPTS) && config.getBoolean(Config.CONFIG_DISABLE_SCRIPTS)) {
            Random r = new Random();
            port = PORT_START + r.nextInt(MAX_PORT_RANGE);
        } else {
            createKnapsackScripts(baseDirectory, port);
        }
        List<BundleActivator> activators = new ArrayList<BundleActivator>();
        if (config.getBoolean(Config.CONFIG_KEY_BUILTIN_LOGGER))
            activators.add(new org.apache.felix.log.Activator());
        if (config.getBoolean(Config.CONFIG_KEY_BUILTIN_CONFIGADMIN))
            activators.add(new ConfigurationManager());
        activators.add(new org.knapsack.Activator(config, logger, port));
        config.put(FELIX_LOGGER_INSTANCE, logger);
        config.put(FELIX_BUNDLE_INSTANCES, activators);
        final Framework framework = frameworkFactory.newFramework(config);
        Runtime.getRuntime().addShutdownHook(new Thread("String_Node_Str") {
            public void run() {
                try {
                    if (framework != null) {
                        framework.stop();
                        framework.waitForStop(0);
                    }
                    FSHelper.deleteFilesInDir(scriptDir);
                } catch (Exception ex) {
                    System.err.println("String_Node_Str" + ex);
                }
            }
        });
        framework.init();
        framework.start();
        logger.log(LogService.LOG_INFO, "String_Node_Str" + ((double) (System.currentTimeMillis() - time) / 1000) + "String_Node_Str" + activators);
    } catch (Exception e) {
        logger.log(LogService.LOG_INFO, "String_Node_Str", e);
        System.exit(1);
    }
}

Output:
         Config config = new Config(baseDirectory);
-        if (config.containsKey(Config.CONFIG_DISABLE_SCRIPTS) && config.getBoolean(Config.CONFIG_DISABLE_SCRIPTS)) {
+        if (!config.containsKey(Config.CONFIG_DISABLE_SCRIPTS) || !config.getBoolean(Config.CONFIG_DISABLE_SCRIPTS)) {
             Random r = new Random();


Input:
public void onPlayerMove(PlayerMoveEvent event) {
    Player p = event.getPlayer();
    Location loc = p.getLocation();
    PortalPlayerSession ps = this.plugin.getPortalSession(event.getPlayer());
    ps.setStaleLocation(loc);
    if (ps.isStaleLocation()) {
        return;
    }
    MVPortal portal = ps.getStandingInPortal();
    if (portal != null && ps.doTeleportPlayer() && !this.showDebugInfo(event.getPlayer(), portal)) {
        Destination d = portal.getDestination();
        Location l = d.getLocation();
        Vector v = event.getPlayer().getVelocity();
        System.out.print("String_Node_Str" + v.toString());
        System.out.print("String_Node_Str" + event.getPlayer().getFallDistance());
        event.getPlayer().setFallDistance(0);
        if (d instanceof InvalidDestination) {
            System.out.print("String_Node_Str");
            return;
        }
        ps.playerDidTeleport();
        event.getPlayer().teleport(l);
    }
}

Output:
     PortalPlayerSession ps = this.plugin.getPortalSession(event.getPlayer());
-    ps.setStaleLocation(loc);
+    ps.setStaleLocation(loc, Type.PLAYER_MOVE);
     if (ps.isStaleLocation()) {


Input:
public void testNamedQuerySingleResult() {
    PersistenceUnitResource resource = new PersistenceUnitResource();
    resource.setPersistenceFactory(factory);
    PersistenceContext context = getAuctionPersistenceContext(null);
    DynamicEntity entity1 = (DynamicEntity) context.newEntity("String_Node_Str");
    entity1.set("String_Node_Str", "String_Node_Str");
    context.create(null, entity1);
    DynamicEntity entity2 = (DynamicEntity) context.newEntity("String_Node_Str");
    entity2.set("String_Node_Str", "String_Node_Str");
    context.create(null, entity2);
    TestHttpHeaders headers = new TestHttpHeaders();
    headers.getAcceptableMediaTypes().add(MediaType.APPLICATION_JSON_TYPE);
    List<String> mediaTypes = new ArrayList<String>();
    mediaTypes.add(MediaType.APPLICATION_JSON);
    TestURIInfo ui = new TestURIInfo();
    ui.addMatrixParameter("String_Node_Str", "String_Node_Str", "String_Node_Str");
    StreamingOutput output = (StreamingOutput) resource.namedQuerySingleResult("String_Node_Str", "String_Node_Str", headers, ui).getEntity();
    String resultString = stringifyResults(output);
    assertTrue("String_Node_Str", resultString.contains("String_Node_Str"));
    assertFalse("String_Node_Str", resultString.contains("String_Node_Str"));
    clearData();
}

Output:
 public void testNamedQuerySingleResult() {
-    PersistenceUnitResource resource = new PersistenceUnitResource();
+    SingleResultQueryResource resource = new SingleResultQueryResource();
     resource.setPersistenceFactory(factory);


Input:
protected Sound initSound(Sound input) {
    long[] newdata = new long[(int) (input.getSamples().length * factor)];
    this.sound = new Sound(newdata, input.getNbBytesPerSample(), input.getFreq(), sound.getChannelNum());
    return this.sound;
}

Output:
     long[] newdata = new long[(int) (input.getSamples().length * factor)];
-    this.sound = new Sound(newdata, input.getNbBytesPerSample(), input.getFreq(), sound.getChannelNum());
+    this.sound = new Sound(newdata, input.getNbBytesPerSample(), input.getFreq(), input.getChannelNum());
     return this.sound;


Input:
public static boolean validFoliageSpot(World world, BlockPos pos) {
    return world.getBlockState(pos).getMaterial() == Material.GRASS;
}

Output:
 public static boolean validFoliageSpot(World world, BlockPos pos) {
-    return world.getBlockState(pos).getMaterial() == Material.GRASS;
+    return world.getBlockState(pos).getMaterial() != Material.WATER && world.getBlockState(pos.up()).getMaterial() == Material.WATER;
 }


Input:
public CompletionStage<Result> process(final String languageTag) {
    final UserContext userContext = userContext(languageTag);
    return getOrCreateCart(userContext, session()).thenComposeAsync(cart -> {
        final CheckoutAddressFormData checkoutAddressFormData = extractBean(request(), CheckoutAddressFormData.class);
        final Form<CheckoutAddressFormData> filledForm = obtainFilledForm(checkoutAddressFormData);
        final CheckoutAddressPageContent content = new CheckoutAddressPageContent(checkoutAddressFormData, cart, i18nResolver(), configuration(), userContext, projectContext(), productDataConfig, reverseRouter());
        if (filledForm.hasErrors()) {
            return CompletableFuture.completedFuture(badRequest(userContext, filledForm, content));
        } else {
            return updateCart(cart, content).thenApplyAsync(updatedCart -> redirect(reverseRouter().showCheckoutShippingForm(languageTag)), HttpExecution.defaultContext());
        }
    });
}

Output:
     return getOrCreateCart(userContext, session()).thenComposeAsync(cart -> {
-        final CheckoutAddressFormData checkoutAddressFormData = extractBean(request(), CheckoutAddressFormData.class);
-        final Form<CheckoutAddressFormData> filledForm = obtainFilledForm(checkoutAddressFormData);
+        final CheckoutAddressFormData checkoutAddressFormData = extractBean(request, CheckoutAddressFormData.class);
+        final Form<CheckoutAddressFormData> filledForm = obtainFilledForm(checkoutAddressFormData, request);
         final CheckoutAddressPageContent content = new CheckoutAddressPageContent(checkoutAddressFormData, cart, i18nResolver(), configuration(), userContext, projectContext(), productDataConfig, reverseRouter());


Input:
public void setStarted(boolean started, int memFactor, long now) {
    if (mOwner == null) {
        Slog.wtf(TAG, "String_Node_Str" + this + "String_Node_Str");
    }
    final boolean wasStarted = mStartedState != STATE_NOTHING;
    final int state = started ? memFactor : STATE_NOTHING;
    if (mStartedState != state) {
        if (mStartedState != STATE_NOTHING) {
            addDuration(SERVICE_STARTED + (mStartedState * SERVICE_COUNT), now - mStartedStartTime);
        } else if (started) {
            mStartedCount++;
        }
        mStartedState = state;
        mStartedStartTime = now;
        mProc = mProc.pullFixedProc(mPackage);
        if (wasStarted != started) {
            if (started) {
                mProc.incStartedServices(memFactor, now);
            } else {
                mProc.decStartedServices(memFactor, now);
            }
        }
        updateRunning(memFactor, now);
    }
}

Output:
     }
-    final boolean wasStarted = mStartedState != STATE_NOTHING;
-    final int state = started ? memFactor : STATE_NOTHING;
-    if (mStartedState != state) {
-        if (mStartedState != STATE_NOTHING) {
-            addDuration(SERVICE_STARTED + (mStartedState * SERVICE_COUNT), now - mStartedStartTime);
-        } else if (started) {
-            mStartedCount++;
-        }
-        mStartedState = state;
-        mStartedStartTime = now;
-        mProc = mProc.pullFixedProc(mPackage);
-        if (wasStarted != started) {
-            if (started) {
-                mProc.incStartedServices(memFactor, now);
-            } else {
-                mProc.decStartedServices(memFactor, now);
-            }
-        }
-        updateRunning(memFactor, now);
-    }
+    mStarted = started;
+    updateStartedState(memFactor, now);
 }


Input:
public static ImageInfo createFromDeviceMapping(UserFullName userFullName, String imageName, String imageDescription, Image.Architecture imageArch, Image.Platform imagePlatform, String rootDeviceName, final List<BlockDeviceMappingItemType> blockDeviceMappings) throws EucalyptusCloudException {
    Context ctx = Contexts.lookup();
    BlockDeviceMappingItemType rootBlockDevice = Iterables.find(blockDeviceMappings, findEbsRoot(rootDeviceName));
    String snapshotId = rootBlockDevice.getEbs().getSnapshotId();
    try {
        Snapshot snap = Snapshots.lookup(userFullName, snapshotId);
        if (!userFullName.getUserId().equals(snap.getOwnerUserId())) {
            throw new EucalyptusCloudException("String_Node_Str" + rootBlockDevice + "String_Node_Str");
        }
        Integer snapVolumeSize = snap.getVolumeSize();
        Integer suppliedVolumeSize = (rootBlockDevice.getEbs().getVolumeSize() != null) ? rootBlockDevice.getEbs().getVolumeSize() : -1;
        suppliedVolumeSize = (suppliedVolumeSize == null) ? rootBlockDevice.getSize() : suppliedVolumeSize;
        Integer targetVolumeSizeGB = (snapVolumeSize <= suppliedVolumeSize) ? suppliedVolumeSize : snapVolumeSize;
        Long imageSizeKB = targetVolumeSizeGB * 1024l * 1024l;
        Boolean targetDeleteOnTermination = Boolean.TRUE.equals(rootBlockDevice.getEbs().getDeleteOnTermination());
        String imageId = generateImageId(Image.Type.machine.getTypePrefix(), snapshotId);
        BlockStorageImageInfo ret = new BlockStorageImageInfo(userFullName, imageId, imageName, imageDescription, imageSizeKB, imageArch, imagePlatform, snap.getDisplayName(), targetDeleteOnTermination);
        ret = Transactions.save(ret, new Callback<BlockStorageImageInfo>() {
            public void fire(BlockStorageImageInfo t) {
                t.getDeviceMappings().addAll(Lists.transform(blockDeviceMappings, Images.deviceMappingGenerator(t)));
            }
        });
        return ret;
    } catch (TransactionFireException ex) {
        throw new EucalyptusCloudException("String_Node_Str" + rootBlockDevice + "String_Node_Str" + ex.getMessage());
    } catch (ExecutionException ex) {
        LOG.error(ex, ex);
        throw new EucalyptusCloudException("String_Node_Str" + rootBlockDevice + "String_Node_Str" + ex.getMessage());
    }
}

Output:
         Integer targetVolumeSizeGB = (snapVolumeSize <= suppliedVolumeSize) ? suppliedVolumeSize : snapVolumeSize;
-        Long imageSizeKB = targetVolumeSizeGB * 1024l * 1024l;
+        Long imageSizeBytes = targetVolumeSizeGB * 1024l * 1024l * 1024l;
         Boolean targetDeleteOnTermination = Boolean.TRUE.equals(rootBlockDevice.getEbs().getDeleteOnTermination());


Input:
private ArrayList<Cookie> parseCookie(String host, String path, String cookieString) {
    ArrayList<Cookie> ret = new ArrayList<Cookie>();
    int index = 0;
    int length = cookieString.length();
    while (true) {
        Cookie cookie = null;
        if (index < 0 || index >= length) {
            break;
        }
        if (cookieString.charAt(index) == WHITE_SPACE) {
            index++;
            continue;
        }
        int semicolonIndex = cookieString.indexOf(SEMICOLON, index);
        int equalIndex = cookieString.indexOf(EQUAL, index);
        if (equalIndex == -1) {
            break;
        }
        if (semicolonIndex > -1 && semicolonIndex < equalIndex) {
            break;
        }
        cookie = new Cookie(host, path);
        cookie.name = cookieString.substring(index, equalIndex);
        if (cookieString.charAt(equalIndex + 1) == QUOTATION) {
            index = cookieString.indexOf(QUOTATION, equalIndex + 2);
            if (index == -1) {
                break;
            }
        }
        semicolonIndex = cookieString.indexOf(SEMICOLON, index);
        if (semicolonIndex == -1) {
            semicolonIndex = length;
        }
        if (semicolonIndex - equalIndex > MAX_COOKIE_LENGTH) {
            cookie.value = cookieString.substring(equalIndex + 1, equalIndex + MAX_COOKIE_LENGTH);
        } else if (equalIndex + 1 == semicolonIndex || semicolonIndex < equalIndex) {
            cookie.value = "String_Node_Str";
        } else {
            cookie.value = cookieString.substring(equalIndex + 1, semicolonIndex);
        }
        index = semicolonIndex;
        while (true) {
            if (index < 0 || index >= length) {
                break;
            }
            if (cookieString.charAt(index) == WHITE_SPACE || cookieString.charAt(index) == SEMICOLON) {
                index++;
                continue;
            }
            if (cookieString.charAt(index) == COMMA) {
                index++;
                break;
            }
            if (length - index > SECURE_LENGTH && cookieString.substring(index, index + SECURE_LENGTH).equalsIgnoreCase(SECURE)) {
                index += SECURE_LENGTH;
                cookie.secure = true;
                if (cookieString.charAt(index) == EQUAL)
                    index++;
                continue;
            }
            if (length - index > HTTP_ONLY_LENGTH && cookieString.substring(index, index + HTTP_ONLY_LENGTH).equalsIgnoreCase(HTTP_ONLY)) {
                index += HTTP_ONLY_LENGTH;
                if (cookieString.charAt(index) == EQUAL)
                    index++;
                continue;
            }
            equalIndex = cookieString.indexOf(EQUAL, index);
            if (equalIndex > 0) {
                String name = cookieString.substring(index, equalIndex).toLowerCase();
                if (name.equals(EXPIRES)) {
                    int comaIndex = cookieString.indexOf(COMMA, equalIndex);
                    if ((comaIndex != -1) && (comaIndex - equalIndex <= 10)) {
                        index = comaIndex + 1;
                    }
                }
                semicolonIndex = cookieString.indexOf(SEMICOLON, index);
                int commaIndex = cookieString.indexOf(COMMA, index);
                if (semicolonIndex == -1 && commaIndex == -1) {
                    index = length;
                } else if (semicolonIndex == -1) {
                    index = commaIndex;
                } else if (commaIndex == -1) {
                    index = semicolonIndex;
                } else {
                    index = Math.min(semicolonIndex, commaIndex);
                }
                String value = cookieString.substring(equalIndex + 1, index);
                if (value.length() > 2 && value.charAt(0) == QUOTATION) {
                    int endQuote = value.indexOf(QUOTATION, 1);
                    if (endQuote > 0) {
                        value = value.substring(1, endQuote);
                    }
                }
                if (name.equals(EXPIRES)) {
                    try {
                        cookie.expires = HttpDateTime.parse(value);
                    } catch (IllegalArgumentException ex) {
                        Log.e(LOGTAG, "String_Node_Str" + value);
                    }
                } else if (name.equals(MAX_AGE)) {
                    try {
                        cookie.expires = System.currentTimeMillis() + 1000 * Long.parseLong(value);
                    } catch (NumberFormatException ex) {
                        Log.e(LOGTAG, "String_Node_Str" + value);
                    }
                } else if (name.equals(PATH)) {
                    if (value.length() > 0) {
                        cookie.path = value;
                    }
                } else if (name.equals(DOMAIN)) {
                    int lastPeriod = value.lastIndexOf(PERIOD);
                    if (lastPeriod == 0) {
                        cookie.domain = null;
                        continue;
                    }
                    try {
                        Integer.parseInt(value.substring(lastPeriod + 1));
                        if (!value.equals(host)) {
                            cookie.domain = null;
                        }
                        continue;
                    } catch (NumberFormatException ex) {
                    }
                    value = value.toLowerCase();
                    if (value.charAt(0) != PERIOD) {
                        value = PERIOD + value;
                        lastPeriod++;
                    }
                    if (host.endsWith(value.substring(1))) {
                        int len = value.length();
                        int hostLen = host.length();
                        if (hostLen > (len - 1) && host.charAt(hostLen - len) != PERIOD) {
                            cookie.domain = null;
                            continue;
                        }
                        if ((len == lastPeriod + 3) && (len >= 6 && len <= 8)) {
                            String s = value.substring(1, lastPeriod);
                            if (Arrays.binarySearch(BAD_COUNTRY_2LDS, s) >= 0) {
                                cookie.domain = null;
                                continue;
                            }
                        }
                        cookie.domain = value;
                    } else {
                        cookie.domain = null;
                    }
                }
            } else {
                index = length;
            }
        }
        if (cookie != null && cookie.domain != null) {
            ret.add(cookie);
        }
    }
    return ret;
}

Output:
             }
-            if (length - index > SECURE_LENGTH && cookieString.substring(index, index + SECURE_LENGTH).equalsIgnoreCase(SECURE)) {
+            if (length - index >= SECURE_LENGTH && cookieString.substring(index, index + SECURE_LENGTH).equalsIgnoreCase(SECURE)) {
                 index += SECURE_LENGTH;


Input:
private void generate(int num, boolean minify) {
    try {
        if (minify) {
            nl = "String_Node_Str";
            sp = "String_Node_Str";
            sc = "String_Node_Str";
        } else {
            nl = "String_Node_Str";
            sp = "String_Node_Str";
            sc = "String_Node_Str";
        }
        BufferedWriter out = new BufferedWriter(new FileWriter(readFileName()));
        out.write("String_Node_Str" + nl + nl + nl);
        Object[][] tableData = divisionTable.getRowData();
        printInitProperties(out, tableData, num);
        for (int i = 0; i < tableData.length; i++) {
            tb = "String_Node_Str";
            if (isZeroWidth((String) tableData[i][1]))
                printColProperties(out, "String_Node_Str" + tableData[i][0] + "String_Node_Str", num);
            else {
                if (!minify)
                    tb = "String_Node_Str";
                out.write(nl + "String_Node_Str" + sp + "String_Node_Str" + sp + tableData[i][1] + "String_Node_Str" + sp + "String_Node_Str" + nl);
                printColProperties(out, "String_Node_Str" + tableData[i][0] + "String_Node_Str", num);
                out.write("String_Node_Str" + nl);
            }
        }
        out.close();
        JOptionPane.showMessageDialog(this, "String_Node_Str", "String_Node_Str", JOptionPane.INFORMATION_MESSAGE);
    } catch (IOException e) {
        JOptionPane.showMessageDialog(this, "String_Node_Str", "String_Node_Str", JOptionPane.ERROR_MESSAGE);
    }
}

Output:
         BufferedWriter out = new BufferedWriter(new FileWriter(readFileName()));
-        out.write("String_Node_Str" + nl + nl + nl);
+        if (minify)
+            out.write("String_Node_Str");
+        else
+            out.write("String_Node_Str");
         Object[][] tableData = divisionTable.getRowData();


Input:
public Fields getFieldsFor(String identifier) {
    String name = platformBroker.createTableNameFrom(identifier);
    if (nameFieldsMap.containsKey(name))
        return nameFieldsMap.get(name);
    Point<Protocol, Format> point = getPointFor(identifier, null, null, null);
    Resource<Protocol, Format, SinkMode> resource = new Resource<Protocol, Format, SinkMode>(identifier, point.protocol, point.format, SinkMode.KEEP);
    Tap tap = createTapFor(rootSchemaDef, rootSchemaDef.findStereotypeFor(Fields.UNKNOWN), resource);
    if (!resourceExists(tap))
        return null;
    Fields fields = tap.retrieveSourceFields(platformBroker.getFlowProcess());
    nameFieldsMap.put(name, fields);
    return fields;
}

Output:
         return nameFieldsMap.get(name);
-    Point<Protocol, Format> point = getPointFor(identifier, null, null, null);
+    Point<Protocol, Format> point = getPointFor(identifier, schemaDef.getName(), null, null);
     Resource<Protocol, Format, SinkMode> resource = new Resource<Protocol, Format, SinkMode>(identifier, point.protocol, point.format, SinkMode.KEEP);


Input:
public static String getDefaultHostIp() {
    if (SystemUtils.IS_OS_WINDOWS) {
        Pattern pattern = Pattern.compile("String_Node_Str");
        try {
            Process result = Runtime.getRuntime().exec("String_Node_Str");
            BufferedReader output = new BufferedReader(new InputStreamReader(result.getInputStream()));
            String line = output.readLine();
            while (line != null) {
                Matcher matcher = pattern.matcher(line);
                if (matcher.find()) {
                    return matcher.group(2);
                }
                line = output.readLine();
            }
        } catch (IOException e) {
            s_logger.debug("String_Node_Str", e);
        }
        return null;
    } else {
        NetworkInterface nic = null;
        String pubNic = getDefaultEthDevice();
        if (pubNic == null) {
            return null;
        }
        try {
            nic = NetworkInterface.getByName(pubNic);
        } catch (final SocketException e) {
            return null;
        }
        String[] info = NetUtils.getNetworkParams(nic);
        return info[0];
    }
}

Output:
         String[] info = NetUtils.getNetworkParams(nic);
-        return info[0];
+        if (info != null) {
+            return info[0];
+        }
+        return null;
     }


Input:
private String getNetworkTopology() {
    return generateTopology();
}

Output:
 private String getNetworkTopology() {
-    return generateTopology();
+    if (Databases.isVolatile()) {
+        return topoString.get();
+    } else {
+        return topoMemoSupplier.get();
+    }
 }


Input:
public void render(Object obj) throws IOException {
    if (null == obj) {
        writer.write("String_Node_Str");
    } else if (obj instanceof Class) {
        string2Json(((Class<?>) obj).getName());
    } else if (obj instanceof Mirror) {
        string2Json(((Mirror<?>) obj).getType().getName());
    } else {
        Mirror mr = Mirror.me(obj.getClass());
        if (mr.isEnum()) {
            string2Json(((Enum) obj).name());
        } else if (mr.isNumber() || mr.isBoolean() || mr.isChar()) {
            writer.append(obj.toString());
        } else if (mr.isStringLike()) {
            string2Json(obj.toString());
        } else if (mr.isDateTimeLike()) {
            string2Json(format.getCastors().castToString(obj));
        } else if (memo.containsKey(obj)) {
            writer.append("String_Node_Str");
        } else {
            memo.put(obj, null);
            if (obj instanceof Map)
                map2Json((Map) obj);
            else if (obj instanceof Collection)
                coll2Json((Collection) obj);
            else if (obj.getClass().isArray())
                array2Json(obj);
            else {
                pojo2Json(obj);
            }
            memo.remove(obj);
        }
    }
}

Output:
             string2Json(((Enum) obj).name());
-        } else if (mr.isNumber() || mr.isBoolean() || mr.isChar()) {
+        } else if (mr.isNumber() || mr.isBoolean()) {
             writer.append(obj.toString());


Input:
public static void main(String[] args) throws Exception {
    ClientSeventhConfig config = null;
    try {
        Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
            public void uncaughtException(Thread t, Throwable e) {
                if (t.getName().equals("String_Node_Str")) {
                    catchException(e);
                }
            }
        });
        config = loadConfig();
        VideoConfig vConfig = config.getVideo();
        DisplayMode displayMode = findBestDimensions(vConfig);
        LwjglApplicationConfiguration.disableAudio = true;
        LwjglApplicationConfiguration cfg = new LwjglApplicationConfiguration();
        cfg.setFromDisplayMode(displayMode);
        cfg.fullscreen = vConfig.isFullscreen();
        cfg.title = "String_Node_Str" + SeventhGame.getVersion();
        cfg.forceExit = true;
        cfg.resizable = false;
        cfg.useGL30 = vConfig.useGL30();
        cfg.vSyncEnabled = vConfig.isVsync();
        if (!cfg.fullscreen) {
            cfg.width = 1024;
            cfg.height = 768;
        }
        new LwjglApplication(new SeventhGame(config), cfg);
    } catch (Exception e) {
        catchException(e);
    } finally {
        if (config != null) {
        }
    }
}

Output:
         if (!cfg.fullscreen) {
-            cfg.width = 1024;
-            cfg.height = 768;
+            cfg.width = 840;
+            cfg.height = 480;
         }


Input:
private WebReply handleJaspi(Subject receivedSubject, String uriName, WebRequest webRequest, WebSecurityContext webSecurityContext) throws SecurityViolationException, IOException {
    performPrecludedAccessTests(webRequest, webSecurityContext, uriName);
    WebReply webReply = unprotectedSpecialURI(webRequest, uriName, webRequest.getHttpServletRequest().getMethod());
    if (webReply == null) {
        String authMech = webAppSecConfig.getOverrideHttpAuthenticationMechanism();
        AuthenticationResult authResult = null;
        if (authMech != null && authMech.equals("String_Node_Str")) {
            authResult = authenticateRequest(webRequest);
        }
        if (authResult != null && authResult.getStatus() != AuthResult.SUCCESS) {
            authResult = providerAuthenticatorProxy.handleJaspi(webRequest, null);
            authResult.setAuditCredType(AuditEvent.CRED_TYPE_JASPIC);
            if (receivedSubject != null && receivedSubject.getPrincipals() != null) {
                authResult.setAuditCredValue(receivedSubject.getPrincipals().iterator().next().getName());
            }
        }
        if (authResult.getStatus() == AuthResult.RETURN) {
            String reason = authResult.getReason();
            int statusCode = webRequest.getHttpServletResponse().getStatus();
            if (reason != null && reason.contains("String_Node_Str")) {
                if (unprotectedResource(webRequest) == PERMIT_REPLY) {
                    AuthenticationResult permitResult = new AuthenticationResult(AuthResult.SUCCESS, (Subject) null, AuditEvent.CRED_TYPE_JASPIC, null, AuditEvent.OUTCOME_SUCCESS);
                    Audit.audit(Audit.EventID.SECURITY_AUTHN_01, webRequest, authResult, Integer.valueOf(statusCode));
                    Audit.audit(Audit.EventID.SECURITY_AUTHZ_01, webRequest, permitResult, uriName, Integer.valueOf(HttpServletResponse.SC_OK));
                    return PERMIT_REPLY;
                } else if (statusCode == HttpServletResponse.SC_OK) {
                    statusCode = HttpServletResponse.SC_UNAUTHORIZED;
                    webRequest.getHttpServletResponse().setStatus(statusCode);
                }
            }
            webReply = new ReturnReply(statusCode, reason);
            Audit.audit(Audit.EventID.SECURITY_AUTHN_01, webRequest, authResult, Integer.valueOf(webReply.getStatusCode()));
            SecurityViolationException secVE = convertWebSecurityException(new WebSecurityCollaboratorException(webReply.message, webReply, webSecurityContext));
            throw secVE;
        } else if (authResult.getStatus() != AuthResult.CONTINUE) {
            webReply = determineWebReply(receivedSubject, uriName, webRequest, authResult);
        }
    }
    return webReply;
}

Output:
         }
-        if (authResult != null && authResult.getStatus() != AuthResult.SUCCESS) {
+        if (authResult == null || authResult.getStatus() != AuthResult.SUCCESS) {
             authResult = providerAuthenticatorProxy.handleJaspi(webRequest, null);


Input:
public boolean apply(final Allocation allocInfo) {
    try {
        EventRecord.here(ClusterAllocator.class, EventType.VM_PREPARE, LogUtil.dumpObject(allocInfo)).info();
        final ServiceConfiguration config = Topology.lookup(ClusterController.class, allocInfo.getPartition());
        final Callable<Boolean> runnable = new Callable<Boolean>() {
            public Boolean call() {
                try {
                    new ClusterAllocator(allocInfo).run();
                } catch (final Exception ex) {
                    LOG.warn("String_Node_Str" + allocInfo.getAllocationTokens());
                    LOG.error("String_Node_Str" + allocInfo.getAllocationTokens(), ex);
                }
                return Boolean.TRUE;
            }
        };
        Threads.enqueue(config, 32, runnable);
        return true;
    } catch (final Exception ex) {
        throw Exceptions.toUndeclared(ex);
    }
}

Output:
     try {
-        EventRecord.here(ClusterAllocator.class, EventType.VM_PREPARE, LogUtil.dumpObject(allocInfo)).info();
+        if (EventRecord.isDebugEnabled(ClusterAllocator.class)) {
+            EventRecord.here(ClusterAllocator.class, EventType.VM_PREPARE, LogUtil.dumpObject(allocInfo)).debug();
+        }
         final ServiceConfiguration config = Topology.lookup(ClusterController.class, allocInfo.getPartition());


Input:
public void createRelationEdgeRep(final IGraph parentPathway, final IGraphItem pathwayRelationEdge, final IGraphItem graphItemIn, final IGraphItem graphItemOut) {
    int iGeneratedId = -1;
    IGraphItem pathwayRelationEdgeRep = new PathwayRelationEdgeGraphItemRep(iGeneratedId);
    parentPathway.addItem(pathwayRelationEdgeRep);
    pathwayRelationEdgeRep.addGraph(parentPathway, EGraphItemHierarchy.GRAPH_PARENT);
    pathwayRelationEdgeRep.addItem(pathwayRelationEdge, EGraphItemProperty.ALIAS_PARENT);
    pathwayRelationEdge.addItem(pathwayRelationEdgeRep, EGraphItemProperty.ALIAS_CHILD);
    pathwayRelationEdgeRep.addItemDoubleLinked(graphItemIn, EGraphItemProperty.INCOMING);
    pathwayRelationEdgeRep.addItemDoubleLinked(graphItemOut, EGraphItemProperty.OUTGOING);
}

Output:
 public void createRelationEdgeRep(final IGraph parentPathway, final IGraphItem pathwayRelationEdge, final IGraphItem graphItemIn, final IGraphItem graphItemOut) {
-    int iGeneratedId = -1;
-    IGraphItem pathwayRelationEdgeRep = new PathwayRelationEdgeGraphItemRep(iGeneratedId);
+    IGraphItem pathwayRelationEdgeRep = new PathwayRelationEdgeGraphItemRep();
     parentPathway.addItem(pathwayRelationEdgeRep);


Input:
public ImmunizationData getData() {
    ImmunizationData data = new ImmunizationData();
    for (int i = 1; i < rows; ++i) {
        ImmunizationRow row = new ImmunizationRow(this.data[i][0]);
        for (int j = 1; j < cols; j++) {
            if (selectedindex[i][j] == ExtensionConstants.VACCINATION_GIVEN_ON_DATE) {
                row.setDose(j, selectedindex[i][j], new Date(recorddate[i][j]));
            } else {
                row.setVaccinationDose(j, selectedindex[i][j]);
            }
        }
        data.addRow(row);
    }
    return data;
}

Output:
             if (selectedindex[i][j] == ExtensionConstants.VACCINATION_GIVEN_ON_DATE) {
-                row.setDose(j, selectedindex[i][j], new Date(recorddate[i][j]));
+                row.setDose(j - 1, selectedindex[i][j], new Date(recorddate[i][j]));
             } else {


Input:
public void onInit(GitHubData data) {
    if (data instanceof ContributorsData) {
        if (((ContributorsData) data).contributors != null) {
            for (ContributorsData.ContributorData contributor : ((ContributorsData) data).contributors) {
                if (contributor.login == null)
                    continue;
                TranslatorInfoData mergeTranslator = new TranslatorInfoData(contributor.login, null, contributor.avatar_url, null, null, null);
                TranslatorInfoData translatorInfo = mergeTranslator;
                if (translators.contains(mergeTranslator)) {
                    translatorInfo = translators.get(translators.indexOf(mergeTranslator));
                    translatorInfo.merge(mergeTranslator);
                } else
                    translators.add(translatorInfo);
                if (!translatorInfo.hasEverything())
                    addRequest(new UserData(contributor.login));
            }
        }
    } else if (data instanceof UserData) {
        UserData user = (UserData) data;
        TranslatorInfoData translator = new TranslatorInfoData(user.login, user.name, user.avatar_url, null, user.blog, user.email);
        if (!translators.contains(translator))
            translators.add(0, translator);
        else
            translators.get(translators.indexOf(translator)).merge(translator);
    }
}

Output:
                     continue;
-                TranslatorInfoData mergeTranslator = new TranslatorInfoData(contributor.login, null, contributor.avatar_url, null, null, null);
-                TranslatorInfoData translatorInfo = mergeTranslator;
-                if (translators.contains(mergeTranslator)) {
-                    translatorInfo = translators.get(translators.indexOf(mergeTranslator));
-                    translatorInfo.merge(mergeTranslator);
-                } else
-                    translators.add(translatorInfo);
-                if (!translatorInfo.hasEverything())
+                InfoData child = addChild(new TranslatorInfoData(contributor.login, null, contributor.avatar_url, null, null, null));
+                if (child instanceof Mergeable && !((Mergeable) child).hasAll())
                     addRequest(new UserData(contributor.login));


Input:
private void captureImage() {
    Image image;
    try {
        final CameraFile cf = cameraGphoto.captureImage();
        if (cf != null) {
            Shooting activeShooting = shootingService.searchIsActive();
            if (activeShooting != null) {
                int imageID = imageService.getNextImageID();
                String directoryPath = activeShooting.getStorageDir() + "String_Node_Str";
                DateFormat dateFormat = new SimpleDateFormat("String_Node_Str");
                Date date = new Date();
                String imagePath = directoryPath + "String_Node_Str" + camera.getId() + "String_Node_Str" + dateFormat.format(date) + "String_Node_Str";
                image = new Image(imageID, imagePath, activeShooting.getId(), new Date());
                image = imageService.create(image);
                cf.save(new File(imagePath).getAbsolutePath());
                imageProcessor.processShot(image);
                LOGGER.debug(imageService.getLastImgPath(activeShooting.getId()));
            } else {
                LOGGER.error("String_Node_Str");
            }
            cf.close();
        }
    } catch (CameraException ex) {
        LOGGER.error("String_Node_Str", ex);
        setStop(true);
    } catch (ServiceException ex) {
        LOGGER.error("String_Node_Str", ex);
    }
}

Output:
             if (activeShooting != null) {
-                int imageID = imageService.getNextImageID();
-                String directoryPath = activeShooting.getStorageDir() + "String_Node_Str";
-                DateFormat dateFormat = new SimpleDateFormat("String_Node_Str");
-                Date date = new Date();
-                String imagePath = directoryPath + "String_Node_Str" + camera.getId() + "String_Node_Str" + dateFormat.format(date) + "String_Node_Str";
-                image = new Image(imageID, imagePath, activeShooting.getId(), new Date());
-                image = imageService.create(image);
-                cf.save(new File(imagePath).getAbsolutePath());
-                imageProcessor.processShot(image);
-                LOGGER.debug(imageService.getLastImgPath(activeShooting.getId()));
+                for (int i = 0; i < anz; i++) {
+                    int imageID = imageService.getNextImageID();
+                    String directoryPath = activeShooting.getStorageDir() + "String_Node_Str";
+                    DateFormat dateFormat = new SimpleDateFormat("String_Node_Str");
+                    Date date = new Date();
+                    String imagePath = directoryPath + "String_Node_Str" + camera.getId() + "String_Node_Str" + dateFormat.format(date) + "String_Node_Str";
+                    image = new Image(imageID, imagePath, activeShooting.getId(), new Date());
+                    image = imageService.create(image);
+                    cf.save(new File(imagePath).getAbsolutePath());
+                    imageList.add(image);
+                    LOGGER.debug(imageService.getLastImgPath(activeShooting.getId()));
+                }
+                for (Image shot : imageList) {
+                    imageProcessor.processShot(shot);
+                    sleep(5000);
+                }
             } else {


Input:
void setCropInTransaction(Rect clipRect, boolean recoveringMemory) {
    if (SHOW_TRANSACTIONS)
        logSurface("String_Node_Str" + clipRect.toShortString(), null);
    try {
        if (clipRect.width() > 0 && clipRect.height() > 0) {
            mSurfaceControl.setWindowCrop(clipRect);
            mHiddenForCrop = false;
        } else {
            hideInTransaction();
            mHiddenForCrop = true;
        }
    } catch (RuntimeException e) {
        Slog.w(TAG, "String_Node_Str" + this + "String_Node_Str" + clipRect.toShortString(), e);
        if (!recoveringMemory) {
            mAnimator.reclaimSomeSurfaceMemory("String_Node_Str", true);
        }
    }
}

Output:
         } else {
-            hideInTransaction();
+            hideInTransaction("String_Node_Str");
             mHiddenForCrop = true;


Input:
public void testEditSubmissions() throws Exception {
    ______TS("String_Node_Str");
    restoreTypicalDataInDatastore();
    loginAsAdmin("String_Node_Str");
    ArrayList<SubmissionData> submissionContainer = new ArrayList<SubmissionData>();
    logic.editSubmissions(submissionContainer);
    SubmissionData sub1 = dataBundle.submissions.get("String_Node_Str");
    SubmissionData sub2 = dataBundle.submissions.get("String_Node_Str");
    alterSubmission(sub1);
    submissionContainer.add(sub1);
    logic.editSubmissions(submissionContainer);
    verifyPresentInDatastore(sub1);
    verifyPresentInDatastore(sub2);
    alterSubmission(sub1);
    alterSubmission(sub2);
    submissionContainer = new ArrayList<SubmissionData>();
    submissionContainer.add(sub1);
    submissionContainer.add(sub2);
    logic.editSubmissions(submissionContainer);
    verifyPresentInDatastore(sub1);
    verifyPresentInDatastore(sub2);
    ______TS("String_Node_Str");
    try {
        logic.editSubmissions(null);
        fail();
    } catch (NullPointerException e) {
        assertContains("String_Node_Str", e.getMessage().toLowerCase());
    }
    ______TS("String_Node_Str");
    ______TS("String_Node_Str");
    restoreTypicalDataInDatastore();
    String methodName = "String_Node_Str";
    Class<?>[] paramTypes = new Class<?>[] { List.class };
    List<SubmissionData> submissions = new ArrayList<SubmissionData>();
    SubmissionData s = new SubmissionData();
    s.course = "String_Node_Str";
    s.evaluation = "String_Node_Str";
    s.reviewer = "String_Node_Str";
    submissions.add(s);
    Object[] params = new Object[] { submissions };
    loginAsAdmin("String_Node_Str");
    EvaluationData evaluation = logic.getEvaluation(s.course, s.evaluation);
    evaluation.startTime = Common.getDateOffsetToCurrentTime(1);
    evaluation.endTime = Common.getDateOffsetToCurrentTime(2);
    evaluation.activated = false;
    assertEquals(EvalStatus.AWAITING, evaluation.getStatus());
    logic.editEvaluation(evaluation);
    logoutUser();
    verifyCannotAccess(USER_TYPE_NOT_LOGGED_IN, methodName, "String_Node_Str", paramTypes, params);
    verifyCannotAccess(USER_TYPE_UNREGISTERED, methodName, "String_Node_Str", paramTypes, params);
    verifyCannotAccess(USER_TYPE_STUDENT, methodName, "String_Node_Str", paramTypes, params);
    verifyCannotAccess(USER_TYPE_STUDENT, methodName, "String_Node_Str", paramTypes, params);
    verifyCannotAccess(USER_TYPE_COORD, methodName, "String_Node_Str", paramTypes, params);
    verifyCanAccess(USER_TYPE_COORD, methodName, "String_Node_Str", paramTypes, params);
}

Output:
     assertEquals(EvalStatus.AWAITING, evaluation.getStatus());
-    logic.editEvaluation(evaluation);
+    BackDoorLogic backDoorLogic = new BackDoorLogic();
+    backDoorLogic.editEvaluation(evaluation);
     logoutUser();


Input:
private String string(String string) {
    string = string.substring(1, string.length() - 1);
    string = string.replace("String_Node_Str", "String_Node_Str");
    return string;
}

Output:
     string = string.substring(1, string.length() - 1);
-    string = string.replace("String_Node_Str", "String_Node_Str");
-    return string;
+    String returnString = "String_Node_Str";
+    int slashIndex = string.indexOf('\\');
+    if (slashIndex == -1) {
+        return string;
+    }
+    int position = 0;
+    while (slashIndex > -1) {
+        String subString = string.substring(position, slashIndex);
+        returnString += subString;
+        position = slashIndex;
+        char nextChar = string.charAt(slashIndex + 1);
+        switch(nextChar) {
+            case 'b':
+                {
+                    position += 2;
+                    returnString += '\b';
+                    break;
+                }
+            case 'r':
+                {
+                    position += 2;
+                    returnString += '\r';
+                    break;
+                }
+            case 'f':
+                {
+                    position += 2;
+                    returnString += '\f';
+                    break;
+                }
+            case 'n':
+                {
+                    position += 2;
+                    returnString += '\n';
+                    break;
+                }
+            case 't':
+                {
+                    position += 2;
+                    returnString += '\t';
+                    break;
+                }
+            case '"':
+                {
+                    position += 2;
+                    returnString += '"';
+                    break;
+                }
+            case '\\':
+                {
+                    position += 2;
+                    returnString += '\\';
+                    break;
+                }
+            case '/':
+                {
+                    position += 2;
+                    returnString += '/';
+                    break;
+                }
+            case 'u':
+                {
+                    position += 6;
+                    String hexValue = string.substring(slashIndex + 2, slashIndex + 6);
+                    returnString += Character.toString((char) Integer.parseInt(hexValue, 16));
+                    break;
+                }
+        }
+        slashIndex = string.indexOf('\\', position);
+    }
+    if (position < string.length()) {
+        String subString = string.substring(position, string.length());
+        returnString += subString;
+    }
+    return returnString;
 }


Input:
protected DetermineDestPickInfoReturn determineDestPickInfo(MouseEvent e) {
    boolean deactivateGrab = false;
    PickInfo swingHitPickInfo = null;
    if (swingPickInfos.peek() != null) {
        try {
            PickInfoQueueEntry entry = swingPickInfos.take();
            if (e.getID() == entry.mouseEvent.getID() && e.getX() == entry.mouseEvent.getX() && e.getY() == entry.mouseEvent.getY()) {
                swingHitPickInfo = entry.hitPickInfo;
            } else {
                logger.warning("String_Node_Str");
                logger.warning("String_Node_Str" + e);
                logger.warning("String_Node_Str" + entry.mouseEvent);
            }
        } catch (InterruptedException ex) {
        }
    }
    if (e.getID() == MouseEvent.MOUSE_PRESSED) {
        buttonLastX = e.getX();
        buttonLastY = e.getY();
    } else if (e.getID() == MouseEvent.MOUSE_CLICKED) {
        if (!buttonWithinClickThreshold(e.getX(), e.getY())) {
            return null;
        }
    }
    if (e.getID() == MouseEvent.MOUSE_CLICKED) {
        return new DetermineDestPickInfoReturn(lastButtonReleasedPickInfo, lastButtonReleasedPickInfo);
    }
    PickInfo hitPickInfo;
    if (swingHitPickInfo == null) {
        hitPickInfo = pickEventScreenPos(e.getX(), e.getY());
        logger.finest("String_Node_Str" + hitPickInfo);
        if (hitPickInfo != null) {
            logger.finest("String_Node_Str" + hitPickInfo.size());
        }
    } else {
        hitPickInfo = swingHitPickInfo;
    }
    GrabChangeType grabChange = GrabChangeType.GRAB_NO_CHANGE;
    int eventID = e.getID();
    if (eventID == MouseEvent.MOUSE_PRESSED || eventID == MouseEvent.MOUSE_RELEASED) {
        grabChange = evaluateButtonGrabStateChange(eventID, e);
        if (grabChange == GrabChangeType.GRAB_ACTIVATE) {
            grabIsActive = true;
            grabPickInfo = hitPickInfo;
            logger.finest("String_Node_Str" + grabPickInfo);
            if (grabPickInfo != null) {
                logger.finest("String_Node_Str" + grabPickInfo.size());
                if (grabPickInfo.size() > 0) {
                    PickDetails pd = grabPickInfo.get(0);
                    logger.finest("String_Node_Str" + pd);
                    if (pd != null) {
                        logPickDetailsEntity(pd);
                        CollisionComponent cc = pd.getCollisionComponent();
                        logger.finest("String_Node_Str" + cc);
                        if (cc != null) {
                            logger.finest("String_Node_Str" + cc.getEntity());
                        }
                    }
                }
            }
        }
    }
    PickInfo destPickInfo;
    logger.finest("String_Node_Str" + grabIsActive);
    if (grabIsActive) {
        destPickInfo = grabPickInfo;
        logger.finest("String_Node_Str" + grabPickInfo);
    } else {
        destPickInfo = hitPickInfo;
    }
    logger.finest("String_Node_Str" + destPickInfo);
    if (grabChange == GrabChangeType.GRAB_DEACTIVATE) {
        grabIsActive = false;
        grabPickInfo = null;
    }
    if (e.getID() == MouseEvent.MOUSE_RELEASED) {
        lastButtonReleasedPickInfo = destPickInfo;
    }
    logger.fine("String_Node_Str" + e);
    logPickInfo("String_Node_Str", destPickInfo);
    logPickInfo("String_Node_Str", hitPickInfo);
    return new DetermineDestPickInfoReturn(destPickInfo, hitPickInfo);
}

Output:
     if (e.getID() == MouseEvent.MOUSE_CLICKED) {
-        return new DetermineDestPickInfoReturn(lastButtonReleasedPickInfo, lastButtonReleasedPickInfo);
+        return new DetermineDestPickInfoReturn(lastButtonPressedPickInfo, lastButtonPressedPickInfo);
     }


Input:
protected void onPageUnload() {
    for (Iterator iter = moduleSpacesByName.entrySet().iterator(); iter.hasNext(); ) {
        Map.Entry entry = (Map.Entry) iter.next();
        String moduleName = (String) entry.getKey();
        ModuleSpace space = (ModuleSpace) entry.getValue();
        space.dispose();
        logger.log(TreeLogger.SPAM, "String_Node_Str" + moduleName, null);
    }
    moduleSpacesByName.clear();
    if (!toolbar.openWebModeButton.isDisposed()) {
        toolbar.openWebModeButton.setEnabled(false);
    }
}

Output:
         ModuleSpace space = (ModuleSpace) entry.getValue();
-        space.dispose();
-        logger.log(TreeLogger.SPAM, "String_Node_Str" + moduleName, null);
+        unloadModule(space, moduleName);
     }


Input:
public long getEntityOwnerId() {
    VirtualMachineTemplate iso = _responseGenerator.findTemplateById(getId());
    if (iso == null) {
        return Account.ACCOUNT_ID_SYSTEM;
    }
    return iso.getAccountId();
}

Output:
 public long getEntityOwnerId() {
-    VirtualMachineTemplate iso = _responseGenerator.findTemplateById(getId());
-    if (iso == null) {
-        return Account.ACCOUNT_ID_SYSTEM;
+    UserVm vm = _entityMgr.findById(UserVm.class, getVirtualMachineId());
+    if (vm == null) {
+        throw new InvalidParameterValueException("String_Node_Str" + getVirtualMachineId());
     }


Input:
public void onBindViewHolder(ShowcaseMoreInfoHolder showcaseMoreInfoHolder, final int position) {
    showcaseMoreInfoHolder.description.setText(categories.get(position).title);
    Glide.with(mContext).load(categories.get(position).imageUrl).centerCrop().placeholder(R.color.background).crossFade().into(showcaseMoreInfoHolder.categoryImg);
    showcaseMoreInfoHolder.mRippleBtnMore.setOnRippleCompleteListener(new RippleView.OnRippleCompleteListener() {

        public void onComplete(RippleView rippleView) {
            ((BottomBarActivity) mContext).replaceFragment(HomeFragment.newInstance(Constants.CATEGORY_PAGETYPE, categories.get(position)), HomeFragment.class.getName() + CategoriesGridFragment.class.getName());
        }
    });
    mLayoutManager = new LinearLayoutManager(mContext);
    mLayoutManager.setOrientation(LinearLayoutManager.HORIZONTAL);
    mLayoutManager.setReverseLayout(true);
    showcaseMoreInfoHolder.mHorizontalRecycleView.setNestedScrollingEnabled(false);
    if (mGiftPositionMap.get(position).gifts.size() == 0) {
        mGiftPositionMap.get(position).showcaseMoreInfoAdapter = new ShowcaseMoreInfoAdapter(mContext, mGiftPositionMap.get(position).gifts);
        getGifts(position, mGiftPositionMap.get(position).start_index);
    }
    showcaseMoreInfoHolder.mHorizontalRecycleView.setAdapter(mGiftPositionMap.get(position).showcaseMoreInfoAdapter);
    showcaseMoreInfoHolder.mHorizontalRecycleView.setLayoutManager(mLayoutManager);
}

Output:
     Glide.with(mContext).load(categories.get(position).imageUrl).centerCrop().placeholder(R.color.background).crossFade().into(showcaseMoreInfoHolder.categoryImg);
-    showcaseMoreInfoHolder.mRippleBtnMore.setOnRippleCompleteListener(new RippleView.OnRippleCompleteListener() {
+    showcaseMoreInfoHolder.more.setOnClickListener(new View.OnClickListener() {


Input:
private <T> void writeAndReadRecords(JournalWriter<T> journal, int count, int pageSize, RecordGenerator<T> generator) throws IOException, JournalException, ParserException {
    for (int i = 0; i < count; i++) {
        journal.append(generator.generate(i));
    }
    journal.commit();
    try (MemoryPages buffer = new MemoryPages(pageSize)) {
        MemoryRecordAccessor a = new MemoryRecordAccessor(journal.getMetadata(), buffer);
        LongList offsets = new LongList();
        for (Record rec : compiler.compile(factory, journal.getLocation().getName())) {
            offsets.add(a.append(rec));
        }
        for (int i = 0; i < count; i++) {
            a.init(offsets.getQuick(i));
            generator.assertRecord(a, i);
        }
    }
}

Output:
         for (int i = 0; i < count; i++) {
-            a.init(offsets.getQuick(i));
+            a.of(offsets.getQuick(i));
             generator.assertRecord(a, i);


Input:
public static void updateReportListFile(IFolder outputFolder, IFolder targetFolder) {
    try {
        File oldFolder = WorkspaceUtils.ifolderToFile(outputFolder);
        File newFolder = WorkspaceUtils.ifolderToFile(targetFolder.getFolder(outputFolder.getName()));
        File file = new File(newFolder.getAbsolutePath() + File.separator + ReportUtils.REPORT_LIST);
        if (file.exists() && file.isFile()) {
            String str1 = oldFolder.toString();
            String str2 = newFolder.toString();
            str1 = StringUtils.replace(str1, "String_Node_Str", "String_Node_Str");
            str2 = StringUtils.replace(str2, "String_Node_Str", "String_Node_Str");
            FilesUtils.replaceInFile(str1, file.toString(), str2);
        }
    } catch (Exception e) {
        log.warn(e, e);
    }
}

Output:
         if (file.exists() && file.isFile()) {
-            String str1 = oldFolder.toString();
-            String str2 = newFolder.toString();
-            str1 = StringUtils.replace(str1, "String_Node_Str", "String_Node_Str");
-            str2 = StringUtils.replace(str2, "String_Node_Str", "String_Node_Str");
-            FilesUtils.replaceInFile(str1, file.toString(), str2);
+            replaceReportGenDocFilePath(file, oldFolder.toString(), newFolder.toString());
         }


Input:
public Account getDefaultAccount() {
    for (Account e : getAccounts()) {
        if (e.isDefault) {
            return e;
        }
    }
    return null;
}

Output:
         if (e.isDefault) {
-            return e;
+            return e.address;
         }


Input:
private FormElement createBodyPortalFormElement(BodyPortal listViewPortal, FlattenedSolution fs, final boolean isInDesigner) {
    Form form = listViewPortal.getForm();
    Part bodyPart = null;
    for (Part prt : Utils.iterate(form.getParts())) {
        if (prt.getPartType() == Part.BODY) {
            bodyPart = prt;
            break;
        }
    }
    if (bodyPart != null) {
        try {
            String name = "String_Node_Str" + form.getName();
            int startPos = form.getPartStartYPos(bodyPart.getID());
            int endPos = bodyPart.getHeight();
            int bodyheight = endPos - startPos;
            JSONObject portal = new JSONObject();
            portal.put("String_Node_Str", name);
            portal.put("String_Node_Str", !listViewPortal.isTableview());
            portal.put("String_Node_Str", !listViewPortal.isTableview() ? bodyheight : getRowHeight(form));
            portal.put("String_Node_Str", form.getScrollbars());
            if (listViewPortal.isTableview()) {
                int headerHeight = 30;
                if (form.hasPart(Part.HEADER)) {
                    headerHeight = 0;
                }
                portal.put("String_Node_Str", headerHeight);
                portal.put("String_Node_Str", form.getOnSortCmdMethodID() != -1);
            }
            portal.put("String_Node_Str", IAnchorConstants.ALL);
            JSONObject location = new JSONObject();
            location.put("String_Node_Str", 0);
            location.put("String_Node_Str", isInDesigner ? startPos : 0);
            portal.put("String_Node_Str", location);
            JSONObject size = new JSONObject();
            size.put("String_Node_Str", form.getWidth());
            size.put("String_Node_Str", bodyheight);
            portal.put("String_Node_Str", size);
            portal.put("String_Node_Str", listViewPortal.getVisible());
            portal.put("String_Node_Str", listViewPortal.getEnabled());
            portal.put("String_Node_Str", new JSONArray());
            JSONObject relatedFoundset = new JSONObject();
            relatedFoundset.put("String_Node_Str", "String_Node_Str");
            portal.put("String_Node_Str", relatedFoundset);
            PropertyPath propertyPath = new PropertyPath();
            propertyPath.setShouldAddElementName();
            FormElement portalFormElement = new FormElement("String_Node_Str", portal, form, name, fs, propertyPath, isInDesigner);
            PropertyDescription pd = portalFormElement.getWebComponentSpec().getProperties().get("String_Node_Str");
            if (pd != null)
                pd = ((CustomJSONArrayType<?, ?>) pd.getType()).getCustomJSONTypeDefinition();
            if (pd == null) {
                Debug.error(new RuntimeException("String_Node_Str"));
                return null;
            }
            ComponentPropertyType type = ((ComponentPropertyType) pd.getType());
            Map<String, Object> portalFormElementProperties = new HashMap<>(portalFormElement.getRawPropertyValues());
            portalFormElementProperties.put("String_Node_Str", startPos);
            portalFormElementProperties.put("String_Node_Str", bodyPart.getHeight());
            Iterator<IPersist> it = form.getAllObjects(PositionComparator.XY_PERSIST_COMPARATOR);
            List<Object> children = new ArrayList<>();
            List<String> headersText = new ArrayList<>();
            propertyPath.add(portalFormElement.getName());
            propertyPath.add("String_Node_Str");
            int minBodyPortalTabSeq = -2;
            while (it.hasNext()) {
                IPersist persist = it.next();
                if (persist instanceof IFormElement) {
                    Point loc = ((IFormElement) persist).getLocation();
                    if (startPos <= loc.y && endPos > loc.y) {
                        if (listViewPortal.isTableview() && persist instanceof GraphicalComponent && ((GraphicalComponent) persist).getLabelFor() != null)
                            continue;
                        propertyPath.add(children.size());
                        FormElement fe = getFormElement((IFormElement) persist, fs, propertyPath, isInDesigner);
                        if (listViewPortal.isTableview()) {
                            String elementName = fe.getName();
                            boolean hasLabelFor = false;
                            Iterator<GraphicalComponent> graphicalComponents = form.getGraphicalComponents();
                            while (graphicalComponents.hasNext()) {
                                GraphicalComponent gc = graphicalComponents.next();
                                if (gc.getLabelFor() != null && Utils.equalObjects(elementName, gc.getLabelFor()) && startPos <= gc.getLocation().y && endPos > gc.getLocation().y) {
                                    headersText.add(gc.getText());
                                    hasLabelFor = true;
                                    break;
                                }
                            }
                            if (!hasLabelFor) {
                                if (fe.getPropertyValue("String_Node_Str") != null) {
                                    headersText.add(fe.getPropertyValue("String_Node_Str").toString());
                                } else {
                                    headersText.add(null);
                                }
                            }
                        }
                        children.add(type.getFormElementValue(null, pd, propertyPath, fe, fs));
                        propertyPath.backOneLevel();
                        Collection<PropertyDescription> tabSequenceProperties = fe.getWebComponentSpec().getProperties(NGTabSeqPropertyType.NG_INSTANCE);
                        for (PropertyDescription tabSeqProperty : tabSequenceProperties) {
                            String tabSeqPropertyName = tabSeqProperty.getName();
                            Integer tabSeqVal = (Integer) fe.getPropertyValue(tabSeqPropertyName);
                            if (tabSeqVal == null)
                                tabSeqVal = Integer.valueOf(0);
                            if (minBodyPortalTabSeq < 0 || minBodyPortalTabSeq > tabSeqVal.intValue())
                                minBodyPortalTabSeq = tabSeqVal.intValue();
                        }
                    }
                }
            }
            propertyPath.backOneLevel();
            propertyPath.backOneLevel();
            portalFormElementProperties.put("String_Node_Str", children.toArray());
            if (listViewPortal.isTableview()) {
                portalFormElementProperties.put("String_Node_Str", headersText.toArray());
            }
            portalFormElementProperties.put("String_Node_Str", Integer.valueOf(minBodyPortalTabSeq));
            portalFormElement.updatePropertyValuesDontUse(portalFormElementProperties);
            return portalFormElement;
        } catch (JSONException ex) {
            Debug.error("String_Node_Str", ex);
        }
    }
    return null;
}

Output:
                         if (listViewPortal.isTableview()) {
-                            String elementName = fe.getName();
-                            boolean hasLabelFor = false;
-                            Iterator<GraphicalComponent> graphicalComponents = form.getGraphicalComponents();
-                            while (graphicalComponents.hasNext()) {
-                                GraphicalComponent gc = graphicalComponents.next();
-                                if (gc.getLabelFor() != null && Utils.equalObjects(elementName, gc.getLabelFor()) && startPos <= gc.getLocation().y && endPos > gc.getLocation().y) {
-                                    headersText.add(gc.getText());
-                                    hasLabelFor = true;
-                                    break;
+                            int access = clientFlattenedSolution.getSecurityAccess(persist.getUUID());
+                            if ((access & IRepository.VIEWABLE) != 0) {
+                                String elementName = fe.getName();
+                                boolean hasLabelFor = false;
+                                Iterator<GraphicalComponent> graphicalComponents = form.getGraphicalComponents();
+                                while (graphicalComponents.hasNext()) {
+                                    GraphicalComponent gc = graphicalComponents.next();
+                                    if (gc.getLabelFor() != null && Utils.equalObjects(elementName, gc.getLabelFor()) && startPos <= gc.getLocation().y && endPos > gc.getLocation().y) {
+                                        headersText.add(gc.getText());
+                                        hasLabelFor = true;
+                                        break;
+                                    }
                                 }


Input:
protected void defaultSettings() {
    super.defaultSettings();
    manipulatingCamera = false;
    scalingDuringCamManip = false;
    if (usingModelviewStack) {
        modelviewStack = new A3DMatrixStack();
    }
    textureMode(IMAGE);
    if (!primarySurface) {
        PGraphicsAndroid3D a3d = (PGraphicsAndroid3D) parent.g;
        try {
            Method meth = this.getClass().getMethod("String_Node_Str", new Class[] { PGraphicsAndroid3D.class });
            recreateResourceIdx = a3d.addRecreateResourceMethod(this, meth);
        } catch (Exception e) {
            recreateResourceIdx = -1;
        }
    }
}

Output:
     scalingDuringCamManip = false;
-    if (usingModelviewStack) {
+    clearColorBuffer = false;
+    if (fbStack == null) {
+        fbStack = new Stack<PFramebuffer>();
+        screenFramebuffer = new PFramebuffer(parent, width, height, true);
+        setFramebuffer(screenFramebuffer);
+    }
+    if (usingModelviewStack && modelviewStack == null) {
         modelviewStack = new A3DMatrixStack();


Input:
public static String SUBSTR(String string, int start, Integer length) {
    if (string == null) {
        return null;
    }
    if (start > string.length()) {
        return "String_Node_Str";
    }
    if (start > 0) {
        start--;
    } else if (start < 0) {
        start = string.length() + start;
        if (start < 0) {
            start = 0;
        }
    }
    String result;
    if (length == null || (length + start) > string.length()) {
        result = string.substring(start);
    } else if (length <= 0) {
        return "String_Node_Str";
    } else {
        result = string.substring(start, length + start);
    }
    return result;
}

Output:
 public static String SUBSTR(String string, int start, Integer length) {
-    if (string == null) {
+    if (isVacant(string)) {
         return null;


Input:
public Date getOrder() {
    GregorianCalendar gc = new GregorianCalendar(2012, 10, 19, 10, 0, 0);
    return gc.getTime();
}

Output:
 public Date getOrder() {
-    GregorianCalendar gc = new GregorianCalendar(2012, 10, 19, 10, 0, 0);
+    GregorianCalendar gc = new GregorianCalendar(2012, 10, 26, 10, 0, 0);
     return gc.getTime();


Input:
protected void build() {
    addChild(new DocumentFragment());
    addChild(new DialogContainerFragment(new ExceptionDialogFragment()));
    addChild(new DialogContainerFragment(new ParameterDialogFragment()));
}

Output:
 protected void build() {
-    addChild(new DocumentFragment());
-    addChild(new DialogContainerFragment(new ExceptionDialogFragment()));
-    addChild(new DialogContainerFragment(new ParameterDialogFragment()));
+    addChild(new ParameterFragment());
 }


Input:
private final DimensionSetInstance getDimensionSet(ICS ics) {
    try {
        String site = ics.GetVar("String_Node_Str");
        if (StringUtils.isNotBlank(site)) {
            long discoveredId = LocaleUtils.locateDimensionSetForSite(ics, site);
            LOG.trace("String_Node_Str" + site + "String_Node_Str" + discoveredId);
            return LocaleUtils.getDimensionSet(ics, discoveredId);
        }
    } catch (RuntimeException e) {
        LOG.trace("String_Node_Str" + e);
    }
    throw new IllegalArgumentException("String_Node_Str");
}

Output:
     }
-    throw new IllegalArgumentException("String_Node_Str");
+    return null;
 }


Input:
public void getODMMetadata(int parentStudyId, int studyId, MetaDataVersionBean metadata, String odmVersion) {
    String cvIds = "String_Node_Str";
    HashMap<Integer, Integer> cvIdPoses = new HashMap<Integer, Integer>();
    this.setStudyEventAndFormMetaTypesExpected();
    logger.debug("String_Node_Str");
    logger.error("String_Node_Str" + this.getStudyEventAndFormMetaSql(parentStudyId, studyId, false));
    ArrayList rows = this.select(this.getStudyEventAndFormMetaSql(parentStudyId, studyId, false));
    Iterator it = rows.iterator();
    String sedprev = "String_Node_Str";
    MetaDataVersionProtocolBean protocol = metadata.getProtocol();
    HashMap<Integer, String> nullMap = new HashMap<Integer, String>();
    HashMap<String, String> nullValueCVs = new HashMap<String, String>();
    while (it.hasNext()) {
        HashMap row = (HashMap) it.next();
        Integer sedOrder = (Integer) row.get("String_Node_Str");
        Integer cvId = (Integer) row.get("String_Node_Str");
        String sedOID = (String) row.get("String_Node_Str");
        String sedName = (String) row.get("String_Node_Str");
        Boolean sedRepeat = (Boolean) row.get("String_Node_Str");
        String sedType = (String) row.get("String_Node_Str");
        String cvOID = (String) row.get("String_Node_Str");
        String cvName = (String) row.get("String_Node_Str");
        Boolean cvRequired = (Boolean) row.get("String_Node_Str");
        String nullValue = (String) row.get("String_Node_Str");
        String crfName = (String) row.get("String_Node_Str");
        StudyEventDefBean sedef = new StudyEventDefBean();
        if (sedprev.equals(sedOID)) {
            int p = metadata.getStudyEventDefs().size() - 1;
            sedef = metadata.getStudyEventDefs().get(p);
        } else {
            sedprev = sedOID;
            ElementRefBean sedref = new ElementRefBean();
            sedref.setElementDefOID(sedOID);
            sedref.setMandatory("String_Node_Str");
            sedref.setOrderNumber(sedOrder);
            protocol.getStudyEventRefs().add(sedref);
            sedef.setOid(sedOID);
            sedef.setName(sedName);
            sedef.setRepeating(sedRepeat ? "String_Node_Str" : "String_Node_Str");
            String type = sedType.toLowerCase();
            type = type.substring(0, 1).toUpperCase() + type.substring(1);
            sedef.setType(type);
            metadata.getStudyEventDefs().add(sedef);
        }
        ElementRefBean formref = new ElementRefBean();
        formref.setElementDefOID(cvOID);
        formref.setMandatory(cvRequired ? "String_Node_Str" : "String_Node_Str");
        sedef.getFormRefs().add(formref);
        if (!cvIdPoses.containsKey(cvId)) {
            FormDefBean formdef = new FormDefBean();
            formdef.setOid(cvOID);
            formdef.setName(crfName + "String_Node_Str" + cvName);
            formdef.setRepeating("String_Node_Str");
            metadata.getFormDefs().add(formdef);
            cvIdPoses.put(cvId, metadata.getFormDefs().size() - 1);
            cvIds += cvId + "String_Node_Str";
            if (nullValue != null && nullValue.length() > 0) {
                nullMap.put(cvId, nullValue);
                nullValueCVs.put(sedOID + "String_Node_Str" + cvOID, nullValue);
            }
        }
    }
    cvIds = cvIds.substring(0, cvIds.length() - 1);
    metadata.setCvIds(cvIds);
    HashMap<Integer, Integer> maxLengths = new HashMap<Integer, Integer>();
    this.setItemDataMaxLengthTypesExpected();
    rows.clear();
    logger.debug("String_Node_Str");
    rows = select(this.getItemDataMaxLengths(cvIds));
    it = rows.iterator();
    while (it.hasNext()) {
        HashMap row = (HashMap) it.next();
        maxLengths.put((Integer) row.get("String_Node_Str"), (Integer) row.get("String_Node_Str"));
    }
    this.setItemGroupAndItemMetaWithUnitTypesExpected();
    rows.clear();
    logger.debug("String_Node_Str");
    logger.error("String_Node_Str" + this.getItemGroupAndItemMetaWithUnitSql(cvIds));
    rows = select(this.getItemGroupAndItemMetaWithUnitSql(cvIds));
    it = rows.iterator();
    ArrayList<ItemGroupDefBean> itemGroupDefs = (ArrayList<ItemGroupDefBean>) metadata.getItemGroupDefs();
    ArrayList<ItemDefBean> itemDefs = (ArrayList<ItemDefBean>) metadata.getItemDefs();
    ArrayList<CodeListBean> codeLists = (ArrayList<CodeListBean>) metadata.getCodeLists();
    ArrayList<MultiSelectListBean> multiSelectLists = (ArrayList<MultiSelectListBean>) metadata.getMultiSelectLists();
    ArrayList<ElementRefBean> itemGroupRefs = new ArrayList<ElementRefBean>();
    Set<String> igset = new HashSet<String>();
    HashMap<String, Integer> igdPos = new HashMap<String, Integer>();
    Set<String> itset = new HashSet<String>();
    Set<Integer> itdset = new HashSet<Integer>();
    Set<Integer> clset = new HashSet<Integer>();
    Set<Integer> mslset = new HashSet<Integer>();
    ItemGroupDefBean igdef = new ItemGroupDefBean();
    HashMap<String, String> igMandatories = new HashMap<String, String>();
    boolean isLatest = false;
    int cvprev = -1;
    String igrprev = "String_Node_Str";
    String igdprev = "String_Node_Str";
    String itMandatory = "String_Node_Str";
    int itOrder = 0;
    Integer igId = -1;
    String sectionIds = "String_Node_Str";
    while (it.hasNext()) {
        HashMap row = (HashMap) it.next();
        Integer cId = (Integer) row.get("String_Node_Str");
        Integer cvId = (Integer) row.get("String_Node_Str");
        igId = (Integer) row.get("String_Node_Str");
        Integer itId = (Integer) row.get("String_Node_Str");
        Integer rsId = (Integer) row.get("String_Node_Str");
        String cvOID = (String) row.get("String_Node_Str");
        String igOID = (String) row.get("String_Node_Str");
        String itOID = (String) row.get("String_Node_Str");
        String igName = (String) row.get("String_Node_Str");
        String itName = (String) row.get("String_Node_Str");
        Integer dataTypeId = (Integer) row.get("String_Node_Str");
        Integer secId = (Integer) row.get("String_Node_Str");
        String header = (String) row.get("String_Node_Str");
        String left = (String) row.get("String_Node_Str");
        String right = (String) row.get("String_Node_Str");
        Boolean itRequired = (Boolean) row.get("String_Node_Str");
        String regexp = (String) row.get("String_Node_Str");
        String regexpErr = (String) row.get("String_Node_Str");
        String widthDecimal = (String) row.get("String_Node_Str");
        Integer rsTypeId = (Integer) row.get("String_Node_Str");
        String rsText = (String) row.get("String_Node_Str");
        String rsValue = (String) row.get("String_Node_Str");
        String rsLabel = (String) row.get("String_Node_Str");
        String igHeader = (String) row.get("String_Node_Str");
        String itDesc = (String) row.get("String_Node_Str");
        String itQuesNum = (String) row.get("String_Node_Str");
        String muOid = (String) row.get("String_Node_Str");
        if (cvprev != cvId) {
            if (itemGroupRefs != null && itemGroupRefs.size() > 0) {
                String temp = igMandatories.containsKey(igdprev) ? igMandatories.get(igdprev) : itMandatory;
                itemGroupRefs.get(itemGroupRefs.size() - 1).setMandatory(temp);
            }
            itMandatory = "String_Node_Str";
            cvprev = cvId;
            FormDefBean formDef = new FormDefBean();
            if (cvIdPoses.containsKey(cvId)) {
                int p = cvIdPoses.get(cvId);
                formDef = metadata.getFormDefs().get(p);
            } else {
                logger.debug("String_Node_Str" + cvId + "String_Node_Str");
            }
            itemGroupRefs = (ArrayList<ElementRefBean>) formDef.getItemGroupRefs();
        }
        String igDefKey = igId + "String_Node_Str";
        if (!igdprev.equals(igDefKey)) {
            if (igdPos.containsKey(igDefKey)) {
                igdef = itemGroupDefs.get(igdPos.get(igDefKey));
                isLatest = false;
                itOrder = igdef.getItemRefs().size();
            } else {
                igdef = new ItemGroupDefBean();
                itOrder = 0;
                igMandatories.put(igdprev, itMandatory);
                isLatest = true;
                igdef.setOid(igOID);
                igdef.setName("String_Node_Str".equalsIgnoreCase(igName) ? igOID : igName);
                igdef.setRepeating("String_Node_Str".equalsIgnoreCase(igName) ? "String_Node_Str" : "String_Node_Str");
                igdef.setComment(igHeader);
                igdef.setPreSASDatasetName(igName.toUpperCase());
                itemGroupDefs.add(igdef);
                igdPos.put(igDefKey, itemGroupDefs.size() - 1);
            }
            igdprev = igDefKey;
        }
        String igRefKey = igId + "String_Node_Str" + cvId;
        if (igrprev.equals(igRefKey)) {
            itMandatory = isLatest && itRequired && "String_Node_Str".equals(itMandatory) ? "String_Node_Str" : itMandatory;
        } else {
            if (!igset.contains(igRefKey)) {
                igset.add(igRefKey);
                ElementRefBean igref = new ElementRefBean();
                igref.setElementDefOID(igOID);
                int size = itemGroupRefs.size();
                if (size > 0) {
                    String prev = igrprev.split("String_Node_Str")[0].trim();
                    String temp = igMandatories.containsKey(prev) ? igMandatories.get(prev) : itMandatory;
                    itemGroupRefs.get(size - 1).setMandatory(temp);
                }
                itemGroupRefs.add(igref);
                itMandatory = "String_Node_Str";
            }
            igrprev = igRefKey;
        }
        String mandatory = itRequired ? "String_Node_Str" : "String_Node_Str";
        if (!itset.contains(igDefKey + "String_Node_Str" + itId)) {
            ++itOrder;
            itset.add(igDefKey + "String_Node_Str" + itId);
            ElementRefBean itemRef = new ElementRefBean();
            itemRef.setElementDefOID(itOID);
            if (itemRef.getMandatory() == null || itemRef.getMandatory().length() <= 0) {
                itemRef.setMandatory(mandatory);
            }
            itemRef.setOrderNumber(itOrder);
            igdef.getItemRefs().add(itemRef);
        }
        boolean hasCode = MetadataUnit.needCodeList(rsTypeId, dataTypeId);
        LinkedHashMap<String, String> codes = new LinkedHashMap<String, String>();
        if (hasCode) {
            codes = MetadataUnit.parseCode(rsText, rsValue);
        }
        boolean hasMultiSelect = MetadataUnit.needMultiSelectList(rsTypeId);
        LinkedHashMap<String, String> multi = new LinkedHashMap<String, String>();
        if (hasMultiSelect) {
            multi = MetadataUnit.parseCode(rsText, rsValue);
        }
        String datatype = MetadataUnit.getOdmItemDataType(rsTypeId, dataTypeId, odmVersion);
        if (sectionIds.contains("String_Node_Str" + secId + "String_Node_Str")) {
        } else {
            sectionIds += secId + "String_Node_Str";
        }
        if (!itdset.contains(itId)) {
            itdset.add(itId);
            ItemDefBean idef = new ItemDefBean();
            idef.setOid(itOID);
            idef.setName(itName);
            idef.setComment(itDesc);
            if (muOid != null && muOid.length() > 0) {
                ElementRefBean measurementUnitRef = new ElementRefBean();
                measurementUnitRef.setElementDefOID(muOid);
                idef.setMeasurementUnitRef(measurementUnitRef);
            }
            idef.setPreSASFieldName(itName);
            idef.setCodeListOID(hasCode ? "String_Node_Str" + rsId : "String_Node_Str");
            if (hasMultiSelect) {
                ElementRefBean multiSelectListRef = new ElementRefBean();
                multiSelectListRef.setElementDefOID("String_Node_Str" + rsId);
                idef.setMultiSelectListRef(multiSelectListRef);
            }
            idef.getQuestion().setQuestionNumber(itQuesNum);
            idef.getQuestion().getQuestion().setText(MetadataUnit.getItemQuestionText(header, left, right));
            if (regexp != null && regexp.startsWith("String_Node_Str")) {
                idef.setRangeCheck(MetadataUnit.getItemRangeCheck(regexp.substring(5).trim(), metadata.getSoftHard(), regexpErr, muOid));
            }
            idef.setDataType(datatype);
            int len = 0;
            int sig = 0;
            if (widthDecimal != null && widthDecimal.length() > 0) {
                len = parseWidth(widthDecimal);
                sig = parseDecimal(widthDecimal);
            }
            if (rsTypeId == 3 || rsTypeId == 7) {
                len = maxLengths.containsKey(itId) ? maxLengths.get(itId) : 0;
                len = Math.max(len, Math.max(rsText.length(), rsValue.length()));
                idef.setLength(len);
            } else if ("String_Node_Str".equalsIgnoreCase(datatype)) {
                if (len > 0) {
                    idef.setLength(len);
                } else {
                    idef.setLength(hasCode ? MetadataUnit.getDataTypeLength(codes.keySet()) : maxLengths.containsKey(itId) ? maxLengths.get(itId) : MetaDataCollector.getTextLength());
                }
            } else if ("String_Node_Str".equalsIgnoreCase(datatype)) {
                if (len > 0) {
                    idef.setLength(len);
                } else {
                    idef.setLength(hasCode ? MetadataUnit.getDataTypeLength(codes.keySet()) : 10);
                }
            } else if ("String_Node_Str".equalsIgnoreCase(datatype)) {
                if (len > 0) {
                    idef.setLength(len);
                } else {
                    idef.setLength(hasCode ? MetadataUnit.getDataTypeLength(codes.keySet()) : 25);
                }
            } else {
                idef.setLength(0);
            }
            idef.setSignificantDigits(sig > 0 ? sig : MetadataUnit.getSignificantDigits(datatype, codes.keySet(), hasCode));
            itemDefs.add(idef);
        }
        if (hasCode && !clset.contains(rsId)) {
            clset.add(rsId);
            CodeListBean cl = new CodeListBean();
            cl.setOid("String_Node_Str" + rsId);
            cl.setName(rsLabel);
            cl.setPreSASFormatName(rsLabel);
            cl.setDataType(datatype);
            Iterator<String> iter = codes.keySet().iterator();
            while (iter.hasNext()) {
                String de = iter.next();
                CodeListItemBean cli = new CodeListItemBean();
                cli.setCodedValue(de);
                TranslatedTextBean tt = cli.getDecode();
                tt.setText(codes.get(de));
                tt.setXmlLang(CoreResources.getField("String_Node_Str"));
                cli.setDecode(tt);
                cl.getCodeListItems().add(cli);
            }
            codeLists.add(cl);
        }
        if (odmVersion.startsWith("String_Node_Str") && hasMultiSelect && !mslset.contains(rsId)) {
            mslset.add(rsId);
            MultiSelectListBean msl = new MultiSelectListBean();
            msl.setOid("String_Node_Str" + rsId);
            msl.setName(rsLabel);
            msl.setDataType(datatype);
            msl.setActualDataType(datatype);
            Iterator<String> iter = multi.keySet().iterator();
            while (iter.hasNext()) {
                String de = iter.next();
                MultiSelectListItemBean msli = new MultiSelectListItemBean();
                msli.setCodedOptionValue(de);
                TranslatedTextBean tt = new TranslatedTextBean();
                String t = multi.get(de);
                tt.setText(t);
                tt.setXmlLang(CoreResources.getField("String_Node_Str"));
                msli.setDecode(tt);
                msl.getMultiSelectListItems().add(msli);
            }
            multiSelectLists.add(msl);
        }
    }
    if (itemGroupRefs != null && itemGroupRefs.size() > 0) {
        String last = igMandatories.containsKey(igId + "String_Node_Str") ? igMandatories.get(igId + "String_Node_Str") : itMandatory;
        itemGroupRefs.get(itemGroupRefs.size() - 1).setMandatory(last);
    }
    sectionIds = sectionIds.length() > 0 ? sectionIds.substring(1, sectionIds.length() - 1) : "String_Node_Str";
    metadata.setSectionIds(sectionIds);
}

Output:
     logger.debug("String_Node_Str");
-    logger.error("String_Node_Str" + this.getStudyEventAndFormMetaSql(parentStudyId, studyId, false));
+    logger.debug("String_Node_Str" + this.getStudyEventAndFormMetaSql(parentStudyId, studyId, false));
     ArrayList rows = this.select(this.getStudyEventAndFormMetaSql(parentStudyId, studyId, false));


Input:
public boolean store(final Node node, final IHashGroupify g, final int[] usedSnapshot) {
    if ((node.isAnonymous() || (g.size() > snapshotSizeDataset) || canPrune(node))) {
        return false;
    }
    if (usedSnapshot != null) {
        final double percentSize = (g.size() / ((double) usedSnapshot.length / config.getSnapshotLength()));
        if (percentSize > snapshotSizeSnapshot) {
            return false;
        }
    }
    final int[] data = createSnapshot(g);
    if (cache.size() >= maxSize) {
        purgeCache();
    }
    nodeToSnapshot.put(node, data);
    cache.append(node);
    return true;
}

Output:
     final int[] data = createSnapshot(g);
-    if (cache.size() >= maxSize) {
+    if (cache.size() >= size) {
         purgeCache();


Input:
boolean containsWrites() {
    return addCount + removeCount > 0;
}

Output:
 boolean containsWrites() {
-    return addCount + removeCount > 0;
+    return containsWrites;
 }


Input:
protected double updateHappinessAfterHunt(double foodHunted, double foodReceived) {
    double entitlement = getDataModel().getEconomicBelief() * foodHunted;
    double surplus = foodReceived - entitlement;
    Double currentHappiness = getDataModel().getCurrentHappiness();
    if (currentHappiness == null)
        currentHappiness = 0.5 * getDataModel().getEconomicBelief();
    double newHappiness = currentHappiness;
    if (surplus > 0) {
        newHappiness += ValueScaler.scale(surplus, entitlement, 0.01);
        if (newHappiness >= 1)
            return 1;
        else
            return newHappiness;
    }
    if (surplus < 0) {
        newHappiness -= ValueScaler.scale(Math.abs(surplus), entitlement, 0.01);
        if (newHappiness <= 0)
            return 0;
        else
            return newHappiness;
    }
    newHappiness += ValueScaler.scale(0, entitlement, 0.01);
    if (newHappiness >= 1)
        return 1;
    else
        return newHappiness;
}

Output:
         currentHappiness = 0.5 * getDataModel().getEconomicBelief();
-    double newHappiness = currentHappiness;
+    System.out.println("String_Node_Str" + currentHappiness);
     if (surplus > 0) {


Input:
protected boolean doExecute() throws Exception {
    EMFUtil emfUtil = new EMFUtil();
    for (File file : fileList) {
        if (file.isFile()) {
            URI uri = URI.createFileURI(file.getAbsolutePath());
            EObject eObject = null;
            try {
                Resource resource = emfUtil.getResourceSet().getResource(uri, true);
                eObject = resource.getContents().get(0);
                if (FactoriesUtil.isProvFile(uri.fileExtension())) {
                    for (EObject object : resource.getContents()) {
                        if (object instanceof Connection) {
                            eObject = object;
                            break;
                        }
                    }
                }
            } catch (Exception e) {
                log.warn("String_Node_Str" + file.getAbsolutePath(), e);
            }
            if (eObject != null) {
                if (eObject instanceof ModelElement) {
                    ModelElement modelElement = (ModelElement) eObject;
                    AElementPersistance writer = ElementWriterFactory.getInstance().create(uri.fileExtension());
                    Property oldPropery = PropertyHelper.getProperty(modelElement);
                    if (writer != null) {
                        Property property = writer.initProperty(modelElement);
                        if (oldPropery != null) {
                            property.setId(oldPropery.getId());
                            property.setAuthor(oldPropery.getAuthor());
                            property.getItem().setState(oldPropery.getItem().getState());
                        }
                        computePath(property, file);
                        URI propURI = uri.trimFileExtension().appendFileExtension(FactoriesUtil.PROPERTIES_EXTENSION);
                        Resource propResource = emfUtil.getResourceSet().createResource(propURI);
                        propResource.getContents().add(property);
                        propResource.getContents().add(property.getItem());
                        propResource.getContents().add(property.getItem().getState());
                        EMFUtil.saveResource(propResource);
                    } else {
                        log.warn("String_Node_Str" + modelElement.getName() + "String_Node_Str");
                    }
                } else {
                    log.warn("String_Node_Str" + eObject.toString());
                }
            }
        }
    }
    emfUtil = null;
    return true;
}

Output:
                         }
-                        computePath(property, file);
+                        if (file.getName().endsWith("String_Node_Str")) {
+                            System.out.println("String_Node_Str");
+                        }
+                        String statePathStr = PropertyHelper.computePath(property, file);
+                        property.getItem().getState().setPath(statePathStr);
                         URI propURI = uri.trimFileExtension().appendFileExtension(FactoriesUtil.PROPERTIES_EXTENSION);