Input:
protected void addDragAndDropSupport(int operations, Transfer[] transfers) {
    getMainTreeViewer().addDragSupport(operations, transfers, new TreeViewerContainerDragSourceListener(getTreeViewer()));
    getMainTreeViewer().addDropSupport(operations, transfers, new TCEditorDropTargetListener(this));
}

Output:
     getMainTreeViewer().addDragSupport(operations, transfers, new TreeViewerContainerDragSourceListener(getTreeViewer()));
-    getMainTreeViewer().addDropSupport(operations, transfers, new TCEditorDropTargetListener(this));
+    getMainTreeViewer().addDropSupport(operations, transfers, getViewerDropAdapter());
 }


Input:
public void testDeclareMessageContents() {
    List msgs = handler.getMessages();
    IMessage msg = (IMessage) ((TestMessageHandler.TestMessage) msgs.get(1)).getContainedMessage();
    assertEquals("String_Node_Str", msg.getMessage());
    assertEquals("String_Node_Str", msg.getDetails());
}

Output:
     List msgs = handler.getMessages();
-    IMessage msg = (IMessage) ((TestMessageHandler.TestMessage) msgs.get(1)).getContainedMessage();
+    IMessage msg = ((TestMessageHandler.TestMessage) msgs.get(1)).getContainedMessage();
     assertEquals("String_Node_Str", msg.getMessage());


Input:
private void decompress(ResourcesManager srcManager, File destRootFolder) throws IOException {
    Set<IPath> paths = srcManager.getPaths();
    for (IPath path : paths) {
        InputStream bis = srcManager.getStream(path);
        File destFile = new File(destRootFolder, path.toPortableString());
        File parentFile = destFile.getParentFile();
        if (!parentFile.exists()) {
            parentFile.mkdirs();
        }
        BufferedOutputStream bos = null;
        try {
            bos = new BufferedOutputStream(new FileOutputStream(destFile), BUFFER_SIZE);
            int count;
            byte[] data = new byte[BUFFER_SIZE];
            while ((count = bis.read(data, 0, BUFFER_SIZE)) != -1) {
                bos.write(data, 0, count);
            }
        } finally {
            if (bos != null) {
                bos.flush();
                bos.close();
            }
            bis.close();
        }
    }
}

Output:
     Set<IPath> paths = srcManager.getPaths();
