def disassemble(co, lasti):
       code = co.co_code
       labels = findlabels(code)
       n = len(code)
       i = 0
       while i < n:
               c = code[i]
               op = ord(c)
               if op = SET_LINENO and i > 0: print # Extra blank line
               if i = lasti: print '-->',
               else: print '   ',
               if i in labels: print '>>',
               else: print '  ',
               print string.rjust(`i`, 4),
               print string.ljust(opname[op], 15),
               i = i+1
               if op >= HAVE_ARGUMENT:
                       oparg = ord(code[i]) + ord(code[i+1])*256
                       i = i+2
                       print string.rjust(`oparg`, 5),
                       if op in hasconst:
                               print '(' + `co.co_consts[oparg]` + ')',
                       elif op in hasname:
                               print '(' + co.co_names[oparg] + ')',
                       elif op in hasjrel:
                               print '(to ' + `i + oparg` + ')',
               print

 def writeMol2File(self, outFile, whichXyz=None):
   '''writes the data to an already open file. don't close it.'''
   if whichXyz is None:
     whichXyz = range(self.xyzCount)
   for oneXyz in whichXyz:
     outFile.write("@<TRIPOS>MOLECULE\n")
     if self.protName == "fake": #don't write fake
       outFile.write(self.name + "\n")
     else:
       outFile.write(self.name + " " + self.protName + "\n")
     outFile.write("%5d %5d %5d %5d %5d\n" % (len(self.atomNum), \
                   len(self.bondNum), 0, 0, 0))
     outFile.write("SMALL\nUSER_CHARGES\n\n")
     outFile.write("mmff94s_NoEstat = %5.2f\n" % self.inputEnergy[oneXyz])
     outFile.write("@<TRIPOS>ATOM\n")
     for oneAtom in xrange(len(self.atomNum)):
       outFile.write( \
         "%7d %6s    % 8.4f  % 8.4f  % 8.4f %5s     1 <0>       % 8.4f\n" % \
         (self.atomNum[oneAtom], string.ljust(self.atomName[oneAtom], 6), \
          self.atomXyz[oneXyz][oneAtom][0], \
          self.atomXyz[oneXyz][oneAtom][1], \
          self.atomXyz[oneXyz][oneAtom][2], \
          string.ljust(self.atomType[oneAtom], 5), \
          self.atomCharge[oneAtom]))
     outFile.write("@<TRIPOS>BOND\n")
     for oneBond in xrange(len(self.bondNum)):
       outFile.write( \
         "%6d%5d%5d %2s\n" % \
         (self.bondNum[oneBond], self.bondStart[oneBond], \
          self.bondEnd[oneBond], string.ljust(self.bondType[oneBond], 2)))

    def run_all(self):
        """For each file in the test suite, run client program
        assuming each file represents an individual test."""
        try:
            server = Server(self.ini["core"], self.ini["module"])
        except Exception as e:
            print e
            raise RuntimeError("Unknown server: core = {0}, module = {1}".format(
                               self.ini["core"], self.ini["module"]))

        if len(self.tests) == 0:
            # noting to test, exit
            return 0

        server.deploy(self.ini["config"],
                      server.find_exe(self.args.builddir, silent=False),
                      self.args.vardir, self.args.mem, self.args.start_and_exit,
                      self.args.gdb, self.args.valgrind,
                      init_lua=self.ini["init_lua"], silent=False)
        if self.args.start_and_exit:
            print "  Start and exit requested, exiting..."
            exit(0)

        longsep = "=============================================================================="
        shortsep = "------------------------------------------------------------"
        print longsep
        print string.ljust("TEST", 48), "RESULT"
        print shortsep
        failed_tests = []
        self.ini["server"] = server

        for test in self.tests:
            sys.stdout.write(string.ljust(test.name, 48))
            # for better diagnostics in case of a long-running test
            sys.stdout.flush()

            test_name = os.path.basename(test.name)
            if test_name in self.ini["disabled"]:
                print "[ skip ]"
            elif not server.debug and test_name in self.ini["release_disabled"]:
                print "[ skip ]"
            elif self.args.valgrind and test_name in self.ini["valgrind_disabled"]:
                print "[ skip ]"
            else:
                test.run(server)
                if not test.passed():
                    failed_tests.append(test.name)

        print shortsep
        if len(failed_tests):
            print "Failed {0} tests: {1}.".format(len(failed_tests),
                                                ", ".join(failed_tests))
        server.stop(silent=False)
        server.cleanup()

        if self.args.valgrind and check_valgrind_log(server.valgrind_log):
            print "  Error! There were warnings/errors in valgrind log file:"
            print_tail_n(server.valgrind_log, 20)
            return 1
        return len(failed_tests)

