Input:
protected void drawImage(IImageArea image) {
    if (image == null)
        return;
    ContainerPosition curPos;
    String imageName;
    shapeCount++;
    if (!containerStack.isEmpty()) {
        curPos = (ContainerPosition) containerStack.peek();
    } else {
        curPos = new ContainerPosition(0, 0);
    }
    int imageX = curPos.x + image.getX();
    int imageY = curPos.y + image.getY();
    IImageContent imageContent = ((IImageContent) image.getContent());
    String imageTitle = "String_Node_Str" + currentPageNum + "String_Node_Str" + shapeCount;
    if (imageNames.containsKey(imageContent.getURI())) {
        imageName = (String) imageNames.get(imageContent.getURI());
    } else {
        String extension = getImageExtension(imageContent.getURI());
        imageName = imageTitle + "String_Node_Str" + extension;
        imageNames.put(imageContent.getURI(), imageName);
        imageExtensions.put(imageContent.getURI(), extension);
        recordFileLists(imageName);
        currentImageContents.add(imageContent);
    }
    double width = pptMeasure(image.getWidth());
    double height = pptMeasure(image.getHeight());
    double x = layoutAreaX2PPT(imageX);
    double y = layoutAreaY2PPT(imageY);
    try {
        pptOutput.write(("String_Node_Str" + (shapeCount) + "String_Node_Str").getBytes());
        pptOutput.write(("String_Node_Str" + x + "String_Node_Str" + y + "String_Node_Str" + width + "String_Node_Str" + height + "String_Node_Str").getBytes());
        pptOutput.write(("String_Node_Str").getBytes());
        pptOutput.write(("String_Node_Str" + imageName + "String_Node_Str" + imageTitle + "String_Node_Str").getBytes());
        pptOutput.write(("String_Node_Str" + "String_Node_Str" + "String_Node_Str" + "String_Node_Str").getBytes());
        pptOutput.write(("String_Node_Str").getBytes());
    } catch (IOException ioe) {
        logger.log(Level.WARNING, ioe.getMessage(), ioe);
    }
}

Output:
     String imageTitle = "String_Node_Str" + currentPageNum + "String_Node_Str" + shapeCount;
