Input:
private static List<EdgeEntity<Object>> getEdges(final Class<?> edgeClazz, final JsonDeserializationContext context, final JsonArray edges) {
    final List<EdgeEntity<Object>> list = new ArrayList<EdgeEntity<Object>>();
    if (edges != null) {
        for (int i = 0, imax = edges.size(); i < imax; i++) {
            final JsonObject edge = edges.get(i).getAsJsonObject();
            final EdgeEntity<Object> ve = deserializeBaseParameter(edge, new EdgeEntity<Object>());
            deserializeDocumentParameter(edge, ve);
            if (edgeClazz != null) {
                ve.setEntity(context.deserialize(edge, edgeClazz));
            } else {
                ve.setEntity(context.deserialize(edge, Object.class));
            }
            list.add(ve);
        }
    }
    return list;
}

Output:
             final JsonObject edge = edges.get(i).getAsJsonObject();
-            final EdgeEntity<Object> ve = deserializeBaseParameter(edge, new EdgeEntity<Object>());
-            deserializeDocumentParameter(edge, ve);
-            if (edgeClazz != null) {
-                ve.setEntity(context.deserialize(edge, edgeClazz));
-            } else {
-                ve.setEntity(context.deserialize(edge, Object.class));
-            }
+            final EdgeEntity<Object> ve = context.deserialize(edge, EdgeEntity.class);
             list.add(ve);


Input:
private FileDesc removeInternal(File file) {
    FileDesc fd;
    rwLock.writeLock().lock();
    try {
        fd = fileToFileDescMap.get(file);
        if (fd != null) {
            removeFileDesc(file, fd);
        }
        Future future = fileToFutures.remove(file);
        if (future != null) {
            future.cancel(true);
        }
    } finally {
        rwLock.writeLock().unlock();
    }
    if (fd != null) {
        getLibraryData().removeManagedFile(file);
    }
    return fd;
}

Output:
         if (future != null) {
-            future.cancel(true);
+            cancelled = future.cancel(true);
         }


Input:
public AmHealthState getClusterStatus(String clusterName) {
    String fields = "String_Node_Str";
    String servicesWithState = apiResourceRootV1.getClustersResource().getComponentsResource(clusterName).readComponentsWithFilter(fields);
    ApiComponentList componentList = ApiUtils.jsonToObject(ApiComponentList.class, servicesWithState);
    AmHealthState state = AmHealthState.HEALTHY;
    if (componentList.getApiComponents() != null) {
        for (ApiServiceComponent component : componentList.getApiComponents()) {
            ApiServiceComponentInfo info = component.getApiServiceComponent();
            if (info.getCategory().equalsIgnoreCase("String_Node_Str") && (!ComponentStatus.INSTALLED.toString().equalsIgnoreCase(info.getState()))) {
                state = AmHealthState.UNHEALTHY;
            } else if ((!info.getCategory().equalsIgnoreCase("String_Node_Str")) && (!ComponentStatus.STARTED.toString().equalsIgnoreCase(info.getState()))) {
                state = AmHealthState.UNHEALTHY;
            }
        }
    }
    return state;
}

Output:
     String fields = "String_Node_Str";
-    String servicesWithState = apiResourceRootV1.getClustersResource().getComponentsResource(clusterName).readComponentsWithFilter(fields);
+    String servicesWithState = null;
+    servicesWithState = apiResourceRootV1.getClustersResource().getComponentsResource(clusterName).readComponentsWithFilter(fields);
     ApiComponentList componentList = ApiUtils.jsonToObject(ApiComponentList.class, servicesWithState);


Input:
Object findTargetWindow(KeyEvent nextKey, QueuedEvent qev, MotionEvent nextMotion, boolean isPointerEvent) {
    mOutsideTouchTargets = null;
    if (nextKey != null) {
        final int keycode = nextKey.getKeyCode();
        final int repeatCount = nextKey.getRepeatCount();
        final boolean down = nextKey.getAction() != KeyEvent.ACTION_UP;
        boolean dispatch = mKeyWaiter.checkShouldDispatchKey(keycode);
        if (!dispatch) {
            mPolicy.interceptKeyTi(null, keycode, nextKey.getMetaState(), down, repeatCount);
            Log.w(TAG, "String_Node_Str" + nextKey);
            return SKIP_TARGET_TOKEN;
        }
        WindowState focus = null;
        synchronized (mWindowMap) {
            focus = getFocusedWindowLocked();
        }
        wakeupIfNeeded(focus, LocalPowerManager.BUTTON_EVENT);
        if (mPolicy.interceptKeyTi(focus, keycode, nextKey.getMetaState(), down, repeatCount)) {
            return CONSUMED_EVENT_TOKEN;
        }
        return focus;
    } else if (!isPointerEvent) {
        boolean dispatch = mKeyWaiter.checkShouldDispatchKey(-1);
        if (!dispatch) {
            Log.w(TAG, "String_Node_Str" + nextMotion);
            return SKIP_TARGET_TOKEN;
        }
        WindowState focus = null;
        synchronized (mWindowMap) {
            focus = getFocusedWindowLocked();
        }
        wakeupIfNeeded(focus, LocalPowerManager.BUTTON_EVENT);
        return focus;
    }
    if (nextMotion == null) {
        return SKIP_TARGET_TOKEN;
    }
    boolean dispatch = mKeyWaiter.checkShouldDispatchKey(KeyEvent.KEYCODE_UNKNOWN);
    if (!dispatch) {
        Log.w(TAG, "String_Node_Str" + nextMotion);
        return SKIP_TARGET_TOKEN;
    }
    int action = nextMotion.getAction();
    final float xf = nextMotion.getX();
    final float yf = nextMotion.getY();
    final long eventTime = nextMotion.getEventTime();
    final boolean screenWasOff = qev != null && (qev.flags & WindowManagerPolicy.FLAG_BRIGHT_HERE) != 0;
    WindowState target = null;
    synchronized (mWindowMap) {
        synchronized (this) {
            if (action == MotionEvent.ACTION_DOWN) {
                if (mMotionTarget != null) {
                    Log.w(TAG, "String_Node_Str" + mMotionTarget);
                    mMotionTarget = null;
                }
                final int x = (int) xf;
                final int y = (int) yf;
                final ArrayList windows = mWindows;
                final int N = windows.size();
                WindowState topErrWindow = null;
                final Rect tmpRect = mTempRect;
                for (int i = N - 1; i >= 0; i--) {
                    WindowState child = (WindowState) windows.get(i);
                    final int flags = child.mAttrs.flags;
                    if ((flags & WindowManager.LayoutParams.FLAG_SYSTEM_ERROR) != 0) {
                        if (topErrWindow == null) {
                            topErrWindow = child;
                        }
                    }
                    if (!child.isVisibleLw()) {
                        continue;
                    }
                    if ((flags & WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE) != 0) {
                        if ((flags & WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH) != 0) {
                            child.mNextOutsideTouch = mOutsideTouchTargets;
                            mOutsideTouchTargets = child;
                        }
                        continue;
                    }
                    tmpRect.set(child.mFrame);
                    if (child.mTouchableInsets == ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_CONTENT) {
                        tmpRect.left += child.mGivenContentInsets.left;
                        tmpRect.top += child.mGivenContentInsets.top;
                        tmpRect.right -= child.mGivenContentInsets.right;
                        tmpRect.bottom -= child.mGivenContentInsets.bottom;
                    } else if (child.mTouchableInsets == ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_VISIBLE) {
                        tmpRect.left += child.mGivenVisibleInsets.left;
                        tmpRect.top += child.mGivenVisibleInsets.top;
                        tmpRect.right -= child.mGivenVisibleInsets.right;
                        tmpRect.bottom -= child.mGivenVisibleInsets.bottom;
                    }
                    final int touchFlags = flags & (WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL);
                    if (tmpRect.contains(x, y) || touchFlags == 0) {
                        if (!screenWasOff || (flags & WindowManager.LayoutParams.FLAG_TOUCHABLE_WHEN_WAKING) != 0) {
                            mMotionTarget = child;
                        } else {
                            mMotionTarget = null;
                        }
                        break;
                    }
                    if ((flags & WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH) != 0) {
                        child.mNextOutsideTouch = mOutsideTouchTargets;
                        mOutsideTouchTargets = child;
                    }
                }
                if (topErrWindow != null && mMotionTarget != topErrWindow) {
                    mMotionTarget = null;
                }
            }
            target = mMotionTarget;
        }
    }
    wakeupIfNeeded(target, eventType(nextMotion));
    return target != null ? target : SKIP_TARGET_TOKEN;
}

Output:
         if (!dispatch) {
-            mPolicy.interceptKeyTi(null, keycode, nextKey.getMetaState(), down, repeatCount);
+            if (callingUid == 0 || mContext.checkPermission(android.Manifest.permission.INJECT_EVENTS, callingPid, callingUid) == PackageManager.PERMISSION_GRANTED) {
+                mPolicy.interceptKeyTi(null, keycode, nextKey.getMetaState(), down, repeatCount);
+            }
             Log.w(TAG, "String_Node_Str" + nextKey);


Input:
public ClusterRead findClusterWithNodes(String clusterName, boolean includeVolumes) {
    ClusterEntity cluster = clusterDao.findWithNodes(clusterName, includeVolumes);
    ClusterRead clusterRead = RestObjectManager.clusterEntityToRead(cluster);
    SoftwareManager softMgr = null;
    try {
        softMgr = softwareManagerCollector.getSoftwareManager(cluster.getAppManager());
    } catch (Exception e) {
        logger.error("String_Node_Str");
    }
    int clusterInstanceNum = 0;
    List<NodeGroupRead> ngReads = new ArrayList<>();
    List<VcResourcePoolEntity> rps = new ArrayList<>();
    for (NodeGroupEntity ng : cluster.getNodeGroupsSortedById()) {
        NodeGroupRead ngRead = RestObjectManager.nodeGroupEntityToRead(ng);
        List<NodeRead> nodeReads = new ArrayList<>();
        for (NodeEntity node : ng.getNodes()) {
            nodeReads.add(RestObjectManager.nodeEntityToRead(node, includeVolumes));
        }
        ngRead.setInstances(nodeReads);
        int instanceNum = this.nodeDao.getCountByNodeGroup(ng.getId());
        ngRead.setInstanceNum(instanceNum);
        clusterInstanceNum += instanceNum;
        try {
            ngRead.setComputeOnly(softMgr.isComputeOnlyRoles(ngRead.getRoles()));
        } catch (Exception e) {
        }
        ngReads.add(ngRead);
        List<VcResourcePoolEntity> rpsNg = this.rpDao.findUsedRpsByNodeGroup(ng.getId());
        if (rpsNg != null && !rpsNg.isEmpty()) {
            rps.addAll(rpsNg);
        }
        logger.debug("String_Node_Str" + rps.size());
    }
    clusterRead.setNodeGroups(ngReads);
    clusterRead.setInstanceNum(clusterInstanceNum);
    clusterRead.setTemplateName(this.nodeTemplateDAO.findByMoid(cluster.getTemplateId()).getName());
    List<ResourcePoolRead> rpReads = new ArrayList<ResourcePoolRead>();
    Set<Long> processedRpIds = new HashSet<>();
    for (VcResourcePoolEntity rp : rps) {
        if (!processedRpIds.contains(rp.getId())) {
            ResourcePoolRead rpRead = RestObjectManager.vcResourcePoolEntityToRead(rp);
            rpRead.setNodes(null);
            rpReads.add(rpRead);
            processedRpIds.add(rp.getId());
        }
    }
    logger.debug("String_Node_Str" + rpReads.size());
    clusterRead.setResourcePools(rpReads);
    return clusterRead;
}

Output:
     clusterRead.setInstanceNum(clusterInstanceNum);
-    clusterRead.setTemplateName(this.nodeTemplateDAO.findByMoid(cluster.getTemplateId()).getName());
+    setNodeTemplateName(clusterRead, cluster.getTemplateId());
     List<ResourcePoolRead> rpReads = new ArrayList<ResourcePoolRead>();


Input:
public static void setNumberMinMaxToScale(AutoScale sc, Object oMinimum, Object oMaximum, final RunTimeContext rtc, final OneAxis ax) throws ChartException {
    if (oMinimum != null) {
        if (oMinimum instanceof NumberDataElement) {
            sc.setMinimum(new Double(((NumberDataElement) oMinimum).getValue()));
        } else {
            throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", new Object[] { sc.getMinimum(), ax.getModelAxis().getType().getName() }, Messages.getResourceBundle(rtc.getULocale()));
        }
        sc.info.bMinimumFixed(true);
    }
    if (oMaximum != null) {
        if (oMaximum instanceof NumberDataElement) {
            sc.setMaximum(Double.valueOf(((NumberDataElement) oMaximum).getValue()));
        } else {
            throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", new Object[] { sc.getMaximum(), ax.getModelAxis().getType().getName() }, Messages.getResourceBundle(rtc.getULocale()));
        }
        sc.info.bMaximumFixed(true);
    }
    if (sc.info.bMaximumFixed && sc.info.bMinimumFixed) {
        if (((Double) sc.getMinimum()).doubleValue() > ((Double) sc.getMaximum()).doubleValue()) {
            throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", new Object[] { sc.getMinimum(), sc.getMaximum() }, Messages.getResourceBundle(rtc.getULocale()));
        }
    }
}

Output:
         } else {
-            throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", new Object[] { sc.getMinimum(), ax.getModelAxis().getType().getName() }, Messages.getResourceBundle(rtc.getULocale()));
+            throw new ChartException(ChartEnginePlugin.ID, ChartException.GENERATION, "String_Node_Str", new Object[] { oMinimum, ax.getModelAxis().getType().getName() }, Messages.getResourceBundle(rtc.getULocale()));
         }


