def chkid_allrecord(self,m,rr1):
			# que = "SELECT * FROM wp_2015ptainsuracelist where frm_id='%s';" % (rr1)
			# rr=m.db.query(que)
			idData = (str(rr1),)
			que = """SELECT * FROM """+self.table+""" where frm_id==?"""
			rr=m.dbsql3.data_query(que,idData,False)
			print rr
			p = Stack()
			print(rr)
			if rr:
				for i in rr[0]:
					p.push(i)
				rrr=p.seek()
				OR = rrr[18]
				ins = rrr[16]
				reg = rrr[15]
				trans = rrr[19]
				print "Pass chkid_allrecord!******************"
				if OR=='' and ins==0 and reg==0 and trans=='':
					return 'False1',rrr
				if OR!='' and ins==0 and trans!='':
					return 'True1',rrr
				if OR!='' and ins!=0 and trans!='':
					return 'True2',rrr
			else:
				return 'False2'

	def chkid_len(self,main,a,b=None,c=None,d=None,e=False):

		if e:
			if len(a)==8 or len(a)==10 or a.count('x')==4:
				return True
			else:
				self.alert(main,'ID Less than 8 or 10!','ID length allowed is 8 or 10 \n You have #'+str(len(a))+' digits.')
				return False
		else:
			print("self table===="+self.table)
			print("Check by name is activated!")
			# que = "SELECT * FROM wp_2015ptainsuracelist where frm_stdname='%s' AND frm_std_middle_name='%s' AND frm_std_last_name='%s';" % (b,c,d)
			que = """SELECT * FROM """+self.table+""" where frm_stdname=? AND frm_std_middle_name=? AND frm_std_last_name=?"""
			fullname = (str(b),str(c),str(d))
			rr=main.dbsql3.data_query(que,fullname)
			p = Stack()
			print(b+" "+c+" "+d)
			print("student name! search")
			print(rr)
			if rr:
				for i in rr[0]:
					p.push(i)
				rrr=p.seek()
				OR = rrr[18]
				ins = rrr[16]
				reg = rrr[15]
				trans = rrr[19]
				if OR=='' and ins==0 and reg==0 and trans=='':
					return 'False1'
				if OR!='' and ins==0 and trans!='':
					return 'True1',rrr
				if OR!='' and ins!=0 and trans!='':
					return 'True2',rrr
			else:
				return 'False2'

def revstring_mine(mystr):
    s = Stack()
    for char in mystr:
        s.push(char)
    revstr = ''
    while not s.isEmpty():
        revstr += s.pop()
    return revstr

def revstring(mystr):
	s = Stack()
	new_mystr = ''
	for i in mystr:
		s.push(i)
	while not s.isEmpty():
		new_mystr = new_mystr+s.pop()
	return new_mystr

def revstring(mystr):
    myStack = Stack()
    for i in mystr:
      myStack.push(i)
      revstr = ''
    while not myStack.isEmpty():
      revstr = revstr + myStack.pop()
    return revstr

def revstring(mystr):
    # your code here
    reversed = ""
    string_stack = Stack()
    for char in mystr:
        string_stack.push(char)
    while not string_stack.isEmpty():
        last = string_stack.pop()
        reversed += last
    return reversed

def match_parenthesis (symbolString):
  ## close any and all open parenthesises & return a "file" to be processed further... 
  from pythonds.basic.stack import Stack
  s = Stack()
  balanced = True
  index = 0
  while index < len(symbolString) and balanced:
        symbol = symbolString[index]
        if symbol == "(":
            s.push(symbol+ str(index))
        elif symbol == ")":
            if s.isEmpty():
                balanced = False
            else:
                s.pop()

        index = index + 1

  if balanced and s.isEmpty():
        #print ("it is FINALLY balanced!")
        return symbolString
  elif balanced and not s.isEmpty():
        #print "opening barace is not closed at " 
        
        idx = int (s.pop().strip("("))
        #print idx
        #print symbolString[idx]
        return (match_parenthesis(removeExtra(symbolString,idx))) 
  else:   #couldn't pop from stack
        #print "extra closing present at"
        #print index
        return (match_parenthesis(removeExtra(symbolString,index-1))) 

def buildParseTree(fpexp):
    fplist = fpexp.split()
    pStack = Stack()
    eTree = BinaryTree('')
    pStack.push(eTree)
    currentTree = eTree
    for i in fplist:
        if i == '(':            
            currentTree.insertLeft('')
            pStack.push(currentTree)
            currentTree = currentTree.getLeftChild()
        elif i not in ['+', '-', '*', '/', ')']:  
            currentTree.setRootVal(int(i))
            parent = pStack.pop()
            currentTree = parent
        elif i in ['+', '-', '*', '/']:       
            currentTree.setRootVal(i)
            currentTree.insertRight('')
            pStack.push(currentTree)
            currentTree = currentTree.getRightChild()
        elif i == ')':          
            currentTree = pStack.pop()
        else:
            raise ValueError
    return eTree

