#write it yourself

#return the equivalent temperature of c degree celcius in fahrenheit

scale
#c is a floating point number
#for example, temperature_conversion(50.0) should return 122.0 and so on
#def temperature_conversion(c):

#write it yourself
#return the distance between two points (x1,y1) and (x2,y2) in cartesian
coordinate space
#x1, x2, y1 and y2 are floating point numbers
#def distance(x1,x2,y1,y2):

#write it yourself
#return the area of the traingle having vertices at (x1,y1), (x2,y2) and
(x3,y3) in cartesian space
#determine the length of the three sides of the triangle using the
distance() function above
#then use the formula area=sqrt(s*(s-a)*(s-b)*(s-c))
#x1, x2, x3, y1, y2 and y3 are floating point numbers
#def area(x1,x2,,x3,y1,y2,y3):

#primality testing
#n is an integer greater than 0
#returns true if n is a prime, false if not
def isPrime(n):
if n==1:
return False #1 is not prime by convention
for i in range(2,n):
if n%i==0:
return False
return True

#prints the prime numbers between 1 to n

#uses isPrime() to test for primes
#n must be an integer
def print_prime(n):
for i in range(1,n+1):
if isPrime(i)==True:
print(i)

#write it yourself
#print all the divisors/factors of positive integer n
#def all_factors(n):

#prints the prime factorization of positive integer n

#prime factorization means expressing a positive integer as product of
power of primes
#prime factorization of an integer is unique
def prime_factorization(n):
div=2
while n>1:
cnt=0
while n%div==0:
cnt+=1
n//=div
if cnt>0:
print(div,"^",cnt,sep="",end="")
if n!=1:
print(" * ",end="")
div+=1
print()

#write it yourself
#return the number of factors of positive integer n
#modify the above prime_factorization() function to implement the
algorithm described in the link below
# http://www.wikihow.com/Find-How-Many-Factors-Are-in-a-Number
#dont print anything, just return the number of factors of n
#def num_factors(n):

#write it yourself
#return the gcd(greatest common divisor) of positive integer a and b
#def gcd(a,b):

#write it yourself
#return the lcm(least common multiple) of positive integer a and b
#def lcm(a,b):

#returns the factorial of positive integer n

#iterative version
def factorial_1(n):
prod=1
for i in range(1,n+1):
prod*=i
return prod

#returns the factorial of positive integer n

#recursive version
def factorial_2(n):
if n<2:
return 1
return n*factorial_2(n-1)
#write it yourself
#return the n-th fibonacci number
#google if you are not familiar with fibonacci numbers
#def fibonacci(n):

#write it yourself
#binary to decimal conversion
#implement several versions
#try both iterative and recursive version
#one version may print the binary form but return nothing
#another version may return the binary number in integer or string format
without printing anything
#def decimal_to_binary(n):

#write it yourself
#generalized number base conversion
#convert n represented in base src_base to the equivalent number in base
dst_base
#for example, base_conversion(123,4,5) should return or print 102 as an
integer or string
#def base_conversion(n,src_base,dst_base):

#implements the slicing operator

#returns src_str[start:end] without actually using the slicing operator
#src_str is a string, start and end are integers
def slicer(src_str,start,end):
res=""
for i in range(start,end):
res+=src_str[i]
return res

#implements the count() function

#returns the number of occurence of the character qry_char in the string
src_str
def count(src_str,qry_char):
cnt=0
for i in src_str:
if i==qry_char:
cnt+=1
return cnt

#write it yourself
#implement the upper() method without using the builtin lower() function
(for all the functions below, do not use the builtin function provided
for the task; write your own version)
#return the modified src_str replacing all lower case characters of
src_str by their upper case equivalent
#for example, upper("Upper123") should return "UPPER123"
#closely observe the ordinal values of different characters to convert
lowercase characeters to uppercase
#the ord() and chr() functions may come handy
#def upper(src_str):

#implements the find() function using the slicing operator

#returns the index of the first occurence of qry_str in src_str
#returns -1 if qry_str is not a substring of src_str
def find_1(src_str,qry_str):
for i in range(0,len(src_str)-len(qry_str)+1):
if qry_str==src_str[i:i+len(qry_str)]:
return i
return -1

#implements the find() function without using the slicing operator

#returns the index of the first occurence of qry_str in src_str
#returns -1 if qry_str is not a substring of src_str
def find_2(src_str,qry_str):
for i in range(0,len(src_str)-len(qry_str)+1):
flag=True
for j in range(len(qry_str)):
if qry_str[j]!=src_str[i+j]:
flag=False
break
if flag==True:
return i
return -1

#write it yourself
#implement the in() function
#return true if qry_str is a substring of src_str, false otherwise
#def in(src_str,qry_str):

#removes the first occurence of qry_str in src_str using the slicing

operator
#returns the modified source string
#returns the original source string if qry_str is not found anywhere
within src_str
def remove_first_1(src_str,qry_str):
index=find_1(src_str,qry_str)
if index!=-1:
return src_str[:index]+src_str[index+len(qry_str):]
return src_str

