Input:
private void runPairwise() {
    String name1 = params.getPdb1();
    String file1 = params.getFile1();
    if (name1 == null && file1 == null) {
        throw new RuntimeException("String_Node_Str");
    }
    if (file1 == null) {
        if (name1.length() < 4) {
            throw new RuntimeException("String_Node_Str");
        }
    }
    String name2 = params.getPdb2();
    String file2 = params.getFile2();
    if (name2 == null && file2 == null) {
        throw new RuntimeException("String_Node_Str");
    }
    if (file2 == null) {
        if (name2.length() < 4) {
            throw new RuntimeException("String_Node_Str");
        }
    }
    Structure structure1 = null;
    Structure structure2 = null;
    String path = params.getPdbFilePath();
    if (file1 == null || file2 == null) {
        if (path == null) {
            throw new RuntimeException("String_Node_Str");
        }
        AtomCache cache = new AtomCache(path, params.isPdbDirSplit());
        cache.setAutoFetch(params.isAutoFetch());
        structure1 = getStructure(cache, name1, file1);
        structure2 = getStructure(cache, name2, file2);
    } else {
        structure1 = getStructure(null, name1, file1);
        structure2 = getStructure(null, name2, file2);
    }
    if (structure1 == null) {
        System.err.println("String_Node_Str");
        return;
    }
    if (structure2 == null) {
        System.err.println("String_Node_Str");
        return;
    }
    try {
        Atom[] ca1;
        Atom[] ca2;
        List<Group> hetatms1 = new ArrayList<Group>();
        List<Group> nucs1 = new ArrayList<Group>();
        List<Group> hetatms2 = new ArrayList<Group>();
        List<Group> nucs2 = new ArrayList<Group>();
        ca1 = StructureTools.getAtomCAArray(structure1);
        ca2 = StructureTools.getAtomCAArray(structure2);
        if (params.isShow3d()) {
            hetatms1 = structure1.getChain(0).getAtomGroups("String_Node_Str");
            nucs1 = structure1.getChain(0).getAtomGroups("String_Node_Str");
        }
        StructureAlignment algorithm = getAlgorithm();
        Object jparams = getParameters();
        AFPChain afpChain;
        afpChain = algorithm.align(ca1, ca2, jparams);
        afpChain.setName1(name1);
        afpChain.setName2(name2);
        if (params.isShow3d()) {
            if ((afpChain.getBlockNum() - 1) == 0) {
                hetatms2 = structure2.getChain(0).getAtomGroups("String_Node_Str");
                nucs2 = structure2.getChain(0).getAtomGroups("String_Node_Str");
            }
            if (!GuiWrapper.isGuiModuleInstalled()) {
                System.err.println("String_Node_Str");
            } else {
                try {
                    Object jmol = GuiWrapper.display(afpChain, ca1, ca2, hetatms1, nucs1, hetatms2, nucs2);
                    GuiWrapper.showAlignmentImage(afpChain, ca1, ca2, jmol);
                } catch (Exception e) {
                    System.err.println(e.getMessage());
                    e.printStackTrace();
                }
            }
        }
        if (params.getOutFile() != null) {
            String output = null;
            if (params.isOutputPDB()) {
                if (!GuiWrapper.isGuiModuleInstalled()) {
                    System.err.println("String_Node_Str");
                    output = AFPChainXMLConverter.toXML(afpChain, ca1, ca2);
                } else {
                    Structure tmp = AFPAlignmentDisplay.createArtificalStructure(afpChain, ca1, ca2);
                    output = "String_Node_Str" + afpChain.getAlgorithmName() + "String_Node_Str" + afpChain.getVersion() + "String_Node_Str";
                    output += afpChain.getName1() + "String_Node_Str" + afpChain.getName2();
                    output += newline;
                    output += tmp.toPDB();
                }
            } else {
                output = AFPChainXMLConverter.toXML(afpChain, ca1, ca2);
            }
            FileOutputStream out;
            PrintStream p;
            try {
                out = new FileOutputStream(params.getOutFile());
                p = new PrintStream(out);
                p.println(output);
                p.close();
            } catch (Exception e) {
                System.err.println("String_Node_Str" + params.getOutFile());
            }
        }
        if (params.isPrintXML()) {
            String fatcatXML = AFPChainXMLConverter.toXML(afpChain, ca1, ca2);
            System.out.println(fatcatXML);
        }
        if (params.isPrintFatCat()) {
            System.out.println(afpChain.toFatcat(ca1, ca2));
        }
        if (params.isPrintCE()) {
            System.out.println(afpChain.toCE(ca1, ca2));
        }
    } catch (Exception e) {
        e.printStackTrace();
        return;
    }
}

Output:
                 try {
-                    Object jmol = GuiWrapper.display(afpChain, ca1, ca2, hetatms1, nucs1, hetatms2, nucs2);
+                    Object jmol = GuiWrapper.display(afpChain, ca1, ca2);
                     GuiWrapper.showAlignmentImage(afpChain, ca1, ca2, jmol);


Input:
public boolean isAutosave() {
    return true;
}

Output:
 public boolean isAutosave() {
-    return true;
+    return autosave;
 }


Input:
public void deleteIfUnused(String inventory) {
    String[] parts = inventory.split("String_Node_Str");
    if (parts[0].matches("String_Node_Str")) {
        if (parts.length != 2 || this.sharesMap.containsKey(parts[1])) {
            inventories.remove(inventory);
            debugger.debugEvent(MultiInvEvent.INVENTORY_DELETE, new String[] { inventory });
        }
    }
}

Output:
     String[] parts = inventory.split("String_Node_Str");
-    if (parts[0].matches("String_Node_Str")) {
+    if (parts[1].matches("String_Node_Str")) {
         if (parts.length != 2 || this.sharesMap.containsKey(parts[1])) {


Input:
void disconnectWithReason(PE_TaskPriority disconnectPriority_nullable, ConnectionFailListener.Status connectionFailReasonIfConnecting, Timing timing, int gattStatus, int bondFailReason, ReadWriteListener.ReadWriteEvent txnFailReason) {
    if (isNull())
        return;
    final boolean cancelled = connectionFailReasonIfConnecting != null && connectionFailReasonIfConnecting.wasCancelled();
    final boolean explicit = connectionFailReasonIfConnecting != null && connectionFailReasonIfConnecting.wasExplicit();
    final BleDeviceState highestState = BleDeviceState.getTransitoryConnectionState(getStateMask());
    if (explicit) {
        m_reconnectMngr_shortTerm.stop();
    }
    if (cancelled) {
        m_useAutoConnect = m_alwaysUseAutoConnect;
        m_connectionFailMngr.onExplicitDisconnect();
    }
    final boolean wasConnecting = is_internal(CONNECTING_OVERALL);
    final boolean attemptingReconnect_longTerm = cancelled ? false : is(RECONNECTING_LONG_TERM);
    E_Intent intent = cancelled ? E_Intent.INTENTIONAL : E_Intent.UNINTENTIONAL;
    m_lastConnectOrDisconnectWasUserExplicit = intent == E_Intent.INTENTIONAL;
    final boolean cancellableFromConnect = BleDeviceConfig.bool(conf_device().disconnectIsCancellable, conf_mngr().disconnectIsCancellable);
    final boolean tryBondingWhileDisconnected = connectionFailReasonIfConnecting == Status.BONDING_FAILED && BleDeviceConfig.bool(conf_device().tryBondingWhileDisconnected, conf_mngr().tryBondingWhileDisconnected);
    final boolean underwentPossibleImplicitBondingAttempt = m_nativeWrapper.isNativelyUnbonded() && m_underwentPossibleImplicitBondingAttempt == true;
    final boolean taskIsCancellable = cancellableFromConnect == true && tryBondingWhileDisconnected == false && underwentPossibleImplicitBondingAttempt == false;
    {
        saveLastDisconnect(explicit);
        final boolean saveLastDisconnectAfterTaskCompletes = connectionFailReasonIfConnecting != Status.ROGUE_DISCONNECT;
        final int taskOrdinal;
        final boolean clearQueue;
        if (isAny_internal(CONNECTED, CONNECTING_OVERALL, INITIALIZED)) {
            final P_Task_Disconnect disconnectTask = new P_Task_Disconnect(this, m_taskStateListener, true, disconnectPriority_nullable, taskIsCancellable, saveLastDisconnectAfterTaskCompletes);
            queue().add(disconnectTask);
            taskOrdinal = disconnectTask.getOrdinal();
            clearQueue = true;
        } else {
            taskOrdinal = -1;
            clearQueue = false;
        }
        final Object[] overrideBondingStates = m_bondMngr.getOverrideBondStatesForDisconnect(connectionFailReasonIfConnecting);
        final boolean forceMainStateTracker = explicit;
        setStateToDisconnected(attemptingReconnect_longTerm, intent, gattStatus, forceMainStateTracker, overrideBondingStates);
        m_txnMngr.cancelAllTransactions();
        if (clearQueue) {
            queue().clearQueueOf(PA_Task_RequiresConnection.class, this, taskOrdinal);
        }
        if (!attemptingReconnect_longTerm) {
            m_reconnectMngr_longTerm.stop();
        }
    }
    if (wasConnecting) {
        if (getManager().ASSERT(connectionFailReasonIfConnecting != null)) {
            m_connectionFailMngr.onConnectionFailed(connectionFailReasonIfConnecting, timing, attemptingReconnect_longTerm, gattStatus, bondFailReason, highestState, ConnectionFailListener.AutoConnectUsage.NOT_APPLICABLE, txnFailReason);
        }
    }
}

Output:
         }
-        final Object[] overrideBondingStates = m_bondMngr.getOverrideBondStatesForDisconnect(connectionFailReasonIfConnecting);
-        final boolean forceMainStateTracker = explicit;
-        setStateToDisconnected(attemptingReconnect_longTerm, intent, gattStatus, forceMainStateTracker, overrideBondingStates);
-        m_txnMngr.cancelAllTransactions();
-        if (clearQueue) {
-            queue().clearQueueOf(PA_Task_RequiresConnection.class, this, taskOrdinal);
-        }
-        if (!attemptingReconnect_longTerm) {
-            m_reconnectMngr_longTerm.stop();
-        }
-    }
-    if (wasConnecting) {
-        if (getManager().ASSERT(connectionFailReasonIfConnecting != null)) {
-            m_connectionFailMngr.onConnectionFailed(connectionFailReasonIfConnecting, timing, attemptingReconnect_longTerm, gattStatus, bondFailReason, highestState, ConnectionFailListener.AutoConnectUsage.NOT_APPLICABLE, txnFailReason);
-        }
-    }
+    });
 }


