Input:
protected Response removeAttribute(String persistenceUnit, String type, String key, String attribute, HttpHeaders hh, UriInfo ui, URI baseURI, InputStream in) {
    PersistenceContext app = getPersistenceFactory().get(persistenceUnit, baseURI, null);
    if (app == null || app.getClass(type) == null) {
        if (app == null) {
            JPARSLogger.fine("String_Node_Str", new Object[] { persistenceUnit });
        } else {
            JPARSLogger.fine("String_Node_Str", new Object[] { type, persistenceUnit });
        }
        return Response.status(Status.NOT_FOUND).build();
    }
    Map<String, String> discriminators = getParameterMap(ui, persistenceUnit);
    Object id = IdHelper.buildId(app, type, key, discriminators);
    Object entity = null;
    String partner = (String) getParameterMap(ui, attribute).get(RELATIONSHIP_PARTNER);
    try {
        ClassDescriptor descriptor = app.getDescriptor(type);
        DatabaseMapping mapping = (DatabaseMapping) descriptor.getMappingForAttributeName(attribute);
        if (!mapping.isForeignReferenceMapping()) {
            JPARSLogger.fine("String_Node_Str", new Object[] { attribute, type, key, persistenceUnit });
            return Response.status(Status.NOT_FOUND).build();
        }
        entity = app.unmarshalEntity(((ForeignReferenceMapping) mapping).getReferenceDescriptor().getAlias(), mediaType(hh.getAcceptableMediaTypes()), in);
    } catch (JAXBException e) {
        JPARSLogger.fine("String_Node_Str", new Object[] { type, persistenceUnit, e.toString() });
        return Response.status(Status.BAD_REQUEST).build();
    }
    Object result = app.removeAttribute(getParameterMap(ui, persistenceUnit), type, id, getHintMap(ui), attribute, entity, partner);
    if (result == null) {
        JPARSLogger.fine("String_Node_Str", new Object[] { attribute, type, key, persistenceUnit });
        return Response.status(Status.NOT_FOUND).build();
    } else {
        return Response.ok(new StreamingOutputMarshaller(app, result, hh.getAcceptableMediaTypes())).build();
    }
}

Output:
     }
-    Map<String, String> discriminators = getParameterMap(ui, persistenceUnit);
-    Object id = IdHelper.buildId(app, type, key, discriminators);
+    Object id = IdHelper.buildId(app, type, key);
     Object entity = null;


Input:
private void placeComponents() {
    FillLayout flMain = new FillLayout();
    flMain.marginHeight = 4;
    flMain.marginWidth = 2;
    GridLayout glContent = new GridLayout();
    glContent.verticalSpacing = 5;
    glContent.horizontalSpacing = 5;
    glContent.marginHeight = 0;
    glContent.marginWidth = 0;
    glContent.numColumns = 2;
    GridLayout glTicks = new GridLayout();
    glTicks.marginHeight = 4;
    glTicks.marginWidth = 4;
    glTicks.verticalSpacing = 2;
    glTicks.horizontalSpacing = 5;
    glTicks.numColumns = 2;
    this.setLayout(flMain);
    cmpContent = new Composite(this, SWT.NONE);
    cmpContent.setLayout(glContent);
    if (bLineGroupEnabled) {
        FillLayout flLines = new FillLayout();
        flLines.marginHeight = 1;
        flLines.marginWidth = 1;
        cmpLines = new Composite(cmpContent, SWT.NONE);
        GridData gdCMPLines = new GridData(GridData.FILL_BOTH);
        gdCMPLines.horizontalSpan = 2;
        cmpLines.setLayoutData(gdCMPLines);
        cmpLines.setLayout(flLines);
        int lineStyels = LineAttributesComposite.ENABLE_VISIBILITY | LineAttributesComposite.ENABLE_STYLES | LineAttributesComposite.ENABLE_WIDTH | LineAttributesComposite.ENABLE_COLOR | LineAttributesComposite.ENABLE_AUTO_COLOR;
        liacLines = new LineAttributesComposite(cmpLines, SWT.NONE, lineStyels, context, grid.getLineAttributes());
        liacLines.addListener(this);
        liacLines.setAttributesEnabled(ChartUIUtil.is3DWallFloorSet(context.getModel()));
    }
    boolean bTicksEnabled = this.context.getModel().getDimension().getValue() != ChartDimension.THREE_DIMENSIONAL;
    if (bTicksEnabled) {
        Group grpTicks = new Group(cmpContent, SWT.NONE);
        {
            GridData gdGRPTicks = new GridData(GridData.FILL_BOTH);
            gdGRPTicks.horizontalSpan = 2;
            grpTicks.setLayoutData(gdGRPTicks);
            grpTicks.setLayout(glTicks);
            grpTicks.setText(Messages.getString("String_Node_Str"));
        }
        int lineStyels = LineAttributesComposite.ENABLE_VISIBILITY | LineAttributesComposite.ENABLE_COLOR | LineAttributesComposite.ENABLE_AUTO_COLOR;
        liacTicks = new LineAttributesComposite(grpTicks, SWT.NONE, lineStyels, context, grid.getTickAttributes());
        {
            GridData gdLIACTicks = new GridData(GridData.FILL_HORIZONTAL);
            gdLIACTicks.horizontalSpan = 2;
            liacTicks.setLayoutData(gdLIACTicks);
            liacTicks.addListener(this);
        }
        boolean tickUIEnabled = !ChartUIExtensionUtil.isSetInvisible(grid.getTickAttributes());
        lblStyle = new Label(grpTicks, SWT.NONE);
        {
            GridData gdLBLStyle = new GridData();
            gdLBLStyle.horizontalIndent = 4;
            lblStyle.setLayoutData(gdLBLStyle);
            lblStyle.setText(Messages.getString("String_Node_Str"));
            lblStyle.setEnabled(tickUIEnabled);
        }
        cmbTickStyle = new Combo(grpTicks, SWT.DROP_DOWN | SWT.READ_ONLY);
        {
            GridData gdCMBTickStyle = new GridData(GridData.FILL_HORIZONTAL);
            cmbTickStyle.setLayoutData(gdCMBTickStyle);
            cmbTickStyle.addSelectionListener(this);
            cmbTickStyle.setEnabled(tickUIEnabled);
        }
        populateLists();
        setDefaultSelections();
    }
}

Output:
     }
-    boolean bTicksEnabled = this.context.getModel().getDimension().getValue() != ChartDimension.THREE_DIMENSIONAL;
-    if (bTicksEnabled) {
+    if (bTicksVisible) {
         Group grpTicks = new Group(cmpContent, SWT.NONE);


Input:
public static int getImageOrientation(Context ctx, String filePath) {
    Uri curStream;
    int orientation = 0;
    filePath = filePath.replace("String_Node_Str", "String_Node_Str");
    if (!filePath.contains("String_Node_Str"))
        curStream = Uri.parse("String_Node_Str" + filePath);
    else
        curStream = Uri.parse(filePath);
    try {
        Cursor cur = ctx.getContentResolver().query(curStream, new String[] { MediaStore.Images.Media.ORIENTATION }, null, null, null);
        if (cur != null) {
            if (cur.moveToFirst()) {
                orientation = cur.getInt(cur.getColumnIndex(MediaStore.Images.Media.ORIENTATION));
            }
            cur.close();
        }
    } catch (Exception errReadingContentResolver) {
        AppLog.e(AppLog.T.UTILS, errReadingContentResolver);
    }
    if (orientation == 0) {
        orientation = getExifOrientation(filePath);
    }
    return orientation;
}

Output:
     } catch (Exception errReadingContentResolver) {
-        AppLog.e(AppLog.T.UTILS, errReadingContentResolver);
+        AppLog.e(AppLog.T.UTILS, "String_Node_Str" + filePath, errReadingContentResolver);
     }


Input:
public void addSprite(Sprite sprite, Vector2 position) {
    sprites.add(sprite);
    spritePositionMap.put(sprite.getID(), position);
}

Output:
     sprites.add(sprite);
-    spritePositionMap.put(sprite.getID(), position);
+    positions.add(position);
+    indices.add(sprites.size() - 1);
 }


Input:
public void onClick(View v) {
    lastOpenId = ProfileSetupActivity.PROFILE_SETUP_WITH_EMAIL_AND_PASSWORD;
    lastOpen = bind.login;
    AlertDialog.Builder builder = new AlertDialog.Builder(SigninActivity.this);
    View view = getLayoutInflater().inflate(R.layout.dialog_email_password_holder, null);
    final EditText emailHolder = (EditText) view.findViewById(R.id.email_holder);
    final EditText passwordHolder = (EditText) view.findViewById(R.id.password_holder);
    final TextView done = (TextView) view.findViewById(R.id.done);
    builder.setView(view);
    final AlertDialog d = builder.create();
    d.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
    d.show();
    done.setOnClickListener(new View.OnClickListener() {
        public void onClick(View v) {
            dialog.show();
            d.cancel();
            emailPasswordSignin(emailHolder.getText().toString(), passwordHolder.getText().toString());
        }
    });
}

Output:
     lastOpenId = ProfileSetupActivity.PROFILE_SETUP_WITH_EMAIL_AND_PASSWORD;
-    lastOpen = bind.login;
+    lastOpenImg = bind.loginImg;
     AlertDialog.Builder builder = new AlertDialog.Builder(SigninActivity.this);


Input:
public NamedList addNamedList(NamedList target, String name, Object object) {
    NamedList<Object> list = new NamedList<>();
    target.add(name, list);
    for (Method method : object.getClass().getMethods()) {
        if (method.getParameterCount() > 0) {
            continue;
        }
        String fieldName = NameConverter.getFieldName(method.getName());
        if (fieldName == null) {
            continue;
        }
        if (fieldNames == null || fieldNames.contains(fieldName)) {
            try {
                list.add(fieldName, method.invoke(object));
            } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                System.out.println("String_Node_Str" + fieldName + "String_Node_Str" + method);
                throw new RuntimeException(e);
            }
        }
    }
    return list;
}

Output:
             } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
-                System.out.println("String_Node_Str" + fieldName + "String_Node_Str" + method);
-                throw new RuntimeException(e);
+                throw new RuntimeException(fieldName + "String_Node_Str" + e.getCause().getMessage(), e.getCause());
             }


Input:
protected float getGravityVelocity() {
    return 0;
}

Output:
 protected float getGravityVelocity() {
-    return 0;
+    return 0F;
 }


Input:
public final void register(IListenerOwner owner, Object listener) {
    Class<?> clazz = listener.getClass();
    while (clazz != null) {
        for (Method m : listener.getClass().getDeclaredMethods()) {
            if (!matches(m))
                continue;
            Class<? extends AEvent> event = m.getParameterTypes()[0].asSubclass(AEvent.class);
            boolean toMe = m.getAnnotation(ListenTo.class).sendToMe() && ADirectedEvent.class.isAssignableFrom(event);
            register(event, new AnnotationBasedEventListener(owner, listener, m, toMe));
        }
        clazz = clazz.getSuperclass();
    }
}