#removes the first occurence of qry_str in src_str without using the

slicing operator
#returns the modified source string
#returns the original source string if qry_str is not found anywhere
within src_str
def remove_first_2(src_str,qry_str):
index=find_2(src_str,qry_str)
 if index!=-1:
res=""
for i in range(index):
res+=src_str[i]
for i in range(index+len(qry_str),len(src_str)):
res+=src_str[i]
return res
return src_str

#removes all occurences of qry_str in src_str using the remove_first_1()

function
#returns the modified source string
#returns the original source string if qry_str is not found anywhere
within src_str
def remove_all_1(src_str,qry_str):
res=remove_first_1(src_str,qry_str)
while res!=src_str:
src_str=res
res=remove_first_1(src_str,qry_str)
return res

#removes all occurences of qry_str in src_str by iterative matching using

the slicing operator
#returns the modified source string
#returns the original source string if qry_str is not found anywhere
within src_str
def remove_all_2(src_str,qry_str):
for i in range(0,len(src_str)-len(qry_str)+1):
if qry_str==src_str[i:i+len(qry_str)]:
src_str=src_str[:i]+src_str[i+len(qry_str):]
return src_str

#write it yourself
#replace the first occurence of qry_str in src_str by dst_str
#for example, replace_first("hi this is nothing","is","are") should
return "hi thare is nothing"
#return the original source string if query string is not found in the
source string
#def replace_first(src_str,qry_str,dst_str):

#write it yourself
#replace all occurences of qry_str in src_str by dst_str
#for example, replace_all("hi this is nothing","is","are") should return
"hi thare are nothing"
#return the original source string if query string is not found in the
source string
#def replace_all(src_str,qry_str,dst_str):

#returns the reversed form of the source string

#creates the reversed string incrementally by scanning the source string
backward
def reverse_1(src_str):
res=""
for i in range(len(src_str)-1,-1,-1):
res+=src_str[i]
return res

#returns the reversed form of the source string

#recursive version
def reverse_2(src_str):
if len(src_str)<2:
return src_str
return reverse_2(src_str[1:len(src_str)])+src_str[0]

#write it yourself
#reverse the portion of src_str from index start to end
#return the modified source string
#for example, range_reverse("abcdefghij",3,6) should return "abcfedghij"
#src_str is a string, start and end are integers
#def range_reverse(src_str,start,end):

#returns true if src_str is a palindrome, false otherwise

#palindrome is a string that reads the same forward and backward
#this version uses reverse_1() function to check for palindrome
def isPalindrome_1(src_str):
return src_str==reverse_1(src_str)

#returns true if src_str is a palindrome, false otherwise

#recursive version
def isPalindrome_2(src_str):
if len(src_str)<2:
return True
if src_str[0]!=src_str[len(src_str)-1]:
return False
return isPalindrome_2(src_str[1:len(src_str)-1])

#returns true if src_str is a palindrome, false otherwise

#iterative version
def isPalindrome_3(src_str):
for i in range(len(src_str)//2):
if src_str[i]!=src_str[len(src_str)-1-i]:
return False
return True

#write it yourself
#return the src_str rotated right by pos steps
#for example, right_rotate("abcdef",2) should return "efabcd",
right_rotate("abc",4) should return "cab"
#src_str is a string and pos is an integer
#def right_rotate(src_str,pos):
#write it yourself
#transform/encode strings
#assume that src_str consists of only lower case characters
#replace each character in src_str by the pos-th next character in the
alphabet
#return the modified source string
#for example, encode("afczx",3) returns "difca" (the next character of
'z' is 'a')
#the ord() and chr() functions may come handy
#src_str is a string and pos is an integer
#def encode(src_str,pos):

#write it yourself
#return the length of the initial portion of src_str which consists only
of characters that are part of qry_str
#for example, strspn("auibde","aeiou") should return 3
#def strspn(src_str,qry_str):

#returns true if qry_str is a subsequence of src_str, false otherwise

#a subsequence is a sequence that can be derived from another sequence by
deleting some elements without changing the order of the remaining
elements
#for example, "asd" is a subsequence of "aaasssddd", but "dsa" is not
#uses two index variables to track the matched portion of the two strings
def subseq(src_str,qry_str):
src_index=0
qry_index=0
while True:
if qry_index==len(qry_str):
return True
if src_index==len(src_str):
return False
while src_str[src_index]!=qry_str[qry_index]:
src_index+=1
if src_index==len(src_str):
return False
src_index+=1
qry_index+=1

#tester of some string funcitons

def main():
while True:
src=input()
if src=="halt":
break
qry=input()
#print(count(src,qry))
#print(find_1(src,qry))
#print(find_2(src,qry))
#print(remove_first_1(src,qry))
#print(remove_first_2(src,qry))
#print(remove_all_1(src,qry))
 #print(remove_all_2(src,qry))
#print(reverse_1(src))
#print(reverse_2(src))
#print(isPalindrome_1(src))
#print(isPalindrome_2(src))
#print(isPalindrome_3(src))
#print(subseq(src,qry))

main()