minified umd standalone library
542322
function min() {
  return gulp.src(pack.main)
    .pipe(uglify())
    .on('error', gutil.log)
    .pipe(rename({ extname: minext + '.js' }))
    .pipe(gulp.dest('./'));
}
201817
function ui5CompileLessLib(oFile) {
  const sDestDir = path.dirname(oFile.path)
  const sFileName = oFile.path.split(path.sep).pop()
  const sLessFileContent = oFile.contents.toString('utf8')

  // options for less-openui5
  const oOptions = {
    lessInput: sLessFileContent,
    rootPaths: [sDestDir],
    rtl: true,
    parser: {
      filename: sFileName,
      paths: [sDestDir]
    },
    compiler: { compress: false }
  }

  // build a theme
  const oBuildThemePromise = builder
    .build(oOptions)
    .catch(oError => {
      // CSS build fails in 99% of all cases, because of a missing .less file
      // create empty LESS file and try again if build failed

      // try to parse error message to find out which missing LESS file caused the failed build
      const sMissingFileName = (oError.message.match(
        /((\.*?\/?)*\w.*\.\w+)/g
      ) || [''])[0]
      const sSourceFileName = oError.filename
      const sMissingFilePath = path.resolve(
        sDestDir,
        sSourceFileName.replace('library.source.less', ''),
        sMissingFileName
      )
      let isIssueFixed = false

      // create missing .less file (with empty content), else the library.css can't be created
      if (!fs.existsSync(sMissingFilePath)) {
        try {
          fs.writeFileSync(sMissingFilePath, '')
          isIssueFixed = true
        } catch (e) {
          isIssueFixed = false
        }
      }

      if (!isIssueFixed) {
        // if this error message raises up, the build failed due to the other 1% cases
        return Promise.reject('Compile UI5 less lib: ')
      }

      // if missing file could be created, try theme build again
      return isIssueFixed ? ui5CompileLessLib(oFile) : Promise.reject()
    })
    .then(oResult => {
      // build css content was successfull >> save result
      const aTargetFiles = [
        {
          path: `${sDestDir}/library.css`,
          content: oResult.css
        },
        {
          path: `${sDestDir}/library-RTL.css`,
          content: oResult.cssRtl
        },
        {
          path: `${sDestDir}/library-parameters.json`,
          content:
            JSON.stringify(
              oResult.variables,
              null,
              oOptions.compiler.compress ? 0 : 4
            ) || ''
        }
      ]

      const aWriteFilesPromises = aTargetFiles.map(oFile => {
        return new Promise((resolve, reject) =>
          fs.writeFile(
            oFile.path,
            oFile.content,
            oError => (oError ? reject() : resolve())
          )
        )
      })

      // return promise
      return Promise.all(aWriteFilesPromises)
    })
    .then(() => {
      // clear builder cache when finished to cleanup memory
      builder.clearCache()
      return Promise.resolve()
    })

  return oBuildThemePromise
}
371498
def main(unused_argv):
    """"""
    utils.ensure_dir_exists(os.path.dirname(FLAGS.export_path))
    if FLAGS.create_bootstrap:
        dual_net.bootstrap()
    dual_net.export_model(FLAGS.export_path)
239540
function transpileMinifyLESS(src) {
  return gulp.src(src)
    .pipe(sourcemaps.init())
    .pipe(lessCompiler({
      paths: [ path.join(__dirname, 'less', 'includes') ]
    }))
    .pipe(cssmin().on('error', function(err) {
      console.log(err);
    }))
    .pipe(rename({suffix: '.min'}))
    .pipe(sourcemaps.write())
    .pipe(gulp.dest(function (file) {
      return __dirname + file.base.slice(__dirname.length);
    }));
}
1252548
function main(options = util.getDefaultOptions()) {
  createLogger(options.debug);
  log.info(`Preparing '${options.sdk}' schemas in version '${options.version || 'latest'}'...`);

  let allLibs = {};

  // do the downloading and encapsulate in Promise
  const dlPromise = new Promise((resolve, reject) => {
    download.allLibsFile(options)
      .then((allLibsJSON) => {
        allLibs = allLibsJSON;
        download.schemas(options, allLibs)
          .then((values) => {
            resolve(values);
          })
          .catch((e) => {
            reject(e);
          });
      })
      .catch((e) => {
        reject(e);
      });
  });


  dlPromise.then(() => {
    log.info('Yay, all schema files were successfully downloaded!');
    if (options.upgrade) {
      upgrade(options, allLibs);
    }
    if (options.link) {
      link(options, allLibs);
    }
  }, (e) => {
    log.error('Damn... Something went all wrong while downloading the schema files!');
    log.error(`Are you sure the version '${options.version}' is still available on '${options.sdk}' download pages?`);
    log.error(e);
  });
}
839793
function amdDefine(sModuleName, aDependencies, vFactory) {
		var oArgs = arguments;
		var bExportIsSet = typeof oArgs[oArgs.length - 1] === "boolean";

		// bExport parameter is proprietary and should not be used for an AMD compliant define()
		if (bExportIsSet) {
			oArgs = Array.prototype.slice.call(oArgs, 0, oArgs.length - 1);
		}

		ui5Define.apply(this, oArgs);
	}
