Input:
protected String doInBackground(String... strings) {
    String result = ERROR_UNKNOWN;
    try {
        URL url = createURL(strings[0]);
        Log.i("String_Node_Str", "String_Node_Str" + url);
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("String_Node_Str");
        conn.setRequestProperty("String_Node_Str", "String_Node_Str" + new String(id, "String_Node_Str"));
        conn.connect();
        int responseCode = conn.getResponseCode();
        Log.i("String_Node_Str", "String_Node_Str" + responseCode);
        if (responseCode == 200) {
            Log.i("String_Node_Str", "String_Node_Str" + conn.getHeaderFields());
            Log.i("String_Node_Str", "String_Node_Str" + conn.getResponseMessage());
            InputStream in = (InputStream) conn.getContent();
            result = inputStreamToString(in);
            Log.i("String_Node_Str", "String_Node_Str" + result);
            in.close();
        } else {
            analyzeHttpErrorCode(responseCode);
        }
        conn.disconnect();
    } catch (MalformedURLException e) {
        Log.e("String_Node_Str", "String_Node_Str");
        result = ERROR_URL;
        e.printStackTrace();
    } catch (ProtocolException e) {
        Log.e("String_Node_Str", "String_Node_Str");
        e.printStackTrace();
    } catch (UnsupportedEncodingException e) {
        Log.e("String_Node_Str", "String_Node_Str");
        e.printStackTrace();
    } catch (IOException e) {
        Log.e("String_Node_Str", "String_Node_Str");
        e.printStackTrace();
        Log.e("String_Node_Str", "String_Node_Str" + e.getMessage());
    } catch (ArrayIndexOutOfBoundsException e) {
        Log.e("String_Node_Str", "String_Node_Str");
        e.printStackTrace();
    } catch (URISyntaxException e) {
        Log.e("String_Node_Str", "String_Node_Str" + e.getMessage());
        e.printStackTrace();
    }
    return result;
}

Output:
         } else {
-            analyzeHttpErrorCode(responseCode);
+            result = analyzeHttpErrorCode(responseCode);
         }


Input:
void handleService(IServiceInfo serviceInfo, boolean discovered) {
    IServiceID serviceID = serviceInfo.getServiceID();
    if (matchServiceID(serviceID))
        handleOSGiServiceEndpoint(serviceID, serviceInfo, true);
}

Output:
     if (matchServiceID(serviceID))
-        handleOSGiServiceEndpoint(serviceID, serviceInfo, true);
+        handleOSGiServiceEndpoint(serviceID, serviceInfo, discovered);
 }


Input:
public void pseudoCacheDemo() {
    getActivity().getSupportFragmentManager().beginTransaction().addToBackStack(this.toString()).replace(R.id.activity_main, new PseudoCacheMergeFragment(), this.toString()).commit();
}

Output:
 public void pseudoCacheDemo() {
-    getActivity().getSupportFragmentManager().beginTransaction().addToBackStack(this.toString()).replace(R.id.activity_main, new PseudoCacheMergeFragment(), this.toString()).commit();
+    getActivity().getSupportFragmentManager().beginTransaction().addToBackStack(PseudoCacheMergeFragment.class.toString()).replace(android.R.id.content, new PseudoCacheMergeFragment(), PseudoCacheMergeFragment.class.toString()).commit();
 }


Input:
public void setPageNumber(long pageNumber) throws EngineException {
    if (pageNumber <= 0 || pageNumber > totalPage) {
        throw new EngineException("String_Node_Str", new Long(pageNumber));
    }
    innerRender = new PageRangeRender(new long[] { pageNumber, pageNumber });
}

Output:
     if (pageNumber <= 0 || pageNumber > totalPage) {
-        throw new EngineException("String_Node_Str", new Long(pageNumber));
+        throw new EngineException(MessageConstants.PAGE_NOT_FOUND_ERROR, new Long(pageNumber));
     }


Input:
protected void onResume() {
    super.onResume();
    IntentFilter filter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
    registerReceiver(mCloseSystemDialogsReceiver, filter);
    if (mRestoring) {
        mWorkspaceLoading = true;
        mModel.startLoader(this, true);
        mRestoring = false;
    }
    if (mIsNewIntent) {
        mWorkspace.post(new Runnable() {
            public void run() {
                stopSearch();
            }
        });
    }
    mIsNewIntent = false;
}

Output:
     super.onResume();
-    IntentFilter filter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
-    registerReceiver(mCloseSystemDialogsReceiver, filter);
+    mPaused = false;
     if (mRestoring) {


Input:
public void run() {
    if (prepareTransaction()) {
        return;
    }
    evicted = recordStore.evict(dataKey);
}

Output:
     }
-    evicted = recordStore.evict(dataKey);
+    dataValue = mapService.toData(recordStore.evict(dataKey));
+    evicted = dataValue != null;
 }


Input:
public void testKnowsCreatedTraversal2() throws IOException {
    Configuration config = new Configuration();
    config.set(VerticesVerticesMapReduce.DIRECTION, Direction.OUT.name());
    config.setStrings(VerticesVerticesMapReduce.LABELS, "String_Node_Str");
    mapReduceDriver.withConfiguration(config);
    Map<Long, FaunusVertex> results = runWithGraph(startPath(generateGraph(ExampleGraph.TINKERGRAPH), Vertex.class, true), mapReduceDriver);
    assertEquals(results.size(), 6);
    assertEquals(results.get(1l).pathCount(), 0);
    assertEquals(results.get(2l).pathCount(), 0);
    assertEquals(results.get(3l).pathCount(), 3);
    assertEquals(results.get(4l).pathCount(), 0);
    assertEquals(results.get(5l).pathCount(), 1);
    assertEquals(results.get(6l).pathCount(), 0);
}

Output:
     mapReduceDriver.withConfiguration(config);
-    Map<Long, FaunusVertex> results = runWithGraph(startPath(generateGraph(ExampleGraph.TINKERGRAPH), Vertex.class, true), mapReduceDriver);
+    Map<Long, FaunusVertex> results = runWithGraph(startPath(generateGraph(ExampleGraph.TINKERGRAPH), Vertex.class), mapReduceDriver);
     assertEquals(results.size(), 6);


Input:
public void testWriter() throws Exception {
    openDesign(fileName);
    DataItem data = (DataItem) design.findElement("String_Node_Str");
    DataItemHandle dataHandle = (DataItemHandle) data.getHandle(design);
    dataHandle.setHelpTextKey("String_Node_Str");
    dataHandle.setHelpText("String_Node_Str");
    ActionHandle action = dataHandle.getActionHandle();
    assertNotNull(action);
    dataHandle.setRole("String_Node_Str");
    dataHandle.setLanguage("String_Node_Str");
    dataHandle.setAltText("String_Node_Str");
    dataHandle.setOrder(2);
    dataHandle = (DataItemHandle) designHandle.findElement("String_Node_Str");
    dataHandle.setHelpTextKey("String_Node_Str");
    dataHandle.setHelpText("String_Node_Str");
    action = dataHandle.getActionHandle();
    assertNotNull(action);
    Iterator columnBindings = dataHandle.columnBindingsIterator();
    ComputedColumnHandle column = (ComputedColumnHandle) columnBindings.next();
    column.setDisplayName("String_Node_Str");
    column.setDisplayNameID("String_Node_Str");
    column.setAggregateFunction(DesignChoiceConstants.MEASURE_FUNCTION_COUNT);
    data = (DataItem) design.findElement("String_Node_Str");
    columnBindings = dataHandle.columnBindingsIterator();
    column = (ComputedColumnHandle) columnBindings.next();
    AggregationArgumentHandle argumentHandle = (AggregationArgumentHandle) column.argumentsIterator().next();
    argumentHandle.setName("String_Node_Str" + argumentHandle.getName());
    argumentHandle.setValue("String_Node_Str" + argumentHandle.getValue());
    dataHandle = (DataItemHandle) designHandle.findElement("String_Node_Str");
    dataHandle.setAllowExport(true);
    save();
    assertTrue(compareFile(goldenFileName));
}

Output:
     assertNotNull(action);
-    dataHandle.setRole("String_Node_Str");
+    dataHandle.setTagType("String_Node_Str");
     dataHandle.setLanguage("String_Node_Str");


Input:
public void onReplicationEvent(WanReplicationEvent replicationEvent) {
    Object eventObject = replicationEvent.getEventObject();
    if (eventObject instanceof MapReplicationUpdate) {
        MapReplicationUpdate replicationUpdate = (MapReplicationUpdate) eventObject;
        EntryView entryView = replicationUpdate.getEntryView();
        MapMergePolicy mergePolicy = replicationUpdate.getMergePolicy();
        String mapName = replicationUpdate.getMapName();
        MapContainer mapContainer = getMapContainer(mapName);
        MergeOperation operation = new MergeOperation(mapName, toData(entryView.getKey(), mapContainer.getPartitioningStrategy()), entryView, mergePolicy);
        try {
            int partitionId = nodeEngine.getPartitionService().getPartitionId(entryView.getKey());
            Future f = nodeEngine.getOperationService().invokeOnPartition(SERVICE_NAME, operation, partitionId);
            f.get();
        } catch (Throwable t) {
            throw ExceptionUtil.rethrow(t);
        }
    } else if (eventObject instanceof MapReplicationRemove) {
        MapReplicationRemove replicationRemove = (MapReplicationRemove) eventObject;
        DeleteOperation operation = new DeleteOperation(replicationRemove.getMapName(), replicationRemove.getKey());
        try {
            int partitionId = nodeEngine.getPartitionService().getPartitionId(replicationRemove.getKey());
            Future f = nodeEngine.getOperationService().invokeOnPartition(SERVICE_NAME, operation, partitionId);
            f.get();
        } catch (Throwable t) {
            throw ExceptionUtil.rethrow(t);
        }
    }
}

Output:
         MapReplicationRemove replicationRemove = (MapReplicationRemove) eventObject;