def buildParseTree(fpexp):
    fplist = fpexp.split()
    pStack = Stack()
    eTree = BinaryTree("")
    pStack.push(eTree)
    currentTree = eTree
    for i in fplist:
        if i == "(":
            currentTree.insertLeft("")
            pStack.push(currentTree)
            currentTree = currentTree.getLeftChild()
        elif i not in ["+", "-", "*", "/", ")"]:
            currentTree.setRootVal(int(i))
            parent = pStack.pop()
            currentTree = parent
        elif i in ["+", "-", "*", "/"]:
            currentTree.setRootVal(i)
            currentTree.insertRight("")
            pStack.push(currentTree)
            currentTree = currentTree.getRightChild()
        elif i == ")":
            currentTree = pStack.pop()
        else:
            raise ValueError
    return eTree

def match_parenthesis(symbolString):
    ## close any and all open parenthesises & return a "file" to be processed further... 
    from pythonds.basic.stack import Stack
    s = Stack()
    balanced = True
    index = 0
    while index < len(symbolString) and balanced:
        symbol = symbolString[index]
        if symbol == "(":
            s.push(symbol+ str(index))
        elif symbol == ")":
            if s.isEmpty():
                balanced = False
            else:
                s.pop()

        index = index + 1

    if balanced and s.isEmpty():
        return symbolString
    elif balanced and not s.isEmpty():
        idx = int (s.pop().strip("("))
        return (match_parenthesis(removeExtra(symbolString,idx)))
    else:   #couldn't pop from stack
        return (match_parenthesis(removeExtra(symbolString,index-1)))

def divide_by_2(num):
    rem_stack = Stack() # putting my stack in action

    while num > 0:
        rem = num % 2 # remainder variable
        rem_stack.push(rem) # push the remainder in my stack
        num = num // 2 # divide my num by two

    bin_string = '' # create my binary string
    while not rem_stack.isEmpty():
        bin_string = bin_string + str(rem_stack.pop()) # pop the remainder from my stack
    return bin_string # get my binary string

def revString(astring):
    s = Stack() #create a new stack
    
    for ch in astring:
        s.push(ch)
    
    reverse_string = ''

    for i in range(len(astring)):
        reverse_string = reverse_string + s.pop()
        
    return reverse_string

def divide_by_two(decimal):
    stack = Stack()

    while decimal > 0:
        remainder = decimal % 2
        stack.push(remainder)
        decimal = decimal // 2

    binary = ''
    while not stack.isEmpty():
        binary += str(stack.pop())

    return binary

def divideBy2(decNumber):
    remstack = Stack()

    while decNumber > 0:
        rem = decNumber % 2
        remstack.push(rem)
        decNumber = decNumber // 2

    binString = ""
    while not remstack.isEmpty():
        binString = binString + str(remstack.pop())

    return binString

def revstring(sg):
    s = Stack()

    lst = [i for i in sg]
    res = []

    for c in lst:
        s.push(c)

    while not s.isEmpty():
        res.append(s.pop())

    return "".join(res)

def baseConverter(decNumber, base):
	digits = '0123456789ABCDEF'
	remstack = Stack()

	while decNumber > 0:
		rem = decNumber % base
		remstack.push(rem)
		decNumber = decNumber // base
		
	newString = ''

	while not remstack.isEmpty():
		newString = newString + digits[remstack.pop()]
	return newString

def baseConverter(decNumber, base):
    digits = string.digits + string.uppercase
    s = Stack()

    while decNumber > 0:
        rem = decNumber % base
        s.push(rem)
        decNumber /= base

    res = []
    while not s.isEmpty():
        res.append(str(digits[s.pop()]))

    return "".join(res)

def divideBy2(decNumber):
    s = Stack()

    while decNumber > 0:
        rem = decNumber % 2
        s.push(rem)

        decNumber //= 2

    res = []
    while not s.isEmpty():
        res.append(str(s.pop()))

    return "".join(res)

	def chkDate_allRec(self,m,a,camp):

		# que = "SELECT * FROM wp_2015ptainsuracelist where frm_time_date='%s';" % (a)
		# rr=m.db.query(que)
		dateData = (str(a),)
		que = """SELECT * FROM """+self.table+""" where frm_time_date==?"""
		rr=m.dbsql3.data_query(que,dateData,False)
		# print(rr)
		y = Stack()
		p= []
		str2=[]
		if rr:
			for i in rr:

				print(i)
				# OR = i[18]
				# ins = i[16]
				# reg = i[15]
				# trans = i[19]
				#
				if i[18]!='' and i[15]!=0 and i[16]!=0 and i[19]!='' and i[20]==camp:
					y.push(list(i))
				#Has a sibling and paid the insurance fee
				if i[18]!='' and i[15]==0 and i[16]!=0 and i[19]!='' and i[20]==camp:
					y.push(list(i))
				#declared but not insured
				if i[18]!='' and i[15]==0 and i[16]==0 and i[19]!='' and i[20]==camp:
					y.push(list(i))
			return True,y.seek()

			# ns!='':
				# return 'True2',rrr

		else:
			return False

def baseConverter(decNumber,base):
	digits = "0123456789ABCDEF"
	remstack = Stack()

	while decNumber > 0:
		rem = decNumber % base
		remstack.push(rem)
		decNumber = decNumber // base


	binString =''
	while not remstack.isEmpty():
		binString += digits[(remstack.pop())]


	return binString