def gen_lists():
    #First, let's define some variables.
    num_of_blocks = 4 #This is an arbitrary number of blocks.
    len_of_blocks = 24 #Once again, an arbitrary number of words in the block.
    total_words = num_of_blocks * len_of_blocks #The total number of words.
    dict_list = [] #The list to hold the dictionaries
    sample_list = [] #This list will hold a few dictionaries in order to provide a sample.

    """
    We will be creating dictionaries with the following keys:
        word                The actual word.
        color               The color the word will be presented as.
        matched             True or false (True if the word describes its own color, false otherwise.)

    """

    #So, now we begin to create the lists.
    for y in range (num_of_blocks):
        for x in range(len_of_blocks/8):
            block_list = []
            #This block will create the matched word/color pairs.
            r_trial = {'word':'red', 'color':'RED', 'matched':True}
            block_list.append(r_trial)
            sample_list.append(r_trial)
            b_trial = {'word':'blue', 'color':'BLUE', 'matched':True}
            block_list.append(b_trial)
            sample_list.append(b_trial)
            g_trial = {'word':'green', 'color':'GREEN', 'matched':True}
            block_list.append(g_trial)
            sample_list.append(g_trial)
            o_trial = {'word':'orange', 'color':'ORANGE', 'matched':True}
            block_list.append(o_trial)
            sample_list.append(o_trial)

            #This set of four will create the mismatched color lists.
            rf_trial = {'word':'red', 'color':randomize_color('red', x%3), 'matched':False}
            block_list.append(rf_trial)
            sample_list.append(rf_trial)
            bf_trial = {'word':'blue', 'color':randomize_color('blue', x%3), 'matched':False}
            block_list.append(bf_trial)
            sample_list.append(bf_trial)
            gf_trial = {'word':'green', 'color':randomize_color('green', x%3), 'matched':False}
            block_list.append(gf_trial)
            sample_list.append(gf_trial)
            of_trial = {'word':'orange', 'color':randomize_color('orange', x%3), 'matched':False}
            block_list.append(of_trial)
            sample_list.append(of_trial)

            #And now we shuffle the lists to ensure randomness.
            shuffle(block_list)
            dict_list.append(block_list)
    shuffle(dict_list)
    return(dict_list, sample_list)

#Read in the instructions
instruct_text = open('stroop_instructions.rst', 'r').read()
RSTFONTSIZE = 30
RSTWIDTH = 900
NUMBLOCKS = 4
LENBLOCKS = 24
recDuration = 2
interBlockDur = 2
interStimulusInterval = 2

from smile.log as lg
#define subject pool
subjects = ["s000/","s001/","s002/"]
dic_list = []
for sbj in subjects:
    #get at all the different subjects
    dic_list.append(lg.log2dl(log_filename="data/" + sbj + "Log_Stroop"))
#print out all of the stimulus words of the first subject's first trial
print dic_list[0]['stim_word']

from smile.log as lg
#define subject pool
subjects = ["s000/","s001/","s002/"]
for sbj in subjects:
    #Get at all the subjects data, naming the csv appropriately.
    lg.log2csv(log_filename="data/" + sbj + "Log_Stroop", csv_filename=sbj + "_Stroop")

from smile.common import *
from smile.audio import RecordSoundFile
from random import *
from math import *

#execute both the configuration file and the
#stimulus generation file
from config import *
from gen_stim import *


#Define the Experiment Variable
exp = Experiment()

#Show the instructions as an RstDocument Viewer on the screen
init_text = RstDocument(text=instruct_text, font_size=RSTFONTSIZE, width=RSTWIDTH, top=exp.screen.top, height=exp.screen.height)
with UntilDone():
    #Once you press any key, the UntilDone will cancel the RstDocument,
    #allowing the rest of the experiment to continue running.
    keypress = KeyPress()

#Initialize the block counter, only used because we need
#unique names for the .wav files later.
exp.blockNum = 0