-    if (imageNames.containsKey(imageContent.getURI())) {
-        imageName = (String) imageNames.get(imageContent.getURI());
+    if (imageContent.getURI() != null) {
+        if (imageNames.containsKey(imageContent.getURI())) {
+            imageName = (String) imageNames.get(imageContent.getURI());
+        } else {
+            String extension = getImageExtension(imageContent.getURI());
+            imageName = imageTitle + "String_Node_Str" + extension;
+            imageNames.put(imageContent.getURI(), imageName);
+            imageExtensions.put(imageContent.getURI(), extension);
+            recordFileLists(imageName);
+            currentImageContents.add(imageContent);
+        }
     } else {


Input:
private boolean isSimpleXMLRoot(XMLRoot xmlRoot) {
    Class xmlRootObjectClass = xmlRoot.getObject().getClass();
    if (XMLConversionManager.getDefaultJavaTypes().get(xmlRootObjectClass) != null || ClassConstants.List_Class.isAssignableFrom(xmlRootObjectClass)) {
        return true;
    }
    return false;
}

Output:
     Class xmlRootObjectClass = xmlRoot.getObject().getClass();
-    if (XMLConversionManager.getDefaultJavaTypes().get(xmlRootObjectClass) != null || ClassConstants.List_Class.isAssignableFrom(xmlRootObjectClass)) {
+    if (XMLConversionManager.getDefaultJavaTypes().get(xmlRootObjectClass) != null || ClassConstants.List_Class.isAssignableFrom(xmlRootObjectClass) || ClassConstants.XML_GREGORIAN_CALENDAR.isAssignableFrom(xmlRootObjectClass) || ClassConstants.DURATION.isAssignableFrom(xmlRootObjectClass)) {
         return true;


Input:
public void before() throws Exception {
    cConf.set(Constants.Dataset.Manager.ADDRESS, "String_Node_Str");
    cConf.setBoolean(Constants.Dangerous.UNRECOVERABLE_RESET, true);
    Configuration txConf = HBaseConfiguration.create();
    CConfigurationUtil.copyTxProperties(cConf, txConf);
    Impersonator impersonator = new DefaultImpersonator(cConf, null, null);
    Injector injector = Guice.createInjector(new ConfigModule(cConf, txConf), new DiscoveryRuntimeModule().getInMemoryModules(), new AuthorizationTestModule(), new AuthorizationEnforcementModule().getInMemoryModules(), new AuthenticationContextModules().getMasterModule(), new TransactionInMemoryModule(), new AbstractModule() {
        protected void configure() {
            bind(MetricsCollectionService.class).to(NoOpMetricsCollectionService.class).in(Singleton.class);
            install(new FactoryModuleBuilder().implement(DatasetDefinitionRegistry.class, DefaultDatasetDefinitionRegistry.class).build(DatasetDefinitionRegistryFactory.class));
            bind(RemoteDatasetFramework.class);
        }
    });
    txManager = new TransactionManager(txConf);
    txManager.startAndWait();
    InMemoryTxSystemClient txSystemClient = new InMemoryTxSystemClient(txManager);
    TransactionSystemClientService txSystemClientService = new DelegatingTransactionSystemClientService(txSystemClient);
    DiscoveryService discoveryService = injector.getInstance(DiscoveryService.class);
    DiscoveryServiceClient discoveryServiceClient = injector.getInstance(DiscoveryServiceClient.class);
    MetricsCollectionService metricsCollectionService = injector.getInstance(MetricsCollectionService.class);
    AuthenticationContext authenticationContext = injector.getInstance(AuthenticationContext.class);
    framework = new RemoteDatasetFramework(cConf, discoveryServiceClient, registryFactory, authenticationContext);
    SystemDatasetInstantiatorFactory datasetInstantiatorFactory = new SystemDatasetInstantiatorFactory(locationFactory, framework, cConf);
    DatasetAdminService datasetAdminService = new DatasetAdminService(framework, cConf, locationFactory, datasetInstantiatorFactory, new NoOpMetadataStore(), impersonator);
    ImmutableSet<HttpHandler> handlers = ImmutableSet.<HttpHandler>of(new DatasetAdminOpHTTPHandler(datasetAdminService));
    opExecutorService = new DatasetOpExecutorService(cConf, discoveryService, metricsCollectionService, handlers);
    opExecutorService.startAndWait();
    ImmutableMap<String, DatasetModule> modules = ImmutableMap.<String, DatasetModule>builder().put("String_Node_Str", new InMemoryTableModule()).put("String_Node_Str", new CoreDatasetsModule()).putAll(DatasetMetaTableUtil.getModules()).build();
    InMemoryDatasetFramework mdsFramework = new InMemoryDatasetFramework(registryFactory, modules);
    ExploreFacade exploreFacade = new ExploreFacade(new DiscoveryExploreClient(cConf, discoveryServiceClient), cConf);
    TransactionExecutorFactory txExecutorFactory = new DynamicTransactionExecutorFactory(txSystemClient);
    AuthorizationEnforcer authorizationEnforcer = injector.getInstance(AuthorizationEnforcer.class);
    DatasetTypeManager typeManager = new DatasetTypeManager(cConf, locationFactory, txSystemClientService, txExecutorFactory, mdsFramework, impersonator);
    DatasetInstanceManager instanceManager = new DatasetInstanceManager(txSystemClientService, txExecutorFactory, mdsFramework);
    PrivilegesManager privilegesManager = injector.getInstance(PrivilegesManager.class);
    DatasetTypeService typeService = new DatasetTypeService(typeManager, namespaceQueryAdmin, namespacedLocationFactory, authorizationEnforcer, privilegesManager, authenticationContext, cConf, impersonator, txSystemClientService, mdsFramework, txExecutorFactory, DEFAULT_MODULES);
    DatasetOpExecutor opExecutor = new LocalDatasetOpExecutor(cConf, discoveryServiceClient, opExecutorService);
    DatasetInstanceService instanceService = new DatasetInstanceService(typeService, instanceManager, opExecutor, exploreFacade, namespaceQueryAdmin, authorizationEnforcer, privilegesManager, authenticationContext);
    instanceService.setAuditPublisher(inMemoryAuditPublisher);
    service = new DatasetService(cConf, discoveryService, discoveryServiceClient, metricsCollectionService, new InMemoryDatasetOpExecutor(framework), new HashSet<DatasetMetricsReporter>(), typeService, instanceService);
    service.startAndWait();
    EndpointStrategy endpointStrategy = new RandomEndpointStrategy(discoveryServiceClient.discover(Constants.Service.DATASET_MANAGER));
    Preconditions.checkNotNull(endpointStrategy.pick(5, TimeUnit.SECONDS), "String_Node_Str", service);
    createNamespace(Id.Namespace.SYSTEM);
    createNamespace(NAMESPACE_ID);
}

Output:
     InMemoryDatasetFramework mdsFramework = new InMemoryDatasetFramework(registryFactory, modules);
-    ExploreFacade exploreFacade = new ExploreFacade(new DiscoveryExploreClient(cConf, discoveryServiceClient), cConf);
+    DiscoveryExploreClient exploreClient = new DiscoveryExploreClient(discoveryServiceClient, authenticationContext);
+    ExploreFacade exploreFacade = new ExploreFacade(exploreClient, cConf);
     TransactionExecutorFactory txExecutorFactory = new DynamicTransactionExecutorFactory(txSystemClient);


Input:
private void prepareAndShowBottomSheetWithBundle(Bundle bundle, boolean shouldShowCallMenuController) {
    View view = getActivity().getLayoutInflater().inflate(R.layout.bottom_sheet, null, false);
    if (shouldShowCallMenuController) {
        getChildRouter((ViewGroup) view).setRoot(RouterTransaction.with(new CallMenuController(bundle)).popChangeHandler(new VerticalChangeHandler()).pushChangeHandler(new VerticalChangeHandler()));
    } else {
        getChildRouter((ViewGroup) view).setRoot(RouterTransaction.with(new EntryMenuController(bundle)).popChangeHandler(new VerticalChangeHandler()).pushChangeHandler(new VerticalChangeHandler()));
    }
    boolean isNew = false;
    if (bottomSheet == null) {
        bottomSheet = new BottomSheet.Builder(getActivity()).setView(view).create();
        isNew = true;
    }
    if (bottomSheet.getWindow() != null && isNew) {
        bottomSheet.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
    }
    bottomSheet.show();
}

Output:
 private void prepareAndShowBottomSheetWithBundle(Bundle bundle, boolean shouldShowCallMenuController) {
-    View view = getActivity().getLayoutInflater().inflate(R.layout.bottom_sheet, null, false);
+    if (view == null) {
+        view = getActivity().getLayoutInflater().inflate(R.layout.bottom_sheet, null, false);
+    }
     if (shouldShowCallMenuController) {


Input:
IOdaDataSourceDesign newExtendedDataSource(OdaDataSourceHandle source) throws BirtException {
    OdaDataSourceDesign dteSource = new OdaDataSourceDesign(source.getQualifiedName());
    IBaseDataSourceEventHandler eventHandler = new DataSourceScriptExecutor(source, reportContext);
    dteSource.setEventHandler(eventHandler);
    adaptBaseDataSource(source, dteSource);
    String driverName = source.getExtensionID();
    if (driverName == null || driverName.length() == 0) {
        throw new EngineException("String_Node_Str" + source.getName());
    }
    dteSource.setExtensionID(driverName);
    Map staticProps = getExtensionProperties(source, source.getExtensionPropertyDefinitionList());
    if (staticProps != null && !staticProps.isEmpty()) {
        Iterator propNamesItr = staticProps.keySet().iterator();
        while (propNamesItr.hasNext()) {
            String propName = (String) propNamesItr.next();
            assert (propName != null);
            String propValue;
            String bindingExpr = source.getPropertyBinding(propName);
            if (needPropertyBinding() && bindingExpr != null && bindingExpr.length() > 0) {
                propValue = evaluatePropertyBindingExpr(bindingExpr);
            } else {
                propValue = (String) staticProps.get(propName);
            }
            dteSource.addPublicProperty((String) propName, propValue);
        }
    }
    Iterator elmtIter = source.privateDriverPropertiesIterator();
    if (elmtIter != null) {
        while (elmtIter.hasNext()) {
            ExtendedPropertyHandle modelProp = (ExtendedPropertyHandle) elmtIter.next();
            dteSource.addPrivateProperty(modelProp.getName(), modelProp.getValue());
        }
    }
    return dteSource;
}

Output:
     OdaDataSourceDesign dteSource = new OdaDataSourceDesign(source.getQualifiedName());
-    IBaseDataSourceEventHandler eventHandler = new DataSourceScriptExecutor(source, reportContext);
+    IBaseDataSourceEventHandler eventHandler = new DataSourceScriptExecutor(source, context);
     dteSource.setEventHandler(eventHandler);


Input:
private String _buildShardingCacheKey(String whereSql, ShardingDBResource shardingDBResource, int version) {
    StringBuilder cacheKey = new StringBuilder("String_Node_Str");
    cacheKey.append(shardingDBResource.getClusterName());
    cacheKey.append("String_Node_Str");
    cacheKey.append(shardingDBResource.getDbName());
    cacheKey.append("String_Node_Str");
    cacheKey.append(shardingDBResource.getRegionCapacity());
    cacheKey.append("String_Node_Str");
    cacheKey.append(shardingDBResource.getTableName()).append(shardingDBResource.getTableIndex());
    cacheKey.append("String_Node_Str");
    cacheKey.append(version).append("String_Node_Str");
    cacheKey.append(SecurityUtil.md5(whereSql));
    return cacheKey.toString();
}

Output:
     cacheKey.append(version).append("String_Node_Str");
-    cacheKey.append(SecurityUtil.md5(whereSql));
+    cacheKey.append(SecurityUtil.md5(whereKey));
     return cacheKey.toString();


Input:
private InstanceTypeDescription getType(Map<InstanceType, InstanceTypeDescription> types) {
    if (types == null || types.size() < 1) {
        throw new IllegalArgumentException("String_Node_Str");
    }
    long minMemory = 0;
    int minCPUCores = Integer.MAX_VALUE;
    InstanceTypeDescription retValue = null;
    final Iterator<InstanceTypeDescription> it = types.values().iterator();
    while (it.hasNext()) {
        final InstanceTypeDescription descr = it.next();
        if (retValue == null) {
            retValue = descr;
        }
        if (descr.getInstanceType().getNumberOfCores() < minCPUCores && descr.getHardwareDescription().getSizeOfFreeMemory() > minMemory) {
            minCPUCores = descr.getInstanceType().getNumberOfCores();
            minMemory = descr.getHardwareDescription().getSizeOfFreeMemory();
            retValue = descr;
        }
    }
    return retValue;
}

Output:
         final InstanceTypeDescription descr = it.next();
-        if (retValue == null) {
-            retValue = descr;
+        if (descr.getHardwareDescription() == null || descr.getInstanceType() == null) {
+            continue;
         }


Input:
public void watch(GameEvent event, Game game) {
    if (condition) {
        return;
    }
    if (event.getType() == GameEvent.EventType.ZONE_CHANGE && ((ZoneChangeEvent) event).isDiesEvent()) {
        Permanent p = (Permanent) game.getLastKnownInformation(event.getTargetId(), Zone.BATTLEFIELD);
        if (p != null && p.isCreature()) {
            condition = true;
        }
    }
}

Output:
     }
-    if (event.getType() == GameEvent.EventType.ZONE_CHANGE && ((ZoneChangeEvent) event).isDiesEvent()) {
-        Permanent p = (Permanent) game.getLastKnownInformation(event.getTargetId(), Zone.BATTLEFIELD);
-        if (p != null && p.isCreature()) {
-            condition = true;
-        }
+    if (event.getType() == GameEvent.EventType.ZONE_CHANGE && ((ZoneChangeEvent) event).isDiesEvent() && ((ZoneChangeEvent) event).getTarget().isCreature()) {
+        condition = true;
     }


Input:
public void listen(EntityDeathEvent event) {
    if (event.getEntity().getKiller() != player.getPlayerEntity())
        return;
    if (region != null)
        if (!WorldGuardUtilities.inRegion(player.getLocation(), region))
            return;
    if (cuboid != null)
        if (!cuboid.isInsideCuboid(player.getLocation()))
            return;
    if (type == KillType.ENTITY) {
        dEntity ent = new dEntity(event.getEntity());
        boolean count_it = false;
        for (String target : targets) {
            if (dEntity.valueOf(target) != null)
                if (ent.comparesTo(dEntity.valueOf(target)) == 1)
                    count_it = true;
        }
        if (count_it || targets.contains("String_Node_Str")) {
            kills_so_far++;
            dB.log(player.getName() + "String_Node_Str" + ent.identify() + "String_Node_Str" + kills_so_far + "String_Node_Str" + required + "String_Node_Str");
            check();
        }
    } else if (type == KillType.NPC) {
        if (!CitizensAPI.getNPCRegistry().isNPC(event.getEntity()))
            return;
        dNPC npc = dNPC.mirrorCitizensNPC(CitizensAPI.getNPCRegistry().getNPC(event.getEntity()));
        boolean count_it = false;
        for (String target : targets) {
            if (dNPC.valueOf(target) != null) {
                if (dNPC.valueOf(target).getId() == npc.getId())
                    count_it = true;
            } else if (npc.getName().equalsIgnoreCase(target))
                count_it = true;
        }
        if (count_it || targets.contains("String_Node_Str")) {
            kills_so_far++;
            dB.log(player.getName() + "String_Node_Str" + npc.toString() + "String_Node_Str" + kills_so_far + "String_Node_Str" + required + "String_Node_Str");
            check();
        }
    } else if (type == KillType.PLAYER) {
        if (event.getEntityType() != EntityType.PLAYER)
            return;
        if (CitizensAPI.getNPCRegistry().isNPC(event.getEntity()))
            return;
        dPlayer player = dPlayer.mirrorBukkitPlayer((Player) event.getEntity());
        boolean count_it = false;
        for (String target : targets) {
            if (dPlayer.valueOf(target) != null)
                if (dPlayer.valueOf(target).getName().equalsIgnoreCase(player.getName()))
                    count_it = true;
        }
        if (count_it || targets.contains("String_Node_Str")) {
            kills_so_far++;
            dB.log(player.getName() + "String_Node_Str" + player.getName() + "String_Node_Str" + kills_so_far + "String_Node_Str" + required + "String_Node_Str");
            check();
        }
    } else if (type == KillType.GROUP) {
        if (event.getEntityType() == EntityType.PLAYER)
            for (String group : Depends.permissions.getPlayerGroups((Player) event.getEntity())) if (targets.contains(group.toUpperCase())) {
                kills_so_far++;
                dB.log(player.getName() + "String_Node_Str" + ((Player) event.getEntity()).getName().toUpperCase() + "String_Node_Str" + group + "String_Node_Str");
                check();
                break;
            }
    }
}

Output:
                     count_it = true;
-            } else if (npc.getName().equalsIgnoreCase(target))
+            }
+            if (npc.getName().equalsIgnoreCase(target.toLowerCase().replace("String_Node_Str", "String_Node_Str")))
                 count_it = true;


Input:
public ResourceTO create(HttpServletResponse response, ResourceTO resourceTO) throws IOException {
    if (log.isDebugEnabled()) {
        log.debug("String_Node_Str");
    }
    ResourceDataBinder binder = new ResourceDataBinder(schemaDAO, connectorInstanceDAO);
    if (resourceTO == null) {
        if (log.isErrorEnabled()) {
            log.error("String_Node_Str");
        }
        return throwNotFoundException("String_Node_Str", response);
    }
    Resource actual = null;
    try {
        if (log.isDebugEnabled()) {
            log.debug("String_Node_Str");
        }
        Resource resource = binder.getResource(resourceTO);
        if (log.isInfoEnabled()) {
            log.info("String_Node_Str" + resource.getName());
        }
        actual = resourceDAO.save(resource);
        if (actual == null) {
            if (log.isErrorEnabled()) {
                log.error("String_Node_Str");
            }
            SyncopeClientException ex = new SyncopeClientException(SyncopeClientExceptionType.Unknown);
            throw ex;
        }
    } catch (SyncopeClientCompositeErrorException e) {
        return throwCompositeException(e, response);
    } catch (SyncopeClientException ex) {
        SyncopeClientCompositeErrorException compositeErrorException = new SyncopeClientCompositeErrorException(HttpStatus.BAD_REQUEST);
        compositeErrorException.addException(ex);
        return throwCompositeException(compositeErrorException, response);
    } catch (Throwable t) {
        if (log.isErrorEnabled()) {
            log.error("String_Node_Str", t);
        }
        SyncopeClientException ex = new SyncopeClientException(SyncopeClientExceptionType.Unknown);
        SyncopeClientCompositeErrorException compositeErrorException = new SyncopeClientCompositeErrorException(HttpStatus.BAD_REQUEST);
        compositeErrorException.addException(ex);
        return throwCompositeException(compositeErrorException, response);
    }
    response.setStatus(HttpServletResponse.SC_CREATED);
    return binder.getResourceTO(actual);
}

Output:
         }
-        Resource resource = binder.getResource(resourceTO);
+        Resource resource = null;
+        if (resourceDAO.find(resourceTO.getName()) != null) {
+            SyncopeClientException ex = new SyncopeClientException(SyncopeClientExceptionType.AlreadyExists);
+            ex.addElement(resourceTO.getName());
+            throw ex;
+        }
+        if (log.isDebugEnabled()) {
+            log.debug("String_Node_Str");
+        }
+        resource = binder.getResource(resourceTO);
         if (log.isInfoEnabled()) {


Input:
public double applyBonusMultiplierAspect(ProceedingJoinPoint pjp) throws Throwable {
    double percentage = (double) pjp.proceed();
    LoggerUtil.getInstance().debug("String_Node_Str" + bonus.getMultiplier() + "String_Node_Str" + percentage);
    return percentage * bonus.getMultiplier();
}

Output:
     double percentage = (double) pjp.proceed();
-    LoggerUtil.getInstance().debug("String_Node_Str" + bonus.getMultiplier() + "String_Node_Str" + percentage);
-    return percentage * bonus.getMultiplier();
+    if (bonus.isValid()) {
+        LoggerUtil.getInstance().debug("String_Node_Str" + bonus.getMultiplier() + "String_Node_Str" + percentage);
+        percentage *= bonus.getMultiplier();
+    }
+    return percentage;
 }


Input:
public int pairwiseAnd_EWAH32(BenchmarkState benchmarkState) {
    int total = 0;
    for (int k = 0; k + 1 < benchmarkState.ewah32.size(); ++k) total += EWAHCompressedBitmap32.and(benchmarkState.ewah32.get(k), benchmarkState.ewah32.get(k + 1)).cardinality();
    if (total != benchmarkState.totaland)
        throw new RuntimeException("String_Node_Str");
    return total;
}

Output:
     int total = 0;
-    for (int k = 0; k + 1 < benchmarkState.ewah32.size(); ++k) total += EWAHCompressedBitmap32.and(benchmarkState.ewah32.get(k), benchmarkState.ewah32.get(k + 1)).cardinality();
+    for (int k = 0; k + 1 < benchmarkState.ewah32.size(); ++k) total += benchmarkState.ewah32.get(k).and(benchmarkState.ewah32.get(k + 1)).cardinality();
     if (total != benchmarkState.totaland)


Input:
public void setName(String name) throws IllegalActionException, NameDuplicationException {
    if (name == null) {
        name = new String("String_Node_Str");
    }
    Entity container = (Entity) getContainer();
    if ((container != null)) {
        Port another = container.getPort(name);
        if ((another != null) && (another != this)) {
            throw new NameDuplicationException(container, "String_Node_Str" + name + "String_Node_Str");
        }
    }
    super.setName(name);
}

Output:
         if ((another != null) && (another != this)) {
-            throw new NameDuplicationException(container, "String_Node_Str" + name + "String_Node_Str");
+            throw new NameDuplicationException(container, "String_Node_Str" + name);
         }


Input:
public BasicCookieStore getNewCookieStore() throws JSONException, ParseException {
    BasicCookieStore basicCookieStore = new BasicCookieStore();
    Iterator<String> cookieNames = jsonCookies.keys();
    while (cookieNames.hasNext()) {
        String cookieName = cookieNames.next();
        JSONObject cookie = (JSONObject) jsonCookies.get(cookieName);
        System.out.println("String_Node_Str" + cookie);
        BasicClientCookie basicCookie = new BasicClientCookie(cookieName, cookie.getString(VALUE));
        System.out.println(dateFormat);
        System.out.println(cookie.getString(EXPIRES));
        basicCookie.setExpiryDate(new Date(cookie.getString(EXPIRES)));
        basicCookie.setDomain("String_Node_Str");
        basicCookie.setPath("String_Node_Str");
        basicCookieStore.addCookie(basicCookie);
    }
    return basicCookieStore;
}

Output:
         System.out.println(cookie.getString(EXPIRES));
-        basicCookie.setExpiryDate(new Date(cookie.getString(EXPIRES)));
+        basicCookie.setExpiryDate(dateFormatWithoutTimeZone.parse(cookie.getString(EXPIRES)));
         basicCookie.setDomain("String_Node_Str");


Input:
public SymbolData merge(SymbolData other) {
    SymbolType result = null;
    if (other == null) {
        result = this;
    } else {
        if (other.getArrayCount() == getArrayCount()) {
            List<Class<?>> bounds = ClassInspector.getTheNearestSuperClasses(getBoundClasses(), other.getBoundClasses());
            if (bounds.isEmpty()) {
                result = null;
            } else if (bounds.size() == 1) {
                result = new SymbolType(bounds.get(0));
            } else {
                List<SymbolType> boundsList = new LinkedList<SymbolType>();
                for (Class<?> bound : bounds) {
                    boundsList.add(new SymbolType(bound));
                }
                result = new SymbolType(boundsList);
            }
            if (result != null) {
                if (lowerBounds != null) {
                    result.lowerBounds = new LinkedList<SymbolType>();
                    for (SymbolType st : lowerBounds) {
                        result.lowerBounds.add(st.clone());
                    }
                }
                result.arrayCount = other.getArrayCount();
            }
        } else {
            result = new SymbolType(Object.class);
        }
    }
    return result;
}

Output:
     SymbolType result = null;
-    if (other == null) {
+    if (other == null || equals(other)) {
         result = this;


Input:
public static org.hl7.fhir.dstu2016may.model.TestScript.SetupActionOperationComponent convertSetupActionOperationComponent(org.hl7.fhir.dstu3.model.TestScript.SetupActionOperationComponent src) throws FHIRException {
    if (src == null)
        return null;
    org.hl7.fhir.dstu2016may.model.TestScript.SetupActionOperationComponent tgt = new org.hl7.fhir.dstu2016may.model.TestScript.SetupActionOperationComponent();
    copyElement(src, tgt);
    tgt.setType(convertCoding(src.getType()));
    tgt.setResource(src.getResource());
    tgt.setLabel(src.getLabel());
    tgt.setDescription(src.getDescription());
    tgt.setAccept(convertContentType(src.getAccept()));
    tgt.setContentType(convertContentType(src.getContentType()));
    tgt.setDestination(src.getDestination());
    tgt.setEncodeRequestUrl(src.getEncodeRequestUrl());
    tgt.setOrigin(src.getOrigin());
    tgt.setParams(src.getParams());
    for (org.hl7.fhir.dstu3.model.TestScript.SetupActionOperationRequestHeaderComponent t : src.getRequestHeader()) tgt.addRequestHeader(convertSetupActionOperationRequestHeaderComponent(t));
    tgt.setResponseId(src.getResponseId());
    tgt.setSourceId(src.getSourceId());
    tgt.setTargetId(src.getTargetId());
    tgt.setUrl(src.getUrl());
    return tgt;
}

Output:
 public static org.hl7.fhir.dstu2016may.model.TestScript.SetupActionOperationComponent convertSetupActionOperationComponent(org.hl7.fhir.dstu3.model.TestScript.SetupActionOperationComponent src) throws FHIRException {
-    if (src == null)
+    if (src == null || src.isEmpty())
         return null;


Input:
public void test() {
    ReadObjectQuery query = new ReadObjectQuery(IsolatedEmployee.class);
    Session client1 = this.server.acquireClientSession();
    IsolatedEmployee employee = (IsolatedEmployee) client1.executeQuery(query);
    client1.release();
    try {
        employee.getPhoneNumbers();
        throw new TestErrorException("String_Node_Str");
    } catch (ValidationException ex) {
    }
}

Output:
     ReadObjectQuery query = new ReadObjectQuery(IsolatedEmployee.class);
-    Session client1 = this.server.acquireClientSession();
+    ClientSession client1 = this.server.acquireClientSession();
     IsolatedEmployee employee = (IsolatedEmployee) client1.executeQuery(query);


Input:
private void checkforErrors() {
    List<String> dErrors = new ArrayList<String>();
    if (repositoryTree.getTree().getItems().length == 0) {
        dErrors.add(Messages.getString("String_Node_Str"));
    }
    if (repositoryTree.getCheckedElements().length == 0) {
        dErrors.add(Messages.getString("String_Node_Str"));
    }
    dErrors.addAll(writer.check());
    ItemRecord[] elements = getElements();
    for (ItemRecord record : elements) {
        for (File depFile : record.getDependencyMap().keySet()) {
            ModelElement element = record.getDependencyMap().get(depFile);
            ItemRecord findRecord = ItemRecord.findRecord(depFile);
            if (findRecord == null || !repositoryTree.getChecked(findRecord)) {
                dErrors.add("String_Node_Str" + record.getName() + "String_Node_Str" + element.getName());
            }
        }
    }
    if (!dErrors.isEmpty()) {
        setErrorMessage(dErrors.get(0));
    } else {
        setErrorMessage(null);
    }
    updatePageStatus();
}

Output:
             if (findRecord == null || !repositoryTree.getChecked(findRecord)) {
-                dErrors.add("String_Node_Str" + record.getName() + "String_Node_Str" + element.getName());
+                dErrors.add("String_Node_Str" + record.getName() + "String_Node_Str" + dptLabel);
             }


Input:
public void activate(UserRequest ureq, List<ContextEntry> entries, StateEntry state) {
    if (entries == null || entries.isEmpty())
        return;
    String type = entries.get(0).getOLATResourceable().getResourceableTypeName();
    if ("String_Node_Str".equalsIgnoreCase(type)) {
        Long levelKey = entries.get(0).getOLATResourceable().getResourceableId();
        List<TaxonomyLevelRow> rows = model.getObjects();
        for (TaxonomyLevelRow row : rows) {
            if (levelKey.equals(row.getKey())) {
                List<ContextEntry> subEntries = entries.subList(1, entries.size());
                doSelectTaxonomyLevel(ureq, row).activate(ureq, subEntries, entries.get(0).getTransientState());
                break;
            }
        }
    }
}

Output:
                 List<ContextEntry> subEntries = entries.subList(1, entries.size());
-                doSelectTaxonomyLevel(ureq, row).activate(ureq, subEntries, entries.get(0).getTransientState());
+                TaxonomyLevelOverviewController ctrl = doSelectTaxonomyLevel(ureq, row);
+                if (ctrl != null) {
+                    ctrl.activate(ureq, subEntries, entries.get(0).getTransientState());
+                }
                 break;


Input:
public ContentValues getValuesFromCursor(Cursor cursor, String[] arrProjection) {
    ContentValues contentValues = new ContentValues();
    for (String projection : arrProjection) {
        int index;
        try {
            index = cursor.getColumnIndexOrThrow(projection);
        } catch (IllegalArgumentException e) {
            Logger.log("String_Node_Str", e);
            continue;
        }
        int type = cursor.getType(index);
        switch(type) {
            case Cursor.FIELD_TYPE_STRING:
                contentValues.put(projection, cursor.getString(index));
                break;
            case Cursor.FIELD_TYPE_INTEGER:
                contentValues.put(projection, cursor.getInt(index));
                break;
            case Cursor.FIELD_TYPE_FLOAT:
                contentValues.put(projection, cursor.getFloat(index));
                break;
            case Cursor.FIELD_TYPE_BLOB:
                contentValues.put(projection, cursor.getBlob(index));
                break;
            case Cursor.FIELD_TYPE_NULL:
                Logger.log("String_Node_Str");
                break;
            default:
                Logger.log("String_Node_Str");
        }
    }
    return contentValues;
}

Output:
         } catch (IllegalArgumentException e) {
-            Logger.log("String_Node_Str", e);
+            Logger.log("String_Node_Str", e, LogType.DATABASE);
             continue;


Input:
public void onErrorResponse(VolleyError response) {
    if (response.toString().equals(AuthFailureError.class.getName())) {
        String errorTitle = getString(R.string.theme_auth_error_title);
        String errorMsg = getString(R.string.theme_auth_error_message);
        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
        WPAlertDialogFragment fragment = WPAlertDialogFragment.newInstance(errorMsg, errorTitle, false);
        ft.add(fragment, "String_Node_Str");
        ft.commitAllowingStateLoss();
        Log.d("String_Node_Str", "String_Node_Str");
    } else {
        Toast.makeText(ThemeBrowserActivity.this, R.string.theme_fetch_failed, Toast.LENGTH_LONG).show();
        Log.d("String_Node_Str", "String_Node_Str" + response.toString());
    }
    mFetchingThemes = false;
    mProgressBar.setVisibility(View.GONE);
    stopAnimatingRefreshButton();
    refreshViewPager();
}

Output:
         String errorMsg = getString(R.string.theme_auth_error_message);
-        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
-        WPAlertDialogFragment fragment = WPAlertDialogFragment.newInstance(errorMsg, errorTitle, false);
-        ft.add(fragment, "String_Node_Str");
-        ft.commitAllowingStateLoss();
+        if (!isDestroyed()) {
+            FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
+            WPAlertDialogFragment fragment = WPAlertDialogFragment.newInstance(errorMsg, errorTitle, false);
+            ft.add(fragment, "String_Node_Str");
+            ft.commitAllowingStateLoss();
+        }
         Log.d("String_Node_Str", "String_Node_Str");


Input:
private void onExternalPaymentProcessed(ProcessExternalPayment pep) {
    switch(pep.status) {
        case SUCCESS:
            Fragment fragment = getCurrentFragment();
            if (fragment instanceof SuccessFragment) {
                ((SuccessFragment) fragment).saveCard(pep.moneySource);
            } else {
                showSuccess(pep.moneySource);
            }
            break;
        case EXT_AUTH_REQUIRED:
            showWeb(pep.acsUri, pep.acsParams);
            break;
        default:
            showError(pep.error, pep.status.code);
    }
}

Output:
             Fragment fragment = getCurrentFragment();
-            if (fragment instanceof SuccessFragment) {
-                ((SuccessFragment) fragment).saveCard(pep.moneySource);
-            } else {
+            if (!(fragment instanceof SuccessFragment)) {
                 showSuccess(pep.moneySource);


Input:
public MergeResult call() throws NoHeadException, ConcurrentRefUpdateException, CheckoutConflictException, InvalidMergeHeadsException, WrongRepositoryStateException, NoMessageException {
    checkCallable();
    if (commits.size() != 1)
        throw new InvalidMergeHeadsException(commits.isEmpty() ? JGitText.get().noMergeHeadSpecified : MessageFormat.format(JGitText.get().mergeStrategyDoesNotSupportHeads, mergeStrategy.getName(), Integer.valueOf(commits.size())));
    RevWalk revWalk = null;
    try {
        Ref head = repo.getRef(Constants.HEAD);
        if (head == null)
            throw new NoHeadException(JGitText.get().commitOnRepoWithoutHEADCurrentlyNotSupported);
        StringBuilder refLogMessage = new StringBuilder("String_Node_Str");
        revWalk = new RevWalk(repo);
        RevCommit headCommit = revWalk.lookupCommit(head.getObjectId());
        Ref ref = commits.get(0);
        refLogMessage.append(ref.getName());
        ObjectId objectId = ref.getPeeledObjectId();
        if (objectId == null)
            objectId = ref.getObjectId();
        RevCommit srcCommit = revWalk.lookupCommit(objectId);
        if (revWalk.isMergedInto(srcCommit, headCommit)) {
            setCallable(false);
            return new MergeResult(headCommit, srcCommit, new ObjectId[] { headCommit, srcCommit }, MergeStatus.ALREADY_UP_TO_DATE, mergeStrategy, null, null);
        } else if (revWalk.isMergedInto(headCommit, srcCommit)) {
            refLogMessage.append("String_Node_Str" + MergeStatus.FAST_FORWARD);
            DirCacheCheckout dco = new DirCacheCheckout(repo, headCommit.getTree(), repo.lockDirCache(), srcCommit.getTree());
            dco.setFailOnConflict(true);
            dco.checkout();
            updateHead(refLogMessage, srcCommit, head.getObjectId());
            setCallable(false);
            return new MergeResult(srcCommit, srcCommit, new ObjectId[] { headCommit, srcCommit }, MergeStatus.FAST_FORWARD, mergeStrategy, null, null);
        } else {
            repo.writeMergeCommitMsg(new MergeMessageFormatter().format(commits, head));
            repo.writeMergeHeads(Arrays.asList(ref.getObjectId()));
            ThreeWayMerger merger = (ThreeWayMerger) mergeStrategy.newMerger(repo);
            boolean noProblems;
            Map<String, org.eclipse.jgit.merge.MergeResult<?>> lowLevelResults = null;
            Map<String, MergeFailureReason> failingPaths = null;
            if (merger instanceof ResolveMerger) {
                ResolveMerger resolveMerger = (ResolveMerger) merger;
                resolveMerger.setCommitNames(new String[] { "String_Node_Str", "String_Node_Str", ref.getName() });
                resolveMerger.setWorkingTreeIterator(new FileTreeIterator(repo));
                noProblems = merger.merge(headCommit, srcCommit);
                lowLevelResults = resolveMerger.getMergeResults();
                failingPaths = resolveMerger.getFailingPathes();
            } else
                noProblems = merger.merge(headCommit, srcCommit);
            if (noProblems) {
                DirCacheCheckout dco = new DirCacheCheckout(repo, headCommit.getTree(), repo.lockDirCache(), merger.getResultTreeId());
                dco.setFailOnConflict(true);
                dco.checkout();
                RevCommit newHead = new Git(getRepository()).commit().call();
                return new MergeResult(newHead.getId(), null, new ObjectId[] { headCommit.getId(), srcCommit.getId() }, MergeStatus.MERGED, mergeStrategy, null, null);
            } else {
                if (failingPaths != null) {
                    repo.writeMergeCommitMsg(null);
                    repo.writeMergeHeads(null);
                    return new MergeResult(null, merger.getBaseCommit(0, 1), new ObjectId[] { headCommit.getId(), srcCommit.getId() }, MergeStatus.FAILED, mergeStrategy, lowLevelResults, null);
                } else
                    return new MergeResult(null, merger.getBaseCommit(0, 1), new ObjectId[] { headCommit.getId(), srcCommit.getId() }, MergeStatus.CONFLICTING, mergeStrategy, lowLevelResults, null);
            }
        }
    } catch (IOException e) {
        throw new JGitInternalException(MessageFormat.format(JGitText.get().exceptionCaughtDuringExecutionOfMergeCommand, e), e);
    } finally {
        if (revWalk != null)
            revWalk.release();
    }
}

Output:
                 lowLevelResults = resolveMerger.getMergeResults();
-                failingPaths = resolveMerger.getFailingPathes();
+                failingPaths = resolveMerger.getFailingPaths();
             } else


Input:
public void insertFinished(Object context) {
    try {
        if (context == null) {
            String msg = "String_Node_Str";
            Logging.logMessage(Logging.LEVEL_ERROR, this, msg);
            dbInterface.replication_runtime_failure(msg);
        }
        Status<Request> rq = (Status<Request>) context;
        if (rq != null) {
            updateLastWrittenLSN(rq.getValue().getLSN());
            Request parsed = RequestPreProcessor.getReplicationRequest(rq);
            if (parsed != null)
                replication.sendACK((Request) parsed);
            Logging.logMessage(Logging.LEVEL_TRACE, replication, "String_Node_Str" + rq.getValue().getLSN().toString());
            rq.finished();
        }
    } catch (ReplicationException e) {
        Logging.logMessage(Logging.LEVEL_ERROR, this, "String_Node_Str" + e.getMessage());
        dbInterface.replication_runtime_failure(e.getMessage());
    } catch (Exception e) {
        Logging.logMessage(Logging.LEVEL_ERROR, this, e.getMessage());
        dbInterface.replication_runtime_failure(e.getMessage());
    }
}

Output:
                 replication.sendACK((Request) parsed);
-            Logging.logMessage(Logging.LEVEL_TRACE, replication, "String_Node_Str" + rq.getValue().getLSN().toString());
+            Logging.logMessage(Logging.LEVEL_ERROR, replication, "String_Node_Str" + rq.getValue().getLSN().toString());
             rq.finished();


Input:
protected void onUnload() {
    cleanup();
}

Output:
 protected void onUnload() {
-    cleanup();
+    if (isShowing()) {
+        setState(false, false);
+    }
 }


Input:
public boolean canInteractWith(EntityPlayer var1) {
    return fusion.isUseableByPlayer(var1);
}

Output:
 public boolean canInteractWith(EntityPlayer var1) {
-    return fusion.isUseableByPlayer(var1);
+    return true;
 }


Input:
private static TdColumn addColumnAttribute(String label, String columnName, String typeName, int columnSize, int decimalDigits, String columnRemark, ResultSet resutSet, TdColumn column, java.sql.Connection conn, boolean isMssql) throws SQLException {
    boolean isIBMDB2ZOS = false;
    boolean isTeradataSqlModel = false;
    boolean isSAS = false;
    if (databaseconnection != null) {
        String dbMetaData = databaseconnection.getDatabaseType();
        if (dbMetaData != null && dbMetaData.equals(EDatabaseTypeName.IBMDB2ZOS.getDisplayName())) {
            isIBMDB2ZOS = true;
        }
        if (dbMetaData != null && dbMetaData.equals(EDatabaseTypeName.TERADATA.getDisplayName()) && databaseconnection.isSQLMode()) {
            isTeradataSqlModel = true;
        }
        if (dbMetaData != null && dbMetaData.equals(EDatabaseTypeName.SAS.getDisplayName())) {
            isSAS = true;
        }
    }
    if (column == null) {
        column = RelationalFactory.eINSTANCE.createTdColumn();
    }
    Object defaultvalue = null;
    try {
        defaultvalue = resutSet.getObject(GetColumn.COLUMN_DEF.name());
    } catch (Exception e1) {
        log.warn(e1, e1);
    }
    String defaultStr = (defaultvalue != null) ? String.valueOf(defaultvalue) : null;
    TdExpression defExpression = createTdExpression(GetColumn.COLUMN_DEF.name(), defaultStr);
    if (columnName == null || "String_Node_Str".equals(columnName)) {
        try {
            columnName = resutSet.getString(GetColumn.COLUMN_NAME.name());
        } catch (Exception e1) {
            log.warn(e1, e1);
            if (columnName == null) {
                columnName = e1.getMessage();
            }
        }
    }
    column.setLabel(label);
    column.setName(columnName);
    int dataType = 0;
    try {
        if (isIBMDB2ZOS || isTeradataSqlModel || isSAS) {
            dataType = resutSet.getInt(GetColumn.TYPE_NAME.name());
        } else {
            dataType = resutSet.getInt(GetColumn.DATA_TYPE.name());
        }
    } catch (Exception e) {
        log.warn(e, e);
    }
    if (typeName == null || "String_Node_Str".equals(typeName)) {
        try {
            typeName = resutSet.getString(GetColumn.TYPE_NAME.name());
        } catch (Exception e1) {
            log.warn(e1, e1);
        }
    }
    if (typeName != null && isMssql()) {
        if (typeName.toLowerCase().equals("String_Node_Str")) {
            dataType = 91;
        } else if (typeName.toLowerCase().equals("String_Node_Str")) {
            dataType = 92;
        }
    }
    if (columnSize < 0) {
        try {
            columnSize = resutSet.getInt(GetColumn.COLUMN_SIZE.name());
        } catch (Exception e1) {
            log.warn(e1, e1);
        }
    }
    column.setLength(columnSize);
    if (decimalDigits < 0) {
        try {
            decimalDigits = resutSet.getInt(GetColumn.DECIMAL_DIGITS.name());
        } catch (Exception e) {
            log.warn(e);
        }
    }
    int numPrecRadix = 0;
    try {
        if (!isIBMDB2ZOS && !isTeradataSqlModel && !isSAS) {
            numPrecRadix = resutSet.getInt(GetColumn.NUM_PREC_RADIX.name());
        }
    } catch (Exception e) {
        log.warn(e);
    }
    if (columnRemark == null || "String_Node_Str".equals(columnRemark)) {
        try {
            columnRemark = resutSet.getString(GetColumn.REMARKS.name());
        } catch (Exception e) {
            log.warn(e, e);
        }
        if (columnRemark == null) {
            columnRemark = "String_Node_Str";
        }
        columnRemark = ManagementTextUtils.filterSpecialChar(columnRemark);
    }
    ColumnHelper.setComment(columnRemark, column);
    TdSqlDataType sqlDataType = createDataType(dataType, typeName, decimalDigits, numPrecRadix);
    column.setSqlDataType(sqlDataType);
    try {
        if (isIBMDB2ZOS || isTeradataSqlModel || isSAS) {
            column.getSqlDataType().setNullable(NullableType.get(resutSet.getInt(GetColumn.IS_NULLABLE.name())));
        } else {
            column.getSqlDataType().setNullable(NullableType.get(resutSet.getInt(GetColumn.NULLABLE.name())));
        }
    } catch (Exception e1) {
        log.warn(e1, e1);
    }
    column.setInitialValue(defExpression);
    String mapping = databaseconnection == null ? null : databaseconnection.getDbmsId();
    if (databaseconnection != null && mapping != null) {
        MappingTypeRetriever mappingTypeRetriever = MetadataTalendType.getMappingTypeRetriever(mapping);
        String talendType = mappingTypeRetriever.getDefaultSelectedTalendType(typeName, ExtractMetaDataUtils.getInstance().getIntMetaDataInfo(resutSet, "String_Node_Str"), ExtractMetaDataUtils.getInstance().getIntMetaDataInfo(resutSet, "String_Node_Str"));
        column.setTalendType(talendType);
    }
    try {
        column.setNullable("String_Node_Str".equals(resutSet.getString(GetColumn.IS_NULLABLE.name())));
    } catch (Exception e) {
        column.setNullable(false);
    }
    return column;
}

Output:
         MappingTypeRetriever mappingTypeRetriever = MetadataTalendType.getMappingTypeRetriever(mapping);
-        String talendType = mappingTypeRetriever.getDefaultSelectedTalendType(typeName, ExtractMetaDataUtils.getInstance().getIntMetaDataInfo(resutSet, "String_Node_Str"), ExtractMetaDataUtils.getInstance().getIntMetaDataInfo(resutSet, "String_Node_Str"));
-        column.setTalendType(talendType);
+        if (mappingTypeRetriever != null) {
+            String talendType = mappingTypeRetriever.getDefaultSelectedTalendType(typeName, ExtractMetaDataUtils.getInstance().getIntMetaDataInfo(resutSet, "String_Node_Str"), ExtractMetaDataUtils.getInstance().getIntMetaDataInfo(resutSet, "String_Node_Str"));
+            column.setTalendType(talendType);
+        }
     }


Input:
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.pre_jogo_page);
    contadorTextView = (TextView) findViewById(R.id.pre_jogo_contador);
    setContador(inicializaContador());
    Intent intent = getIntent();
    jogo = (Jogo) intent.getSerializableExtra("String_Node_Str");
    tempoDesejado = intent.getLongExtra("String_Node_Str", 180000);
    preJogoIntent = new Intent(PreJogoAdedonhaActivity.this, JogoAdedonhaActivity.class);
    preJogoIntent.putExtra("String_Node_Str", jogo);
    preJogoIntent.putExtra("String_Node_Str", tempoDesejado);
}

Output:
     Intent intent = getIntent();
-    jogo = (Jogo) intent.getSerializableExtra("String_Node_Str");
-    tempoDesejado = intent.getLongExtra("String_Node_Str", 180000);
-    preJogoIntent = new Intent(PreJogoAdedonhaActivity.this, JogoAdedonhaActivity.class);
-    preJogoIntent.putExtra("String_Node_Str", jogo);
-    preJogoIntent.putExtra("String_Node_Str", tempoDesejado);
+    ConfiguracaoParatida configuracao = (ConfiguracaoParatida) intent.getSerializableExtra(ConfiguracaoParatida.CONFIGURACAO);
+    Jogador jogador = (Jogador) intent.getSerializableExtra(Jogador.JOGADOR);
+    this.preJogoIntent = new Intent(PreJogoAdedonhaActivity.this, JogoAdedonhaActivity.class);
+    this.preJogoIntent.putExtra(Jogador.JOGADOR, jogador);
+    this.preJogoIntent.putExtra(ConfiguracaoParatida.CONFIGURACAO, configuracao);
 }


Input:
public synchronized boolean joinTournament(UUID userId, String name, String playerType, int skill) throws GameException {
    if (table.getState() != TableState.WAITING) {
        return false;
    }
    Seat seat = table.getNextAvailableSeat(playerType);
    if (seat == null) {
        throw new GameException("String_Node_Str");
    }
    User user = UserManager.getInstance().getUser(userId);
    if (user == null) {
        logger.fatal(new StringBuilder("String_Node_Str").append(name).append("String_Node_Str").append(userId).toString());
        return false;
    }
    if (userPlayerMap.containsKey(userId)) {
        user.showUserMessage("String_Node_Str", new StringBuilder("String_Node_Str").toString());
        return false;
    }
    Player player = createPlayer(name, seat.getPlayerType(), skill);
    if (player != null) {
        if (!player.canJoinTable(table)) {
            user.showUserMessage("String_Node_Str", new StringBuilder("String_Node_Str").append(seat.getPlayerType()).append("String_Node_Str").toString());
            return false;
        }
        tournament.addPlayer(player, seat.getPlayerType());
        table.joinTable(player, seat);
        logger.debug("String_Node_Str" + player.getId());
        if (seat.getPlayer().isHuman()) {
            user.addTable(player.getId(), table);
            user.joinedTable(table.getRoomId(), table.getId(), true);
            userPlayerMap.put(userId, player.getId());
        }
        return true;
    } else {
        throw new GameException("String_Node_Str" + seat.getPlayerType().toString() + "String_Node_Str");
    }
}

Output:
     }
-    if (userPlayerMap.containsKey(userId)) {
+    if (userPlayerMap.containsKey(userId) && playerType.equals("String_Node_Str")) {
         user.showUserMessage("String_Node_Str", new StringBuilder("String_Node_Str").toString());


Input:
public JsonValue liveSynchronize(final String objectType, final JsonValue previousStage) throws ResourceException {
    if (!serviceAvailable) {
        return previousStage;
    }
    JsonValue stage = previousStage != null ? previousStage.copy() : new JsonValue(new LinkedHashMap<String, Object>());
    JsonValue connectorData = stage.get("String_Node_Str");
    SyncToken token = null;
    if (!connectorData.isNull()) {
        if (connectorData.isMap()) {
            token = ConnectorUtil.convertToSyncToken(connectorData);
        } else {
            throw new IllegalArgumentException("String_Node_Str");
        }
    }
    stage.remove("String_Node_Str");
    try {
        final OperationHelper helper = operationHelperBuilder.build(objectType, stage, cryptoService);
        if (helper.isOperationPermitted(SyncApiOp.class)) {
            ConnectorFacade connector = getConnectorFacade();
            SyncApiOp operation = (SyncApiOp) connector.getOperation(SyncApiOp.class);
            if (null == operation) {
                throw new UnsupportedOperationException(SyncApiOp.class.getCanonicalName());
            }
            if (null == token) {
                token = operation.getLatestSyncToken(helper.getObjectClass());
                logger.debug("String_Node_Str", token);
            } else {
                final SyncToken[] lastToken = new SyncToken[] { token };
                final String[] failedRecord = new String[1];
                OperationOptionsBuilder operationOptionsBuilder = helper.getOperationOptionsBuilder(SyncApiOp.class, null, previousStage);
                try {
                    logger.debug("String_Node_Str", new Object[] { helper.getObjectClass().getObjectClassValue(), token });
                    SyncToken syncToken = operation.sync(helper.getObjectClass(), token, new SyncResultsHandler() {
                        public boolean handle(SyncDelta syncDelta) {
                            try {
                                final String resourceId = syncDelta.getUid().getUidValue();
                                final String resourceContainer = getSource(objectType);
                                final JsonValue content = new JsonValue(new LinkedHashMap<String, Object>(2));
                                switch(syncDelta.getDeltaType()) {
                                    case CREATE:
                                        {
                                            JsonValue deltaObject = helper.build(syncDelta.getObject());
                                            content.put("String_Node_Str", null);
                                            content.put("String_Node_Str", deltaObject.getObject());
                                            ActionRequest onCreateRequest = Requests.newActionRequest("String_Node_Str", "String_Node_Str").setAdditionalParameter("String_Node_Str", resourceContainer).setAdditionalParameter("String_Node_Str", resourceId).setContent(content);
                                            connectionFactory.getConnection().action(routerContext, onCreateRequest);
                                            activityLogger.log(routerContext, RequestType.ACTION, "String_Node_Str", onCreateRequest.getResourceName(), deltaObject, deltaObject, Status.SUCCESS);
                                            break;
                                        }
                                    case UPDATE:
                                    case CREATE_OR_UPDATE:
                                        {
                                            JsonValue deltaObject = helper.build(syncDelta.getObject());
                                            content.put("String_Node_Str", null);
                                            content.put("String_Node_Str", deltaObject.getObject());
                                            if (null != syncDelta.getPreviousUid()) {
                                                deltaObject.put("String_Node_Str", syncDelta.getPreviousUid().getUidValue());
                                            }
                                            ActionRequest onUpdateRequest = Requests.newActionRequest("String_Node_Str", "String_Node_Str").setAdditionalParameter("String_Node_Str", resourceContainer).setAdditionalParameter("String_Node_Str", resourceId).setContent(content);
                                            connectionFactory.getConnection().action(routerContext, onUpdateRequest);
                                            activityLogger.log(routerContext, RequestType.ACTION, "String_Node_Str", onUpdateRequest.getResourceName(), deltaObject, deltaObject, Status.SUCCESS);
                                            break;
                                        }
                                    case DELETE:
                                        content.put("String_Node_Str", null);
                                        ActionRequest onDeleteRequest = Requests.newActionRequest("String_Node_Str", "String_Node_Str").setAdditionalParameter("String_Node_Str", resourceContainer).setAdditionalParameter("String_Node_Str", resourceId).setContent(content);
                                        connectionFactory.getConnection().action(routerContext, onDeleteRequest);
                                        activityLogger.log(routerContext, RequestType.ACTION, "String_Node_Str", onDeleteRequest.getResourceName(), null, null, Status.SUCCESS);
                                        break;
                                }
                            } catch (Exception e) {
                                failedRecord[0] = SerializerUtil.serializeXmlObject(syncDelta, true);
                                if (logger.isDebugEnabled()) {
                                    logger.error("String_Node_Str", syncDelta.getUid(), syncFailureHandler, e);
                                }
                                Map<String, Object> syncFailure = new HashMap<String, Object>(6);
                                syncFailure.put("String_Node_Str", syncDelta.getToken().getValue());
                                syncFailure.put("String_Node_Str", systemIdentifier.getName());
                                syncFailure.put("String_Node_Str", objectType);
                                syncFailure.put("String_Node_Str", syncDelta.getUid().getUidValue());
                                syncFailure.put("String_Node_Str", failedRecord[0]);
                                syncFailureHandler.invoke(syncFailure, e);
                            }
                            lastToken[0] = syncDelta.getToken();
                            return true;
                        }
                    }, operationOptionsBuilder.build());
                    if (syncToken != null) {
                        lastToken[0] = syncToken;
                    }
                } catch (Throwable t) {
                    Map<String, Object> lastException = new LinkedHashMap<String, Object>(2);
                    lastException.put("String_Node_Str", t.getMessage());
                    if (null != failedRecord[0]) {
                        lastException.put("String_Node_Str", failedRecord[0]);
                    }
                    stage.put("String_Node_Str", lastException);
                    if (logger.isDebugEnabled()) {
                        logger.error("String_Node_Str", new Object[] { objectType, systemIdentifier.getName() }, t);
                    }
                } finally {
                    token = lastToken[0];
                    logger.debug("String_Node_Str", token);
                }
            }
            if (null != token) {
                stage.put("String_Node_Str", ConnectorUtil.convertFromSyncToken(token));
            }
        }
    } catch (ResourceException e) {
        logger.debug("String_Node_Str", e);
        throw new RuntimeException(e);
    } catch (UnsupportedOperationException e) {
        logger.debug("String_Node_Str", e);
        throw new NotFoundException("String_Node_Str" + e.getMessage(), e);
    } catch (Exception e) {
        logger.debug("String_Node_Str", e);
        throw new InternalServerErrorException("String_Node_Str" + e.getMessage(), e);
    }
    return stage;
}

Output:
         logger.debug("String_Node_Str", e);
-        throw new NotFoundException("String_Node_Str" + e.getMessage(), e);
+        throw new NotFoundException("String_Node_Str", e).setDetail(new JsonValue(e.getMessage()));
     } catch (Exception e) {


Input:
public String getText(Object element) {
    if (element instanceof IContainer) {
        return ((IContainer) element).getName();
    } else if (element instanceof IFolderNode) {
        IFolderNode node = ((IFolderNode) element);
        if (node.isLoaded()) {
            return ((IFolderNode) element).getName() + "String_Node_Str" + ((IFolderNode) element).getChildren().length + "String_Node_Str";
        } else {
            return ((IFolderNode) element).getName();
        }
    }
    String text = super.getText(element);
    if (text.endsWith(PluginConstant.PRV_SUFFIX)) {
        IFile file = (IFile) element;
        TypedReturnCode<TdDataProvider> rc = PrvResourceFileHelper.getInstance().getTdProvider(file);
        String decorateText = PluginConstant.EMPTY_STRING;
        if (rc.isOk()) {
            decorateText = rc.getObject().getName();
        } else {
            log.warn(rc.getMessage());
        }
        return decorateText;
    }
    if (element instanceof TdTable) {
        text = text + "String_Node_Str" + TableHelper.getColumns((TdTable) element).size() + "String_Node_Str";
    }
    if (element instanceof TdView) {
        text = text + "String_Node_Str" + ViewHelper.getColumns((TdView) element).size() + "String_Node_Str";
    }
    return text;
}

Output:
     } else if (element instanceof IFolderNode) {
-        IFolderNode node = ((IFolderNode) element);
-        if (node.isLoaded()) {
-            return ((IFolderNode) element).getName() + "String_Node_Str" + ((IFolderNode) element).getChildren().length + "String_Node_Str";
-        } else {
-            return ((IFolderNode) element).getName();
-        }
+        return ((IFolderNode) element).getName();
     }


Input:
public Report execute(IndexService index, ModelService model, StorageService storage, List<TransferredResource> resources) throws PluginException {
    Report report = PluginHelper.createPluginReport(this);
    Report pluginReport;
    Map<String, Report> reports = new HashMap<>();
    aipIdToTransferredResourceId = new HashMap<>();
    Date startDate = new Date();
    String parentId = PluginHelper.getStringFromParameters(this, PARAMETER_PARENT_ID);
    boolean forceParentId = PluginHelper.getBooleanFromParameters(this, PARAMETER_FORCE_PARENT_ID);
    getParameterValues().put(RodaConstants.PLUGIN_PARAMS_PARENT_ID, parentId);
    getParameterValues().put(RodaConstants.PLUGIN_PARAMS_FORCE_PARENT_ID, forceParentId ? "String_Node_Str" : "String_Node_Str");
    pluginReport = transformTransferredResourceIntoAnAIP(index, model, storage, resources);
    reports = mergeReports(reports, pluginReport);
    List<AIP> aips = getAIPsFromReports(index, model, storage, reports);
    stepsCompleted = PluginHelper.updateJobStatus(this, index, model, stepsCompleted, totalSteps);
    createIngestStartedEvent(model, index, aipIdToTransferredResourceId, startDate);
    if (PluginHelper.verifyIfStepShouldBePerformed(this, PARAMETER_DO_VIRUS_CHECK)) {
        pluginReport = doVirusCheck(index, model, storage, aips);
        reports = mergeReports(reports, pluginReport);
        stepsCompleted = PluginHelper.updateJobStatus(this, index, model, stepsCompleted, totalSteps);
        aips = recalculateAIPsList(aips, reports, aipIdToTransferredResourceId);
    }
    if (PluginHelper.verifyIfStepShouldBePerformed(this, PARAMETER_DO_PDFTOPDFA_CONVERSION)) {
        Map<String, String> params = new HashMap<String, String>();
        params.put("String_Node_Str", "String_Node_Str");
        pluginReport = doPDFtoPDFAConversion(index, model, storage, aips, params);
        reports = mergeReports(reports, pluginReport);
        stepsCompleted = PluginHelper.updateJobStatus(this, index, model, stepsCompleted, totalSteps);
    }
    if (PluginHelper.verifyIfStepShouldBePerformed(this, PARAMETER_DO_VERAPDF_CHECK)) {
        Map<String, String> params = new HashMap<String, String>();
        params.put("String_Node_Str", "String_Node_Str");
        params.put("String_Node_Str", "String_Node_Str");
        params.put("String_Node_Str", "String_Node_Str");
        pluginReport = doVeraPDFCheck(index, model, storage, aips, params);
        reports = mergeReports(reports, pluginReport);
        stepsCompleted = PluginHelper.updateJobStatus(this, index, model, stepsCompleted, totalSteps);
    }
    pluginReport = createPremisSkeleton(index, model, storage, aips);
    reports = mergeReports(reports, pluginReport);
    stepsCompleted = PluginHelper.updateJobStatus(this, index, model, stepsCompleted, totalSteps);
    aips = recalculateAIPsList(aips, reports, aipIdToTransferredResourceId);
    pluginReport = verifyIfAipIsWellFormed(index, model, storage, aips);
    reports = mergeReports(reports, pluginReport);
    stepsCompleted = PluginHelper.updateJobStatus(this, index, model, stepsCompleted, totalSteps);
    aips = recalculateAIPsList(aips, reports, aipIdToTransferredResourceId);
    pluginReport = verifyProducerAuthorization(index, model, storage, aips);
    reports = mergeReports(reports, pluginReport);
    stepsCompleted = PluginHelper.updateJobStatus(this, index, model, stepsCompleted, totalSteps);
    aips = recalculateAIPsList(aips, reports, aipIdToTransferredResourceId);
    if (PluginHelper.verifyIfStepShouldBePerformed(this, PARAMETER_DO_FILE_FORMAT_IDENTIFICATION)) {
        pluginReport = doFileFormatIdentification(index, model, storage, aips);
        reports = mergeReports(reports, pluginReport);
        stepsCompleted = PluginHelper.updateJobStatus(this, index, model, stepsCompleted, totalSteps);
    }
    if (PluginHelper.verifyIfStepShouldBePerformed(this, PARAMETER_DO_METADATA_AND_FULL_TEXT_EXTRACTION)) {
        pluginReport = doMetadataAndFullTextExtraction(index, model, storage, aips);
        reports = mergeReports(reports, pluginReport);
        stepsCompleted = PluginHelper.updateJobStatus(this, index, model, stepsCompleted, totalSteps);
    }
    if (PluginHelper.verifyIfStepShouldBePerformed(this, PARAMETER_DO_AUTO_ACCEPT)) {
        pluginReport = doAutoAccept(index, model, storage, aips);
        reports = mergeReports(reports, pluginReport);
    }
    createIngestEndedEvent(model, index, aips, reports, aipIdToTransferredResourceId);
    return report;
}

Output:
     pluginReport = transformTransferredResourceIntoAnAIP(index, model, storage, resources);
-    reports = mergeReports(reports, pluginReport);
+    reports = mergeReports(reports, aipIdToTransferredResourceId, pluginReport);
     List<AIP> aips = getAIPsFromReports(index, model, storage, reports);


Input:
public void requestClose() throws IOException, InterruptedException {
    if (!this.closeRequested) {
        this.closeRequested = true;
        if (this.serializationBuffer.dataLeftFromPreviousSerialization()) {
            flush();
        }
        if (!isBroadcastChannel() || getChannelIndex() == 0) {
            transferEvent(new ByteBufferedChannelCloseEvent());
            flush();
        }
    }
}

Output:
         }
-        if (!isBroadcastChannel() || getChannelIndex() == 0) {
+        if (getType() == ChannelType.INMEMORY || !isBroadcastChannel() || getChannelIndex() == 0) {
             transferEvent(new ByteBufferedChannelCloseEvent());


Input:
public static void addIndex(Config c, Habitat habitat, String name) {
    habitat.addIndex(new ExistingSingletonInhabitant<Config>(c), Config.class.getName(), ServerEnvironment.DEFAULT_INSTANCE_NAME);
    ConfigBeanProxy[] dirref = { c.getAdminListener(), c.getAdminService(), c.getAlertService(), c.getAvailabilityService(), c.getConnectorService(), c.getDiagnosticService(), c.getEjbContainer(), c.getGroupManagementService(), c.getHttpService(), c.getIiopService(), c.getJavaConfig(), c.getJmsService(), c.getLogService(), c.getManagementRules(), c.getMdbContainer(), c.getMonitoringService(), c.getNetworkConfig(), c.getSecurityService(), c.getThreadPools(), c.getTransactionService(), c.getWebContainer() };
    for (ConfigBeanProxy cbp : dirref) {
        if (cbp != null) {
            habitat.addIndex(new ExistingSingletonInhabitant<ConfigBeanProxy>(cbp), ConfigSupport.getImpl(cbp).getProxyType().getName(), ServerEnvironment.DEFAULT_INSTANCE_NAME);
        }
    }
    for (Container extension : c.getContainers()) {
        habitat.addIndex(new ExistingSingletonInhabitant<Container>(extension), ConfigSupport.getImpl(extension).getProxyType().getName(), ServerEnvironment.DEFAULT_INSTANCE_NAME);
    }
}

Output:
     habitat.addIndex(new ExistingSingletonInhabitant<Config>(c), Config.class.getName(), ServerEnvironment.DEFAULT_INSTANCE_NAME);
-    ConfigBeanProxy[] dirref = { c.getAdminListener(), c.getAdminService(), c.getAlertService(), c.getAvailabilityService(), c.getConnectorService(), c.getDiagnosticService(), c.getEjbContainer(), c.getGroupManagementService(), c.getHttpService(), c.getIiopService(), c.getJavaConfig(), c.getJmsService(), c.getLogService(), c.getManagementRules(), c.getMdbContainer(), c.getMonitoringService(), c.getNetworkConfig(), c.getSecurityService(), c.getThreadPools(), c.getTransactionService(), c.getWebContainer() };
+    ConfigBeanProxy[] dirref = { c.getAdminService(), c.getAlertService(), c.getAvailabilityService(), c.getConnectorService(), c.getDiagnosticService(), c.getEjbContainer(), c.getGroupManagementService(), c.getHttpService(), c.getIiopService(), c.getJavaConfig(), c.getJmsService(), c.getLogService(), c.getManagementRules(), c.getMdbContainer(), c.getMonitoringService(), c.getNetworkConfig(), c.getSecurityService(), c.getThreadPools(), c.getTransactionService(), c.getWebContainer() };
     for (ConfigBeanProxy cbp : dirref) {


Input:
public void process() {
    PerformanceMonitor.startActivity("String_Node_Str");
    sceneToneMapped = dynamicFBOsManager.get(TONE_MAPPED_URN);
    sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.ReadOnlyGBuffer.getName());
    toneMapping.enable();
    sceneToneMapped.bind();
    setViewportToSizeOf(sceneToneMapped);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    renderFullscreenQuad();
    bindDisplay();
    setViewportToSizeOf(sceneOpaque);
    PerformanceMonitor.endActivity();
}

Output:
     sceneToneMapped = dynamicFBOsManager.get(TONE_MAPPED_URN);
-    sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.ReadOnlyGBuffer.getName());
+    sceneOpaque = dynamicFBOsManager.get(DefaultDynamicFBOs.READ_ONLY_GBUFFER.getName());
     toneMapping.enable();


Input:
public void parseIcsFile_allBeginVeventMissing_noEventsProcessed() {
    LinkedList<WorkSession> testCalendar = IcsParser.parseIcsFile("String_Node_Str");
    assert (testCalendar.size() == 0);
}

Output:
 public void parseIcsFile_allBeginVeventMissing_noEventsProcessed() {
-    LinkedList<WorkSession> testCalendar = IcsParser.parseIcsFile("String_Node_Str");
-    assert (testCalendar.size() == 0);
+    testCalendar = IcsParser.parseIcsFile("String_Node_Str");
+    assertEquals(0, testCalendar.size());
 }


Input:
public boolean isRecordType() {
    return false;
}

Output:
 public boolean isRecordType() {
-    return false;
+    return toMaybeRecordType() != null;
 }


Input:
private void populateStats(String[] units, String tag, Double weight, int columnIndex, int newCCIndex) {
    ColumnConfig columnConfig = this.columnConfigList.get(columnIndex);
    CountAndFrequentItems countAndFrequentItems = this.variableCountMap.get(newCCIndex);
    if (countAndFrequentItems == null) {
        countAndFrequentItems = new CountAndFrequentItems();
        this.variableCountMap.put(newCCIndex, countAndFrequentItems);
    }
    countAndFrequentItems.offer(this.missingOrInvalidValues, units[columnIndex]);
    boolean isMissingValue = false;
    boolean isInvalidValue = false;
    BinningInfoWritable binningInfoWritable = this.columnBinningInfo.get(newCCIndex);
    if (binningInfoWritable == null) {
        return;
    }
    binningInfoWritable.setTotalCount(binningInfoWritable.getTotalCount() + 1L);
    if (columnConfig.isHybrid()) {
        int binNum = 0;
        if (units[columnIndex] == null || missingOrInvalidValues.contains(units[columnIndex].toLowerCase())) {
            isMissingValue = true;
        }
        String str = StringUtils.trim(units[columnIndex]);
        double douVal = CommonUtils.parseNumber(str);
        Double hybridThreshould = columnConfig.getHybridThreshold();
        if (hybridThreshould == null) {
            hybridThreshould = Double.NEGATIVE_INFINITY;
        }
        boolean isCategory = Double.isNaN(douVal) || douVal < hybridThreshould;
        boolean isNumber = !Double.isNaN(douVal);
        if (isMissingValue) {
            binningInfoWritable.setMissingCount(binningInfoWritable.getMissingCount() + 1L);
            binNum = binningInfoWritable.getBinCategories().size() + binningInfoWritable.getBinBoundaries().size();
        } else if (isCategory) {
            binNum = quickLocateCategoricalBin(this.categoricalBinMap.get(newCCIndex), str);
            if (binNum < 0) {
                isInvalidValue = true;
            }
            if (isInvalidValue) {
                binningInfoWritable.setMissingCount(binningInfoWritable.getMissingCount() + 1L);
                binNum = binningInfoWritable.getBinCategories().size() + binningInfoWritable.getBinBoundaries().size();
            } else {
                binNum += binningInfoWritable.getBinBoundaries().size();
                ;
            }
        } else if (isNumber) {
            binNum = getBinNum(binningInfoWritable.getBinBoundaries(), douVal);
            if (binNum == -1) {
                throw new RuntimeException("String_Node_Str");
            }
            binningInfoWritable.setSum(binningInfoWritable.getSum() + douVal);
            double squaredVal = douVal * douVal;
            binningInfoWritable.setSquaredSum(binningInfoWritable.getSquaredSum() + squaredVal);
            binningInfoWritable.setTripleSum(binningInfoWritable.getTripleSum() + squaredVal * douVal);
            binningInfoWritable.setQuarticSum(binningInfoWritable.getQuarticSum() + squaredVal * squaredVal);
            if (Double.compare(binningInfoWritable.getMax(), douVal) < 0) {
                binningInfoWritable.setMax(douVal);
            }
            if (Double.compare(binningInfoWritable.getMin(), douVal) > 0) {
                binningInfoWritable.setMin(douVal);
            }
        }
        if (posTags.contains(tag)) {
            binningInfoWritable.getBinCountPos()[binNum] += 1L;
            binningInfoWritable.getBinWeightPos()[binNum] += weight;
        } else if (negTags.contains(tag)) {
            binningInfoWritable.getBinCountNeg()[binNum] += 1L;
            binningInfoWritable.getBinWeightNeg()[binNum] += weight;
        }
    } else if (columnConfig.isCategorical()) {
        int lastBinIndex = binningInfoWritable.getBinCategories().size();
        int binNum = 0;
        if (units[columnIndex] == null || missingOrInvalidValues.contains(units[columnIndex].toLowerCase())) {
            isMissingValue = true;
        } else {
            String str = StringUtils.trim(units[columnIndex]);
            binNum = quickLocateCategoricalBin(this.categoricalBinMap.get(columnIndex), str);
            if (binNum < 0) {
                isInvalidValue = true;
            }
        }
        if (isInvalidValue || isMissingValue) {
            binningInfoWritable.setMissingCount(binningInfoWritable.getMissingCount() + 1L);
            binNum = lastBinIndex;
        }
        if (modelConfig.isRegression()) {
            if (posTags.contains(tag)) {
                binningInfoWritable.getBinCountPos()[binNum] += 1L;
                binningInfoWritable.getBinWeightPos()[binNum] += weight;
            } else if (negTags.contains(tag)) {
                binningInfoWritable.getBinCountNeg()[binNum] += 1L;
                binningInfoWritable.getBinWeightNeg()[binNum] += weight;
            }
        } else {
            binningInfoWritable.getBinCountPos()[binNum] += 1L;
            binningInfoWritable.getBinWeightPos()[binNum] += weight;
        }
    } else if (columnConfig.isNumerical()) {
        int lastBinIndex = binningInfoWritable.getBinBoundaries().size();
        double douVal = 0.0;
        if (units[columnIndex] == null || units[columnIndex].length() == 0) {
            isMissingValue = true;
        } else {
            try {
                douVal = Double.parseDouble(units[columnIndex].trim());
            } catch (Exception e) {
                isInvalidValue = true;
            }
        }
        if (Double.compare(douVal, modelConfig.getNumericalValueThreshold()) > 0) {
            isInvalidValue = true;
        }
        if (isInvalidValue || isMissingValue) {
            binningInfoWritable.setMissingCount(binningInfoWritable.getMissingCount() + 1L);
            if (modelConfig.isRegression()) {
                if (posTags.contains(tag)) {
                    binningInfoWritable.getBinCountPos()[lastBinIndex] += 1L;
                    binningInfoWritable.getBinWeightPos()[lastBinIndex] += weight;
                } else if (negTags.contains(tag)) {
                    binningInfoWritable.getBinCountNeg()[lastBinIndex] += 1L;
                    binningInfoWritable.getBinWeightNeg()[lastBinIndex] += weight;
                }
            }
        } else {
            int binNum = getBinNum(binningInfoWritable.getBinBoundaries(), units[columnIndex]);
            if (binNum == -1) {
                throw new RuntimeException("String_Node_Str");
            }
            if (modelConfig.isRegression()) {
                if (posTags.contains(tag)) {
                    binningInfoWritable.getBinCountPos()[binNum] += 1L;
                    binningInfoWritable.getBinWeightPos()[binNum] += weight;
                } else if (negTags.contains(tag)) {
                    binningInfoWritable.getBinCountNeg()[binNum] += 1L;
                    binningInfoWritable.getBinWeightNeg()[binNum] += weight;
                }
            }
            binningInfoWritable.setSum(binningInfoWritable.getSum() + douVal);
            double squaredVal = douVal * douVal;
            binningInfoWritable.setSquaredSum(binningInfoWritable.getSquaredSum() + squaredVal);
            binningInfoWritable.setTripleSum(binningInfoWritable.getTripleSum() + squaredVal * douVal);
            binningInfoWritable.setQuarticSum(binningInfoWritable.getQuarticSum() + squaredVal * squaredVal);
            if (Double.compare(binningInfoWritable.getMax(), douVal) < 0) {
                binningInfoWritable.setMax(douVal);
            }
            if (Double.compare(binningInfoWritable.getMin(), douVal) > 0) {
                binningInfoWritable.setMin(douVal);
            }
        }
    }
}

Output:
             String str = StringUtils.trim(units[columnIndex]);
-            binNum = quickLocateCategoricalBin(this.categoricalBinMap.get(columnIndex), str);
+            binNum = quickLocateCategoricalBin(this.categoricalBinMap.get(newCCIndex), str);
             if (binNum < 0) {


Input:
public Collection getMethods() {
    ArrayList<JavaMethod> methodCollection = new ArrayList<JavaMethod>();
    Method[] methods = jClass.getMethods();
    for (Method method : methods) {
        methodCollection.add(new JavaMethodImpl(method));
    }
    return methodCollection;
}

Output:
     ArrayList<JavaMethod> methodCollection = new ArrayList<JavaMethod>();
-    Method[] methods = jClass.getMethods();
+    Method[] methods = PrivilegedAccessHelper.getMethods(jClass);
     for (Method method : methods) {


Input:
protected void paintComponent(java.awt.Graphics g) {
    super.paintComponent(g);
    Graphics2D graphics = (Graphics2D) g.create();
    int w = this.getWidth();
    int h = this.getHeight();
    if ((_mp != null) && (_vrc != null)) {
        VideoDataBuffer buffer = new VideoDataBuffer(null, 0, 0, 0, VideoDataBuffer.Format.BGR);
        _vrc.getData(buffer);
        IntBuffer intBuffer = (IntBuffer) buffer.getBuffer();
        BufferedImage image = (BufferedImage) createImage(buffer.getWidth(), buffer.getHeight());
        image.setRGB(0, 0, buffer.getWidth(), buffer.getHeight(), intBuffer.array(), 0, buffer.getWidth());
        AffineTransform transform = new AffineTransform();
        transform.scale(1, -1);
        transform.translate(0, -buffer.getHeight());
        graphics.drawImage(image, transform, this);
        _vrc.releaseData(buffer);
        graphics.setComposite(AlphaComposite.SrcOver);
        graphics.setColor(Color.red.darker());
        graphics.setFont(new Font("String_Node_Str", Font.BOLD, 12));
        graphics.drawString("String_Node_Str" + format(_mp.getMediaTime()), 10, 20);
        graphics.drawString("String_Node_Str" + format(_mp.getDuration()), 10, 40);
        graphics.drawString("String_Node_Str" + _mp.getRate(), 10, 60);
    }
}

Output:
         IntBuffer intBuffer = (IntBuffer) buffer.getBuffer();
-        BufferedImage image = (BufferedImage) createImage(buffer.getWidth(), buffer.getHeight());
-        image.setRGB(0, 0, buffer.getWidth(), buffer.getHeight(), intBuffer.array(), 0, buffer.getWidth());
-        AffineTransform transform = new AffineTransform();
-        transform.scale(1, -1);
-        transform.translate(0, -buffer.getHeight());
-        graphics.drawImage(image, transform, this);
+        if (intBuffer != null) {
+            BufferedImage image = (BufferedImage) createImage(buffer.getWidth(), buffer.getHeight());
+            image.setRGB(0, 0, buffer.getWidth(), buffer.getHeight(), intBuffer.array(), 0, buffer.getWidth());
+            AffineTransform transform = new AffineTransform();
+            transform.scale(1, -1);
+            transform.translate(0, -buffer.getHeight());
+            graphics.drawImage(image, transform, this);
+        }
         _vrc.releaseData(buffer);


Input:
public CountDownRiakFuture newRiakFuture(String name) {
    ChannelPipeline pipeline = this.channel.getPipeline();
    return new CountDownRiakFuture(name, pipeline);
}

Output:
 public CountDownRiakFuture newRiakFuture(String name) {
-    ChannelPipeline pipeline = this.channel.getPipeline();
-    return new CountDownRiakFuture(name, pipeline);
+    return new CountDownRiakFuture(name, this);
 }


Input:
public void addSelectionInterval(int index0, int index1) {
    if (!enabled)
        return;
    listSelection.select(index0, index1);
}

Output:
         return;
-    listSelection.select(index0, index1);
+    swingThreadSource.getReadWriteLock().writeLock().lock();
+    try {
+        listSelection.select(index0, index1);
+    } finally {
+        swingThreadSource.getReadWriteLock().writeLock().unlock();
+    }
 }


Input:
private ToolBar buildToolbar() {
    saveButton = new Button(I18N.CONSTANTS.save(), IconImageBundle.ICONS.save());
    saveButton.setEnabled(false);
    copyButton = new Button(I18N.CONSTANTS.copy());
    copyButton.setEnabled(true);
    pasteButton = new Button(I18N.CONSTANTS.paste());
    pasteButton.setEnabled(false);
    excelButton = new Button(I18N.CONSTANTS.exportToExcel(), IconImageBundle.ICONS.excel());
    excelButton.hide();
    excelForm = new FormPanel();
    excelForm.setBodyBorder(false);
    excelForm.setHeaderVisible(false);
    excelForm.setPadding(0);
    excelForm.setEncoding(Encoding.URLENCODED);
    excelForm.setMethod(Method.POST);
    excelForm.setAction(GWT.getModuleBaseURL() + "String_Node_Str");
    final ToolBar toolBar = new ToolBar();
    toolBar.setAlignment(HorizontalAlignment.RIGHT);
    toolBar.setBorders(false);
    toolBar.add(saveButton);
    toolBar.add(copyButton);
    toolBar.add(pasteButton);
    toolBar.add(new SeparatorToolItem());
    toolBar.add(excelButton);
    toolBar.add(excelForm);
    return toolBar;
}

Output:
     final ToolBar toolBar = new ToolBar();
-    toolBar.setAlignment(HorizontalAlignment.RIGHT);
+    toolBar.setAlignment(HorizontalAlignment.LEFT);
     toolBar.setBorders(false);


Input:
private void manageAttributeListeners() {
    documentAttributes = (Document) webEngineAttributes.executeScript("String_Node_Str");
    EventListenerDataMap.put(documentAttributes, new ArrayList<>());
    if (((EventTarget) documentAttributes.getElementById("String_Node_Str")) != null) {
        addEventListener(documentAttributes, "String_Node_Str", "String_Node_Str", moveNorthListener, true);
    }
    if (((EventTarget) documentAttributes.getElementById("String_Node_Str")) != null) {
        addEventListener(documentAttributes, "String_Node_Str", "String_Node_Str", moveSouthListener, true);
    }
    if (((EventTarget) documentAttributes.getElementById("String_Node_Str")) != null) {
        addEventListener(documentAttributes, "String_Node_Str", "String_Node_Str", moveWestListener, true);
    }
    if (((EventTarget) documentAttributes.getElementById("String_Node_Str")) != null) {
        addEventListener(documentAttributes, "String_Node_Str", "String_Node_Str", moveEastListener, true);
    }
    String id;
    for (InventorySlot invSlot : InventorySlot.values()) {
        id = invSlot.toString() + "String_Node_Str";
        if (invSlot != InventorySlot.WEAPON_MAIN && invSlot != InventorySlot.WEAPON_OFFHAND) {
            if (((EventTarget) documentAttributes.getElementById(id)) != null) {
                InventorySelectedItemEventListener el = new InventorySelectedItemEventListener().setClothingEquipped(Main.game.getPlayer(), invSlot);
                addEventListener(documentAttributes, id, "String_Node_Str", el, false);
                addEventListener(documentAttributes, id, "String_Node_Str", moveTooltipListener, false);
                addEventListener(documentAttributes, id, "String_Node_Str", hideTooltipListener, false);
                InventoryTooltipEventListener el2 = new InventoryTooltipEventListener().setInventorySlot(invSlot, Main.game.getPlayer());
                addEventListener(documentAttributes, id, "String_Node_Str", el2, false);
            }
        } else {
            if (((EventTarget) documentAttributes.getElementById(id)) != null) {
                InventorySelectedItemEventListener el = new InventorySelectedItemEventListener().setWeaponEquipped(Main.game.getPlayer(), invSlot);
                addEventListener(documentAttributes, id, "String_Node_Str", el, false);
                addEventListener(documentAttributes, id, "String_Node_Str", moveTooltipListener, false);
                addEventListener(documentAttributes, id, "String_Node_Str", hideTooltipListener, false);
                InventoryTooltipEventListener el2 = new InventoryTooltipEventListener().setInventorySlot(invSlot, Main.game.getPlayer());
                addEventListener(documentAttributes, id, "String_Node_Str", el2, false);
            }
        }
    }
    id = "String_Node_Str";
    if (((EventTarget) documentAttributes.getElementById(id)) != null) {
        ((EventTarget) documentAttributes.getElementById(id)).addEventListener("String_Node_Str", e -> {
            Main.getProperties().setValue(PropertyValue.calendarDisplay, !Main.getProperties().hasValue(PropertyValue.calendarDisplay));
            Main.saveProperties();
            MainController.updateUI();
        }, false);
        addEventListener(documentAttributes, id, "String_Node_Str", moveTooltipListener, false);
        addEventListener(documentAttributes, id, "String_Node_Str", hideTooltipListener, false);
        TooltipInformationEventListener el2 = new TooltipInformationEventListener().setInformation("String_Node_Str", "String_Node_Str");
        addEventListener(documentAttributes, id, "String_Node_Str", el2, false);
    }
    id = "String_Node_Str";
    if (((EventTarget) documentAttributes.getElementById(id)) != null) {
        ((EventTarget) documentAttributes.getElementById(id)).addEventListener("String_Node_Str", e -> {
            Main.getProperties().setValue(PropertyValue.twentyFourHourTime, !Main.getProperties().hasValue(PropertyValue.twentyFourHourTime));
            Main.saveProperties();
            MainController.updateUI();
        }, false);
        addEventListener(documentAttributes, id, "String_Node_Str", moveTooltipListener, false);
        addEventListener(documentAttributes, id, "String_Node_Str", hideTooltipListener, false);
        TooltipInformationEventListener el2 = new TooltipInformationEventListener().setInformation("String_Node_Str", "String_Node_Str");
        addEventListener(documentAttributes, id, "String_Node_Str", el2, false);
    }
    if (((EventTarget) documentAttributes.getElementById("String_Node_Str" + TFEssence.ARCANE.hashCode())) != null) {
        addEventListener(documentAttributes, "String_Node_Str" + TFEssence.ARCANE.hashCode(), "String_Node_Str", moveTooltipListener, false);
        addEventListener(documentAttributes, "String_Node_Str" + TFEssence.ARCANE.hashCode(), "String_Node_Str", hideTooltipListener, false);
        InventoryTooltipEventListener el2 = new InventoryTooltipEventListener().setEssence(TFEssence.ARCANE);
        addEventListener(documentAttributes, "String_Node_Str" + TFEssence.ARCANE.hashCode(), "String_Node_Str", el2, false);
    }
    Attribute[] attributes = { Attribute.HEALTH_MAXIMUM, Attribute.MANA_MAXIMUM, Attribute.EXPERIENCE, Attribute.MAJOR_PHYSIQUE, Attribute.MAJOR_ARCANE, Attribute.MAJOR_CORRUPTION, Attribute.AROUSAL, Attribute.LUST };
    List<GameCharacter> charactersBeingRendered = new ArrayList<>();
    if (Main.game.isInSex()) {
        charactersBeingRendered.addAll(Sex.getDominantParticipants().keySet());
        charactersBeingRendered.addAll(Sex.getSubmissiveParticipants().keySet());
    } else if (Main.game.isInCombat()) {
        charactersBeingRendered.add(Main.game.getPlayer());
        charactersBeingRendered.addAll(Combat.getAllies());
    } else {
        if (Main.game.getPlayer() != null) {
            charactersBeingRendered.add(Main.game.getPlayer());
            charactersBeingRendered.addAll(Main.game.getPlayer().getCompanions());
        }
    }
    for (GameCharacter character : charactersBeingRendered) {
        String idModifier = (character.isPlayer() ? "String_Node_Str" : "String_Node_Str" + character.getId() + "String_Node_Str");
        for (Attribute a : attributes) {
            if (((EventTarget) documentAttributes.getElementById(idModifier + a.getName())) != null) {
                if (a == Attribute.EXPERIENCE) {
                    ((EventTarget) documentAttributes.getElementById(idModifier + a.getName())).addEventListener("String_Node_Str", e -> {
                        if (character.isPlayer()) {
                            if (Main.game.isInNewWorld()) {
                                if (Main.game.getCurrentDialogueNode().getDialgoueNodeType() == DialogueNodeType.PHONE) {
                                    if (Main.game.getCurrentDialogueNode() == PhoneDialogue.CHARACTER_APPEARANCE) {
                                        openPhone();
                                    } else {
                                        Main.game.setContent(new Response("String_Node_Str", "String_Node_Str", PhoneDialogue.CHARACTER_APPEARANCE));
                                    }
                                } else if (!Main.game.getCurrentDialogueNode().isOptionsDisabled()) {
                                    if (Main.game.getCurrentDialogueNode().getDialgoueNodeType() == DialogueNodeType.NORMAL) {
                                        Main.game.saveDialogueNode();
                                    }
                                    Main.game.setContent(new Response("String_Node_Str", "String_Node_Str", PhoneDialogue.CHARACTER_APPEARANCE));
                                }
                            }
                        } else {
                            openCharactersPresent(character);
                        }
                    }, false);
                }
                addEventListener(documentAttributes, idModifier + a.getName(), "String_Node_Str", moveTooltipListener, false);
                addEventListener(documentAttributes, idModifier + a.getName(), "String_Node_Str", hideTooltipListener, false);
                TooltipInformationEventListener el = new TooltipInformationEventListener().setAttribute(a, character);
                addEventListener(documentAttributes, idModifier + a.getName(), "String_Node_Str", el, false);
            }
        }
        if (((EventTarget) documentAttributes.getElementById(idModifier + "String_Node_Str")) != null) {
            ((EventTarget) documentAttributes.getElementById(idModifier + "String_Node_Str")).addEventListener("String_Node_Str", e -> {
                if (character.isPlayer()) {
                    if (Main.game.isInNewWorld()) {
                        if (Main.game.getCurrentDialogueNode().getDialgoueNodeType() == DialogueNodeType.PHONE) {
                            if (Main.game.getCurrentDialogueNode() == PhoneDialogue.CHARACTER_LEVEL_UP) {
                                openPhone();
                            } else {
                                Main.game.setContent(new Response("String_Node_Str", "String_Node_Str", PhoneDialogue.CHARACTER_LEVEL_UP));
                            }
                        } else if (!Main.game.getCurrentDialogueNode().isOptionsDisabled()) {
                            if (Main.game.getCurrentDialogueNode().getDialgoueNodeType() == DialogueNodeType.NORMAL) {
                                Main.game.saveDialogueNode();
                            }
                            Main.game.setContent(new Response("String_Node_Str", "String_Node_Str", PhoneDialogue.CHARACTER_LEVEL_UP));
                        }
                    }
                } else {
                    openCharactersPresent(character);
                }
            }, false);
            addEventListener(documentAttributes, idModifier + "String_Node_Str", "String_Node_Str", moveTooltipListener, false);
            addEventListener(documentAttributes, idModifier + "String_Node_Str", "String_Node_Str", hideTooltipListener, false);
            TooltipInformationEventListener el = new TooltipInformationEventListener().setExtraAttributes(character);
            addEventListener(documentAttributes, idModifier + "String_Node_Str", "String_Node_Str", el, false);
        }
        for (StatusEffect se : character.getStatusEffects()) {
            if (((EventTarget) documentAttributes.getElementById("String_Node_Str" + idModifier + se)) != null) {
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + se, "String_Node_Str", moveTooltipListener, false);
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + se, "String_Node_Str", hideTooltipListener, false);
                TooltipInformationEventListener el = new TooltipInformationEventListener().setStatusEffect(se, character);
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + se, "String_Node_Str", el, false);
            }
        }
        for (Perk trait : character.getTraits()) {
            id = "String_Node_Str" + idModifier + trait;
            if (((EventTarget) documentAttributes.getElementById(id)) != null) {
                addEventListener(documentAttributes, id, "String_Node_Str", moveTooltipListener, false);
                addEventListener(documentAttributes, id, "String_Node_Str", hideTooltipListener, false);
                TooltipInformationEventListener el = new TooltipInformationEventListener().setPerk(trait, character);
                addEventListener(documentAttributes, id, "String_Node_Str", el, false);
            }
        }
        for (Fetish f : character.getFetishes()) {
            if (((EventTarget) documentAttributes.getElementById("String_Node_Str" + idModifier + f)) != null) {
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + f, "String_Node_Str", moveTooltipListener, false);
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + f, "String_Node_Str", hideTooltipListener, false);
                TooltipInformationEventListener el = new TooltipInformationEventListener().setFetish(f, character);
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + f, "String_Node_Str", el, false);
            }
        }
        for (SpecialAttack sa : character.getSpecialAttacks()) {
            if (((EventTarget) documentAttributes.getElementById("String_Node_Str" + idModifier + sa)) != null) {
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + sa, "String_Node_Str", moveTooltipListener, false);
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + sa, "String_Node_Str", hideTooltipListener, false);
                TooltipInformationEventListener el = new TooltipInformationEventListener().setSpecialAttack(sa, character);
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + sa, "String_Node_Str", el, false);
            }
        }
        for (Spell s : character.getAllSpells()) {
            if (((EventTarget) documentAttributes.getElementById("String_Node_Str" + idModifier + s)) != null) {
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + s, "String_Node_Str", moveTooltipListener, false);
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + s, "String_Node_Str", hideTooltipListener, false);
                TooltipInformationEventListener el = new TooltipInformationEventListener().setSpell(s, character);
                addEventListener(documentAttributes, "String_Node_Str" + idModifier + s, "String_Node_Str", el, false);
            }
        }
    }
}