Input:
public List<PageNavigation> getNavigations() throws Exception {
    WebuiRequestContext context = WebuiRequestContext.getCurrentInstance();
    List<PageNavigation> result = new ArrayList<PageNavigation>();
    if (context.getRemoteUser() != null) {
        result.add(PageNavigationUtils.filter(getSelectedNavigation(), context.getRemoteUser()));
    } else {
        for (PageNavigation nav : Util.getUIPortal().getNavigations()) {
            if (!showUserNavigation && nav.getOwnerType().equals("String_Node_Str"))
                continue;
            result.add(PageNavigationUtils.filter(nav, null));
        }
    }
    return result;
}

Output:
     } else {
-        for (PageNavigation nav : Util.getUIPortal().getNavigations()) {
+        for (PageNavigation nav : Util.getUIPortalApplication().getNavigations()) {
             if (!showUserNavigation && nav.getOwnerType().equals("String_Node_Str"))


Input:
protected HearthTreeNode notifyCardPlayBegin(HearthTreeNode boardState, Deck deckPlayer0, Deck deckPlayer1, boolean singleRealizationOnly) throws HSException {
    HearthTreeNode toRet = boardState;
    ArrayList<CardPlayBeginInterface> matches = new ArrayList<CardPlayBeginInterface>();
    for (Card card : toRet.data_.getCurrentPlayerHand()) {
        if (card instanceof CardPlayBeginInterface) {
            matches.add((CardPlayBeginInterface) card);
        }
    }
    Card hero = toRet.data_.getCurrentPlayerHero();
    if (hero instanceof CardPlayBeginInterface) {
        matches.add((CardPlayBeginInterface) hero);
    }
    for (Minion minion : PlayerSide.CURRENT_PLAYER.getPlayer(toRet).getMinions()) {
        if (!minion.isSilenced()) {
            if (minion instanceof CardPlayBeginInterface) {
                matches.add((CardPlayBeginInterface) minion);
            }
        }
    }
    for (CardPlayBeginInterface match : matches) {
        toRet = match.onCardPlayBegin(PlayerSide.CURRENT_PLAYER, PlayerSide.CURRENT_PLAYER, this, toRet, deckPlayer0, deckPlayer1, singleRealizationOnly);
    }
    matches.clear();
    for (Card card : toRet.data_.getWaitingPlayerHand()) {
        if (card instanceof CardPlayBeginInterface) {
            matches.add((CardPlayBeginInterface) card);
        }
    }
    hero = toRet.data_.getWaitingPlayerHero();
    if (hero instanceof CardPlayBeginInterface) {
        matches.add((CardPlayBeginInterface) hero);
    }
    for (Minion minion : PlayerSide.WAITING_PLAYER.getPlayer(toRet).getMinions()) {
        if (!minion.isSilenced()) {
            if (minion instanceof CardPlayBeginInterface) {
                matches.add((CardPlayBeginInterface) minion);
            }
        }
    }
    for (CardPlayBeginInterface match : matches) {
        toRet = match.onCardPlayBegin(PlayerSide.WAITING_PLAYER, PlayerSide.CURRENT_PLAYER, this, toRet, deckPlayer0, deckPlayer1, singleRealizationOnly);
    }
    toRet = BoardStateFactoryBase.handleDeadMinions(toRet, deckPlayer0, deckPlayer1);
    return toRet;
}

Output:
     for (Minion minion : PlayerSide.CURRENT_PLAYER.getPlayer(toRet).getMinions()) {
-        if (!minion.isSilenced()) {
-            if (minion instanceof CardPlayBeginInterface) {
-                matches.add((CardPlayBeginInterface) minion);
-            }
+        if (!minion.isSilenced() && minion instanceof CardPlayBeginInterface) {
+            matches.add((CardPlayBeginInterface) minion);
         }


Input:
public static ConsumerEndpoint createUnconfiguredEndpoint(Properties props, String resourcePath) {
    logger.debug("String_Node_Str");
    String resourceId = null;
    String pattern = "String_Node_Str";
    Pattern regex = Pattern.compile(pattern);
    Matcher m = regex.matcher(resourcePath);
    if (m.find()) {
        resourcePath = m.group(1);
        resourceId = m.group(2).substring(0, m.group(2).length() - 1);
        logger.info("String_Node_Str", resourcePath, resourceId);
    } else {
        resourcePath = resourcePath.replaceAll("String_Node_Str", "String_Node_Str");
    }
    String clientId = props.getProperty(Constants.CONSUMER_PROPS_ID_CLIENT);
    ConsumerEndpoint endpoint = new ConsumerEndpoint(resourcePath, clientId, "String_Node_Str");
    endpoint.setResourceId(resourceId);
    if (!ConsumerGatewayUtil.setConsumerMember(endpoint) || !ConsumerGatewayUtil.setProducerMember(endpoint)) {
        endpoint = null;
    } else {
        String ns = props.getProperty(Constants.ENDPOINT_PROPS_SERVICE_NAMESPACE_SERIALIZE);
        String prefix = props.getProperty(Constants.ENDPOINT_PROPS_SERVICE_NAMESPACE_PREFIX_SERIALIZE);
        endpoint.getProducer().setNamespaceUrl(ns);
        endpoint.getProducer().setNamespacePrefix(prefix);
    }
    return endpoint;
}

Output:
     Pattern regex = Pattern.compile(pattern);
-    Matcher m = regex.matcher(resourcePath);
+    Matcher m = regex.matcher(pathToResource);
     if (m.find()) {


Input:
public CommandEvent readEvent(int timeout, TimeUnit unit) throws Exception {
    checkConnected();
    connection.setReadTimeout((int) unit.toMillis(timeout));
    InputStream bytesIn = connection.getInputStream();
    CharsetDecoder decoder = UTF_8.newDecoder();
    BufferedReader textIn = new BufferedReader(new InputStreamReader(bytesIn, decoder));
    String eventType = textIn.readLine();
    switch(eventType.charAt(0)) {
        case 'P':
            if ("String_Node_Str".equals(eventType)) {
                return readPreparedEvent(textIn);
            }
            break;
        case 'S':
            if ("String_Node_Str".equals(eventType)) {
                return readStartedEvent(textIn);
            }
            break;
        case 'E':
            if ("String_Node_Str".equals(eventType)) {
                return readErrorEvent(textIn);
            }
            break;
        case 'F':
            if ("String_Node_Str".equals(eventType)) {
                return readFinishedEvent(textIn);
            }
            break;
    }
    throw new IllegalStateException("String_Node_Str" + eventType);
}

Output:
             if ("String_Node_Str".equals(eventType)) {
-                return readPreparedEvent(textIn);
+                return readPreparedEvent();
             }


Input:
public List<VpnUserVO> searchForVpnUsers(ListVpnUsersCmd cmd) {
    String username = cmd.getUsername();
    Long id = cmd.getId();
    Account caller = UserContext.current().getCaller();
    List<Long> permittedAccounts = new ArrayList<Long>();
    Ternary<Long, Boolean, ListProjectResourcesCriteria> domainIdRecursiveListProject = new Ternary<Long, Boolean, ListProjectResourcesCriteria>(cmd.getDomainId(), cmd.isRecursive(), null);
    _accountMgr.buildACLSearchParameters(caller, id, cmd.getAccountName(), cmd.getProjectId(), permittedAccounts, domainIdRecursiveListProject, cmd.listAll());
    Long domainId = domainIdRecursiveListProject.first();
    Boolean isRecursive = domainIdRecursiveListProject.second();
    ListProjectResourcesCriteria listProjectResourcesCriteria = domainIdRecursiveListProject.third();
    Filter searchFilter = new Filter(VpnUserVO.class, "String_Node_Str", true, cmd.getStartIndex(), cmd.getPageSizeVal());
    SearchBuilder<VpnUserVO> sb = _vpnUsersDao.createSearchBuilder();
    _accountMgr.buildACLSearchBuilder(sb, domainId, isRecursive, permittedAccounts, listProjectResourcesCriteria);
    sb.and("String_Node_Str", sb.entity().getId(), SearchCriteria.Op.EQ);
    sb.and("String_Node_Str", sb.entity().getUsername(), SearchCriteria.Op.EQ);
    sb.and("String_Node_Str", sb.entity().getState(), SearchCriteria.Op.EQ);
    SearchCriteria<VpnUserVO> sc = sb.create();
    _accountMgr.buildACLSearchCriteria(sc, domainId, isRecursive, permittedAccounts, listProjectResourcesCriteria);
    sc.setParameters("String_Node_Str", State.Active);
    if (id != null) {
        sc.setParameters("String_Node_Str", id);
    }
    if (username != null) {
        sc.setParameters("String_Node_Str", username);
    }
    return _vpnUsersDao.search(sc, searchFilter);
}

Output:
     Ternary<Long, Boolean, ListProjectResourcesCriteria> domainIdRecursiveListProject = new Ternary<Long, Boolean, ListProjectResourcesCriteria>(cmd.getDomainId(), cmd.isRecursive(), null);
-    _accountMgr.buildACLSearchParameters(caller, id, cmd.getAccountName(), cmd.getProjectId(), permittedAccounts, domainIdRecursiveListProject, cmd.listAll());
+    _accountMgr.buildACLSearchParameters(caller, id, cmd.getAccountName(), cmd.getProjectId(), permittedAccounts, domainIdRecursiveListProject, cmd.listAll(), false);
     Long domainId = domainIdRecursiveListProject.first();


Input:
public synchronized void create(final NamespaceMeta metadata) throws Exception {
    Preconditions.checkArgument(metadata != null, "String_Node_Str");
    NamespaceId namespace = new NamespaceId(metadata.getName());
    if (exists(namespace.toId())) {
        throw new NamespaceAlreadyExistsException(namespace.toId());
    }
    if (hasCustomMapping(metadata)) {
        validateCustomMapping(metadata);
    }
    Principal principal = authenticationContext.getPrincipal();
    authorizationEnforcer.enforce(instanceId, principal, Action.ADMIN);
    privilegesManager.grant(namespace, principal, ImmutableSet.of(Action.ALL));
    if (SecurityUtil.isKerberosEnabled(cConf)) {
        ImpersonationInfo impersonationInfo = new ImpersonationInfo(metadata, cConf);
        String namespacePrincipal = impersonationInfo.getPrincipal();
        String namespaceUserName = new KerberosName(namespacePrincipal).getShortName();
        Principal namespaceUser = new Principal(namespaceUserName, Principal.PrincipalType.USER);
        privilegesManager.grant(namespace, namespaceUser, EnumSet.allOf(Action.class));
    }
    nsStore.create(metadata);
    try {
        impersonator.doAs(metadata, new Callable<Void>() {
            public Void call() throws Exception {
                storageProviderNamespaceAdmin.create(metadata);
                return null;
            }
        });
    } catch (IOException | ExploreException | SQLException e) {
        nsStore.delete(metadata.getNamespaceId().toId());
        privilegesManager.revoke(namespace);
        throw new NamespaceCannotBeCreatedException(namespace.toId(), e);
    }
}

Output:
     authorizationEnforcer.enforce(instanceId, principal, Action.ADMIN);
-    privilegesManager.grant(namespace, principal, ImmutableSet.of(Action.ALL));
+    privilegesManager.grant(namespace, principal, EnumSet.allOf(Action.class));
     if (SecurityUtil.isKerberosEnabled(cConf)) {


Input:
public Object getPushData() {
    ArrayList<Object> pushData = new ArrayList<Object>();
    for (Option option : config.settings.options) {
        if (option.isPicked) {
            pushData.add(option.getPushData());
        }
    }
    return pushData;
}

Output:
     ArrayList<Object> pushData = new ArrayList<Object>();
-    for (Option option : config.settings.options) {
-        if (option.isPicked) {
-            pushData.add(option.getPushData());
+    if (config != null && config.settings != null && config.settings.options != null) {
+        for (Option option : config.settings.options) {
+            if (option.isPicked) {
+                pushData.add(option.getPushData());
+            }
         }


Input:
protected Map<String, String> getKeysFromIamRole() {
    try {
        String query = "String_Node_Str" + roleName;
        URL url = new URL("String_Node_Str", IAM_ROLE_ENDPOINT, query);
        InputStreamReader is = new InputStreamReader(url.openStream(), "String_Node_Str");
        BufferedReader reader = new BufferedReader(is);
        Map<String, String> map = parseIamRole(reader);
        return map;
    } catch (IOException io) {
        throw new InvalidConfigurationException("String_Node_Str");
    }
}

Output:
         URL url = new URL("String_Node_Str", IAM_ROLE_ENDPOINT, query);
-        InputStreamReader is = new InputStreamReader(url.openStream(), "String_Node_Str");
-        BufferedReader reader = new BufferedReader(is);
-        Map<String, String> map = parseIamRole(reader);
-        return map;
+        BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream(), "String_Node_Str"));
+        return parseIamRole(reader);
     } catch (IOException io) {


Input:
protected void doSearch(UserRequest ureq, String search, List<String> condQueries) {
    if (dataSource != null) {
        resetInternComponents();
        dataSource.clear();
        dataSource.search(search, condQueries, 0, getPageSize());
    }
}

Output:
         dataSource.clear();
-        dataSource.search(search, condQueries, 0, getPageSize());
+        ResultInfos<?> infos = dataSource.load(search, conditionalQueries, 0, getPageSize(), orderBy);
+        System.out.println("String_Node_Str" + infos.getObjects().size());
     }


Input:
public PostmarkResponse sendMessage(PostmarkMessage message) throws PostmarkException {
    HttpClient httpClient = new DefaultHttpClient();
    PostmarkResponse theResponse = new PostmarkResponse();
    try {
        HttpPost method = new HttpPost("String_Node_Str");
        method.addHeader("String_Node_Str", "String_Node_Str");
        method.addHeader("String_Node_Str", "String_Node_Str");
        method.addHeader("String_Node_Str", serverToken);
        method.addHeader("String_Node_Str", "String_Node_Str");
        message.validate();
        message.clean();
        Gson gson = gsonBuilder.create();
        String messageContents = gson.toJson(message);
        logger.info("String_Node_Str" + messageContents);
        StringEntity payload = new StringEntity(messageContents);
        method.setEntity(payload);
        ResponseHandler<String> responseHandler = new BasicResponseHandler();
        try {
            String response = httpClient.execute(method, responseHandler);
            logger.info("String_Node_Str" + response);
            theResponse = gsonBuilder.create().fromJson(response, PostmarkResponse.class);
            theResponse.status = PostmarkStatus.SUCCESS;
        } catch (HttpResponseException hre) {
            switch(hre.getStatusCode()) {
                case 401:
                case 422:
                    logger.log(Level.SEVERE, "String_Node_Str" + hre.getMessage());
                    theResponse.setMessage(hre.getMessage());
                    theResponse.status = PostmarkStatus.USERERROR;
                    throw new PostmarkException(hre.getMessage(), theResponse);
                case 500:
                    logger.log(Level.SEVERE, "String_Node_Str" + hre.getMessage());
                    theResponse.setMessage(hre.getMessage());
                    theResponse.status = PostmarkStatus.SERVERERROR;
                    throw new PostmarkException(hre.getMessage(), theResponse);
                default:
                    logger.log(Level.SEVERE, "String_Node_Str" + hre.getMessage());
                    theResponse.status = PostmarkStatus.UNKNOWN;
                    theResponse.setMessage(hre.getMessage());
                    throw new PostmarkException(hre.getMessage(), theResponse);
            }
        }
    } catch (Exception e) {
        logger.log(Level.SEVERE, "String_Node_Str" + e.getMessage());
        throw new PostmarkException(e);
    } finally {
        httpClient.getConnectionManager().shutdown();
    }
    return theResponse;
}

Output:
         logger.info("String_Node_Str" + messageContents);
-        StringEntity payload = new StringEntity(messageContents);
+        StringEntity payload = new StringEntity(messageContents, "String_Node_Str");
         method.setEntity(payload);


Input:
public void toController(OFMessage msg, FloodlightContext cntx) {
    if (ofcch == null) {
        return;
    }
    log.debug("String_Node_Str" + msg.getType());
    int xid = msg.getXid();
    switch(msg.getType()) {
        case PACKET_IN:
            OFPacketIn pcktIn = (OFPacketIn) msg;
            OFMatch match = new OFMatch();
            if (pcktIn.getPacketData().length <= 0) {
                log.debug("String_Node_Str");
                return;
            }
            match.loadFromPacket(pcktIn.getPacketData(), pcktIn.getInPort());
            OFFlowMod flowMod = new OFFlowMod();
            flowMod.setMatch(match);
            List<OFFlowMod> allowed = this.mySlicer.allowedFlows(flowMod);
            if (allowed.size() == 0) {
                log.debug("String_Node_Str" + this.mySlicer.getSliceName());
                return;
            }
            if (this.packetInRate.okToProcess()) {
                this.mySlicer.addBufferId(pcktIn.getBufferId(), pcktIn.getPacketData());
                if (this.mySlicer.getTagManagement()) {
                    log.debug("String_Node_Str");
                    Ethernet newPkt = new Ethernet();
                    byte[] pktData = pcktIn.getPacketData();
                    newPkt.deserialize(pktData, 0, pktData.length);
                    newPkt.setEtherType(newPkt.getEtherType());
                    newPkt.setVlanID(Ethernet.VLAN_UNTAGGED);
                    byte[] newPktData = newPkt.serialize();
                    pcktIn.setPacketData(newPktData);
                    pcktIn.setTotalLength((short) newPktData.length);
                }
                break;
            } else {
                log.error("String_Node_Str" + this.getSlicer().getSliceName() + "String_Node_Str" + this.getSlicer().getSwitchName() + "String_Node_Str");
                this.setAdminStatus(false);
                return;
            }
        case PORT_STATUS:
            OFPortStatus portStatus = (OFPortStatus) msg;
            OFPhysicalPort port = portStatus.getDesc();
            if (!this.mySlicer.isPortPartOfSlice(port.getName())) {
                log.debug("String_Node_Str" + this.getSlicer().getSwitchName() + "String_Node_Str" + port.getName() + "String_Node_Str" + this.mySlicer.getSliceName());
                return;
            }
            switch(OFPortReason.fromReasonCode(portStatus.getReason())) {
                case OFPPR_ADD:
                    this.mySlicer.setPortId(port.getName(), port.getPortNumber());
                    break;
                case OFPPR_MODIFY:
                    break;
                case OFPPR_DELETE:
                    break;
            }
            break;
        case ERROR:
            if (xidMap.containsKey(xid)) {
                msg.setXid(xidMap.get(xid));
                xidMap.remove(xid);
                OFError error = (OFError) msg;
                OFMessage error_msg = null;
                try {
                    error_msg = error.getOffendingMsg();
                } catch (MessageParseException e) {
                    log.error("String_Node_Str");
                    break;
                }
                if (error_msg == null) {
                    break;
                }
                switch(error_msg.getType()) {
                    case FLOW_MOD:
                        OFFlowMod mod = (OFFlowMod) error_msg;
                        switch(mod.getCommand()) {
                            case OFFlowMod.OFPFC_ADD:
                                this.flowCount--;
                                break;
                            case OFFlowMod.OFPFC_DELETE:
                                this.flowCount++;
                                break;
                            case OFFlowMod.OFPFC_DELETE_STRICT:
                                this.flowCount++;
                                break;
                            default:
                                break;
                        }
                        break;
                    default:
                        break;
                }
            } else {
                return;
            }
            break;
        case FLOW_REMOVED:
            OFFlowRemoved removedFlow = (OFFlowRemoved) msg;
            OFFlowMod mod = new OFFlowMod();
            mod.setMatch(removedFlow.getMatch());
            List<OFFlowMod> flows = mySlicer.allowedFlows(mod);
            if (flows.size() == 0) {
                return;
            }
            if (mySlicer.getTagManagement()) {
                mod.getMatch().setDataLayerVirtualLan((short) 0);
                mod.getMatch().getWildcardObj().wildcard(Wildcards.Flag.DL_VLAN);
                List<OFAction> acts = mod.getActions();
                List<OFAction> newActs = new ArrayList<OFAction>();
                int length = 0;
                for (OFAction act : acts) {
                    switch(act.getType()) {
                        case SET_VLAN_ID:
                            break;
                        case STRIP_VLAN:
                            break;
                        default:
                            newActs.add(act);
                            length += act.getLengthU();
                    }
                }
                mod.setActions(newActs);
                mod.setLength((short) (OFFlowMod.MINIMUM_LENGTH + length));
                msg = mod;
            }
            this.flowCount--;
            break;
        case BARRIER_REPLY:
            if (xidMap.containsKey(xid)) {
                msg.setXid(xidMap.get(xid));
                xidMap.removeToKey(xid);
            } else {
                return;
            }
            break;
        case ECHO_REQUEST:
            return;
        default:
            log.debug("String_Node_Str" + msg.getType());
            break;
    }
    try {
        ofcch.sendMessage(msg);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

Output:
             if (mySlicer.getTagManagement()) {
-                mod.getMatch().setDataLayerVirtualLan((short) 0);
-                mod.getMatch().getWildcardObj().wildcard(Wildcards.Flag.DL_VLAN);
-                List<OFAction> acts = mod.getActions();
-                List<OFAction> newActs = new ArrayList<OFAction>();
-                int length = 0;
-                for (OFAction act : acts) {
-                    switch(act.getType()) {
-                        case SET_VLAN_ID:
-                            break;
-                        case STRIP_VLAN:
-                            break;
-                        default:
-                            newActs.add(act);
-                            length += act.getLengthU();
-                    }
-                }
-                mod.setActions(newActs);
-                mod.setLength((short) (OFFlowMod.MINIMUM_LENGTH + length));
-                msg = mod;
+                removedFlow.getMatch().setDataLayerVirtualLan((short) 0);
+                removedFlow.getMatch().getWildcardObj().wildcard(Wildcards.Flag.DL_VLAN);
+                msg = removedFlow;
             }


Input:
protected boolean playerHasTooManyWolves(Player player) {
    if (plugin.maxWolves == -1)
        return false;
    int numWolves = 0;
    for (Entity entity : player.getWorld().getEntities()) {
        if (entity instanceof Wolf) {
            Wolf wolf = (Wolf) entity;
            if (wolf.isTamed() && wolf.getOwner().equals(player)) {
                numWolves++;
            }
        }
    }
    return (numWolves >= plugin.maxWolves);
}

Output:
             Wolf wolf = (Wolf) entity;
-            if (wolf.isTamed() && wolf.getOwner().equals(player)) {
-                numWolves++;
+            if (wolf.isTamed() && wolf.getOwner() instanceof Player) {
+                Player owner = (Player) wolf.getOwner();
+                if (owner.equals(player)) {
+                    numWolves++;
+                }
             }


Input:
public Optional<ISeedStorageControllable> getControllable(ItemStack stack) {
    TileEntity te = this.getTileEntity();
    if (te instanceof ISeedStorageController) {
        return ((ISeedStorageController) te).getControllable(stack);
    } else if (te instanceof ISeedStorageControllable) {
        return Optional.of((ISeedStorageControllable) te);
    } else {
        return Optional.empty();
    }
}

Output:
 public Optional<ISeedStorageControllable> getControllable(ItemStack stack) {
-    TileEntity te = this.getTileEntity();
-    if (te instanceof ISeedStorageController) {
-        return ((ISeedStorageController) te).getControllable(stack);
-    } else if (te instanceof ISeedStorageControllable) {
-        return Optional.of((ISeedStorageControllable) te);
+    if (this.tile instanceof ISeedStorageController) {
+        return ((ISeedStorageController) this.tile).getControllable(stack);
+    } else if (this.tile instanceof ISeedStorageControllable) {
+        return Optional.of((ISeedStorageControllable) tile);
     } else {


Input:
static void setBalance(String name, double balance) {
    if (!hasAccount(name)) {
        createAccount(name, balance, 0);
        return;
    }
    if (useMiniDB() || useInventoryDB() || useOrbDB()) {
        if (useInventoryDB())
            if (inventory.dataExists(name)) {
                inventory.setBalance(name, balance);
                return;
            }
        if (useOrbDB()) {
            Player gainer = iConomy.Server.getPlayer(name);
            if (gainer != null) {
                for (int i = 0; i < balance; i++) gainer.setExperience(i);
                return;
            }
        }
        if (database.hasIndex(name)) {
            database.setArgument(name, "String_Node_Str", balance);
            database.update();
        }
        return;
    }
    try {
        QueryRunner run = new QueryRunner();
        Connection c = iConomy.Database.getConnection();
        try {
            String t = Constants.Nodes.DatabaseTable.toString();
            int update = run.update(c, "String_Node_Str" + t + "String_Node_Str", balance, name.toLowerCase());
        } catch (SQLException ex) {
            System.out.println("String_Node_Str" + ex);
        } finally {
            DbUtils.close(c);
        }
    } catch (SQLException ex) {
        System.out.println("String_Node_Str" + ex);
    }
}

Output:
             if (gainer != null) {
-                for (int i = 0; i < balance; i++) gainer.setExperience(i);
+                gainer.setTotalExperience((int) balance);
                 return;


Input:
public void processAction(ActionRequest req, ActionResponse resp) throws PortletException, IOException {
    dumpParameters(req);
    String[] vals = req.getParameterValues(PARAM_FG_COLOR);
    String r = "String_Node_Str";
    String g = "String_Node_Str";
    String b = "String_Node_Str";
    if (vals != null) {
        for (String v : vals) {
            if (v.equals(PARAM_FG_RED))
                r = "String_Node_Str";
            if (v.equals(PARAM_FG_GREEN))
                g = "String_Node_Str";
            if (v.equals(PARAM_FG_BLUE))
                b = "String_Node_Str";
        }
    }
    String clr = "String_Node_Str" + r + g + b;
    if (vals != null) {
        resp.setRenderParameter(PARAM_FG_COLOR, vals);
    }
    String subType = req.getParameter(PARAM_SUBTYPE);
    if (subType != null) {
        resp.setRenderParameter(PARAM_SUBTYPE, subType);
    }
    String text = req.getParameter(PARAM_MSG_INPUT);
    if (text != null) {
        resp.setRenderParameter(PARAM_MSG_INPUT, text);
    }
    String msg = text + DELIM + clr;
    Enumeration<QName> eqn = getPublishingEventQNames();
    if (eqn.hasMoreElements()) {
        QName qn = eqn.nextElement();
        resp.setEvent(qn, msg);
        logger.fine("String_Node_Str" + qn.toString());
    } else {
        logger.warning("String_Node_Str");
    }
    StringBuilder sb = new StringBuilder("String_Node_Str").append(Arrays.toString(vals));
    sb.append("String_Node_Str").append(subType);
    sb.append("String_Node_Str").append(text);
    logger.fine(sb.toString());
}

Output:
 public void processAction(ActionRequest req, ActionResponse resp) throws PortletException, IOException {
-    dumpParameters(req);
-    String[] vals = req.getParameterValues(PARAM_FG_COLOR);
+    dumpParameters("String_Node_Str", req.getActionParameters());
+    dumpParameters("String_Node_Str", req.getRenderParameters());
+    String[] vals = req.getActionParameters().getValues(PARAM_FG_COLOR);
     String r = "String_Node_Str";


Input:
public void init(FilterConfig filterConfig) throws ServletException {
    String configPrefix = filterConfig.getInitParameter(CONFIG_PREFIX);
    configPrefix = (configPrefix != null) ? configPrefix + "String_Node_Str" : "String_Node_Str";
    Properties config = getConfiguration(configPrefix, filterConfig);
    String authHandlerName = config.getProperty(AUTH_TYPE, null);
    String authHandlerClassName;
    if (authHandlerName == null) {
        throw new ServletException("String_Node_Str");
    }
    if (authHandlerName.equals("String_Node_Str")) {
        authHandlerClassName = PseudoAuthenticationHandler.class.getName();
    } else if (authHandlerName.equals("String_Node_Str")) {
        authHandlerClassName = KerberosAuthenticationHandler.class.getName();
    } else {
        authHandlerClassName = authHandlerName;
    }
    try {
        Class klass = Thread.currentThread().getContextClassLoader().loadClass(authHandlerClassName);
        authHandler = (AuthenticationHandler) klass.newInstance();
        authHandler.init(config);
    } catch (ClassNotFoundException ex) {
        throw new ServletException(ex);
    } catch (InstantiationException ex) {
        throw new ServletException(ex);
    } catch (IllegalAccessException ex) {
        throw new ServletException(ex);
    }
    String signatureSecret = config.getProperty(configPrefix + SIGNATURE_SECRET);
    if (signatureSecret == null) {
        signatureSecret = Long.toString(new Random(System.currentTimeMillis()).nextLong());
        randomSecret = true;
        LOG.warn("String_Node_Str");
    }
    signer = new Signer(signatureSecret.getBytes());
    validity = Long.parseLong(config.getProperty(AUTH_TOKEN_VALIDITY, "String_Node_Str")) * 1000;
    cookieDomain = config.getProperty(COOKIE_DOMAIN, null);
    cookiePath = config.getProperty(COOKIE_PATH, null);
}

Output:
     try {
-        Class klass = Thread.currentThread().getContextClassLoader().loadClass(authHandlerClassName);
+        Class<?> klass = Thread.currentThread().getContextClassLoader().loadClass(authHandlerClassName);
         authHandler = (AuthenticationHandler) klass.newInstance();


Input:
public void beginShutdown() {
    try {
        if (mainFrame != null)
            mainFrame.dispose();
    } finally {
        try {
            GuiActivator.bundleContext.getBundle(0).stop();
        } catch (BundleException ex) {
            logger.error("String_Node_Str", ex);
            System.exit(0);
        }
    }
}

Output:
     } finally {
-        try {
-            GuiActivator.bundleContext.getBundle(0).stop();
-        } catch (BundleException ex) {
-            logger.error("String_Node_Str", ex);
-            System.exit(0);
-        }
+        System.exit(0);
     }


Input:
private XPartition createPartition(String cubeTableName, Date partDate) {
    XPartition xp = cubeObjectFactory.createXPartition();
    xp.setLocation("String_Node_Str");
    xp.setCubeTableName(cubeTableName);
    XTimePartSpec timeSpec = cubeObjectFactory.createXTimePartSpec();
    XTimePartSpecElement timePart = cubeObjectFactory.createXTimePartSpecElement();
    timePart.setKey("String_Node_Str");
    timePart.setValue(JAXBUtils.getXMLGregorianCalendar(partDate));
    timeSpec.getPartSpecElement().add(timePart);
    xp.setTimePartitionSpec(timeSpec);
    xp.setUpdatePeriod("String_Node_Str");
    return xp;
}

Output:
     XTimePartSpec timeSpec = cubeObjectFactory.createXTimePartSpec();
-    XTimePartSpecElement timePart = cubeObjectFactory.createXTimePartSpecElement();
-    timePart.setKey("String_Node_Str");
-    timePart.setValue(JAXBUtils.getXMLGregorianCalendar(partDate));
-    timeSpec.getPartSpecElement().add(timePart);
+    for (XTimePartSpecElement timePartSpec : timePartSpecs) {
+        timeSpec.getPartSpecElement().add(timePartSpec);
+    }
     xp.setTimePartitionSpec(timeSpec);


Input:
public MapReduceJarInfo getJarInfo(URL resolvedJarUrl) throws IOException, ClassNotFoundException {
    ClassLoader classLoader = getClass().getClassLoader();
    List<Class<?>> classesInJarWithMain = jarUtility.getClassesInJarWithMain(resolvedJarUrl.toExternalForm(), classLoader);
    List<String> classNamesInJarWithMain = new ArrayList<>(classesInJarWithMain.size());
    for (Class<?> aClass : classesInJarWithMain) {
        classNamesInJarWithMain.add(aClass.getCanonicalName());
    }
    classNamesInJarWithMain = Collections.unmodifiableList(classNamesInJarWithMain);
    final List<String> finalClassNamesInJarWithMain = classNamesInJarWithMain;
    final Class<?> mainClassFromManifest = jarUtility.getMainClassFromManifest(resolvedJarUrl, classLoader);
    return new MapReduceJarInfo() {
        public List<String> getClassesWithMain() {
            return finalClassNamesInJarWithMain;
        }
        public String getMainClass() {
            return mainClassFromManifest != null ? mainClassFromManifest.getCanonicalName() : null;
        }
    };
}

Output:
     final List<String> finalClassNamesInJarWithMain = classNamesInJarWithMain;
-    final Class<?> mainClassFromManifest = jarUtility.getMainClassFromManifest(resolvedJarUrl, classLoader);
+    Class<?> mainClassFromManifest = null;
+    try {
+        mainClassFromManifest = jarUtility.getMainClassFromManifest(resolvedJarUrl, classLoader);
+    } catch (Exception e) {
+    }
+    final String mainClassName = mainClassFromManifest != null ? mainClassFromManifest.getCanonicalName() : null;
     return new MapReduceJarInfo() {


Input:
public String getTabText() {
    return getLabel().getText();
}

Output:
 public String getTabText() {
-    return getLabel().getText();
+    Label label = getLabel();
+    return label.getText();
 }


Input:
public void lookupMatch() throws IOException {
    RuleKey key = new RuleKey("String_Node_Str");
    SourcePath input = new FakeSourcePath("String_Node_Str");
    HashCode hashCode = HashCode.fromInt(20);
    Manifest manifest = Manifest.fromMap(ImmutableMap.of(key, ImmutableMap.of(RESOLVER.getRelativePath(input).toString(), hashCode)));
    FileHashCache fileHashCache = new FakeFileHashCache(ImmutableMap.of(RESOLVER.getAbsolutePath(input), hashCode));
    assertThat(manifest.lookup(fileHashCache, RESOLVER, ImmutableSet.of(input)), Matchers.equalTo(Optional.of(key)));
}

Output:
     HashCode hashCode = HashCode.fromInt(20);
-    Manifest manifest = Manifest.fromMap(ImmutableMap.of(key, ImmutableMap.of(RESOLVER.getRelativePath(input).toString(), hashCode)));
+    Manifest manifest = Manifest.fromMap(new RuleKey("String_Node_Str"), ImmutableMap.of(key, ImmutableMap.of(RESOLVER.getRelativePath(input).toString(), hashCode)));
     FileHashCache fileHashCache = new FakeFileHashCache(ImmutableMap.of(RESOLVER.getAbsolutePath(input), hashCode));


Input:
public Vector<Vector<String>> runQuery(String mQuery) throws SQLException {
    Vector<Vector<String>> mResults = new Vector<Vector<String>>();
    Statement mStatement = (Statement) this.mConnection.createStatement();
    ResultSet mResultSet = mStatement.executeQuery(mQuery);
    mMetaData = mResultSet.getMetaData();
    int mNumColumns = mMetaData.getColumnCount();
    setColumns(mNumColumns, mMetaData);
    while (mResultSet.next()) {
        Vector<String> mRow = new Vector<String>();
        for (int i = 1; i <= mNumColumns; i++) {
            mRow.add(mResultSet.getString(i));
        }
        mResults.add(mRow);
    }
    return mResults;
}

Output:
     setColumns(mNumColumns, mMetaData);
-    while (mResultSet.next()) {
-        Vector<String> mRow = new Vector<String>();
-        for (int i = 1; i <= mNumColumns; i++) {
-            mRow.add(mResultSet.getString(i));
-        }
-        mResults.add(mRow);
-    }
-    return mResults;
+    return mResultSet;
 }


Input:
public void onEntityDamage(EntityDamageEvent event) {
    if (event instanceof EntityDamageByEntityEvent) {
        EntityDamageByEntityEvent e = (EntityDamageByEntityEvent) event;
        HumanNPC npc = NPCManager.getNPC(e.getEntity());
        if (e.getEntity() instanceof Player && npc != null) {
            e.setCancelled(true);
        }
        if (e.getDamager() instanceof Player && npc.isHealer()) {
            Entity entity = e.getDamager();
            if (entity instanceof Player) {
                Player player = (Player) entity;
                if (Permission.hasPermission("String_Node_Str", (CommandSender) player)) {
                    int playerHealth = player.getHealth();
                    int healerHealth = HealerPropertyPool.getStrength(npc.getUID());
                    if (player.getItemInHand().getTypeId() == Citizens.healerTakeHealthItem) {
                        if (playerHealth <= 19) {
                            if (healerHealth >= 1) {
                                player.setHealth(playerHealth + 1);
                                HealerPropertyPool.saveStrength(npc.getUID(), healerHealth - 1);
                                player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                            } else {
                                player.sendMessage(StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                            }
                        } else {
                            player.sendMessage(ChatColor.GREEN + "String_Node_Str");
                        }
                    } else if (player.getItemInHand().getTypeId() == Citizens.healerGiveHealthItem) {
                        if (playerHealth >= 1) {
                            if (healerHealth < HealerPropertyPool.getMaxStrength(npc.getUID())) {
                                player.setHealth(playerHealth - 1);
                                HealerPropertyPool.saveStrength(npc.getUID(), healerHealth + 1);
                                player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                            } else {
                                player.sendMessage(StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                            }
                        } else {
                            player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()));
                        }
                    } else if (player.getItemInHand().getType() == Material.DIAMOND_BLOCK) {
                        if (healerHealth != HealerPropertyPool.getMaxStrength(npc.getUID())) {
                            HealerPropertyPool.saveStrength(npc.getUID(), HealerPropertyPool.getMaxStrength(npc.getUID()));
                            player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                            int x = player.getItemInHand().getAmount();
                            ItemStack diamondBlock = new ItemStack(Material.DIAMOND_BLOCK, x - 1);
                            player.setItemInHand(diamondBlock);
                        } else {
                            player.sendMessage(StringUtils.yellowify(npc.getStrippedName()) + "String_Node_Str");
                        }
                    }
                } else {
                    player.sendMessage(MessageUtils.noPermissionsMessage);
                }
            }
        }
        if (e.getDamager() instanceof Player && npc.isWizard()) {
            Entity entity = e.getDamager();
            if (entity instanceof Player) {
                Player player = (Player) entity;
                if (Permission.hasPermission("String_Node_Str", (CommandSender) player)) {
                    if (player.getItemInHand().getTypeId() == Citizens.wizardInteractItem) {
                        if (!npc.isWizard()) {
                            return;
                        }
                        if (npc.getWizard().getNrOfLocations() > 0) {
                            npc.getWizard().nextLocation();
                            player.sendMessage(ChatColor.GREEN + "String_Node_Str" + StringUtils.yellowify(npc.getWizard().getCurrentLocationName()));
                        }
                    }
                } else {
                    player.sendMessage(MessageUtils.noPermissionsMessage);
                }
            }
        }
    }
}

Output:
         }
-        if (e.getDamager() instanceof Player && npc.isHealer()) {
+        if (npc != null && e.getDamager() instanceof Player && npc.isHealer()) {
             Entity entity = e.getDamager();


Input:
public void run() {
    setLsCache(children, file.getDate());
}

Output:
 public void run() {
-    setLsCache(children, file.getDate());
+    setLsCache(children2, file.getDate());
 }


Input:
public void onClick(View view) {
    if (view == buttonJiami) {
        String mingwen = editMing.getText().toString();
        if (mingwen == null) {
            Toast.makeText(getActivity(), "String_Node_Str", Toast.LENGTH_SHORT).show();
            return;
        }
        byte[] mingData = mingwen.getBytes();
        String miwen = "String_Node_Str";
        try {
            miwen = base64.encryptBASE64(mingData);
        } catch (Exception e) {
            e.printStackTrace();
        }
        editMi.setText(miwen);
    } else if (view == buttonJiemi) {
        String miwen = editMi.getText().toString();
        if (miwen == null) {
            Toast.makeText(getActivity(), "String_Node_Str", Toast.LENGTH_SHORT).show();
            return;
        }
        byte[] mingData = null;
        try {
            mingData = base64.decryptBASE64(miwen);
        } catch (Exception e) {
            e.printStackTrace();
        }
        String mingwen = new String(mingData);
        editMing.setText(mingwen);
    }
}

Output:
         String mingwen = editMing.getText().toString();
-        if (mingwen == null) {
+        if (mingwen.equals("String_Node_Str")) {
             Toast.makeText(getActivity(), "String_Node_Str", Toast.LENGTH_SHORT).show();


Input:
public List<MetricGraphData> getMetricValue(CriteriaInfo criteriaInfo, long beginTime, long duration, int aggregationPeriod, String autoDelay) {
    List<MetricGraphData> result = new ArrayList<MetricGraphData>();
    String encodedMetricName = criteriaInfo.getMetricName();
    String metricName = decodeMetricName(encodedMetricName);
    long endTime = beginTime + TimeUnit.SECONDS.toMillis(duration);
    boolean serverSide = MonitoringSystem.COLLECTION_LOCATION_SERVER.equals(criteriaInfo.getRoleType());
    Map<String, List<String>> filters = new HashMap<String, List<String>>();
    if (criteriaInfo.getServiceName() != null)
        filters.put("String_Node_Str", Arrays.asList(criteriaInfo.getServiceName().trim()));
    if (criteriaInfo.getOperationName() != null)
        filters.put("String_Node_Str", Arrays.asList(criteriaInfo.getOperationName().trim()));
    if (criteriaInfo.getConsumerName() != null)
        filters.put("String_Node_Str", Arrays.asList(criteriaInfo.getConsumerName().trim()));
    Map<String, List<MetricValue<?>>> metricValuesByOperationName;
    try {
        metricValuesByOperationName = metricValuesDAO.findMetricValuesByOperation(metricName, beginTime, endTime, serverSide, aggregationPeriod, filters);
        List<MetricValue<?>> metricValues = metricValuesByOperationName.get(criteriaInfo.getOperationName());
        for (int i = 0; i < duration / aggregationPeriod; ++i) {
            long startTime = beginTime + TimeUnit.SECONDS.toMillis(i * aggregationPeriod);
            long stopTime = startTime + TimeUnit.SECONDS.toMillis(aggregationPeriod);
            double value = 0;
            for (MetricValue<?> metricValue : metricValues) {
                long time = metricValue.getTimeMiliseconds();
                if (startTime <= time && time < stopTime) {
                    value += (Double) metricValue.getValueForMetric(encodedMetricName);
                    break;
                }
            }
            MetricGraphData metricGraphData = new MetricGraphData();
            metricGraphData.setCount(value);
            metricGraphData.setTimeSlot(startTime);
            metricGraphData.setCriteria(null);
            result.add(metricGraphData);
        }
    } catch (ServiceException e) {
        e.printStackTrace();
    }
    return result;
}

Output:
         metricValuesByOperationName = metricValuesDAO.findMetricValuesByOperation(metricName, beginTime, endTime, serverSide, aggregationPeriod, filters);
-        List<MetricValue<?>> metricValues = metricValuesByOperationName.get(criteriaInfo.getOperationName());
-        for (int i = 0; i < duration / aggregationPeriod; ++i) {
-            long startTime = beginTime + TimeUnit.SECONDS.toMillis(i * aggregationPeriod);
-            long stopTime = startTime + TimeUnit.SECONDS.toMillis(aggregationPeriod);
-            double value = 0;
-            for (MetricValue<?> metricValue : metricValues) {
-                long time = metricValue.getTimeMiliseconds();
-                if (startTime <= time && time < stopTime) {
-                    value += (Double) metricValue.getValueForMetric(encodedMetricName);
-                    break;
+        operationNames = filters.get("String_Node_Str");
+        for (String opName : operationNames) {
+            List<MetricValue<?>> metricValues = metricValuesByOperationName.get(opName);
+            for (int i = 0; i < duration / aggregationPeriod; ++i) {
+                long startTime = beginTime + TimeUnit.SECONDS.toMillis(i * aggregationPeriod);
+                long stopTime = startTime + TimeUnit.SECONDS.toMillis(aggregationPeriod);
+                double value = 0;
+                for (MetricValue<?> metricValue : metricValues) {
+                    long time = metricValue.getTimeMiliseconds();
+                    if (startTime <= time && time < stopTime) {
+                        value += (Double) metricValue.getValueForMetric(encodedMetricName);
+                        break;
+                    }
                 }


Input:
public ItemStack transferStackInSlot(EntityPlayer player, int slot) {
    ItemStack iStackTarget = null;
    Slot slotObj = (Slot) this.inventorySlots.get(slot);
    if (slotObj != null && slotObj.getHasStack()) {
        ItemStack iStackSource = slotObj.getStack();
        iStackTarget = iStackSource.copy();
        int nSlots = this.chocoBagInv.getSizeInventory();
        if (slot < nSlots) {
            if (!this.mergeItemStack(iStackSource, nSlots, this.inventorySlots.size(), true)) {
                return null;
            }
        } else if (!this.mergeItemStack(iStackSource, 0, nSlots, false)) {
            return null;
        }
        if (iStackSource.stackSize == 0) {
            slotObj.putStack((ItemStack) null);
        } else {
            slotObj.onSlotChanged();
        }
    }
    return iStackTarget;
}

Output:
         int nSlots = this.chocoBagInv.getSizeInventory();
-        if (slot < nSlots) {
-            if (!this.mergeItemStack(iStackSource, nSlots, this.inventorySlots.size(), true)) {
+        if (sourceSlotIdx < nSlots) {
+            if (!this.mergeItemStack(sourceItemStack, nSlots, this.inventorySlots.size(), true)) {
                 return null;


Input:
public TableWriter getWriter(CharSequence tableName) {
    return writerPool.getWriter(tableName);
}

Output:
 public TableWriter getWriter(CharSequence tableName) {
-    return writerPool.getWriter(tableName);
+    return writerPool.get(tableName);
 }


Input:
public void init(Set<Integer> partitions) {
    super.init(partitions, checkpointManager);
    scheduledExecutor = MoreExecutors.listeningDecorator(Executors.newSingleThreadScheduledExecutor(Threads.createDaemonThreadFactory("String_Node_Str")));
    partitionCheckpoints.clear();
    try {
        for (Integer partition : partitions) {
            partitionCheckpoints.put(partition, checkpointManager.getCheckpoint(partition));
        }
    } catch (Exception e) {
        LOG.error("String_Node_Str", e);
        throw Throwables.propagate(e);
    }
    checkPointWriter = new CheckPointWriter(checkpointManager, partitionCheckpoints);
    scheduledExecutor.scheduleWithFixedDelay(checkPointWriter, 100, 10000, TimeUnit.MILLISECONDS);
}

Output:
     try {
-        for (Integer partition : partitions) {
-            partitionCheckpoints.put(partition, checkpointManager.getCheckpoint(partition));
+        Map<Integer, Checkpoint> partitionMap = checkpointManager.getCheckpoint(partitions);
+        for (Map.Entry<Integer, Checkpoint> partition : partitionMap.entrySet()) {
+            partitionCheckpoints.put(partition.getKey(), partition.getValue());
         }


Input:
public static String[] createFailovers(final AppenderRef... refs) {
    if (refs == null) {
        logger.error("String_Node_Str");
        return null;
    }
    final String[] arr = new String[refs.length];
    for (int i = 0; i < refs.length; ++i) {
        arr[i] = refs[i].getRef();
    }
    return arr;
}

Output:
     if (refs == null) {
-        logger.error("String_Node_Str");
+        LOGGER.error("String_Node_Str");
         return null;


Input:
public ARXProcessStatistics optimizeFast(DataHandle handle, double records, double gsFactor, ARXListener listener) throws RollbackRequiredException {
    if (listener == null) {
        throw new NullPointerException("String_Node_Str");
    }
    if (handle == null) {
        throw new NullPointerException("String_Node_Str");
    }
    if (!Double.isNaN(records) && (records <= 0d || records > 1d)) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (!Double.isNaN(gsFactor) && (gsFactor < 0d || gsFactor > 1d)) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (!(handle instanceof DataHandleOutput)) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    if (!isOptimizable(handle)) {
        return new ARXProcessStatistics();
    }
    long time = System.currentTimeMillis();
    DataHandleOutput output = (DataHandleOutput) handle;
    if (output.getInputBuffer() == null || !output.getInputBuffer().equals(this.manager.getDataGeneralized().getArray())) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    int initialRecords = 0;
    RowSet rowset = RowSet.create(output.getNumRows());
    for (int row = 0; row < output.getNumRows(); row++) {
        if (output.isOutlier(row)) {
            rowset.add(row);
            initialRecords++;
        }
    }
    initialRecords = output.getNumRows() - initialRecords;
    ARXConfiguration config = this.config.getInstanceForLocalRecoding(rowset, gsFactor);
    if (!Double.isNaN(records)) {
        double absoluteRecords = records * handle.getNumRows();
        double relativeRecords = absoluteRecords / (double) rowset.size();
        relativeRecords = relativeRecords < 0d ? 0d : relativeRecords;
        relativeRecords = relativeRecords > 1d ? 1d : relativeRecords;
        config.setSuppressionLimit(1d - relativeRecords);
    }
    DataDefinition definition = this.definition.clone();
    DataManager manager = this.manager.getSubsetInstance(rowset);
    ARXAnonymizer anonymizer = new ARXAnonymizer();
    if (listener != null) {
        anonymizer.setListener(listener);
    }
    if (this.anonymizer != null) {
        anonymizer.parse(this.anonymizer);
    }
    Result result = null;
    try {
        result = anonymizer.anonymize(manager, definition, config);
    } catch (IOException e) {
        throw new RuntimeException("String_Node_Str");
    }
    if (result.optimum == null) {
        return new ARXProcessStatistics();
    }
    TransformedData data = result.checker.getApplicator().applyTransformation(result.optimum, output.getOutputBufferMicroaggregated().getDictionary());
    int newIndex = -1;
    DataMatrix oldGeneralized = output.getOutputBufferGeneralized().getArray();
    DataMatrix oldMicroaggregated = output.getOutputBufferMicroaggregated().getArray();
    DataMatrix newGeneralized = data.bufferGeneralized.getArray();
    DataMatrix newMicroaggregated = data.bufferMicroaggregated.getArray();
    try {
        int optimized = 0;
        for (int oldIndex = 0; oldIndex < rowset.length(); oldIndex++) {
            if (rowset.contains(oldIndex)) {
                newIndex++;
                if (oldGeneralized != null && oldGeneralized.getNumRows() != 0) {
                    oldGeneralized.copyFrom(oldIndex, newGeneralized, newIndex);
                    optimized += (newGeneralized.get(newIndex, 0) & Data.OUTLIER_MASK) != 0 ? 0 : 1;
                }
                if (oldMicroaggregated != null && oldMicroaggregated.getNumRows() != 0) {
                    oldMicroaggregated.copyFrom(oldIndex, newMicroaggregated, newIndex);
                }
            }
        }
        output.updateDataTypes(result.optimum.getGeneralization());
        if (optimized != 0) {
            output.setOptimized(true);
        }
        time = System.currentTimeMillis() - time;
        return new ARXProcessStatistics(result, initialRecords, optimized, time);
    } catch (Exception e) {
        throw new RollbackRequiredException("String_Node_Str", e);
    }
}

Output:
     if (!Double.isNaN(records)) {
-        double absoluteRecords = records * handle.getNumRows();
+        double absoluteRecords = records * output.getNumRows();
         double relativeRecords = absoluteRecords / (double) rowset.size();


Input:
private void handleCacheSyncRequest(CommandMessage message, Tuple tuple) throws IOException {
    logger.info("String_Node_Str", message);
    List<String> droppedFlows = new ArrayList<>();
    List<String> addedFlows = new ArrayList<>();
    List<String> modifiedFlows = new ArrayList<>();
    List<String> unchangedFlows = new ArrayList<>();
    List<FlowInfo> flowInfos = pathComputer.getFlowInfo();
    HashMap<String, FlowInfo> flowToInfo = new HashMap<>();
    for (FlowInfo fi : flowInfos) {
        flowToInfo.put(fi.getFlowId(), fi);
    }
    for (FlowInfo fi : flowInfos) {
        String flowid = fi.getFlowId();
        if (flowCache.cacheContainsFlow(flowid)) {
            ImmutablePair<Flow, Flow> fc = flowCache.getFlow(flowid);
            if (fi.getCookie() != fc.left.getCookie() || fi.getMeterId() != fc.left.getMeterId() || fi.getTransitVlanId() != fc.left.getTransitVlan() || fi.getSrcSwitchId() != fc.left.getSourceSwitch()) {
                modifiedFlows.add(MAPPER.writeValueAsString(fc));
            } else {
                unchangedFlows.add(flowid);
            }
        } else {
            addedFlows.add(flowid);
        }
    }
    for (ImmutablePair<Flow, Flow> flow : flowCache.dumpFlows()) {
        String flowid = flow.left.getFlowId();
        if (!flowToInfo.containsKey(flowid)) {
            String removedFlow = flowCache.removeFlow(flowid).toString();
            String asJson = MAPPER.writeValueAsString(removedFlow);
            droppedFlows.add(asJson);
        }
    }
    FlowCacheSyncResults results = new FlowCacheSyncResults(droppedFlows.toArray(new String[0]), addedFlows.toArray(new String[0]), modifiedFlows.toArray(new String[0]), unchangedFlows.toArray(new String[0]));
    Values northbound = new Values(new InfoMessage(new FlowCacheSyncResponse(results), message.getTimestamp(), message.getCorrelationId(), Destination.NORTHBOUND));
    outputCollector.emit(StreamType.RESPONSE.toString(), tuple, northbound);
}

Output:
     for (FlowInfo fi : flowInfos) {
-        flowToInfo.put(fi.getFlowId(), fi);
+        flowToInfo.put(fi.getFlowId() + fi.getCookie(), fi);
     }