353086
def compile_less(input_file, output_file):
    
    from .modules import less

    if not isinstance(input_file, str):
        raise RuntimeError('LESS compiler takes only a single input file.')

    return {
        'dependencies_fn': less.less_dependencies,
        'compiler_fn': less.less_compile,
        'input': input_file,
        'output': output_file,
        'kwargs': {},
    }
175768
def mini(args):
    
    p = OptionParser(mini.__doc__)
    opts, args = p.parse_args(args)

    if len(args) != 2:
        sys.exit(not p.print_help())

    bamfile, region = args
    get_minibam(bamfile, region)
650734
def minify_js(input_files, output_file):
    
    from .modules import minify, utils

    if not isinstance(input_files, (list, tuple)):
        raise RuntimeError('JS minifier takes a list of input files.')

    return {
        'dependencies_fn': utils.no_dependencies,
        'compiler_fn': minify.minify_js,
        'input': input_files,
        'output': output_file,
        'kwargs': {},
    }
1122016
def _make_exe(linklibs, identifier, verbose):
    """"""
    linktxt = "$(LIBS) " if linklibs else ""
    redirect = "" if verbose else " > /dev/null"
    base = """
$(EXENAME): $(OBJSF90)
	-rm $(EXENAME) 2> /dev/null
	echo -n "Linking... "{2}
	-$(F90) $(LDFLAGS) -o $(EXENAME) $(OBJSF90) {0}>> $(LOG) 2>> $(LOG)
	echo "done."{2}
	if test -e $(EXENAME); then echo "Produced executable: $(EXENAME)"{2}; else $(SHOW_LOG); echo "Error."; fi

$(OBJSF90): %.o: %.f90
	echo -n "Compiling: $^... "{2}
	-$(F90) -c $(FFLAGS) $^ >> $(LOG) 2>> $(LOG)
	echo "done."{2}

{1}.so: $(SLIBF90)
	-rm {1}.so 2> /dev/null
	echo -n "Creating shared library..."{2}
	-$(F90) -shared -fPIC $(FFLAGS) -o {1}.so {0}$(SLIBF90) >> $(LOG) 2>> $(LOG)
	echo "done."{2}

{1}.a: $(SLIBF90)
	echo -n "Creating linked library..."{2}
	ar ru $@ $?
	ranlib $@
	echo "done."{2}

clean:
	-mv fpy_auxiliary.mod fpy_auxiliary.modt 2> /dev/null
	-mv fpy_auxiliary.o fpy_auxiliary.ot 2> /dev/null
	-mv fortpy.o fortpy.ot
	-mv fortpy.mod fortpy.modt
	-rm *.o *.mod *.i90 $(EXENAME) initializeTree.so 2> /dev/null
	-mv fpy_auxiliary.modt fpy_auxiliary.mod 2> /dev/null
	-mv fpy_auxiliary.ot fpy_auxiliary.o 2> /dev/null
	-mv fortpy.ot fortpy.o
	-mv fortpy.modt fortpy.mod
remake: clean
	-rm *.o *.mod *.i90 $(EXENAME) {1}.so
"""
    return base.format(linktxt, identifier, redirect)
1234612
function minifyScripts(scriptNames) {
  console.log("Minifying and concatting scripts.");

  var UglifyJS = require("uglify-js");

  var regexMinifed = /min.js$/;
  var regexCopyright = /^\/\*![\s\S]*?\*\//m;
  var buffer = [];
  scriptNames.forEach(function(script) {
    var scriptFile = fs.readFileSync(srcDir + script, "utf8");
    var copyright = regexCopyright.exec(scriptFile);
    if (copyright) {
      buffer.push(copyright);
    }

    // check if file is already minified
    if (!regexMinifed.test(script)) {
      var result = UglifyJS.minify(scriptFile);
      if (result.error) {
        throw new Error(error);
      }
      scriptFile = result.code;
    } else {
      console.log("> Skipping: " + script + " is already minified.");
    }

    buffer.push(scriptFile + ";");
  });

  var combined = buffer.join("\n");
  fs.writeFileSync(publishDir + scriptDir + scriptFilename, combined);
  console.log("Combined all scripts into " + scriptFilename);
}
330734
private static final int mula_small(byte[] p,byte[] q,int m,byte[] x,int n,int z) {
		int v=0;
		for (int i=0;i<n;++i) {
			v+=(q[i+m] & 0xFF)+z*(x[i] & 0xFF);
			p[i+m]=(byte)v;
			v>>=8;
		}
		return v;		
	}
