Here we build all the pug functions
189762
function(callback) {

			var fileLoop = function(currentDir,templateDirectories,cb) {
				var callback_has_been_called = false
				fs.readdir(currentDir,function(err,files) {
					if (err) {
						return console.log('Unable to find files in path',currentDir)
					}
					var num = files.length

					var finishFile = function(i) {
						if (!(--num)) {
							if (!callback_has_been_called) {
								callback_has_been_called = true
								return cb()
							}
						} else {
							buildFileData(i+1)
						}
					}

					var buildFileData = function(i) {
						var file = files[i]
						var filepath = currentDir + '/' + file

						fs.stat(filepath,function(err2,stats) {
							if (err2) {
								return console.log('Unable to find file',filepath)
							}

							if (stats && stats.isDirectory()) {
								var pugatizerPath = '    puglatizer' + currentDir.replace(templateDirectories,'').replace(/\//g,'"]["') + '"]["' + file.replace('.pug','') + '"] = {}\r\n'
								pugatizerPath = pugatizerPath.replace('puglatizer"]','puglatizer')
								fs.appendFileSync(outputFile,pugatizerPath)
								fileLoop(filepath,templateDirectories,function() {
									finishFile(i)
								})
							} else if (stats && stats.isFile()) {
								var ext = path.extname(filepath)
								if (ext == '.pug') {
									var pugatizerPath = '    puglatizer' + currentDir.replace(templateDirectories,'').replace(/\//g,'"]["') + '"]["' + file.replace('.pug','') + '"] = '
									pugatizerPath = pugatizerPath.replace('puglatizer"]','puglatizer')
									buildTemplateFromFile(filepath,options,function(err,template) {
										pugatizerPath += minify.js(template.toString()) + ';\r\n\r\n'
										fs.appendFileSync(outputFile,pugatizerPath)
										finishFile(i)
									})
								} else {
									finishFile(i)
								}
							} else {
								finishFile(i)
							}
						})
					}

					if (!num) {
						return console.log('Unable to find files in path',currentDir)
					} else {
						buildFileData(0)
					}

				})

			}
			
			fileLoop(templateDirectories,templateDirectories,function() {
				return callback()
			})
		}
660338
function build(options) {
  installGitDependencies(options, function(err) {
    if (err) {
      console.error(err.message);
      process.exit(1);
    }

    var args = [path.join('node_modules', 'pangyp', 'bin', 'node-gyp'), 'rebuild'].concat(
      ['libsass_ext', 'libsass_cflags', 'libsass_ldflags', 'libsass_library'].map(function(subject) {
        return ['--', subject, '=', process.env[subject.toUpperCase()] || ''].join('');
      })).concat(options.args);

    console.log(['Building:', process.sass.runtime.execPath].concat(args).join(' '));

    var proc = spawn(process.sass.runtime.execPath, args, {
      stdio: [0, 1, 2]
    });

    proc.on('exit', function(errorCode) {
      if (!errorCode) {
        afterBuild(options);

        return;
      }

      console.error(errorCode === 127 ? 'node-gyp not found!' : 'Build failed');
      process.exit(1);
    });
  });
}
606546
function compileSass() {
    let tasks = [];

    Object.keys(config).forEach((key) => {
        let val = config[key];
        tasks.push(gulp.src(val.src)
            .pipe(plumber({ errorHandler: handleErrors }))
            .pipe(sourcemaps.init())
            .pipe(sass(config.settings))
            .pipe(sourcemaps.write('./'))
            .pipe(gulp.dest(val.dest)));
    });

    return merge(tasks);
}
1044297
function () {
		var start = Date.now();
		gutil.log('Building APP bundle');
		appBundler.bundle()
			.on('error', gutil.log)
			.pipe(source('main.js'))
			.pipe(gulpif(!isDevelopment, streamify(uglify())))
			.pipe(gulp.dest(configs.folders[options.environment]))
			.pipe(notify(function () {
				gutil.log('APP bundle built in ' + (Date.now() - start) + 'ms');
			}))
			.pipe(connect.reload());
	}
572868
function(mixin){
    var ast = [];
    var self = this;
    var name = 'pug_mixins[';
    var args = mixin.args || '';
    var block = mixin.block;
    var attrs = mixin.attrs;
    var attrsBlocks = this.attributeBlocks(mixin.attributeBlocks);
    var pp = this.pp;
    var dynamic = mixin.name[0]==='#';
    var key = mixin.name;
    if (dynamic) this.dynamicMixins = true;
    name += (dynamic ? mixin.name.substr(2,mixin.name.length-3):'"'+mixin.name+'"')+']';
    var mixinName = dynamic ? (mixin.astName || this.parseExpr(mixin.name.substr(2,mixin.name.length-3))): t.stringLiteral(mixin.name);
    this.mixins[key] = this.mixins[key] || {used: false, instances: []};

    // mixin invocation
    if (mixin.call) {
      this.mixins[key].used = true;
      if (pp) {
        ast.push(t.expressionStatement(t.callExpression(
          t.memberExpression(t.identifier('pug_indent'), t.identifier('push')),
          [t.stringLiteral(Array(this.indents + 1).join(pp))]
        )))
      }
      if (block || attrs.length || attrsBlocks.length) {

        var astArgs = []
        ast.push(
          t.expressionStatement(this.wrapCallExpression(t.callExpression(
            t.memberExpression(
              t.memberExpression(t.identifier('pug_mixins'), mixinName, true),
              t.identifier("call")
            ),
            astArgs
          )))
        );

        var astObj, astKey;
        if (block || attrsBlocks.length || attrs.length) {
          astKey = [];
          astObj = t.objectExpression(astKey);
          astArgs.push(astObj);
        }

        if (block) {
          var astFunc = [];
        
          // Render block with no indents, dynamically added when rendered
          this.parentIndents++;
          var _indents = this.indents;
          this.indents = 0;
          push.apply(astFunc, this.visit(mixin.block, mixin));
          this.indents = _indents;
          this.parentIndents--;

          astKey.push(t.objectProperty(
            t.identifier('block'),
            t.functionExpression(
              null,
              [],
              t.blockStatement(astFunc),
              this.useGenerators
            )
          ));
 
        }

        if (attrsBlocks.length) {
          if (attrs.length) {
            var val = this.attrs(attrs);
            attrsBlocks.unshift(val);
          }
          if (attrsBlocks.length > 1) {
            astKey.push(t.objectProperty(
              t.identifier('attributes'),
              t.callExpression(
                this.runtime('merge', true),
                attrsBlocks.map(function(b) { return self.parseExpr(b) })
              )
            ));
          } else {
            astKey.push(t.objectProperty(
              t.identifier('attributes'),
              this.parseExpr(attrsBlocks[0])
            ));
          }
        } else if (attrs.length) {
          var val = this.attrs(attrs);
          astKey.push(t.objectProperty(
            t.identifier('attributes'),
            this.parseExpr(val)
          ));
        }

        if (args) { 
          args = args ? args.split(',') : [];
          Array.prototype.push.apply(astArgs, mixin.astArgs || this.parseArgs(args) )
        }

      } else {
        var astArgs = mixin.astArgs || this.parseArgs(args);
        ast.push(t.expressionStatement(this.wrapCallExpression(t.callExpression(
          t.memberExpression(t.identifier('pug_mixins'), mixinName, true),
          astArgs
        ))));
      }
      if (pp) {
        ast.push(t.expressionStatement(t.callExpression(
          t.memberExpression(t.identifier('pug_indent'), t.identifier('pop')),
          []
        )))
 
      }
    }
    // mixin definition
    else {
      args = args ? args.split(',') : [];
      var rest;
      if (args.length && /^\.\.\./.test(args[args.length - 1].trim())) {
        rest = args.pop().trim().replace(/^\.\.\./, '');
      }
      var astArgs = args.map(function(arg) { return t.identifier(arg.trim())})
      // we need use pug_interp here for v8: https://code.google.com/p/v8/issues/detail?id=4165
      // once fixed, use this: this.buf.push(name + ' = function(' + args.join(',') + '){');
      var astMixin = [];

      astMixin.push(
        t.variableDeclaration('var', [
          t.variableDeclarator(
            t.identifier('block'),
            t.logicalExpression('&&', t.thisExpression(), t.memberExpression(t.thisExpression(), t.identifier('block')))
          ),
          t.variableDeclarator(
            t.identifier('attributes'),
            t.logicalExpression('||',
              t.logicalExpression('&&', t.thisExpression(), t.memberExpression(t.thisExpression(), t.identifier('attributes'))),
              t.objectExpression([])
            )
          )
        ])
      )

      if (rest) {
        astMixin.push(
          t.variableDeclaration('var', [
            t.variableDeclarator(
              t.identifier(rest),
              t.arrayExpression([])
            )
          ])
        )
        astMixin.push(
          t.forStatement(
            t.assignmentExpression('=', t.identifier('pug_interp'), t.numericLiteral(args.length)),
            t.binaryExpression('<', t.identifier('pug_interp'), t.memberExpression(t.identifier('arguments'), t.identifier('length'))),
            t.updateExpression('++', t.identifier('pug_interp'), false),
            t.expressionStatement(
              t.callExpression(
                t.memberExpression(t.identifier(rest), t.identifier('push')),
                [t.memberExpression(t.identifier('arguments'), t.identifier('pug_interp'), true)]
              )
            )
          )
        )
      }

      this.parentIndents++;
      push.apply(astMixin, this.visit(block, mixin));
      this.parentIndents--;


      var mixinStmt = 
        t.expressionStatement(
          t.assignmentExpression(
            '=',
            t.memberExpression(t.identifier('pug_mixins'), mixinName, true),
            t.assignmentExpression(
              '=',
              t.identifier('pug_interp'),
              t.functionExpression(
                null,
                astArgs,
                t.blockStatement(astMixin),
                this.useGenerators
              )
            )
          )
        );
      ast.push(mixinStmt);
 


      this.mixins[key].instances.push({stmt: mixinStmt});
    }
    return ast;
  }
708727
def build_accumulate(function: Callable[[Any, Any], Tuple[Any, Any]] = None, *,
                     init: Any = NONE):
    
    _init = init

    def _build_accumulate(function: Callable[[Any, Any], Tuple[Any, Any]]):
        @wraps(function)
        def _wrapper(init=NONE) -> Accumulate:
            init = _init if init is NONE else init
            if init is NONE:
                raise TypeError('"init" argument has to be defined')
            return Accumulate(function, init=init)
        return _wrapper

    if function:
        return _build_accumulate(function)

    return _build_accumulate
735759
function () {
	var len, attr, g, args;

	args = arguments;

	len = args.length;

	if (len === 0) {
		g = noop;
	}
	else if (len === 1) {
		attr = args[0];

		g = function (obj) {
			return obj[attr];
		};
	}
	else {
		g = function (obj) {
			var i, tuple;

			tuple = [];

			for (i = 0; i < len; ++i) {
				tuple.push(obj[args[i]]);
			}

			return tuple;
		};
	}



	return g;
}
310652
public static function runAll()
    {
        self::checkSapiEnv();
        self::init();
        self::parseCommand();
        self::daemonize();
        self::initWorkers();
        self::installSignal();
        self::saveMasterPid();
        self::forkWorkers();
        self::displayUI();
        self::resetStd();
        self::monitorWorkers();
    }
970124
def cid
      pug_uri = "https://pubchem.ncbi.nlm.nih.gov/rest/pug/"
      update(:cid => RestClientWrapper.post(File.join(pug_uri, "compound", "inchi", "cids", "TXT"),{:inchi => inchi}).strip) unless self["cid"] 
      self["cid"]
    end
983829
function build(options) {
  var args = [require.resolve(path.join('node-gyp', 'bin', 'node-gyp.js')), 'rebuild', '--verbose'].concat(
    ['libsass_ext', 'libsass_cflags', 'libsass_ldflags', 'libsass_library'].map(function(subject) {
      return ['--', subject, '=', process.env[subject.toUpperCase()] || ''].join('');
    })).concat(options.args);

  console.log('Building:', [process.execPath].concat(args).join(' '));

  var proc = spawn(process.execPath, args, {
    stdio: [0, 1, 2]
  });

  proc.on('exit', function(errorCode) {
    if (!errorCode) {
      afterBuild(options);
      return;
    }

    if (errorCode === 127 ) {
      console.error('node-gyp not found!');
    } else {
      console.error('Build failed with error code:', errorCode);
    }

    process.exit(1);
  });
}
127425
function(each){
    var indexVarName = each.key || 'pug_index' + this.eachCount;
    this.eachCount++;

    this.buf.push(''
      + '// iterate ' + each.obj + '\n'
      + ';(function(){\n'
      + '  var $$obj = ' + each.obj + ';\n'
      + '  if (\'number\' == typeof $$obj.length) {');

    if (each.alternate) {
      this.buf.push('    if ($$obj.length) {');
    }

    this.buf.push(''
      + '      for (var ' + indexVarName + ' = 0, $$l = $$obj.length; ' + indexVarName + ' < $$l; ' + indexVarName + '++) {\n'
      + '        var ' + each.val + ' = $$obj[' + indexVarName + '];');

    this.visit(each.block, each);

    this.buf.push('      }');

    if (each.alternate) {
      this.buf.push('    } else {');
      this.visit(each.alternate, each);
      this.buf.push('    }');
    }

    this.buf.push(''
      + '  } else {\n'
      + '    var $$l = 0;\n'
      + '    for (var ' + indexVarName + ' in $$obj) {\n'
      + '      $$l++;\n'
      + '      var ' + each.val + ' = $$obj[' + indexVarName + '];');

    this.visit(each.block, each);

    this.buf.push('    }');
    if (each.alternate) {
      this.buf.push('    if ($$l === 0) {');
      this.visit(each.alternate, each);
      this.buf.push('    }');
    }
    this.buf.push('  }\n}).call(this);\n');
  }
463006
public function puc()
    {
        $const = \get_defined_constants(true);

        if (!isset($const['user'])) {
            $this->outputData = $this->dump(null);
        } else {
            $this->outputData = $this->dump($const['user']);
        }
    }
951382
function(block){
    if (this.pp) this.buf.push("pug_indent.push('" + Array(this.indents + 1).join(this.pp) + "');");
    this.buf.push('block && block();');
    if (this.pp) this.buf.push("pug_indent.pop();");
  }
1014115
function buildUmdLib(dest, plugins = []) {
	return src.transform(rollup, {
		plugins: plugins,
		input: 'Ractive.js',
		output: {
			name: 'Ractive',
			format: 'umd',
			file: dest,
			sourcemap: true,
			banner: banner,
			noConflict: true
		},
		cache: false
	}).transform(transpile, { accept: ['.js'] }).transform(replacePlaceholders);
}
1195202
function buildPack(ret) {
  var src = ret.src;
  var pack = {};

  Object.keys(src).forEach(function(subpath) {
    var file = src[subpath];
    var packTo = file.packTo;

    if (!packTo || file.release === false || file.isPartial) {
      return;
    }

    pack[packTo] = pack[packTo] || [];
    pack[packTo].push(file.subpath);
  });

  return pack;
}
323095
function build(hasSeparateGlobals) {
                    var root = new output.NavigationItem('Index', 'index.html');
                    if (entryPoint == project) {
                        var globals = new output.NavigationItem('Globals', hasSeparateGlobals ? 'globals.html' : 'index.html', root);
                        globals.isGlobals = true;
                    }
                    var modules = [];
                    project.getReflectionsByKind(td.models.ReflectionKind.SomeModule).forEach(function (someModule) {
                        var target = someModule.parent;
                        var inScope = (someModule == entryPoint);
                        while (target) {
                            if (target.kindOf(td.models.ReflectionKind.ExternalModule))
                                return;
                            if (entryPoint == target)
                                inScope = true;
                            target = target.parent;
                        }
                        if (inScope) {
                            modules.push(someModule);
                        }
                    });
                    if (modules.length < 10) {
                        buildGroups(modules, root);
                    }
                    else {
                        buildGroups(entryPoint.getChildrenByKind(td.models.ReflectionKind.SomeModule), root, buildChildren);
                    }
                    return root;
                }
1009134
def build(self):
        """"""
        self.load_builtins()
        self.load_functions(self.tree)
        self.visit(self.tree)