-        DeleteOperation operation = new DeleteOperation(replicationRemove.getMapName(), replicationRemove.getKey());
+        WanOriginatedDeleteOperation operation = new WanOriginatedDeleteOperation(replicationRemove.getMapName(), replicationRemove.getKey());
         try {


Input:
protected String _generateTypeConvertStatement(Channel source, Channel sink, int offset) throws IllegalActionException {
    Type sourceType = ((TypedIOPort) source.port).getType();
    Type sinkType = ((TypedIOPort) sink.port).getType();
    if (sourceType == BaseType.UNKNOWN) {
        return "String_Node_Str";
    }
    String sourceRef = _getTypeConvertReference(source);
    int rate = Math.max(DFUtilities.getTokenProductionRate(source.port), DFUtilities.getTokenConsumptionRate(source.port));
    if (rate > 1) {
        sourceRef += "String_Node_Str" + offset + "String_Node_Str";
    }
    String sinkPortChannel = sink.port.getName() + "String_Node_Str" + sink.channelNumber + "String_Node_Str" + offset;
    if (sink.port.getContainer() instanceof CompositeActor && sink.port.isOutput()) {
        sinkPortChannel = "String_Node_Str" + sinkPortChannel;
    }
    String sinkRef = ((CodeGeneratorHelper) _getHelper(sink.port.getContainer())).getReference(sinkPortChannel, true);
    if (sink.port.getContainer() instanceof ModalController) {
        sinkRef = generateName(sink.port);
        if (sink.port.isMultiport()) {
            sinkRef = sinkRef + "String_Node_Str" + sink.channelNumber + "String_Node_Str";
        }
    }
    String result = sourceRef;
    if (sinkType != sourceType) {
        if (isPrimitive(sinkType)) {
            result = codeGenType(sourceType) + "String_Node_Str" + codeGenType(sinkType) + "String_Node_Str" + result + "String_Node_Str";
        } else if (isPrimitive(sourceType)) {
            result = "String_Node_Str" + codeGenType(sourceType) + "String_Node_Str" + result + "String_Node_Str";
        }
        if (sinkType != BaseType.SCALAR && sinkType != BaseType.GENERAL && !isPrimitive(sinkType)) {
            if (sinkType instanceof ArrayType) {
                if (isPrimitive(sourceType)) {
                    result = "String_Node_Str" + result + "String_Node_Str" + codeGenType(sourceType) + "String_Node_Str";
                }
                Type elementType = ((ArrayType) sinkType).getElementType();
                if (elementType != BaseType.SCALAR) {
                    result = "String_Node_Str" + codeGenType(sinkType) + "String_Node_Str" + result + "String_Node_Str" + codeGenType(((ArrayType) sinkType).getElementType()) + "String_Node_Str";
                }
            } else {
                result = "String_Node_Str" + codeGenType(sinkType) + "String_Node_Str" + result + "String_Node_Str";
            }
        }
    }
    return sinkRef + "String_Node_Str" + result + "String_Node_Str" + _eol;
}

Output:
     }
-    String sourceRef = _getTypeConvertReference(source);
-    int rate = Math.max(DFUtilities.getTokenProductionRate(source.port), DFUtilities.getTokenConsumptionRate(source.port));
-    if (rate > 1) {
-        sourceRef += "String_Node_Str" + offset + "String_Node_Str";
-    }
+    String sourcePortChannel = source.port.getName() + "String_Node_Str" + source.channelNumber + "String_Node_Str" + offset;
+    String sourceRef = ((CodeGeneratorHelper) _getHelper(source.port.getContainer())).getReference(sourcePortChannel);
     String sinkPortChannel = sink.port.getName() + "String_Node_Str" + sink.channelNumber + "String_Node_Str" + offset;


Input:
protected void addTextureCoords(RenderObject r, MeshBase mesh) {
    if (mesh.hasTextureCoords()) {
        ArrayList<Vector3d> coords = mesh.getTextureCoords();
        for (int i = 0; i < coords.size(); i++) {
            Vector3d coord = coords.get(i);
            r.addTextureCoord((float) coord.x, (float) (1 - coord.y));
        }
    }
}

Output:
             Vector3d coord = coords.get(i);
-            r.addTextureCoord((float) coord.x, (float) (1 - coord.y));
+            r.addTextureCoord((float) coord.x, (float) coord.y);
         }


Input:
public static JoinContext _collectJoins(SqlOp sqlOp, Set<String> refs) {
    JoinContext result;
    SqlOps type = SqlOps.valueOf(sqlOp.getClass().getSimpleName());
    switch(type) {
        case SqlOpEmpty:
            result = collectJoins((SqlOpEmpty) sqlOp, refs);
            break;
        case SqlOpTable:
            result = collectJoins((SqlOpTable) sqlOp, refs);
            break;
        case SqlOpQuery:
            result = collectJoins((SqlOpQuery) sqlOp, refs);
            break;
        case SqlOpFilter:
            result = collectJoins((SqlOpFilter) sqlOp, refs);
            break;
        case SqlOpExtend:
            result = collectJoins((SqlOpExtend) sqlOp, refs);
            break;
        case SqlOpRename:
            result = collectJoins((SqlOpRename) sqlOp, refs);
            break;
        case SqlOpJoin:
            result = collectJoins((SqlOpJoin) sqlOp, refs);
            break;
        case SqlOpUnionN:
            result = collectJoins((SqlOpUnionN) sqlOp, refs);
            break;
        default:
            logger.warn("String_Node_Str");
            result = MultiMethod.invokeStatic(SqlOpSelectBlockCollectorImpl.class, "String_Node_Str", sqlOp);
            break;
    }
    return result;
}

Output:
         default:
-            logger.warn("String_Node_Str");
-            result = MultiMethod.invokeStatic(SqlOpSelectBlockCollectorImpl.class, "String_Node_Str", sqlOp);
-            break;
+            throw new RuntimeException("String_Node_Str" + sqlOp);
     }


Input:
public void findConnections() {
    if (!isConnected()) {
        for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
            if (dir != ForgeDirection.UP && dir != ForgeDirection.DOWN) {
                if (connectTo(dir)) {
                    break;
                }
            }
        }
    }
}

Output:
                 if (connectTo(dir)) {
-                    break;
+                    return;
                 }


Input:
public synchronized void join(UUID userId) {
    UUID playerId = userPlayerMap.get(userId);
    if (playerId == null) {
        logger.error("String_Node_Str" + userId + "String_Node_Str" + tournament.getId());
        return;
    }
    TournamentSession tournamentSession = new TournamentSession(tournament, userId, tableId, playerId);
    if (tournamentSessions == null) {
        logger.error("String_Node_Str" + userId + "String_Node_Str" + tournament.getId());
        return;
    }
    tournamentSessions.put(playerId, tournamentSession);
    UserManager.getInstance().getUser(userId).addTournament(playerId, tournamentSession);
    TournamentPlayer player = tournament.getPlayer(playerId);
    player.setJoined();
    logger.debug("String_Node_Str" + playerId + "String_Node_Str" + tournament.getId());
    ChatManager.getInstance().broadcast(chatId, "String_Node_Str", player.getPlayer().getName() + "String_Node_Str", MessageColor.BLACK, true, MessageType.STATUS);
    checkStart();
}