Input:
public void handle(Command command, Arguments arguments, Response response, IDebugAdapterContext context) {
    StackTraceArguments stacktraceArgs = (StackTraceArguments) arguments;
    List<Types.StackFrame> result = new ArrayList<>();
    if (stacktraceArgs.startFrame < 0 || stacktraceArgs.levels < 0) {
        response.body = new Responses.StackTraceResponseBody(result, 0);
        return;
    }
    ThreadReference thread = DebugUtility.getThread(context.getDebugSession(), stacktraceArgs.threadId);
    int totalFrames = 0;
    if (thread != null) {
        try {
            totalFrames = thread.frameCount();
            if (totalFrames <= stacktraceArgs.startFrame) {
                response.body = new Responses.StackTraceResponseBody(result, totalFrames);
                return;
            }
            List<StackFrame> stackFrames = stacktraceArgs.levels == 0 ? thread.frames(stacktraceArgs.startFrame, totalFrames - stacktraceArgs.startFrame) : thread.frames(stacktraceArgs.startFrame, Math.min(totalFrames - stacktraceArgs.startFrame, stacktraceArgs.levels));
            for (int i = 0; i < stacktraceArgs.levels; i++) {
                StackFrame stackFrame = stackFrames.get(stacktraceArgs.startFrame + i);
                int frameId = context.getRecyclableIdPool().addObject(stackFrame.thread().uniqueID(), new JdiObjectProxy<>(stackFrame));
                Types.StackFrame clientStackFrame = convertDebuggerStackFrameToClient(stackFrame, frameId, context);
                result.add(clientStackFrame);
            }
        } catch (IncompatibleThreadStateException | IndexOutOfBoundsException | URISyntaxException | AbsentInformationException e) {
        }
    }
    response.body = new Responses.StackTraceResponseBody(result, totalFrames);
}

Output:
             List<StackFrame> stackFrames = stacktraceArgs.levels == 0 ? thread.frames(stacktraceArgs.startFrame, totalFrames - stacktraceArgs.startFrame) : thread.frames(stacktraceArgs.startFrame, Math.min(totalFrames - stacktraceArgs.startFrame, stacktraceArgs.levels));
