CONVERT #include "ge.h"
515054
static public void slide(byte[] r, byte[] a) {
        int i;
        int b;
        int k;

        for (i = 0; i < 256; ++i) {
            //CONVERT r[i] = 1 & (a[i >> 3] >> (i & 7));
            r[i] = (byte) (1 & (a[i >> 3] >>> (i & 7)));
        }

        for (i = 0; i < 256; ++i)
            if (r[i] != 0) {
                for (b = 1; b <= 6 && i + b < 256; ++b) {
                    if (r[i + b] != 0) {
                        if (r[i] + (r[i + b] << b) <= 15) {
                            r[i] += r[i + b] << b;
                            r[i + b] = 0;
                        } else if (r[i] - (r[i + b] << b) >= -15) {
                            r[i] -= r[i + b] << b;
                            for (k = i + b; k < 256; ++k) {
                                if (r[k] == 0) {
                                    r[k] = 1;
                                    break;
                                }
                                r[k] = 0;
                            }
                        } else
                            break;
                    }
                }
            }

    }
1099262
def fastq_convert_pipe_cl(in_file, data):
    
    cmd = _seqtk_fastq_prep_cl(data, in_file)
    if not cmd:
        cat_cmd = "zcat" if in_file.endswith(".gz") else "cat"
        cmd = cat_cmd + " " + in_file
    return "<(%s)" % cmd
769270
def compile(self):
        """"""
        return "{lhs}{sep}{rhs}".format(
            lhs=self.lhs.compile(),
            sep=self.sep,
            rhs=self.rhs.compile(),
        )
1206052
function convertWindowsVersion(version) {
  const parts = version.split('-');
  const mainVersion = parts.shift();

  if (parts.length > 0) {
    return [mainVersion, parts.join('-').replace(/\./g, '')].join('-');
  }

  return mainVersion;
}
513192
function transpile(src, options) {
	return buble.transform(src, {
		target: { ie: 9 },
		transforms: { modules: false }
	});
}
300476
function (h) {
      h = x64Xor(h, [0, h[0] >>> 1])
      h = x64Multiply(h, [0xff51afd7, 0xed558ccd])
      h = x64Xor(h, [0, h[0] >>> 1])
      h = x64Multiply(h, [0xc4ceb9fe, 0x1a85ec53])
      h = x64Xor(h, [0, h[0] >>> 1])
      return h
    }
183943
def generate_cdef():
    """"""
    include_libc_path = path.join(HERE, 'fake_libc_include')
    include_vulkan_path = path.join(HERE, 'vulkan_include')
    out_file = path.join(HERE, path.pardir, 'vulkan', 'vulkan.cdef.h')
    header = path.join(include_vulkan_path, 'vulkan.h')

    command = ['cpp',
               '-std=c99',
               '-P',
               '-nostdinc',
               '-I' + include_libc_path,
               '-I' + include_vulkan_path,
               '-o' + out_file,
               '-DVK_USE_PLATFORM_XCB_KHR',
               '-DVK_USE_PLATFORM_WAYLAND_KHR',
               '-DVK_USE_PLATFORM_ANDROID_KHR',
               '-DVK_USE_PLATFORM_WIN32_KHR',
               '-DVK_USE_PLATFORM_XLIB_KHR',
               header]
    subprocess.run(command, check=True)
822465
def _fixup_cdef_enums(string, reg=re.compile(r"=\s*(\d+)\s*<<\s*(\d+)")):
    """"""

    def repl_shift(match):
        shift_by = int(match.group(2))
        value = int(match.group(1))
        int_value = ctypes.c_int(value << shift_by).value
        return "= %s" % str(int_value)
    return reg.sub(repl_shift, string)
585745
function convertPr (ghPr) {
  return {
    number: ghPr.number,
    description: ghPr.body,
    url: ghPr.html_url,
    headSha: ghPr.head.sha
  }
}
561680
def _gt_from_ge(self, other):
    """"""
    op_result = self.__ge__(other)
    if op_result is NotImplemented:
        return NotImplemented
    return op_result and self != other
668053
def _make_compiler_include(precompile, extralinks):
    """"""
    base = """ifeq ($(FAM),ifort)
  include {2}/Makefile.ifort{0}{3}
else
ifeq ($(FAM),gfortran)
  include {2}/Makefile.gfortran{1}{3}
else
  include Makefile.error
endif
endif"""
    if extralinks is not None and len(extralinks) > 0:
        from os import path
        libs = []
        for i, link in enumerate(extralinks):
            #We can only include *directories* for the -I specification.
            if path.isdir(link):
                libs.append("-I$(LBD{0:d})".format(i))
        exlinks = "\n  FFLAGS += {}".format(' '.join(libs))
    else:
        exlinks = ""
        
    #We need to see whether to include the pre-compiler directive or not.    
    if precompile:
        insert = ["\n  FFLAGS += -fpp -save-temps -heap-arrays", "\n  FFLAGS += -cpp",
                  get_fortpy_templates(), exlinks]
        return base.format(*insert)
    else:
        return base.format("", "", get_fortpy_templates(), exlinks)
242512
def main():
    """"""
    args = parse_args()
    converter = h5f.Converter(args.output, args.group, args.chunk)
    for infile in args.file:
        converter.convert(infile)
475594
def hg(command, error = true)
      unless Berkshelf.which('hg') || Berkshelf.which('hg.exe')
        raise HgNotInstalled.new
      end

      Berkshelf.log.debug("Running:hg #{command}")
      response = shell_out(%|hg #{command}|)
      Berkshelf.log.debug("response:hg #{response.stdout}")

      if response.error?
        raise HgCommandError.new(command, response, cache_path)
      end

      response.stdout.strip
    end
1310271
function convertForPackage(context, pkg) {
	var name = pkg.name;
	var version = pkg.version;

	var conv = context.deferredConversions;
	var pkgConv = conv[name];
	var depPkg, fns, keys = 0;
	if(pkgConv) {
		for(var range in pkgConv) {
			depPkg = crawl.matchedVersion(context, name, range);
			if(depPkg) {
				fns = pkgConv[range];
				for(var i = 0, len = fns.length; i < len; i++) {
					fns[i].call(context);
				}
				delete pkgConv[range];
			} else {
				keys++;
			}
		}
		if(keys === 0) {
			delete conv[name];
		}
	}
}
760879
function(){// Convert
for(var ue=this.words,be=ue.length,he=[],me=0,ge;me<be;me++)ge=ue[me],he.push(ge.high),he.push(ge.low);// Shortcuts
return le.create(he,this.sigBytes)}
257404
def _lt_from_ge(self, other):
    """"""
    op_result = self.__ge__(other)
    if op_result is NotImplemented:
        return NotImplemented
    return not op_result
1362518
def _astore32(ins):
    ''' 
    '''
    output = _addr(ins.quad[1])

    value = ins.quad[2]
    if value[0] == '*':
        value = value[1:]
        indirect = True
    else:
        indirect = False

    try:
        value = int(ins.quad[2]) & 0xFFFFFFFF  # Immediate?
        if indirect:
            output.append('push hl')
            output.append('ld hl, %i' % (value & 0xFFFF))
            output.append('call __ILOAD32')
            output.append('ld b, h')
            output.append('ld c, l')  # BC = Lower 16 bits
            output.append('pop hl')
            REQUIRES.add('iload32.asm')
        else:
            output.append('ld de, %i' % (value >> 16))
            output.append('ld bc, %i' % (value & 0xFFFF))
    except ValueError:
        output.append('pop bc')
        output.append('pop de')

    output.append('call __STORE32')
    REQUIRES.add('store32.asm')

    return output