Output:
     if (playerId == null) {
-        logger.error("String_Node_Str" + userId + "String_Node_Str" + tournament.getId());
+        if (logger.isDebugEnabled()) {
+            User user = UserManager.getInstance().getUser(userId);
+            if (user != null) {
+                logger.debug(user.getName() + "String_Node_Str" + tournament.getId());
+            }
+        }
         return;


Input:
public boolean checkFlight(Player player, Distance distance) {
    if (distance.getYDifference() > 400) {
        return false;
    }
    double y1 = distance.fromY();
    double y2 = distance.toY();
    Block block = player.getLocation().getBlock().getRelative(BlockFace.DOWN);
    if (y1 == y2 && !isMovingExempt(player) && !player.isInsideVehicle() && player.getFallDistance() == 0 && !Utilities.isOnLilyPad(player)) {
        String name = player.getName();
        if (Utilities.cantStandAt(block) && !Utilities.isOnLilyPad(player) && Utilities.cantStandAt(player.getLocation().getBlock()) && !Utilities.isInWater(player)) {
            int violation = 1;
            if (!flightViolation.containsKey(name)) {
                flightViolation.put(name, violation);
            } else {
                violation = flightViolation.get(name) + 1;
                flightViolation.put(name, violation);
            }
            if (violation >= FLIGHT_LIMIT) {
                flightViolation.put(name, 1);
                return true;
            }
            if (flightViolation.containsKey(name) && flightViolation.get(name) > 0) {
                for (int i = FLY_LOOP; i > 0; i--) {
                    Location newLocation = new Location(player.getWorld(), player.getLocation().getX(), player.getLocation().getY() - i, player.getLocation().getZ());
                    Block lower = newLocation.getBlock();
                    if (lower.getTypeId() == 0) {
                        player.teleport(newLocation);
                        break;
                    }
                }
            }
        }
    }
    return false;
}

Output:
     Block block = player.getLocation().getBlock().getRelative(BlockFace.DOWN);
-    if (y1 == y2 && !isMovingExempt(player) && !player.isInsideVehicle() && player.getFallDistance() == 0 && !Utilities.isOnLilyPad(player)) {
+    if (y1 == y2 && !isMovingExempt(player) && !player.isInsideVehicle() && player.getFallDistance() == 0 && !Utilities.isOnLilyPad(player) && !Utilities.isOnVine(player)) {
         String name = player.getName();


Input:
protected void extendInterceptors(List<Object> interceptors) {
    OpenEntityManagerInViewInterceptor omivi = new OpenEntityManagerInViewInterceptor();
    omivi.setEntityManagerFactory(entityManagerFactory);
    interceptors.add(omivi);
}

Output:
 protected void extendInterceptors(List<Object> interceptors) {
-    OpenEntityManagerInViewInterceptor omivi = new OpenEntityManagerInViewInterceptor();
-    omivi.setEntityManagerFactory(entityManagerFactory);
-    interceptors.add(omivi);
+    if (null != entityManagerFactory) {
+        OpenEntityManagerInViewInterceptor omivi = new OpenEntityManagerInViewInterceptor();
+        omivi.setEntityManagerFactory(entityManagerFactory);
+        interceptors.add(omivi);
+    }
 }


Input:
public Response get(final UriInfo uriInfo) {
    MultivaluedMap<String, String> params = uriInfo.getQueryParameters();
    servlet.getMetrics().incrementRequests(1);
    try {
        CellSetModel model = new CellSetModel();
        for (String rk : params.get(ROW_KEYS_PARAM_NAME)) {
            RowSpec rowSpec = new RowSpec(rk);
            if (this.versions != null) {
                rowSpec.setMaxVersions(this.versions);
            }
            if (this.columns != null) {
                for (int i = 0; i < this.columns.length; i++) {
                    rowSpec.addColumn(this.columns[i].getBytes());
                }
            }
            ResultGenerator generator = ResultGenerator.fromRowSpec(this.tableResource.getName(), rowSpec, null, !params.containsKey(NOCACHE_PARAM_NAME));
            Cell value = null;
            RowModel rowModel = new RowModel(rk);
            if (generator.hasNext()) {
                while ((value = generator.next()) != null) {
                    rowModel.addCell(new CellModel(CellUtil.cloneFamily(value), CellUtil.cloneQualifier(value), value.getTimestamp(), CellUtil.cloneValue(value)));
                }
                model.addRow(rowModel);
            } else {
                if (LOG.isTraceEnabled()) {
                    LOG.trace("String_Node_Str" + rk + "String_Node_Str");
                }
            }
        }
        if (model.getRows().isEmpty()) {
            servlet.getMetrics().incrementFailedGetRequests(1);
            return Response.status(Response.Status.NOT_FOUND).type(MIMETYPE_TEXT).entity("String_Node_Str" + CRLF).build();
        } else {
            servlet.getMetrics().incrementSucessfulGetRequests(1);
            return Response.ok(model).build();
        }
    } catch (IOException e) {
        servlet.getMetrics().incrementFailedGetRequests(1);
        return processException(e);
    }
}

Output:
                 for (int i = 0; i < this.columns.length; i++) {
-                    rowSpec.addColumn(this.columns[i].getBytes());
+                    rowSpec.addColumn(Bytes.toBytes(this.columns[i]));
                 }


Input:
private String parseRegex(CharacterIterator ci) {
    StringBuffer regexBuffer = new StringBuffer();
    int braceCount = 1;
    while (true) {
        char c = ci.next();
        if (c == '{') {
            braceCount++;
        } else if (c == '}') {
            braceCount--;
            if (braceCount == 0)
                break;
        }
        regexBuffer.append(c);
    }
    return regexBuffer.toString().trim();
}

Output:
             braceCount--;
-            if (braceCount == 0)
+            if (braceCount == 0) {
                 break;


Input:
private Class<?> injectToPlainClassLoader(ClassPool pool, ClassLoader classLoader, String className) throws NotFoundException, IOException, CannotCompileException, IllegalArgumentException, IllegalAccessException, InvocationTargetException {
    Class<?> c = null;
    try {
        c = classLoader.loadClass(className);
    } catch (ClassNotFoundException ex) {
        if (logger.isTraceEnabled()) {
            logger.trace("String_Node_Str", ex.getMessage(), ex);
        }
    }
    if (c != null) {
        return c;
    }
    final CtClass ct = pool.get(className);
    if (ct == null) {
        throw new NotFoundException(className);
    }
    final CtClass superClass = ct.getSuperclass();
    if (superClass != null) {
        injectToPlainClassLoader(pool, classLoader, superClass.getName());
    }
    final CtClass[] interfaces = ct.getInterfaces();
    for (CtClass ctInterface : interfaces) {
        injectToPlainClassLoader(pool, classLoader, ctInterface.getName());
    }
    final Collection<String> refs = ct.getRefClasses();
    for (String ref : refs) {
        try {
            injectToPlainClassLoader(pool, classLoader, ref);
        } catch (NotFoundException e) {
            logger.warn("String_Node_Str", e);
        }
    }
    final byte[] bytes = ct.toBytecode();
    return (Class<?>) DEFINE_CLASS.invoke(classLoader, ct.getName(), bytes, 0, bytes.length);
}

Output:
     } catch (ClassNotFoundException ex) {
-        if (logger.isTraceEnabled()) {
-            logger.trace("String_Node_Str", ex.getMessage(), ex);
+        if (isDebug) {
+            logger.debug("String_Node_Str", ex.getMessage());
         }


Input:
public void mouseOver(Pick pick) {
    if (labelProvider != null) {
        toolTipMessage = labelProvider.getLabel();
    }
    System.out.println("String_Node_Str");
    thread = new ToolTipThread();
    Runnable runnable = new Runnable() {
        public void run() {
            view.getParentComposite().getDisplay().asyncExec(thread);
        }
    };
    Thread timerThread = new Thread(runnable);
    timerThread.start();
}

Output:
     System.out.println("String_Node_Str");
-    thread = new ToolTipThread();
+    thread = new ToolTipThread(new Point(pick.getPickedPoint().x, pick.getPickedPoint().y));
     Runnable runnable = new Runnable() {


Input:
public void fromBytes(ByteBuf buf) {
    int size = buf.readInt();
    dimensions = new HashMap<Integer, DimensionDescriptor>();
    for (int i = 0; i < size; i++) {
        int id = buf.readInt();
        PacketBuffer buffer = new PacketBuffer(buf);
        NBTTagCompound tagCompound;
        try {
            tagCompound = buffer.readNBTTagCompoundFromBuffer();
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        DimensionDescriptor descriptor = new DimensionDescriptor(tagCompound);
        dimensions.put(id, descriptor);
    }
    size = buf.readInt();
    dimensionInformation = new HashMap<Integer, DimensionInformation>();
    for (int i = 0; i < size; i++) {
        int id = buf.readInt();
        byte[] dst = new byte[buf.readInt()];
        buf.readBytes(dst);
        String name = new String(dst);
        DimensionInformation dimInfo = new DimensionInformation(name, dimensions.get(id), buf);
        dimensionInformation.put(id, dimInfo);
    }
}

Output:
         int id = buf.readInt();
-        byte[] dst = new byte[buf.readInt()];
-        buf.readBytes(dst);
-        String name = new String(dst);
+        String name = NetworkTools.readString(buf);
         DimensionInformation dimInfo = new DimensionInformation(name, dimensions.get(id), buf);


Input:
private void validateEjbProducer(Class annotatedClass, AnnotatedField annotatedField, List<InjectionCapable> injectionResources) {
    EJB ejbAnnotation = annotatedField.getAnnotation(EJB.class);
    if (ejbAnnotation != null) {
        String lookupName = getLookupName(annotatedClass, annotatedField, injectionResources);
        EjbDescriptor foundEjb = null;
        Collection<EjbDescriptor> ejbs = deployment.getDeployedEjbs();
        for (EjbDescriptor oneEjb : ejbs) {
            String jndiName = oneEjb.getJndiName();
            if (lookupName.indexOf(jndiName) >= 0) {
                foundEjb = oneEjb;
                break;
            }
        }
        if (foundEjb != null) {
            String className = foundEjb.getEjbImplClassName();
            try {
                Class clazz = Class.forName(className, false, annotatedClass.getClassLoader());
                validateResourceClass(annotatedField, clazz);
            } catch (ClassNotFoundException ignore) {
            }
        }
    }
}

Output:
             String jndiName = oneEjb.getJndiName();
-            if (lookupName.indexOf(jndiName) >= 0) {
+            if (lookupName.contains(jndiName)) {
                 foundEjb = oneEjb;


Input:
public static Document getFileAsDocument(Resource resource) throws IoRuntimeException {
    if (resource == null)
        throw new IoRuntimeException(new NullPointerException("String_Node_Str"));
    DocumentBuilder dBuilder;
    try {
        dBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
        try {
            File configurationFile = resource.getFile();
            return dBuilder.parse(configurationFile);
        } catch (FileNotFoundException e) {
            return dBuilder.parse(resource.getInputStream());
        }
    } catch (ParserConfigurationException | SAXException e) {
        throw new IoRuntimeException(e);
    } catch (IOException e) {
        throw IoRuntimeException.propagate(e);
    }
}

Output:
             return dBuilder.parse(configurationFile);
-        } catch (FileNotFoundException e) {
+        } catch (FileNotFoundRuntimeException e) {
             return dBuilder.parse(resource.getInputStream());


Input:
public final void compute(Bounds bo) throws ChartException, IllegalArgumentException {
    ChartWithAxes cwa = getModel();
    initInnerFields(bo, cwa);
    if (boPlot.getWidth() <= 0 || boPlot.getHeight() <= 0) {
        return;
    }
    if (ChartUtil.hasMultipleYAxes(getModel()) && getModel().isStudyLayout()) {
        computeWithStudyLayout();
    } else {
        computeCommon();
    }
}

Output:
     initInnerFields(bo, cwa);
-    if (boPlot.getWidth() <= 0 || boPlot.getHeight() <= 0) {
+    if (boPlot.getWidth() < 0 || boPlot.getHeight() < 0) {
         return;


Input:
protected String createSqlStatement(Analysis analysis) {
    this.cachedAnalysis = analysis;
    StringBuilder sql = new StringBuilder("String_Node_Str");
    EList<ModelElement> analysedElements = analysis.getContext().getAnalysedElements();
    if (analysedElements.isEmpty()) {
        this.errorMessage = Messages.getString("String_Node_Str", analysis.getName());
        return null;
    }
    Set<ColumnSet> fromPart = new HashSet<ColumnSet>();
    final Iterator<ModelElement> iterator = analysedElements.iterator();
    while (iterator.hasNext()) {
        ModelElement modelElement = iterator.next();
        TdColumn col = SwitchHelpers.COLUMN_SWITCH.doSwitch(modelElement);
        if (col == null) {
            this.errorMessage = Messages.getString("String_Node_Str", modelElement);
            return null;
        }
        Classifier owner = col.getOwner();
        if (owner == null) {
            this.errorMessage = Messages.getString("String_Node_Str", col.getName());
        }
        ColumnSet colSet = SwitchHelpers.COLUMN_SET_SWITCH.doSwitch(owner);
        if (colSet == null) {
            this.errorMessage = Messages.getString("String_Node_Str", col.getName(), colSet);
            return null;
        }
        if (!analysis.getParameters().isStoreData()) {
            sql.append(this.quote(col.getName()));
            if (iterator.hasNext()) {
                sql.append(',');
            }
        }
        fromPart.add(colSet);
    }
    if (fromPart.size() != 1) {
        log.error("String_Node_Str" + fromPart.size() + "String_Node_Str");
        this.errorMessage = "String_Node_Str";
        return null;
    }
    if (analysis.getParameters().isStoreData()) {
        List<TdColumn> columnList = TableHelper.getColumns(SwitchHelpers.TABLE_SWITCH.doSwitch(analysedElements.get(0).eContainer()));
        Iterator<TdColumn> iter = columnList.iterator();
        while (iter.hasNext()) {
            TdColumn column = iter.next();
            sql.append(this.quote(column.getName()));
            if (iter.hasNext()) {
                sql.append(',');
            }
        }
    }
    sql.append(dbms().from());
    ModelElement element = fromPart.iterator().next();
    Package parentRelation = PackageHelper.getCatalogOrSchema(fromPart.iterator().next());
    if (parentRelation instanceof Schema) {
        sql.append(dbms().toQualifiedName(null, parentRelation.getName(), element.getName()));
    } else if (parentRelation instanceof Catalog) {
        String ownerUser = null;
        if (ConnectionUtils.isSybaseeDBProducts(dbms().getDbmsName())) {
            ownerUser = ColumnSetHelper.getTableOwner((ModelElement) element);
        }
        sql.append(dbms().toQualifiedName(parentRelation.getName(), ownerUser, element.getName()));
    }
    ModelElementAnalysisHandler handler = new ModelElementAnalysisHandler();
    handler.setAnalysis(analysis);
    String stringDataFilter = handler.getStringDataFilter();
    sql.append(GenericSQLHandler.WHERE_CLAUSE);
    String sqlStatement = sql.toString();
    sqlStatement = dbms().addWhereToStatement(sqlStatement, stringDataFilter);
    return sqlStatement;
}

Output:
     ModelElement element = fromPart.iterator().next();
-    Package parentRelation = PackageHelper.getCatalogOrSchema(fromPart.iterator().next());
+    Package parentRelation = PackageHelper.getParentPackage((MetadataTable) fromPart.iterator().next());
     if (parentRelation instanceof Schema) {


Input:
private void parseClassContent(CodeSensorParser.DeclByClassContext ctx) {
    restrictStreamToClassContent(ctx);
    ShallowParser shallowParser = new ShallowParser();
    shallowParser.setStack(itemStack);
    shallowParser.parseTokenStream(stream);
    stream.resetRestriction();
}

Output:
     shallowParser.setStack(itemStack);
-    shallowParser.parseTokenStream(stream);
+    shallowParser.parseAndWalk(stream);
     stream.resetRestriction();


Input:
private void installFromZip() {
    try {
        ZipFile zip = new ZipFile(APK_PATH);
        ZipEntry zipen = zip.getEntry(TOR_BINARY_ZIP_KEY);
        streamToFile(zip.getInputStream(zipen), TOR_BINARY_INSTALL_PATH);
        zipen = zip.getEntry(TORRC_ZIP_KEY);
        streamToFile(zip.getInputStream(zipen), TORRC_INSTALL_PATH);
        zipen = zip.getEntry(PRIVOXY_ZIP_KEY);
        streamToFile(zip.getInputStream(zipen), PRIVOXY_INSTALL_PATH);
        zipen = zip.getEntry(PRIVOXYCONFIG_ZIP_KEY);
        streamToFile(zip.getInputStream(zipen), PRIVOXYCONFIG_INSTALL_PATH);
        zip.close();
        Log.i(TAG, "String_Node_Str");
    } catch (IOException ioe) {
        Log.i(TAG, "String_Node_Str", ioe);
    }
}

Output:
     try {
-        ZipFile zip = new ZipFile(APK_PATH);
+        String apkPath = APK_PATH;
+        int apkIdx = 1;
+        while (!new File(apkPath).exists()) {
+            apkPath = APK_PATH_BASE + '-' + (apkIdx++) + "String_Node_Str";
+            Log.i(TAG, "String_Node_Str" + apkPath);
+        }
+        ZipFile zip = new ZipFile(apkPath);
         ZipEntry zipen = zip.getEntry(TOR_BINARY_ZIP_KEY);


Input:
public static Paging<AlbumSimplified> createSimpleAlbumPage(JSONObject simpleAlbumPageJson) {
    Paging<AlbumSimplified> page = createItemlessSimpleAlbumPage(simpleAlbumPageJson);
    page.setItems(createSimpleAlbums(simpleAlbumPageJson.getJSONArray("String_Node_Str")));
    return page;
}

Output:
     Paging<AlbumSimplified> page = createItemlessSimpleAlbumPage(simpleAlbumPageJson);
-    page.setItems(createSimpleAlbums(simpleAlbumPageJson.getJSONArray("String_Node_Str")));
+    page.setItems(createAlbumsSimplified(simpleAlbumPageJson.getJSONArray("String_Node_Str")));
     return page;


Input:
public Class<T> getInputType() {
    return ellipseRefiner.getInputType();
}

Output:
 public Class<T> getInputType() {
-    return ellipseRefiner.getInputType();
+    return inputType;
 }


Input:
public void startRequest(MRCRequest rq) {
    try {
        final openRequest rqArgs = (openRequest) rq.getRequestArgs();
        final VolumeManager vMan = master.getVolumeManager();
        final FileAccessManager faMan = master.getFileAccessManager();
        Path p = new Path(rqArgs.getPath());
        VolumeInfo volume = vMan.getVolumeByName(p.getComp(0));
        StorageManager sMan = vMan.getStorageManager(volume.getId());
        PathResolver res = new PathResolver(sMan, p);
        faMan.checkSearchPermission(sMan, res, rq.getDetails().userId, rq.getDetails().superUser, rq.getDetails().groupIds);
        AtomicDBUpdate update = sMan.createAtomicDBUpdate(master, rq);
        FileMetadata file = null;
        try {
            res.checkIfFileDoesNotExist();
            file = res.getFile();
            String target = sMan.getSoftlinkTarget(file.getId());
            if (target != null) {
                rqArgs.setPath(target);
                p = new Path(target);
                if (!vMan.hasVolume(p.getComp(0))) {
                    finishRequest(rq, new ErrorRecord(ErrorClass.USER_EXCEPTION, ErrNo.ENOENT, "String_Node_Str" + target + "String_Node_Str"));
                    return;
                }
                volume = vMan.getVolumeByName(p.getComp(0));
                sMan = vMan.getStorageManager(volume.getId());
                res = new PathResolver(sMan, p);
                file = res.getFile();
            }
            if (file.isDirectory())
                throw new UserException(ErrNo.EISDIR, "String_Node_Str");
            if (file.isReadOnly() && ((rqArgs.getFlags() & (FileAccessManager.O_RDWR | FileAccessManager.O_WRONLY | FileAccessManager.O_TRUNC | FileAccessManager.O_APPEND)) != 0))
                throw new UserException(ErrNo.EPERM, "String_Node_Str");
            faMan.checkPermission(rqArgs.getFlags(), sMan, file, res.getParentDirId(), rq.getDetails().userId, rq.getDetails().superUser, rq.getDetails().groupIds);
        } catch (UserException exc) {
            if (exc.getErrno() == ErrNo.ENOENT && (rqArgs.getFlags() & FileAccessManager.O_CREAT) != 0) {
                faMan.checkPermission(FileAccessManager.O_WRONLY, sMan, res.getParentDir(), res.getParentsParentId(), rq.getDetails().userId, rq.getDetails().superUser, rq.getDetails().groupIds);
                if ((rqArgs.getFlags() & FileAccessManager.O_EXCL) != 0)
                    res.checkIfFileExistsAlready();
                long fileId = sMan.getNextFileId();
                int time = (int) (TimeSync.getGlobalTime() / 1000);
                file = sMan.createFile(fileId, res.getParentDirId(), res.getFileName(), time, time, time, rq.getDetails().userId, rq.getDetails().groupIds.get(0), rqArgs.getMode(), 0, 0, false, 0, 0, update);
                sMan.setLastFileId(fileId, update);
                rq.setResponse(new createResponse());
            } else
                throw exc;
        }
        if ((rqArgs.getFlags() & FileAccessManager.O_TRUNC) != 0) {
            update = sMan.createAtomicDBUpdate(master, rq);
            file.setIssuedEpoch(file.getIssuedEpoch() + 1);
            sMan.setMetadata(file, FileMetadata.RC_METADATA, update);
        }
        XLocList xLocList = file.getXLocList();
        XLocSet xLocSet = null;
        if (xLocList == null || xLocList.getReplicaCount() == 0) {
            Replica replica = MRCHelper.createReplica(null, sMan, master.getOSDStatusManager(), volume, res.getParentDirId(), rqArgs.getPath(), ((InetSocketAddress) rq.getRPCRequest().getClientIdentity()).getAddress());
            ReplicaSet replicas = new ReplicaSet();
            replicas.add(replica);
            xLocSet = new XLocSet(replicas, 0, "String_Node_Str", 0);
            file.setXLocList(Converter.xLocSetToXLocList(sMan, xLocSet));
            sMan.setMetadata(file, FileMetadata.XLOC_METADATA, update);
        } else
            xLocSet = Converter.xLocListToXLocSet(xLocList);
        Capability cap = new Capability(volume.getId() + "String_Node_Str" + file.getId(), rqArgs.getFlags(), TimeSync.getGlobalTime() / 1000 + Capability.DEFAULT_VALIDITY, ((InetSocketAddress) rq.getRPCRequest().getClientIdentity()).getAddress().getHostAddress(), file.getEpoch(), master.getConfig().getCapabilitySecret());
        MRCHelper.updateFileTimes(res.getParentsParentId(), file, !master.getConfig().isNoAtime(), true, true, sMan, update);
        MRCHelper.updateFileTimes(res.getParentsParentId(), res.getParentDir(), false, true, true, sMan, update);
        if (!master.getConfig().isNoAtime())
            MRCHelper.updateFileTimes(res.getParentsParentId(), res.getParentDir(), true, false, false, sMan, update);
        rq.setResponse(new openResponse(new FileCredentials(xLocSet, cap.getXCap())));
        update.execute();
    } catch (UserException exc) {
        Logging.logMessage(Logging.LEVEL_TRACE, this, exc);
        finishRequest(rq, new ErrorRecord(ErrorClass.USER_EXCEPTION, exc.getErrno(), exc.getMessage(), exc));
    } catch (Exception exc) {
        finishRequest(rq, new ErrorRecord(ErrorClass.INTERNAL_SERVER_ERROR, "String_Node_Str", exc));
    }
}

Output:
             xLocSet = Converter.xLocListToXLocSet(xLocList);
-        Capability cap = new Capability(volume.getId() + "String_Node_Str" + file.getId(), rqArgs.getFlags(), TimeSync.getGlobalTime() / 1000 + Capability.DEFAULT_VALIDITY, ((InetSocketAddress) rq.getRPCRequest().getClientIdentity()).getAddress().getHostAddress(), file.getEpoch(), master.getConfig().getCapabilitySecret());
+        Capability cap = new Capability(volume.getId() + "String_Node_Str" + file.getId(), rqArgs.getFlags(), TimeSync.getGlobalTime() / 1000 + Capability.DEFAULT_VALIDITY, ((InetSocketAddress) rq.getRPCRequest().getClientIdentity()).getAddress().getHostAddress(), trEpoch, master.getConfig().getCapabilitySecret());
         MRCHelper.updateFileTimes(res.getParentsParentId(), file, !master.getConfig().isNoAtime(), true, true, sMan, update);


Input:
public void nodeChildrenChanged(final String path) {
    if (path.equals(watcher.znodePaths.drainingZNode)) {
        try {
            final List<String> newNodes = ZKUtil.listChildrenAndWatchThem(watcher, watcher.znodePaths.drainingZNode);
            add(newNodes);
        } catch (KeeperException e) {
            abortable.abort("String_Node_Str", e);
        } catch (IOException e) {
            abortable.abort("String_Node_Str", e);
        }
    }
}

Output:
 public void nodeChildrenChanged(final String path) {
-    if (path.equals(watcher.znodePaths.drainingZNode)) {
+    if (path.equals(watcher.getZNodePaths().drainingZNode)) {
         try {


Input:
public org.hl7.fhir.dstu2.model.Organization convertOrganization(org.hl7.fhir.dstu3.model.Organization src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2.model.Organization tgt = new org.hl7.fhir.dstu2.model.Organization();
    copyDomainResource(src, tgt);
    for (org.hl7.fhir.dstu3.model.Identifier t : src.getIdentifier()) tgt.addIdentifier(convertIdentifier(t));
    tgt.setActive(src.getActive());
    tgt.setType(convertCodeableConcept(src.getType()));
    tgt.setName(src.getName());
    for (org.hl7.fhir.dstu3.model.ContactPoint t : src.getTelecom()) tgt.addTelecom(convertContactPoint(t));
    for (org.hl7.fhir.dstu3.model.Address t : src.getAddress()) tgt.addAddress(convertAddress(t));
    tgt.setPartOf(convertReference(src.getPartOf()));
    for (org.hl7.fhir.dstu3.model.Organization.OrganizationContactComponent t : src.getContact()) tgt.addContact(convertOrganizationContactComponent(t));
    return tgt;
}

Output:
 public org.hl7.fhir.dstu2.model.Organization convertOrganization(org.hl7.fhir.dstu3.model.Organization src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
private byte[] unescapeStream(byte[] data, int offset, int limit) {
    int position = offset;
    List<Integer> escapePositions = new ArrayList<Integer>();
    while (position < limit) {
        position = findNextUnescapeIndex(data, position, limit);
        if (position < limit) {
            escapePositions.add(position);
            position += 3;
        }
    }
    int escapeCount = escapePositions.size();
    int escapedPosition = offset;
    int unescapedPosition = 0;
    byte[] unescapedData = new byte[limit - offset - escapeCount];
    for (int i = 0; i < escapeCount; i++) {
        int nextEscapePosition = escapePositions.get(i);
        int copyLength = nextEscapePosition - escapedPosition;
        System.arraycopy(data, escapedPosition, unescapedData, unescapedPosition, copyLength);
        escapedPosition += copyLength + 3;
        unescapedPosition += copyLength + 2;
    }
    int remainingLength = unescapedData.length - unescapedPosition;
    System.arraycopy(data, escapedPosition, unescapedData, unescapedPosition, remainingLength);
    return unescapedData;
}

Output:
         if (position < limit) {
-            escapePositions.add(position);
+            if (scratchEscapePositions.length <= scratchEscapeCount) {
+                scratchEscapePositions = Arrays.copyOf(scratchEscapePositions, scratchEscapePositions.length * 2);
+            }
+            scratchEscapePositions[scratchEscapeCount++] = position;
             position += 3;


Input:
public static boolean generatePackage(GATWorkerNode node) {
    LinkedList<URI> traceScripts = new LinkedList<URI>();
    LinkedList<String> traceParams = new LinkedList<String>();
    String host = node.getHost();
    String installDir = node.getInstallDir();
    String workingDir = node.getWorkingDir();
    String user = node.getUser();
    if (user == null) {
        user = "String_Node_Str";
    } else {
        user += "String_Node_Str";
    }
    try {
        traceScripts.add(new URI(Protocol.ANY_URI.getSchema() + user + host + File.separator + installDir + TRACE_SCRIPT_PATH));
    } catch (URISyntaxException e) {
        logger.error("String_Node_Str", e);
        return false;
    }
    String pars = "String_Node_Str" + workingDir + "String_Node_Str" + host;
    traceParams.add(pars);
    return new CleanerExecutor(node).executeScript(traceScripts, traceParams);
}

Output:
     traceParams.add(pars);
-    return new CleanerExecutor(node).executeScript(traceScripts, traceParams);
+    return new GATScriptExecutor(node).executeScript(traceScripts, traceParams, "String_Node_Str" + host);
 }


Input:
public void redrawLinkers() {
    int maxColumnsNumber = CoreRuntimePlugin.getInstance().getPreferenceStore().getInt(ITalendCorePrefConstants.MAXIMUM_AMOUNT_OF_COLUMNS_FOR_XML);
    if (schemaViewer.getTable().getItems().length <= maxColumnsNumber + 1) {
        linker.removeAllLinks();
        TreeItem root = xmlViewer.getTree().getItem(0);
        TableItem[] tableItems = schemaViewer.getTable().getItems();
        initLinker(root, tableItems);
        linker.updateLinksStyleAndControlsSelection(xmlViewer.getTree(), true);
    }
}

Output:
         initLinker(root, tableItems);
-        linker.updateLinksStyleAndControlsSelection(xmlViewer.getTree(), true);
+        if (linker.linkSize() == 0) {
+            linker.updateLinksStyleAndControlsSelection(xmlViewer.getTree(), true);
+        }
     }


Input:
private void refreshTable(final TreeItem treeItem, final int size) {
    IHDFSNode node = (IHDFSNode) treeItem.getData();
    if (!threadExecutor.isThreadRunning(treeItem)) {
        if (node.getType() == EHadoopFileTypes.FILE) {
            RetrieveColumnRunnable runnable = new RetrieveColumnRunnable(treeItem, threadExecutor);
            threadExecutor.execute(runnable);
        }
    } else {
        RetrieveColumnRunnable runnable = threadExecutor.getRunnable(node.getPath());
        runnable.setCanceled(false);
    }
}

Output:
         if (node.getType() == EHadoopFileTypes.FILE) {
-            RetrieveColumnRunnable runnable = new RetrieveColumnRunnable(treeItem, threadExecutor);
+            RetrieveColumnRunnable runnable = new RetrieveColumnRunnable(treeItem);
             threadExecutor.execute(runnable);


Input:
public void attributeChanged(Attribute attribute) throws IllegalActionException {
    if (attribute == modelFileOrURL) {
        if (_debugging) {
            _debug("String_Node_Str" + modelFileOrURL.getExpression());
        }
        URL url = modelFileOrURL.asURL();
        if (url != null) {
            File asFile = modelFileOrURL.asFile();
            if (!asFile.isFile()) {
                throw new IllegalActionException(this, "String_Node_Str" + url);
            }
            MoMLParser parser = new MoMLParser();
            try {
                _model = parser.parse(null, url);
            } catch (Exception ex) {
                throw new IllegalActionException(this, ex, "String_Node_Str" + url);
            }
            if (_model instanceof CompositeActor) {
                _manager = new Manager(_model.workspace(), "String_Node_Str");
                ((CompositeActor) _model).setManager(_manager);
                if (_debugging) {
                    _debug("String_Node_Str");
                }
            }
        } else {
            _model = null;
            _manager = null;
            _throwable = null;
        }
    } else if (attribute == executionOnFiring) {
        String executionOnFiringValue = executionOnFiring.stringValue();
        if (executionOnFiringValue.equals("String_Node_Str")) {
            _executionOnFiringValue = _RUN_IN_CALLING_THREAD;
        } else if (executionOnFiringValue.equals("String_Node_Str")) {
            _executionOnFiringValue = _RUN_IN_A_NEW_THREAD;
        } else if (executionOnFiringValue.equals("String_Node_Str")) {
            _executionOnFiringValue = _DO_NOTHING;
        } else {
            throw new IllegalActionException(this, "String_Node_Str" + executionOnFiringValue);
        }
    } else if (attribute == postfireAction) {
        String postfireActionValue = postfireAction.stringValue();
        if (postfireActionValue.equals("String_Node_Str")) {
            _postfireActionValue = _DO_NOTHING;
        } else if (postfireActionValue.equals("String_Node_Str")) {
            _postfireActionValue = _STOP_EXECUTING;
        } else {
            throw new IllegalActionException(this, "String_Node_Str" + postfireActionValue);
        }
    } else {
        super.attributeChanged(attribute);
    }
}

Output:
         if (url != null) {
-            File asFile = modelFileOrURL.asFile();
-            if (!asFile.isFile()) {
-                throw new IllegalActionException(this, "String_Node_Str" + url);
+            if (url.getProtocol().equals("String_Node_Str")) {
+                File asFile = modelFileOrURL.asFile();
+                if (!asFile.isFile()) {
+                    throw new IllegalActionException(this, "String_Node_Str" + url);
+                }
             }


Input:
public void testImportInnerInner01() {
    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
}

Output:
 public void testImportInnerInner01() {
-    this.runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
+    runConformTest(new String[] { "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str", "String_Node_Str", "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" }, "String_Node_Str");
 }


Input:
protected void startUp() throws Exception {
    int hiveServerPort = hiveConf.getInt("String_Node_Str", 0);
    Preconditions.checkArgument(hiveServerPort != 0, "String_Node_Str");
    LOG.info("String_Node_Str", hostname, hiveServerPort, 2.1);
    hiveServer2 = new HiveServer2();
    hiveServer2.init(hiveConf);
    hiveServer2.start();
    waitForPort(hostname.getHostName(), hiveServerPort);
    LOG.info("String_Node_Str");
    final InetSocketAddress socketAddress = new InetSocketAddress(hostname, hiveServerPort);
    discoveryService.register(new Discoverable() {
        public String getName() {
            return Constants.Service.HIVE;
        }
        public InetSocketAddress getSocketAddress() {
            return socketAddress;
        }
    });
    LOG.info("String_Node_Str");
}

Output:
     Preconditions.checkArgument(hiveServerPort != 0, "String_Node_Str");
-    LOG.info("String_Node_Str", hostname, hiveServerPort, 2.1);
+    LOG.info("String_Node_Str", hostname, hiveServerPort);
     hiveServer2 = new HiveServer2();


Input:
public RepositoryNode getRootRepositoryNode(ERepositoryObjectType type, boolean tryInit) {
    RepositoryNode rootTypeNode = null;
    if (type != null) {
        String typeName = type.name();
        if (repositoryNodeMap.containsKey(typeName)) {
            rootTypeNode = repositoryNodeMap.get(typeName);
            if (tryInit) {
                initNode(rootTypeNode);
            }
        }
    }
    return rootTypeNode;
}

Output:
     }
-    return rootTypeNode;
+    return rootRepoNode;
 }


Input:
public void expandDown(int amount) {
    Location l = new Location(p1.getWorld(), p1.getX(), Math.max(0D, p1.getY() - amount), p1.getZ());
    setLocation(coords, "String_Node_Str", l);
    save();
    reloadRegion();
}

Output:
 public void expandDown(int amount) {
-    Location l = new Location(p1.getWorld(), p1.getX(), Math.max(0D, p1.getY() - amount), p1.getZ());
-    setLocation(coords, "String_Node_Str", l);
-    save();
-    reloadRegion();
+    int x = p1.getBlockX();
+    int y = Math.max(0, p1.getBlockY() - amount);
+    int z = p1.getBlockZ();
+    setSaveReload(coords, "String_Node_Str", p1.getWorld(), x, y, z);
 }


Input:
public void viewDidLoad() {
    super.viewDidLoad();
    long globalLevel = NSUserDefaults.getStandardUserDefaults().getInteger(PIA_GLOBAL_LEVEL_NUMBER_KEY);
    if (globalLevel <= 0) {
        NSUserDefaults.getStandardUserDefaults().put(PIA_GLOBAL_LEVEL_NUMBER_KEY, 0);
        NSUserDefaults.getStandardUserDefaults().synchronize();
    }
}

Output:
     super.viewDidLoad();
-    long globalLevel = NSUserDefaults.getStandardUserDefaults().getInteger(PIA_GLOBAL_LEVEL_NUMBER_KEY);
+    long globalLevel = NSUserDefaults.getStandardUserDefaults().getInt(PIA_GLOBAL_LEVEL_NUMBER_KEY);
     if (globalLevel <= 0) {


Input:
public Object clone() {
    HetatomImpl n = new HetatomImpl();
    n.setPDBFlag(has3D());
    n.setResidueNumber(residueNumber);
    n.setPDBName(getPDBName());
    for (int i = 0; i < atoms.size(); i++) {
        Atom atom = atoms.get(i);
        n.addAtom((Atom) atom.clone());
    }
    return n;
}

Output:
     for (int i = 0; i < atoms.size(); i++) {
-        Atom atom = atoms.get(i);
-        n.addAtom((Atom) atom.clone());
+        Atom atom = (Atom) atoms.get(i).clone();
+        n.addAtom(atom);
+        atom.setGroup(n);
     }


Input:
private void addReferenceBindings(IBaseQueryDefinition qd, ListingHandle table, String expression) throws BirtException, ChartException {
    List<IColumnBinding> exprs = ExpressionUtil.extractColumnExpressions(expression);
    for (Iterator<IColumnBinding> iter = exprs.iterator(); iter.hasNext(); ) {
        IColumnBinding cb = iter.next();
        String cname = cb.getResultSetColumnName();
        for (Iterator<ComputedColumnHandle> cbIter = table.columnBindingsIterator(); cbIter.hasNext(); ) {
            ComputedColumnHandle cch = cbIter.next();
            if (cch.getName().equals(cname)) {
                if (cch.getAggregateFunction() == null && !qd.getBindings().containsKey(cname)) {
                    addColumnBinding(qd, cch);
                    addReferenceBindings(qd, table, cch.getExpression());
                }
                break;
            }
        }
    }
}

Output:
                     addColumnBinding(qd, cch);
-                    addReferenceBindings(qd, table, cch.getExpression());
+                    ScriptExpression se = ChartReportItemUtil.newExpression(modelAdapter, cch);
+                    addReferenceBindings(qd, table, se.getText());
                 }


Input:
private void populateArgument(IBinding binding, ComputedColumnHandle modelCmptdColumn) throws AdapterException {
    Iterator it = modelCmptdColumn.argumentsIterator();
    while (it != null && it.hasNext()) {
        AggregationArgumentHandle arg = (AggregationArgumentHandle) it.next();
        try {
            binding.addArgument(this.adaptExpression((Expression) arg.getExpressionProperty(AggregationArgument.VALUE_MEMBER).getValue()));
        } catch (DataException e) {
            throw new AdapterException(e.getLocalizedMessage(), e);
        }
    }
}

Output:
         try {
-            binding.addArgument(this.adaptExpression((Expression) arg.getExpressionProperty(AggregationArgument.VALUE_MEMBER).getValue()));
+            Expression expr = (Expression) arg.getExpressionProperty(AggregationArgument.VALUE_MEMBER).getValue();
+            if (expr != null)
+                binding.addArgument(this.adaptExpression(expr));
         } catch (DataException e) {


Input:
private boolean collectForceStopServicesLocked(String name, int userId, boolean evenPersistent, boolean doit, ArrayMap<ComponentName, ServiceRecord> services, ArrayList<ServiceRecord> result) {
    boolean didSomething = false;
    for (int i = 0; i < services.size(); i++) {
        ServiceRecord service = services.valueAt(i);
        if ((name == null || service.packageName.equals(name)) && (service.app == null || evenPersistent || !service.app.persistent)) {
            if (!doit) {
                return true;
            }
            didSomething = true;
            Slog.i(TAG, "String_Node_Str" + service);
            if (service.app != null) {
                service.app.removed = true;
                service.app.services.remove(service);
            }
            service.app = null;
            service.isolatedProc = null;
            result.add(service);
        }
    }
    return didSomething;
}

Output:
                 service.app.removed = true;
-                service.app.services.remove(service);
+                if (!service.app.persistent) {
+                    service.app.services.remove(service);
+                }
             }


Input:
public void processClassesAndProperties(JavaClass[] classes) {
    typeInfoClasses = new ArrayList<JavaClass>();
    typeInfo = new HashMap<String, TypeInfo>();
    userDefinedSchemaTypes = new HashMap<String, QName>();
    packageToNamespaceMappings = new HashMap<String, NamespaceInfo>();
    this.factoryMethods = new HashMap<String, JavaMethod>();
    this.namespaceResolver = new NamespaceResolver();
    ArrayList<JavaClass> classesToProcess = new ArrayList<JavaClass>();
    for (JavaClass javaClass : classes) {
        if (helper.isAnnotationPresent(javaClass, XmlRegistry.class)) {
            this.processObjectFactory(javaClass, classesToProcess);
        } else if (!helper.isAnnotationPresent(javaClass, XmlTransient.class)) {
            classesToProcess.add(javaClass);
            if (helper.isAnnotationPresent(javaClass, XmlSeeAlso.class)) {
                XmlSeeAlso seeAlso = (XmlSeeAlso) helper.getAnnotation(javaClass, XmlSeeAlso.class);
                for (Class next : seeAlso.value()) {
                    classesToProcess.add(helper.getJavaClass(next));
                }
            }
        }
    }
    updateGlobalElements(classesToProcess);
    for (JavaClass javaClass : classesToProcess) {
        if (javaClass == null) {
            continue;
        }
        createTypeInfoFor(javaClass);
        for (Iterator<JavaClass> jClassIt = javaClass.getDeclaredClasses().iterator(); jClassIt.hasNext(); ) {
            JavaClass innerClass = jClassIt.next();
            if (shouldGenerateTypeInfo(innerClass)) {
                createTypeInfoFor(innerClass);
            }
        }
        JavaClass superClass = (JavaClass) javaClass.getSuperclass();
        if (shouldGenerateTypeInfo(superClass)) {
            createTypeInfoFor(superClass);
        }
    }
    checkForCallbackMethods();
}

Output:
             classesToProcess.add(javaClass);
-            if (helper.isAnnotationPresent(javaClass, XmlSeeAlso.class)) {
-                XmlSeeAlso seeAlso = (XmlSeeAlso) helper.getAnnotation(javaClass, XmlSeeAlso.class);
-                for (Class next : seeAlso.value()) {
+            Class xmlSeeAlsoClass = null;
+            Method valueMethod = null;
+            try {
+                xmlSeeAlsoClass = PrivilegedAccessHelper.getClassForName("String_Node_Str");
+                valueMethod = PrivilegedAccessHelper.getDeclaredMethod(xmlSeeAlsoClass, "String_Node_Str", new Class[] {});
+            } catch (ClassNotFoundException ex) {
+            } catch (NoSuchMethodException ex) {
+            }
+            if (xmlSeeAlsoClass != null && helper.isAnnotationPresent(javaClass, xmlSeeAlsoClass)) {
+                Object seeAlso = (XmlSeeAlso) helper.getAnnotation(javaClass, xmlSeeAlsoClass);
+                Class[] values = null;
+                try {
+                    values = (Class[]) PrivilegedAccessHelper.invokeMethod(valueMethod, seeAlso, new Object[] {});
+                } catch (Exception ex) {
+                }
+                for (Class next : values) {
                     classesToProcess.add(helper.getJavaClass(next));


Input:
protected void postAnnotationProcess(WebBundleDescriptorImpl descriptor, ReadableArchive archive) throws IOException {
    super.postAnnotationProcess(descriptor, archive);
    List<WebFragmentDescriptor> wfList = readStandardFragments(descriptor, archive);
    if (isProcessAnnotation(descriptor)) {
        Map<ExtensionsArchivist, RootDeploymentDescriptor> localExtensions = new HashMap<ExtensionsArchivist, RootDeploymentDescriptor>();
        for (WebFragmentDescriptor wfDesc : wfList) {
            super.readAnnotations(archive, wfDesc, localExtensions);
        }
        ModuleScanner scanner = getScanner();
        if (scanner instanceof WarScanner) {
            ((WarScanner) scanner).setScanOtherLibraries(true);
            readAnnotations(archive, descriptor, localExtensions, scanner);
        }
    }
    WebFragmentDescriptor mergedWebFragment = null;
    for (WebFragmentDescriptor wf : wfList) {
        if (mergedWebFragment == null) {
            mergedWebFragment = wf;
        } else {
            mergedWebFragment.addWebBundleDescriptor(wf);
        }
    }
    if (mergedWebFragment != null) {
        descriptor.addWebBundleDescriptor(mergedWebFragment);
    }
    WebBundleDescriptorImpl defaultWebBundleDescriptor = getPlainDefaultWebXmlBundleDescriptor();
    descriptor.addDefaultWebBundleDescriptor(defaultWebBundleDescriptor);
}

Output:
         if (mergedWebFragment == null) {
-            mergedWebFragment = wf;
+            if (wf.isExists()) {
+                mergedWebFragment = wf;
+            }
         } else {


Input:
public void closeDB() {
    try {
        disk.seek(0);
        int flag;
        byte[] pageFlag = new byte[4];
        for (int i = 0; i < tableLength; i++) {
            flag = pageAccessTable[i];
            pageFlag = intToByte(flag);
            disk.write(pageFlag, 0, 4);
        }
        StringBuffer sb = new StringBuffer();
        String fileName = new String();
        String pageNum = new String();
        Iterator it = fileEntry.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry entry = (Map.Entry) it.next();
            fileName = (String) entry.getKey();
            pageNum = entry.getValue().toString();
            sb.append(fileName).append("String_Node_Str").append(pageNum).append("String_Node_Str");
        }
        openFile("String_Node_Str");
        writeFile("String_Node_Str", sb);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Output:
         for (int i = 0; i < tableLength; i++) {
-            flag = pageAccessTable[i];
+            flag = pageAllocateTable[i];
             pageFlag = intToByte(flag);


Input:
public void testScannedPathsJarGlobOrder() throws Exception {
    File fileA = null, fileB = null, fileC = null;
    File jarFile = null, globFile = null;
    String filenameA, filenameB, filenameC, fileRegex;
    String tempPath = "String_Node_Str";
    ScannedPaths sc;
    Iterator<String> iter = null;
    PrintWriter writer;
    try {
        filenameA = "String_Node_Str";
        filenameB = "String_Node_Str";
        filenameC = "String_Node_Str";
        fileRegex = tempPath;
        fileA = createNewPath(tempPath + filenameA);
        fileB = createNewPath(tempPath + filenameB);
        fileC = createNewPath(tempPath + filenameC);
        jarFile = createNewPath(tempPath + "String_Node_Str");
        writer = new PrintWriter(jarFile, "String_Node_Str");
        writer.println(filenameB);
        writer.println(filenameA);
        writer.close();
        sc = new ScannedPaths(fileRegex, "String_Node_Str");
        Assert.assertEquals(Iterators.size(sc.iterator()), 2, "String_Node_Str");
        iter = sc.iterator();
        Assert.assertTrue(iter.next().contains(filenameB));
        Assert.assertTrue(iter.next().contains(filenameA));
        if (jarFile != null) {
            jarFile.delete();
        }
        globFile = createNewPath(tempPath + "String_Node_Str");
        writer = new PrintWriter(globFile, "String_Node_Str");
        writer.println(filenameB);
        writer.println(filenameA);
        writer.println(filenameC);
        writer.close();
        sc = new ScannedPaths(fileRegex, "String_Node_Str");
        Assert.assertEquals(Iterators.size(sc.iterator()), 3, "String_Node_Str");
        iter = sc.iterator();
        Assert.assertTrue(iter.next().contains(filenameB));
        Assert.assertTrue(iter.next().contains(filenameA));
        Assert.assertTrue(iter.next().contains(filenameC));
    } catch (Exception e) {
        Assert.fail("String_Node_Str" + e.getMessage());
    } finally {
        FileUtils.deleteQuietly(new File(tempPath));
    }
}

Output:
 public void testScannedPathsJarGlobOrder() throws Exception {
-    File fileA = null, fileB = null, fileC = null;
-    File jarFile = null, globFile = null;
+    File jarFile, globFile;
     String filenameA, filenameB, filenameC, fileRegex;


Input:
public void readAttributes(DataInputStream stream) throws IOException {
    int attrs = stream.readInt();
    for (int i = 0; i < attrs; i++) {
        String key = stream.readUTF();
        String value = stream.readUTF();
        attributes.put(key, value);
    }
}

Output:
         String key = stream.readUTF();
-        String value = stream.readUTF();
+        String value = StringUtils.read(stream);
         attributes.put(key, value);


Input:
private void loadViewToUnderInteractionLayer(final int iViewID) {
    if (iSlerpFactor > 0 && iSlerpFactor < SLERP_RANGE)
        return;
    arSlerpActions.clear();
    generalManager.getViewGLCanvasManager().getGLEventListener(iViewID).broadcastElements(ESelectionType.NORMAL);
    if (stackLayer.containsElement(iViewID)) {
        SlerpAction slerpActionTransition = new SlerpAction(iViewID, stackLayer, transitionLayer);
        arSlerpActions.add(slerpActionTransition);
        if (underInteractionLayer.getElementIdByPositionIndex(0) != -1) {
            SlerpAction reverseSlerpAction = new SlerpAction(underInteractionLayer.getElementIdByPositionIndex(0), underInteractionLayer, stackLayer);
            arSlerpActions.add(reverseSlerpAction);
        }
        SlerpAction slerpAction = new SlerpAction(iViewID, transitionLayer, underInteractionLayer);
        arSlerpActions.add(slerpAction);
    } else {
        SlerpAction slerpActionTransition = new SlerpAction(iViewID, poolLayer, transitionLayer);
        arSlerpActions.add(slerpActionTransition);
        if (!stackLayer.containsElement(-1)) {
            SlerpAction reverseSlerpAction = new SlerpAction(stackLayer.getElementIdByPositionIndex(stackLayer.getNextPositionIndex()), stackLayer, true);
            arSlerpActions.add(reverseSlerpAction);
            generalManager.getViewGLCanvasManager().getGLEventListener(stackLayer.getElementIdByPositionIndex(stackLayer.getNextPositionIndex())).broadcastElements(ESelectionType.REMOVE);
        }
        SlerpAction reverseSlerpAction2 = new SlerpAction(underInteractionLayer.getElementIdByPositionIndex(0), underInteractionLayer, true);
        arSlerpActions.add(reverseSlerpAction2);
        SlerpAction slerpAction = new SlerpAction(iViewID, transitionLayer, underInteractionLayer);
        arSlerpActions.add(slerpAction);
    }
    iSlerpFactor = 0;
}

Output:
     arSlerpActions.clear();
-    generalManager.getViewGLCanvasManager().getGLEventListener(iViewID).broadcastElements(ESelectionType.NORMAL);
+    generalManager.getViewGLCanvasManager().getGLEventListener(iViewID).broadcastElements(ESelectionType.ADD);
     if (stackLayer.containsElement(iViewID)) {


Input:
public String getUnlocalizedName(ItemStack itemstack) {
    return "String_Node_Str" + ZhaPin.list[itemstack.getItemDamage()].getUnlocalizedName();
}

Output:
 public String getUnlocalizedName(ItemStack itemstack) {
-    return "String_Node_Str" + ZhaPin.list[itemstack.getItemDamage()].getUnlocalizedName();
+    return "String_Node_Str" + ZhaPinRegistry.get(itemstack.getItemDamage()).getUnlocalizedName();
 }


Input:
public void testCrossJoin() throws Exception {
    String mdx = "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str";
    propSaver.set(MondrianProperties.instance().CrossJoinOptimizerSize, Integer.MAX_VALUE);
    Result result1 = getCubeTestContext().executeQuery(mdx);
    String resultString1 = TestContext.toString(result1);
    propSaver.set(MondrianProperties.instance().CrossJoinOptimizerSize, Integer.MAX_VALUE);
    Result result2 = getCubeTestContext().executeQuery(mdx);
    String resultString2 = TestContext.toString(result2);
    assertEquals(resultString1, resultString2);
}

Output:
     propSaver.set(MondrianProperties.instance().CrossJoinOptimizerSize, Integer.MAX_VALUE);
-    Result result1 = getCubeTestContext().executeQuery(mdx);
+    Result result1 = getTestContext().executeQuery(mdx);
     String resultString1 = TestContext.toString(result1);


Input:
public void send(Message m) throws IOException {
    long priorCompressed = 0, priorUncompressed = 0;
    try {
        if (isWriteDeflated()) {
            priorUncompressed = _deflater.getTotalIn();
            priorCompressed = _deflater.getTotalOut();
        }
        try {
            m.write(_out);
        } catch (IOException ioe) {
            close();
            throw ioe;
        }
        updateWriteStatistics(m, priorUncompressed, priorCompressed);
    } catch (NullPointerException e) {
        throw CONNECTION_CLOSED;
    }
}

Output:
         }
-        try {
-            m.write(_out);
-        } catch (IOException ioe) {
-            close();
-            throw ioe;
-        }
+        m.write(_out);
         updateWriteStatistics(m, priorUncompressed, priorCompressed);


Input:
protected JCodeModel generateModel() throws IllegalStateException {
    final JCodeModel codeModel = super.generateModel();
    JFieldVar projectCodeVar = null;
    if (!getProjectCode().isEmpty()) {
        projectCodeVar = getDefinedClass().field(JMod.PRIVATE | JMod.STATIC | JMod.FINAL, String.class, "String_Node_Str");
        projectCodeVar.init(JExpr.lit(getProjectCode()));
    }
    getDefinedClass().constructor(JMod.PROTECTED);
    ClassModelUtil.createReadResolveMethod(getDefinedClass());
    for (MethodDescriptor methodDesc : methodDescriptor) {
        final JClass returnType = codeModel.ref(methodDesc.returnType());
        final JMethod jMethod = getDefinedClass().method(JMod.PUBLIC | JMod.FINAL, returnType, methodDesc.name());
        jMethod.annotate(Override.class);
        final Message message = methodDesc.message();
        final JMethod msgMethod = addMessageMethod(methodDesc.name(), message.value());
        final JBlock body = jMethod.body();
        final JClass returnField = codeModel.ref(returnType.fullName());
        final JVar result = body.decl(returnField, "String_Node_Str");
        JClass formatter = null;
        switch(message.format()) {
            case MESSAGE_FORMAT:
                formatter = codeModel.ref(java.text.MessageFormat.class);
                break;
            case PRINTF:
                formatter = codeModel.ref(String.class);
                break;
        }
        final JInvocation formatterMethod = formatter.staticInvoke("String_Node_Str");
        if (message.id() > Message.NONE && projectCodeVar != null) {
            String formatedId = String.format(STRING_ID_FORMAT, message.id());
            formatterMethod.arg(projectCodeVar.plus(JExpr.lit(formatedId)).plus(JExpr.invoke(msgMethod)));
        } else {
            formatterMethod.arg(JExpr.invoke(msgMethod));
        }
        for (MethodDescriptor.MethodParameter param : methodDesc.parameters()) {
            final JClass paramType = codeModel.ref(param.fullType());
            JVar paramVar = jMethod.param(JMod.FINAL, paramType, param.name());
            if (!param.isCause()) {
                formatterMethod.arg(paramVar);
            }
        }
        if (codeModel.ref(Throwable.class).isAssignableFrom(returnField)) {
            initCause(result, returnField, body, methodDesc, formatterMethod);
        } else {
            result.init(formatterMethod);
        }
        body._return(result);
    }
    return codeModel;
}

Output:
     for (MethodDescriptor methodDesc : methodDescriptor) {
-        final JClass returnType = codeModel.ref(methodDesc.returnType());
+        final JClass returnType = codeModel.ref(methodDesc.returnType().getReturnTypeAsString());
         final JMethod jMethod = getDefinedClass().method(JMod.PUBLIC | JMod.FINAL, returnType, methodDesc.name());


Input:
public static VolleyRequest newRefreshRequest(Uri uri) {
    RequestFuture<String> future = RequestFuture.newFuture();
    String refreshToken = uri.getQueryParameter("String_Node_Str");
    String url = stripQueryParameters(uri);
    VolleyRequest request = new VolleyRequest(Method.POST, url, future);
    request.contentType = "String_Node_Str";
    request.params.put("String_Node_Str", "String_Node_Str");
    request.params.put("String_Node_Str", refreshToken);
    return request;
}

Output:
 public static VolleyRequest newRefreshRequest(Uri uri) {
-    RequestFuture<String> future = RequestFuture.newFuture();
-    String refreshToken = uri.getQueryParameter("String_Node_Str");
-    String url = stripQueryParameters(uri);
-    VolleyRequest request = new VolleyRequest(Method.POST, url, future);
-    request.contentType = "String_Node_Str";
-    request.params.put("String_Node_Str", "String_Node_Str");
-    request.params.put("String_Node_Str", refreshToken);
-    return request;
+    return newAuthRequest(uri);
 }


Input:
public boolean applies(GameEvent event, Ability source, Game game) {
    if (!this.used && super.applies(event, source, game) && event.getTargetId().equals(source.getFirstTarget())) {
        return true;
    }
    return false;
}

Output:
 public boolean applies(GameEvent event, Ability source, Game game) {
-    if (!this.used && super.applies(event, source, game) && event.getTargetId().equals(source.getFirstTarget())) {
-        return true;
-    }
-    return false;
+    return !this.used && super.applies(event, source, game) && event.getTargetId().equals(source.getFirstTarget());
 }


Input:
public void createDummyTable() {
    setColumns(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" }, new int[] { 200, 200, 200 });
    layout(true);
    WizardBase.removeException();
}

Output:
 public void createDummyTable() {
-    setColumns(new String[] { "String_Node_Str", "String_Node_Str", "String_Node_Str" }, new int[] { 200, 200, 200 });
+    isDummy = true;
+    for (int i = 0; i < 3; i++) {
+        columnWidths.add(Integer.valueOf(200));
+    }
+    placeComponents();
     layout(true);


Input:
public boolean onCommand(CommandSender sender, Command commandArg, String commandLabel, String[] arg) {
    Player player = (Player) sender;
    PlayerInventory inventory = player.getInventory();
    String command = commandArg.getName().toLowerCase();
    ItemStack itemstack;
    if (command.equalsIgnoreCase("String_Node_Str")) {
        if (player.isOp() || gimme.Permissions.has(player, "String_Node_Str") || (gimme.Permissions.has(player, "String_Node_Str") || gimme.Permissions.has(player, "String_Node_Str"))) {
            if (arg.length >= 1 && arg.length <= 2) {
                Pattern p = Pattern.compile("String_Node_Str");
                Matcher m = p.matcher(arg[0]);
                if (m.matches()) {
                    if (!(itemdeny(Integer.valueOf(arg[0])))) {
                        itemstack = new ItemStack(Integer.parseInt(arg[0]));
                        if (arg.length == 1) {
                            itemstack.setAmount(amount);
                        }
                        if (arg.length == 2) {
                            itemstack.setAmount(Integer.parseInt(arg[1]));
                        }
                        player.sendMessage("String_Node_Str");
                        inventory.addItem(itemstack);
                    } else {
                        player.sendMessage(logPrefix + "String_Node_Str");
                        log.info(logPrefix + player + "String_Node_Str" + arg[0].toString());
                    }
                } else {
                    int itemid = items.get(arg[0].toLowerCase());
                    if (!(itemdeny(itemid))) {
                        itemstack = new ItemStack(itemid);
                        if (arg.length == 1) {
                            itemstack.setAmount(amount);
                        }
                        if (arg.length == 2) {
                            itemstack.setAmount(Integer.parseInt(arg[1]));
                        }
                        player.sendMessage("String_Node_Str");
                        inventory.addItem(itemstack);
                    } else {
                        player.sendMessage(logPrefix + "String_Node_Str");
                        log.info(logPrefix + player + "String_Node_Str" + arg[0].toString());
                    }
                }
            } else {
                player.sendMessage("String_Node_Str");
            }
        } else {
            player.sendMessage("String_Node_Str");
            log.info(logPrefix + "String_Node_Str" + player.getDisplayName() + "String_Node_Str" + command + "String_Node_Str");
        }
        return true;
    }
    return true;
}

Output:
     if (command.equalsIgnoreCase("String_Node_Str")) {
-        if (player.isOp() || gimme.Permissions.has(player, "String_Node_Str") || (gimme.Permissions.has(player, "String_Node_Str") || gimme.Permissions.has(player, "String_Node_Str"))) {
+        if (gimme.Permissions.has(player, "String_Node_Str") || gimme.Permissions.has(player, "String_Node_Str") || (gimme.Permissions.has(player, "String_Node_Str"))) {
             if (arg.length >= 1 && arg.length <= 2) {


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 && attackingCreature.getMinBlockedBy() > 1) {
                                } else {
                                    mayBlock = true;
                                    break;
                                }
                            }
                        }
                        if (mayBlock) {
                            if (controller.isHuman()) {
                                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) {
                            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.getLogName());
        }
    }
    if (sb.length() > 0) {
        sb.insert(0, "String_Node_Str");
        sb.append("String_Node_Str");
        game.informPlayer(controller, sb.toString());
        return false;
    }
    return true;
}

Output:
                                 Permanent attackingCreature = game.getPermanent(attackingCreatureId);
-                                if (attackingCreature != null && attackingCreature.getMinBlockedBy() > 1) {
-                                } else {
-                                    mayBlock = true;
-                                    break;
+                                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;
+                                    }
                                 }


Input:
private NSArray<NSIndexPath> getIndexPathsFromIndexesWithSection(NSIndexSet indexSet, final long section) {
    final NSArray<NSIndexPath> indexPaths = new NSMutableArray<>(indexSet.size());
    indexSet.enumerateIndexes(new VoidBlock2<Long, BooleanPtr>() {
        public void invoke(Long idx, BooleanPtr stop) {
            indexPaths.add(NSIndexPath.item(idx, section));
        }
    });
    return indexPaths;
}

Output:
     final NSArray<NSIndexPath> indexPaths = new NSMutableArray<>(indexSet.size());
-    indexSet.enumerateIndexes(new VoidBlock2<Long, BooleanPtr>() {
-        public void invoke(Long idx, BooleanPtr stop) {
-            indexPaths.add(NSIndexPath.item(idx, section));
-        }
+    indexSet.enumerateIndexes((idx, stop) -> {
+        indexPaths.add(NSIndexPath.item(idx, section));
     });


Input:
public EventDefinition readNextEvent() throws CTFReaderException {
    Long eventID = null;
    long timestamp = 0;
    if (getStreamEventHeaderDef() != null) {
        getStreamEventHeaderDef().read(getBitBuffer());
        EnumDefinition idEnumDef = (EnumDefinition) getStreamEventHeaderDef().lookupDefinition("String_Node_Str");
        assert (idEnumDef != null);
        eventID = idEnumDef.getIntegerValue();
        VariantDefinition variantDef = (VariantDefinition) getStreamEventHeaderDef().lookupDefinition("String_Node_Str");
        assert (variantDef != null);
        StructDefinition variantCurrentField = (StructDefinition) variantDef.getCurrentField();
        assert (variantCurrentField != null);
        IntegerDefinition idIntegerDef = (IntegerDefinition) variantCurrentField.lookupDefinition("String_Node_Str");
        if (idIntegerDef != null) {
            eventID = idIntegerDef.getValue();
        }
        IntegerDefinition timestampDef = (IntegerDefinition) variantCurrentField.lookupDefinition("String_Node_Str");
        assert (timestampDef != null);
        timestamp = calculateTimestamp(timestampDef);
    }
    if (getStreamEventContextDef() != null) {
        getStreamEventContextDef().read(getBitBuffer());
    }
    EventDefinition eventDef = events.get(eventID);
    if (eventDef == null) {
        throw new CTFReaderException("String_Node_Str" + eventID);
    }
    if (eventDef.context != null) {
        eventDef.context.read(getBitBuffer());
    }
    if (eventDef.fields != null) {
        int pos = getBitBuffer().position();
        int minAlign = (int) eventDef.fields.getDeclaration().getMinAlign();
        int offset = pos % minAlign;
        pos += (minAlign - offset) % minAlign;
        getBitBuffer().position(pos);
        eventDef.fields.read(getBitBuffer());
    }
    eventDef.timestamp = timestamp;
    return eventDef;
}

Output:
     long timestamp = 0;
-    if (getStreamEventHeaderDef() != null) {
-        getStreamEventHeaderDef().read(getBitBuffer());
-        EnumDefinition idEnumDef = (EnumDefinition) getStreamEventHeaderDef().lookupDefinition("String_Node_Str");
+    StructDefinition sehd = getStreamEventHeaderDef();
+    BitBuffer currentBitBuffer = getBitBuffer();
+    if (sehd != null) {
+        sehd.read(currentBitBuffer);
+        EnumDefinition idEnumDef = (EnumDefinition) sehd.lookupDefinition("String_Node_Str");
         assert (idEnumDef != null);


Input:
public boolean isNull() {
    return invoke(new IsNullRequest(name));
}

Output:
 public boolean isNull() {
-    return invoke(new IsNullRequest(name));
+    return (Boolean) invoke(new IsNullRequest(name));
 }


Input:
private void saveToCache(ValidationResult res, String cacheName) throws IOException {
    if (cacheName == null)
        return;
    if (res.getDisplay() != null)
        TextFile.stringToFile(res.getDisplay(), cacheName);
    else if (res.getSeverity() == IssueSeverity.WARNING)
        TextFile.stringToFile("String_Node_Str" + res.getMessage(), cacheName);
    else
        TextFile.stringToFile("String_Node_Str" + res.getMessage(), cacheName);
}

Output:
         TextFile.stringToFile(res.getDisplay(), cacheName);
-    else if (res.getSeverity() == IssueSeverity.WARNING)
-        TextFile.stringToFile("String_Node_Str" + res.getMessage(), cacheName);
-    else
-        TextFile.stringToFile("String_Node_Str" + res.getMessage(), cacheName);
+    else if (res.getMessage() != null) {
+        if (res.getSeverity() == IssueSeverity.WARNING)
+            TextFile.stringToFile("String_Node_Str" + res.getMessage(), cacheName);
+        else
+            TextFile.stringToFile("String_Node_Str" + res.getMessage(), cacheName);
+    }
 }


Input:
public void sendWelcomeMessage(final SocketChannel socketChannel, final long timeStampOfLastMessage, final int localIdentifier1) throws IOException {
    bytes.clear();
    byteBuffer.clear();
    bytes.writeByte(localIdentifier1);
    bytes.writeLong(timeStampOfLastMessage);
    byteBuffer.limit((int) bytes.position());
    socketChannel.write(byteBuffer);
    bytes.clear();
    byteBuffer.clear();
}

Output:
     socketChannel.write(byteBuffer);
-    bytes.clear();
-    byteBuffer.clear();
+    if (byteBuffer.remaining() == 0) {
+        byteBuffer.position(0);
+        byteBuffer.limit(0);
+    } else {
+        byteBuffer.compact();
+        byteBuffer.flip();
+    }
+    bytes.position(byteBuffer.limit());
+    bytes.limit(bytes.capacity());
 }


Input:
public void updateNotification(StatusBarNotification notification, RankingMap ranking) {
    if (DEBUG)
        Log.d(TAG, "String_Node_Str" + notification + "String_Node_Str");
    final String key = notification.getKey();
    Entry entry = mNotificationData.get(key);
    if (entry == null) {
        return;
    } else if (mHeadsUpEntriesToRemoveOnSwitch.contains(entry)) {
        mHeadsUpEntriesToRemoveOnSwitch.remove(entry);
    }
    Notification n = notification.getNotification();
    mNotificationData.updateRanking(ranking);
    boolean applyInPlace = entry.cacheContentViews(mContext, notification.getNotification());
    boolean shouldPeek = shouldPeek(entry, notification);
    boolean alertAgain = alertAgain(entry, n);
    if (DEBUG) {
        Log.d(TAG, "String_Node_Str" + applyInPlace + "String_Node_Str" + shouldPeek + "String_Node_Str" + alertAgain);
    }
    final StatusBarNotification oldNotification = entry.notification;
    entry.notification = notification;
    mGroupManager.onEntryUpdated(entry, oldNotification);
    boolean updateSuccessful = false;
    if (applyInPlace) {
        if (DEBUG)
            Log.d(TAG, "String_Node_Str" + key);
        try {
            if (entry.icon != null) {
                final StatusBarIcon ic = new StatusBarIcon(notification.getUser(), notification.getPackageName(), n.getSmallIcon(), n.iconLevel, n.number, n.tickerText);
                entry.icon.setNotification(n);
                if (!entry.icon.set(ic)) {
                    handleNotificationError(notification, "String_Node_Str" + ic);
                    return;
                }
            }
            updateNotificationViews(entry, notification);
            updateSuccessful = true;
        } catch (RuntimeException e) {
            Log.w(TAG, "String_Node_Str" + notification.getPackageName(), e);
        }
    }
    if (!updateSuccessful) {
        if (DEBUG)
            Log.d(TAG, "String_Node_Str" + key);
        final StatusBarIcon ic = new StatusBarIcon(notification.getUser(), notification.getPackageName(), n.getSmallIcon(), n.iconLevel, n.number, n.tickerText);
        entry.icon.setNotification(n);
        entry.icon.set(ic);
        inflateViews(entry, mStackScroller);
    }
    updateHeadsUp(key, entry, shouldPeek, alertAgain);
    updateNotifications();
    updateNotificationVetoButton(entry.row, notification);
    if (DEBUG) {
        boolean isForCurrentUser = isNotificationForCurrentProfiles(notification);
        Log.d(TAG, "String_Node_Str" + (isForCurrentUser ? "String_Node_Str" : "String_Node_Str") + "String_Node_Str");
    }
    setAreThereNotifications();
}

Output:
     updateNotifications();
-    updateNotificationVetoButton(entry.row, notification);
+    bindVetoButtonClickListener(entry.row, notification);
     if (DEBUG) {


Input:
protected void doSessionOpened(IoSessionEx session) throws Exception {
    writeStringMessageToSession("String_Node_Str" + counter, session);
    InetSocketAddress socketAddress = (InetSocketAddress) session.getLocalAddress();
    expectedPatterns = Arrays.asList(String.format("String_Node_Str", session.getId(), socketAddress.getPort()));
}

Output:
     InetSocketAddress socketAddress = (InetSocketAddress) session.getLocalAddress();
-    expectedPatterns = Arrays.asList(String.format("String_Node_Str", session.getId(), socketAddress.getPort()));
+    checkLogMessageRule.setExpectedPatterns(Arrays.asList(String.format("String_Node_Str", session.getId(), socketAddress.getPort())));
 }