#Initialize the Loop as "with Loop(list_like) as reference_variable_name:"
with Loop(trials) as block:
    #Initialize the trial counter, only used because we need
    #unique names for the .wav files later.
    exp.trialNum = 0

    inter_stim = Label(text = '+', font_size = 80, duration = interBlockDur)
    #Initialize the Loop as "with Loop(list_like) as reference_variable_name:"
    with Loop(block.current) as trial:
        #Display the word, with the appropriate colored text
        t = Label(text=trial.current['word'], font_size=48, color=trial.current['color'])
        with UntilDone():
            #The Label will stay on the screen for as long as
            #the RecordSoundFile state is active. The filename
            #for this state is different for each trial in each block.
            rec = RecordSoundFile(filename="b_" + Ref(str,exp.blockNum) + "_t_" + Ref(str, exp.trialNum),
                                  duration=recDuration)
        #Log the color and word that was presented on the screen,
        #as well as the block and trial number
        Log(name='Stroop', stim_word=trial.current['word'], stim_color=trial.current['color'],
            block_num=exp.blockNum, trial_num=exp.trialNum)
        Wait(interStimulusInterval)
        #Wait for a duration then present the fixation
        #cross again.
        inter_stim = Label(text = '+', font_size = 80, duration = interBlockDur)
        #Increase the trialNum
        exp.trialNum += 1
    #Increase the blockNum
    exp.blockNum += 1
#Run the experiment!
exp.run()

instruct_text = open('stroop_instructions.rst', 'r').read()
RSTFONTSIZE = 30
RSTWIDTH = 900
NUMBLOCKS = 4
LENBLOCKS = 24
recDuration = 2
interBlockDur = 2
interStimulusInterval = 2

def gen_lists(num_of_blocks, len_of_blocks):
    #First, let's define some variables.
    total_words = num_of_blocks * len_of_blocks #The total number of words.
    dict_list = [] #The list to hold the dictionaries
    sample_list = [] #This list will hold a few dictionaries in order to provide a sample.

    """
    We will be creating dictionaries with the following keys:
        word                The actual word.
        color               The color the word will be presented as.
        matched             True or false (True if the word describes its own color, false otherwise.)

    """

    #Now we begin to create the lists.
    for y in range (num_of_blocks):
        for x in range(len_of_blocks/8):
            block_list = []
            #This block will create the matched word/color pairs.
            r_trial = {'word':'red', 'color':'RED', 'matched':True}
            block_list.append(r_trial)
            sample_list.append(r_trial)
            b_trial = {'word':'blue', 'color':'BLUE', 'matched':True}
            block_list.append(b_trial)
            sample_list.append(b_trial)
            g_trial = {'word':'green', 'color':'GREEN', 'matched':True}
            block_list.append(g_trial)
            sample_list.append(g_trial)
            o_trial = {'word':'orange', 'color':'ORANGE', 'matched':True}
            block_list.append(o_trial)
            sample_list.append(o_trial)

            #This set of four will create the mismatched color lists.
            rf_trial = {'word':'red', 'color':randomize_color('red', x%3), 'matched':False}
            block_list.append(rf_trial)
            sample_list.append(rf_trial)
            bf_trial = {'word':'blue', 'color':randomize_color('blue', x%3), 'matched':False}
            block_list.append(bf_trial)
            sample_list.append(bf_trial)
            gf_trial = {'word':'green', 'color':randomize_color('green', x%3), 'matched':False}
            block_list.append(gf_trial)
            sample_list.append(gf_trial)
            of_trial = {'word':'orange', 'color':randomize_color('orange', x%3), 'matched':False}
            block_list.append(of_trial)
            sample_list.append(of_trial)

            #And now we shuffle the lists to ensure randomness.
            shuffle(block_list)
            dict_list.append(block_list)
    shuffle(dict_list)
    return(dict_list, sample_list)



#This function will essentially select a random color from blue, orange, green, and red from amongst the colors that the inputted word is not.
def randomize_color(sColor, iColor):

    final_color = ''
    if(sColor == 'red'):
        if(iColor == 0):
            final_color = 'BLUE'
        elif(iColor == 1):
            final_color = 'ORANGE'
        else:
            final_color = 'GREEN'
    elif(sColor == 'blue'):
        if(iColor == 0):
            final_color = 'RED'
        elif(iColor == 1):
            final_color = 'GREEN'
        else:
            final_color = 'ORANGE'
    elif(sColor == 'green'):
        if(iColor == 0):
            final_color = 'ORANGE'
        elif(iColor == 1):
            final_color = 'BLUE'
        else:
            final_color = 'RED'
    elif(sColor == 'orange'):
        if(iColor == 0):
            final_color = 'RED'
        elif(iColor == 1):
            final_color = 'GREEN'
        else:
            final_color = 'BLUE'
    return final_color
#Generate the Stimulus
trials, sample_list = gen_lists(NUMBLOCKS, LENBLOCKS)

# global imports
import random
import string
# load all the states
from smile.common import *