Output:
                             if (Main.game.isInNewWorld()) {
-                                if (Main.game.getCurrentDialogueNode().getDialgoueNodeType() == DialogueNodeType.PHONE) {
+                                if (Main.game.getCurrentDialogueNode().getDialogueNodeType() == DialogueNodeType.PHONE) {
                                     if (Main.game.getCurrentDialogueNode() == PhoneDialogue.CHARACTER_APPEARANCE) {


Input:
void flush(ArchiveFileV2 af) throws IOException {
    ByteArrayOutputStream buffer = new ByteArrayOutputStream();
    DataOutputStream out = new DataOutputStream(buffer);
    out.writeLong(DOCUMENT_TAG);
    out.writeLong(DOCUMENT_VERSION_1);
    out.writeInt(fileStatus);
    out.writeInt(blockSize);
    IOUtil.writeString(out, af.systemId);
    IOUtil.writeString(out, af.dependId);
    byte[] b = buffer.toByteArray();
    if (b.length > DEFAULT_BLOCK_SIZE) {
        throw new IOException(Messages.getFormattedString(ResourceConstants.EXCEED_MAX_BLOCK_SIZE, new Object[] { DEFAULT_BLOCK_SIZE }));
    }
    af.write(0, 0, b, 0, b.length);
}

Output:
     if (b.length > DEFAULT_BLOCK_SIZE) {
-        throw new IOException(Messages.getFormattedString(ResourceConstants.EXCEED_MAX_BLOCK_SIZE, new Object[] { DEFAULT_BLOCK_SIZE }));
+        throw new IOException(CoreMessages.getFormattedString(ResourceConstants.EXCEED_MAX_BLOCK_SIZE, new Object[] { DEFAULT_BLOCK_SIZE }));
     }


Input:
private com.stratio.streaming.commons.constants.ColumnType convertType(ColumnType columnType) throws UnsupportedException {
    com.stratio.streaming.commons.constants.ColumnType returnType = null;
    switch(columnType) {
        case BIGINT:
            returnType = com.stratio.streaming.commons.constants.ColumnType.LONG;
            break;
        case BOOLEAN:
            returnType = com.stratio.streaming.commons.constants.ColumnType.BOOLEAN;
            break;
        case DOUBLE:
            returnType = com.stratio.streaming.commons.constants.ColumnType.DOUBLE;
            break;
        case FLOAT:
            returnType = com.stratio.streaming.commons.constants.ColumnType.FLOAT;
            break;
        case INT:
            returnType = com.stratio.streaming.commons.constants.ColumnType.INTEGER;
            break;
        case TEXT:
        case VARCHAR:
            returnType = com.stratio.streaming.commons.constants.ColumnType.STRING;
            break;
        default:
            throw new UnsupportedException("String_Node_Str" + columnType.name() + "String_Node_Str");
    }
    return returnType;
}

Output:
         default:
-            throw new UnsupportedException("String_Node_Str" + columnType.name() + "String_Node_Str");
+            throw new ExecutionValidationException("String_Node_Str" + columnType.name() + "String_Node_Str");
     }