1094318
function buildMain(inpOptions, callback) {
  const options = Object.assign({}, inpOptions);

  // pre process app
  const tmpObj = tmp.dirSync({ mode: '0755', unsafeCleanup: true });
  const tmpPath = tmpObj.name;

  // todo check if this is still needed on later version of packager
  const packagerConsole = new PackagerConsole();

  const progress = new DishonestProgress(5);

  async.waterfall(
    [
      (cb) => {
        progress.tick('inferring');
        optionsFactory(options)
          .then((result) => {
            cb(null, result);
          })
          .catch((error) => {
            cb(error);
          });
      },
      (opts, cb) => {
        progress.tick('copying');
        buildApp(opts.dir, tmpPath, opts, (error) => {
          if (error) {
            cb(error);
            return;
          }
          // Change the reference file for the Electron app to be the temporary path
          const newOptions = Object.assign({}, opts, {
            dir: tmpPath,
          });
          cb(null, newOptions);
        });
      },
      (opts, cb) => {
        progress.tick('icons');
        iconBuild(opts, (error, optionsWithIcon) => {
          cb(null, optionsWithIcon);
        });
      },
      (opts, cb) => {
        progress.tick('packaging');
        // maybe skip passing icon parameter to electron packager
        let packageOptions = maybeNoIconOption(opts);
        // maybe skip passing other parameters to electron packager
        packageOptions = maybeNoAppCopyrightOption(packageOptions);
        packageOptions = maybeNoAppVersionOption(packageOptions);
        packageOptions = maybeNoBuildVersionOption(packageOptions);
        packageOptions = maybeNoVersionStringOption(packageOptions);
        packageOptions = maybeNoWin32metadataOption(packageOptions);

        packagerConsole.override();

        packager(packageOptions)
          .then((appPathArray) => {
            packagerConsole.restore(); // restore console.error
            cb(null, opts, appPathArray); // options still contain the icon to waterfall
          })
          .catch((error) => {
            packagerConsole.restore(); // restore console.error
            cb(error, opts); // options still contain the icon to waterfall
          });
      },
      (opts, appPathArray, cb) => {
        progress.tick('finalizing');
        // somehow appPathArray is a 1 element array
        const appPath = getAppPath(appPathArray);
        if (!appPath) {
          cb();
          return;
        }

        maybeCopyIcons(opts, appPath, (error) => {
          cb(error, appPath);
        });
      },
    ],
    (error, appPath) => {
      packagerConsole.playback();
      callback(error, appPath);
    },
  );
}
1253176
function UMLNodeInstanceView() {
        UMLGeneralNodeView.apply(this, arguments);
        this.iconRatio = NODE_RATIO_PERCENT;
        this.containerChangeable = true;
        // mixin UMLNodeViewMixin
        _.extend(UMLNodeInstanceView.prototype, UMLNodeViewMixin);

        this.fillColor = PreferenceManager.get("uml.nodeinstance.fillColor", "#ffffff") || PreferenceManager.get("view.fillColor", "#ffffff");
        this.stereotypeDisplay  = PreferenceManager.get("uml.node.stereotypeDisplay", UML.SD_LABEL);
    }
445693
def process_additional_minidisks(self, userid, disk_info):
        '''
        '''
        for idx, disk in enumerate(disk_info):
            vdev = disk.get('vdev') or self.generate_disk_vdev(
                                                    offset = (idx + 1))
            fmt = disk.get('format')
            mount_dir = disk.get('mntdir') or ''.join(['/mnt/ephemeral',
                                                       str(vdev)])
            disk_parms = self._generate_disk_parmline(vdev, fmt, mount_dir)
            func_name = '/var/lib/zvmsdk/setupDisk'
            self.aemod_handler(userid, func_name, disk_parms)

        # trigger do-script
        if self.get_power_state(userid) == 'on':
            self.execute_cmd(userid, "/usr/bin/zvmguestconfigure start")