#execute both the configuration file and the
#stimulus generation file
from config import *
from gen_stim import *

# config vars
NUM_TRIALS = 2
#The trials, shuffled, for the stimulus generation.
NUM_ITEMS = [2,2,2,2,2,2,2,3,3,3,3,3,3,3,4,4,4,4,4,4,4]
random.shuffle(NUM_ITEMS)
ITEMS = string.ascii_lowercase
#instructions written in another document
instruct_text = open('stern_instructions.rst', 'r').read()
RSTFONTSIZE = 30
RSTWIDTH = 900
STUDY_DURATION = 1.2
STUDY_ISI = .4
RETENTION_INTERVAL = 1.0
#KeyPress stuff
RESP_KEYS = ['J','K']
RESP_DELAY = .2
ORIENT_DURATION = 1.0
ORIENT_ISI = .5
ITI = 1.0
FONTSIZE = 30

# generate sternberg trial
def stern_trial(nitems=2, lure_trial=False,):
    if lure_trial:
        condition = 'lure'
        items = random.sample(ITEMS,nitems+1)
    else:
        condition = 'target'
        items = random.sample(ITEMS,nitems)
        # append a test item
        items.append(random.sample(items,1)[0])
    trial = {'nitems':nitems,
             'study_items':items[:-1],
             'test_item':items[-1],
             'condition':condition,}
    return trial

trials = []
for i in NUM_ITEMS:
    # add target trials
    trials.extend([stern_trial(i,lure_trial=False) for t in range(NUM_TRIALS)])
    # add lure trials
    trials.extend([stern_trial(i,lure_trial=True) for t in range(NUM_TRIALS)])

# shuffle and number
random.shuffle(trials)
for t in range(len(trials)):
    trials[t]['trial_num'] = t

#Define the experiment
exp = Experiment()
#Present the instructions to the participant
init_text = RstDocument(text=instruct_text, width=RSTWIDTH, font_size=RSTFONTSIZE, top=exp.screen.top, height=exp.screen.height)
with UntilDone():
    #Once the KeyPress is detected, the UntilDone
    #cancels the RstDocument
    keypress = KeyPress()
# loop over study block
with Loop(trials) as trial:
    #Setup the list of study times.
    exp.study_times = []
    # orient stim
    orient = Label(text='+',duration=ORIENT_DURATION, font_size=FONTSIZE)
    Wait(ORIENT_ISI)
    # loop over study items
    with Loop(trial.current['study_items']) as item:
        # present the letter
        ss = Label(text=item.current, duration=STUDY_DURATION, font_size=FONTSIZE)
        # wait some jittered amount
        Wait(STUDY_ISI)
        # append the time
        exp.study_times+=[ss.appear_time['time']]
    # Retention interval
    Wait(RETENTION_INTERVAL - STUDY_ISI)
    # present the letter
    test_stim = Label(text=trial.current['test_item'], bold=True, font_size=FONTSIZE)
    with UntilDone():
        # wait some before accepting input
        Wait(RESP_DELAY)
        #After the KeyPress is detected, the UntilDone
        #cancels the Label test_stim and allows the
        #experiment to continue.
        ks = KeyPress(keys=RESP_KEYS,
                      base_time=test_stim.appear_time['time'])
    # Log the trial
    Log(trial.current,
        name="Stern",
        resp=ks.pressed,
        rt=ks.rt,
        orient_time=orient.appear_time['time'],
        study_times=exp.study_times,
        test_time=test_stim.appear_time['time'],
        correct=(((trial.current['condition']=='target')&
                 (ks.pressed==RESP_KEYS[0])) |
                 ((trial.current['condition']=='lure')&
                 (ks.pressed==RESP_KEYS[1]))))
    Wait(ITI)
# run that exp!
exp.run()

from smile.log as lg
#define subject pool
subjects = ["s000/","s001/","s002/"]
dic_list = []
for sbj in subjects:
    #get at all the different subjects
    dic_list.append(lg.log2dl(log_filename="data/" + sbj + "Log_Stern"))
#print out all of the study times in the first study block for
#participant one, block one
print dic_list[0]['study_times']

from smile.log as lg
#define subject pool
subjects = ["s000/","s001/","s002/"]
for sbj in subjects:
    #Get at all the subjects data, naming the csv appropriately.
    lg.log2csv(log_filename="data/" + sbj + "Log_Stern", csv_filename=sbj + "_Stern")