def write_data(toolbox, data):
    ''' Opens the workbook, then the worksheet, then writes the data.'''
    try:
        workbook = excel.Workbooks.Open(toolbox)
    except Exception as e:
        print "Unable to instantiate workbook!"
        print repr(e)
        raise
    if not workbook:
        print "Unable to instantiate workbook!"
        raise IOError("Workbook not found.")

    try:
        sheet = get_sheet('Inputs')
    except Exception as e:
        print "Unable to instantiate worksheet!"
        print repr(e)
        raise
    if not sheet:
        print "Unable to instantiate worksheet!"
        raise IOError("Worksheet not found")

    for k, d in data.items():
        if d.cell:
            print ('{}: writing value {} to cell {}'
                   ''.format(ljust(k, 30), d.value, d.cell))
            sheet.Range(d.cell).Value = d.value
        else:
            print ('{}: skipping value {}, no cell'
                   ''.format(ljust(k, 30), d.value))
    excel.Visible = True

    def report(self, prefix="", emit=None):
        if not emit:
            emit = logging.info

        if getattr(self, "source", None):
            emit(prefix + "source : %s" % (self.source))
        if getattr(self, "sink", None):
            emit(prefix + "sink   : %s" % (self.sink))

        cur_time = time.time()
        delta = cur_time - self.prev_time
        c, p = self.cur, self.prev
        x = sorted([k for k in c.iterkeys() if "_sink_" in k])

        width_k = max([5] + [len(k.replace("tot_sink_", "")) for k in x])
        width_v = max([20] + [len(str(c[k])) for k in x])
        width_d = max([10] + [len(str(c[k] - p[k])) for k in x])
        width_s = max([10] + [len("%0.1f" % ((c[k] - p[k]) / delta)) for k in x])
        emit(prefix + " %s : %s | %s | %s"
             % (string.ljust("", width_k),
                string.rjust("total", width_v),
                string.rjust("last", width_d),
                string.rjust("per sec", width_s)))
        verbose_set = ["tot_sink_batch", "tot_sink_msg"]
        for k in x:
            if k not in verbose_set or self.opts.verbose > 0:
                emit(prefix + " %s : %s | %s | %s"
                 % (string.ljust(k.replace("tot_sink_", ""), width_k),
                    string.rjust(str(c[k]), width_v),
                    string.rjust(str(c[k] - p[k]), width_d),
                    string.rjust("%0.1f" % ((c[k] - p[k]) / delta), width_s)))
        self.prev_time = cur_time
        self.prev = copy.copy(c)

def miscellaneous():

    #
    # alias
    #

    fp.write('#\n# Alias\n#\n')

    results = db.sql('''
	    select alias,
		   cdate = convert(char(10), creation_date, 101)
	    from MRK_Alias_View where _Marker_key =  %s
	    order by alias
	    ''' % (markerKey), 'auto')

    for r in results:
        fp.write(string.ljust(r['alias'],30) + TAB)
        fp.write(string.ljust(r['cdate'],15) + CRT)

    #
    # synonym
    #

    fp.write('#\n# Synonym\n#\n')

    results = db.sql('''
	    select synonym,
		   cdate = convert(char(10), creation_date, 101)
	    from MGI_Synonym where _MGIType_key = 2 and _Object_key =  %s
	    ''' % (markerKey), 'auto')

    for r in results:
        fp.write(string.ljust(r['synonym'],30) + TAB)
        fp.write(string.ljust(r['cdate'],15) + CRT)

    def short_help(self):
        help_str = "\nSupported modes are:\n"

        mode_list = Mode.mode_list( )
        for mode in mode_list:
            aliases = mode.aliases()
            s = ''
            if aliases:
                s += ' (%s)' % ', '.join( aliases )
            lhs = '%s%s:' % (mode.__name__, s)
            
            name_box      = 15
            name          = string.ljust(lhs, name_box)

            help          = toolkit.boxed_string( mode.help(), 60 )

            indent        = string.ljust('', name_box+4)                
            indented_help = string.replace( help, '\n', '\n'+indent )

            help_str = ( "%s    %s%s\n" 
                         % ( help_str, name, indented_help )
                         )

        print ( "%s\nType '%s mode --help' for further help on a mode"
                % ( help_str, self.get_prog_name() )
                )

	def display(self, cols):

		# Create the maxCols list which represents the max
		# length of each row element.

		maxCols = []
		for i in range(0, len(cols[0])):
			maxCols.append(0)
		for row in cols:
			for i in range(0, len(row)):
				if len(row[i]) > maxCols[i]:
					maxCols[i] = len(row[i])

		# Print the table using maxCols list to force all
		# columns in the rows to line up.  The first column
		# (hostname) is left justified, and the subsequent
		# columns are right justified.

		for row in cols:
			for i in range(0, len(row)):
				if i == 0:
					print string.ljust(row[i], maxCols[i]),
				else:
					print string.rjust(row[i], maxCols[i]),
				if i < len(row)-1:
					print '\t',
			print