-            for (int i = 0; i < stacktraceArgs.levels; i++) {
-                StackFrame stackFrame = stackFrames.get(stacktraceArgs.startFrame + i);
+            for (int i = 0; i < stackFrames.size(); i++) {
+                StackFrame stackFrame = stackFrames.get(i);
                 int frameId = context.getRecyclableIdPool().addObject(stackFrame.thread().uniqueID(), new JdiObjectProxy<>(stackFrame));


Input:
public void waitForUserAction() throws InterruptedException {
    if (!openSocket) {
        return;
    }
    InputStream in;
    try {
        boolean action = false;
        pred.println("String_Node_Str");
        do {
            in = s.getInputStream();
            LineNumberReader reader = new LineNumberReader(new InputStreamReader(in));
            String line = reader.readLine();
            if ("String_Node_Str".equals(line)) {
                pred.println("String_Node_Str");
                Thread.sleep(100);
            } else {
                action = true;
            }
        } while (!action);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Output:
         boolean action = false;
-        pred.println("String_Node_Str");
+        oos.writeObject(TraceStatusBean.UI_STATUS);
         do {


Input:
protected void validateBindingsFileAgainstSchema(Source src) {
    String result = null;
    SchemaFactory sFact = SchemaFactory.newInstance(XMLConstants.SCHEMA_URL);
    Schema theSchema;
    try {
        InputStream bindingsFileXSDInputStream = getClass().getClassLoader().getResourceAsStream("String_Node_Str");
        if (bindingsFileXSDInputStream == null) {
            bindingsFileXSDInputStream = getClass().getClassLoader().getResourceAsStream("String_Node_Str");
        }
        if (bindingsFileXSDInputStream == null) {
            fail("String_Node_Str");
        }
        Source bindingsFileXSDSource = new StreamSource(bindingsFileXSDInputStream);
        theSchema = sFact.newSchema(bindingsFileXSDSource);
        Validator validator = theSchema.newValidator();
        validator.validate(src);
    } catch (Exception e) {
        e.printStackTrace();
        if (e.getMessage() == null) {
            result = "String_Node_Str";
        }
        result = e.getMessage();
    }
    assertTrue("String_Node_Str" + result, result == null);
}

Output:
     try {
-        InputStream bindingsFileXSDInputStream = getClass().getClassLoader().getResourceAsStream("String_Node_Str");
+        InputStream bindingsFileXSDInputStream = getClass().getClassLoader().getResourceAsStream(ECLIPSELINK_OXM_XSD);
         if (bindingsFileXSDInputStream == null) {


Input:
public void makeInactive() {
    mActive--;
    if (mActive == 0) {
        mProc.decActiveServices();
    }
}

Output:
 public void makeInactive() {
-    mActive--;
-    if (mActive == 0) {
-        mProc.decActiveServices();
-    }
+    mActive = false;
 }


Input:
public void read(String line) throws ParserException {
    int split, posa, posb;
    this.clear();
    line = line.replaceAll("String_Node_Str", "String_Node_Str");
    posa = 0;
    posb = split = line.indexOf(' ', posa);
    if (posb == -1)
        return;
    if (line.charAt(posa) == '<')
        posa++;
    if (line.charAt(posb - 1) == '>')
        posb--;
    this.setSubject(line.substring(posa, posb));
    posa = split + 1;
    posb = split = line.indexOf(' ', posa);
    if (posb == -1)
        return;
    if (line.charAt(posa) == '<')
        posa++;
    if (posb > posa && line.charAt(posb - 1) == '>')
        posb--;
    this.setPredicate(line.substring(posa, posb));
    posa = split + 1;
    posb = line.length();
    if (line.charAt(posb - 1) == '.')
        posb--;
    if (line.charAt(posb - 1) == ' ')
        posb--;
    if (line.charAt(posa) == '<') {
        posa++;
        if (posb > posa && line.charAt(posb - 1) == '>')
            posb--;
    }
    this.setObject(UnicodeEscape.unescapeString(line.substring(posa, posb)));
}

Output:
         posb--;
-    this.setSubject(line.substring(posa, posb));
+    this.setSubject(UnicodeEscape.unescapeString(line.substring(posa, posb)));
     posa = split + 1;


Input:
private void addButtonsToPalette() {
    paletteBlock.clear();
    for (int i = paletteLayout.getChildCount() - 1; i > 0; i--) {
        if (paletteLayout.getChildAt(i) instanceof PaletteButton) {
            paletteLayout.removeViewAt(i);
        }
    }
    if (visibleGroups.contains(FormulaBase.class.getSimpleName())) {
        FormulaBase.addToPalette(context, paletteLayout);
    }
    for (TermTypeIf.GroupType g : FormulaTerm.collectPaletteGroups()) {
        if (visibleGroups.contains(g.toString())) {
            FormulaTerm.addToPalette(context, paletteLayout, g);
        }
    }
    for (int i = 0; i < Category.values().length; i++) {
        paletteBlock.add(new ArrayList<PaletteButton>());
    }
    for (int i = 0; i < paletteLayout.getChildCount(); i++) {
        View b = paletteLayout.getChildAt(i);
        if (b instanceof PaletteButton) {
            final PaletteButton pb = (PaletteButton) b;
            if (pb.getCategories() != null) {
                for (Category cat : pb.getCategories()) {
                    paletteBlock.get(cat.ordinal()).add(pb);
                }
            }
            pb.setOnLongClickListener(this);
            pb.setOnClickListener(this);
        }
    }
}

Output:
     }
-    if (visibleGroups.contains(FormulaBase.class.getSimpleName())) {
-        FormulaBase.addToPalette(context, paletteLayout);
-    }
+    FormulaBase.addToPalette(context, termButtons);
     for (TermTypeIf.GroupType g : FormulaTerm.collectPaletteGroups()) {


Input:
public void swap(final int arg0, final int arg1) {
    if (input != null)
        input.internalSwap(outer.internalTranslate(arg0), outer.internalTranslate(arg1));
    if (output != null)
        output.internalSwap(outer.internalTranslate(arg0), outer.internalTranslate(arg1));
    if (swapper != null)
        swapper.swap(arg0, arg1);
}

Output:
     if (swapper != null)
-        swapper.swap(arg0, arg1);
+        swapper.swap(outer.internalTranslate(arg0), outer.internalTranslate(arg1));
 }


Input:
private void generateMethod(ClassFile classFile, MethodBinding methodBinding, BodyGenerator gen) {
    classFile.generateMethodInfoHeader(methodBinding);
    int methodAttributeOffset = classFile.contentsOffset;
    int attributeNumber = classFile.generateMethodInfoAttribute(methodBinding, AstUtil.getAjSyntheticAttribute());
    int codeAttributeOffset = classFile.contentsOffset;
    classFile.generateCodeAttributeHeader();
    CodeStream codeStream = classFile.codeStream;
    MethodDeclaration md = AstUtil.makeMethodDeclaration(methodBinding);
    md.scope = initializerScope;
    codeStream.reset(md, classFile);
    gen.generate(codeStream);
    classFile.completeCodeAttribute(codeAttributeOffset);
    attributeNumber++;
    classFile.completeMethodInfo(methodAttributeOffset, attributeNumber);
}

Output:
     int methodAttributeOffset = classFile.contentsOffset;
-    int attributeNumber = classFile.generateMethodInfoAttribute(methodBinding, AstUtil.getAjSyntheticAttribute());
+    int attributeNumber;
+    if (additionalAttributes != null) {
+        List attrs = new ArrayList();
+        attrs.addAll(AstUtil.getAjSyntheticAttribute());
+        attrs.addAll(additionalAttributes);
+        attributeNumber = classFile.generateMethodInfoAttribute(methodBinding, attrs);
+    } else {
+        attributeNumber = classFile.generateMethodInfoAttribute(methodBinding, AstUtil.getAjSyntheticAttribute());
+    }
     int codeAttributeOffset = classFile.contentsOffset;


Input:
private void parseExtendedCaps(byte[] v) {
    mHasSM = (v[0] & MASK_SM) != 0;
    mHasKeyImport = (v[0] & MASK_KEY_IMPORT) != 0;
    mAttriburesChangable = (v[0] & MASK_ATTRIBUTES_CHANGABLE) != 0;
    mSMAESKeySize = (v[1] == 1) ? 16 : 32;
    mMaxCmdLen = (v[6] << 8) + v[7];
    mMaxRspLen = (v[8] << 8) + v[9];
}

Output:
     mAttriburesChangable = (v[0] & MASK_ATTRIBUTES_CHANGABLE) != 0;
-    mSMAESKeySize = (v[1] == 1) ? 16 : 32;
+    mSMAESKeySize = 0;
+    switch(v[1]) {
+        case 1:
+            mSMAESKeySize = 16;
+            break;
+        case 2:
+            mSMAESKeySize = 32;
+            break;
+    }
     mMaxCmdLen = (v[6] << 8) + v[7];


Input:
public void forward(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
    original.getRequestDispatcher(path).forward(original, servletResponse);
}

Output:
 public void forward(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
-    original.getRequestDispatcher(path).forward(original, servletResponse);
+    original.getRequestDispatcher(path).forward(RequestWrapper.this, servletResponse);
 }


Input:
public void addTraceableCuboids(List<IndexedCuboid6> cuboids) {
    float min = BlockPipe.BASE_MIN;
    float max = BlockPipe.BASE_MAX;
    int x = pos.getX();
    int y = pos.getY();
    int z = pos.getZ();
    IBlockState actualState = worldObj.getBlockState(pos).getActualState(worldObj, pos);
    {
        int connectDown = canConnectSide(EnumFacing.DOWN);
        if (connectDown > 0 || isPipeFacing(actualState, BlockPipe.DOWN, BlockPipe.UP)) {
            float bottom = connectDown == 2 ? -5F / 16F : 0F;
            cuboids.add(new IndexedCuboid6(0, new Cuboid6(x + min, y + bottom, z + min, x + max, y + max, z + max)));
        }
    }
    {
        int connectUp = canConnectSide(EnumFacing.UP);
        if (connectUp > 0 || isPipeFacing(actualState, BlockPipe.UP, BlockPipe.DOWN)) {
            float top = connectUp == 2 ? 21F / 16F : 1F;
            cuboids.add(new IndexedCuboid6(1, new Cuboid6(x + min, y + min, z + min, x + max, y + top, z + max)));
        }
    }
    {
        int connectNorth = canConnectSide(EnumFacing.NORTH);
        if (connectNorth > 0 || isPipeFacing(actualState, BlockPipe.NORTH, BlockPipe.SOUTH)) {
            float bottom = connectNorth == 2 ? -5F / 16F : 0F;
            cuboids.add(new IndexedCuboid6(2, new Cuboid6(x + min, y + min, z + bottom, x + max, y + max, z + max)));
        }
    }
    {
        int connectSouth = canConnectSide(EnumFacing.SOUTH);
        if (connectSouth > 0 || isPipeFacing(actualState, BlockPipe.SOUTH, BlockPipe.NORTH)) {
            float top = connectSouth == 2 ? 21F / 16F : 1F;
            cuboids.add(new IndexedCuboid6(3, new Cuboid6(x + min, y + min, z + min, x + max, y + max, z + top)));
        }
    }
    {
        int connectWest = canConnectSide(EnumFacing.WEST);
        if (connectWest > 0 || isPipeFacing(actualState, BlockPipe.WEST, BlockPipe.EAST)) {
            float bottom = connectWest == 2 ? -5F / 16F : 0F;
            cuboids.add(new IndexedCuboid6(4, new Cuboid6(x + bottom, y + min, z + min, x + max, y + max, z + max)));
        }
    }
    {
        int connectEast = canConnectSide(EnumFacing.EAST);
        if (connectEast > 0 || isPipeFacing(actualState, BlockPipe.EAST, BlockPipe.WEST)) {
            float top = connectEast == 2 ? 21F / 16F : 1F;
            cuboids.add(new IndexedCuboid6(5, new Cuboid6(x + min, y + min, z + min, x + top, y + max, z + max)));
        }
    }
    cuboids.add(new IndexedCuboid6(6, new Cuboid6(x + min, y + min, z + min, x + 12F / 16F, y + 12F / 16F, z + 12F / 16F)));
}

Output:
     IBlockState actualState = worldObj.getBlockState(pos).getActualState(worldObj, pos);
-    {
+    boolean hasDown = actualState.getValue(BlockPipe.DOWN);
+    boolean hasUp = actualState.getValue(BlockPipe.UP);
+    boolean hasNorth = actualState.getValue(BlockPipe.NORTH);
+    boolean hasSouth = actualState.getValue(BlockPipe.SOUTH);
+    boolean hasWest = actualState.getValue(BlockPipe.WEST);
+    boolean hasEast = actualState.getValue(BlockPipe.EAST);
+    int numDirs = getMyDirections().size();
+    if (shouldStretchInDirection(hasDown, hasUp, numDirs)) {
         int connectDown = canConnectSide(EnumFacing.DOWN);


Input:
public GECandidateProgram getInitialProgram(int depth) {
    GrammarNode start = grammar.getStartRule();
    List<Integer> codons = new ArrayList<Integer>();
    buildDerivationTree(codons, start, 0, depth);
    return new GECandidateProgram(codons);
}

Output:
     buildDerivationTree(codons, start, 0, depth);
-    return new GECandidateProgram(codons);
+    return new GECandidateProgram(model, codons);
 }


Input:
public String getEntrySetName() {
    if (identifierValue != null)
        return identifierValue + "String_Node_Str" + this.getEntrySetName();
    else
        return this.getEntrySetName();
}

Output:
     if (identifierValue != null)
-        return identifierValue + "String_Node_Str" + this.getEntrySetName();
+        return identifierValue + "String_Node_Str" + super.getEntrySetName();
     else


Input:
public final void addBatch(long eventTime, float[] inData, int metaState) {
    float[] data = mDataSamples;
    long[] times = mTimeSamples;
    final int NP = mNumPointers;
    final int NS = mNumSamples;
    final int NI = NP * NS;
    final int ND = NI * NUM_SAMPLE_DATA;
    if (data.length <= ND) {
        final int NEW_ND = ND + (NP * (BASE_AVAIL_SAMPLES * NUM_SAMPLE_DATA));
        float[] newData = new float[NEW_ND];
        System.arraycopy(data, 0, newData, 0, ND);
        mDataSamples = data = newData;
    }
    if (times.length <= NS) {
        final int NEW_NS = NS + BASE_AVAIL_SAMPLES;
        long[] newHistoryTimes = new long[NEW_NS];
        System.arraycopy(times, 0, newHistoryTimes, 0, NS);
        mTimeSamples = times = newHistoryTimes;
    }
    times[NS] = times[0];
    times[0] = eventTime;
    System.arraycopy(data, 0, data, ND, mNumPointers * NUM_SAMPLE_DATA);
    System.arraycopy(inData, 0, data, 0, mNumPointers * NUM_SAMPLE_DATA);
    mNumSamples = NS + 1;
    mRawX = inData[SAMPLE_X];
    mRawY = inData[SAMPLE_Y];
    mMetaState |= metaState;
    if (DEBUG_POINTERS) {
        StringBuilder sb = new StringBuilder(128);
        sb.append("String_Node_Str");
        for (int i = 0; i < mNumPointers; i++) {
            sb.append("String_Node_Str");
            sb.append(mPointerIdentifiers[i]);
            sb.append("String_Node_Str");
            sb.append(mDataSamples[(i * NUM_SAMPLE_DATA) + SAMPLE_X]);
            sb.append("String_Node_Str");
            sb.append(mDataSamples[(i * NUM_SAMPLE_DATA) + SAMPLE_Y]);
            sb.append("String_Node_Str");
        }
        Log.v("String_Node_Str", sb.toString());
    }
}

Output:
     final int ND = NI * NUM_SAMPLE_DATA;
-    if (data.length <= ND) {
+    if (data.length < (ND + (NP * NUM_SAMPLE_DATA))) {
         final int NEW_ND = ND + (NP * (BASE_AVAIL_SAMPLES * NUM_SAMPLE_DATA));


Input:
private static VmInstance maybeFindVm(final String instanceId, final String publicIp, final String privateIp) {
    VmInstance vm = null;
    try {
        vm = VmInstances.lookup(instanceId);
    } catch (NoSuchElementException ex) {
        try {
            vm = VmInstances.lookupByInstanceIp(privateIp);
        } catch (final NoSuchElementException e) {
            Logs.exhaust().error(e);
        }
    }
    if (vm != null) {
        LOG.trace("String_Node_Str" + vm.getInstanceId() + "String_Node_Str" + vm.getState() + "String_Node_Str" + publicIp);
        if (publicIp.equals(vm.getPublicAddress())) {
            LOG.trace("String_Node_Str" + vm.getInstanceId() + "String_Node_Str" + vm.getState() + "String_Node_Str" + publicIp);
        }
    }
    return vm;
}

Output:
         try {
-            vm = VmInstances.lookupByInstanceIp(privateIp);
+            vm = VmInstances.lookupByPrivateIp(privateIp);
         } catch (final NoSuchElementException e) {


Input:
public static List getJdbcDriversFromODADir(String driverName) {
    if (jdbcDriverInfos != null) {
        if (!driverNameMap.containsValue(jdbcDriverInfos.get(0)))
            jdbcDriverInfos.remove(0);
        if (JdbcDriverManagerDialog.needResetPreferences()) {
            resetPreferences();
            JdbcDriverManagerDialog.resetDriverChangedStatus();
        }
        return jdbcDriverInfos;
    }
    jdbcDriverInfos = new ArrayList();
    failLoadFileList = new ArrayList();
    driverNameMap = new HashMap();
    file2Drivers = new Hashtable();
    addDriversFromFiles();
    final String ODBCJDBCDriverName = "String_Node_Str";
    JDBCDriverInformation ODBCJDBCInfo = null;
    JDBCDriverInformation[] driverInfos = JDBCDriverInfoManager.getDrivers();
    for (int i = 0; i < driverInfos.length; i++) {
        JDBCDriverInformation newInfo = driverInfos[i];
        JDBCDriverInformation existing = (JDBCDriverInformation) driverNameMap.get(newInfo.getDriverClassName());
        if (existing == null) {
            if (newInfo.getDriverClassName().equalsIgnoreCase(ODBCJDBCDriverName)) {
                ODBCJDBCInfo = newInfo;
                continue;
            }
            jdbcDriverInfos.add(newInfo);
            driverNameMap.put(newInfo.getDriverClassName(), newInfo);
        } else {
            existing.setDisplayName(newInfo.getDisplayName());
            existing.setUrlFormat(newInfo.getUrlFormat());
        }
    }
    if (ODBCJDBCInfo != null) {
        jdbcDriverInfos.add(ODBCJDBCInfo);
        driverNameMap.put(ODBCJDBCInfo.getDriverClassName(), ODBCJDBCInfo);
    }
    resetPreferences();
    return jdbcDriverInfos;
}

Output:
         }
-        return jdbcDriverInfos;
+        return getDriverList();
     }


Input:
public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
    encounter.addError("String_Node_Str", type);
    encounter.addError(new IllegalArgumentException("String_Node_Str"));
    encounter.addError(new Message("String_Node_Str"));
    encounter.addError(new IllegalStateException());
}

Output:
 public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
-    encounter.addError("String_Node_Str", type);
-    encounter.addError(new IllegalArgumentException("String_Node_Str"));
-    encounter.addError(new Message("String_Node_Str"));
-    encounter.addError(new IllegalStateException());
+    ++count;
+    MembersInjector membersInjector = new CountingMembersInjector();
+    encounter.register(membersInjector);
+    encounter.register(membersInjector);
+    InjectionListener injectionListener = new CountingInjectionListener();
+    encounter.register(injectionListener);
+    encounter.register(injectionListener);
 }


Input:
protected Composite getComponent(Composite parent) {
    ChartUIUtil.bindHelp(parent, ChartHelpContextIds.POPUP_TEXT_FORMAT);
    cmpContent = new Composite(parent, SWT.NONE);
    {
        GridLayout glMain = new GridLayout();
        glMain.marginHeight = 7;
        glMain.marginWidth = 7;
        cmpContent.setLayout(glMain);
    }
    boolean isLabelEnabled = getAxisForProcessing().getLabel().isVisible();
    Group grpLabel = new Group(cmpContent, SWT.NONE);
    {
        GridLayout layout = new GridLayout();
        layout.numColumns = 2;
        layout.marginWidth = 0;
        layout.marginHeight = 10;
        grpLabel.setLayout(layout);
        grpLabel.setText(Messages.getString("String_Node_Str"));
        grpLabel.setEnabled(isLabelEnabled);
    }
    if (axisType == AngleType.Z) {
        LabelAttributesContext attributesContext = new LabelAttributesContext();
        attributesContext.isPositionEnabled = false;
        attributesContext.isVisibilityEnabled = false;
        attributesContext.isFontEnabled = false;
        attributesContext.isFontAlignmentEnabled = false;
        lacLabel = new LabelAttributesComposite(grpLabel, SWT.NONE, getContext(), attributesContext, null, getAxisForProcessing().getLabelPosition(), getAxisForProcessing().getLabel(), getChart().getUnits());
    } else {
        LabelAttributesContext attributesContext = new LabelAttributesContext();
        attributesContext.isVisibilityEnabled = false;
        attributesContext.isFontEnabled = false;
        attributesContext.isFontAlignmentEnabled = false;
        lacLabel = new LabelAttributesComposite(grpLabel, SWT.NONE, getContext(), attributesContext, null, getAxisForProcessing().getLabelPosition(), getAxisForProcessing().getLabel(), getChart().getUnits(), getPositionScope());
    }
    GridData gdLACLabel = new GridData(GridData.FILL_HORIZONTAL);
    gdLACLabel.horizontalSpan = 2;
    lacLabel.setLayoutData(gdLACLabel);
    lacLabel.addListener(this);
    lacLabel.setEnabled(isLabelEnabled);
    Composite cmpOther = new Composite(grpLabel, SWT.NONE);
    {
        GridLayout glCmpOther = new GridLayout();
        glCmpOther.numColumns = 2;
        glCmpOther.marginWidth = 0;
        glCmpOther.marginHeight = 0;
        cmpOther.setLayout(glCmpOther);
    }
    Label lblInterval = new Label(cmpOther, SWT.NONE);
    {
        GridData gd = new GridData();
        gd.horizontalIndent = 10;
        lblInterval.setLayoutData(gd);
        lblInterval.setText(Messages.getString("String_Node_Str"));
        lblInterval.setEnabled(isLabelEnabled);
    }
    iscInterval = new Spinner(cmpOther, SWT.BORDER);
    {
        iscInterval.setMinimum(1);
        iscInterval.setSelection(getAxisForProcessing().getInterval());
        GridData gd = new GridData();
        gd.widthHint = 135;
        iscInterval.setLayoutData(gd);
        iscInterval.addSelectionListener(this);
        iscInterval.setEnabled(isLabelEnabled);
    }
    {
        Label lbEllipsis = new Label(cmpOther, SWT.NONE);
        {
            GridData gd = new GridData();
            gd.horizontalIndent = 10;
            lbEllipsis.setLayoutData(gd);
            lbEllipsis.setText(Messages.getString("String_Node_Str"));
            lbEllipsis.setEnabled(true);
        }
        iscEllipsis = new Spinner(cmpOther, SWT.BORDER);
        {
            iscEllipsis.setMinimum(0);
            GridData gd = new GridData(GridData.FILL_BOTH);
            iscEllipsis.setLayoutData(gd);
            iscEllipsis.setToolTipText(Messages.getString("String_Node_Str"));
            iscEllipsis.addSelectionListener(this);
            iscEllipsis.setEnabled(getAxisForProcessing().getType() == AxisType.TEXT_LITERAL);
            iscEllipsis.setSelection(getAxisForProcessing().getLabel().getEllipsis());
        }
    }
    if (false) {
        chkWithinAxes = new Button(grpLabel, SWT.CHECK);
        {
            GridData gd = new GridData();
            gd.horizontalSpan = 2;
            gd.horizontalIndent = 10;
            chkWithinAxes.setLayoutData(gd);
            chkWithinAxes.setText("String_Node_Str");
            chkWithinAxes.addSelectionListener(this);
            chkWithinAxes.setEnabled(!(getAxisForProcessing().isCategoryAxis() || getAxisForProcessing().getType() == AxisType.TEXT_LITERAL));
            chkWithinAxes.setSelection(getAxisForProcessing().isLabelWithinAxes());
        }
    }
    return cmpContent;
}

Output:
             iscEllipsis.addSelectionListener(this);
-            iscEllipsis.setEnabled(getAxisForProcessing().getType() == AxisType.TEXT_LITERAL);
+            iscEllipsis.setEnabled(getAxisForProcessing().getType() == AxisType.TEXT_LITERAL || getAxisForProcessing().isCategoryAxis());
             iscEllipsis.setSelection(getAxisForProcessing().getLabel().getEllipsis());


Input:
public boolean equals(Object o) {
    EnvironmentVariable e = (EnvironmentVariable) o;
    if (!getVariableType().equals(e.getVariableType()))
        return false;
    if (isStringValuesSupported()) {
        if (!e.isStringValuesSupported() || stringValues.length != e.stringValues.length)
            return false;
        for (int i = 0; i < stringValues.length; i++) {
            if (!stringValues[i].equals(e.stringValues[i])) {
                return false;
            }
        }
    }
    if (isFloatValuesSupported()) {
        if (!e.isFloatValuesSupported() || floatValues.length != e.floatValues.length)
            return false;
        for (int i = 0; i < floatValues.length; i++) {
            if (!(floatValues[i] == e.floatValues[i])) {
                return false;
            }
        }
    }
    return true;
}

Output:
     if (isStringValuesSupported()) {
-        if (!e.isStringValuesSupported() || stringValues.length != e.stringValues.length)
+        if (!e.isStringValuesSupported() || stringValues == null || e.stringValues == null || stringValues.length != e.stringValues.length)
             return false;


Input:
public static void logEvent(int eventType, String ifName, long durationMs) {
    IpConnectivityEvent.logEvent(eventType, new IpManagerEvent(ifName, durationMs));
}

Output:
 public static void logEvent(int eventType, String ifName, long durationMs) {
-    IpConnectivityEvent.logEvent(eventType, new IpManagerEvent(ifName, durationMs));
+    logEvent(eventType, new IpManagerEvent(ifName, durationMs));
 }


Input:
public void getNodesMetadata(NodeMetaDataParameters nodeMetaDataParameters, MetaDataResultsFilter resultFilter, NodeMetaDataQueryCallback callback) {
    if (false == enabled) {
        return;
    }
    NodeMetaDataQueryRowHandler rowHandler = new NodeMetaDataQueryRowHandler(callback);
    boolean includeType = (resultFilter == null ? true : resultFilter.getIncludeType());
    boolean includeProperties = (resultFilter == null ? true : resultFilter.getIncludeProperties());
    boolean includeAspects = (resultFilter == null ? true : resultFilter.getIncludeAspects());
    boolean includePaths = (resultFilter == null ? true : resultFilter.getIncludePaths());
    boolean includeNodeRef = (resultFilter == null ? true : resultFilter.getIncludeNodeRef());
    boolean includeParentAssociations = (resultFilter == null ? true : resultFilter.getIncludeParentAssociations());
    boolean includeChildAssociations = (resultFilter == null ? true : resultFilter.getIncludeChildAssociations());
    boolean includeOwner = (resultFilter == null ? true : resultFilter.getIncludeOwner());
    boolean includeChildIds = (resultFilter == null ? true : resultFilter.getIncludeChildIds());
    boolean includeTxnId = (resultFilter == null ? true : resultFilter.getIncludeTxnId());
    List<Long> nodeIds = preCacheNodes(nodeMetaDataParameters);
    for (Long nodeId : nodeIds) {
        Map<QName, Serializable> props = null;
        Set<QName> aspects = null;
        if (!nodeDAO.exists(nodeId)) {
            continue;
        }
        NodeMetaData nodeMetaData = new NodeMetaData();
        nodeMetaData.setNodeId(nodeId);
        Pair<Long, NodeRef> pair = nodeDAO.getNodePair(nodeId);
        nodeMetaData.setAclId(nodeDAO.getNodeAclId(nodeId));
        if (includeTxnId) {
            nodeMetaData.setTxnId(nodeDAO.getNodeRefStatus(pair.getSecond()).getDbTxnId());
        }
        if (includeType) {
            QName nodeType = nodeDAO.getNodeType(nodeId);
            nodeMetaData.setNodeType(nodeType);
        }
        if (includeProperties) {
            Map<QName, Serializable> sourceProps = nodeDAO.getNodeProperties(nodeId);
            props = new HashMap<QName, Serializable>((int) (sourceProps.size() * 1.3));
            for (QName propertyQName : sourceProps.keySet()) {
                PropertyDefinition propDef = dictionaryService.getProperty(propertyQName);
                if (propDef != null) {
                    props.put(propertyQName, sourceProps.get(propertyQName));
                }
            }
            nodeMetaData.setProperties(props);
        } else {
            nodeMetaData.setProperties(Collections.<QName, Serializable>emptyMap());
        }
        if (includeAspects) {
            aspects = nodeDAO.getNodeAspects(nodeId);
        }
        nodeMetaData.setAspects(aspects);
        if (includePaths) {
            Collection<Pair<Path, QName>> categoryPaths = getCategoryPaths(pair.getSecond(), aspects, props);
            List<Path> directPaths = nodeDAO.getPaths(pair, false);
            Collection<Pair<Path, QName>> paths = new ArrayList<Pair<Path, QName>>(directPaths.size() + categoryPaths.size());
            for (Path path : directPaths) {
                paths.add(new Pair<Path, QName>(path, null));
            }
            paths.addAll(categoryPaths);
            nodeMetaData.setPaths(paths);
        }
        if (includeNodeRef) {
            nodeMetaData.setNodeRef(pair.getSecond());
        }
        if (includeChildAssociations) {
            final List<ChildAssociationRef> childAssocs = new ArrayList<ChildAssociationRef>(100);
            nodeDAO.getChildAssocs(nodeId, null, null, null, null, null, new ChildAssocRefQueryCallback() {
                public boolean preLoadNodes() {
                    return false;
                }
                public boolean orderResults() {
                    return false;
                }
                public boolean handle(Pair<Long, ChildAssociationRef> childAssocPair, Pair<Long, NodeRef> parentNodePair, Pair<Long, NodeRef> childNodePair) {
                    childAssocs.add(childAssocPair.getSecond());
                    return true;
                }
                public void done() {
                }
            });
            nodeMetaData.setChildAssocs(childAssocs);
        }
        if (includeChildIds) {
            final List<Long> childIds = new ArrayList<Long>(100);
            nodeDAO.getChildAssocs(nodeId, null, null, null, null, null, new ChildAssocRefQueryCallback() {
                public boolean preLoadNodes() {
                    return false;
                }
                public boolean orderResults() {
                    return false;
                }
                public boolean handle(Pair<Long, ChildAssociationRef> childAssocPair, Pair<Long, NodeRef> parentNodePair, Pair<Long, NodeRef> childNodePair) {
                    childIds.add(childNodePair.getFirst());
                    return true;
                }
                public void done() {
                }
            });
            nodeMetaData.setChildIds(childIds);
        }
        if (includeParentAssociations) {
            final List<ChildAssociationRef> parentAssocs = new ArrayList<ChildAssociationRef>(100);
            nodeDAO.getParentAssocs(nodeId, null, null, null, new ChildAssocRefQueryCallback() {
                public boolean preLoadNodes() {
                    return false;
                }
                public boolean orderResults() {
                    return false;
                }
                public boolean handle(Pair<Long, ChildAssociationRef> childAssocPair, Pair<Long, NodeRef> parentNodePair, Pair<Long, NodeRef> childNodePair) {
                    parentAssocs.add(childAssocPair.getSecond());
                    return true;
                }
                public void done() {
                }
            });
            CRC32 crc = new CRC32();
            for (ChildAssociationRef car : parentAssocs) {
                try {
                    crc.update(car.toString().getBytes("String_Node_Str"));
                } catch (UnsupportedEncodingException e) {
                    throw new RuntimeException("String_Node_Str");
                }
            }
            nodeMetaData.setParentAssocs(parentAssocs, crc.getValue());
        }
        if (includeOwner) {
            nodeMetaData.setOwner(ownableService.getOwner(pair.getSecond()));
        }
        rowHandler.processResult(nodeMetaData);
    }
}

Output:
         if (includeProperties) {
-            Map<QName, Serializable> sourceProps = nodeDAO.getNodeProperties(nodeId);
-            props = new HashMap<QName, Serializable>((int) (sourceProps.size() * 1.3));
-            for (QName propertyQName : sourceProps.keySet()) {
-                PropertyDefinition propDef = dictionaryService.getProperty(propertyQName);
-                if (propDef != null) {
-                    props.put(propertyQName, sourceProps.get(propertyQName));
-                }
-            }
+            props = getProperties(nodeId);
             nodeMetaData.setProperties(props);


Input:
public static void main(String[] args) {
    try {
        SBOLDocument doc = new SBOLDocument();
        doc.setDefaultURIprefix("String_Node_Str");
        ComponentDefinition cd = doc.createComponentDefinition("String_Node_Str", ComponentDefinition.DNA);
        ComponentDefinition variant = doc.createComponentDefinition("String_Node_Str", ComponentDefinition.DNA);
        doc.createComponentDefinition("String_Node_Str", ComponentDefinition.DNA);
        Component comp = cd.createComponent("String_Node_Str", AccessType.PUBLIC, "String_Node_Str");
        CombinatorialDerivation combDeriv = doc.createCombinatorialDerivation("String_Node_Str", cd.getIdentity());
        VariableComponent vc = combDeriv.createVariableComponent("String_Node_Str", OperatorType.ONE, comp);
        vc.addVariant(variant.getIdentity());
        doc.write("String_Node_Str");
        SBOLDocument doc2 = SBOLReader.read("String_Node_Str");
        SBOLValidate.compareDocuments("String_Node_Str", doc, "String_Node_Str", doc2);
        if (SBOLValidate.getNumErrors() > 0) {
            for (String error : SBOLValidate.getErrors()) {
                System.out.println(error);
            }
        }
    } catch (Throwable e) {
        e.printStackTrace();
    }
}

Output:
     try {
-        SBOLDocument doc = new SBOLDocument();
-        doc.setDefaultURIprefix("String_Node_Str");
-        ComponentDefinition cd = doc.createComponentDefinition("String_Node_Str", ComponentDefinition.DNA);
-        ComponentDefinition variant = doc.createComponentDefinition("String_Node_Str", ComponentDefinition.DNA);
-        doc.createComponentDefinition("String_Node_Str", ComponentDefinition.DNA);
-        Component comp = cd.createComponent("String_Node_Str", AccessType.PUBLIC, "String_Node_Str");
-        CombinatorialDerivation combDeriv = doc.createCombinatorialDerivation("String_Node_Str", cd.getIdentity());
-        VariableComponent vc = combDeriv.createVariableComponent("String_Node_Str", OperatorType.ONE, comp);
-        vc.addVariant(variant.getIdentity());
-        doc.write("String_Node_Str");
-        SBOLDocument doc2 = SBOLReader.read("String_Node_Str");
-        SBOLValidate.compareDocuments("String_Node_Str", doc, "String_Node_Str", doc2);
-        if (SBOLValidate.getNumErrors() > 0) {
-            for (String error : SBOLValidate.getErrors()) {
-                System.out.println(error);
-            }
-        }
+        SynBioHubFrontend sbh = new SynBioHubFrontend("String_Node_Str", "String_Node_Str");
+        sbh.login("String_Node_Str", "String_Node_Str");
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        String filename = sbh.getAttachment(URI.create("String_Node_Str"), outputStream);
+        File file = new File("String_Node_Str" + filename);
+        FileOutputStream fileOutputStream = new FileOutputStream(file);
+        fileOutputStream.write(outputStream.toByteArray());
+        fileOutputStream.close();
     } catch (Throwable e) {


Input:
public static Message create(DataInputStream input) {
    if (Config.JAVA_SERIALIZATION) {
        try {
            return (Message) (new ObjectInputStream(input).readObject());
        } catch (IOException e) {
            throw new IllegalArgumentException("String_Node_Str", e);
        } catch (ClassNotFoundException e) {
            throw new IllegalArgumentException("String_Node_Str", e);
        }
    }
    return createMine(input);
}

Output:
     if (Config.JAVA_SERIALIZATION) {
-        try {
-            return (Message) (new ObjectInputStream(input).readObject());
-        } catch (IOException e) {
-            throw new IllegalArgumentException("String_Node_Str", e);
-        } catch (ClassNotFoundException e) {
-            throw new IllegalArgumentException("String_Node_Str", e);
-        }
+        return (Message) (new ObjectInputStream(input).readObject());
     }


Input:
public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {
    Field field = new ExternalField(this);
    field.setName(Name.get(name));
    field.setModifiers(access);
    field.setType(ClassFormat.extendedToType(desc));
    if (value != null) {
        field.setValue(IValue.fromObject(value));
    }
    if ((this.modifiers & Modifiers.OBJECT_CLASS) != 0 && name.equals("String_Node_Str")) {
        this.metadata.setInstanceField(field);
        return null;
    }
    this.body.addField(field);
    return new SimpleFieldVisitor(field);
}

Output:
     field.setModifiers(access);
-    field.setType(ClassFormat.extendedToType(desc));
+    field.setType(ClassFormat.extendedToType(signature == null ? desc : signature));
     if (value != null) {


Input:
protected void makeHeader(IProtocolMessage header, IProtocolMessage payload, int headerValue) {
    MyRootProtocol_Response_API response = createResponse(header);
}

Output:
 protected void makeHeader(IProtocolMessage header, IProtocolMessage payload, int headerValue) {
-    MyRootProtocol_Response_API response = createResponse(header);
+    createResponse(header).getRootSwitchResp().setBitValue(headerValue);
 }


Input:
private ParsedField<ParsedLocation> applyMatchWithCountry() {
    List<Country> countries = getCountriesFromCoordinates(latLng);
    if (countries != null && !countries.isEmpty()) {
        if (countries.contains(country)) {
            return ParsedField.success(ParsedLocation.newBuilder().country(country).latLng(latLng).build());
        }
        Optional<Country> equivalentMatch = containsAnyCountry(CountryMaps.equivalent(country), countries);
        if (equivalentMatch.isPresent()) {
            return ParsedField.success(ParsedLocation.newBuilder().country(equivalentMatch.get()).latLng(latLng).build());
        }
        Optional<Country> confusedMatch = containsAnyCountry(CountryMaps.confused(country), countries);
        if (confusedMatch.isPresent()) {
            return ParsedField.success(ParsedLocation.newBuilder().country(confusedMatch.get()).latLng(latLng).build(), Collections.singletonList(new InterpretationIssue(IssueType.COUNTRY_DERIVED_FROM_COORDINATES, DwcTerm.country)));
        }
    }
    LOG.info("String_Node_Str");
    for (CoordinatesFunction transformation : alternativeTransformations) {
        LatLng latLngTransformed = transformation.getTransformer().apply(latLng);
        List<Country> countriesFound = getCountriesFromCoordinates(latLngTransformed);
        if (countriesFound == null || countriesFound.isEmpty()) {
            continue;
        }
        if (countriesFound.contains(country)) {
            List<InterpretationIssue> issues = new ArrayList<>();
            CoordinatesFunction.getIssueTypes(transformation).forEach(issueType -> issues.add(new InterpretationIssue(issueType, getCountryAndCoordinatesTerms())));
            return ParsedField.success(ParsedLocation.newBuilder().country(country).latLng(latLngTransformed).build(), issues);
        }
    }
    return getFailResponse();
}

Output:
     }
-    LOG.info("String_Node_Str");
+    LOG.info("String_Node_Str", latLng);
     for (CoordinatesFunction transformation : alternativeTransformations) {


Input:
public void widgetSelected(SelectionEvent e) {
    if (itemSelected instanceof TreeItem) {
    } else {
        NodeType type = (NodeType) itemSelected.getData(NODE_TYPE);
        if (type == NodeType.CONTAINER)
            ;
        else
            properties();
    }
}

Output:
     if (itemSelected instanceof TreeItem) {
-    } else {
+    }
+    if (itemSelected instanceof TableItem) {
         NodeType type = (NodeType) itemSelected.getData(NODE_TYPE);


Input:
protected void calculateOffsets() {
    if (mLegend == null)
        return;
    Log.i(LOG_TAG, "String_Node_Str");
    if (mLegend.getPosition() == LegendPosition.RIGHT_OF_CHART) {
        mLegend.setOffsetRight(mLegend.getMaximumEntryLength(mLegendLabelPaint));
        mLegendLabelPaint.setTextAlign(Align.LEFT);
    } else if (mLegend.getPosition() == LegendPosition.BELOW_CHART_LEFT || mLegend.getPosition() == LegendPosition.BELOW_CHART_RIGHT) {
        if (mXLabels.getPosition() == XLabelPosition.TOP)
            mLegend.setOffsetBottom(mLegendLabelPaint.getTextSize() * 3.5f);
        else {
            mLegend.setOffsetBottom(mLegendLabelPaint.getTextSize() * 2.5f);
        }
    }
    float yleft = 0f, yright = 0f;
    float xtop = 0f, xbottom = 0f;
    if (mYLabels.getPosition() == YLabelPosition.LEFT) {
        if (mYChartMin >= 0)
            yleft = Utils.calcTextWidth(mYLabelPaint, (int) mDeltaY + "String_Node_Str" + mUnit);
        else
            yleft = Utils.calcTextWidth(mYLabelPaint, (int) (mDeltaY * -1) + "String_Node_Str" + mUnit);
        mYLabelPaint.setTextAlign(Align.RIGHT);
    } else if (mYLabels.getPosition() == YLabelPosition.RIGHT) {
        if (mYChartMin >= 0)
            yright = Utils.calcTextWidth(mYLabelPaint, (int) mDeltaY + "String_Node_Str" + mUnit);
        else
            yright = Utils.calcTextWidth(mYLabelPaint, (int) (mDeltaY * -1) + "String_Node_Str" + mUnit);
        mYLabelPaint.setTextAlign(Align.LEFT);
    } else if (mYLabels.getPosition() == YLabelPosition.BOTH_SIDED) {
        float width = 0f;
        if (mYChartMin >= 0)
            width = Utils.calcTextWidth(mYLabelPaint, (int) mDeltaY + "String_Node_Str" + mUnit);
        else
            width = Utils.calcTextWidth(mYLabelPaint, (int) (mDeltaY * -1) + "String_Node_Str" + mUnit);
        yright = width;
        yleft = width;
    }
    if (mXLabels.getPosition() == XLabelPosition.BOTTOM) {
        xbottom = Utils.calcTextHeight(mXLabelPaint, "String_Node_Str") * 2f;
    } else if (mXLabels.getPosition() == XLabelPosition.TOP) {
        xtop = Utils.calcTextHeight(mXLabelPaint, "String_Node_Str") * 2f;
    } else if (mXLabels.getPosition() == XLabelPosition.BOTH_SIDED) {
        float height = Utils.calcTextHeight(mXLabelPaint, "String_Node_Str") * 2f;
        xbottom = height;
        xtop = height;
    }
    if (mDrawLegend) {
        if (mDrawXLabels) {
            mOffsetBottom = Math.max(mOffsetBottom, xbottom + mLegend.getOffsetBottom());
            mOffsetTop = Math.max(mOffsetTop, xtop + mLegend.getOffsetTop());
        } else {
            mOffsetBottom = Math.max(mOffsetBottom, mLegend.getOffsetBottom());
            mOffsetTop = Math.max(mOffsetTop, mLegend.getOffsetTop());
        }
        if (mDrawYLabels) {
            mOffsetLeft = Math.max(mOffsetLeft, yleft + mLegend.getOffsetLeft());
            mOffsetRight = Math.max(mOffsetRight, yright + mLegend.getOffsetRight());
        } else {
            mOffsetLeft = Math.max(mOffsetLeft, mLegend.getOffsetLeft());
            mOffsetRight = Math.max(mOffsetRight, mLegend.getOffsetRight());
        }
    } else {
        if (mDrawXLabels) {
            mOffsetBottom = Math.max(mOffsetBottom, xbottom);
            mOffsetTop = Math.max(mOffsetTop, xtop);
        }
        if (mDrawYLabels) {
            mOffsetLeft = Math.max(mOffsetLeft, yleft);
            mOffsetRight = Math.max(mOffsetRight, yright);
        }
    }
    mLegend.setOffsetTop(mOffsetTop);
    mLegend.setOffsetLeft(mOffsetLeft);
    prepareContentRect();
    float scaleX = (float) ((getWidth() - mOffsetLeft - mOffsetRight) / mDeltaX);
    float scaleY = (float) ((getHeight() - mOffsetBottom - mOffsetTop) / mDeltaY);
    Matrix val = new Matrix();
    val.postTranslate(0, -mYChartMin);
    val.postScale(scaleX, -scaleY);
    mMatrixValueToPx.set(val);
    Matrix offset = new Matrix();
    offset.postTranslate(mOffsetLeft, getHeight() - mOffsetBottom);
    mMatrixOffset.set(offset);
}

Output:
     if (mLegend.getPosition() == LegendPosition.RIGHT_OF_CHART) {
-        mLegend.setOffsetRight(mLegend.getMaximumEntryLength(mLegendLabelPaint));
+        float spacing = Utils.convertDpToPixel(7f);
+        mLegend.setOffsetRight(mLegend.getMaximumEntryLength(mLegendLabelPaint) + mLegend.getFormSize() + mLegend.getFormToTextSpace() + spacing);
         mLegendLabelPaint.setTextAlign(Align.LEFT);


Input:
public static FlowBuilder createClassifierOutFlow(String flowKey, Match match, SfcRspInfo sfcRspInfo, Long outPort) {
    if (flowKey == null || sfcRspInfo == null || sfcRspInfo.getVxlanIpDst() == null) {
        return null;
    }
    String dstIp = sfcRspInfo.getVxlanIpDst().getValue();
    List<Action> theActions = buildNshActions(sfcRspInfo);
    theActions.add(SfcOpenflowUtils.createActionNxSetTunIpv4Dst(dstIp, theActions.size()));
    theActions.add(outPort == null ? SfcOpenflowUtils.createActionOutPort(OutputPortValues.INPORT.toString(), theActions.size()) : SfcOpenflowUtils.createActionOutPort(outPort.intValue(), theActions.size()));
    InstructionsBuilder isb = SfcOpenflowUtils.wrapActionsIntoApplyActionsInstruction(theActions);
    FlowBuilder flowb = new FlowBuilder();
    flowb.setId(new FlowId(flowKey)).setTableId(TABLE_INDEX_CLASSIFIER).setKey(new FlowKey(new FlowId(flowKey))).setPriority(FLOW_PRIORITY_CLASSIFIER).setMatch(match).setInstructions(isb.build());
    return flowb;
}

Output:
 public static FlowBuilder createClassifierOutFlow(String flowKey, Match match, SfcRspInfo sfcRspInfo, Long outPort) {
-    if (flowKey == null || sfcRspInfo == null || sfcRspInfo.getVxlanIpDst() == null) {
-        return null;
-    }
+    Preconditions.checkNotNull(flowKey, "String_Node_Str");
+    Preconditions.checkNotNull(sfcRspInfo, "String_Node_Str");
+    Preconditions.checkNotNull(sfcRspInfo.getVxlanIpDst(), "String_Node_Str");
     String dstIp = sfcRspInfo.getVxlanIpDst().getValue();


Input:
private String[] getColumnSetOwnerNames() {
    List<String> existingTables = new ArrayList<String>();
    for (ModelElement element : getAnalyzedColumns()) {
        if (element instanceof Column) {
            String tableName = ColumnHelper.getColumnSetFullName((Column) element);
            if (!existingTables.contains(tableName)) {
                existingTables.add(tableName);
            }
        } else if (element instanceof Table) {
            String tableName = ((Table) element).getName();
            if (!existingTables.contains(tableName)) {
                existingTables.add(tableName);
            }
        }
    }
    return existingTables.toArray(new String[existingTables.size()]);
}

Output:
     for (ModelElement element : getAnalyzedColumns()) {
-        if (element instanceof Column) {
+        if (element instanceof Column && element.eContainer() instanceof Table) {
             String tableName = ColumnHelper.getColumnSetFullName((Column) element);


Input:
private void updatePosterAndFanartSizes() {
    updatingPosterAndFanartSizes = true;
    BufferedImage fanartImg = (BufferedImage) (fanartImage);
    if (fanartImg != null) {
        BufferedImage fanartScaledImage = ArtWorkPanel.resizeToFanart(fanartImg);
        this.setNewFanart(fanartScaledImage, false);
    }
    BufferedImage posterImg = Thumb.convertToBufferedImage(posterImage);
    BufferedImage posterScaledImage = ArtWorkPanel.resizeToPoster(posterImg);
    this.setNewPoster(posterScaledImage, false);
}

Output:
     updatingPosterAndFanartSizes = true;
-    BufferedImage fanartImg = (BufferedImage) (fanartImage);
-    if (fanartImg != null) {
-        BufferedImage fanartScaledImage = ArtWorkPanel.resizeToFanart(fanartImg);
+    BufferedImage bufferedFanartImg = Thumb.convertToBufferedImage(fanartImage);
+    if (bufferedFanartImg != null) {
+        BufferedImage fanartScaledImage = ArtWorkPanel.resizeToFanart(bufferedFanartImg);
         this.setNewFanart(fanartScaledImage, false);


Input:
public float getBolderFontWeight(float f) {
    return 0;
}

Output:
 public float getBolderFontWeight(float f) {
-    return 0;
+    int weight = ((int) ((f + 50) / 100)) * 100;
+    switch(weight) {
+        case 100:
+            return 600;
+        case 200:
+            return 600;
+        case 300:
+            return 600;
+        case 400:
+            return 600;
+        case 500:
+            return 600;
+        case 600:
+            return 700;
+        case 700:
+            return 800;
+        case 800:
+            return 900;
+        case 900:
+            return 900;
+        default:
+            throw new IllegalArgumentException("String_Node_Str" + f);
+    }
 }


Input:
protected void calcMinMax(List<? extends DataSet<?>> dataSets) {
    if (dataSets == null || dataSets.size() < 1) {
        mYMax = 0f;
        mYMin = 0f;
    } else {
        mYMin = dataSets.get(0).getYMin();
        mYMax = dataSets.get(0).getYMax();
        for (int i = 0; i < dataSets.size(); i++) {
            if (dataSets.get(i).getYMin() < mYMin)
                mYMin = dataSets.get(i).getYMin();
            if (dataSets.get(i).getYMax() > mYMax)
                mYMax = dataSets.get(i).getYMax();
        }
        T firstLeft = getFirstLeft();
        if (firstLeft != null) {
            mLeftAxisMax = firstLeft.getYMax();
            mLeftAxisMin = firstLeft.getYMin();
            for (DataSet<?> dataSet : dataSets) {
                if (dataSet.getAxisDependency() == AxisDependency.LEFT) {
                    if (dataSet.getYMin() < mLeftAxisMin)
                        mLeftAxisMin = dataSet.getYMin();
                    if (dataSet.getYMax() > mLeftAxisMax)
                        mLeftAxisMax = dataSet.getYMax();
                }
            }
        }
        T firstRight = getFirstRight();
        if (firstRight != null) {
            mRightAxisMax = firstRight.getYMax();
            mRightAxisMin = firstRight.getYMin();
            for (DataSet<?> dataSet : dataSets) {
                if (dataSet.getAxisDependency() == AxisDependency.RIGHT) {
                    if (dataSet.getYMin() < mRightAxisMin)
                        mRightAxisMin = dataSet.getYMin();
                    if (dataSet.getYMax() > mRightAxisMax)
                        mRightAxisMax = dataSet.getYMax();
                }
            }
        }
        handleEmptyAxis(firstLeft, firstRight);
    }
}

Output:
     } else {
-        mYMin = dataSets.get(0).getYMin();
-        mYMax = dataSets.get(0).getYMax();
-        for (int i = 0; i < dataSets.size(); i++) {
-            if (dataSets.get(i).getYMin() < mYMin)
-                mYMin = dataSets.get(i).getYMin();
-            if (dataSets.get(i).getYMax() > mYMax)
-                mYMax = dataSets.get(i).getYMax();
+        mYMin = mDataSets.get(0).getYMin();
+        mYMax = mDataSets.get(0).getYMax();
+        for (int i = 0; i < mDataSets.size(); i++) {
+            if (mDataSets.get(i).getYMin() < mYMin)
+                mYMin = mDataSets.get(i).getYMin();
+            if (mDataSets.get(i).getYMax() > mYMax)
+                mYMax = mDataSets.get(i).getYMax();
         }


Input:
public void visitLeafNode(ASTPtLeafNode node) throws IllegalActionException {
    String nodeName = node.getName();
    String discreteVariableName = "String_Node_Str";
    if (nodeName != null) {
        int variableNameEndIndex = nodeName.indexOf("String_Node_Str");
        if (variableNameEndIndex != -1) {
            discreteVariableName = nodeName.substring(0, variableNameEndIndex);
        }
    }
    if (_absentDiscreteVariables.contains(nodeName)) {
        _evaluatedChildToken = new BooleanToken(false);
        if (_construction) {
            _relationList.addRelation(0, 0.0);
            _relationNumber++;
        }
        _relationIndex++;
        if (_relationIndex >= _relationNumber) {
            _relationIndex -= _relationNumber;
        }
        return;
    }
    super.visitLeafNode(node);
    ptolemy.data.Token result = _evaluatedChildToken;
    if (!(result instanceof BooleanToken))
        return;
    if (((BooleanToken) result).booleanValue()) {
        _relationType = 1;
        if (_absentDiscreteVariables.contains(discreteVariableName)) {
            _absentDiscreteVariables.remove(discreteVariableName);
        }
    } else {
        _relationType = 2;
        if (!_absentDiscreteVariables.contains(discreteVariableName)) {
            _absentDiscreteVariables.add(discreteVariableName);
        }
    }
    _difference = 0.0;
    if (_construction) {
        _relationList.addRelation(_relationType, _difference);
        _relationNumber++;
    } else {
        _relationList.setRelation(_relationIndex, _relationType, _difference);
    }
    _relationIndex++;
    if (_relationIndex >= _relationNumber) {
        _relationIndex -= _relationNumber;
    }
}

Output:
         _evaluatedChildToken = new BooleanToken(false);
-        if (_construction) {
+        if (_constructingRelationList) {
             _relationList.addRelation(0, 0.0);


Input:
public void configure() {
    if (confCalled)
        return;
    syncThreads = Boolean.parseBoolean(System.getProperty(SYNC_THREADS, "String_Node_Str"));
    if (numDevices == 0) {
        getNumDevices();
    }
    for (int i = 0; i < numDevices; i++) {
        ClassPathResource confFile = new ClassPathResource("String_Node_Str" + i);
        if (confFile.exists()) {
            Properties props = new Properties();
            try {
                props.load(confFile.getInputStream());
                confs.put(i, new DeviceConfiguration(i, props));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        } else
            confs.put(i, new DeviceConfiguration(i));
    }
    confCalled = true;
}

Output:
     for (int i = 0; i < numDevices; i++) {
-        ClassPathResource confFile = new ClassPathResource("String_Node_Str" + i);
+        ClassPathResource confFile = new ClassPathResource("String_Node_Str" + i, ContextHolder.class.getClassLoader());
         if (confFile.exists()) {


Input:
static String label(final IdentifiedObject object) {
    if (object == null) {
        return null;
    }
    Class<? extends IdentifiedObject> type;
    if (object instanceof AbstractIdentifiedObject) {
        type = ((AbstractIdentifiedObject) object).getInterface();
    } else {
        type = Classes.getLeafInterfaces(object.getClass(), IdentifiedObject.class)[0];
    }
    String label = Classes.getShortName(type);
    String name = IdentifiedObjects.getName(object, null);
    if (name != null) {
        int i = 30;
        if (name.length() >= i) {
            while (i > 15) {
                final int c = name.codePointBefore(i);
                if (Character.isSpaceChar(c))
                    break;
                i -= Character.charCount(c);
            }
            name = CharSequences.trimWhitespaces(name, 0, i).toString() + '…';
        }
        label = label + "String_Node_Str" + name + "String_Node_Str";
    }
    return label;
}

Output:
     }
-    String label = Classes.getShortName(type);
+    String suffix, label = Classes.getShortName(type);
+    if (label.endsWith((suffix = "String_Node_Str")) || label.endsWith(suffix = "String_Node_Str")) {
+        Object cs = object;
+        if (object instanceof CoordinateReferenceSystem) {
+            cs = ((CoordinateReferenceSystem) object).getCoordinateSystem();
+        }
+        if (cs instanceof EllipsoidalCS) {
+            final StringBuilder sb = new StringBuilder(label);
+            sb.setLength(label.length() - suffix.length());
+            label = sb.append(((CoordinateSystem) cs).getDimension()).append('D').toString();
+        }
+    }
     String name = IdentifiedObjects.getName(object, null);


Input:
private static void install(HablarWidget hablar, ChatConfig config) {
    new ChatManagerLogic(hablar.getEventBus(), config, hablar.getPages());
}

Output:
 private static void install(HablarWidget hablar, ChatConfig config) {
-    new ChatManagerLogic(hablar.getEventBus(), config, hablar.getPages());
+    new ChatManagerLogic(hablar.getHablarEventBus(), config, hablar.getPages());
 }


Input:
private void handleObjects(Map<String, String> rowMap, EList<Object> objectLs, List<TdXmlElementType> columnList) {
    EList<Indicator> indicators = analysis.getResults().getIndicators();
    EMap<Indicator, AnalyzedDataSet> indicToRowMap = analysis.getResults().getIndicToRowMap();
    int recordIncrement = 0;
    for (Indicator indicator : indicators) {
        if (!this.continueRun()) {
            break;
        }
        if (ColumnsetPackage.eINSTANCE.getColumnSetMultiValueIndicator().isSuperTypeOf(indicator.eClass())) {
            indicator.handle(objectLs);
            if (indicator instanceof SimpleStatIndicator) {
                if (!indicator.isStoreData()) {
                    break;
                }
                SimpleStatIndicator simpIndi = (SimpleStatIndicator) indicator;
                for (Indicator leafIndicator : simpIndi.getLeafIndicators()) {
                    if (!this.continueRun()) {
                        break;
                    }
                    if (!(leafIndicator instanceof RowCountIndicator)) {
                        continue;
                    }
                    List<Object[]> valueObjectList = initDataSet(leafIndicator, indicToRowMap);
                    recordIncrement = valueObjectList.size();
                    int offset = 0;
                    for (TdXmlElementType columnElement : columnList) {
                        if (!this.continueRun()) {
                            break;
                        }
                        Object newobject = rowMap.get(columnElement.getName());
                        if (recordIncrement < analysis.getParameters().getMaxNumberRows()) {
                            if (recordIncrement < valueObjectList.size()) {
                                valueObjectList.get(recordIncrement)[offset] = newobject;
                            } else {
                                Object[] valueObject = new Object[columnList.size()];
                                valueObject[offset] = newobject;
                                valueObjectList.add(valueObject);
                            }
                        }
                        offset++;
                    }
                }
            }
        }
    }
}

Output:
                 if (!indicator.isStoreData()) {
-                    break;
+                    continue;
                 }


Input:
public void tabCloseClicked(int tabPosition) {
    List<Tab> oldTabs = model.getTabs();
    int oldFocusPos = model.getCurrentTabPosition();
    Tab oldFocusTab = oldTabs.get(oldFocusPos);
    model.removeTab(tabPosition);
    List<Tab> newTabs = model.getTabs();
    int newFocusTab = model.getCurrentTabPosition();
    view.tabRemoved(tabPosition, oldFocusPos, newTabs.indexOf(oldFocusTab), newFocusTab);
    view.updateData(newTabs);
    if (!newTabs.isEmpty()) {
        model.switchTab(newFocusTab);
    }
}

Output:
     int newFocusTab = model.getCurrentTabPosition();
-    view.tabRemoved(tabPosition, oldFocusPos, newTabs.indexOf(oldFocusTab), newFocusTab);
+    view.tabRemoved(tabPosition, oldFocusPos, oldFocusPos, newFocusTab);
     view.updateData(newTabs);


Input:
public void run() {
    String modelName = String.valueOf(input);
    String message = "String_Node_Str" + device.toString() + "String_Node_Str" + modelName;
    IntercomSendMessageTask.launch(context, AppData.defaultUser.getUsername(), message);
}

Output:
 public void run() {
-    String modelName = String.valueOf(input);
-    String message = "String_Node_Str" + device.toString() + "String_Node_Str" + modelName;
-    IntercomSendMessageTask.launch(context, AppData.defaultUser.getUsername(), message);
+    if (AppData.defaultUser != null) {
+        String modelName = String.valueOf(input);
+        String message = "String_Node_Str" + device.toString() + "String_Node_Str" + modelName;
+        IntercomSendMessageTask.launch(context, AppData.defaultUser.getUsername(), message);
+    }
 }


Input:
public void onPostExecute(Boolean movedCorrectly) {
    if (movedCorrectly) {
        if (mainFrag != null && mainFrag.getCurrentPath().equals(paths.get(0))) {
            Intent intent = new Intent(MainActivity.KEY_INTENT_LOAD_LIST);
            intent.putExtra(MainActivity.KEY_INTENT_LOAD_LIST_FILE, paths.get(0));
            context.sendBroadcast(intent);
        }
        for (int i = 0; i < paths.size(); i++) {
            for (HybridFileParcelable f : files.get(i)) {
                FileUtils.scanFile(f.getPath(), context);
                FileUtils.scanFile(paths.get(i) + "String_Node_Str" + f.getName(), context);
            }
        }
        AppConfig.runInBackground(() -> {
            for (int i = 0; i < paths.size(); i++) {
                for (HybridFileParcelable file : files.get(i)) {
                    if (file.getName().endsWith(CryptUtil.CRYPT_EXTENSION)) {
                        try {
                            CryptHandler cryptHandler = new CryptHandler(context);
                            EncryptedEntry oldEntry = cryptHandler.findEntry(file.getPath());
                            EncryptedEntry newEntry = new EncryptedEntry();
                            newEntry.setId(oldEntry.getId());
                            newEntry.setPassword(oldEntry.getPassword());
                            newEntry.setPath(paths.get(i) + "String_Node_Str" + file.getName());
                            cryptHandler.updateEntry(oldEntry, newEntry);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
    } else {
        for (int i = 0; i < paths.size(); i++) {
            Intent intent = new Intent(context, CopyService.class);
            intent.putExtra(CopyService.TAG_COPY_SOURCES, files.get(i));
            intent.putExtra(CopyService.TAG_COPY_TARGET, paths.get(i));
            intent.putExtra(CopyService.TAG_COPY_MOVE, true);
            intent.putExtra(CopyService.TAG_COPY_OPEN_MODE, mode.ordinal());
            ServiceWatcherUtil.runService(context, intent);
        }
    }
}

Output:
             for (HybridFileParcelable f : files.get(i)) {
-                FileUtils.scanFile(f.getPath(), context);
-                FileUtils.scanFile(paths.get(i) + "String_Node_Str" + f.getName(), context);
+                FileUtils.scanFile(f.getFile(), context);
+                FileUtils.scanFile(new File(paths.get(i) + "String_Node_Str" + f.getName()), context);
             }


Input:
public long getSwfXMin(int swfIndex) {
    return headers.get(swfIndex).getXMin();
}

Output:
 public long getSwfXMin(int swfIndex) {
-    return headers.get(swfIndex).getXMin();
+    return iggySwfs.get(swfIndex).getHdr().getXMin();
 }


Input:
public ElementLayout getLayout() {
    return layoutElement;
}

Output:
 public ElementLayout getLayout() {
-    return layoutElement;
+    return layout;
 }


Input:
public static void replaceVarsInList(Map<String, Oparg> replacements, List<Variable> vars, boolean removeDupes) {
    ArrayList<String> alreadySeen = null;
    if (removeDupes) {
        alreadySeen = new ArrayList<String>(vars.size());
    }
    int n = vars.size();
    for (int i = 0; i < n; i++) {
        String varName = vars.get(i).getName();
        if (replacements.containsKey(varName)) {
            Oparg oa = replacements.get(varName);
            if (oa.getType() == OpargType.VAR) {
                if (removeDupes && alreadySeen.contains(oa.getVar().getName())) {
                    vars.remove(i);
                    i--;
                    n--;
                } else {
                    vars.set(i, oa.getVar());
                    if (removeDupes) {
                        alreadySeen.add(oa.getVar().getName());
                    }
                }
            }
        } else {
            if (removeDupes) {
                if (alreadySeen.contains(varName)) {
                    vars.remove(i);
                    i--;
                    n--;
                } else {
                    alreadySeen.add(varName);
                }
            }
        }
    }
}

Output:
     }
-    int n = vars.size();
-    for (int i = 0; i < n; i++) {
-        String varName = vars.get(i).getName();
+    ListIterator<Variable> it = vars.listIterator();
+    while (it.hasNext()) {
+        Variable v = it.next();
+        String varName = v.getName();
         if (replacements.containsKey(varName)) {


Input:
public boolean equals(Object other) {
    if (other == null)
        return false;
    if (other instanceof Keyword) {
        Keyword otherK = (Keyword) other;
        return ((name.equals(otherK.name)) && (namespace.equals(otherK.namespace)));
    } else {
        return false;
    }
}

Output:
         Keyword otherK = (Keyword) other;
-        return ((name.equals(otherK.name)) && (namespace.equals(otherK.namespace)));
+        return ((name.equals(otherK.name)) && ((namespace == null && otherK.namespace == null) || (namespace.equals(otherK.namespace))));
     } else {


Input:
public List<Map.Entry> newEntries(String name) {
    List<Map.Entry> lsEntries = null;
    for (TransactionRecord transactionRecord : transactionRecords) {
        if (transactionRecord.name.equals(name)) {
            if (!transactionRecord.removed) {
                if (transactionRecord.value != null) {
                    if (transactionRecord.newRecord) {
                        if (lsEntries == null) {
                            lsEntries = new ArrayList<Map.Entry>(2);
                        }
                        lsEntries.add(BaseManager.createSimpleEntry(factory, name, transactionRecord.key, transactionRecord.value));
                    }
                }
            }
        }
    }
    return lsEntries;
}

Output:
                         }
-                        lsEntries.add(BaseManager.createSimpleEntry(factory, name, transactionRecord.key, transactionRecord.value));
+                        lsEntries.add(BaseManager.createSimpleMapEntry(factory, name, transactionRecord.key, transactionRecord.value));
                     }


Input:
protected void onEachSelectedCommodity(SelectedCommodityHandler handler) {
    for (int i = 0; i < listViewSelectedCommodities.getChildCount(); i++) {
        View view = listViewSelectedCommodities.getChildAt(i);
        CommodityViewModel commodityViewModel = (CommodityViewModel) listViewSelectedCommodities.getAdapter().getItem(i);
        handler.operate(view, commodityViewModel);
    }
}

Output:
 protected void onEachSelectedCommodity(SelectedCommodityHandler handler) {
-    for (int i = 0; i < listViewSelectedCommodities.getChildCount(); i++) {
-        View view = listViewSelectedCommodities.getChildAt(i);
+    for (int i = 0; i < listViewSelectedCommodities.getAdapter().getCount(); i++) {
+        View view = listViewSelectedCommodities.getAdapter().getView(i, null, listViewSelectedCommodities);
         CommodityViewModel commodityViewModel = (CommodityViewModel) listViewSelectedCommodities.getAdapter().getItem(i);


Input:
public static int receiveBufferCount(Config cfg) {
    return cfg.getIntegerValue(RECEIVE_BUFFERS_COUNT, 32);
}

Output:
 public static int receiveBufferCount(Config cfg) {
-    return cfg.getIntegerValue(RECEIVE_BUFFERS_COUNT, 32);
+    return cfg.getIntegerValue(RECEIVE_BUFFERS_COUNT, 16);
 }


Input:
private String createName(IType type) {
    StringBuilder sb = new StringBuilder();
    while (type != null) {
        if (sb.length() > 0) {
            sb.insert(0, '$');
        }
        if (type instanceof SourceType && type.getElementName().isEmpty()) {
            sb.insert(0, ((SourceType) type).localOccurrenceCount);
        } else {
            sb.insert(0, type.getElementName());
        }
        type = (IType) type.getParent().getAncestor(IJavaElement.TYPE);
    }
    return sb.toString();
}

Output:
         if (type instanceof SourceType && type.getElementName().isEmpty()) {
-            sb.insert(0, ((SourceType) type).localOccurrenceCount);
+            int count;
+            try {
+                count = (Integer) ReflectionUtils.throwableGetPrivateField(SourceType.class, "String_Node_Str", (SourceType) type);
+            } catch (Exception e) {
+                count = type.getOccurrenceCount();
+            }
+            sb.insert(0, count);
         } else {


Input:
protected void flushToNode(NodeDraftGetter nodeDraft, Node node) {
    if (nodeDraft.getColor() != null) {
        node.getNodeData().setR(nodeDraft.getColor().getRed() / 255f);
        node.getNodeData().setG(nodeDraft.getColor().getGreen() / 255f);
        node.getNodeData().setB(nodeDraft.getColor().getBlue() / 255f);
    }
    if (nodeDraft.getLabel() != null) {
        node.getNodeData().setLabel(nodeDraft.getLabel());
    }
    if (node.getNodeData().getTextData() != null) {
        node.getNodeData().getTextData().setVisible(nodeDraft.isLabelVisible());
    }
    if (nodeDraft.getLabelColor() != null && node.getNodeData().getTextData() != null) {
        Color labelColor = nodeDraft.getLabelColor();
        node.getNodeData().getTextData().setColor(labelColor.getRed() / 255f, labelColor.getGreen() / 255f, labelColor.getBlue() / 255f, labelColor.getAlpha() / 255f);
    }
    if (nodeDraft.getLabelSize() != -1f && node.getNodeData().getTextData() != null) {
        node.getNodeData().getTextData().setSize(nodeDraft.getLabelSize());
    }
    if (nodeDraft.getX() != 0 && !Float.isNaN(nodeDraft.getX())) {
        node.getNodeData().setX(nodeDraft.getX());
    } else {
        node.getNodeData().setX((float) ((0.01 + Math.random()) * 1000) - 500);
    }
    if (nodeDraft.getY() != 0 && !Float.isNaN(nodeDraft.getY())) {
        node.getNodeData().setY(nodeDraft.getY());
    } else {
        node.getNodeData().setY((float) ((0.01 + Math.random()) * 1000) - 500);
    }
    if (nodeDraft.getZ() != 0 && !Float.isNaN(nodeDraft.getZ())) {
        node.getNodeData().setZ(nodeDraft.getZ());
    }
    if (nodeDraft.getSize() != 0 && !Float.isNaN(nodeDraft.getSize())) {
        node.getNodeData().setSize(nodeDraft.getSize());
    } else {
        node.getNodeData().setSize(10f);
    }
    if (nodeDraft.getTimeInterval() != null) {
        AttributeColumn col = attributeModel.getNodeTable().getColumn(DynamicModel.TIMEINTERVAL_COLUMN);
        if (col == null) {
            col = attributeModel.getNodeTable().addColumn(DynamicModel.TIMEINTERVAL_COLUMN, "String_Node_Str", AttributeType.TIME_INTERVAL, AttributeOrigin.PROPERTY, null);
        }
        node.getNodeData().getAttributes().setValue(col.getIndex(), nodeDraft.getTimeInterval());
    }
    if (node.getNodeData().getAttributes() != null) {
        AttributeRow row = (AttributeRow) node.getNodeData().getAttributes();
        for (AttributeValue val : nodeDraft.getAttributeRow().getValues()) {
            if (val.getValue() != null) {
                row.setValue(val.getColumn(), val.getValue());
            }
        }
    }
}

Output:
         for (AttributeValue val : nodeDraft.getAttributeRow().getValues()) {
-            if (val.getValue() != null) {
+            if (!val.getColumn().getOrigin().equals(AttributeOrigin.PROPERTY) && val.getValue() != null) {
                 row.setValue(val.getColumn(), val.getValue());


Input:
public boolean checkBlockRequirementsAfter(Player player, Player controller, Game game) {
    Set<UUID> opponents = game.getOpponents(attackerId);
    Map<UUID, Set<UUID>> mustBeBlockedByAtLeastOne = new HashMap<>();
    for (Permanent creature : game.getBattlefield().getActivePermanents(new FilterControlledCreaturePermanent(), player.getId(), game)) {
        if (opponents.contains(creature.getControllerId())) {
            if (creature.getBlocking() > 0) {
                for (Map.Entry<RequirementEffect, HashSet<Ability>> entry : game.getContinuousEffects().getApplicableRequirementEffects(creature, game).entrySet()) {
                    RequirementEffect effect = entry.getKey();
                    for (Ability ability : entry.getValue()) {
                        UUID toBeBlockedCreature = effect.mustBlockAttackerIfElseUnblocked(ability, game);
                        if (toBeBlockedCreature != null) {
                            Set<UUID> potentialBlockers;
                            if (mustBeBlockedByAtLeastOne.containsKey(toBeBlockedCreature)) {
                                potentialBlockers = mustBeBlockedByAtLeastOne.get(toBeBlockedCreature);
                            } else {
                                potentialBlockers = new HashSet<>();
                                mustBeBlockedByAtLeastOne.put(toBeBlockedCreature, potentialBlockers);
                            }
                            potentialBlockers.add(creature.getId());
                        }
                    }
                }
            }
            if (creature.getBlocking() == 0) {
                for (Map.Entry<RequirementEffect, HashSet<Ability>> entry : game.getContinuousEffects().getApplicableRequirementEffects(creature, game).entrySet()) {
                    RequirementEffect effect = entry.getKey();
                    for (Ability ability : entry.getValue()) {
                        UUID toBeBlockedCreature = effect.mustBlockAttackerIfElseUnblocked(ability, game);
                        if (toBeBlockedCreature != null) {
                            Set<UUID> potentialBlockers;
                            if (mustBeBlockedByAtLeastOne.containsKey(toBeBlockedCreature)) {
                                potentialBlockers = mustBeBlockedByAtLeastOne.get(toBeBlockedCreature);
                            } else {
                                potentialBlockers = new HashSet<>();
                                mustBeBlockedByAtLeastOne.put(toBeBlockedCreature, potentialBlockers);
                            }
                            potentialBlockers.add(creature.getId());
                        }
                    }
                    if (effect.mustBlockAny(game)) {
                        boolean mayBlock = false;
                        for (UUID attackingCreatureId : getAttackers()) {
                            if (creature.canBlock(attackingCreatureId, game)) {
                                Permanent attackingCreature = game.getPermanent(attackingCreatureId);
                                if (attackingCreature != null) {
                                    if (attackingCreature.getMaxBlockedBy() != 0) {
                                        int alreadyBlockingCreatures = 0;
                                        for (CombatGroup group : getGroups()) {
                                            if (group.getAttackers().contains(attackingCreatureId)) {
                                                alreadyBlockingCreatures = group.getBlockers().size();
                                                break;
                                            }
                                        }
                                        if (attackingCreature.getMaxBlockedBy() <= alreadyBlockingCreatures) {
                                            continue;
                                        }
                                    }
                                    if (attackingCreature.getMinBlockedBy() > 1) {
                                    } else {
                                        mayBlock = true;
                                        break;
                                    }
                                }
                            }
                        }
                        if (mayBlock) {
                            if (controller.isHuman()) {
                                if (!game.isSimulation()) {
                                    game.informPlayer(controller, "String_Node_Str" + creature.getLogName());
                                }
                            } else {
                                Player defender = game.getPlayer(creature.getControllerId());
                                if (defender != null) {
                                    for (UUID attackingCreatureId : getAttackers()) {
                                        if (creature.canBlock(attackingCreatureId, game)) {
                                            defender.declareBlocker(defender.getId(), creature.getId(), attackingCreatureId, game);
                                            break;
                                        }
                                    }
                                }
                            }
                            return false;
                        }
                    }
                }
            }
        }
    }
    for (UUID toBeBlockedCreatureId : mustBeBlockedByAtLeastOne.keySet()) {
        for (CombatGroup combatGroup : game.getCombat().getGroups()) {
            if (combatGroup.getBlockers().isEmpty() && combatGroup.getAttackers().contains(toBeBlockedCreatureId)) {
                if (controller.isHuman()) {
                    Permanent toBeBlockedCreature = game.getPermanent(toBeBlockedCreatureId);
                    if (toBeBlockedCreature != null) {
                        boolean possibleBlockerAvailable = false;
                        for (UUID possibleBlockerId : mustBeBlockedByAtLeastOne.get(toBeBlockedCreatureId)) {
                            Set<UUID> forcingAttackers = creatureMustBlockAttackers.get(possibleBlockerId);
                            if (forcingAttackers == null) {
                                possibleBlockerAvailable = true;
                                break;
                            }
                            List<UUID> blockedAttackers = null;
                            for (CombatGroup combatGroupToCheck : game.getCombat().getGroups()) {
                                if (combatGroupToCheck.getBlockers().contains(possibleBlockerId)) {
                                    blockedAttackers = combatGroupToCheck.getAttackers();
                                    break;
                                }
                            }
                            if (blockedAttackers == null) {
                                possibleBlockerAvailable = true;
                                break;
                            }
                            possibleBlockerAvailable = true;
                            for (UUID blockedAttackerId : blockedAttackers) {
                                if (creatureMustBlockAttackers.get(possibleBlockerId).contains(blockedAttackerId)) {
                                    possibleBlockerAvailable = false;
                                    break;
                                }
                            }
                            if (possibleBlockerAvailable) {
                                break;
                            }
                        }
                        if (possibleBlockerAvailable) {
                            if (!game.isSimulation()) {
                                game.informPlayer(controller, new StringBuilder(toBeBlockedCreature.getLogName()).append("String_Node_Str").toString());
                            }
                            return false;
                        }
                    }
                } else {
                    UUID blockingCreatureId = mustBeBlockedByAtLeastOne.get(toBeBlockedCreatureId).iterator().next();
                    Permanent blockingCreature = game.getPermanent(blockingCreatureId);
                    if (blockingCreature != null) {
                        Player defender = game.getPlayer(blockingCreature.getControllerId());
                        if (defender != null) {
                            defender.declareBlocker(defender.getId(), blockingCreatureId, toBeBlockedCreatureId, game);
                        }
                    }
                }
            }
        }
    }
    StringBuilder sb = new StringBuilder();
    for (Map.Entry<UUID, Set<UUID>> entry : creatureMustBlockAttackers.entrySet()) {
        boolean blockIsValid;
        Permanent creatureForcedToBlock = game.getPermanent(entry.getKey());
        if (creatureForcedToBlock == null) {
            break;
        }
        if (creatureForcedToBlock.getBlocking() == 0) {
            blockIsValid = false;
        } else {
            blockIsValid = false;
            CombatGroups: for (CombatGroup combatGroup : game.getCombat().getGroups()) {
                if (combatGroup.getBlockers().contains(creatureForcedToBlock.getId())) {
                    for (UUID forcingAttackerId : combatGroup.getAttackers()) {
                        if (entry.getValue().contains(forcingAttackerId)) {
                            blockIsValid = true;
                            break CombatGroups;
                        } else {
                            if (combatGroup.getBlockers().size() == 1) {
                                if (mustBeBlockedByAtLeastOne.containsKey(forcingAttackerId)) {
                                    if (mustBeBlockedByAtLeastOne.get(forcingAttackerId).contains(creatureForcedToBlock.getId())) {
                                        blockIsValid = true;
                                        break CombatGroups;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        if (!blockIsValid) {
            sb.append("String_Node_Str").append(creatureForcedToBlock.getIdName());
        }
    }
    if (sb.length() > 0) {
        if (!game.isSimulation()) {
            sb.insert(0, "String_Node_Str");
            sb.append("String_Node_Str");
            game.informPlayer(controller, sb.toString());
        }
        return false;
    }
    return true;
}

Output:
                         for (UUID possibleBlockerId : mustBeBlockedByAtLeastOne.get(toBeBlockedCreatureId)) {
-                            Set<UUID> forcingAttackers = creatureMustBlockAttackers.get(possibleBlockerId);
-                            if (forcingAttackers == null) {
-                                possibleBlockerAvailable = true;
-                                break;
-                            }
-                            List<UUID> blockedAttackers = null;
-                            for (CombatGroup combatGroupToCheck : game.getCombat().getGroups()) {
-                                if (combatGroupToCheck.getBlockers().contains(possibleBlockerId)) {
-                                    blockedAttackers = combatGroupToCheck.getAttackers();
-                                    break;
-                                }
-                            }
-                            if (blockedAttackers == null) {
-                                possibleBlockerAvailable = true;
-                                break;
-                            }
-                            possibleBlockerAvailable = true;
-                            for (UUID blockedAttackerId : blockedAttackers) {
-                                if (creatureMustBlockAttackers.get(possibleBlockerId).contains(blockedAttackerId)) {
-                                    possibleBlockerAvailable = false;
-                                    break;
-                                }
-                            }
-                            if (possibleBlockerAvailable) {
-                                break;
+                            String blockRequiredMessage = isCreatureDoingARequiredBlock(possibleBlockerId, mustBeBlockedByAtLeastOne, game);
+                            if (blockRequiredMessage != null) {
+                                game.informPlayer(controller, blockRequiredMessage + "String_Node_Str" + toBeBlockedCreature.getIdName());
+                                return false;
                             }