syck_badalias_initialize
514022
@JRubyMethod
    public static IRubyObject initialize(IRubyObject self, IRubyObject val) {
        ((RubyObject)self).fastSetInstanceVariable("@name", val);
        return self;
    }
1371695
@Override void init0() {
    _sums = MemoryManager.malloc8d(_nbin);
    _ssqs = MemoryManager.malloc8d(_nbin);
  }
382447
@SuppressWarnings("squid:S3346")
    private void initialize() throws ContradictionException {

        sumISizes = new long[nbDims];
        computeSumItemSizes();

        int[][] rLoads = new int[nbDims][nbBins];
        int[][] cLoads = new int[nbDims][nbBins];

        for (int i = 0; i < bins.length; i++) {
            bins[i].updateLowerBound(0, this);
            bins[i].updateUpperBound(nbBins - 1, this);
            if (bins[i].isInstantiated()) {
                for (int d = 0; d < nbDims; d++) {
                    rLoads[d][bins[i].getValue()] += iSizes[d][i];
                }
            } else {
                DisposableValueIterator it = bins[i].getValueIterator(true);
                try {
                    while (it.hasNext()) {
                        int b = it.next();
                        for (int d = 0; d < nbDims; d++) {
                            cLoads[d][b] += iSizes[d][i];
                        }
                    }
                } finally {
                    it.dispose();
                }
            }
        }

        int[] slb = new int[nbDims];
        int[] slu = new int[nbDims];
        for (int b = 0; b < nbBins; b++) {
            for (int d = 0; d < nbDims; d++) {
                assignedLoad[d][b].set(rLoads[d][b]);
                potentialLoad[d][b].set(rLoads[d][b] + cLoads[d][b]);
                loads[d][b].updateLowerBound(rLoads[d][b], this);
                loads[d][b].updateUpperBound(rLoads[d][b] + cLoads[d][b], this);
                slb[d] += loads[d][b].getLB();
                slu[d] += loads[d][b].getUB();
            }
        }

        for (int d = 0; d < nbDims; d++) {
            sumLoadInf[d].set(slb[d]);
            sumLoadSup[d].set(slu[d]);
        }

        loadsHaveChanged = getModel().getEnvironment().makeBool(false);

        if (decoKPSimple != null) {
            decoKPSimple.postInitialize();
        }

        assert checkLoadConsistency();

        for (IIntDeltaMonitor delta : deltaMonitor) {
            delta.unfreeze();
        }
    }
1117807
function createGetAlias(aliases) {
    if (isPlainObject(aliases) && !Array.isArray(aliases)) {
        aliases = Object.keys(aliases).map((key) => { // eslint-disable-line
            let onlyModule = false;
            let obj = aliases[key];
            if (/\$$/.test(key)) {
                onlyModule = true;
                key = key.substr(0, key.length - 1); // eslint-disable-line
            }
            if (isString(obj)) {
                obj = {
                    alias: obj,
                };
            }
            return {
                name: key,
                onlyModule,
                ...obj,
            };
        });
    }

    return (request) => {
        for (const alias of aliases) {
            if ((!alias.onlyModule && request.indexOf(`${alias.name}/`) === 0) || request === alias.name) {
                if (request.indexOf(`${alias.alias}/`) !== 0 && request !== alias.alias) {
                    return alias.alias + request.substr(alias.name.length);
                }
            }
        }
        return request;
    };
}
658965
function init() {
    var stateFromHash = getStateFromHash();
    var stateChanged = false;

    if (typeof defaults === 'object' && defaults) {
      Object.keys(defaults).forEach(function(key) {
        if (key in stateFromHash) return;

        stateFromHash[key] = defaults[key]
        stateChanged = true;
      });
    }

    if (stateChanged) set(stateFromHash);
  }
234936
public void init(InputStream is, OutputStream os)
  {
    _is = is;
    _os = os;
    _needsFlush = false;
  }
1221962
def _init_rabit():
    """"""
    if _LIB is not None:
        _LIB.RabitGetRank.restype = ctypes.c_int
        _LIB.RabitGetWorldSize.restype = ctypes.c_int
        _LIB.RabitIsDistributed.restype = ctypes.c_int
        _LIB.RabitVersionNumber.restype = ctypes.c_int