def Point3DCoord():
    "show the coordinate of selected point"
    pt = Point2D()
    res = kcs_ui.point2D_req("请选择要查询的点", pt)

    if res[0] == kcs_util.ok():
        res = kcs_util.tra_coord_ship(pt.X, pt.Y, "")
        if res[0] == 0:
            pt3d = Point3D(res[1], res[2], res[3])
            res, fr, fr_offset = kcs_util.coord_to_pos(1, pt3d.X)
            res, lp_y, lp_y_offset = kcs_util.coord_to_pos(2, pt3d.Y)
            res, lp_z, lp_z_offset = kcs_util.coord_to_pos(3, pt3d.Z)
            fr_offset=round(fr_offset,2)
            lp_y_offset=round(lp_y_offset,2)
            lp_z_offset=round(lp_z_offset,2)
            x=round(pt3d.X,2)
            y=round(pt3d.Y,2)
            z=round(pt3d.Z,2)

            Msg("--"*25)
            Msg("二维点：" + str(pt))
            Msg("三维坐标信息：")
            Msg("X: %s,FR%s %s" % (string.ljust(str(x), width), str(fr), _fmt(fr_offset)))
            Msg("Y: %s,LP%s %s" % (string.ljust(str(y), width), str(lp_y), _fmt(lp_y_offset)))
            Msg("Z: %s,LP%s %s" % (string.ljust(str(z), width), str(lp_z), _fmt(lp_z_offset)))
            Msg("--"*25)

def checkNumberOfRateRules(rrInstance, testId):
    print string.ljust ("Check " + testId, rpadding),
    errorFlag = False
    value = int (readLine())
    if rrInstance.model.getNumRateRules() != value:
        errorFlag = True
    print passMsg (errorFlag)

def GetValues(fullname):
    # 把完整的项拆分成根项和子项两部分
    name = string.split(fullname,'\\',1)
    # 打开相应的项，为了让该函数更通用
    # 使用了多个判断语句
    if name[0] == 'HKEY_LOCAL_MACHINE':
        key = RegOpenKey(HKEY_LOCAL_MACHINE,name[1], 0, KEY_READ)
    elif name[0] == 'HKEY_CURRENT_USER':
        key = RegOpenKey(HKEY_CURRENT_USER,name[1], 0, KEY_READ)
    elif name[0] == 'HKEY_CLASSES_ROOT':
        key = RegOpenKey(HKEY_CLASSES_ROOT,name[1], 0, KEY_READ)
    elif name[0] == 'HKEY_CURRENT_CONFIG':
        key = RegOpenKey(HKEY_CURRENT_CONFIG,name[1], 0, KEY_READ)
    elif name[0] == 'HKEY_USERS':
        key = RegOpenKey(HKEY_USERS,name[1], 0, KEY_READ)
    else:
        print 'err,no key named %s' (name[0])  
    # 查询项的项值数目     
    info = RegQueryInfoKey(key)
    # 遍历项值获得项值数据
    for i in range(0,info[1]):
       ValueName = RegEnumValue(key, i)
       # 调整项值名称长度，使输出更好看
       print string.ljust(ValueName[0],20),ValueName[1]
    # 关闭打开的项
    RegCloseKey(key)

 def setAIPS(self, fd, value):
     """
     Write parameter value to AIPS TD file opened as fd
     Inputs:
     fd    = open TD file positioned for write
     value = data value dictionary
     """
     ################################################################
     # Is this a "GO" parameter
     code = self.AIPScode
     if (code==' ') | (code=='*') | (code=='&') | (code=='$'):
         myvalue = value[self.name]    # extract value array from dictionary
         # list and scalar separate
         if myvalue.__class__==list: # List
             # AIPS only supports float and strings
             if self.type==float:     # Float
                 for x in myvalue:
                     fd.write(struct.pack('f',x))
             elif self.type==str:     # String
                 for x in myvalue:
                     # Blank pad to proper length
                     xx = string.ljust(string.strip(x),self.dim[0])  
                     fmt = str(self.dim[0])+'s'
                     fd.write(struct.pack(fmt,xx))
         else:  # Scalar
             if self.type==float:     # Float
                 fd.write(struct.pack('f',myvalue))
             elif self.type==str:     # String
                 # Blank pad to proper length
                 xx = string.ljust(string.strip(myvalue),self.dim[0])  
                 fmt = str(self.dim[0])+'s'
                 fd.write(struct.pack(fmt,xx))