Output:
     while (clazz != null) {
-        for (Method m : listener.getClass().getDeclaredMethods()) {
+        for (Method m : clazz.getDeclaredMethods()) {
             if (!matches(m))


Input:
protected final Object fetch(int index, boolean recordHitsOrMisses) {
    getReadWriteLock().writeLock().lock();
    try {
        Object value = null;
        IndexedTreeNode indexNode = indexTree.getNode(index);
        Object nodeValue = indexNode.getValue();
        if (EMPTY_INDEX_NODE != nodeValue && nodeValue != null) {
            if (recordHitsOrMisses)
                cacheHits++;
            IndexedTreeNode cacheNode = (IndexedTreeNode) indexNode.getValue();
            AgedNode agedNode = (AgedNode) cacheNode.getValue();
            value = agedNode.getValue();
            cacheNode.removeFromTree();
            indexNode.setValue(cache.addByNode(agedNode));
        } else {
            if (recordHitsOrMisses)
                cacheMisses++;
            value = source.get(index);
            if (currentSize < maxSize) {
                currentSize++;
                IndexedTreeNode cacheNode = cache.addByNode(new AgedNode(indexNode, value));
                indexNode.setValue(cacheNode);
            } else {
                IndexedTreeNode oldestInCache = cache.getNode(0);
                oldestInCache.removeFromTree();
                AgedNode oldAgedNode = (AgedNode) oldestInCache.getValue();
                IndexedTreeNode oldIndexNode = oldAgedNode.getIndexNode();
                oldIndexNode.setValue(EMPTY_INDEX_NODE);
                IndexedTreeNode cacheNode = cache.addByNode(new AgedNode(indexNode, value));
                indexNode.setValue(cacheNode);
            }
        }
        return value;
    } finally {
        getReadWriteLock().writeLock().unlock();
    }
}

Output:
 protected final Object fetch(int index, boolean recordHitsOrMisses) {
-    getReadWriteLock().writeLock().lock();
-    try {
-        Object value = null;
-        IndexedTreeNode indexNode = indexTree.getNode(index);
-        Object nodeValue = indexNode.getValue();
-        if (EMPTY_INDEX_NODE != nodeValue && nodeValue != null) {
-            if (recordHitsOrMisses)
-                cacheHits++;
-            IndexedTreeNode cacheNode = (IndexedTreeNode) indexNode.getValue();
-            AgedNode agedNode = (AgedNode) cacheNode.getValue();
-            value = agedNode.getValue();
-            cacheNode.removeFromTree();
-            indexNode.setValue(cache.addByNode(agedNode));
+    Object value = null;
+    IndexedTreeNode indexNode = indexTree.getNode(index);
+    Object nodeValue = indexNode.getValue();
+    if (EMPTY_INDEX_NODE != nodeValue && nodeValue != null) {
+        if (recordHitsOrMisses)
+            cacheHits++;
+        IndexedTreeNode cacheNode = (IndexedTreeNode) indexNode.getValue();
+        AgedNode agedNode = (AgedNode) cacheNode.getValue();
+        value = agedNode.getValue();
+        cacheNode.removeFromTree();
+        indexNode.setValue(cache.addByNode(agedNode));
+    } else {
+        if (recordHitsOrMisses)
+            cacheMisses++;
+        value = source.get(index);
+        if (currentSize < maxSize) {
+            currentSize++;
+            IndexedTreeNode cacheNode = cache.addByNode(new AgedNode(indexNode, value));
+            indexNode.setValue(cacheNode);
         } else {


Input:
public static double[] adaptedRandIndexStats3DN2(ImagePlus segA, ImagePlus segB) {
    if (segA.getImageStack().getProcessor(1) instanceof ShortProcessor == false || segB.getImageStack().getProcessor(1) instanceof ShortProcessor == false)
        return null;
    int nSlices = segA.getImageStackSize();
    int nLabelsA = 0;
    int nLabelsB = 0;
    for (int slice = 1; slice <= nSlices; slice++) {
        ImageProcessor gt = segA.getImageStack().getProcessor(slice);
        gt.resetMinAndMax();
        if (nLabelsA < gt.getMax())
            nLabelsA = (int) gt.getMax();
        ImageProcessor proposal = segB.getImageStack().getProcessor(slice);
        proposal.resetMinAndMax();
        if (nLabelsB < proposal.getMax())
            nLabelsB = (int) proposal.getMax();
    }
    long[][] pij = new long[nLabelsA + 1][nLabelsB + 1];
    double n = segA.getImageStackSize() * segA.getWidth() * segA.getHeight();
    for (int slice = 1; slice <= nSlices; slice++) {
        ShortProcessor cluster1 = (ShortProcessor) segA.getImageStack().getProcessor(slice);
        ShortProcessor cluster2 = (ShortProcessor) segB.getImageStack().getProcessor(slice);
        final short[] pixels1 = (short[]) cluster1.getPixels();
        final short[] pixels2 = (short[]) cluster2.getPixels();
        double nPixels = pixels1.length;
        for (int i = 0; i < nPixels; i++) pij[pixels1[i]][pixels2[i]]++;
    }
    double[] ai = new double[pij.length];
    for (int i = 1; i < pij.length; i++) for (int j = 0; j < pij[0].length; j++) {
        ai[i] += pij[i][j];
    }
    double[] bj = new double[pij[0].length];
    for (int j = 1; j < pij[0].length; j++) for (int i = 1; i < pij.length; i++) {
        bj[j] += pij[i][j];
    }
    double[] pi0 = new double[pij.length];
    double aux = 0;
    for (int i = 1; i < pij.length; i++) {
        pi0[i] = pij[i][0];
        aux += pi0[i];
    }
    double sumA = 0;
    for (int i = 0; i < ai.length; i++) sumA += ai[i] * ai[i];
    double sumB = 0;
    for (int j = 0; j < bj.length; j++) sumB += bj[j] * bj[j];
    sumB += aux / n;
    double sumAB = 0;
    for (int i = 1; i < pij.length; i++) for (int j = 1; j < pij[0].length; j++) sumAB += pij[i][j] * pij[i][j];
    sumAB += aux / n;
    return new double[] { sumAB / sumB, sumAB / sumA, 1.0 - (sumA + sumB - 2.0 * sumAB) / (n * n) };
}

Output:
         double nPixels = pixels1.length;
-        for (int i = 0; i < nPixels; i++) pij[pixels1[i]][pixels2[i]]++;
+        for (int i = 0; i < nPixels; i++) pij[pixels1[i] & 0xffff][pixels2[i] & 0xffff]++;
     }


Input:
public void setupClasspathScript() throws IOException {
    if (hbaseProtocolJarPaths.isEmpty()) {
        LOG.info("String_Node_Str");
        return;
    }
    File exploreHadoopBin = new File(directory, "String_Node_Str");
    LOG.info("String_Node_Str", hbaseProtocolJarPaths);
    String hadoopBin = hiveConf.get(HiveConf.ConfVars.HADOOPBIN.toString());
    StringBuilder fileBuilder = new StringBuilder();
    fileBuilder.append("String_Node_Str");
    fileBuilder.append("String_Node_Str");
    fileBuilder.append("String_Node_Str");
    fileBuilder.append("String_Node_Str");
    fileBuilder.append("String_Node_Str");
    fileBuilder.append("String_Node_Str");
    fileBuilder.append("String_Node_Str");
    fileBuilder.append("String_Node_Str").append(File.pathSeparatorChar).append("String_Node_Str").append("String_Node_Str").append(Joiner.on(':').join(hiveAuxJars)).append(Joiner.on(' ').join(hbaseProtocolJarPaths)).append(')').append("String_Node_Str");
    fileBuilder.append("String_Node_Str");
    fileBuilder.append("String_Node_Str");
    fileBuilder.append("String_Node_Str");
    fileBuilder.append("String_Node_Str");
    fileBuilder.append("String_Node_Str").append(hadoopBin).append("String_Node_Str");
    Files.write(fileBuilder.toString(), exploreHadoopBin, Charsets.UTF_8);
    if (!exploreHadoopBin.setExecutable(true, false)) {
        throw new RuntimeException("String_Node_Str" + exploreHadoopBin.getAbsolutePath());
    }
    LOG.info("String_Node_Str", exploreHadoopBin.getAbsolutePath());
    System.setProperty(HiveConf.ConfVars.HADOOPBIN.toString(), exploreHadoopBin.getAbsolutePath());
}

Output:
     fileBuilder.append("String_Node_Str");
-    fileBuilder.append("String_Node_Str").append(File.pathSeparatorChar).append("String_Node_Str").append("String_Node_Str").append(Joiner.on(':').join(hiveAuxJars)).append(Joiner.on(' ').join(hbaseProtocolJarPaths)).append(')').append("String_Node_Str");
+    fileBuilder.append("String_Node_Str").append(File.pathSeparatorChar).append("String_Node_Str").append(Joiner.on(' ').join(hiveAuxJars)).append("String_Node_Str").append(Joiner.on(' ').join(hbaseProtocolJarPaths)).append(')').append("String_Node_Str");
+    fileBuilder.append("String_Node_Str");
+    fileBuilder.append("String_Node_Str");
+    fileBuilder.append("String_Node_Str");
     fileBuilder.append("String_Node_Str");


Input:
public void updateConfiguration(Configuration config, DisplayMetrics metrics) {
    synchronized (mTmpValue) {
        int configChanges = 0xfffffff;
        if (config != null) {
            configChanges = mConfiguration.updateFrom(config);
        }
        if (mConfiguration.locale == null) {
            mConfiguration.locale = Locale.getDefault();
        }
        if (metrics != null) {
            mMetrics.setTo(metrics);
            mMetrics.updateMetrics(mCompatibilityInfo, mConfiguration.orientation, mConfiguration.screenLayout);
        }
        mMetrics.scaledDensity = mMetrics.density * mConfiguration.fontScale;
        String locale = null;
        if (mConfiguration.locale != null) {
            locale = mConfiguration.locale.getLanguage();
            if (mConfiguration.locale.getCountry() != null) {
                locale += "String_Node_Str" + mConfiguration.locale.getCountry();
            }
        }
        int width, height;
        if (mMetrics.widthPixels >= mMetrics.heightPixels) {
            width = mMetrics.widthPixels;
            height = mMetrics.heightPixels;
        } else {
            width = mMetrics.heightPixels;
            height = mMetrics.widthPixels;
        }
        int keyboardHidden = mConfiguration.keyboardHidden;
        if (keyboardHidden == Configuration.KEYBOARDHIDDEN_NO && mConfiguration.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_YES) {
            keyboardHidden = Configuration.KEYBOARDHIDDEN_SOFT;
        }
        mAssets.setConfiguration(mConfiguration.mcc, mConfiguration.mnc, locale, mConfiguration.orientation, mConfiguration.touchscreen, (int) (mMetrics.density * 160), mConfiguration.keyboard, keyboardHidden, mConfiguration.navigation, width, height, mConfiguration.screenLayout, mConfiguration.uiMode, sSdkVersion);
        int N = mDrawableCache.size();
        if (DEBUG_CONFIG) {
            Log.d(TAG, "String_Node_Str" + Integer.toHexString(configChanges));
        }
        for (int i = 0; i < N; i++) {
            WeakReference<Drawable.ConstantState> ref = mDrawableCache.valueAt(i);
            if (ref != null) {
                Drawable.ConstantState cs = ref.get();
                if (cs != null) {
                    if (Configuration.needNewResources(configChanges, cs.getChangingConfigurations())) {
                        if (DEBUG_CONFIG) {
                            Log.d(TAG, "String_Node_Str" + Long.toHexString(mDrawableCache.keyAt(i)) + "String_Node_Str" + cs + "String_Node_Str" + Integer.toHexString(cs.getChangingConfigurations()));
                        }
                        mDrawableCache.setValueAt(i, null);
                    } else if (DEBUG_CONFIG) {
                        Log.d(TAG, "String_Node_Str" + Long.toHexString(mDrawableCache.keyAt(i)) + "String_Node_Str" + cs + "String_Node_Str" + Integer.toHexString(cs.getChangingConfigurations()) + "String_Node_Str");
                    }
                }
            }
        }
        mDrawableCache.clear();
        mColorStateListCache.clear();
        flushLayoutCache();
    }
    synchronized (mSync) {
        if (mPluralRule != null) {
            mPluralRule = PluralRules.ruleForLocale(config.locale);
        }
    }
}

Output:
         mAssets.setConfiguration(mConfiguration.mcc, mConfiguration.mnc, locale, mConfiguration.orientation, mConfiguration.touchscreen, (int) (mMetrics.density * 160), mConfiguration.keyboard, keyboardHidden, mConfiguration.navigation, width, height, mConfiguration.screenLayout, mConfiguration.uiMode, sSdkVersion);
-        int N = mDrawableCache.size();
-        if (DEBUG_CONFIG) {
-            Log.d(TAG, "String_Node_Str" + Integer.toHexString(configChanges));
-        }
-        for (int i = 0; i < N; i++) {
-            WeakReference<Drawable.ConstantState> ref = mDrawableCache.valueAt(i);
-            if (ref != null) {
-                Drawable.ConstantState cs = ref.get();
-                if (cs != null) {
-                    if (Configuration.needNewResources(configChanges, cs.getChangingConfigurations())) {
-                        if (DEBUG_CONFIG) {
-                            Log.d(TAG, "String_Node_Str" + Long.toHexString(mDrawableCache.keyAt(i)) + "String_Node_Str" + cs + "String_Node_Str" + Integer.toHexString(cs.getChangingConfigurations()));
-                        }
-                        mDrawableCache.setValueAt(i, null);
-                    } else if (DEBUG_CONFIG) {
-                        Log.d(TAG, "String_Node_Str" + Long.toHexString(mDrawableCache.keyAt(i)) + "String_Node_Str" + cs + "String_Node_Str" + Integer.toHexString(cs.getChangingConfigurations()) + "String_Node_Str");
-                    }
-                }
-            }
-        }
-        mDrawableCache.clear();
+        drawableCacheClear(mDrawableCache, configChanges);
+        drawableCacheClear(mColorDrawableCache, configChanges);
         mColorStateListCache.clear();


Input:
protected boolean getNextAction(Game game) {
    if (root != null && root.children.size() > 0) {
        SimulationNode2 test = root;
        root = root.children.get(0);
        while (root.children.size() > 0 && !root.playerId.equals(playerId)) {
            test = root;
            root = root.children.get(0);
        }
        logger.trace("String_Node_Str" + game.getState().getValue(true) + "String_Node_Str" + test.gameValue);
        if (!suggested.isEmpty()) {
            return false;
        }
        if (root.playerId.equals(playerId) && root.abilities != null && game.getState().getValue(true).hashCode() == test.gameValue) {
            logger.info("String_Node_Str");
            actions = new LinkedList<Ability>(root.abilities);
            combat = root.combat;
            return true;
        } else {
            return false;
        }
    }
    return false;
}

Output:
             logger.info("String_Node_Str");
-            actions = new LinkedList<Ability>(root.abilities);
+            actions = new LinkedList<>(root.abilities);
             combat = root.combat;


Input:
public void put(String whereSql, ShardingDBResource db, List data) {
    if (StringUtil.isBlank(whereSql)) {
        return;
    }
    try {
        String versionKey = _buildShardingVersion(db);
        int version = r.nextInt(10000);
        if (!_exists(versionKey)) {
            this.memClient.incr(versionKey, 0, version);
        } else {
            version = Integer.parseInt((String) this.memClient.get(versionKey));
        }
        String cacheKey = _buildShardingCacheKey(whereSql, db, version);
        this.memClient.set(cacheKey, expire, data);
        if (LOG.isDebugEnabled()) {
            LOG.debug("String_Node_Str" + cacheKey);
        }
    } catch (Exception e) {
        LOG.warn("String_Node_Str");
    }
}

Output:
 public void put(String whereSql, ShardingDBResource db, List data) {
-    if (StringUtil.isBlank(whereSql)) {
+    if (StringUtil.isBlank(whereSql) || data == null || data.isEmpty()) {
         return;


Input:
public Suite parse() throws InvalidStructureException, IOException, XmlPullParserException {
    checkNode("String_Node_Str");
    String sVersion = parser.getAttributeValue(null, "String_Node_Str");
    int version = Integer.parseInt(sVersion);
    Hashtable<String, Detail> details = new Hashtable<String, Detail>();
    Hashtable<String, Entry> entries = new Hashtable<String, Entry>();
    Vector<Menu> menus = new Vector<Menu>();
    try {
        parser.next();
        int eventType;
        eventType = parser.getEventType();
        do {
            if (eventType == KXmlParser.END_DOCUMENT) {
            } else if (eventType == KXmlParser.START_TAG) {
                if (parser.getName().toLowerCase().equals("String_Node_Str")) {
                    Entry e = new EntryParser(parser).parse();
                    entries.put(e.getCommandId(), e);
                } else if (parser.getName().toLowerCase().equals("String_Node_Str")) {
                    Entry e = new ViewParser(parser).parse();
                    entries.put(e.getCommandId(), e);
                } else if (parser.getName().toLowerCase().equals("String_Node_Str")) {
                    String localeKey = parser.getAttributeValue(null, "String_Node_Str");
                    parser.nextTag();
                    Resource r = new ResourceParser(parser).parse();
                    table.addResource(r, table.getInstallers().getLocaleFileInstaller(localeKey), resourceGuid);
                } else if (parser.getName().toLowerCase().equals("String_Node_Str")) {
                    String path = parser.getAttributeValue(null, "String_Node_Str");
                    while (this.nextTagInBlock("String_Node_Str")) {
                        Resource r = new ResourceParser(parser).parse();
                        table.addResource(r, table.getInstallers().getMediaInstaller(path), resourceGuid);
                    }
                } else if (parser.getName().toLowerCase().equals("String_Node_Str")) {
                    parser.nextTag();
                    Resource r = new ResourceParser(parser).parse();
                    table.addResource(r, table.getInstallers().getXFormInstaller(), resourceGuid);
                } else if (parser.getName().toLowerCase().equals("String_Node_Str")) {
                    Detail d = new DetailParser(parser).parse();
                    details.put(d.getId(), d);
                } else if (parser.getName().toLowerCase().equals("String_Node_Str")) {
                    Menu m = new MenuParser(parser).parse();
                    menus.addElement(m);
                } else {
                    System.out.println("String_Node_Str" + parser.getName());
                }
            } else if (eventType == KXmlParser.END_TAG) {
            } else if (eventType == KXmlParser.TEXT) {
            }
            eventType = parser.next();
        } while (eventType != KXmlParser.END_DOCUMENT);
        suite = new Suite(version, details, entries, menus);
        return suite;
    } catch (XmlPullParserException e) {
        e.printStackTrace();
        throw new InvalidStructureException("String_Node_Str", parser);
    } catch (IOException e) {
        e.printStackTrace();
        throw new InvalidStructureException("String_Node_Str", parser);
    } catch (StorageFullException e) {
        e.printStackTrace();
        throw new InvalidStructureException("String_Node_Str", parser);
    }
}

Output:
                     parser.nextTag();
-                    Resource r = new ResourceParser(parser).parse();
+                    Resource r = new ResourceParser(parser, maximumResourceAuthority).parse();
                     table.addResource(r, table.getInstallers().getLocaleFileInstaller(localeKey), resourceGuid);


Input:
private static boolean intersect(final double[] outerBounds, final double[] bounds) {
    return contains(outerBounds, bounds[0], bounds[2]) || contains(outerBounds, bounds[0], bounds[3]) || contains(outerBounds, bounds[1], bounds[2]) || contains(outerBounds, bounds[1], bounds[3]);
}

Output:
 private static boolean intersect(final double[] outerBounds, final double[] bounds) {
-    return contains(outerBounds, bounds[0], bounds[2]) || contains(outerBounds, bounds[0], bounds[3]) || contains(outerBounds, bounds[1], bounds[2]) || contains(outerBounds, bounds[1], bounds[3]);
+    return contains(outerBounds, bounds[0], bounds[2]) || contains(outerBounds, bounds[0], bounds[3]) || contains(outerBounds, bounds[1], bounds[2]) || contains(outerBounds, bounds[1], bounds[3]) || contains(bounds, outerBounds[0], outerBounds[2]) || contains(bounds, outerBounds[0], outerBounds[3]) || contains(bounds, outerBounds[1], outerBounds[2]) || contains(bounds, outerBounds[1], outerBounds[3]);
 }


Input:
public void onBar(Instrument instrument, Period period, IBar askBar, IBar bidBar) throws JFException {
    if (!instrument.equals(this.instrument) || !period.equals(this.period))
        return;
    if (askBar.getVolume() == 0 || bidBar.getVolume() == 0)
        return;
    IBar prevBar = history.getBar(instrument, period, OfferSide.BID, 1);
    double[][] ha = indicators.heikinAshi(instrument, period, OfferSide.BID, indicatorFilter, numberOfCandlesBefore, prevBar.getTime(), numberOfCandlesAfter);
    final int PREV = numberOfCandlesBefore + numberOfCandlesAfter - 1;
    final int OPEN = 0, HIGH = 2, LOW = 3, CLOSE = 1;
    double average = priceToPips(((ha[PREV][HIGH] - ha[PREV][LOW]) + (ha[PREV - 1][HIGH] - ha[PREV - 1][LOW])) / 2.0);
    double spread = askPrice - bidPrice;
    stopLossPips = roundPips(stopLossFactor * average);
    if (stopLossPips < stopLossFactor)
        return;
    double volume = getLotSize(account);
    takeProfitPips = roundPips(takeProfitFactor * average);
    if (takeProfitPips < takeProfitFactor)
        return;
    if (!useStopLoss)
        stopLossPips = 0;
    double[][] dc = indicators.donchian(instrument, period, OfferSide.BID, dcTimePeriod, indicatorFilter, numberOfCandlesBefore, prevBar.getTime(), numberOfCandlesAfter);
    final int UPPER = 0, LOWER = 1;
    double[] maf = indicators.ma(instrument, period, OfferSide.BID, appliedPriceFast, maTimePeriodFast, maTypeFast, indicatorFilter, numberOfCandlesBefore, prevBar.getTime(), numberOfCandlesAfter);
    double[] mas = indicators.ma(instrument, period, OfferSide.BID, appliedPriceSlow, maTimePeriodSlow, maTypeSlow, indicatorFilter, numberOfCandlesBefore, prevBar.getTime(), numberOfCandlesAfter);
    if (askPrice < maf[PREV]) {
        for (IOrder order : engine.getOrders()) {
            if (order.getLabel().substring(0, id.length()).equals(id) && order.getState() == IOrder.State.FILLED) {
                if (order.isLong() && order.getProfitLossInPips() > stopLossFactor)
                    order.close();
            }
        }
    } else if (bidPrice > maf[PREV]) {
        for (IOrder order : engine.getOrders()) {
            if (order.getLabel().substring(0, id.length()).equals(id) && order.getState() == IOrder.State.FILLED) {
                if (!order.isLong() && order.getProfitLossInPips() > stopLossFactor)
                    order.close();
            }
        }
    }
    double amt = 0;
    boolean uol = account.getUseOfLeverage() > maximumUoL;
    if (uol) {
        for (IOrder order : engine.getOrders(instrument)) {
            if (order.getState() == IOrder.State.FILLED) {
                if (order.isLong())
                    amt += order.getAmount();
                else
                    amt -= order.getAmount();
            }
        }
    }
    boolean longOk = (uol && amt > 0) ? false : true;
    boolean shortOk = (uol && amt < 0) ? false : true;
    if (verbose) {
        SimpleDateFormat bdf = new SimpleDateFormat("String_Node_Str");
        bdf.setTimeZone(TimeZone.getTimeZone("String_Node_Str"));
        console.getOut().printf("String_Node_Str", bdf.format(roundTime(prevBar.getTime(), 60000)));
        console.getOut().printf("String_Node_Str", Arrays.deepToString(ha));
        console.getOut().printf("String_Node_Str", Arrays.deepToString(dc));
        console.getOut().printf("String_Node_Str", Arrays.toString(maf));
        console.getOut().printf("String_Node_Str", Arrays.toString(mas));
        console.getOut().printf("String_Node_Str", bidPrice, askPrice, stopLossPips, takeProfitPips);
        console.getOut().printf("String_Node_Str", average, spread, volume);
        if (uol)
            console.getOut().printf("String_Node_Str", amt, account.getUseOfLeverage());
    }
    if (longOk && bidPrice + spread < dc[LOWER][PREV] && dc[LOWER][PREV] < dc[LOWER][PREV - 1]) {
        double stopLossPrice = stopLossPips > 0 ? stopLossPrice = askPrice - getPipPrice(stopLossPips) : 0;
        double takeProfitPrice = askPrice + getPipPrice(takeProfitPips);
        console.getOut().printf("String_Node_Str", getLabel(instrument), instrument.name(), askPrice, volume, stopLossPrice, takeProfitPrice);
        IOrder order = engine.submitOrder(getLabel(instrument), instrument, OrderCommand.BUY, volume, askPrice, slippage, stopLossPrice, takeProfitPrice);
    }
    if (shortOk && askPrice > dc[UPPER][PREV] && dc[UPPER][PREV] > dc[UPPER][PREV - 1]) {
        double stopLossPrice = stopLossPips > 0 ? stopLossPrice = bidPrice + getPipPrice(stopLossPips) : 0;
        double takeProfitPrice = bidPrice - getPipPrice(takeProfitPips);
        console.getOut().printf("String_Node_Str", getLabel(instrument), instrument.name(), bidPrice, volume, stopLossPrice, takeProfitPrice);
        IOrder order = engine.submitOrder(getLabel(instrument), instrument, OrderCommand.SELL, volume, bidPrice, slippage, stopLossPrice, takeProfitPrice);
    }
}

Output:
     double[][] ha = indicators.heikinAshi(instrument, period, OfferSide.BID, indicatorFilter, numberOfCandlesBefore, prevBar.getTime(), numberOfCandlesAfter);
-    final int PREV = numberOfCandlesBefore + numberOfCandlesAfter - 1;
-    final int OPEN = 0, HIGH = 2, LOW = 3, CLOSE = 1;
-    double average = priceToPips(((ha[PREV][HIGH] - ha[PREV][LOW]) + (ha[PREV - 1][HIGH] - ha[PREV - 1][LOW])) / 2.0);
+    double average = priceToPips(instrument, ((ha[PREV][HIGH] - ha[PREV][LOW]) + (ha[PREV - 1][HIGH] - ha[PREV - 1][LOW])) / 2.0);
     double spread = askPrice - bidPrice;


Input:
public void run() {
    super.run();
    while (stopFlag == false) {
        checkConnectedDevices();
        synchronized (deviceGrantQueue) {
            if (!deviceGrantQueue.isEmpty() && !isGranting) {
                isGranting = true;
                grantingDevice = deviceGrantQueue.remove();
                PendingIntent permissionIntent = PendingIntent.getBroadcast(context, 0, new Intent(UsbMidiGrantedReceiver.USB_PERMISSION_GRANTED_ACTION), 0);
                context.registerReceiver(new UsbMidiGrantedReceiver(grantingDevice, deviceAttachedListener), new IntentFilter(UsbMidiGrantedReceiver.USB_PERMISSION_GRANTED_ACTION));
                usbManager.requestPermission(grantingDevice, permissionIntent);
            }
        }
        try {
            sleep(1000);
        } catch (InterruptedException e) {
        }
    }
    for (UsbDevice device : grantedDevices) {
        Message message = deviceDetachedHandler.obtainMessage();
        message.obj = device;
        deviceDetachedHandler.sendMessage(message);
    }
    grantedDevices.clear();
}

Output:
     for (UsbDevice device : grantedDevices) {
-        Message message = deviceDetachedHandler.obtainMessage();
-        message.obj = device;
-        deviceDetachedHandler.sendMessage(message);
+        onDeviceDetached(device);
     }


Input:
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (!(obj instanceof IndexDefinition))
        return false;
    IndexDefinition other = (IndexDefinition) obj;
    if (!Arrays.equals(indexedFields, other.indexedFields))
        return false;
    if (!Arrays.equals(orderFields, other.orderFields))
        return false;
    return true;
}

Output:
         return false;
-    return true;
+    if (indexedFields.length != other.indexedFields.length) {
+        return false;
+    }
+    int matchCount = 0;
+    for (int i = 0; i < indexedFields.length; i++) {
+        for (int j = 0; j < other.indexedFields.length; j++) {
+            if (indexedFields[i].equals(other.indexedFields[i])) {
+                matchCount++;
+                continue;
+            }
+        }
+    }
+    return matchCount == indexedFields.length;
 }


Input:
public boolean setPositivExamplesChecked(String indi) {
    boolean isChecked = false;
    if (individual.toString().contains(indi)) {
        isChecked = true;
    }
    return isChecked;
}

Output:
     boolean isChecked = false;
-    if (individual.toString().contains(indi)) {
-        isChecked = true;
+    if (individual != null) {
+        if (individual.toString().contains(indi)) {
+            isChecked = true;
+        }
     }


Input:
public Object getElementInfo() throws JavaModelException {
    try {
        return super.getElementInfo();
    } catch (JavaModelException jme) {
        if (!jme.getJavaModelStatus().isDoesNotExist()) {
            throw jme;
        }
        final IType anonType = this;
        return new org.eclipse.jdt.internal.core.SourceTypeElementInfo() {

            {
                setHandle(anonType);
                setFlags(inner.getModifiers());
                ClassNode[] faces = inner.getInterfaces();
                char[][] names = new char[faces.length][];
                for (int i = 0; i < faces.length; i += 1) {
                    names[i] = faces[i].getName().toCharArray();
                }
                setSuperInterfaceNames(names);
                setSuperclassName(inner.getUnresolvedSuperClass().getName().toCharArray());
                setNameSourceStart(inner.getNameStart());
                setNameSourceEnd(inner.getNameEnd());
                setSourceRangeStart(inner.getStart());
                setSourceRangeEnd(inner.getEnd());
            }
        };
    }
}

Output:
         }
-        final IType anonType = this;
-        return new org.eclipse.jdt.internal.core.SourceTypeElementInfo() {
+        return new org.eclipse.jdt.internal.core.SourceMethodInfo() {


Input:
public void addInformation(ItemStack stack, EntityPlayer playerIn, List<String> tooltip, boolean advanced) {
    NBTTagCompound plateNBT = getPlateNBT(stack);
    if (plateNBT != null) {
        ItemStack plateStack = ItemStack.loadItemStackFromNBT(plateNBT.getCompoundTag("String_Node_Str"));
        if (plateStack != null) {
            tooltip.add(TextFormatting.BLUE + plateStack.getDisplayName());
        }
    }
    super.addInformation(stack, playerIn, tooltip, advanced);
}

Output:
     if (plateNBT != null) {
-        ItemStack plateStack = ItemStack.loadItemStackFromNBT(plateNBT.getCompoundTag("String_Node_Str"));
+        ItemStack plateStack = new ItemStack(plateNBT.getCompoundTag("String_Node_Str"));
         if (plateStack != null) {


Input:
public DeploymentInfoWorkingCopy load() throws CoreException {
    DeploymentInfoWorkingCopy workingCopy = appModule.getDeploymentInfoWorkingCopy();
    Map<Object, Object> results = parseManifestFromFile();
    if (results == null) {
        return null;
    }
    Map<Object, Object> applications = getContainingPropertiesMap(results, APPLICATIONS_PROP);
    if (applications == null) {
        throw CloudErrorUtil.toCoreException("String_Node_Str" + relativePath + "String_Node_Str");
    }
    String appName = getValue(applications, NAME_PROP);
    if (appName != null) {
        workingCopy.setDeploymentName(appName);
    }
    String memoryVal = getValue(applications, MEMORY_PROP);
    if (memoryVal != null) {
        int memory = Integer.valueOf(memoryVal);
        if (memory > 0) {
            workingCopy.setMemory(memory);
        }
    }
    String host = getValue(applications, SUB_DOMAIN_PROP);
    if (host != null) {
        CloudApplicationUrlLookup lookup = CloudApplicationUrlLookup.getCurrentLookup(cloudServer);
        CloudApplicationURL defaultUrl = lookup.getDefaultApplicationURL(host);
        if (defaultUrl != null) {
            List<String> urls = Arrays.asList(defaultUrl.getUrl());
            workingCopy.setUris(urls);
        }
    }
    Map<Object, Object> services = getContainingPropertiesMap(applications, SERVICES_PROP);
    if (services != null) {
        List<String> servicesToBind = new ArrayList<String>();
        for (Entry<Object, Object> entry : services.entrySet()) {
            Object serviceNameObj = entry.getKey();
            if (serviceNameObj instanceof String) {
                String serviceName = (String) serviceNameObj;
                if (!servicesToBind.contains(serviceName)) {
                    servicesToBind.add(serviceName);
                }
            }
        }
        workingCopy.setServices(servicesToBind);
    }
    return workingCopy;
}

Output:
     }
-    String appName = getValue(applications, NAME_PROP);
+    String appName = getStringValue(applications, NAME_PROP);
     if (appName != null) {


Input:
private void setQueryExpression(String expression, boolean isSharing) {
    if (ChartUIConstants.QUERY_VALUE.equals(queryType)) {
        if (!(context.getChartType() instanceof GanttChart) && !context.getDataServiceProvider().checkState(IDataServiceProvider.SHARE_QUERY) && context.getDataServiceProvider().checkState(IDataServiceProvider.HAS_DATA_SET)) {
            if (context.getDataServiceProvider().getDataType(expression) == DataType.DATE_TIME_LITERAL) {
                ChartAdapter.beginIgnoreNotifications();
                if (query.getGrouping() == null) {
                    query.setGrouping(DataFactoryImpl.init().createSeriesGrouping());
                }
                SeriesGrouping group = query.getGrouping();
                group.setEnabled(true);
                group.setAggregateExpression("String_Node_Str");
                ChartAdapter.endIgnoreNotifications();
            }
        }
    } else if (ChartUIConstants.QUERY_CATEGORY.equals(queryType)) {
        DataType type = context.getDataServiceProvider().getDataType(expression);
        ChartAdapter.beginIgnoreNotifications();
        if (seriesdefinition.getGrouping() == null) {
            seriesdefinition.setGrouping(DataFactoryImpl.init().createSeriesGrouping());
        }
        seriesdefinition.getGrouping().setGroupType(type);
        if (type == DataType.DATE_TIME_LITERAL) {
            seriesdefinition.getGrouping().setGroupingUnit(GroupingUnitType.YEARS_LITERAL);
        }
        ChartAdapter.endIgnoreNotifications();
    } else if (ChartUIConstants.QUERY_OPTIONAL.equals(queryType)) {
        ChartAdapter.beginIgnoreNotifications();
        if (expression == null || expression.trim().length() == 0) {
            seriesdefinition.eUnset(DataPackage.eINSTANCE.getSeriesDefinition_Sorting());
            seriesdefinition.getSortKey().setDefinition(null);
        } else {
            if (seriesdefinition.getSortKey() != null && seriesdefinition.getSortKey().getDefinition() != null && seriesdefinition.getSortKey().getDefinition().equals(query.getDefinition())) {
                seriesdefinition.getSortKey().setDefinition(expression);
            }
            DataType type = context.getDataServiceProvider().getDataType(expression);
            if (query.getGrouping() == null) {
                query.setGrouping(DataFactoryImpl.init().createSeriesGrouping());
            }
            query.getGrouping().setGroupType(type);
            if (type == DataType.DATE_TIME_LITERAL) {
                query.getGrouping().setGroupingUnit(GroupingUnitType.YEARS_LITERAL);
            }
        }
        ChartAdapter.endIgnoreNotifications();
    }
    if (query != null) {
        if (isSharing) {
            query.setDefinition(expression);
        } else {
            query.setDefinition(btnBuilder.getExpression());
        }
    } else {
        query = QueryImpl.create(expression);
        query.eAdapters().addAll(seriesdefinition.eAdapters());
        seriesdefinition.setQuery(query);
    }
}

Output:
             seriesdefinition.eUnset(DataPackage.eINSTANCE.getSeriesDefinition_Sorting());
-            seriesdefinition.getSortKey().setDefinition(null);
+            if (seriesdefinition.getSortKey() != null) {
+                seriesdefinition.getSortKey().setDefinition(null);
+            }
         } else {


Input:
private Set<Explanation> computePreciseJusts(OWLAxiom entailment, int limit) throws OWLException {
    Set<Explanation> regularExplanations = pelletExplanation.getExplanations((OWLAxiom) entailment);
    logger.debug("String_Node_Str" + regularExplanations.size() + "String_Node_Str");
    lastRegularExplanations.clear();
    lastRegularExplanations.addAll(regularExplanations);
    allPreviouslyFoundExplanations = new HashSet<Explanation>();
    allPreviouslyFoundExplanations.addAll(regularExplanations);
    Set<Explanation> nonLaconicExplanations = new HashSet<Explanation>();
    Set<Explanation> laconicExplanations = new HashSet<Explanation>();
    Set<OWLAxiom> axiomsInPreviousOntology = new HashSet<OWLAxiom>();
    for (; ; ) {
        if (progressMonitor.isCancelled()) {
            return laconicExplanations;
        }
        Set<OWLAxiom> unionOfAllExplanations = new HashSet<OWLAxiom>();
        for (Explanation expl : allPreviouslyFoundExplanations) {
            unionOfAllExplanations.addAll(expl.getAxioms());
        }
        Set<OWLAxiom> oPlus = computeOPlus(unionOfAllExplanations);
        OWLOntologyManager man2 = OWLManager.createOWLOntologyManager();
        OWLOntology extendedOntology = man2.createOntology(oPlus);
        for (OWLLogicalAxiom logAx : ontology.getLogicalAxioms()) {
            if (!unionOfAllExplanations.contains(logAx) || oPlus.contains(logAx)) {
                man2.addAxiom(extendedOntology, logAx);
            }
        }
        if (extendedOntology.getLogicalAxioms().equals(axiomsInPreviousOntology)) {
            logger.debug("String_Node_Str");
            break;
        }
        axiomsInPreviousOntology.clear();
        axiomsInPreviousOntology.addAll(extendedOntology.getLogicalAxioms());
        Set<Explanation> allPrevJustsCopy = new HashSet<Explanation>(allPreviouslyFoundExplanations);
        Set<OWLOntology> ont2 = new HashSet<OWLOntology>();
        ont2.add(extendedOntology);
        PelletExplanationGenerator expGen = new PelletExplanationGenerator(man2, ont2);
        Set<Explanation> currentExplanations = expGen.getExplanations((OWLAxiom) entailment);
        allPreviouslyFoundExplanations.addAll(currentExplanations);
        if (allPreviouslyFoundExplanations.equals(allPrevJustsCopy)) {
            break;
        }
        for (Explanation currentExplanation : currentExplanations) {
            if (!laconicExplanations.contains(currentExplanation) && !nonLaconicExplanations.contains(currentExplanation)) {
                if (isLaconic(currentExplanation)) {
                    laconicExplanations.add(currentExplanation);
                } else {
                    nonLaconicExplanations.add(currentExplanation);
                }
                if (laconicExplanations.size() == limit) {
                    return laconicExplanations;
                }
            }
        }
    }
    Set<Explanation> explanations = new HashSet<Explanation>();
    for (Explanation explanation : allPreviouslyFoundExplanations) {
        if (!nonLaconicExplanations.contains(explanation)) {
            if (laconicExplanations.contains(explanation)) {
                explanations.add(explanation);
            } else if (isLaconic(explanation)) {
                explanations.add(explanation);
            }
        }
    }
    return laconicExplanations;
}

Output:
     }
-    return laconicExplanations;
+    return explanations;
 }


Input:
public void apply(JsonNode source, JsonNode target) throws SynchronizationException {
    try {
        Object result = this.source.get(source).getValue();
        if (script != null) {
            HashMap<String, Object> scope = new HashMap<String, Object>();
            scope.put("String_Node_Str", result);
            result = script.exec(scope);
        }
        this.target.put(target, result);
    } catch (JsonNodeException jne) {
        throw new SynchronizationException(jne);
    } catch (ScriptException se) {
        throw new SynchronizationException(se);
    }
}

Output:
     try {
-        Object result = this.source.get(source).getValue();
+        JsonNode node = sourcePath.get(sourceObject);
+        if (node == null) {
+            throw new SynchronizationException("String_Node_Str" + sourcePath.toString() + "String_Node_Str");
+        }
+        Object result = node.getValue();
         if (script != null) {


Input:
synchronized public ArchiveEntry openEntry(String name) throws IOException {
    if (isArchiveFileAvailable(af)) {
        return af.openEntry(name);
    } else {
        throw new IOException("String_Node_Str" + name + "String_Node_Str" + systemId);
    }
}

Output:
     } else {
-        throw new IOException("String_Node_Str" + name + "String_Node_Str" + systemId);
+        throw new IOException(Messages.getString(ResourceConstants.FILE_HAS_BEEN_CLOSED));
     }


Input:
public static void randomiseBody(GameCharacter character) {
    if (Math.random() >= (character.isFeminine() ? 0.1f : 0.9f) || character.hasFetish(Fetish.FETISH_MASOCHIST)) {
        character.setPiercedEar(true);
        if (Math.random() <= 0.33f || character.hasFetish(Fetish.FETISH_MASOCHIST)) {
            character.setPiercedNavel(true);
        }
        if (Math.random() <= 0.19f || character.hasFetish(Fetish.FETISH_MASOCHIST)) {
            character.setPiercedNose(true);
        }
        if (Math.random() <= 0.1f || character.hasFetish(Fetish.FETISH_MASOCHIST)) {
            character.setPiercedTongue(true);
        }
        if (Math.random() <= 0.1f || character.hasFetish(Fetish.FETISH_MASOCHIST)) {
            character.setPiercedNipples(true);
        }
        if (Math.random() <= 0.1f || character.hasFetish(Fetish.FETISH_MASOCHIST)) {
            character.setPiercedLip(true);
        }
        if (character.hasPenis() && (Math.random() <= 0.05f || character.hasFetish(Fetish.FETISH_MASOCHIST))) {
            character.setPiercedPenis(true);
        }
        if (character.hasVagina() && (Math.random() <= 0.05f || character.hasFetish(Fetish.FETISH_MASOCHIST))) {
            character.setPiercedVagina(true);
        }
    }
    if (character.hasFetish(Fetish.FETISH_ANAL_RECEIVING) || character.getHistory() == History.PROSTITUTE) {
        character.setAssVirgin(false);
        character.setAssCapacity(character.getAssRawCapacityValue() * 1.2f, true);
        character.setAssStretchedCapacity(character.getAssRawCapacityValue());
    } else {
        character.setAssVirgin(true);
    }
    character.setHeight(character.getHeightValue() - 15 + Util.random.nextInt(30) + 1);
    if (Main.getProperties().multiBreasts == 0) {
        character.setBreastRows(1);
    } else if (Main.getProperties().multiBreasts == 1) {
        if (character.getSkinType() == SkinType.HUMAN) {
            character.setBreastRows(1);
        }
    }
    if (character.hasBreasts()) {
        character.setBreastSize(Math.max(CupSize.AA.getMeasurement(), character.getBreastSize().getMeasurement() - 2 + (Util.random.nextInt(5))));
        if (Math.random() <= 0.015f) {
            character.setBreastMilkStorage((int) ((character.getBreastSize().getMeasurement() * 5) * (1 + (Math.random() * 2))));
            if (Math.random() <= 0.025f) {
                character.addMilkModifier(FluidModifier.ADDICTIVE);
            }
            if (Math.random() <= 0.025f) {
                character.addMilkModifier(FluidModifier.HALLUCINOGENIC);
            }
        }
    }
    if (character.hasFetish(Fetish.FETISH_ORAL_GIVING) || character.getHistory() == History.PROSTITUTE) {
        character.setFaceCapacity(Capacity.FIVE_ROOMY.getMedianValue(), true);
        character.setFaceStretchedCapacity(character.getFaceRawCapacityValue());
        character.setFaceVirgin(false);
    } else {
        if (Math.random() > 0.15f) {
            character.setFaceVirgin(true);
        } else {
            character.setFaceVirgin(false);
        }
    }
    if (Math.random() <= 0.2f && !character.getCovering(character.getHairType().getBodyCoveringType()).getType().getDyePatterns().isEmpty()) {
        Covering currentCovering = character.getCovering(character.getHairType().getBodyCoveringType());
        character.setHairCovering(new Covering(currentCovering.getType(), currentCovering.getType().getDyePatterns().get(Util.random.nextInt(currentCovering.getType().getDyePatterns().size())), currentCovering.getType().getAllPrimaryColours().isEmpty() ? currentCovering.getPrimaryColour() : currentCovering.getType().getAllPrimaryColours().get(Util.random.nextInt(currentCovering.getType().getAllPrimaryColours().size())), Math.random() <= 0.05f, currentCovering.getType().getAllSecondaryColours().isEmpty() ? currentCovering.getSecondaryColour() : currentCovering.getType().getAllSecondaryColours().get(Util.random.nextInt(currentCovering.getType().getAllSecondaryColours().size())), Math.random() <= 0.05f), true);
    }
    if (character.getHairRawLengthValue() != 0 || (character.getFaceType() == FaceType.ALLIGATOR_MORPH && Math.random() <= 0.2f)) {
        character.setHairLength(character.getHairLength().getMinimumValue() + Util.random.nextInt(character.getHairLength().getMaximumValue() - character.getHairLength().getMinimumValue()) + 1);
    }
    if (character.hasPenis()) {
        character.setPenisVirgin(false);
        if ((character.getGender() == Gender.F_P_TRAP || character.getGender() == Gender.N_P_TRAP) && Math.random() >= 0.1f) {
            character.setPenisSize(PenisSize.ONE_TINY.getMinimumValue() + Util.random.nextInt(character.getPenisSize().getMaximumValue() - character.getPenisSize().getMinimumValue()) + 1);
            character.setTesticleSize(TesticleSize.ONE_TINY.getValue());
            character.setCumProduction(CumProduction.ONE_TRICKLE.getMedianValue());
        } else {
            character.setPenisSize(character.getPenisSize().getMinimumValue() + Util.random.nextInt(character.getPenisSize().getMaximumValue() - character.getPenisSize().getMinimumValue()) + 1);
        }
        if (Math.random() <= 0.005f) {
            character.addCumModifier(FluidModifier.ADDICTIVE);
        }
        if (Math.random() <= 0.005f) {
            character.addCumModifier(FluidModifier.HALLUCINOGENIC);
        }
    }
    if (character.hasVagina()) {
        if (character.hasFetish(Fetish.FETISH_PURE_VIRGIN) && character.getHistory() != History.PROSTITUTE) {
            character.setVaginaVirgin(true);
            int capacity = Capacity.ZERO_IMPENETRABLE.getMinimumValue() + Util.random.nextInt(Capacity.TWO_TIGHT.getMaximumValue() - Capacity.ZERO_IMPENETRABLE.getMinimumValue());
            character.setVaginaCapacity(capacity, true);
        } else {
            if (Math.random() > 0.25f || character.getHistory() == History.PROSTITUTE) {
                character.setVaginaVirgin(false);
                character.setVaginaCapacity(character.getVaginaRawCapacityValue() * 1.2f, true);
                character.setVaginaStretchedCapacity(character.getVaginaRawCapacityValue());
            } else {
                character.setVaginaVirgin(true);
            }
        }
        character.setVaginaWetness(character.getVaginaWetness().getValue() - 1 + Util.random.nextInt(3));
        if (Math.random() <= 0.005f) {
            character.addGirlcumModifier(FluidModifier.ADDICTIVE);
        }
        if (Math.random() <= 0.005f) {
            character.addGirlcumModifier(FluidModifier.HALLUCINOGENIC);
        }
    }
    character.setAssStretchedCapacity(character.getAssRawCapacityValue());
    character.setNippleStretchedCapacity(character.getNippleRawCapacityValue());
    character.setFaceStretchedCapacity(character.getFaceRawCapacityValue());
    character.setPenisStretchedCapacity(character.getPenisRawCapacityValue());
    character.setVaginaStretchedCapacity(character.getVaginaRawCapacityValue());
}

Output:
     }
-    if (Math.random() <= 0.2f && !character.getCovering(character.getHairType().getBodyCoveringType()).getType().getDyePatterns().isEmpty()) {
-        Covering currentCovering = character.getCovering(character.getHairType().getBodyCoveringType());
+    if (Math.random() <= 0.2f && !character.getCovering(character.getHairType().getBodyCoveringType(character)).getType().getDyePatterns().isEmpty()) {
+        Covering currentCovering = character.getCovering(character.getHairType().getBodyCoveringType(character));
         character.setHairCovering(new Covering(currentCovering.getType(), currentCovering.getType().getDyePatterns().get(Util.random.nextInt(currentCovering.getType().getDyePatterns().size())), currentCovering.getType().getAllPrimaryColours().isEmpty() ? currentCovering.getPrimaryColour() : currentCovering.getType().getAllPrimaryColours().get(Util.random.nextInt(currentCovering.getType().getAllPrimaryColours().size())), Math.random() <= 0.05f, currentCovering.getType().getAllSecondaryColours().isEmpty() ? currentCovering.getSecondaryColour() : currentCovering.getType().getAllSecondaryColours().get(Util.random.nextInt(currentCovering.getType().getAllSecondaryColours().size())), Math.random() <= 0.05f), true);


Input:
protected StringBuilder mergeIssues(TurboIssue original, TurboIssue latest) {
    StringBuilder changeLog = new StringBuilder();
    mergeTitle(original, latest, changeLog);
    mergeDescription(original, latest, changeLog);
    mergeParents(original, latest, changeLog);
    mergeLabels(original, latest, changeLog);
    mergeAssignee(original, latest, changeLog);
    mergeMilestone(original, latest, changeLog);
    mergeOpen(original, latest);
    return changeLog;
}

Output:
     mergeTitle(original, latest, changeLog);
-    mergeDescription(original, latest, changeLog);
+    if (overwriteDesc) {
+        mergeDescription(original, latest, changeLog);
+    }
     mergeParents(original, latest, changeLog);


Input:
public void execute(long t) {
    System.out.println(getName() + "String_Node_Str");
    if (packetListener != null) {
        int len = memory[RAM_TXFIFO];
        int[] data = new int[len];
        System.arraycopy(memory, RAM_TXFIFO + 1, data, 0, len);
        packetListener.transmissionEnded(data);
    }
}

Output:
 public void execute(long t) {
-    System.out.println(getName() + "String_Node_Str");
+    if (DEBUG)
+        System.out.println(getName() + "String_Node_Str");
     if (packetListener != null) {


Input:
private RangerContextEnricher buildContextEnricher(RangerServiceDef.RangerContextEnricherDef enricherDef) {
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + enricherDef + "String_Node_Str");
    }
    RangerContextEnricher ret = null;
    String name = enricherDef != null ? enricherDef.getName() : null;
    String clsName = enricherDef != null ? enricherDef.getEnricher() : null;
    if (!StringUtils.isEmpty(clsName)) {
        try {
            Class<RangerContextEnricher> enricherClass = (Class<RangerContextEnricher>) Class.forName(clsName);
            ret = enricherClass.newInstance();
        } catch (Exception excp) {
            LOG.error("String_Node_Str" + clsName + "String_Node_Str" + name + "String_Node_Str", excp);
        }
    }
    if (ret != null) {
        ret.setContextEnricherDef(enricherDef);
        ret.setContextServiceName(serviceName);
        ret.setContextServiceDef(componentServiceDef);
        ret.init();
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + enricherDef + "String_Node_Str" + ret);
    }
    return ret;
}

Output:
         ret.setContextEnricherDef(enricherDef);
-        ret.setContextServiceName(serviceName);
+        ret.setContextServiceName(componentServiceName);
         ret.setContextServiceDef(componentServiceDef);


Input:
public GeneralTab getGt() {
    return nt;
}

Output:
 public GeneralTab getGt() {
-    return nt;
+    return gt;
 }


Input:
private void placeComponents(Composite c) {
    GridLayout gl = (GridLayout) c.getLayout();
    gl.numColumns = 4;
    Label labelStyle = new Label(c, SWT.NONE);
    labelStyle.setText(Messages.getString("String_Node_Str"));
    fComboStyle = new Combo(c, SWT.NONE);
    GridData gd = new GridData(GridData.FILL_HORIZONTAL);
    gd.horizontalSpan = 2;
    fComboStyle.setLayoutData(gd);
    Label label = new Label(c, SWT.NONE);
    fTable = new Table(c, SWT.SINGLE | SWT.BORDER | SWT.V_SCROLL);
    fTable.setLinesVisible(true);
    fTable.setHeaderVisible(true);
    gd = new GridData(GridData.FILL_BOTH);
    gd.horizontalSpan = 3;
    gd.verticalSpan = 16;
    fTable.setLayoutData(gd);
    fTableViewer = new TableViewer(fTable);
    fTableViewer.setUseHashlookup(true);
    fBtnAdd = new Button(c, SWT.NONE);
    fBtnAdd.setText(Messages.getString("String_Node_Str"));
    fBtnRemove = new Button(c, SWT.NONE);
    fBtnRemove.setText(Messages.getString("String_Node_Str"));
}

Output:
     Label label = new Label(c, SWT.NONE);
-    fTable = new Table(c, SWT.SINGLE | SWT.BORDER | SWT.V_SCROLL);
+    fTable = new Table(c, SWT.BORDER | SWT.V_SCROLL | SWT.FULL_SELECTION);
     fTable.setLinesVisible(true);


Input:
public void checkout(TestProject testProject, TranslationService translationService) throws SystemException, TeamAuthentificationException {
    if (logger.isInfoEnabled()) {
        logger.info("String_Node_Str" + testProject.getFullName());
    }
    String projectName = testProject.getName();
    try {
        TeamShareConfig teamShareConfig = testProject.getTestProjectConfig().getTeamShareConfig();
        String url = ((SVNTeamShareConfig) teamShareConfig).getUrl() + "String_Node_Str" + projectName;
        SVNClientManager clientManager = getSVNClientManager(testProject);
        SVNUpdateClient updateClient = clientManager.getUpdateClient();
        SVNURL svnUrl;
        if (url.startsWith("String_Node_Str")) {
            svnUrl = SVNURL.fromFile(new File(url));
        } else {
            svnUrl = SVNURL.parseURIEncoded(url);
        }
        updateClient.setEventHandler(new SVNLoggingEventHandler(listener, logger));
        File dstPath = new File(testProject.getTestProjectConfig().getProjectPath()).getParentFile();
        long doCheckout = updateClient.doCheckout(svnUrl, new File(dstPath, testProject.getName()), SVNRevision.HEAD, SVNRevision.HEAD, SVNDepth.INFINITY, true);
        logger.info("String_Node_Str" + doCheckout);
    } catch (SVNCancelException canExp) {
        File dirtyPrjPath = new File(testProject.getTestProjectConfig().getProjectPath());
        logger.info("String_Node_Str");
        try {
            FileUtils.deleteDirectory(dirtyPrjPath);
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
        }
        logger.info("String_Node_Str" + dirtyPrjPath);
    } catch (SVNException e) {
        logger.error(e.getMessage(), e);
        String message = substitudeSVNException(e, translationService);
        int errorCode = e.getErrorMessage().getErrorCode().getCode();
        if ((errorCode == AUTHENTICATION_REQUIRED) || (errorCode == CONNECTION_REFUSED || errorCode == AUTHENTICATION_REQUIRED_2)) {
            throw new TeamAuthentificationException("String_Node_Str", e);
        }
        throw new SystemException(message, e);
    }
}

Output:
 public void checkout(TestProject testProject, TranslationService translationService) throws SystemException, TeamAuthentificationException {
-    if (logger.isInfoEnabled()) {
-        logger.info("String_Node_Str" + testProject.getFullName());
-    }
+    logger.trace("String_Node_Str" + testProject.getFullName() + "String_Node_Str");
     String projectName = testProject.getName();


Input:
private String getRegex(String urlPattern) {
    StringBuffer buffer = new StringBuffer();
    Matcher matcher = PATTERN_FOR_VARIABLE_PARTS_OF_ROUTE.matcher(urlPattern);
    while (matcher.find()) {
        String variablePartOfRouteName = matcher.group(1);
        String namedVariablePartOfRoute = matcher.group(3);
        String namedVariablePartOfORouteReplacedWithRegex;
        if (namedVariablePartOfRoute != null) {
            String variableRegex = replacePosixClasses(namedVariablePartOfRoute);
            namedVariablePartOfORouteReplacedWithRegex = String.format("String_Node_Str", variablePartOfRouteName, Matcher.quoteReplacement(variableRegex));
        } else {
            namedVariablePartOfORouteReplacedWithRegex = String.format(VARIABLE_ROUTES_DEFAULT_REGEX, variablePartOfRouteName);
        }
        matcher.appendReplacement(buffer, namedVariablePartOfORouteReplacedWithRegex);
    }
    matcher.appendTail(buffer);
    return buffer.toString();
}

Output:
             String variableRegex = replacePosixClasses(namedVariablePartOfRoute);
-            namedVariablePartOfORouteReplacedWithRegex = String.format("String_Node_Str", variablePartOfRouteName, Matcher.quoteReplacement(variableRegex));
+            namedVariablePartOfORouteReplacedWithRegex = String.format("String_Node_Str", getPathParameterRegexGroupName(pathParameterIndex), Matcher.quoteReplacement(variableRegex));
         } else {


Input:
public void addInitialTaxonomyTableIntoGraph(String filename, String synonymfile, String taxonomyversion) throws TaxonNotFoundException {
    initContainersForTaxLoading();
    String str = "String_Node_Str";
    int count = 0;
    if (synonymfile.length() > 0) {
        synFileExists = true;
    }
    if (synFileExists) {
        synonymHash = new HashMap<String, ArrayList<ArrayList<String>>>();
        try {
            BufferedReader sbr = new BufferedReader(new FileReader(synonymfile));
            while ((str = sbr.readLine()) != null) {
                StringTokenizer st = new StringTokenizer(str, "String_Node_Str");
                String name = st.nextToken();
                String parentuid = st.nextToken();
                String uid = parentuid;
                String type = "String_Node_Str";
                String source = "String_Node_Str";
                ArrayList<String> tar = new ArrayList<String>();
                tar.add(uid);
                tar.add(name);
                tar.add(type);
                tar.add(source);
                if (synonymHash.get(parentuid) == null) {
                    ArrayList<ArrayList<String>> ttar = new ArrayList<ArrayList<String>>();
                    synonymHash.put(parentuid, ttar);
                }
                synonymHash.get(parentuid).add(tar);
            }
            sbr.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(0);
        }
        System.out.println("String_Node_Str" + synonymHash.size());
    }
    Transaction tx;
    ArrayList<String> templines = new ArrayList<String>();
    try {
        BufferedReader br = new BufferedReader(new FileReader(filename));
        while ((str = br.readLine()) != null) {
            if (count == 0) {
                if (str.startsWith("String_Node_Str")) {
                    System.out.println("String_Node_Str" + str);
                    continue;
                }
            }
            count += 1;
            templines.add(str);
            if (count % transactionFrequency == 0) {
                System.out.print("String_Node_Str" + count);
                System.out.print("String_Node_Str");
                tx = graphDb.beginTx();
                try {
                    for (int i = 0; i < templines.size(); i++) {
                        processTaxInputLine(templines.get(i), taxonomyversion);
                    }
                    tx.success();
                } finally {
                    tx.finish();
                }
                templines.clear();
            }
        }
        br.close();
        tx = graphDb.beginTx();
        try {
            for (int i = 0; i < templines.size(); i++) {
                processTaxInputLine(templines.get(i), taxonomyversion);
            }
            tx.success();
        } finally {
            tx.finish();
        }
        templines.clear();
        ArrayList<String> temppar = new ArrayList<String>();
        count = 0;
        for (String key : taxUIDToNodeMap.keySet()) {
            count += 1;
            temppar.add(key);
            if (count % transactionFrequency == 0) {
                System.out.println(count);
                tx = graphDb.beginTx();
                try {
                    for (int i = 0; i < temppar.size(); i++) {
                        try {
                            addParentRelationshipForTaxUID(temppar.get(i));
                        } catch (java.lang.IllegalArgumentException io) {
                            continue;
                        }
                    }
                    tx.success();
                } finally {
                    tx.finish();
                }
                temppar.clear();
            }
        }
        tx = graphDb.beginTx();
        try {
            for (int i = 0; i < temppar.size(); i++) {
                try {
                    addParentRelationshipForTaxUID(temppar.get(i));
                } catch (java.lang.IllegalArgumentException io) {
                    continue;
                }
            }
            tx.success();
        } finally {
            tx.finish();
        }
    } catch (IOException ioe) {
    }
    initMrcaAndStreeRelsTax();
}

Output:
             while ((str = sbr.readLine()) != null) {
-                StringTokenizer st = new StringTokenizer(str, "String_Node_Str");
-                String name = st.nextToken();
-                String parentuid = st.nextToken();
-                String uid = parentuid;
-                String type = "String_Node_Str";
-                String source = "String_Node_Str";
-                ArrayList<String> tar = new ArrayList<String>();
-                tar.add(uid);
-                tar.add(name);
-                tar.add(type);
-                tar.add(source);
-                if (synonymHash.get(parentuid) == null) {
-                    ArrayList<ArrayList<String>> ttar = new ArrayList<ArrayList<String>>();
-                    synonymHash.put(parentuid, ttar);
+                if (!str.trim().equals("String_Node_Str")) {
+                    StringTokenizer st = new StringTokenizer(str, "String_Node_Str");
+                    String name = st.nextToken();
+                    String parentuid = st.nextToken();
+                    String uid = parentuid;
+                    String type = "String_Node_Str";
+                    String source = "String_Node_Str";
+                    ArrayList<String> tar = new ArrayList<String>();
+                    tar.add(uid);
+                    tar.add(name);
+                    tar.add(type);
+                    tar.add(source);
+                    if (synonymHash.get(parentuid) == null) {
+                        ArrayList<ArrayList<String>> ttar = new ArrayList<ArrayList<String>>();
+                        synonymHash.put(parentuid, ttar);
+                    }
+                    synonymHash.get(parentuid).add(tar);
                 }


Input:
public void render(FontRenderer fontRenderer, int currenty, Object[] screenData, float factor) {
    GL11.glDisable(GL11.GL_LIGHTING);
    int xoffset;
    if (!line.isEmpty()) {
        fontRenderer.drawString(line, 7, currenty + 2, color);
        xoffset = 7 + 80;
    } else {
        xoffset = 7 + 5;
    }
    boolean act = false;
    if (toggle) {
        if (screenData != null && screenData.length >= 1) {
            act = ((Integer) screenData[0]) > 0;
        }
    } else {
        act = activated;
    }
    RenderHelper.drawBeveledBox(xoffset - 5, currenty, 130 - 7, currenty + 12, act ? 0xff333333 : 0xffeeeeee, act ? 0xffeeeeee : 0xff333333, 0xff666666);
    fontRenderer.drawString(fontRenderer.trimStringToWidth(button, 130 - 7 - xoffset), xoffset + (act ? 1 : 0), currenty + 2 + (act ? 1 : 0), buttonColor);
}

Output:
     if (toggle) {
-        if (screenData != null && screenData.length >= 1) {
+        if (screenData != null && screenData.length >= 1 && screenData[0] instanceof Integer) {
             act = ((Integer) screenData[0]) > 0;


Input:
public static String getBlockStringName(String blockData) {
    String[] blockArr = blockData.split("String_Node_Str");
    Material.getMaterial(Integer.parseInt(blockArr[0]));
    if (blockArr.length > 1)
        return Material.getMaterial(Integer.parseInt(blockArr[0])).name() + "String_Node_Str" + blockArr[1];
    else
        return Material.getMaterial(Integer.parseInt(blockArr[0])).name();
}

Output:
     String[] blockArr = blockData.split("String_Node_Str");
-    Material.getMaterial(Integer.parseInt(blockArr[0]));
+    if (!Util.isInteger(blockArr[0]))
+        return blockData;
     if (blockArr.length > 1)


Input:
public Object extractPrimaryKeyFromObject(Object domainObject, AbstractSession session, boolean shouldReturnNullIfNull) {
    if (domainObject == null) {
        return null;
    }
    boolean isPersistenceEntity = (domainObject instanceof PersistenceEntity) && (!isXMLObjectBuilder());
    if (isPersistenceEntity) {
        Object primaryKey = ((PersistenceEntity) domainObject)._persistence_getId();
        if (primaryKey != null) {
            return primaryKey;
        }
    }
    ClassDescriptor descriptor = this.descriptor;
    boolean isNull = false;
    if (descriptor.hasInheritance() && (domainObject.getClass() != descriptor.getJavaClass()) && (!domainObject.getClass().getSuperclass().equals(descriptor.getJavaClass()))) {
        return session.getDescriptor(domainObject).getObjectBuilder().extractPrimaryKeyFromObject(domainObject, session, shouldReturnNullIfNull);
    }
    CacheKeyType cacheKeyType = descriptor.getCachePolicy().getCacheKeyType();
    List<DatabaseField> primaryKeyFields = descriptor.getPrimaryKeyFields();
    Object[] primaryKeyValues = null;
    if (cacheKeyType != CacheKeyType.ID_VALUE) {
        primaryKeyValues = new Object[primaryKeyFields.size()];
    }
    List<DatabaseMapping> mappings = getPrimaryKeyMappings();
    int size = mappings.size();
    if (descriptor.hasSimplePrimaryKey()) {
        for (int index = 0; index < size; index++) {
            AbstractColumnMapping mapping = (AbstractColumnMapping) mappings.get(index);
            Object keyValue = mapping.valueFromObject(domainObject, primaryKeyFields.get(index), session);
            if (isPrimaryKeyComponentInvalid(keyValue, index)) {
                if (shouldReturnNullIfNull) {
                    return null;
                }
                isNull = true;
            }
            if (cacheKeyType == CacheKeyType.ID_VALUE) {
                if (isPersistenceEntity && (!isNull)) {
                    ((PersistenceEntity) domainObject)._persistence_setId(keyValue);
                }
                return keyValue;
            } else {
                primaryKeyValues[index] = keyValue;
            }
        }
    } else {
        AbstractRecord databaseRow = createRecordForPKExtraction(size, session);
        for (int index = 0; index < size; index++) {
            DatabaseMapping mapping = mappings.get(index);
            if (mapping != null) {
                mapping.writeFromObjectIntoRow(domainObject, databaseRow, session, WriteType.UNDEFINED);
            }
        }
        List<Class> primaryKeyClassifications = getPrimaryKeyClassifications();
        Platform platform = session.getPlatform(domainObject.getClass());
        for (int index = 0; index < size; index++) {
            Class classification = primaryKeyClassifications.get(index);
            Object value = databaseRow.get(primaryKeyFields.get(index));
            if (isPrimaryKeyComponentInvalid(value, index)) {
                if (shouldReturnNullIfNull) {
                    return null;
                }
                isNull = true;
            }
            value = platform.convertObject(value, classification);
            if (cacheKeyType == CacheKeyType.ID_VALUE) {
                if (isPersistenceEntity && (!isNull)) {
                    ((PersistenceEntity) domainObject)._persistence_setId(value);
                }
                return value;
            } else {
                primaryKeyValues[index] = value;
            }
        }
    }
    CacheId id = new CacheId(primaryKeyValues);
    if (isPersistenceEntity && (!isNull)) {
        ((PersistenceEntity) domainObject)._persistence_setId(id);
    }
    return id;
}

Output:
             DatabaseMapping mapping = mappings.get(index);
-            if (mapping != null) {
+            if (mapping != null && !writtenMappings.contains(mapping)) {
                 mapping.writeFromObjectIntoRow(domainObject, databaseRow, session, WriteType.UNDEFINED);


Input:
private static void incrementSSRCCounter(Map<Long, Long> map, long ssrc, long step) {
    Long count = map.get(ssrc);
    map.put(ssrc, (count == null) ? step : (count + step));
}

Output:
 private static void incrementSSRCCounter(Map<Long, Long> map, long ssrc, long step) {
-    Long count = map.get(ssrc);
-    map.put(ssrc, (count == null) ? step : (count + step));
+    synchronized (map) {
+        Long count = map.get(ssrc);
+        map.put(ssrc, (count == null) ? step : (count + step));
+    }
 }


Input:
protected JsValue doInvoke(String name, Object jthis, Class[] types, Object[] args) {
    JsValueMoz jsthis = JsValueMoz.createUndefinedValue(window);
    CompilingClassLoader isolatedClassLoader = getIsolatedClassLoader();
    jsthis.setWrappedJavaObject(isolatedClassLoader, jthis);
    int argc = args.length;
    JsValueMoz[] argv = new JsValueMoz[argc];
    int[] jsArgsInt = new int[argc];
    for (int i = 0; i < argc; ++i) {
        argv[i] = JsValueMoz.createUndefinedValue(window);
        JsValueGlue.set(argv[i], isolatedClassLoader, types[i], args[i]);
        jsArgsInt[i] = argv[i].getJsRootedValue();
    }
    JsValueMoz returnVal = JsValueMoz.createUndefinedValue(window);
    LowLevelMoz.invoke(window, name, jsthis.getJsRootedValue(), jsArgsInt, returnVal.getJsRootedValue());
    return returnVal;
}

Output:
 protected JsValue doInvoke(String name, Object jthis, Class[] types, Object[] args) {
-    JsValueMoz jsthis = JsValueMoz.createUndefinedValue(window);
+    JsValueMoz jsthis = new JsValueMoz();
     CompilingClassLoader isolatedClassLoader = getIsolatedClassLoader();


Input:
public StackTraceElement resymbolize(StackTraceElement ste, String strongName) {
    String declaringClass = null;
    String methodName = null;
    String filename = null;
    int lineNumber = -1;
    int fragmentId = -1;
    String steFilename = ste.getFileName();
    SymbolMap map = loadSymbolMap(strongName);
    String symbolData = map == null ? null : map.get(ste.getMethodName());
    if (symbolData != null) {
        String[] parts = symbolData.split("String_Node_Str");
        if (parts.length == 6) {
            String[] ref = parse(parts[0].substring(0, parts[0].lastIndexOf(')') + 1));
            if (ref != null) {
                declaringClass = ref[0];
                methodName = ref[1];
            } else {
                declaringClass = ste.getClassName();
                methodName = ste.getMethodName();
            }
            filename = "String_Node_Str".equals(parts[3]) ? null : parts[3].substring(parts[3].lastIndexOf('/') + 1);
            lineNumber = ste.getLineNumber();
            if (lineNumber == LINE_NUMBER_UNKNOWN) {
                lineNumber = Integer.parseInt(parts[4]);
            }
            fragmentId = Integer.parseInt(parts[5]);
        }
    }
    int column = 1;
    if (steFilename != null) {
        int columnMarkerIndex = steFilename.indexOf("String_Node_Str");
        if (columnMarkerIndex != -1) {
            try {
                column = Integer.parseInt(steFilename.substring(columnMarkerIndex + 1));
            } catch (NumberFormatException nfe) {
            }
            steFilename = steFilename.substring(0, columnMarkerIndex);
        }
    }
    if (fragmentId == -1 && steFilename != null) {
        Matcher matcher = fragmentIdPattern.matcher(steFilename);
        if (matcher.matches()) {
            String fragment = matcher.group(1);
            try {
                fragmentId = Integer.parseInt(fragment);
            } catch (Exception e) {
            }
        } else if (steFilename.contains(strongName)) {
            fragmentId = 0;
        }
    }
    int jsLineNumber = ste.getLineNumber();
    if (fragmentId != -1) {
        SourceMapping sourceMapping = loadSourceMap(strongName, fragmentId);
        if (sourceMapping != null && ste.getLineNumber() > -1) {
            Mapping.OriginalMapping mappingForLine = sourceMapping.getMappingForLine(jsLineNumber, column);
            if (mappingForLine != null) {
                if (declaringClass == null || declaringClass.equals(ste.getClassName())) {
                    declaringClass = mappingForLine.getOriginalFile();
                    methodName = mappingForLine.getIdentifier();
                }
                filename = mappingForLine.getOriginalFile();
                lineNumber = mappingForLine.getLineNumber() - 1;
            }
        }
    }
    if (declaringClass != null) {
        return new StackTraceElement(declaringClass, methodName, filename, lineNumber);
    }
    return ste;
}

Output:
                 filename = mappingForLine.getOriginalFile();
-                lineNumber = mappingForLine.getLineNumber() - 1;
+                lineNumber = mappingForLine.getLineNumber();
             }


Input:
protected void verifyOptions() {
    if (fork && isInIncrementalMode() && !isInIncrementalFileMode()) {
        String m = "String_Node_Str";
        throw new BuildException(m);
    }
}

Output:
     if (fork && isInIncrementalMode() && !isInIncrementalFileMode()) {
-        String m = "String_Node_Str";
-        throw new BuildException(m);
+        sb.append("String_Node_Str");
+    }
+    if ((null == outjar) && (DEFAULT_DESTDIR == destDir)) {
+        final String REQ = "String_Node_Str";
+        if (copyInjars) {
+            sb.append("String_Node_Str");
+            sb.append(REQ);
+        }
+        if (null != sourceRootCopyFilter) {
+            sb.append("String_Node_Str");
+            sb.append(REQ);
+        }
+    }
+    if (0 < sb.length()) {
+        throw new BuildException(sb.toString());
     }


Input:
private void closeMulticastSocket() {
    logger.debug("String_Node_Str");
    if (socket != null) {
        try {
            socket.leaveGroup(group);
            socket.close();
            if (incomingListener != null) {
                incomingListener.join();
            }
        } catch (Exception exception) {
            logger.log(Level.WARNING, "String_Node_Str", exception);
        }
        socket = null;
    }
}

Output:
         } catch (Exception exception) {
-            logger.log(Level.WARNING, "String_Node_Str", exception);
+            logger.warn("String_Node_Str", exception);
         }


Input:
private void wait(Callable<Boolean> condition, long timeout) throws Exception {
    long startTime = System.currentTimeMillis();
    long remainingTime = timeout;
    synchronized (waitLock) {
        while (remainingTime > 0 && condition.call()) {
            try {
                waitLock.wait(remainingTime);
            } catch (InterruptedException ex) {
            }
            long currentTime = System.currentTimeMillis();
            remainingTime = remainingTime - (currentTime - startTime);
            startTime = currentTime;
        }
    }
}

Output:
     long remainingTime = timeout;
-    synchronized (waitLock) {
-        while (remainingTime > 0 && condition.call()) {
+    while (remainingTime > 0 && condition.call()) {
+        synchronized (waitLock) {
             try {


Input:
public void setRawContent(String rawContent) {
    if (rawContent != null) {
        rawContent.replace("String_Node_Str", "String_Node_Str");
        this.rawContent = rawContent;
        this.contentType = ContentChecker.checkJsonXmlContent(rawContent);
        if (ContentType.JSON.equals(contentType)) {
            this.JSONContent = JSONSerializer.toJSON(this.rawContent);
            this.XMLContent = null;
        } else if (ContentType.XML.equals(contentType)) {
            try {
                DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
                DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
                this.XMLContent = docBuilder.parse(new InputSource(new StringReader(this.rawContent)));
            } catch (Exception ex) {
                ex.printStackTrace();
                this.contentType = ContentType.Undefined;
                this.XMLContent = null;
            }
            this.JSONContent = null;
        } else {
            this.JSONContent = null;
            this.XMLContent = null;
        }
    } else {
        this.rawContent = "String_Node_Str";
        this.contentType = ContentChecker.ContentType.Undefined;
    }
}

Output:
         if (ContentType.JSON.equals(contentType)) {
-            this.JSONContent = JSONSerializer.toJSON(this.rawContent);
+            this.JSONContent = JSONSerializer.toJSON(rawContent);
             this.XMLContent = null;


Input:
private static void fillClass(String className, String packageName, Set<Class<?>> classes, ClassFilter classFilter) {
    if (className.startsWith(packageName)) {
        try {
            final Class<?> clazz = Class.forName(className, false, getClassLoader());
            if (classFilter == null || classFilter.accept(clazz)) {
                classes.add(clazz);
            }
        } catch (Throwable ex) {
        }
    }
}

Output:
             }
-        } catch (Throwable ex) {
+        } catch (Exception ex) {
         }


Input:
public void onMediaCapturePathReady(String mediaCapturePath) {
    mMediaCapturePath = mediaCapturePath;
    mCurrentActivityRequest = RequestCode.ACTIVITY_REQUEST_CODE_TAKE_VIDEO;
}

Output:
     mMediaCapturePath = mediaCapturePath;
-    mCurrentActivityRequest = RequestCode.ACTIVITY_REQUEST_CODE_TAKE_VIDEO;
+    mCurrentActivityRequest = RequestCode.ACTIVITY_REQUEST_CODE_TAKE_PHOTO;
 }


Input:
protected AddPushButton createAddPushButton() {
    return new AddPushButtonForExtendedTable(this.toolbar, getExtendedTableViewer()) {

        public boolean getEnabledState() {
            return super.getEnabledState() && (model == null || !model.getElemParameter().isBasedOnSubjobStarts());
        }
        protected Object getObjectToAdd() {
            PropertiesTableEditorModel tableEditorModel = (PropertiesTableEditorModel) getExtendedTableViewer().getExtendedControlModel();
            if (!tableEditorModel.isButtonEnabled()) {
                MessageDialog.openInformation(tableEditorModel.getTableViewer().getControl().getShell(), "String_Node_Str", "String_Node_Str");
                return null;
            }
            Object newEntry = tableEditorModel.createNewEntry();
            if (tableEditorModel.isAggregateRow() && newEntry instanceof Map) {
                List<ColumnInfo> tableInputs = new ArrayList<ColumnInfo>();
                String[] displayNames = tableEditorModel.getElemParameter().getListItemsDisplayName();
                Object[] itemsValue = tableEditorModel.getElemParameter().getListItemsValue();
                String paramColumnsName = "String_Node_Str";
                for (int i = 0; i < itemsValue.length; i++) {
                    if (itemsValue[i] instanceof IElementParameter) {
                        IElementParameter tableParameter = (IElementParameter) itemsValue[i];
                        if (tableParameter.getFieldType().equals(EParameterFieldType.COLUMN_LIST)) {
                            paramColumnsName = tableParameter.getName();
                        } else {
                            ColumnInfo row = new ColumnInfo();
                            row.name = displayNames[i];
                            row.parameter = tableParameter;
                            row.defaultValue = "String_Node_Str";
                            tableInputs.add(row);
                        }
                    }
                }
                Node node = (Node) tableEditorModel.getElement();
                String outputTableName = null;
                if (node.getMetadataList() != null && !node.getMetadataList().isEmpty()) {
                    IMetadataTable metadata = node.getMetadataList().get(0);
                    if (metadata.getListColumns() != null) {
                        for (IMetadataColumn column : metadata.getListColumns()) {
                            if (!tableEditorModel.exist(column.getLabel())) {
                                outputTableName = column.getLabel();
                                break;
                            }
                        }
                    }
                }
                if (outputTableName != null) {
                    Map mapObject = (Map) newEntry;
                    if (mapObject.containsKey(paramColumnsName)) {
                        mapObject.put(paramColumnsName, outputTableName);
                    }
                    for (ColumnInfo col : tableInputs) {
                        Object defaultValue = col.defaultValue;
                        Object found = findDefaultName(outputTableName, col);
                        if (found != null && !"String_Node_Str".equals(found)) {
                            defaultValue = found;
                        }
                        if (defaultValue != null && !"String_Node_Str".equals(defaultValue)) {
                            mapObject.put(col.parameter.getName(), defaultValue);
                        }
                    }
                }
            }
            return newEntry;
        }
    };
}

Output:
 protected AddPushButton createAddPushButton() {
-    return new AddPushButtonForExtendedTable(this.toolbar, getExtendedTableViewer()) {
+    final AddPushButton addPushButton = new AddPushButtonForExtendedTable(this.toolbar, getExtendedTableViewer()) {


Input:
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
    monitorWrap = SubMonitor.convert(monitor);
    try {
        if (!isArchive) {
            ImportProjectsUtilities.importProjectAs(shell, name, technicalName, sourcePath, monitorWrap);
        } else {
            ImportProjectsUtilities.importArchiveProjectAs(shell, name, technicalName, sourcePath, monitorWrap);
        }
    } catch (IOException e) {
        throw new InvocationTargetException(e);
    } catch (TarException e) {
        throw new InvocationTargetException(e);
    }
    monitorWrap.done();
    MessageDialog.openInformation(shell, Messages.getString("String_Node_Str"), Messages.getString("String_Node_Str"));
}

Output:
 public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
-    monitorWrap = SubMonitor.convert(monitor);
+    monitorWrap = new EventLoopProgressMonitor(monitor);
     try {


Input:
private void dispose() {
    IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
    if (window == null) {
        return;
    }
    IHandlerService service = (IHandlerService) window.getService(IHandlerService.class);
    for (IHandlerActivation activation : fHandlerActivations) {
        service.deactivateHandler(activation);
    }
    fGoToMessageForKeyBinding = null;
    fFindForKeyBinding = null;
    fMoveUpForKeyBinding = null;
    fMoveDownForKeyBinding = null;
    fMoveLeftForKeyBinding = null;
    fMoveRightForKeyBinding = null;
    fShowNodeStartForKeyBinding = null;
    fShowNodeEndForKeyBinding = null;
}

Output:
     }
-    IHandlerService service = (IHandlerService) window.getService(IHandlerService.class);
+    Object serviceObject = window.getService(IHandlerService.class);
+    IHandlerService service = (IHandlerService) serviceObject;
     for (IHandlerActivation activation : fHandlerActivations) {