# global imports
import random
import string
# load all the states
from smile.common import *

#execute both the configuration file and the
#stimulus generation file
from config import *
from gen_stim import *

#Define the experiment
exp = Experiment()
#Present the instructions to the participant
init_text = RstDocument(text=instruct_text, width=RSTWIDTH, font_size=RSTFONTSIZE top=exp.screen.top, height=exp.screen.height)
with UntilDone():
    #Once the KeyPress is detected, the UntilDone
    #cancels the RstDocument
    keypress = KeyPress()
# loop over study block
with Loop(trials) as trial:
    #Setup the list of study times.
    exp.study_times = []
    # orient stim
    orient = Label(text='+',duration=ORIENT_DURATION, font_size=FONTSIZE)
    Wait(ORIENT_ISI)
    # loop over study items
    with Loop(trial.current['study_items']) as item:
        # present the letter
        ss = Label(text=item.current, duration=STUDY_DURATION, font_size=FONTSIZE)
        # wait some jittered amount
        Wait(STUDY_ISI)
        # append the time
        exp.study_times+=[ss.appear_time['time']]
    # Retention interval
    Wait(RETENTION_INTERVAL - STUDY_ISI)
    # present the letter
    test_stim = Label(text=trial.current['test_item'], bold=True, font_size=FONTSIZE)
    with UntilDone():
        # wait some before accepting input
        Wait(RESP_DELAY)
        #After the KeyPress is detected, the UntilDone
        #cancels the Label test_stim and allows the
        #experiment to continue.
        ks = KeyPress(keys=RESP_KEYS,
                      base_time=test_stim.appear_time['time'])
    # Log the trial
    Log(trial.current,
        name="Stern",
        resp=ks.pressed,
        rt=ks.rt,
        orient_time=orient.appear_time['time'],
        study_times=exp.study_times,
        test_time=test_stim.appear_time['time'],
        correct=(((trial.current['condition']=='target')&
                 (ks.pressed==RESP_KEYS[0])) |
                 ((trial.current['condition']=='lure')&
                 (ks.pressed==RESP_KEYS[1]))))
    Wait(ITI)
# run that exp!
exp.run()

# config vars
NUM_TRIALS = 2
NUM_ITEMS = [2,3,4]
ITEMS = string.ascii_lowercase
instruct_text = open('stern_instructions.rst', 'r').read()
RSTFONTSIZE = 30
RSTWIDTH = 900
STUDY_DURATION = 1.2
STUDY_ISI = .4
RETENTION_INTERVAL = 1.0
RESP_KEYS = ['J','K']
RESP_DELAY = .2
ORIENT_DURATION = 1.0
ORIENT_ISI = .5
ITI = 1.0
FONTSIZE = 30

# generate Sternberg trial
def stern_trial(nitems=2, lure_trial=False,):
    if lure_trial:
        condition = 'lure'
        items = random.sample(ITEMS,nitems+1)
    else:
        condition = 'target'
        items = random.sample(ITEMS,nitems)
        # append a test item
        items.append(random.sample(items,1)[0])
    trial = {'nitems':nitems,
             'study_items':items[:-1],
             'test_item':items[-1],
             'condition':condition,}
    return trial

trials = []
for i in NUM_ITEMS:
    # add target trials
    trials.extend([stern_trial(i,lure_trial=False) for t in range(NUM_TRIALS)])
    # add lure trials
    trials.extend([stern_trial(i,lure_trial=True) for t in range(NUM_TRIALS)])

# shuffle and number
random.shuffle(trials)
for t in range(len(trials)):
    trials[t]['trial_num'] = t

#freekey.py
from smile.common import *
from smile.freekey import FreeKey

#execute both the configuration file and the
#stimulus generation file
from config import *
from gen_stim import *

#Names of the stimulus files
filenameL = "pools/living.txt"
filenameN = "pools/nonliving.txt"

#Open the files and combine them
L = open(filenameL)
N = open(filenameN)
stimList = L.read().split('\n')
stimList.append(N.read().split('\n'))

#Open the instructions file
instruct_text = open('freekey_instructions.rst', 'r').read()

#Define the Experimental Variables
ISI = 2
IBI = 2
STIMDUR = 2
PFI = 4
FONTSIZE = 40
RSTFONTSIZE = 30
RSTWIDTH = 900

MINFKDUR = 20

NUMBLOCKS = 6
NUMPERBLOCK = [10,15,20]

import random