def Atom2pdb( atmobj ):
		try:
			if atmobj.valid != True: return ''
		except:
			return None
			
		atm_type   = ljust(str(atmobj.atm_type),6).upper()
		atm_number = rjust(str(atmobj.atm_number),5)
		
		if atmobj.atm_name[0].isdigit() and atmobj.atm_name[-1].isdigit(): atm_name   = ' '+center(str(atmobj.atm_name),4).upper()	
		elif atmobj.atm_name[-1].isdigit(): atm_name   = ' '+ljust(str(atmobj.atm_name),4).upper()
		elif (atmobj.atm_name[-1] =='\''): atm_name   = ' '+rjust(str(atmobj.atm_name),4).upper()
		else: atm_name   = ' '+center(str(atmobj.atm_name),4).upper()
		
		alt_loc    = center(str(atmobj.alt_loc),1)
		resi_name  = center(str(atmobj.resi_name),3).upper()+' '
		chain      = center(str(atmobj.chain),1).upper()
		resSeq     = rjust( str(atmobj.resSeq),4) 
		icode      = center(str(atmobj.icode),1)+3*' '
		pos        = rjust( "%.3f" % atmobj.pos[0],8)+rjust("%.3f" % atmobj.pos[1],8)+rjust("%.3f" % atmobj.pos[2], 8)
		occ        = rjust( str(atmobj.occ), 6) 
		bfac       = rjust( str(atmobj.bfac),5) + 11*' '
		elem       = center( str(atmobj.elem),2)
		charge     = center(str(atmobj.charge),2) 
	
		return atm_type + atm_number + atm_name + alt_loc+ resi_name + chain + resSeq + icode + pos + occ + bfac + elem + charge+'\n'		

    def __str__(self):
	# display process details (OLD, doesn't show many details)
	c = string.ljust(self.comm, 20)
	u = string.ljust(self.user, 10)
	t = string.ljust(self.time, 10)

	return( '%s\t%s\t%s\t%s\t%s\t%s' % (self.pid, u, c, t, self.pcpu, self.s) )

    def print_items(self, max_items):
        import os
        import string
        from findtorrent.core.colors import colors
        from hurry.filesize import size, si

        cols = int(os.popen('stty size', 'r').read().split()[1])
        print colors.HEADER + \
              'No.  Name' + (cols - 33) * ' ' + 'Size  Files  Seed  Leech'
        print cols * '-'
        for index, item in enumerate(Items.sorted):
            if (max_items != -1 and index + 1 > max_items):
                break
            print colors.INDEX + string.ljust(str(index + 1) + '.', 5) + \
                  colors.NAME + string.ljust(item['name'][:cols - 31],
                                             cols - 31) + \
                  colors.SIZE + string.rjust(size(item['size'],
                                                  system=si), 6) + \
                  colors.FILES + string.rjust(str(item['files']) \
                                 .replace('-1', 'N/A'), 7) + \
                  colors.SEED + string.rjust(str(item['seed']) \
                                .replace('-1', 'N/A'), 6) + \
                  colors.LEECH + string.rjust(str(item['leech']) \
                                 .replace('-1', 'N/A'), 7) + \
                  colors.ENDC

    def getPDBString(self):
        """
            Returns a string of the new atom type.  Uses the ATOM string
            output but changes the first field to either by ATOM or
            HETATM as necessary.
            
            This is for the pdb representation of the atom. The propka30 module 
            depends on this being correct. No touchy!

            Returns
                str: String with ATOM/HETATM field set appropriately
        """
        outstr = self.getCommonStringRep(chainflag=True)
        
        tstr = "%6.2f" % self.occupancy
        outstr += string.ljust(tstr, 6)[:6]
        tstr = "%6.2f" % self.tempFactor
        outstr += string.rjust(tstr, 6)[:6]
        tstr = self.segID
        outstr += string.ljust(tstr, 4)[:4]
        tstr = self.element
        outstr += string.ljust(tstr, 2)[:2]
        tstr = str(self.charge)
        outstr += string.ljust(tstr, 2)[:2]


        return outstr