710060
function getBundleMinIf(bundle, build, min) {
  // Disable minification?
  if (bundle.noMin)
    return false;
  // Glob filter paths to exlude and include files for minification.
  // Start by excluding absolute paths of pre-minified files.
  var minGlobs = lodash.map(min, function minAbsPath(relPath) {
    return build.notPath(path.resolve(relPath));
  });
  if (minGlobs.length === 0) {
    // Nothing to exclude, so include all files.
    return true;
  }
  // Append a catch-all inclusion after all exclusions.
  minGlobs.push('**/*');
  return minGlobs;
}
1076928
function(node, out, ufName, rootID, parentClasses) {
			var context = this,
				children = [],
				rootItem,
				itemRootID,
				value,
				propertyName,
				propertyVersion,
				i,
				x,
				y,
				z,
				child;

			children = modules.domUtils.getChildren( node );

			y = 0;
			z = children.length;
			while(y < z) {
				child = children[y];

				// get microformat classes for this single element
				var classes = context.getUfClassNames(child, ufName);

				// a property which is a microformat
				if(classes.root.length > 0 && classes.properties.length > 0 && !child.addedAsRoot) {
					// create object with type, property and value
					rootItem = context.createUfObject(
						classes.root,
						classes.typeVersion,
						modules.text.parse(this.document, child, context.options.textFormat)
					);

					// add the microformat as an array of properties
					propertyName = context.removePropPrefix(classes.properties[0][0]);

					// modifies value with "implied value rule"
					if(parentClasses && parentClasses.root.length === 1 && parentClasses.properties.length === 1){
						if(context.impliedValueRule){
							out = context.impliedValueRule(out, parentClasses.properties[0][0], classes.properties[0][0], value);
						}
					}

					if(out.properties[propertyName]) {
						out.properties[propertyName].push(rootItem);
					} else {
						out.properties[propertyName] = [rootItem];
					}

					context.rootID++;
					// used to stop duplication in heavily nested structures
					child.addedAsRoot = true;


					x = 0;
					i = rootItem.type.length;
					itemRootID = context.rootID;
					while(x < i) {
						context.walkChildren(child, rootItem, rootItem.type, itemRootID, classes);
						x++;
					}
					if(this.impliedRules){
						context.impliedRules(child, rootItem, classes);
					}
					this.cleanUfObject(rootItem);

				}

				// a property which is NOT a microformat and has not been used for a given root element
				if(classes.root.length === 0 && classes.properties.length > 0) {

					x = 0;
					i = classes.properties.length;
					while(x < i) {

						value = context.getValue(child, classes.properties[x][0], out);
						propertyName = context.removePropPrefix(classes.properties[x][0]);
						propertyVersion = classes.properties[x][1];

						// modifies value with "implied value rule"
						if(parentClasses && parentClasses.root.length === 1 && parentClasses.properties.length === 1){
							if(context.impliedValueRule){
								out = context.impliedValueRule(out, parentClasses.properties[0][0], classes.properties[x][0], value);
							}
						}

						// if we have not added this value into a property with the same name already
						if(!context.hasRootID(child, rootID, propertyName)) {
							// check the root and property is the same version or if overlapping versions are allowed
							if( context.isAllowedPropertyVersion( out.typeVersion, propertyVersion ) ){
								// add the property as an array of properties
								if(out.properties[propertyName]) {
									out.properties[propertyName].push(value);
								} else {
									out.properties[propertyName] = [value];
								}
								// add rootid to node so we can track its use
								context.appendRootID(child, rootID, propertyName);
							}
						}

						x++;
					}

					context.walkChildren(child, out, ufName, rootID, classes);
				}

				// if the node has no microformat classes, see if its children have
				if(classes.root.length === 0 && classes.properties.length === 0) {
					context.walkChildren(child, out, ufName, rootID, classes);
				}

				// if the node is a child root add it to the children tree
				if(classes.root.length > 0 && classes.properties.length === 0) {

					// create object with type, property and value
					rootItem = context.createUfObject(
						classes.root,
						classes.typeVersion,
						modules.text.parse(this.document, child, context.options.textFormat)
					);

					// add the microformat as an array of properties
					if(!out.children){
						out.children =  [];
					}

					if(!context.hasRootID(child, rootID, 'child-root')) {
						out.children.push( rootItem );
						context.appendRootID(child, rootID, 'child-root');
						context.rootID++;
					}

					x = 0;
					i = rootItem.type.length;
					itemRootID = context.rootID;
					while(x < i) {
						context.walkChildren(child, rootItem, rootItem.type, itemRootID, classes);
						x++;
					}
					if(this.impliedRules){
						context.impliedRules(child, rootItem, classes);
					}
					context.cleanUfObject( rootItem );

				}



				y++;
			}

		}