#Shuffle the stimulus
random.shuffle(stimList)

blocks = []
#Loop NUMBLOCKS times
for i in range(NUMBLOCKS):
    tempList = []
    #For each block, loop either 10, 15, or 20 times
    #Counter balanced to have equal numbers of each
    for x in range(NUMPERBLOCK[i%len(NUMPERBLOCK)]):
        tempList.append(stimList.pop())
    #Create tempBlock
    tempBlock = {"study":tempList,
                 "duration":(MINFKDUR + 10*i%len(NUMPERBLOCK))}
    blocks.append(tempBlock)
#Shuffle the newly created list of blocks
random.shuffle(blocks)

from smile.log as lg
#define subject pool
subjects = ["s000/","s001/","s002/"]
dic_list = []
for sbj in subjects:
    #get at all the different subjects
    dic_list.append(lg.log2dl(log_filename="data/" + sbj + "Log_FreeKey"))
#print out all of the study times in the first study block for
#participant one, block one
print dic_list[0]['study_times']

from smile.log as lg
#define subject pool
subjects = ["s000/","s001/","s002/"]
for sbj in subjects:
    #Get at all the subjects data, naming the csv appropriately.
    lg.log2csv(log_filename="data/" + sbj + "Log_FreeKey", csv_filename=sbj + "_FreeKey")

#freekey.py
from smile.common import *
from smile.freekey import FreeKey

#execute both the configuration file and the
#stimulus generation file
from config import *
from gen_stim import *

#Initialize the Experiment
exp = Experiment()

#Show the instructions to the participant
RstDocument(text=instruct_text, base_font_size=RSTFONTSIZE, width=RSTWIDTH, height=exp.screen.height)
with UntilDone():
    #When a KeyPress is detected, the UntilDone
    #will cancel the RstDocument state
    KeyPress()
#Start the experiment Loop
with Loop(blocks) as block:
    Wait(IBI)
    with Loop(block.current['study']) as study:
        #Present the Fixation Cross
        Label(text="+", duration=ISI, font_size=FONTSIZE)
        #Present the study item
        Label(text=study.current, duration=STIMDUR, font_size=FONTSIZE)
    Wait(PFI)
    #Start FreeKey
    fk = FreeKey(Label(text="XXXXXXX", font_size=FONTSIZE), max_duration=block.current['duration'])
    #Log everything!
    Log(block,
        name="FreeKey",
        responses = fk.responses)
#Run the experiment
exp.run()

#Names of the stimulus files
filenameL = "pools/living.txt"
filenameN = "pools/nonliving.txt"

#Open the files and combine them
L = open(filenameL)
N = open(filenameN)
stimList = L.read().split('\n')
stimList.append(N.read().split('\n'))

#Open the instructions file
instruct_text = open('freekey_instructions.rst', 'r').read()

#Define the Experimental Variables
ISI = 2
IBI = 2
STIMDUR = 2
PFI = 4
FONTSIZE = 40
RSTFONTSIZE = 30
RSTWIDTH = 900

MINFKDUR = 20

NUMBLOCKS = 6
NUMPERBLOCK = [10,15,20]

import random

#Shuffle the stimulus
random.shuffle(stimList)

blocks = []
#Loop NUMBLOCKS times
for i in range(NUMBLOCKS):
    tempList = []
    #For each block, loop either 10, 15, or 20 times
    #Counter balanced to have equal numbers of each
    for x in range(NUMPERBLOCK[i%len(NUMPERBLOCK)]):
        tempList.append(stimList.pop())
    #Create tempBlock
    tempBlock = {"study":tempList,
                 "duration":(MINFKDUR + 10*i%len(NUMPERBLOCK))}
    blocks.append(tempBlock)
#Shuffle the newly created list of blocks
random.shuffle(blocks)

from smile.common import *
from config import *
from gen_stim import *

#RST VARIABLES
RSTFONTSIZE = 50
RSTWIDTH = 600
instruct1 = open('iat_mouse_instructions1.rst', 'r').read()
instruct2 = open('iat_mouse_instructions2.rst', 'r').read()
instruct3 = open('iat_mouse_instructions3.rst', 'r').read()
instruct4 = open('iat_mouse_instructions4.rst', 'r').read()
instruct5 = open('iat_mouse_instructions5.rst', 'r').read()
instruct6 = open('iat_mouse_instructions6.rst', 'r').read()
instruct7 = open('iat_mouse_instructions7.rst', 'r').read()