1093121
function Init(appGlobal, pathsList) {
            debug("Initializing Boot");
            loadFinder = new Finder();
            loadProvider = new Provider();
            loadNamespace = new Namespace();
            global = appGlobal;
            global.App = {};
            global.Modules = {};
            global.Config = {};
            this.initProviders(sortProvider);
            this.initApplication();
            this.initModules();
            var mainApp = require("../express");
            this.boot(mainApp);
            mainApp.boot = function (nameProvider, userApp) {
                debug("Booting Manual Provider");
                loadProvider.bootProvider(nameProvider, userApp ? userApp : mainApp);
            };
            mainApp.provider = function (nameProvider) {
                debug("Getting " + nameProvider + " Provider");
                return loadProvider.providerByName(nameProvider).instance;
            };
            return mainApp;
        }
547275
def initialize(self, symbolic_vm: LaserEVM):
        

        @symbolic_vm.pre_hook("SSTORE")
        def mutator_hook(global_state: GlobalState):
            global_state.annotate(MutationAnnotation())

        @symbolic_vm.laser_hook("add_world_state")
        def world_state_filter_hook(global_state: GlobalState):
            if And(
                *global_state.mstate.constraints[:]
                + [
                    global_state.environment.callvalue
                    > symbol_factory.BitVecVal(0, 256)
                ]
            ).is_false:
                return
            if isinstance(
                global_state.current_transaction, ContractCreationTransaction
            ):
                return
            if len(list(global_state.get_annotations(MutationAnnotation))) == 0:
                raise PluginSkipWorldState
368619
def _initializer_wrapper(actual_initializer, *rest):
    
    signal.signal(signal.SIGINT, signal.SIG_IGN)
    if actual_initializer is not None:
        actual_initializer(*rest)
704961
@Override
  public final void initialize(final Password pconstraintAnnotation) {
    messageBlacklist = pconstraintAnnotation.messageBlacklist();
    messageStartCharacters = pconstraintAnnotation.messageStartCharacters();
    messageMaxRepeat = pconstraintAnnotation.messageMaxRepeat();
    minRules = pconstraintAnnotation.minRules();
    if (pconstraintAnnotation.blacklist() == null) {
      blacklist = Collections.emptyList();
    } else {
      blacklist = Arrays.asList(StringUtils.split(pconstraintAnnotation.blacklist(), ',')).stream()
          .filter(entry -> StringUtils.isNotEmpty(entry)).map(entry -> entry.trim().toLowerCase())
          .collect(Collectors.toList());
    }
    if (StringUtils.isEmpty(pconstraintAnnotation.disalowedStartChars())) {
      disalowedStartChars = null;
    } else {
      disalowedStartChars = pconstraintAnnotation.disalowedStartChars().toCharArray();
    }
    maxRepeatChar = pconstraintAnnotation.maxRepeatChar();
  }
641831
def init():
    
    global LABELS
    global LET_ASSIGNMENT
    global PRINT_IS_USED
    global SYMBOL_TABLE

    global ast
    global data_ast
    global optemps
    global OPTIONS
    global last_brk_linenum

    LABELS = {}
    LET_ASSIGNMENT = False
    PRINT_IS_USED = False
    last_brk_linenum = 0

    ast = None
    data_ast = None  # Global Variables AST
    optemps = OpcodesTemps()

    gl.INITS.clear()
    del gl.FUNCTION_CALLS[:]
    del gl.FUNCTION_LEVEL[:]
    del gl.FUNCTIONS[:]
    SYMBOL_TABLE = gl.SYMBOL_TABLE = api.symboltable.SymbolTable()
    OPTIONS = api.config.OPTIONS

    # DATAs info
    gl.DATA_LABELS.clear()
    gl.DATA_IS_USED = False
    del gl.DATAS[:]
    gl.DATA_PTR_CURRENT = api.utils.current_data_label()
    gl.DATA_FUNCTIONS = []
    gl.error_msg_cache.clear()
878528
public void createWithDepth(int allowableDepth, TreeGP manager, TGPInitializationStrategy initializationStrategy){

      final int constantCount = manager.getConstants().size();
      for(int i=0; i < constantCount; ++i){
         constantSet.add(new Terminal("c" + i, manager.constant(i), manager.constantText(i), true), manager.constantWeight(i));
      }

      final int registerCount = manager.getVariableCount();
      for(int i=0; i < registerCount; ++i) {
         variableSet.add(new Terminal("v" + i, 0.0, "", false), 1.0);
      }

      final int operatorCount = manager.getOperatorSet().size();
      for(int i=0; i < operatorCount; ++i) {
         Primitive operator = manager.getOperatorSet().get(i);
         operatorSet.add(operator, manager.getOperatorSet().getWeight(i));
      }

      root = TreeGenerator.createWithDepth(this, allowableDepth, manager, initializationStrategy);
      calcLength();
      calcDepth();
   }