-    for (IPath path : paths) {
-        InputStream bis = srcManager.getStream(path);
-        File destFile = new File(destRootFolder, path.toPortableString());
-        File parentFile = destFile.getParentFile();
-        if (!parentFile.exists()) {
-            parentFile.mkdirs();
-        }
-        BufferedOutputStream bos = null;
-        try {
-            bos = new BufferedOutputStream(new FileOutputStream(destFile), BUFFER_SIZE);
-            int count;
-            byte[] data = new byte[BUFFER_SIZE];
-            while ((count = bis.read(data, 0, BUFFER_SIZE)) != -1) {
-                bos.write(data, 0, count);
+    Thread currentThread = Thread.currentThread();
+    try {
+        for (IPath path : paths) {
+            if (interrupable && currentThread.isInterrupted()) {
+                throw new InterruptedException();
+            }
+            InputStream bis = srcManager.getStream(path);
+            File destFile = new File(destRootFolder, path.toPortableString());
+            File parentFile = destFile.getParentFile();
+            if (!parentFile.exists()) {
+                parentFile.mkdirs();
             }


Input:
public final IType getReferenceType() {
    Type type = new Type(this.position, this.theClass);
    type.name = this.name;
    return type;
}

Output:
     Type type = new Type(this.position, this.theClass);
-    type.name = this.name;
+    if (this != Types.VOID) {
+        type.name = this.name;
+    }
     return type;


Input:
public WsrSession call() throws Exception {
    IoBufferAllocatorEx<?> parentAllocator = session.getBufferAllocator();
    WsrBufferAllocator wsrAllocator = new WsrBufferAllocator(parentAllocator);
    WsrSession wsrSession = new WsrSession(WsrConnector.this, getProcessor(), connectAddress, connectAddress, session, wsrAllocator, null, null);
    wsrSession.setRtmpAddress(rtmpAddress);
    wsrSession.suspendWrite();
    return wsrSession;
}

Output:
     WsrBufferAllocator wsrAllocator = new WsrBufferAllocator(parentAllocator);
-    WsrSession wsrSession = new WsrSession(WsrConnector.this, getProcessor(), connectAddress, connectAddress, session, wsrAllocator, null, null);
+    WsrSession wsrSession = new WsrSession(WsrConnector.this, getProcessor(), connectAddress, connectAddress, session, wsrAllocator, null);
     wsrSession.setRtmpAddress(rtmpAddress);


Input:
private void initParameterMap() {
    portletParameters = new HashMap();
    Iterator iterator = url.getParameters().iterator();
    while (iterator.hasNext()) {
        PortalURLParameter param = (PortalURLParameter) iterator.next();
        String name = param.getName();
        String[] values = param.getValues();
        if (param.getWindowId().equals(portletWindow.getId().getStringId())) {
            portletParameters.put(name, values);
        }
    }
    String id = url.getActionWindow();
    if (portletWindow.getId().getStringId().equals(id)) {
        Enumeration params = super.getParameterNames();
        while (params.hasMoreElements()) {
            String name = params.nextElement().toString();
            String[] values = super.getParameterValues(name);
            if (portletParameters.containsKey(name)) {
                String[] temp = (String[]) portletParameters.get(name);
                String[] all = new String[values.length + temp.length];
                System.arraycopy(values, 0, all, 0, values.length);
                System.arraycopy(temp, 0, all, values.length, temp.length);
            }
            portletParameters.put(name, values);
        }
    }
    if (LOG.isDebugEnabled()) {
        LOG.debug("String_Node_Str" + portletWindow.getId().getStringId() + "String_Node_Str");
    }
}

Output:
         String[] values = param.getValues();
-        if (param.getWindowId().equals(portletWindow.getId().getStringId())) {
-            portletParameters.put(name, values);
+        if (param.getWindowId() != null) {
+            if (param.getWindowId().equals(portletWindow.getId().getStringId())) {
+                portletParameters.put(name, values);
+            }
         }


Input:
protected void doService(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    BaseAttributeBean attrBean = (BaseAttributeBean) request.getAttribute(IBirtConstants.ATTRIBUTE_BEAN);
    OutputStream out = response.getOutputStream();
    GetUpdatedObjectsResponse upResponse = new GetUpdatedObjectsResponse();
    IContext context = new BirtContext(request, response);
    Operation op = null;
    try {
        if (ParameterAccessor.isGetImageOperator(request)) {
            BirtRenderImageActionHandler renderImageHandler = new BirtRenderImageActionHandler(context, op, upResponse);
            renderImageHandler.execute();
        } else {
            boolean isPrint = false;
            if (IBirtConstants.ACTION_PRINT.equalsIgnoreCase(attrBean.getAction())) {
                isPrint = true;
                out = new ByteArrayOutputStream();
            }
            BirtRunAndRenderActionHandler runAndRenderHandler = new BirtRunAndRenderActionHandler(context, op, upResponse, out);
            runAndRenderHandler.execute();
            if (isPrint) {
                InputStream inputStream = new ByteArrayInputStream(out.toString().getBytes());
                BirtUtility.doPrintAction(inputStream, request, response);
            }
        }
    } catch (RemoteException e) {
        AxisFault fault = (AxisFault) e;
        response.setContentType("String_Node_Str");
        BirtUtility.writeMessage(response.getOutputStream(), ParameterAccessor.htmlEncode(fault.getFaultString()), IBirtConstants.MSG_ERROR);
    }
}

Output:
             if (isPrint) {
-                InputStream inputStream = new ByteArrayInputStream(out.toString().getBytes());
+                InputStream inputStream = new ByteArrayInputStream(((ByteArrayOutputStream) out).toByteArray());
                 BirtUtility.doPrintAction(inputStream, request, response);


Input:
public int getIslamicOffset() {
    return Integer.parseInt(prefs.getString(Constants.PREF_ISLAMIC_OFFSET, Constants.DEFAULT_ISLAMIC_OFFSET));
}

Output:
 public int getIslamicOffset() {
-    return Integer.parseInt(prefs.getString(Constants.PREF_ISLAMIC_OFFSET, Constants.DEFAULT_ISLAMIC_OFFSET));
+    return Integer.parseInt(prefs.getString(Constants.PREF_ISLAMIC_OFFSET, Constants.DEFAULT_ISLAMIC_OFFSET).replace("String_Node_Str", "String_Node_Str"));
 }


Input:
public static LoggingContext getLoggingContext(String namespaceId, String applicationId, String entityId, ProgramType programType, String runId, String adapterName) {
    switch(programType) {
        case FLOW:
            return new FlowletLoggingContext(namespaceId, applicationId, entityId, "String_Node_Str", runId, null);
        case WORKFLOW:
            return new WorkflowLoggingContext(namespaceId, applicationId, entityId, runId);
        case MAPREDUCE:
            return new MapReduceLoggingContext(namespaceId, applicationId, entityId, runId, adapterName);
        case SPARK:
            return new SparkLoggingContext(namespaceId, applicationId, entityId, runId);
        case SERVICE:
            return new UserServiceLoggingContext(namespaceId, applicationId, entityId, "String_Node_Str", runId, null);
        case WORKER:
            return new WorkerLoggingContext(namespaceId, applicationId, entityId, runId, null, adapterName);
        default:
            throw new IllegalArgumentException(String.format("String_Node_Str", programType));
    }
}

Output:
         case WORKFLOW:
-            return new WorkflowLoggingContext(namespaceId, applicationId, entityId, runId);
+            return new WorkflowLoggingContext(namespaceId, applicationId, entityId, runId, adapterName);
         case MAPREDUCE:


Input:
public SewingController getBugLoginController() {
    return new BugLoginController();
}

Output:
 public SewingController getBugLoginController() {
-    return new BugLoginController();
+    return new BUGLoginController();
 }


Input:
public boolean set(int x, int y, int z, int value, int expected) {
    if (!contains(x, y, z))
        throw new IndexOutOfBoundsException();
    if (value < 0 || value > 255 || expected < 0 || expected > 255)
        throw new IllegalArgumentException();
    int pos = pos(x, y, z);
    int old = data[pos] & 0xFF;
    if (old == expected) {
        data[pos] = (byte) value;
        return true;
    }
    return false;
}

Output:
     if (!contains(x, y, z))
-        throw new IndexOutOfBoundsException();
-    if (value < 0 || value > 255 || expected < 0 || expected > 255)
-        throw new IllegalArgumentException();
+        throw new IndexOutOfBoundsException("String_Node_Str" + x + "String_Node_Str" + y + "String_Node_Str" + z + "String_Node_Str");
+    if (value < -128 || value > 127)
+        throw new IllegalArgumentException("String_Node_Str" + value + "String_Node_Str");
+    if (expected < -128 || expected > 127)
+        throw new IllegalArgumentException("String_Node_Str" + value + "String_Node_Str");
     int pos = pos(x, y, z);


Input:
public void setThrowableHeading(double x, double y, double z, float velocity, float inaccuracy) {
    float var9 = MathHelper.sqrt_double(x * x + y * y + z * z);
    x /= (double) var9;
    y /= (double) var9;
    z /= (double) var9;
    x += this.rand.nextGaussian() * 0.007499999832361937D * (double) inaccuracy;
    y += this.rand.nextGaussian() * 0.007499999832361937D * (double) inaccuracy;
    z += this.rand.nextGaussian() * 0.007499999832361937D * (double) inaccuracy;
    x *= (double) velocity;
    y *= (double) velocity;
    z *= (double) velocity;
    this.motionX = x;
    this.motionY = y;
    this.motionZ = z;
    float var10 = MathHelper.sqrt_double(x * x + z * z);
    this.prevRotationYaw = this.rotationYaw = (float) (Math.atan2(x, z) * 180.0D / Math.PI);
    this.prevRotationPitch = this.rotationPitch = (float) (Math.atan2(y, (double) var10) * 180.0D / Math.PI);
    this.ticksInGround = 0;
}

Output:
 public void setThrowableHeading(double x, double y, double z, float velocity, float inaccuracy) {
-    float var9 = MathHelper.sqrt_double(x * x + y * y + z * z);
+    float var9 = MathHelper.sqrt(x * x + y * y + z * z);
     x /= (double) var9;


Input:
public void testBatchReads() throws OperationException, InterruptedException {
    final String table = "String_Node_Str";
    SortedSet<Long> keysWritten = Sets.newTreeSet();
    List<WriteOperation> ops = Lists.newArrayListWithCapacity(500);
    Random rand = new Random(451);
    for (int i = 0; i < 500; i++) {
        long keyLong = rand.nextLong();
        byte[] key = org.apache.hadoop.hbase.util.Bytes.toBytes(keyLong);
        ops.add(new Write(table, key, new byte[][] { c, key }, new byte[][] { key, v }));
        keysWritten.add(keyLong);
    }
    local.commit(context, ops);
    OperationResult<List<KeyRange>> result = remote.execute(context, new GetSplits(table));
    Assert.assertFalse(result.isEmpty());
    List<KeyRange> splits = result.getValue();
    SortedSet<Long> keysToVerify = Sets.newTreeSet(keysWritten);
    verifySplits(table, splits, keysToVerify);
    long start = 0x10000000L, stop = 0x40000000L;
    result = remote.execute(context, new GetSplits(table, 5, org.apache.hadoop.hbase.util.Bytes.toBytes(start), org.apache.hadoop.hbase.util.Bytes.toBytes(stop)));
    Assert.assertFalse(result.isEmpty());
    splits = result.getValue();
    Assert.assertTrue(splits.size() <= 5);
    keysToVerify = Sets.newTreeSet(keysWritten.subSet(start, stop));
    verifySplits(table, splits, keysToVerify);
}

Output:
         long keyLong = rand.nextLong();
-        byte[] key = org.apache.hadoop.hbase.util.Bytes.toBytes(keyLong);
+        byte[] key = Bytes.toBytes(keyLong);
         ops.add(new Write(table, key, new byte[][] { c, key }, new byte[][] { key, v }));


Input:
public static byte[] uncompress(byte[] data) throws Exception {
    byte[] retBytes = new byte[0];
    String headerFragment = new String(data, 0, C_HEADER_BEGIN.length());
    if (headerFragment.equals(C_HEADER_BEGIN)) {
        headerFragment = new String(data, (C_HEADER_BEGIN.length()), max3(C_HEADER_NONE_VAL.length(), C_HEADER_ZLIB_VAL.length(), C_HEADER_GZIP_VAL.length()));
        if (headerFragment.indexOf(C_HEADER_NONE_VAL) == 0) {
            retBytes = new byte[data.length - COMPRESS_HEADER_NONE.length()];
            System.arraycopy(data, COMPRESS_HEADER_NONE.length(), retBytes, 0, data.length - COMPRESS_HEADER_NONE.length());
        } else if (headerFragment.indexOf(C_HEADER_GZIP_VAL) == 0) {
            retBytes = new byte[data.length - COMPRESS_HEADER_GZIP.length()];
            System.arraycopy(data, COMPRESS_HEADER_GZIP.length(), retBytes, 0, data.length - COMPRESS_HEADER_GZIP.length());
            retBytes = uncompressGZIP(retBytes);
        } else if (headerFragment.indexOf(C_HEADER_ZLIB_VAL) == 0) {
            retBytes = new byte[data.length - COMPRESS_HEADER_ZLIB.length()];
            System.arraycopy(data, COMPRESS_HEADER_ZLIB.length(), retBytes, 0, data.length - COMPRESS_HEADER_ZLIB.length());
            retBytes = uncompressZLIB(retBytes);
        } else
            ;
    } else
        return data;
    return retBytes;
}

Output:
     if (headerFragment.equals(C_HEADER_BEGIN)) {
-        headerFragment = new String(data, (C_HEADER_BEGIN.length()), max3(C_HEADER_NONE_VAL.length(), C_HEADER_ZLIB_VAL.length(), C_HEADER_GZIP_VAL.length()));
-        if (headerFragment.indexOf(C_HEADER_NONE_VAL) == 0) {
-            retBytes = new byte[data.length - COMPRESS_HEADER_NONE.length()];
-            System.arraycopy(data, COMPRESS_HEADER_NONE.length(), retBytes, 0, data.length - COMPRESS_HEADER_NONE.length());
-        } else if (headerFragment.indexOf(C_HEADER_GZIP_VAL) == 0) {
+        boolean found = false;
+        int i = 0;
+        for (; i < data.length && !found; i++) if (data[i] == (byte) 125)
+            found = true;
+        headerFragment = new String(data, 1, i - 1 - 1);
+        int comp = getCompressionType(headerFragment);
+        if (comp == NONE) {
+            retBytes = new byte[data.length - (headerFragment.length() + 2)];
+            System.arraycopy(data, i, retBytes, 0, data.length - (headerFragment.length() + 2));
+        } else if (comp == GZIP) {
             retBytes = new byte[data.length - COMPRESS_HEADER_GZIP.length()];


Input:
public void setCopytoMap(final Map<File, File> value) {
    prop.put(COPYTO_TARGET_TO_SOURCE_MAP_LIST, new HashMap<File, File>(value));
}

Output:
 public void setCopytoMap(final Map<File, File> value) {
-    prop.put(COPYTO_TARGET_TO_SOURCE_MAP_LIST, new HashMap<File, File>(value));
+    final Map<String, String> res = new HashMap<String, String>();
+    for (final Map.Entry<File, File> e : value.entrySet()) {
+        res.put(e.getKey().toString(), e.getValue().toString());
+    }
+    prop.put(COPYTO_TARGET_TO_SOURCE_MAP_LIST, res);
 }


Input:
private void drawColumn(Canvas canvas, RectF rect, GregorianCalendar date) {
    Integer[] values = frequency.get(new Timestamp(date));
    float rowHeight = rect.height() / 8.0f;
    prevRect.set(rect);
    Integer[] localeWeekdayList = DateUtils.getLocaleWeekdayList();
    for (int j = 0; j < localeWeekdayList.length; j++) {
        rect.set(0, 0, baseSize, baseSize);
        rect.offset(prevRect.left, prevRect.top + baseSize * j);
        int i = DateUtils.javaWeekdayToLoopWeekday(localeWeekdayList[j]);
        if (values != null)
            drawMarker(canvas, rect, values[i]);
        rect.offset(0, rowHeight);
    }
    drawFooter(canvas, rect, date);
}

Output:
         rect.offset(prevRect.left, prevRect.top + baseSize * j);
-        int i = DateUtils.javaWeekdayToLoopWeekday(localeWeekdayList[j]);
+        int i = localeWeekdayList[j] % 7;
         if (values != null)


Input:
public void itemChanged(Item item) {
    if (item == null) {
        set(true, EMPTY);
        log(Player.class).info("String_Node_Str");
    } else if (val.same(item)) {
        set(true, val);
        log(Player.class).info("String_Node_Str");
    } else if (nextMetadataCache.same(item)) {
        set(true, nextMetadataCache);
        log(Player.class).info("String_Node_Str");
    } else {
        log(Player.class).info("String_Node_Str");
        load(true, item);
    }
    nextCachePreloader.start();
}

Output:
         log(Player.class).info("String_Node_Str");
-    } else if (nextMetadataCache.same(item)) {
-        set(true, nextMetadataCache);
+    } else if (valNext.same(item)) {
+        set(true, valNext);
         log(Player.class).info("String_Node_Str");


Input:
public void positionReached() {
    inProcess = false;
    if (worldObj.isRemote) {
        return;
    }
    int i = targetX;
    int j = targetY - 1;
    int k = targetZ;
    int blockId = worldObj.getBlockId(i, j, k);
    if (isQuarriableBlock(blockId, i, j, k)) {
        powerProvider.getTimeTracker().markTime(worldObj);
        ArrayList<ItemStack> stacks = BlockUtil.getItemStackFromBlock(worldObj, i, j, k);
        if (stacks != null) {
            for (ItemStack s : stacks) {
                if (s != null) {
                    mineStack(s);
                }
            }
        }
        worldObj.playAuxSFXAtEntity(null, 2001, i, j, k, blockId + (worldObj.getBlockMetadata(i, j, k) << 12));
        worldObj.setBlockWithNotify(i, j, k, 0);
    }
    double[] head = getHead();
    AxisAlignedBB axis = AxisAlignedBB.getBoundingBox(head[0] - 1.5, head[1], head[2] - 1.5, head[0] + 2.5, head[1] + 2.5, head[2] + 2.5);
    List result = worldObj.getEntitiesWithinAABB(EntityItem.class, axis);
    for (int ii = 0; ii < result.size(); ii++) {
        if (result.get(ii) instanceof EntityItem) {
            EntityItem entity = (EntityItem) result.get(ii);
            if (entity.isDead)
                continue;
            if (entity.item.stackSize <= 0)
                continue;
            CoreProxy.proxy.removeEntity(entity);
            mineStack(entity.item);
        }
    }
}

Output:
     int blockId = worldObj.getBlockId(i, j, k);
-    if (isQuarriableBlock(blockId, i, j, k)) {
+    if (isQuarriableBlock(i, j, k)) {
         powerProvider.getTimeTracker().markTime(worldObj);


Input:
public boolean isLock(RepositoryNode sourceNode) {
    boolean isLock = false;
    try {
        ProxyRepositoryFactory.getInstance().initialize();
    } catch (PersistenceException e) {
        e.printStackTrace();
    }
    IRepositoryViewObject objectToCopy = sourceNode.getObject();
    if (ProxyRepositoryFactory.getInstance().getStatus(objectToCopy) == ERepositoryStatus.LOCK_BY_USER) {
        isLock = true;
    }
    if (ProxyRepositoryFactory.getInstance().getStatus(objectToCopy) == ERepositoryStatus.LOCK_BY_OTHER) {
        isLock = true;
    }
    return isLock;
}

Output:
     } catch (PersistenceException e) {
-        e.printStackTrace();
+        ExceptionHandler.process(e);
     }


Input:
protected Map<String, Object> createProxyInstance2(long dataCenterId) throws ConcurrentOperationException {
    long id = _consoleProxyDao.getNextInSequence(Long.class, "String_Node_Str");
    String name = VirtualMachineName.getConsoleProxyName(id, _instance);
    DataCenterVO dc = _dcDao.findById(dataCenterId);
    Account systemAcct = _accountMgr.getSystemAccount();
    DataCenterDeployment plan = new DataCenterDeployment(dataCenterId);
    List<NetworkOfferingVO> defaultOffering = _networkMgr.getSystemAccountNetworkOfferings(NetworkOfferingVO.SystemVmPublicNetwork);
    List<NetworkOfferingVO> offerings = _networkMgr.getSystemAccountNetworkOfferings(NetworkOfferingVO.SystemVmControlNetwork, NetworkOfferingVO.SystemVmManagementNetwork);
    List<Pair<NetworkVO, NicProfile>> networks = new ArrayList<Pair<NetworkVO, NicProfile>>(offerings.size() + 1);
    NicProfile defaultNic = new NicProfile();
    defaultNic.setDefaultNic(true);
    defaultNic.setDeviceId(2);
    networks.add(new Pair<NetworkVO, NicProfile>(_networkMgr.setupNetwork(systemAcct, defaultOffering.get(0), plan, null, null, false).get(0), defaultNic));
    for (NetworkOfferingVO offering : offerings) {
        networks.add(new Pair<NetworkVO, NicProfile>(_networkMgr.setupNetwork(systemAcct, offering, plan, null, null, false).get(0), null));
    }
    ConsoleProxyVO proxy = new ConsoleProxyVO(id, _serviceOffering.getId(), name, _template.getId(), _template.getGuestOSId(), dataCenterId, systemAcct.getDomainId(), systemAcct.getId(), 0);
    try {
        proxy = _itMgr.allocate(proxy, _template, _serviceOffering, networks, plan, systemAcct);
    } catch (InsufficientCapacityException e) {
        s_logger.warn("String_Node_Str", e);
        throw new CloudRuntimeException("String_Node_Str", e);
    } catch (StorageUnavailableException e) {
        s_logger.warn("String_Node_Str", e);
        throw new CloudRuntimeException("String_Node_Str", e);
    } catch (ResourceUnavailableException e) {
        s_logger.warn("String_Node_Str", e);
        throw new CloudRuntimeException("String_Node_Str", e);
    }
    Map<String, Object> context = new HashMap<String, Object>();
    context.put("String_Node_Str", dc);
    HostPodVO pod = _podDao.findById(proxy.getPodId());
    context.put("String_Node_Str", pod);
    context.put("String_Node_Str", proxy.getId());
    return context;
}

Output:
     try {
-        proxy = _itMgr.allocate(proxy, _template, _serviceOffering, networks, plan, systemAcct);
+        proxy = _itMgr.allocate(proxy, _template, _serviceOffering, networks, plan, null, systemAcct);
     } catch (InsufficientCapacityException e) {


Input:
public static Path exportSubgraphToHDFSParallel(GraphDatabaseService db) throws IOException, URISyntaxException {
    FileSystem fs = FileUtil.getHadoopFileSystem();
    Path pt = new Path(ConfigurationLoader.getInstance().getHadoopHdfsUri() + EDGE_LIST_RELATIVE_FILE_PATH);
    BufferedWriter br = new BufferedWriter(new OutputStreamWriter(fs.create(pt)));
    Integer reportBlockSize = 20000;
    Transaction tx = db.beginTx();
    Iterable<Node> nodes = GlobalGraphOperations.at(db).getAllNodes();
    br.write("String_Node_Str" + "String_Node_Str");
    List<Spliterator<Node>> spliteratorList = new ArrayList<>();
    boolean hasSpliterator = true;
    Spliterator<Node> nodeSpliterator = nodes.spliterator();
    while (hasSpliterator) {
        Spliterator<Node> localSpliterator = nodeSpliterator.trySplit();
        hasSpliterator = localSpliterator != null;
        if (hasSpliterator)
            spliteratorList.add(localSpliterator);
    }
    tx.success();
    tx.close();
    counter = 0;
    if (spliteratorList.size() > 4) {
        ParallelWriter parallelWriter = new ParallelWriter(spliteratorList.toArray(new Spliterator[spliteratorList.size()]), 0, spliteratorList.size(), db, br, spliteratorList.size(), reportBlockSize, ConfigurationLoader.getInstance().getMazerunnerRelationshipType());
        ForkJoinPool pool = new ForkJoinPool();
        pool.invoke(parallelWriter);
    } else {
        spliteratorList.forEach(sl -> sl.forEachRemaining(n -> {
            try {
                writeBlockForNode(n, db, br, reportBlockSize, ConfigurationLoader.getInstance().getMazerunnerRelationshipType());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }));
    }
    System.out.println("String_Node_Str" + MessageFormat.format("String_Node_Str", 1.0));
    br.flush();
    br.close();
    return pt;
}

Output:
     FileSystem fs = FileUtil.getHadoopFileSystem();
-    Path pt = new Path(ConfigurationLoader.getInstance().getHadoopHdfsUri() + EDGE_LIST_RELATIVE_FILE_PATH);
+    Path pt = new Path(ConfigurationLoader.getInstance().getHadoopHdfsUri() + EDGE_LIST_RELATIVE_FILE_PATH.replace("String_Node_Str", "String_Node_Str"));
     BufferedWriter br = new BufferedWriter(new OutputStreamWriter(fs.create(pt)));


Input:
private void updateForSpends(Transaction tx, boolean fromChain) throws VerificationException {
    checkState(lock.isLocked());
    for (TransactionInput input : tx.getInputs()) {
        TransactionInput.ConnectionResult result = input.connect(unspent, TransactionInput.ConnectMode.ABORT_ON_CONFLICT);
        if (result == TransactionInput.ConnectionResult.NO_SUCH_TX) {
            result = input.connect(spent, TransactionInput.ConnectMode.ABORT_ON_CONFLICT);
            if (result == TransactionInput.ConnectionResult.NO_SUCH_TX) {
                result = input.connect(pending, TransactionInput.ConnectMode.ABORT_ON_CONFLICT);
                if (result == TransactionInput.ConnectionResult.NO_SUCH_TX) {
                    continue;
                }
            }
        }
        if (result == TransactionInput.ConnectionResult.ALREADY_SPENT) {
            if (fromChain) {
            } else {
                log.warn("String_Node_Str", tx.getHashAsString());
                log.warn("String_Node_Str", tx.getInputs().indexOf(input));
            }
        } else if (result == TransactionInput.ConnectionResult.SUCCESS) {
            Transaction connected = checkNotNull(input.getOutpoint().fromTx);
            maybeMoveTxToSpent(connected, "String_Node_Str");
        }
    }
    if (fromChain) {
        for (Transaction pendingTx : pending.values()) {
            for (TransactionInput input : pendingTx.getInputs()) {
                TransactionInput.ConnectionResult result = input.connect(tx, TransactionInput.ConnectMode.ABORT_ON_CONFLICT);
                checkState(result != TransactionInput.ConnectionResult.ALREADY_SPENT);
                if (result == TransactionInput.ConnectionResult.SUCCESS) {
                    log.info("String_Node_Str", pendingTx.getHashAsString(), pendingTx.getInputs().indexOf(input));
                }
            }
        }
    }
}

Output:
             Transaction connected = checkNotNull(input.getOutpoint().fromTx);
-            maybeMoveTxToSpent(connected, "String_Node_Str");
+            maybeMovePool(connected, "String_Node_Str");
         }


Input:
private Point getLargeIconSize() {
    int w;
    int h;
    if (Build.VERSION.SDK_INT >= 11) {
        w = context.getResources().getDimensionPixelSize(android.R.dimen.notification_large_icon_width);
        h = context.getResources().getDimensionPixelSize(android.R.dimen.notification_large_icon_height);
    } else {
        w = h = context.getResources().getDimensionPixelSize(android.R.dimen.app_icon_size);
    }
    return new Point(w, h);
}

Output:
     } else {
-        w = h = context.getResources().getDimensionPixelSize(android.R.dimen.app_icon_size);
+        w = context.getResources().getDimensionPixelSize(android.R.dimen.app_icon_size);
+        h = w;
     }


Input:
public static Map<String, List> getTableSummaries() throws TException {
    CachingBlurClient client = Config.getCachingBlurClient();
    List<Map<String, Object>> summaries = new ArrayList<Map<String, Object>>();
    List<String> clusters = client.shardClusterList();
    for (String cluster : clusters) {
        List<String> tables = client.tableListByCluster(cluster);
        for (String table : tables) {
            Map<String, Object> tableInfo = new HashMap<String, Object>();
            TableDescriptor descriptor = client.describe(table);
            tableInfo.put("String_Node_Str", cluster);
            tableInfo.put("String_Node_Str", table);
            tableInfo.put("String_Node_Str", descriptor.isEnabled());
            if (descriptor.isEnabled()) {
                TableStats stats = client.tableStats(table);
                tableInfo.put("String_Node_Str", stats.getRowCount());
                tableInfo.put("String_Node_Str", stats.getRecordCount());
                Schema schema = client.schema(table);
                tableInfo.put("String_Node_Str", new ArrayList<String>(schema.getFamilies().keySet()));
            } else {
                tableInfo.put("String_Node_Str", "String_Node_Str");
                tableInfo.put("String_Node_Str", "String_Node_Str");
                tableInfo.put("String_Node_Str", new ArrayList<String>());
            }
            summaries.add(tableInfo);
        }
    }
    Map<String, List> data = new HashMap<String, List>();
    data.put("String_Node_Str", summaries);
    data.put("String_Node_Str", clusters);
    return data;
}

Output:
             tableInfo.put("String_Node_Str", table);
-            tableInfo.put("String_Node_Str", descriptor.isEnabled());
-            if (descriptor.isEnabled()) {
-                TableStats stats = client.tableStats(table);
-                tableInfo.put("String_Node_Str", stats.getRowCount());
-                tableInfo.put("String_Node_Str", stats.getRecordCount());
-                Schema schema = client.schema(table);
-                tableInfo.put("String_Node_Str", new ArrayList<String>(schema.getFamilies().keySet()));
-            } else {
-                tableInfo.put("String_Node_Str", "String_Node_Str");
-                tableInfo.put("String_Node_Str", "String_Node_Str");
-                tableInfo.put("String_Node_Str", new ArrayList<String>());
+            try {
+                TableDescriptor descriptor = client.describe(table);
+                tableInfo.put("String_Node_Str", descriptor.isEnabled());
+                tableInfo.put("String_Node_Str", descriptor.isReadOnly());
+                if (descriptor.isEnabled()) {
+                    TableStats stats = client.tableStats(table);
+                    tableInfo.put("String_Node_Str", stats.getRowCount());
+                    tableInfo.put("String_Node_Str", stats.getRecordCount());
+                    Schema schema = client.schema(table);
+                    tableInfo.put("String_Node_Str", new ArrayList<String>(schema.getFamilies().keySet()));
+                } else {
+                    tableInfo.put("String_Node_Str", "String_Node_Str");
+                    tableInfo.put("String_Node_Str", "String_Node_Str");
+                    tableInfo.put("String_Node_Str", new ArrayList<String>());
+                }
+            } catch (Exception e) {
+                tableInfo.put("String_Node_Str", e.getMessage());
             }


Input:
protected void changeDomTree(final TreeParent pObject, String filter) {
    String modelDisplay = dataModelCombo.getText();
    if (modelDisplay.length() == 0)
        return;
    this.dataModelName = modelDisplay;
    XtentisPort port = null;
    try {
        port = Util.getPort(pObject);
    } catch (XtentisException e3) {
        log.error(e3.getMessage(), e3);
    } catch (Exception e3) {
        log.error(e3.getMessage(), e3);
    }
    WSDataModel wsDataModel = null;
    try {
        wsDataModel = port.getDataModel(new WSGetDataModel(new WSDataModelPK(dataModelName)));
    } catch (RemoteException e2) {
        log.error(e2.getMessage(), e2);
    }
    try {
        String schema = wsDataModel.getXsdSchema();
        XSDSchema xsd = Util.createXsdSchema(schema, pObject);
        provideViwerContent(xsd, filter);
    } catch (Exception e1) {
        log.error(e1.getMessage(), e1);
    }
}

Output:
     WSDataModel wsDataModel = null;
-    try {
-        wsDataModel = port.getDataModel(new WSGetDataModel(new WSDataModelPK(dataModelName)));
-    } catch (RemoteException e2) {
-        log.error(e2.getMessage(), e2);
-    }
-    try {
-        String schema = wsDataModel.getXsdSchema();
-        XSDSchema xsd = Util.createXsdSchema(schema, pObject);
+    String schema = null;
+    XSDSchema xsd = null;
+    if (port == null) {
+        xsd = MDMRepositoryViewExtensionService.getDataModelXsd(pObject, filter, dataModelName);
         provideViwerContent(xsd, filter);


Input:
protected <K, V> ICache<?, ?> getCacheUnchecked(String cacheName) {
    final String cacheNameWithPrefix = getCacheNameWithPrefix(cacheName);
    ICache<?, ?> cache = caches.get(cacheNameWithPrefix);
    if (cache == null) {
        CacheConfig<K, V> cacheConfig = null;
        if (cacheConfig == null) {
            cacheConfig = getCacheConfigFromPartition(cacheNameWithPrefix, cacheName);
        }
        if (cacheConfig == null) {
            return null;
        }
        final ICache<K, V> cacheProxy = createCacheProxy(cacheConfig);
        final ICache<?, ?> iCache = caches.putIfAbsent(cacheNameWithPrefix, cacheProxy);
        cache = iCache != null ? iCache : cacheProxy;
    }
    return cache;
}

Output:
     if (cache == null) {
-        CacheConfig<K, V> cacheConfig = null;
-        if (cacheConfig == null) {
-            cacheConfig = getCacheConfigFromPartition(cacheNameWithPrefix, cacheName);
-        }
+        CacheConfig<K, V> cacheConfig = getCacheConfigFromPartition(cacheNameWithPrefix, cacheName);
         if (cacheConfig == null) {


Input:
public void e_on_obstacle(int x, int y) {
    Entity actor = WorldModel.get_tile(x, y).get_actor();
    if (actor != null && owner.get_combat() != null) {
        owner.get_combat().inflict_damage(actor);
    }
}

Output:
 public void e_on_obstacle(int x, int y) {
-    Entity actor = WorldModel.get_tile(x, y).get_actor();
+    Entity actor = WorldModel.getWorldLayer(Player.get_zindex()).get_tile(x, y).get_actor();
     if (actor != null && owner.get_combat() != null) {


Input:
public static boolean isFuel(int itemDamage) {
    return itemDamage == 0;
}

Output:
 public static boolean isFuel(int itemDamage) {
-    return itemDamage == 0;
+    return itemDamage == 0 || itemDamage == 3;
 }


Input:
public static boolean isWithinShield(Location loc) {
    for (Integer id : getInstances(StockAbility.AirShield).keySet()) {
        AirShield ashield = (AirShield) getInstances(StockAbility.AirShield).get(id);
        if (ashield.player.getLocation().getWorld() != loc.getWorld())
            return false;
        if (ashield.player.getLocation().distance(loc) <= ashield.radius)
            return true;
    }
    return false;
}

Output:
     for (Integer id : getInstances(StockAbility.AirShield).keySet()) {
-        AirShield ashield = (AirShield) getInstances(StockAbility.AirShield).get(id);
+        AirShield ashield = (AirShield) getAbility(id);
         if (ashield.player.getLocation().getWorld() != loc.getWorld())


Input:
public String asDScriptListWithLevels() {
    String dScriptList = "String_Node_Str";
    if (this.isEmpty())
        return dScriptList;
    for (Entry<Enchantment, Integer> enchantment : this.entrySet()) dScriptList = dScriptList + enchantment.getKey().getName() + "String_Node_Str" + enchantment.getValue() + "String_Node_Str";
    return dScriptList.substring(1, dScriptList.length() - 1);
}

Output:
     for (Entry<Enchantment, Integer> enchantment : this.entrySet()) dScriptList = dScriptList + enchantment.getKey().getName() + "String_Node_Str" + enchantment.getValue() + "String_Node_Str";
-    return dScriptList.substring(1, dScriptList.length() - 1);
+    return dScriptList.substring(0, dScriptList.length() - 1);
 }


Input:
public void selectionChanged(SelectionChangedEvent e) {
    if (e.getSelection() != null) {
        m_addButton.setEnabled(true);
    }
}

Output:
 public void selectionChanged(SelectionChangedEvent e) {
-    if (e.getSelection() != null) {
+    if (e.getSelection() != null && !e.getSelection().isEmpty()) {
+        m_lastSel = e.getSelection();
         m_addButton.setEnabled(true);


Input:
public String toString() {
    String out = "String_Node_Str";
    Map<String, Integer> browsers = new HashMap<>();
    for (String key : browserMap.keySet()) {
        String browser = getBrowserType(key).toString();
        String version = getBrowserVersion(key);
        String platform = getPlatform(key).toString();
        if (version != null) {
            browser += version;
        }
        if (platform != null) {
            browser += platform;
        }
        if (browsers.containsKey(browser)) {
            int newCount = browsers.get(browser) + 1;
            browsers.put(browser, newCount);
        } else {
            browsers.put(browser, 1);
        }
    }
    for (String browser : browsers.keySet()) {
        int count = browsers.get(browser);
        if (!out.isEmpty()) {
            out += "String_Node_Str";
        }
        if (count > 1) {
            out += count + "String_Node_Str";
        }
        out += browser;
    }
    return out;
}

Output:
         String version = getBrowserVersion(key);
-        String platform = getPlatform(key).toString();
+        Platform platform = getPlatform(key);
         if (version != null) {


Input:
public UnmarshalRecord buildSelfRecord(UnmarshalRecord unmarshalRecord, Attributes atts) {
    try {
        Descriptor xmlDescriptor = (Descriptor) xmlCompositeObjectMapping.getReferenceDescriptor();
        if (null == xmlDescriptor) {
            xmlDescriptor = findReferenceDescriptor(null, unmarshalRecord, atts, xmlCompositeObjectMapping, xmlCompositeObjectMapping.getKeepAsElementPolicy());
        }
        if (xmlDescriptor != null) {
            if (xmlDescriptor.hasInheritance()) {
                unmarshalRecord.setAttributes(atts);
                Class clazz = xmlDescriptor.getInheritancePolicy().classFromRow(new org.eclipse.persistence.oxm.record.UnmarshalRecord(unmarshalRecord), unmarshalRecord.getSession());
                if (clazz == null) {
                    XPathQName leafElementType = unmarshalRecord.getLeafElementType();
                    if (leafElementType != null) {
                        Object indicator = xmlDescriptor.getInheritancePolicy().getClassIndicatorMapping().get(leafElementType);
                        if (indicator != null) {
                            clazz = (Class) indicator;
                        }
                    }
                }
                if (clazz != null) {
                    xmlDescriptor = (Descriptor) unmarshalRecord.getSession().getDescriptor(clazz);
                } else {
                    if (Modifier.isAbstract(xmlDescriptor.getJavaClass().getModifiers())) {
                        throw DescriptorException.missingClassIndicatorField(unmarshalRecord, (org.eclipse.persistence.oxm.XMLDescriptor) xmlDescriptor.getInheritancePolicy().getDescriptor());
                    }
                }
            }
            ObjectBuilder stob2 = (ObjectBuilder) xmlDescriptor.getObjectBuilder();
            org.eclipse.persistence.oxm.record.UnmarshalRecord wrapper = (org.eclipse.persistence.oxm.record.UnmarshalRecord) stob2.createRecord(unmarshalRecord.getSession());
            UnmarshalRecord childRecord = wrapper.getUnmarshalRecord();
            childRecord.setUnmarshaller(unmarshalRecord.getUnmarshaller());
            childRecord.setSelfRecord(true);
            unmarshalRecord.setChildRecord(childRecord);
            childRecord.setXMLReader(unmarshalRecord.getXMLReader());
            childRecord.startDocument();
            childRecord.initializeRecord(this.xmlCompositeObjectMapping);
            return childRecord;
        } else {
            return null;
        }
    } catch (SAXException e) {
        throw XMLMarshalException.unmarshalException(e);
    }
}

Output:
                 unmarshalRecord.setAttributes(atts);
-                Class clazz = xmlDescriptor.getInheritancePolicy().classFromRow(new org.eclipse.persistence.oxm.record.UnmarshalRecord(unmarshalRecord), unmarshalRecord.getSession());
+                Class clazz = ((ObjectBuilder) xmlDescriptor.getObjectBuilder()).classFromRow(unmarshalRecord, unmarshalRecord.getSession());
                 if (clazz == null) {


Input:
private String computeBooleanButtonLabel(String property, String label) {
    Boolean enabled = new Boolean(config.getProperty(property));
    return label + ((enabled) ? ON : OFF);
}

Output:
 private String computeBooleanButtonLabel(String property, String label) {
-    Boolean enabled = new Boolean(config.getProperty(property));
-    return label + ((enabled) ? ON : OFF);
+    String propertyValue = config.getProperty(property);
+    if (propertyValue.equals(InvTweaksConfig.VALUE_CI_COMPATIBILITY)) {
+        return label + DISABLE_CI;
+    } else {
+        Boolean enabled = new Boolean(propertyValue);
+        return label + ((enabled) ? ON : OFF);
+    }
 }


Input:
public void setLifeTime(int newLifeTime) {
    lifeTime = newLifeTime;
    if (lifetimeTimer != null) {
        lifetimeTimer.cancel();
    }
    lifetimeTimer = new Timer();
    lifetimeTimer.schedule(new ExpiryTask(this), lifeTime * 1000 + 2000);
}

Output:
     lifeTime = newLifeTime;
-    if (lifetimeTimer != null) {
-        lifetimeTimer.cancel();
+    if (ltExpiryFuture != null) {
+        ltExpiryFuture.cancel(true);
     }


Input:
private void layoutCraftingGrid() {
    int leftCol = 193;
    int topRow = 7;
    addSlotBox(SlotType.SLOT_GHOST, CONTAINER_INVENTORY, SLOT_CRAFTINPUT, leftCol, topRow, 3, 18, 3, 18);
    addSlot(SlotType.SLOT_GHOST, CONTAINER_INVENTORY, SLOT_CRAFTOUTPUT, leftCol, 65);
}

Output:
     addSlotBox(SlotType.SLOT_GHOST, CONTAINER_INVENTORY, SLOT_CRAFTINPUT, leftCol, topRow, 3, 18, 3, 18);
-    addSlot(SlotType.SLOT_GHOST, CONTAINER_INVENTORY, SLOT_CRAFTOUTPUT, leftCol, 65);
+    addSlot(SlotType.SLOT_GHOSTOUT, CONTAINER_INVENTORY, SLOT_CRAFTOUTPUT, leftCol, 65);
 }


Input:
public ReturnCode createConnection(IMetadataConnection metadataBean) {
    return metadataFiller.checkConnection(metadataBean);
}

Output:
 public ReturnCode createConnection(IMetadataConnection metadataBean) {
-    return metadataFiller.checkConnection(metadataBean);
+    return metadataFiller.createConnection(metadataBean);
 }


Input:
public Lock createLock() {
    return this.delegate.createLock();
}

Output:
 public Lock createLock() {
-    return this.delegate.createLock();
+    return delegate.createLock();
 }


Input:
public void onLayout(boolean changed, int left, int top, int right, int bottom) {
    super.onLayout(changed, left, top, right, bottom);
    if (!mRunning) {
        return;
    }
    clearCache();
    mCurrentSpec = mCellSizeChoices[mSizeChoice];
    LayoutSpec spec = mCurrentSpec;
    int oldColumnCount = spec.mColumns;
    int width = right - left;
    spec.mColumns = 1 + (width - spec.mCellWidth) / (spec.mCellWidth + spec.mCellSpacing);
    spec.mLeftEdgePadding = (width - ((spec.mColumns - 1) * spec.mCellSpacing) - (spec.mColumns * spec.mCellWidth)) / 2;
    spec.mRightEdgePadding = spec.mLeftEdgePadding;
    int rows = (mAllImages.getCount() + spec.mColumns - 1) / spec.mColumns;
    mMaxScrollY = spec.mCellSpacing + (rows * (spec.mCellSpacing + spec.mCellHeight)) - (bottom - top);
    if (mImageBlockManager == null) {
        mImageBlockManager = new ImageBlockManager(mLoader);
        mImageBlockManager.moveDataWindow(true);
    }
    mLayoutComplete = true;
    if (mListener != null)
        mListener.onLayout();
}

Output:
     if (mImageBlockManager == null) {
-        mImageBlockManager = new ImageBlockManager(mLoader);
+        mImageBlockManager = new ImageBlockManager();
         mImageBlockManager.moveDataWindow(true);


Input:
protected void createDataSetContents(Composite parent) {
    if (dataSetName != null) {
        Label lb = new Label(parent, SWT.NONE);
        lb.setText(Messages.getString("String_Node_Str"));
        GridData data = new GridData(GridData.FILL_HORIZONTAL);
        data.horizontalSpan = 2;
        lb.setLayoutData(data);
    } else {
        Label dateSetLabel = new Label(parent, SWT.NONE);
        dateSetLabel.setText(Messages.getString("String_Node_Str"));
        dataSetCombo = new Combo(parent, SWT.BORDER | SWT.READ_ONLY);
        dataSetCombo.setItems(getAvailableDatasetItems());
        dataSetCombo.select(0);
        GridData data = new GridData(GridData.FILL_HORIZONTAL);
        dataSetCombo.setLayoutData(data);
        dataSetCombo.setVisibleItemCount(30);
        dataSetCombo.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
                handleDatasetComboSelectedEvent();
            }
        });
    }
}

Output:
         dataSetCombo = new Combo(parent, SWT.BORDER | SWT.READ_ONLY);
-        dataSetCombo.setItems(getAvailableDatasetItems());
+        ModuleHandle handle = SessionHandleAdapter.getInstance().getReportDesignHandle();
+        datasets = org.eclipse.birt.report.designer.internal.ui.util.UIUtil.getVisibleDataSetHandles(handle);
+        for (int i = 0; i < datasets.size(); i++) {
+            dataSetCombo.add(datasets.get(i).getQualifiedName());
+        }
         dataSetCombo.select(0);


Input:
private void actionHierarchyChanged(Hierarchy hierarchy) {
    if (model == null || model.getInputConfig() == null) {
        return;
    }
    updateMinMax();
    if (hierarchy == null) {
        model.getInputConfig().removeHierarchy(attribute);
    } else {
        model.getInputConfig().setHierarchy(attribute, hierarchy);
    }
    model.getInputConfig().removeHierarchyBuilder(attribute);
    controller.update(new ModelEvent(ViewAttributeTransformation.this, ModelPart.HIERARCHY, hierarchy));
}

Output:
     updateMinMax();
-    if (hierarchy == null) {
+    if (hierarchy == null || hierarchy.getHierarchy() == null) {
         model.getInputConfig().removeHierarchy(attribute);


Input:
protected void agents() {
    Random randomGenerator = new Random();
    for (int i = 0; i < 10; i++) {
        addAgent(new TestPoliticalAgent(20, 2, AgentType.AC, randomGenerator.nextDouble(), randomGenerator.nextDouble()));
        addAgent(new TestPoliticalAgent(20, 2, AgentType.TFT, randomGenerator.nextDouble(), randomGenerator.nextDouble()));
        addAgent(new TestPoliticalAgent(20, 2, AgentType.AD, randomGenerator.nextDouble(), randomGenerator.nextDouble()));
        addAgent(new TestPoliticalAgent(20, 2, AgentType.R, randomGenerator.nextDouble(), randomGenerator.nextDouble()));
    }
}

Output:
     Random randomGenerator = new Random();
-    for (int i = 0; i < 10; i++) {
+    for (int i = 0; i < 40; i++) {
         addAgent(new TestPoliticalAgent(20, 2, AgentType.AC, randomGenerator.nextDouble(), randomGenerator.nextDouble()));


Input:
private Object getMissingMappingFromFML(boolean isBlock, String name, int i) {
    String modName = name.split("String_Node_Str")[0];
    if (Loader.isModLoaded(modName)) {
        try {
            FMLMissingMappingsEvent.MissingMapping mapping = new FMLMissingMappingsEvent.MissingMapping((isBlock ? '\u0001' : '\u0020') + name, i);
            ListMultimap<String, FMLMissingMappingsEvent.MissingMapping> missingMapping = ArrayListMultimap.create();
            missingMapping.put(modName, mapping);
            FMLMissingMappingsEvent event = new FMLMissingMappingsEvent(missingMapping);
            for (ModContainer container : Loader.instance().getModList()) {
                if (container instanceof FMLModContainer) {
                    event.applyModContainer(container);
                    ((FMLModContainer) container).handleModStateEvent(event);
                    if (mapping.getAction() != FMLMissingMappingsEvent.Action.DEFAULT) {
                        break;
                    }
                }
            }
            if (mapping.getAction() == FMLMissingMappingsEvent.Action.REMAP) {
                return mapping.getTarget();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return null;
}

Output:
         try {
-            FMLMissingMappingsEvent.MissingMapping mapping = new FMLMissingMappingsEvent.MissingMapping((isBlock ? '\u0001' : '\u0020') + name, i);
+            FMLMissingMappingsEvent.MissingMapping mapping = new FMLMissingMappingsEvent.MissingMapping(isBlock ? GameRegistry.Type.BLOCK : GameRegistry.Type.ITEM, name, i);
             ListMultimap<String, FMLMissingMappingsEvent.MissingMapping> missingMapping = ArrayListMultimap.create();


Input:
private Resource decrypt(final Resource value) throws InternalServerErrorException {
    try {
        return new Resource(value.getId(), value.getRevision(), null != value.getContent() ? service.decrypt(value.getContent()) : null);
    } catch (JsonException je) {
        throw new InternalServerErrorException(je);
    }
}

Output:
     try {
-        return new Resource(value.getId(), value.getRevision(), null != value.getContent() ? service.decrypt(value.getContent()) : null);
+        return new Resource(value.getId(), value.getRevision(), null != value.getContent() ? cryptoService.decrypt(value.getContent()) : null);
     } catch (JsonException je) {


Input:
public Object getObject() {
    if (object == null) {
        if (this.descriptor != null) {
            object = this.descriptor.wrapObjectInXMLRoot(this.rootRecord, this.unmarshaller.isResultAlwaysXMLRoot());
        } else if (documentBuilder != null) {
            Node node = documentBuilder.getDocument().getDocumentElement();
            Root root = new XMLRoot();
            root.setLocalName(node.getLocalName());
            root.setNamespaceURI(node.getNamespaceURI());
            root.setObject(node);
            object = root;
        } else {
            if (rootRecord != null) {
                object = this.rootRecord.getCurrentObject();
            }
        }
    }
    return this.object;
}

Output:
             Node node = documentBuilder.getDocument().getDocumentElement();
-            Root root = new XMLRoot();
+            Root root = unmarshaller.createRoot();
             root.setLocalName(node.getLocalName());


Input:
public void onCreate(RESTResource resource) {
    ServletHolder holder = new ServletHolder(new HTTPResourceContainer(resource));
    handler.addServletWithMapping(holder, resource.getPath());
    resource.addListener(this);
}

Output:
 public void onCreate(RESTResource resource) {
-    ServletHolder holder = new ServletHolder(new HTTPResourceContainer(resource));
-    handler.addServletWithMapping(holder, resource.getPath());
-    resource.addListener(this);
+    if (!isMapped(resource)) {
+        ServletHolder holder = new ServletHolder(new HTTPResourceContainer(resource));
+        handler.addServletWithMapping(holder, resource.getPath());
+        resource.addListener(this);
+        if (resource instanceof CollectionResource && !(resource instanceof IndexResource)) {
+            HttpServlet collectionContainer = new HTTPCollectionContainer((CollectionResource) resource);
+            ServletHolder collectionHolder = new ServletHolder(collectionContainer);
+            handler.addServletWithMapping(collectionHolder, resource.getPath() + "String_Node_Str");
+        }
+    }
 }


Input:
protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
    Log.i(TAG, "String_Node_Str" + requestCode + "String_Node_Str" + resultCode);
    switch(requestCode) {
        case REQUEST_CODE_DECRYPT_TITLE:
            if (resultCode == RESULT_OK && intent != null) {
                String decryptedText = intent.getStringExtra(CryptoIntents.EXTRA_TEXT);
                String encryptedText = intent.getStringExtra(PrivateNotePadIntents.EXTRA_ENCRYPTED_TEXT);
                if (encryptedText != null) {
                    NotesListCursor.mEncryptedStringHashMap.put(encryptedText, decryptedText);
                    Log.i(TAG, "String_Node_Str" + encryptedText + "String_Node_Str" + decryptedText);
                }
                mDecryptionSucceeded = true;
                NotesListCursor.mLoggedIn = true;
                decryptDelayed();
            } else {
                mDecryptionFailed = true;
                setProgressBarIndeterminateVisibility(false);
            }
            break;
        case REQUEST_CODE_OPEN:
            if (resultCode == RESULT_OK && intent != null) {
                File filename = FileUriUtils.getFile(intent.getData());
                if (filename.exists() && !filename.isDirectory()) {
                    Intent i = new Intent(this, NoteEditor.class);
                    i.setAction(Intent.ACTION_VIEW);
                    i.setData(intent.getData());
                    startActivity(i);
                } else {
                    Toast.makeText(this, R.string.file_not_found, Toast.LENGTH_SHORT).show();
                }
            }
            break;
    }
}

Output:
 protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
-    Log.i(TAG, "String_Node_Str" + requestCode + "String_Node_Str" + resultCode);
+    if (debug)
+        Log.i(TAG, "String_Node_Str" + requestCode + "String_Node_Str" + resultCode);
     switch(requestCode) {


Input:
public int compareTo(Location location) {
    int thisPos = -1;
    Annotation annotation = this.getAnnotation(new QName(GenBank.GBNAMESPACE, GenBank.POSITION, GenBank.GBPREFIX));
    if (annotation != null) {
        thisPos = Integer.parseInt(annotation.getStringValue());
    }
    int otherPos = -1;
    annotation = location.getAnnotation(new QName(GenBank.GBNAMESPACE, GenBank.POSITION, GenBank.GBPREFIX));
    if (annotation != null) {
        otherPos = Integer.parseInt(annotation.getStringValue());
    }
    if (thisPos != -1 && otherPos != -1) {
        int result = thisPos - otherPos;
        return result;
    }
    if (location instanceof Range) {
        int result = this.at - ((Range) location).getStart();
        if (result == 0) {
            result = ((Range) location).getEnd() - this.at;
        }
        return result;
    } else if (location instanceof Cut) {
        return this.at - ((Cut) location).getAt();
    }
    return this.at;
}

Output:
     if (annotation != null) {
-        thisPos = Integer.parseInt(annotation.getStringValue());
+        thisPos = Integer.parseInt(annotation.getStringValue().replace("String_Node_Str", "String_Node_Str"));
     }


Input:
public void buildContainerStyle(IContainerContent container, StringBuffer styleBuffer) {
    int display = ((Integer) containerDisplayStack.peek()).intValue();
    handleShrink(display, container.getStyle(), container.getHeight(), container.getWidth(), styleBuffer);
    setDisplayProperty(display, HTMLEmitterUtil.DISPLAY_INLINE_BLOCK, styleBuffer);
    IStyle style = getElementStyle(container);
    if (style == null) {
        return;
    }
    AttributeBuilder.buildFont(styleBuffer, style);
    AttributeBuilder.buildBox(styleBuffer, style);
    AttributeBuilder.buildBackground(styleBuffer, style, reportEmitter);
    AttributeBuilder.buildText(styleBuffer, style);
    AttributeBuilder.buildVisual(styleBuffer, style);
    AttributeBuilder.buildTextDecoration(styleBuffer, style);
}

Output:
     handleShrink(display, container.getStyle(), container.getHeight(), container.getWidth(), styleBuffer);
-    setDisplayProperty(display, HTMLEmitterUtil.DISPLAY_INLINE_BLOCK, styleBuffer);
+    if ((display & HTMLEmitterUtil.DISPLAY_NONE) > 0) {
+        styleBuffer.append("String_Node_Str");
+    } else if (((display & HTMLEmitterUtil.DISPLAY_INLINE) > 0) || ((display & HTMLEmitterUtil.DISPLAY_INLINE_BLOCK) > 0)) {
+        styleBuffer.append("String_Node_Str");
+    }
     IStyle style = getElementStyle(container);


Input:
public Object getValue(final String name) {
    return originalSession.getValue(name);
}

Output:
 public Object getValue(final String name) {
-    return originalSession.getValue(name);
+    return getAttribute(name);
 }


Input:
public void run() {
    logger.info("String_Node_Str");
    FeedbackPanel.this.btnRight.doClick();
}

Output:
     logger.info("String_Node_Str");
-    FeedbackPanel.this.btnRight.doClick();
+    Component c = MageFrame.getGame(gameId);
+    while (c != null && !(c instanceof GamePane)) {
+        c = c.getParent();
+    }
+    if (c != null && ((GamePane) c).isVisible()) {
+        FeedbackPanel.this.btnRight.doClick();
+    }
 }


Input:
private void copy(JournalFactory factory, RecordSource rs, JournalWriter w) throws JournalException {
    final CopyHelper helper = copyHelperCompiler.compile(rs.getMetadata(), w.getMetadata());
    final RecordCursor cursor = rs.prepareCursor(factory);
    while (cursor.hasNext()) {
        JournalEntryWriter ew = w.entryWriter();
        helper.copy(cursor.next(), ew);
        ew.append();
    }
    w.commit();
}

Output:
 private void copy(JournalFactory factory, RecordSource rs, JournalWriter w) throws JournalException {
-    final CopyHelper helper = copyHelperCompiler.compile(rs.getMetadata(), w.getMetadata());
-    final RecordCursor cursor = rs.prepareCursor(factory);
-    while (cursor.hasNext()) {
-        JournalEntryWriter ew = w.entryWriter();
-        helper.copy(cursor.next(), ew);
-        ew.append();
+    final int tsIndex = w.getMetadata().getTimestampIndex();
+    if (tsIndex == -1) {
+        copyNonPartitioned(rs.prepareCursor(factory), w, copyHelperCompiler.compile(rs.getMetadata(), w.getMetadata()));
+    } else {
+        copyPartitioned(rs.prepareCursor(factory), w, copyHelperCompiler.compile(rs.getMetadata(), w.getMetadata()), tsIndex);
     }


Input:
private void parseEvent(XMLEvent xmlEvent) throws SAXException {
    if (null == getContentHandler()) {
        return;
    }
    switch(xmlEvent.getEventType()) {
        case XMLEvent.ATTRIBUTE:
            {
                break;
            }
        case XMLEvent.CDATA:
            {
                Characters characters = xmlEvent.asCharacters();
                if (null == lexicalHandler) {
                    getContentHandler().characters(characters.getData().toCharArray(), 0, characters.getData().length());
                } else {
                    lexicalHandler.startCDATA();
                    getContentHandler().characters(characters.getData().toCharArray(), 0, characters.getData().length());
                    lexicalHandler.endCDATA();
                }
                break;
            }
        case XMLEvent.CHARACTERS:
            {
                Characters characters = xmlEvent.asCharacters();
                getContentHandler().characters(characters.getData().toCharArray(), 0, characters.getData().length());
                break;
            }
        case XMLEvent.COMMENT:
            {
                if (null != lexicalHandler) {
                    Comment comment = (Comment) xmlEvent;
                    lexicalHandler.comment(comment.getText().toCharArray(), 0, comment.getText().length());
                }
                break;
            }
        case XMLEvent.DTD:
            {
                break;
            }
        case XMLEvent.END_DOCUMENT:
            {
                depth--;
                return;
            }
        case XMLEvent.END_ELEMENT:
            {
                ArrayList declaredNs = this.namespaces.get(new Integer(depth));
                depth--;
                EndElement endElement = xmlEvent.asEndElement();
                QName name = endElement.getName();
                String prefix = endElement.getName().getPrefix();
                if (null == prefix || prefix.length() == 0) {
                    getContentHandler().endElement(name.getNamespaceURI(), name.getLocalPart(), name.getLocalPart());
                } else {
                    getContentHandler().endElement(name.getNamespaceURI(), name.getLocalPart(), prefix + XMLConstants.COLON + name.getLocalPart());
                }
                if (declaredNs != null) {
                    Iterator iter = declaredNs.iterator();
                    while (iter.hasNext()) {
                        Namespace next = (Namespace) iter.next();
                        getContentHandler().endPrefixMapping(next.getPrefix());
                    }
                }
                break;
            }
        case XMLEvent.ENTITY_DECLARATION:
            {
                break;
            }
        case XMLEvent.ENTITY_REFERENCE:
            {
                break;
            }
        case XMLEvent.NAMESPACE:
            {
                break;
            }
        case XMLEvent.NOTATION_DECLARATION:
            {
                break;
            }
        case XMLEvent.PROCESSING_INSTRUCTION:
            {
                ProcessingInstruction pi = (ProcessingInstruction) xmlEvent;
                getContentHandler().processingInstruction(pi.getTarget(), pi.getData());
                break;
            }
        case XMLEvent.SPACE:
            {
                char[] characters = xmlEvent.asCharacters().getData().toCharArray();
                getContentHandler().characters(characters, 0, characters.length);
                break;
            }
        case XMLEvent.START_DOCUMENT:
            {
                depth++;
                break;
            }
        case XMLEvent.START_ELEMENT:
            {
                depth++;
                StartElement startElement = xmlEvent.asStartElement();
                Iterator namespaces = startElement.getNamespaces();
                ArrayList<Namespace> declaredNs = null;
                if (namespaces.hasNext()) {
                    declaredNs = new ArrayList<Namespace>();
                }
                while (namespaces.hasNext()) {
                    Namespace next = (Namespace) namespaces.next();
                    getContentHandler().startPrefixMapping(next.getPrefix(), next.getNamespaceURI());
                    declaredNs.add(next);
                }
                if (declaredNs != null) {
                    this.namespaces.put(new Integer(depth), declaredNs);
                }
                QName qName = startElement.getName();
                String prefix = qName.getPrefix();
                if (null == prefix || prefix.length() == 0) {
                    getContentHandler().startElement(qName.getNamespaceURI(), qName.getLocalPart(), qName.getLocalPart(), new IndexedAttributeList(startElement.getAttributes(), startElement.getNamespaces()));
                } else {
                    getContentHandler().startElement(qName.getNamespaceURI(), qName.getLocalPart(), prefix + XMLConstants.COLON + qName.getLocalPart(), new IndexedAttributeList(startElement.getAttributes(), startElement.getNamespaces()));
                }
                break;
            }
    }
}

Output:
                 if (null == lexicalHandler) {
-                    getContentHandler().characters(characters.getData().toCharArray(), 0, characters.getData().length());
+                    contentHandler.characters(characters.getData().toCharArray(), 0, characters.getData().length());
                 } else {


Input:
public void test2() {
    RealInterval interval = new FinalRealInterval(new double[] { 7, 13 });
    double[] extents = IntervalUtils.getExtents(interval);
    assertEquals(6, extents[0], 0);
    assertEquals(12, extents[1], 0);
}

Output:
 public void test2() {
-    RealInterval interval = new FinalRealInterval(new double[] { 7, 13 });
-    double[] extents = IntervalUtils.getExtents(interval);
-    assertEquals(6, extents[0], 0);
-    assertEquals(12, extents[1], 0);
+    final RealInterval interval = new FinalRealInterval(new double[] { 0, 0 }, new double[] { 7, 13 });
+    final double[] extents = IntervalUtils.getExtents(interval);
+    assertEquals(7, extents[0], 0);
+    assertEquals(13, extents[1], 0);
 }


Input:
public CoinData createByTransferData(Transaction tx, CoinTransferData coinParam, String password) throws NulsException {
    UtxoData utxoData = new UtxoData();
    List<UtxoInput> inputs = new ArrayList<>();
    List<UtxoOutput> outputs = new ArrayList<>();
    if (coinParam.getTotalNa().equals(Na.ZERO)) {
        utxoData.setInputs(inputs);
        utxoData.setOutputs(outputs);
        return utxoData;
    }
    long inputValue = 0;
    if (!coinParam.getFrom().isEmpty()) {
        List<UtxoOutput> unSpends = coinManager.getAccountsUnSpend(coinParam.getFrom(), coinParam.getTotalNa().add(coinParam.getFee()));
        for (int i = 0; i < unSpends.size(); i++) {
            UtxoOutput output = unSpends.get(i);
            UtxoInput input = new UtxoInput();
            input.setFrom(output);
            inputs.add(input);
            input.setParent(tx);
            input.setIndex(i);
            inputValue += output.getValue();
        }
    }
    byte[] priKey = null;
    if (coinParam.getPriKey() != null) {
        priKey = coinParam.getPriKey();
    } else {
        Account account = accountService.getDefaultAccount();
        priKey = account.getPriSeed();
    }
    int i = 0;
    long outputValue = 0;
    for (Map.Entry<String, Coin> entry : coinParam.getToMap().entrySet()) {
        UtxoOutput output = new UtxoOutput();
        String address = entry.getKey();
        Coin coin = entry.getValue();
        output.setAddress(new Address(address).getHash());
        output.setValue(coin.getNa().getValue());
        output.setStatus(UtxoOutput.USEABLE);
        output.setIndex(i);
        output.setScript(ScriptBuilder.createOutputScript(ECKey.fromPrivate(new BigInteger(priKey))));
        output.setScriptBytes(output.getScript().getProgram());
        if (coin.getUnlockHeight() > 0) {
            output.setLockTime(coin.getUnlockHeight());
        } else if (coin.getUnlockTime() > 0) {
            output.setLockTime(coin.getUnlockTime());
        } else {
            output.setLockTime(0L);
        }
        output.setParent(tx);
        outputValue += output.getValue();
        outputs.add(output);
        i++;
    }
    long balance = inputValue - outputValue - coinParam.getFee().getValue();
    if (balance > 0) {
        UtxoOutput output = new UtxoOutput();
        output.setAddress(inputs.get(0).getFrom().getAddress());
        output.setValue(balance);
        output.setIndex(i);
        output.setParent(tx);
        output.setStatus(UtxoOutput.USEABLE);
        output.setScript(ScriptBuilder.createOutputScript(new ECKey()));
        output.setScriptBytes(output.getScript().getProgram());
        outputs.add(output);
    }
    utxoData.setInputs(inputs);
    utxoData.setOutputs(outputs);
    return utxoData;
}

Output:
     long outputValue = 0;
-    for (Map.Entry<String, Coin> entry : coinParam.getToMap().entrySet()) {
-        UtxoOutput output = new UtxoOutput();
+    for (Map.Entry<String, List<Coin>> entry : coinParam.getToMap().entrySet()) {
         String address = entry.getKey();


Input:
public boolean onCommand(CommandSender sender, Command command, String commandLabel, String[] args) {
    if (!(sender instanceof Player)) {
        sender.sendMessage(MessageUtils.mustBeIngameMessage);
        return true;
    }
    Player player = (Player) sender;
    HumanNPC npc = null;
    boolean returnval = false;
    if (NPCManager.validateSelected((Player) sender)) {
        npc = NPCManager.get(NPCManager.selectedNPCs.get(player.getName()));
    } else {
        sender.sendMessage(MessageUtils.mustHaveNPCSelectedMessage);
        return true;
    }
    if (!NPCManager.validateOwnership(player, npc.getUID())) {
        sender.sendMessage(MessageUtils.notOwnerMessage);
        return true;
    }
    if (!npc.isQuester()) {
        sender.sendMessage(ChatColor.RED + "String_Node_Str");
        return true;
    } else {
        if (args.length == 1 && args[0].equalsIgnoreCase("String_Node_Str")) {
            if (Permission.canUse(player, npc, "String_Node_Str")) {
                HelpUtils.sendQuesterHelp(sender);
            } else {
                sender.sendMessage(MessageUtils.noPermissionsMessage);
            }
            return true;
        } else if (args.length == 2 && args[0].contains("String_Node_Str")) {
            if (Permission.canModify(player, npc, "String_Node_Str")) {
                assignQuest(player, npc, args[1]);
            } else {
                sender.sendMessage(MessageUtils.noPermissionsMessage);
            }
            returnval = true;
        } else if (args.length == 2 && args[0].contains("String_Node_Str")) {
            if (Permission.canModify(player, npc, "String_Node_Str")) {
                removeQuest(player, npc, args[1]);
            } else {
                sender.sendMessage(MessageUtils.noPermissionsMessage);
            }
            returnval = true;
        }
        PropertyManager.save(npc);
    }
    return returnval;
}

Output:
         if (args.length == 1 && args[0].equalsIgnoreCase("String_Node_Str")) {
-            if (Permission.canUse(player, npc, "String_Node_Str")) {
+            if (Permission.canHelp(player, npc, "String_Node_Str")) {
                 HelpUtils.sendQuesterHelp(sender);


Input:
protected void setReindex() {
    reindex = true;
}

Output:
 protected void setReindex() {
-    reindex = true;
+    reindex = false;
 }


Input:
protected PreparedResult implement(RelDataType rowType, RelNode rootRel, SqlKind sqlKind) {
    RelDataType resultType = rootRel.getRowType();
    boolean isDml = sqlKind.belongsTo(SqlKind.DML);
    EnumerableRelImplementor relImplementor = getRelImplementor(rootRel.getCluster().getRexBuilder());
    ClassDeclaration expr = relImplementor.implementRoot((EnumerableRel) rootRel);
    String s = Expressions.toString(expr.memberDeclarations, "String_Node_Str", false);
    if (DEBUG) {
        System.out.println();
        System.out.println(s);
    }
    Hook.JAVA_PLAN.run(s);
    final Executable executable;
    try {
        executable = (Executable) ClassBodyEvaluator.createFastClassBodyEvaluator(new Scanner(null, new StringReader(s)), expr.name, Utilities.class, new Class[] { Executable.class, Typed.class }, getClass().getClassLoader());
    } catch (Exception e) {
        throw Helper.INSTANCE.wrap("String_Node_Str" + s, e);
    }
    if (timingTracer != null) {
        timingTracer.traceTime("String_Node_Str");
    }
    if (timingTracer != null) {
        timingTracer.traceTime("String_Node_Str");
    }
    return new PreparedResultImpl(resultType, fieldOrigins, rootRel, mapTableModOp(isDml, sqlKind), isDml) {
        public String getCode() {
            throw new UnsupportedOperationException();
        }
        public Object execute() {
            return executable.execute(schema);
        }
        public Type getElementType() {
            return ((Typed) executable).getElementType();
        }
    };
}

Output:
     EnumerableRelImplementor relImplementor = getRelImplementor(rootRel.getCluster().getRexBuilder());
-    ClassDeclaration expr = relImplementor.implementRoot((EnumerableRel) rootRel);
+    ClassDeclaration expr = relImplementor.implementRoot((EnumerableRel) rootRel, prefer);
     String s = Expressions.toString(expr.memberDeclarations, "String_Node_Str", false);


Input:
public void onClick(DialogInterface dialog, int which) {
    switch(which) {
        case DialogInterface.BUTTON_POSITIVE:
            if (mWhichDialog == DIALOG_RECEIVE_COMPLETE_SUCCESS) {
                BluetoothOppUtility.openReceivedFile(this, mTransInfo.mFileName, mTransInfo.mFileType, mTransInfo.mTimeStamp);
                BluetoothOppUtility.updateVisibilityToHidden(this, mUri);
                ((NotificationManager) getSystemService(NOTIFICATION_SERVICE)).cancel(mTransInfo.mID);
            } else if (mWhichDialog == DIALOG_SEND_COMPLETE_FAIL) {
                BluetoothOppUtility.updateVisibilityToHidden(this, mUri);
                ((NotificationManager) getSystemService(NOTIFICATION_SERVICE)).cancel(mTransInfo.mID);
                BluetoothOppUtility.retryTransfer(this, mTransInfo);
                BluetoothDevice remoteDevice = mAdapter.getRemoteDevice(mTransInfo.mDestAddr);
                Toast.makeText(this, this.getString(R.string.bt_toast_4, BluetoothOppManager.getInstance(this).getDeviceName(remoteDevice)), Toast.LENGTH_SHORT).show();
            } else if (mWhichDialog == DIALOG_SEND_COMPLETE_SUCCESS) {
                BluetoothOppUtility.updateVisibilityToHidden(this, mUri);
                ((NotificationManager) getSystemService(NOTIFICATION_SERVICE)).cancel(mTransInfo.mID);
            }
            break;
        case DialogInterface.BUTTON_NEGATIVE:
            if (mWhichDialog == DIALOG_RECEIVE_ONGOING || mWhichDialog == DIALOG_SEND_ONGOING) {
                this.getContentResolver().delete(mUri, null, null);
                String msg = "String_Node_Str";
                if (mWhichDialog == DIALOG_RECEIVE_ONGOING) {
                    msg = getString(R.string.bt_toast_3, mTransInfo.mDeviceName);
                } else if (mWhichDialog == DIALOG_SEND_ONGOING) {
                    msg = getString(R.string.bt_toast_6, mTransInfo.mDeviceName);
                }
                Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
                ((NotificationManager) getSystemService(NOTIFICATION_SERVICE)).cancel(mTransInfo.mID);
            } else if (mWhichDialog == DIALOG_SEND_COMPLETE_FAIL) {
                BluetoothOppUtility.updateVisibilityToHidden(this, mUri);
            }
            break;
    }
    finish();
}

Output:
             if (mWhichDialog == DIALOG_RECEIVE_COMPLETE_SUCCESS) {
-                BluetoothOppUtility.openReceivedFile(this, mTransInfo.mFileName, mTransInfo.mFileType, mTransInfo.mTimeStamp);
+                BluetoothOppUtility.openReceivedFile(this, mTransInfo.mFileName, mTransInfo.mFileType, mTransInfo.mTimeStamp, mUri);
                 BluetoothOppUtility.updateVisibilityToHidden(this, mUri);


Input:
protected void onListItemClick(ListView l, View v, int position, long id) {
    if (position == 0) {
        createNewMessage();
    } else if (v instanceof ConversationListItem) {
        ConversationListItem headerView = (ConversationListItem) v;
        ConversationListItemData ch = headerView.getConversationHeader();
        long threadId = ch.getThreadId();
        if (LogTag.VERBOSE) {
            Log.d(TAG, "String_Node_Str" + v + "String_Node_Str" + position + "String_Node_Str" + id + "String_Node_Str" + threadId);
        }
        openThread(threadId);
    }
}

Output:
         createNewMessage();
-    } else if (v instanceof ConversationListItem) {
-        ConversationListItem headerView = (ConversationListItem) v;
-        ConversationListItemData ch = headerView.getConversationHeader();
-        long threadId = ch.getThreadId();
+    } else {
+        Cursor cursor = (Cursor) getListView().getItemAtPosition(position);
+        Conversation conv = Conversation.from(this, cursor);
+        long tid = conv.getThreadId();
         if (LogTag.VERBOSE) {


Input:
public Action getAction(Observation o) {
    TetrisState tempState = new TetrisState();
    tempState.currentX = o.intArray[TetrisState.TETRIS_STATE_CURRENT_X_INDEX];
    tempState.currentY = o.intArray[TetrisState.TETRIS_STATE_CURRENT_Y_INDEX];
    tempState.currentRotation = o.intArray[TetrisState.TETRIS_STATE_CURRENT_ROTATION_INDEX];
    for (int p = 0; p < TetrisState.TETRIS_STATE_NUMBER_POSSIBLE_BLOCKS; p++) {
        if (o.intArray[tempState.worldState.length + p] == 1) {
            tempState.currentBlockId = p;
        }
    }
    for (int i = 0; i < tempState.worldState.length; i++) {
        tempState.worldState[i] = o.intArray[i];
    }
    boolean currentWatch = CommonConstants.watch;
    CommonConstants.watch = false;
    HashSet<Pair<TetrisState, ArrayList<Integer>>> tetrisStateHolder = TertisAfterStateGenerator.evaluateAfterStates(tempState);
    CommonConstants.watch = currentWatch;
    ArrayList<Pair<Double, Integer>> outputPairs = new ArrayList<Pair<Double, Integer>>();
    double[] outputs;
    for (Pair<TetrisState, ArrayList<Integer>> i : tetrisStateHolder) {
        double[] inputs = MMNEAT.rlGlueExtractor.extract(i.t1.get_observation());
        double[] inputsScaled = scaleInputs(inputs);
        outputs = this.consultPolicy(inputsScaled);
        Pair<Double, Integer> tempPair = new Pair<Double, Integer>(outputs[0], i.t2.get(0));
        outputPairs.add(tempPair);
    }
    double[] outputForArgmax = new double[outputPairs.size()];
    for (int i = 0; i < outputForArgmax.length; i++) {
        outputForArgmax[i] = outputPairs.get(1).t1;
    }
    int index = StatisticsUtilities.argmax(outputForArgmax);
    Action action = new Action(TSO.getNumDiscreteActionDims(), TSO.getNumContinuousActionDims());
    action.intArray[0] = outputPairs.get(index).t2;
    return action;
}

Output:
     for (int i = 0; i < outputForArgmax.length; i++) {
-        outputForArgmax[i] = outputPairs.get(1).t1;
+        outputForArgmax[i] = outputPairs.get(i).t1;
     }


Input:
public static Complex[] FFTComplexOut(double[] x, int order) {
    double[] realPart = FFTRealOut(x, order);
    double[] imagPart = FFTImagOut(x, order);
    return ComplexArrayMath.formArray(realPart, imagPart);
}

Output:
     double[] imagPart = FFTImagOut(x, order);
-    return ComplexArrayMath.formArray(realPart, imagPart);
+    return ComplexArrayMath.formComplexArray(realPart, imagPart);
 }


Input:
public static String formatFingerprint(String fingerprint) {
    if (fingerprint.length() != 62)
        return "String_Node_Str";
    String displayFP = fingerprint.substring(0, 2);
    for (int i = 2; i < fingerprint.length(); i = i + 2) displayFP += "String_Node_Str" + fingerprint.substring(i, i + 2);
    return displayFP;
}

Output:
 public static String formatFingerprint(String fingerprint) {
-    if (fingerprint.length() != 62)
+    if (fingerprint.length() != 64)
         return "String_Node_Str";


Input:
final void releaseTheme(int theme) {
    synchronized (this) {
        deleteTheme(theme);
        decRefsLocked();
    }
}

Output:
         deleteTheme(theme);
-        decRefsLocked();
+        decRefsLocked(theme);
     }


Input:
public static Object[] getChoiceSet(String property) {
    if (AttributeConstant.DATASET.equals(property)) {
        return getDataSets();
    }
    String unitKey = DesignChoiceConstants.CHOICE_UNITS;
    if (AttributeConstant.BACKGROUND_COLOR.equals(property)) {
        unitKey = IColorConstants.COLORS_CHOICE_SET;
    } else if (AttributeConstant.FONT_COLOR.equals(property)) {
        unitKey = IColorConstants.COLORS_CHOICE_SET;
    } else if (AttributeConstant.FONT_SIZE.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_FONT_SIZE;
    } else if (AttributeConstant.FONT_FAMILY.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_FONT_FAMILY;
    } else if (AttributeConstant.TEXT_FORMAT.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_CONTENT_TYPE;
    } else if (AttributeConstant.BORDER_STYLE.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_LINE_STYLE;
    } else if (AttributeConstant.BORDER_WIDTH.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_LINE_WIDTH;
    } else if (SortKey.DIRECTION_MEMBER.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_SORT_DIRECTION;
    } else if (FilterCondition.OPERATOR_MEMBER.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_FILTER_OPERATOR;
    } else if (StyleHandle.VERTICAL_ALIGN_PROP.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_VERTICAL_ALIGN;
    } else if (StyleHandle.TEXT_ALIGN_PROP.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_TEXT_ALIGN;
    } else if (MasterPageHandle.ORIENTATION_PROP.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_PAGE_ORIENTATION;
    } else if (MasterPageHandle.TYPE_PROP.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_PAGE_SIZE;
    } else if (GroupHandle.INTERVAL_PROP.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_INTERVAL;
    } else if (StyleHandle.PAGE_BREAK_BEFORE_PROP.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_PAGE_BREAK;
    } else if (StyleHandle.PAGE_BREAK_AFTER_PROP.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_PAGE_BREAK;
    } else if (StyleHandle.PAGE_BREAK_INSIDE_PROP.equals(property)) {
        unitKey = DesignChoiceConstants.CHOICE_PAGE_BREAK_INSIDE;
    }
    return getUnitChoiceSet(unitKey);
}

Output:
     } else if (AttributeConstant.TEXT_FORMAT.equals(property)) {
-        unitKey = DesignChoiceConstants.CHOICE_CONTENT_TYPE;
+        unitKey = DesignChoiceConstants.CHOICE_TEXT_CONTENT_TYPE;
     } else if (AttributeConstant.BORDER_STYLE.equals(property)) {


Input:
public static String checkUrl(String url) {
    if ((url != null) && (url.length() > 0)) {
        if ((!url.startsWith("String_Node_Str")) && (!url.startsWith("String_Node_Str")) && (!url.startsWith(Constants.URL_ABOUT_BLANK)) && (!url.startsWith(Constants.URL_ABOUT_START))) {
            url = "String_Node_Str" + url;
        }
    }
    return url;
}

Output:
     if ((url != null) && (url.length() > 0)) {
-        if ((!url.startsWith("String_Node_Str")) && (!url.startsWith("String_Node_Str")) && (!url.startsWith(Constants.URL_ABOUT_BLANK)) && (!url.startsWith(Constants.URL_ABOUT_START))) {
+        if ((!url.startsWith("String_Node_Str")) && (!url.startsWith("String_Node_Str")) && (!url.startsWith("String_Node_Str")) && (!url.startsWith(Constants.URL_ABOUT_BLANK)) && (!url.startsWith(Constants.URL_ABOUT_START))) {
             url = "String_Node_Str" + url;


Input:
private void discardChange(IResource res) throws IOException {
    IProject[] proj = new IProject[] { res.getProject() };
    Repository repository = getRepositoriesFor(proj)[0];
    String resRelPath = RepositoryMapping.getMapping(res).getRepoRelativePath(res);
    Entry e = repository.getIndex().getEntry(resRelPath);
    if (e != null && e.getStage() == 0 && e.isModified(repository.getWorkDir())) {
        repository.getIndex().checkoutEntry(repository.getWorkDir(), e);
        try {
            res.refreshLocal(0, new NullProgressMonitor());
        } catch (CoreException e1) {
            MessageDialog.openError(getShell(), UIText.DiscardChangesAction_refreshErrorTitle, UIText.DiscardChangesAction_refreshErrorMessage);
        }
        repository.getIndex().write();
    }
}

Output:
         } catch (CoreException e1) {
-            MessageDialog.openError(getShell(), UIText.DiscardChangesAction_refreshErrorTitle, UIText.DiscardChangesAction_refreshErrorMessage);
+            Activator.handleError(UIText.DiscardChangesAction_refreshErrorMessage, e1, true);
         }


Input:
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
    return scheduleWithFixedDelay(command, initialDelay, delay, unit);
}

Output:
 public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
-    return scheduleWithFixedDelay(command, initialDelay, delay, unit);
+    return executorService.scheduleWithFixedDelay(command, initialDelay, delay, unit);
 }


Input:
public void testSendsENTERKeyEventIfShiftIsNotPressedAndImeDoesNotHaveAction() {
    TestInputConnection inputConnection = (TestInputConnection) mAnySoftKeyboardUnderTest.getCurrentInputConnection();
    mAnySoftKeyboardUnderTest.simulateKeyPress(KeyCodes.ENTER);
    ArgumentCaptor<KeyEvent> keyEventArgumentCaptor = ArgumentCaptor.forClass(KeyEvent.class);
    Mockito.verify(inputConnection, Mockito.times(2)).sendKeyEvent(keyEventArgumentCaptor.capture());
    Assert.assertEquals(2, keyEventArgumentCaptor.getAllValues().size());
    Assert.assertEquals(KeyEvent.KEYCODE_ENTER, keyEventArgumentCaptor.getAllValues().get(0).getKeyCode());
    Assert.assertEquals(KeyEvent.ACTION_DOWN, keyEventArgumentCaptor.getAllValues().get(0).getAction());
    Assert.assertEquals(KeyEvent.KEYCODE_ENTER, keyEventArgumentCaptor.getAllValues().get(1).getKeyCode());
    Assert.assertEquals(KeyEvent.ACTION_UP, keyEventArgumentCaptor.getAllValues().get(1).getAction());
    Mockito.verify(inputConnection, Mockito.never()).commitText("String_Node_Str", 1);
}

Output:
     Assert.assertEquals(KeyEvent.ACTION_UP, keyEventArgumentCaptor.getAllValues().get(1).getAction());
-    Mockito.verify(inputConnection, Mockito.never()).commitText("String_Node_Str", 1);
+    Assert.assertEquals("String_Node_Str", inputConnection.getCurrentTextInInputConnection());
 }


Input:
public void renameFolder(DefaultMutableTreeNode treenode, MyFolder parent) {
    final JTextField name = new JTextField();
    name.addAncestorListener(new AncestorListener() {
        public void ancestorRemoved(AncestorEvent arg0) {
        }
        public void ancestorMoved(AncestorEvent arg0) {
        }
        public void ancestorAdded(AncestorEvent arg0) {
            name.requestFocusInWindow();
        }
    });
    name.setText(parent.toString());
    JPanel p = getPropPanel(name, null);
    int r = (Integer) CustomDialog.showDialog(p, JOptionPane.PLAIN_MESSAGE, JOptionPane.OK_CANCEL_OPTION, panel, "String_Node_Str", null);
    if (r == JOptionPane.OK_OPTION && (!name.getText().equals("String_Node_Str"))) {
        parent.getNode().setNodeValue(name.getText());
        ((DefaultTreeModel) tree.getModel()).nodeChanged(treenode);
        writeXML();
        uploadFile();
    }
}

Output:
     int r = (Integer) CustomDialog.showDialog(p, JOptionPane.PLAIN_MESSAGE, JOptionPane.OK_CANCEL_OPTION, panel, "String_Node_Str", null);
-    if (r == JOptionPane.OK_OPTION && (!name.getText().equals("String_Node_Str"))) {
+    if (r == JOptionPane.OK_OPTION) {
+        if (name.getText().equals("String_Node_Str")) {
+            CustomDialog.showInfo(JOptionPane.WARNING_MESSAGE, main, "String_Node_Str", "String_Node_Str");
+            return;
+        }
+        for (int i = 0; i < treenode.getParent().getChildCount(); i++) {
+            Object node = ((DefaultMutableTreeNode) treenode.getParent().getChildAt(i)).getUserObject();
+            if (node.getClass() == MyFolder.class && node != parent) {
+                if (((MyFolder) node).toString().equals(name.getText())) {
+                    CustomDialog.showInfo(JOptionPane.WARNING_MESSAGE, main, "String_Node_Str", "String_Node_Str");
+                    return;
+                }
+            }
+        }
         parent.getNode().setNodeValue(name.getText());


Input:
public static int getColumnIndex(ResultSetMetaData meta, String colName) throws SQLException {
    if (meta == null)
        return 0;
    int columnCount = meta.getColumnCount();
    for (int i = 1; i <= columnCount; i++) if (meta.getColumnName(i).equalsIgnoreCase(colName))
        return i;
    log.infof("String_Node_Str", colName);
    throw Lang.makeThrow(SQLException.class, "String_Node_Str", colName);
}

Output:
         return i;
-    log.infof("String_Node_Str", colName);
+    log.infof("String_Node_Str", colName, meta.getTableName(1));
     throw Lang.makeThrow(SQLException.class, "String_Node_Str", colName);


Input:
protected SessionHandle doOpenHiveSession(Map<String, String> sessionConf) throws HiveSQLException {
    try {
        return cliService.openSession(UserGroupInformation.getCurrentUser().getShortUserName(), "String_Node_Str", sessionConf);
    } catch (IOException e) {
        throw Throwables.propagate(e);
    }
}

Output:
 protected SessionHandle doOpenHiveSession(Map<String, String> sessionConf) throws HiveSQLException {
-    try {
-        return cliService.openSession(UserGroupInformation.getCurrentUser().getShortUserName(), "String_Node_Str", sessionConf);
-    } catch (IOException e) {
-        throw Throwables.propagate(e);
-    }
+    return cliService.openSession("String_Node_Str", "String_Node_Str", sessionConf);
 }


Input:
public void prepareForTrack() {
    resetSoft();
    mCurrentPlayer.reset(false);
    mCurrentPosition = 0;
    mState = PlaybackStateCompat.STATE_CONNECTING;
    notifyOnPlaybackStatusChanged(mState);
}

Output:
     mCurrentPosition = 0;
-    mState = PlaybackStateCompat.STATE_CONNECTING;
+    mState = PlaybackStateCompat.STATE_BUFFERING;
     notifyOnPlaybackStatusChanged(mState);


Input:
public Object decode(Class targetClass, Object fromDBObject, MappedField mf) throws MappingException {
    if (mf == null || fromDBObject == null)
        return fromDBObject;
    Class subtypeDest = mf.getSubClass();
    Collection vals = null;
    if (fromDBObject.getClass().isArray()) {
        vals = new ArrayList();
        for (Object o : (Object[]) fromDBObject) vals.add(chain.decode((subtypeDest != null) ? subtypeDest : o.getClass(), o));
    } else if (fromDBObject instanceof Iterable) {
        vals = createNewCollection(mf);
        for (Object o : (Iterable) fromDBObject) vals.add(chain.decode((subtypeDest != null) ? subtypeDest : o.getClass(), o));
    }
    if (mf.getType().isArray()) {
        return ReflectionUtils.convertToArray(subtypeDest, (ArrayList) vals);
    } else
        return vals;
}

Output:
     Class subtypeDest = mf.getSubClass();
-    Collection vals = null;
+    Collection vals = createNewCollection(mf);
     if (fromDBObject.getClass().isArray()) {


Input:
public static String getSimpleTestName() {
    String out = testName;
    if (out.indexOf("String_Node_Str") != -1) {
        out = out.substring(0, out.indexOf("String_Node_Str")) + "String_Node_Str";
    }
    return out;
}

Output:
     String out = testName;
-    if (out.indexOf("String_Node_Str") != -1) {
+    if (testName != null && out.indexOf("String_Node_Str") != -1) {
         out = out.substring(0, out.indexOf("String_Node_Str")) + "String_Node_Str";


Input:
private int getAction(CompositeStatementObject parentComposite, int i, CompositeStatementObject childComposite) {
    int action = PUSH_NEW_LIST;
    List<AbstractStatement> statements = new ArrayList<AbstractStatement>(parentComposite.getStatements());
    CompositeStatementObject parent = (CompositeStatementObject) statements.get(0).getParent();
    boolean isBlockWithoutCompositeParent = isBlockWithoutCompositeParent(parent);
    if (parent.getStatement() instanceof Block)
        parent = (CompositeStatementObject) parent.getParent();
    int position = i;
    while (parent != null && parent instanceof TryStatementObject) {
        CompositeStatementObject tryStatement = parent;
        CompositeStatementObject tryStatementParent = (CompositeStatementObject) tryStatement.getParent();
        List<AbstractStatement> tryParentStatements = new ArrayList<AbstractStatement>(tryStatementParent.getStatements());
        if (tryStatementParent.getStatement() instanceof Block)
            tryStatementParent = (CompositeStatementObject) tryStatementParent.getParent();
        int positionOfTryStatementInParent = 0;
        int j = 0;
        for (AbstractStatement statement : tryParentStatements) {
            if (statement.equals(tryStatement)) {
                positionOfTryStatementInParent = j;
                break;
            }
            j++;
        }
        if (((TryStatementObject) tryStatement).hasResources()) {
            tryParentStatements.addAll(positionOfTryStatementInParent + 1, statements);
        } else {
            tryParentStatements.remove(tryStatement);
            tryParentStatements.addAll(positionOfTryStatementInParent, statements);
        }
        statements = tryParentStatements;
        parent = tryStatementParent;
        if (((TryStatementObject) tryStatement).hasResources())
            position = positionOfTryStatementInParent + position + 1;
        else
            position = positionOfTryStatementInParent + position;
    }
    if (parent != null && parent.getStatement() instanceof SwitchStatement && parentComposite.getStatement() instanceof Block) {
        List<AbstractStatement> switchStatements = new ArrayList<AbstractStatement>(parent.getStatements());
        int positionOfBlockInParentSwitch = 0;
        int j = 0;
        for (AbstractStatement statement : switchStatements) {
            if (statement.equals(parentComposite)) {
                positionOfBlockInParentSwitch = j;
                break;
            }
            j++;
        }
        switchStatements.remove(parentComposite);
        switchStatements.addAll(positionOfBlockInParentSwitch, statements);
        statements = switchStatements;
        position = positionOfBlockInParentSwitch + position;
    }
    if (parent != null && isBlockWithoutCompositeParent) {
        List<AbstractStatement> blockStatements = new ArrayList<AbstractStatement>(parent.getStatements());
        int positionOfBlockInParent = 0;
        int j = 0;
        for (AbstractStatement statement : blockStatements) {
            if (statement.equals(parentComposite)) {
                positionOfBlockInParent = j;
                break;
            }
            j++;
        }
        blockStatements.remove(parentComposite);
        blockStatements.addAll(positionOfBlockInParent, statements);
        statements = blockStatements;
        position = positionOfBlockInParent + position;
    }
    if (statements.size() == 1) {
        action = JOIN_TOP_LIST;
        if (parent != null) {
            if (isLoop(parent) || parent.getStatement() instanceof DoStatement)
                action = PUSH_NEW_LIST;
        }
    } else if (statements.size() > 1) {
        AbstractStatement previousStatement = null;
        if (position >= 1)
            previousStatement = statements.get(position - 1);
        int j = 0;
        while (previousStatement != null && previousStatement instanceof TryStatementObject && !((TryStatementObject) previousStatement).hasResources()) {
            CompositeStatementObject tryStatement = (CompositeStatementObject) previousStatement;
            AbstractStatement firstStatement = tryStatement.getStatements().get(0);
            if (firstStatement instanceof CompositeStatementObject) {
                CompositeStatementObject tryBlock = (CompositeStatementObject) firstStatement;
                List<AbstractStatement> tryBlockStatements = tryBlock.getStatements();
                if (tryBlockStatements.size() > 0) {
                    previousStatement = tryBlockStatements.get(tryBlockStatements.size() - 1);
                } else {
                    if (position >= 2 + j)
                        previousStatement = statements.get(position - 2 - j);
                    else
                        previousStatement = null;
                }
            }
            j++;
        }
        while (previousStatement != null && isBlockWithoutCompositeParent(previousStatement)) {
            CompositeStatementObject block = (CompositeStatementObject) previousStatement;
            List<AbstractStatement> blockStatements = block.getStatements();
            if (blockStatements.size() > 0) {
                previousStatement = blockStatements.get(blockStatements.size() - 1);
            }
        }
        if (statements.get(statements.size() - 1).equals(childComposite)) {
            if (previousStatement != null && (previousStatement.getStatement() instanceof IfStatement || previousStatement.getStatement() instanceof SwitchStatement)) {
                action = JOIN_SECOND_FROM_TOP_LIST;
                if (parent != null && (isLoop(parent) || parent.getStatement() instanceof DoStatement))
                    action = PLACE_NEW_LIST_SECOND_FROM_TOP;
            } else {
                action = JOIN_TOP_LIST;
                if (parent != null && (isLoop(parent) || parent.getStatement() instanceof DoStatement))
                    action = PUSH_NEW_LIST;
            }
        } else {
            if (previousStatement != null && (previousStatement.getStatement() instanceof IfStatement || previousStatement.getStatement() instanceof SwitchStatement))
                action = PLACE_NEW_LIST_SECOND_FROM_TOP;
            else {
                action = PUSH_NEW_LIST;
            }
        }
    }
    return action;
}

Output:
     int position = i;
-    while (parent != null && parent instanceof TryStatementObject) {
+    while (parent != null && (parent instanceof TryStatementObject || parent instanceof SynchronizedStatementObject)) {
         CompositeStatementObject tryStatement = parent;


Input:
public void removeUser(ID id) {
    String name = getUserData(id);
    if (name != null) {
        final String str = makeChatLine("String_Node_Str" + name + "String_Node_Str" + LEFT_STRING);
        showText(new ChatLine(str));
    }
    myNames.remove(id);
    removeUserFromTree(id);
}

Output:
     if (name != null) {
-        final String str = makeChatLine("String_Node_Str" + name + "String_Node_Str" + LEFT_STRING);
+        final String str = makeChatLine(name + "String_Node_Str" + LEFT_STRING);
         showText(new ChatLine(str));


Input:
protected CompilationUnitProvider doFilterCompilationUnit(TreeLogger logger, String typeName, CompilationUnitProvider existing) throws UnableToCompleteException {
    if (typeName.equals("String_Node_Str")) {
        return cuMeta;
    }
    CompilationUnitProvider jsnified = injector.inject(logger, existing);
    return jsnified;
}

Output:
     if (typeName.equals("String_Node_Str")) {
-        return cuMeta;
+        try {
+            String source = Utility.getFileFromClassPath("String_Node_Str");
+            return new StaticCompilationUnitProvider("String_Node_Str", "String_Node_Str", source.toCharArray());
+        } catch (IOException e) {
+            logger.log(TreeLogger.ERROR, "String_Node_Str", e);
+            throw new UnableToCompleteException();
+        }
     }