Sets location of the browser binary, either by string or
        ``FirefoxBinary`` instance.
437443
def binary(self, new_binary):
        
        if not isinstance(new_binary, FirefoxBinary):
            new_binary = FirefoxBinary(new_binary)
        self._binary = new_binary
691974
function BinaryTree( options , ... elements ) {
	var autoIndex = 0 ;

	this.trunc = null ;
	this.length = 0 ;
	this.keyFn = options && options.keyFn ;
	this.uniqueKeys = !! ( options && options.uniqueKeys ) ;

	if ( ! this.keyFn ) {
		this.keyFn = ( element , hint ) => hint !== undefined ? hint : autoIndex ++ ;
	}

	if ( elements.length ) {
		this.insert( ... elements ) ;
	}
}
43695
function getBinaryPath(binaryName) {
  if (isWindows) {
    binaryName += '.cmd';
  }

  const jsdocResolved = require.resolve('jsdoc/jsdoc.js');
  const expectedPaths = [
    path.join(__dirname, '..', 'node_modules', '.bin', binaryName),
    path.resolve(path.join(path.dirname(jsdocResolved), '..', '.bin', binaryName))
  ];

  for (let i = 0; i < expectedPaths.length; i++) {
    const expectedPath = expectedPaths[i];
    if (fse.existsSync(expectedPath)) {
      return expectedPath;
    }
  }

  throw Error('JsDoc binary was not found in any of the expected paths: ' + expectedPaths);
}
609138
function updateBinary (os = platform, arch = process.arch) {
  return new Promise((resolve, reject) => {
    if (platform === 'freebsd') return resolve(`
There are no static ffmpeg builds for FreeBSD currently available.
The module will try to use the system-wide installation.

Install it by running "pkg install ffmpeg" or via ports.
`)
    if (platform === 'openbsd') return resolve(`
There are no static ffmpeg builds for OpenBSD currently available.
The module will try to use the system-wide installation.

Install it by running "pkg_add ffmpeg" or via ports.
`) 
    const dir = `bin/${os}/${arch}`
    const bin = `${dir}/ffmpeg${os === 'win32' ? '.exe' : ''}`
    const dest = path.join(__dirname, bin)
    const fname = `${os}-${arch}.tar.bz2`
    const tmp = path.join(__dirname, 'bin', fname)
    try { fs.mkdirSync(path.join(__dirname, 'bin')) } catch(e) {}
    let bar

	// Cleanup directory
	fs.emptyDirSync('bin')

    // Get the latest version
    const req = request.get(`https://github.com/FocaBot/ffmpeg-downloader/raw/master/bin/${fname}`)
    req.on('error', e => reject(e)) // Handle errors
    .on('data', c => {
      bar = bar || new ProgressBar(`${fname} [:bar] :percent (ETA: :etas)`, {
        complete: '=',
        incomplete: ' ',
        width: 25,
        total: parseInt(req.response.headers['content-length'])
      })

      bar.tick(c.length)
    })
    .on('end', () => setTimeout(() => {
      bar.tick(bar.total - bar.curr)
      console.log('Decompressing...')
      decompress(tmp, path.join(__dirname, 'bin')).then(f => {
        fs.unlinkSync(tmp)
        // Try to get the version number
        // Skip this if not the same arch/os as what launched it
        if (os === platform && arch === process.arch) {
          execFile(dest, ['-version'], (error, stdout, stderr) => {
            if (error || stderr.length) return reject(error || stderr)
            resolve(stdout)
          })
        } else {
          resolve('Platform and arch are different than this system, cannot display ffmpeg version') 
        }
      })
    }, 1000))
    .pipe(fs.createWriteStream(tmp, { mode: 0o755 }))
  })
}
903958
function setBrowser() {
		Device.browser = getBrowser();
		Device.browser.BROWSER = BROWSER;

		if (Device.browser.name) {
			for (var b in BROWSER) {
				if (BROWSER[b] === Device.browser.name) {
					Device.browser[b.toLowerCase()] = true;
				}
			}
		}
	}
211578
function loadBinary (file, callback) {
  if (isPlask) {
    loadBinaryPlask(file, callback)
  } else {
    loadBinaryBrowser(file, callback)
  }
}
1132876
public WebSocketInputStream initBinary()
    throws IOException
  {
    if (_binaryIn == null) {
      _binaryIn = new WebSocketInputStream(this);
    }

    _binaryIn.init();

    return _binaryIn;
  }
749841
protected static void renderBinary(InputStream is, String name, boolean inline) {
        throw new BinaryResult(is, name, inline);
    }
291231
function defaultWindowsLocation() {
  var files = [
    process.env['PROGRAMFILES'] || 'C:\\Program Files',
    process.env['PROGRAMFILES(X86)'] || 'C:\\Program Files (x86)'
  ].map(function(prefix) {
    return path.join(prefix, 'Mozilla Firefox\\firefox.exe');
  });
  return io.exists(files[0]).then(function(exists) {
    return exists ? files[0] : io.exists(files[1]).then(function(exists) {
      return exists ? files[1] : null;
    });
  });
}
852177
function setOptOut(optOutParam) {
  window[disableStr] = optOutParam;
  setCookie(optOutParam);
  setLocalStorage(optOutParam);

  return optOutParam;
}
1296620
def _retrieve_binary(self, file_name):
        """"""
        with open(file_name, 'wb') as f:
            return self.session.retrbinary('RETR ' + file_name, f.write)
516645
def _to_binary(val):
    """"""
    if isinstance(val, text_type):
        return val.encode('utf-8')
    assert isinstance(val, binary_type)
    return val
1208827
public function setBinaryString(BinaryIterator $binary)
    {
        $iterator = new \MultipleIterator(\MultipleIterator::MIT_NEED_ALL|\MultipleIterator::MIT_KEYS_ASSOC);
        $iterator->attachIterator(new RectIterator($this->width, $this->height), 'rect');
        $iterator->attachIterator($binary, 'bin');

        foreach ($iterator as $current) {
            $this->setPixel($current['rect'][0], $current['rect'][1], $current['bin']);
        }

        return $this;
    }
287723
private void setValueFromObject(byte[] bytes) {
        if (type.equals(QualifiedName_XSD_BASE64_BINARY)) {
            setValue(ProvFactory.getFactory().base64Encoding(bytes));
        } else if (type.equals(QualifiedName_XSD_HEX_BINARY)) {
            setValue(ProvFactory.getFactory().hexEncoding(bytes));
        }
    }
351707
def get_firefox_binary():
    
    browser_config = BrowserConfig()
    constants_config = ConstantsConfig()
    log_dir = os.path.join(constants_config.get('logs_dir'), 'firefox')
    create_directory(log_dir)

    log_path = os.path.join(log_dir, '{}_{}.log'.format(datetime.datetime.now().isoformat('_'), words.random_word()))
    log_file = open(log_path, 'w')
    log('Firefox log file: {}'.format(log_path))

    binary = FirefoxBinary(log_file=log_file)

    return binary
364095
public function setLessBinary($lessBinary)
    {
        if (null !== $lessBinary) {
            Assert::string($lessBinary, 'The less binary must be a string or null. Got: %s');
            Assert::notEmpty($lessBinary, 'The less binary must not be empty.');
        }

        $this->lessBinary = $lessBinary;
    }
787590
def _set_bin_view(self, session):
        """"""
        if self._bin_view == FEDERATED:
            try:
                session.use_federated_bin_view()
            except AttributeError:
                pass
        else:
            try:
                session.use_isolated_bin_view()
            except AttributeError:
                pass