def usage():
    print _("Usage: %s <options> ...") % sys.argv[0]
    print
    print _("The following options are understood:")

    opt_list = []

    for r in opt_table:
        opt = "--" + r[1]
        if r[0]:
            opt = "-" + r[0] + ", " + opt
        if r[2]:
            opt = opt + "=<" + r[2] + ">"

        opt_list.append([opt + "  ", r[3]])

    # By appending [0,0], we insure that this will work even if
    # opt_list is empty (which it never should be)
    max_len = apply(max, map(lambda x:len(x[0]), opt_list) + [0,0])

    for opt, desc_str in opt_list:

        if 79 - max_len > 10:
            desc = rcd_util.linebreak(desc_str, 79 - max_len)
        else:
            desc = [desc_str]

        desc_first = desc.pop(0)
        print string.ljust(opt, max_len) + desc_first
        for d in desc:
            print " " * max_len + d

    def __str__(self):
        output = "Seq:        %s\n" % self.seq
        output += "Parent Seq: %s\n" % self.parent_seq

        output += "mutations_coding_region: %s\n" % self.mutations_coding_region
        output += "mutations_noncoding_region: %s\n" % self.mutations_noncoding_region
        output += "mutations_degenerate_region: %s\n" % self.mutations_degenerate_region
        output += "net_fitness_effect: %s\n" % self.net_fitness_effect
        output += "function_effect_backbone: %s\n" % self.function_effect_backbone
        output += "function_effect_fluctuating: %s\n" % self.function_effect_fluctuating

        output += "site_function_vector:\n"
        ## prep the header
        vector_output = "    "
        for funct in range(7):
            vector_output += "%s" % string.ljust(SiteFunction.tostring(funct), 4)
        vector_output += "\n"

        ## output the thing
        for (funct, array) in zip(range(7), self.site_function_vector):

            arr = ""
            for val in array:
                arr += string.ljust( str(val), 4 )

            vector_output += "%s%s\n" % ( string.ljust(SiteFunction.tostring(funct), 4), arr)

        output += vector_output

        output += "Comment: %s" % self.comment

        return output

 def print_self(self):
     print "Printing components of perceptron vectors"
     print string.ljust("feature",20),"\tw1\tw2\tw3"
     assert(self.ws[1].keys()==self.ws[2].keys())
     assert(self.ws[2].keys()==self.ws[3].keys())
     for feat in self.keys:
         print string.ljust(feat,20), "\t",self.ws[1][feat],"\t",self.ws[2][feat],"\t",self.ws[3][feat]

def show(info="\n", END=False):
    ''' Output information to be in a table-like form.
        Both print on screen and save into the file of DEFINE_LOG_FILE.
    '''
    out = str(info)
    outfile = open(DEFINE_LOG_FILE,"a")
    if isinstance(info, int):
        outfile.write("%s\t"%out)
        print string.ljust(out,5),
    elif isinstance(info, float):
        outfile.write("%s\t"%out)
        print "%.3f"%info,
    elif isinstance(info, list) or isinstance(info, set) or isinstance(info, tuple):
        for e in info:
            show(e)
    elif out.endswith("\n"):
        outfile.write(out)
        print out[:min(len(out)-1,78)]
    else:
        outfile.write(str(out)+"\t")
        print string.ljust(out[:min(len(out),25)],25),
    if END:
        print ''
        outfile.write("\n")
    outfile.close()
    return ''