#MOUSE MOVING VARIABLES
WARNINGDURATION = 2.0
MOUSEMOVERADIUS = 100
MOUSEMOVEINTERVAL = 0.400

#BUTTON VARIABLES
BUTTONHEIGHT = 150
BUTTONWIDTH = 200

#GENERAL VARIABLES
FONTSIZE = 40
INTERTRIALINTERVAL = 0.750

import random as rm
from config import instruct1,instruct2,instruct3,instruct4,instruct5,instruct6,instruct7

# WORDLISTS FROM Greenwald et al. 1998
filenameI = "pools/insects.txt"
filenameF = "pools/flowers.txt"
filenameP = "pools/positives.txt"
filenameN = "pools/negatives.txt"

I = open(filenameI)
F = open(filenameF)
P = open(filenameP)
N = open(filenameN)

stimListI = I.read().split('\n')
stimListF = F.read().split('\n')
stimListP = P.read().split('\n')
stimListN = N.read().split('\n')

#pop off the trailing line
stimListI.pop(len(stimListI)-1)
stimListF.pop(len(stimListF)-1)
stimListP.pop(len(stimListP)-1)
stimListN.pop(len(stimListN)-1)

def gen_blocks(type):

    sampI = rm.sample(stimListI, 10)
    sampF = rm.sample(stimListF, 10)
    sampP = rm.sample(stimListP, 10)
    sampN = rm.sample(stimListN, 10)

    #Generate the blocks
    list1 = {"left_word":"flower", "right_word":"insect", "instruct":instruct1,
             "words":([{"correct":"right", "center_word":I} for I in sampI] +
                      [{"correct":"left", "center_word":F} for F in sampF])}

    list2 = {"left_word":"positive", "right_word":"negative", "instruct":instruct2,
             "words":([{"correct":"left", "center_word":P} for P in sampP] +
                      [{"correct":"right", "center_word":N} for N in sampN])}

    list3 = {"left_word":"flower positive", "right_word":"insect negative", "instruct":instruct3,
             "words":([{"correct":"right", "center_word":I} for I in rm.sample(sampI[:], 5)] +
                      [{"correct":"left", "center_word":F} for F in rm.sample(sampF[:], 5)] +
                      [{"correct":"left", "center_word":P} for P in rm.sample(sampP[:], 5)] +
                      [{"correct":"right", "center_word":N} for N in rm.sample(sampN[:], 5)])}

    list4 = {"left_word":"flower positive", "right_word":"insect negative", "instruct":instruct4,
             "words":([{"correct":"right", "center_word":I} for I in sampI] +
                      [{"correct":"left", "center_word":F} for F in sampF] +
                      [{"correct":"left", "center_word":P} for P in sampP] +
                      [{"correct":"right", "center_word":N} for N in sampN])}

    list5 = {"left_word":"insect", "right_word":"flower", "instruct":instruct5,
             "words":[{"correct":"left", "center_word":I} for I in sampI] + [{"correct":"right", "center_word":F} for F in sampF]}

    list6 = {"left_word":"insect positive", "right_word":"flower negative", "instruct":instruct6,
             "words":([{"correct":"left", "center_word":I} for I in rm.sample(sampI[:], 5)] +
                      [{"correct":"right", "center_word":F} for F in rm.sample(sampF[:], 5)] +
                      [{"correct":"left", "center_word":P} for P in rm.sample(sampP[:], 5)] +
                      [{"correct":"right", "center_word":N} for N in rm.sample(sampN[:], 5)])}

    list7 = {"left_word":"insect positive", "right_word":"flower negative", "instruct":instruct7,
             "words":([{"correct":"left", "center_word":I} for I in sampI] +
                      [{"correct":"right", "center_word":F} for F in sampF] +
                      [{"correct":"left", "center_word":P} for P in sampP] +
                      [{"correct":"right", "center_word":N} for N in sampN])}
    rm.shuffle(list1['words'])
    rm.shuffle(list2['words'])
    rm.shuffle(list3['words'])
    rm.shuffle(list4['words'])
    rm.shuffle(list5['words'])
    rm.shuffle(list6['words'])
    rm.shuffle(list7['words'])

    #If type 1, then do critical compatible lists
    if type == 1:
        return [list1, list2, list3, list4, list5, list6, list7]
    #if type 2, then do critical incompatible lists
    else:
        return [list5, list2, list6, list7, list1, list3, list4]
#GenBlocks
BLOCKS = gen_blocks(1)