import quantumrandom
import os, sys
import gtk.gdk
import time
import pyaudio
import wave
from array import array



A = quantumrandom.randint(1, 70)
B = quantumrandom.randint(1, 70)
C = quantumrandom.randint(1, 70)
D = quantumrandom.randint(1, 70)
E = quantumrandom.randint(1, 70)
F = quantumrandom.randint(1, 27)



time.sleep(10)



hashsum deleted for anti-xor'ing


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if A == A:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if B == B:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if C == C:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if D == D:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if E == E:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()

if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()


if F == F:

        D = quantumrandom.randint(10, 70)
        FORMAT=pyaudio.paInt16
        CHANNELS=2
        RATE=44100
        CHUNK=1024
        RECORD_SECONDS=D
        FILE_NAME=D


        audio=pyaudio.PyAudio() #instantiate the pyaudio

        #recording prerequisites
        stream=audio.open(format=FORMAT,channels=CHANNELS,
                          rate=RATE,
                          input=True,
                          frames_per_buffer=CHUNK)

        #starting recording
        frames=[]

        for i in range(0,int(RATE/CHUNK*RECORD_SECONDS)):
            data=stream.read(CHUNK)
            data_chunk=array('h',data)
            vol=max(data_chunk)
            if(vol>=0):
                print("catisalive-something said")
                frames.append(data)
            else:
                print("catisalive-something said")
            print("\n")


        #end of recording
        stream.stop_stream()
        stream.close()
        audio.terminate()
        #writing to file
        wavfile=wave.open('%s.wav' % FILE_NAME, 'wb')
        wavfile.setnchannels(CHANNELS)
        wavfile.setsampwidth(audio.get_sample_size(FORMAT))
        wavfile.setframerate(RATE)
        wavfile.writeframes(b''.join(frames))#append frames recorded to file
        wavfile.close()