1108379
def sg_init(sess):
     
    """
    # initialize variables
    sess.run(tf.group(tf.global_variables_initializer(),
                      tf.local_variables_initializer()))
797983
private void init(){

		// First try identifying a prefix
		String[] prefix = name.split(":", 2);
		mySource = null;
		if(prefix.length > 1) {
			// Match Source prefixes
			String suffix = prefix[1];
			try {
				mySource = Source.valueOf(prefix[0].toUpperCase());
			} catch( IllegalArgumentException e ) {
				// unrecognized prefix; fall back on guessing
				mySource = null;
			}
			if(mySource != null) {
				switch( mySource) {
				case SCOP:
					if( ! initFromScop(suffix) )
						throw new IllegalArgumentException("Malformed SCOP domain name:"+suffix);
					return;
				case PDP:
					if( ! initFromPDP(name) )
						throw new IllegalArgumentException("Malformed PDP domain name:"+suffix);
					return;
				case CATH:
					if( ! initFromCATH(suffix) )
						throw new IllegalArgumentException("Malformed CATH domain name:"+suffix);
					return;
				case BIO:
					if( ! initFromBIO(name) )
						throw new IllegalArgumentException("Malformed BIO name:"+suffix);
					return;
				case ECOD:
					if( ! initFromECOD(suffix) )
						throw new IllegalArgumentException("Malformed ECOD domain name:"+suffix);
					return;
				case PDB:
					if( ! initFromPDB(suffix) )
						throw new IllegalArgumentException("Malformed PDB specification:"+suffix);
					return;
				case FILE:
					// Treat file:/ prefixes as URLs
					if( ! suffix.startsWith("/")) {
						// Otherwise, treat as file
						initFromFile();
						return;
					}
					// fall through to URL case
				case URL:
					if( ! initFromURL(name))
						throw new IllegalArgumentException("Malformed URL specification:"+suffix);
					return;
				default:
					throw new IllegalStateException("Unimplemented Source "+mySource);
				}
			}
		}

		// No known prefix, so revert to guessing

		// First guess regex-based identifiers
		// SCOP domain
		if( initFromScop(name) )
			return;
		// CATH
		if( initFromCATH(name) )
			return;
		// ECOD
		if( initFromECOD(name) )
			return;
		// Never guess BIO or PDP

		// URL
		if( initFromURL(name) )
			return;

		// Guess FILE based on file existence
		File file = new File(FileDownloadUtils.expandUserHome(name));
		if( file.canRead() && !file.isDirectory() ) {
			// an attempt to mitigate issue #398. It doesn't fix it but it catches the most common case of passing a pdb id and finding a file in working dir matching it
			if (name.matches("\\d\\w\\w\\w")) {
				// the plain pdb id case, this is unlikely to be what the user wants: let's let it through but warn about it
				logger.warn("Provided 4-letter structure name '{}' matches "
						+ "file name in directory {}. Will read structure "
						+ "data from file {} and not consider the name as a "
						+ "structure identifier. If this is not what you "
						+ "want, use 'FILE:{}'",
						name, file.getAbsoluteFile().getParent(),
						file.getAbsolutePath(), name);
			} else {
				logger.info("Provided structure name '{}' matches "
						+ "file name in directory {}. Will read structure "
						+ "data from file {}.",
						name, file.getAbsoluteFile().getParent(),
						file.getAbsolutePath());
			}

			initFromFile();
			return;
		}

		// Default to PDB
		initFromPDB( name );
	}
41580
function init$1(params){
	var p = params || {};
	TRACE = p.TRACE || false;
	if (p.crossOrigin) { crossOrigin = p.crossOrigin; }
	if (p.baseUrl) { baseUrl = p.baseUrl; }
	if (baseUrl.slice(-1) !== '/') { baseUrl += '/'; }

	loader = new altspace.utilities.shims.OBJMTLLoader();
	loader.crossOrigin = crossOrigin;
	if (TRACE) { console.log('MultiLoader initialized with params', params); }
}
863976
private static function _initialize() 
    {
        for ($i=self::SINGULAR; $i <= self::IRREGULAR; $i++) {
            if (!array_key_exists($i, self::$_inflections)) {
                self::$_inflections[$i] = array();
            }
        }
    }