def __init__(self, speed=1): Sequence.__init__( self, [ Row(speed, [0,0,0,0,0,0,0,0,0,0,0,0]), ], 1 )
def __init__(self,iterable=[],key=None):
"""The only additional data we maintain over a vanilla Sequence
is a dictionary self._tag mapping sequence items to integers,
such that an item is earlier than another iff its tag is smaller.
"""
self._tag = {}
Sequence.__init__(self,iterable,key=key)
def append(self,x):
"""Add x to the end of the sequence."""
if not self._next: # add to empty sequence
Sequence.append(self,x)
self._tag[self.key(x)] = sys.maxint//2
else:
self.insertAfter(self._prev[self._first],x)
def __init__(self, speed=0.85): Sequence.__init__( self, [ Row(speed, [1,0,1,0,1,0,1,0,1,0,1,0]), Row(speed, [0,1,0,1,0,1,0,1,0,1,0,1]), ], 12 )
def insertBefore(self,x,y):
"""Add y before x in the sequence."""
Sequence.insertBefore(self,x,y)
x = self.key(x)
y = self.key(y)
if self._first == y:
self._tag[y] = self._tag[x]//2
if self._tag[y] == self._tag[x]:
self.rebalance(y)
def __init__(self, speed=0.8): Sequence.__init__( self, [ Row(speed, [1,1,1,1,1,1,0,0,0,0,0,0]), Row(speed, [0,0,0,0,0,0,1,1,1,1,1,1]), Row(0.001, [0,0,0,0,0,0,0,0,0,0,0,0]), ], 99 )
def insertAfter(self,x,y):
"""Add y after x and compute a tag for it."""
Sequence.insertAfter(self,x,y)
x = self.key(x)
y = self.key(y)
next = self._next[y]
if next == self._first:
nexttag = sys.maxint
else:
nexttag = self._tag[next]
xtag = self._tag[x]
self._tag[y] = xtag + (nexttag - xtag + 1)//2
if self._tag[y] == nexttag:
self.rebalance(y)
def ParseXMLFile(xmlFileName):
xmlDoc = ET.parse(xmlFileName)
rootNode = xmlDoc.getroot()
idSpeaker = rootNode.find('IdSpeaker').text
idSession = rootNode.find('IdSession').text
device = rootNode.find('Device').text
typeSequence = rootNode.find('TypeSequence').text
digits = rootNode.find('Digits').text
digits = digits.split()
digitsById = []
for i in range(11):
digitNode = rootNode.find('digit' + str(i + 1))
if not digitNode:
break
digitName = digits[i]
digitId = digitsByName[digitName]
startDigit = digitNode.find('start_digit').text
endDigit = digitNode.find('end_digit').text
startTightDigit = digitNode.find('start_tight_digit').text
endTightDigit = digitNode.find('end_tight_digit').text
digit = Digit(digitId, startDigit, endDigit, startTightDigit,
endTightDigit, digitName)
digitsById.append(digit)
sequence = Sequence(idSpeaker, idSession, device, typeSequence, digitsById)
return sequence
def __init__(self, file_list, *args, **kwargs):
self.temp_dir = 'temp/trace_files'
# Copy the files provided into the temp directory
tools.copy_list_to_folder(file_list, self.temp_dir)
self.file_list = tools.listdir_joined(self.temp_dir)
self.trace_file, self.non_abi = tools.abi_filter(self.file_list)
self.seq_list = []
self.entries = []
self.parse_failed = []
self.exceptions = []
self.fail_folder = os.path.join('Exceptions',
str(datetime.date.today()))
for item in self.trace_file:
try:
holder = Sequence(item, *args, **kwargs)
self.seq_list.append(holder)
except:
self.parse_failed.append(item)
print "Failed to parse ", item
# Select the valid files for entry
for seq in self.seq_list:
if seq.record[0] is True:
self.entries.append(seq.record)
elif seq.record[0] is False:
self.exceptions.append(seq.record)
print seq.record[1], ' is not a valid file.'
def Tracking(Sequence, tracker_list, visualize=False):
if not os.path.exists('results/'):
#创建目录
os.mkdir("results")
print 'generate images.txt and region.txt files...'
with open("images.txt", "w") as f:
while Sequence._frame < len(Sequence._images):
#将多个文件的路径写进txt文档
f.write(Sequence.frame() + '\n')
Sequence._frame += 1
Sequence._frame = 0
with open("region.txt", "w") as f:
f.write(
open(os.path.join(Sequence.seqdir, 'groundtruth.txt'),
'r').readline())
print 'start tracking...'
for str in tracker_list:
print 'tracking using: ' + str
print(str)
import_module(str)
if not os.path.exists('results/' + str + '/' + Sequence.name):
os.makedirs('results/' + str + '/' + Sequence.name)
shutil.move("output.txt",
'results/' + str + '/' + Sequence.name + '/output.txt')
#进行文件的删除
os.remove("images.txt")
os.remove("region.txt")
print 'Done!!'
def __init__(self, D):
# refine partition of states by reversed neighborhoods
N = D.reverse()
P = PartitionRefinement(D.states())
P.refine([s for s in D.states() if D.isfinal(s)])
unrefined = Sequence(P, key=id)
while unrefined:
part = arbitrary_item(unrefined)
unrefined.remove(part)
for symbol in D.alphabet:
neighbors = set()
for state in part:
neighbors |= N.transition(state, symbol)
for new, old in P.refine(neighbors):
if old in unrefined or len(new) < len(old):
unrefined.append(new)
else:
unrefined.append(old)
# convert partition to DFA
P.freeze()
self.partition = P
self.initial = P[D.initial]
self.alphabet = D.alphabet
self.DFA = D
def test_minimal_sequence_visualize_tree(self):
s = Sequence.from_file(testpath +
"/test_sequences/minimal_sequence.xml")
s.resolve_references()
tree = _Sequence_verification.Tree(sequence=s, control_values={})
tree.build()
tree.visualize()
def yield_sequence_and_BlastHit(len_seq=500,
n_query=10,
min_len_hit=20,
max_len_hit=40):
# Generate a random subject sequence
with rand_fasta(len_seq=len_seq, n_seq=1) as subject:
pyfasta_gen = pyfasta.Fasta(subject.fasta_path, flatten_inplace=True)
seq_record = pyfasta_gen["seq_0"]
sequence = Sequence(name="seq_0", seq_record=seq_record)
seq_dict = {}
# Generate random hits from the subject
for i in range(n_query):
start = ri(1, len_seq - max_len_hit)
end = start + ri(min_len_hit, max_len_hit)
seq_dict["query_{}:{}-{}".format(i, start,
end)] = str(seq_record[start:end])
with defined_fasta(seq_dict) as query:
# Create Blast DB and perform a blast to generate a list of hits
with Blastn(subject.fasta_path) as blastn:
hit_list = blastn(
query.fasta_path,
task="blastn",
best_query_hit=True,
)
yield (sequence, hit_list)
def make_sequence(path):
sequence = Sequence()
pitch = 48
position = 0
duration = Sequence.TPB
velocity = 100
commands = read_commands_from_file(path)
for command in commands:
type, value = get_type_and_value(command)
if type == ParameterType.PITCH:
pitch = value
sequence.add_note(pitch, position, duration, velocity)
position += duration
elif type == ParameterType.POSITION:
position = value
elif type == ParameterType.DURATION:
duration = value
elif type == ParameterType.VELOCITY:
velocity = value
elif type == ParameterType.BPM:
bpm = value
sequence.set_tempo(bpm)
return sequence
def chargerFichierSequence(nom_fichier):
res = [] # Liste où seront stocké les séquences
# Ouverture du fichier
fichier = open(nom_fichier, 'r')
nomSequence = "" # Nom de la séquence
debut = -1 # Index de début de séquence
fin = -1 # Index de fin de séquence
sequence = "" # La séquence en elle-même
# On lit chaque ligne du fichier
for ligne in fichier:
ligne = ligne.strip() # Supprime les espaces inutiles
if (ligne[0] == '>'): # début d'une séquence
if (sequence != ""): # Si la séquence n'est pas vide
# On enregistre
res.append(Sequence(sequence, nomSequence, debut, fin))
# On remet tout à zero
nomSequence = ""
debut = -1
fin = -1
sequence = ""
# On extrait les informations
infos = ligne.split('|')
if (len(infos) == 3):
nomSequence = infos[1]
debutFin = infos[2].split("-")
if (len(debutFin) == 2):
debut = debutFin[0]
fin = debutFin[1]
else: # Si on a pas toutes les informations on informe qu'il y a une erreur
raise SyntaxError("Fichier invalide (debug ligne: %s )" %
ligne)
else: # Suite d'une séquence
sequence += ligne.strip()
# On oublies pas la dernière séquence (qui n'a aucune autre séquence après elle)
if (sequence != ""):
res.append(Sequence(sequence, nomSequence, debut, fin))
return res
def test_detect_when_sequence_has_infinite_subloop(self):
s = Sequence.from_file(
testpath + "/test_sequences/minimal_sequence_with_subloop.xml")
s.resolve_references()
tree = _Sequence_verification.Tree(sequence=s, control_values={})
with self.assertRaises(InvalidSequenceException):
tree.build()
tree.visualize()
def FromAtoms(selfClass, atoms, bonds=None, withSequence=False):
"""Constructor given a list of atoms."""
self = selfClass()
self.__dict__["_atoms"] = AtomContainer.FromIterable(atoms)
self.__dict__["_connectivity"] = Connectivity.FromAtomContainer(
self.atoms, bonds=bonds)
if withSequence:
self.__dict__["_sequence"] = Sequence.FromAtomContainer(self.atoms)
return self
def loadSequence(self):
seq = Sequence(*self.get_sequence_init_args())
for _,v in self.config['sequence channels'].items():
channelArgs = map(lambda x,y:x(y), [int, lambda x: [eval(y) for y in x], lambda x: [int(y) for y in x]],
[v['chNum'],v['tV_pairs'],v['V_interval_styles']])
seq.addChannelSeq(*channelArgs)
return seq
def plain(file_name):
"""
:param file_name: data file name
:return: Sequence object
"""
with open(file_name) as f:
string = ''.join([line.strip() for line in f.readlines()])
return [Sequence(0, string)]
def calculate_average_ngram_presence(coordinates, genome, ngram):
ngram_presence = np.zeros(len(coordinates))
ngram_reversed = Sequence.reverse_complement(ngram)
for idx, c in enumerate(coordinates):
seq = genome.extract_sequence(c)
ngram_presence[idx] = (seq.count(ngram) +
seq.count(ngram_reversed)) / float(len(c))
return ngram_presence
def test_detect_when_sequence_never_terminates_at_all(self):
s = Sequence.from_file(
testpath + "/test_sequences/minimal_sequence_with_loop.xml")
s.resolve_references()
tree = _Sequence_verification.Tree(sequence=s, control_values={})
tree.build()
tree.visualize()
with self.assertRaises(InvalidSequenceException):
tree.check()
def addBlock(self, block):
self.nbOfBlocks += 1
self.clusters = []
for seq in block:
self.clusters.append(Cluster([Sequence(seq)]))
self.buildClusters()
self.computeRandomModel()
self.computeEvolutionaryModel()
def getDecision(self, current_frame):
self.log.logMessage("DECISION #%d in GAME FRAME #%d" %
(self.actions_performed, self.game.world_counter))
self.log.logMessage("TRAINED ON %d FRAMES" % (self.frames_trained))
features = self.ae_network.encodeNumpyArray(current_frame.pixels)
#self.log.logMessage("Current frame yields features: %s" % str(features))
if self.previous_reward != 0:
self.log.logMessage("GOT REWARD: %d" % self.previous_reward)
self.total_score += self.previous_reward
# First frame of game
if self.actions_performed == 0:
self.actions_performed += 1
self.previous_seq = Sequence(features)
# print("FRAME SEQUENCE: {0}".format(self.previous_seq))
curr_action = self.pickRandomAction()
self.previous_seq = self.previous_seq.createNewSequence(
curr_action)
self.previous_action = curr_action
# print("FIRST SEQUENCE: {0}".format(self.previous_seq))
return
# Should I make a random move?
r = random.random()
# Add on the current frame to the current sequence
self.current_seq = self.previous_seq.createNewSequence(features)
if r > self.epsilon or self.actions_performed < 4: #not self.current_seq.isFull():
curr_action = self.pickRandomAction()
else:
# Run the CNN and pick the max output action
curr_action = self.pickBestAction(self.current_seq)
# Finally, add the chosen action to the current sequence
self.current_seq = self.current_seq.createNewSequence(curr_action)
# Actually perform the action in the game
self.performAction(curr_action)
new_experience = Experience(self.previous_seq, self.previous_action,
self.previous_reward, self.current_seq)
self.replay_memory.store(new_experience)
self.previous_seq = self.current_seq
if self.game.world_counter > STARTING_FRAMES and self.game.world_counter % BATCH_TRAINING_FREQUENCY == 0:
self.trainMinibatch()
# Remember the chosen Action since it will be required for the next iteration
self.previous_action = curr_action
if self.epsilon < MAX_EPSILON:
self.epsilon *= EPSILON_UPDATE
self.log.logMessage("UPDATED EPSILON: %.5f" % self.epsilon)
def addSequenceLocation(self, sequenceLocation):
self.sequencesLocations.append(sequenceLocation)
seq = Sequence.loadCSVSequence(sequenceLocation, self.fields,
self.observationPeriod,
self.predictionPeriod)
self.sequences.append(seq)
if seq.getLabel() not in self.sequencesClasses:
self.sequencesClasses[seq.getLabel()] = []
self.sequencesClasses[seq.getLabel()].append(sequenceLocation)
self.classes[seq.getLabel()] += 1
def __init__ (self, name, fasta, compress=True):
"""
Create a reference object extract fasta ref if needed and create a sequence object per
sequences found in the fasta file
@param name Name of the Reference
@param fasta Path to a fasta file (can be gzipped)
@param compress Fasta output will be gzipped if True
"""
print(("Create {} object".format(name)))
# Create self variables
self.name = name
self.temp_dir = mkdtemp()
self.compress = compress
# Create a name for the fasta file to be generated
self.modified_fasta = "{}_masked.fa{}".format(self.name, ".gz" if self.compress else "")
try:
# Test values
assert self.name not in self.REFERENCE_NAMES, "Reference name <{}> is duplicated".format(self.name)
assert is_readable_file(fasta), "{} is not a valid file".format(fasta)
# If gziped, ungzip the reference fasta file in the temporary folder. If not compress
# copy in the temporary folder
if is_gziped(fasta):
print (" * Unzip fasta file in a temporary directory")
self.fasta = gunzip(fasta, self.temp_dir)
else:
print (" * Copy fasta file in a temporary directory")
self.fasta = cp(fasta, self.temp_dir)
# Loading the fasta sequence in a pyfasta.Fasta (seq_record is a mapping)
print (" * Parsing the file with pyfasta")
seq_dict = {}
fasta_record = pyfasta.Fasta(self.fasta, flatten_inplace=True)
print((" * Found {} sequences in {}".format (len (fasta_record), self.name)))
for name, seq_record in list(fasta_record.items()):
# Remove additional sequence descriptor in fasta header and create a Sequence object
short_name = name.partition(" ")[0]
assert short_name not in seq_dict, "Reference name <{}> is duplicated in <{}>".format(short_name,self.name)
seq_dict[short_name] = Sequence(name=short_name, seq_record=seq_record)
# Save to a name sorted ordered dict
self.seq_dict = OrderedDict(sorted(list(seq_dict.items()), key=lambda x: x))
# Add name to a class list
self.ADD_TO_REFERENCE_NAMES(self.name)
except Exception as E:
self.clean()
raise E
def parse_seq(lines):
seq_name = parse_seq_name(lines)
seq_length = int(lines[0].split('\t', 1)[0])
seq = ""
for i in range(1, seq_length + 1):
seq += lines[i].split('\t', 2)[1]
return Sequence(seq_name, 'RNA', seq)
def read_files(sequences_path, attributes_path):
# initialize structure to store sequence object
orig_seq_storage = []
# append ">END" flag to fasta file
with open(sequences_path, 'a') as f:
f.write("\n>END")
# open fasta file to read
seq_file = open(sequences_path, "r")
# read each sequence from csv and fasta files
with open(attributes_path, "r") as attributesFile:
reader = csv.reader(attributesFile, delimiter=",")
for i, line in enumerate(reader):
# create new sequence
new_sequence = Sequence()
# define sequence variables
new_sequence.accession = line[0]
new_sequence.species = line[1]
new_sequence.length = line[2]
new_sequence.nuc_completeness = line[3]
new_sequence.geo_location = line[4]
new_sequence.us_state = line[5]
new_sequence.isolation_source = line[6]
new_sequence.collection_date = line[7]
# extract DNA sequence
curr_dna_seq = []
iterator = True
seq_line = seq_file.readline()
while iterator:
seq_line = seq_file.readline()
if seq_line[0] == ">":
iterator = False
else:
# store sequence from fasta file into object variable, stripping whitespace
curr_dna_seq.append(seq_line.strip())
# join curr_dna_seq and store to object DNASeq
new_sequence.dna_seq = ''.join(curr_dna_seq)
curr_dna_seq.clear()
# append sequence to sequence storage
orig_seq_storage.append(new_sequence)
# print data
new_sequence.to_string()
return orig_seq_storage
def FASTA(file_name):
with open(file_name) as f:
lines = f.readlines()
result = []
for line in lines:
line = line.strip()
if len(line) == 0: continue
if line[0] == ">":
id = line.split()[0][1:]
result.append(Sequence(id, ""))
else:
result[-1].sequence += line
return result
class Config:
pace = 1
terra_wave = Action('0', 4, cd_type.Attack, 'Terra Wave')
intense_healing = Action('1', 1, cd_type.Healing, 'Intense Healing')
ice_strike = Action('2', 2, cd_type.Attack, 'Ice Strike')
ice_wave = Action('8', 4, cd_type.Attack, 'Ice Wave')
mana_heal = Action('3', 1, cd_type.Nil, 'Mana Potion')
avalanche = Action('4', 2, cd_type.Attack, 'Avalanche')
# mas_san = Action('F5', 2, cd_type.Attack, 'Exevo Mas San')
# rune_area = Action('F6', 2, cd_type.Healing, '')
# strong_mana = Action('F4', 1, cd_type.Attack, '')
# exura_gran_san = Action('F2', 1, cd_type.Attack, '')
seq = Sequence([ice_strike, terra_wave, ice_strike, ice_wave])
mana_pot_seq = Sequence([mana_heal])
intense_healing_seq = Sequence([intense_healing])
avalanche_sequence = Sequence([avalanche])
# sec_pally_atk = Sequence([mas_san, rune_area])
# sec_pally_mana = Sequence([mas_san, rune_area])
# sec_pally_heal_mana = Sequence([mas_san, rune_area])
# Druid
macros = {'f1': seq, 'f2': intense_healing_seq, 'f3': avalanche_sequence}
def __init__(self, f, start, dur, bars):
self.instr = f.makeInstrument()
self.sco = ""
sig = choice([4, 8, 12, 16])
seq = Sequence(sig)
bardur = dur / bars
notedur = bardur / sig
for b in range(bars + 1):
for t in range(len(seq.beats)):
if seq.beats[t] == 1:
istart = start + b * bardur + t * notedur
n = self.instr.makeNote(istart)
self.sco += str(n)
seq.mutate(1)
def from_file(case_path):
'''
Parse a C file into test case.
'''
seq = Sequence('test_syscall')
seed = 0
code_parser = CodeParser()
with open(case_path, 'r') as fd:
for line in fd:
if 'do_' in line:
cmd = code_parser.parse_command(line.strip())
seq.push(cmd)
elif 'srand' in line:
seed = re.findall(r'srand\((\d+)\)', line)[0]
return TestCase(case_path, seq, seed)
def GenBank(file_name):
with open(file_name) as f:
lines = f.readlines()
result = []
state = 0 #0-looking for new sequence, 1 - looking for beginning of sequence, 2 - for end of seq
states = ["LOCUS", "ORIGIN", "//"]
for line in lines:
line = line.strip()
if len(line) == 0: continue
if line.split()[0] != states[state]:
if state == 2:
result[-1].sequence += ''.join(line.split()[1:]).upper()
continue
if state == 0:
id = line.split()[1]
result.append(Sequence(id, ""))
state = (state + 1) % 3
return result
def LexBFS(G):
"""Find lexicographic breadth-first-search traversal order of a graph.
G should be represented in such a way that "for v in G" loops through
the vertices, and "G[v]" produces a sequence of the neighbors of v; for
instance, G may be a dictionary mapping each vertex to its neighbor set.
Running time is O(n+m) and additional space usage over G is O(n).
"""
P = PartitionRefinement(G)
S = Sequence(P, key=id)
while S:
set = S[0]
v = arbitrary_item(set)
yield v
P.remove(v)
if not set:
S.remove(set)
for new,old in P.refine(G[v]):
S.insertBefore(old,new)
def FASTQ(file_name):
"""
:param file_name: data file name
:return: list of Sequences
"""
with open(file_name) as f:
lines = f.readlines()
result = []
current_sequence = None
current_line = 0
for line in lines:
line = line.strip()
if len(line) == 0: continue
if line[0] == "@":
current_line = 0
result.append(Sequence(line[1:], ""))
if current_line == 1:
result[-1].sequence = line
current_line += 1
return result
def _make_sequences(self, alglist, te_in):
"""Convert alglist objects to sequence objects"""
te_out = self._make_teout_name(te_in, alglist.alias)
new_sequence = Sequence(
te_in,
alglist.alg_list,
alglist.alias, # for debugging
te_out)
# _update_if_diagnostic_sequence(new_sequence)
self.sequences.append(new_sequence)
# having appended the new sequence to the sequence list,
# the sequence to which it is connected is attached. This
# will be found elsewhere in the alias table.
# Note that this code is not protected against cycles - that
# is if the inputs do not form a tree, this procedure could go
# into an infinite loop.
for c in self.alias_table[alglist.alias]:
self._make_sequences(c, te_out)
def __setstate__(self, state):
"""Set the state of the object."""
# . Sequence is present.
if "sequence" in state:
sequence = Sequence.FromMapping(state["sequence"])
atoms = sequence.GatherAtoms()
self.__dict__["_atoms"] = AtomContainer.FromIterable(
atoms, attributes=state.get("atoms", None))
self.__dict__["_sequence"] = sequence
# . Sequence is absent.
else:
self.__dict__["_atoms"] = AtomContainer.FromMapping(state["atoms"])
# . Connectivity.
self.__dict__["_connectivity"] = Connectivity.FromAtomContainer(
self.atoms,
bonds=state.get("bonds", None),
ringSets=state.get("ringSets", None))
# . Other attributes.
for key in self.__class__.defaultAttributes:
label = key[1:]
if label not in ("atoms", "connectivity", "sequence"):
value = state.get(label, None)
if value is not None: self.__dict__[key] = value
def LexBFS(G):
"""Find lexicographic breadth-first-search traversal order of a graph.
G should be represented in such a way that "for v in G" loops through
the vertices, and "G[v]" produces a sequence of the neighbors of v; for
instance, G may be a dictionary mapping each vertex to its neighbor set.
Running time is O(n+m) and additional space usage over G is O(n).
"""
P = PartitionRefinement(G) #một phân vùng chứa đồ thị (lọc phân vùng)
S = Sequence(P,
key=id) #một dãy, chuỗi bao gồm các giá trị vừa lọc, thêm id
sigma = [] #mảng sigma
while S: #vòng lặp while đầu vào là một chuỗi
set = S[0] #gọi set là giá trị đầu tiên của mảng, S[0]
v = arbitrary_item(set) #v là 1 giá trị tùy ý
sigma.append(v) #nối thêm giá trị của v vào sigma
P.remove(v) #đồng thời remode giá trị đó ra khỏi phân vùng P
if not set: #thay đổi điều kiện cho đến khi nó thỏa mãn
S.remove(set)
for new, old in P.refine(G.neighbors(v)):
S.insertBefore(old, new)
return sigma
def __init__(self):
speed = 0.083
Sequence.__init__(
self, [
Row(speed, [1,0,0,0,0,0,0,0,0,0,0,0]),
Row(speed, [0,1,0,0,0,0,0,0,0,0,0,0]),
Row(speed, [0,0,1,0,0,0,0,0,0,0,0,0]),
Row(speed, [0,0,0,1,0,0,0,0,0,0,0,0]),
Row(speed, [0,0,0,0,1,0,0,0,0,0,0,0]),
Row(speed, [0,0,0,0,0,1,0,0,0,0,0,0]),
Row(speed, [0,0,0,0,0,0,1,0,0,0,0,0]),
Row(speed, [0,0,0,0,0,0,0,1,0,0,0,0]),
Row(speed, [0,0,0,0,0,0,0,0,1,0,0,0]),
Row(speed, [0,0,0,0,0,0,0,0,0,1,0,0]),
Row(speed, [0,0,0,0,0,0,0,0,0,0,1,0]),
Row(speed, [0,0,0,0,0,0,0,0,0,0,0,1]),
Row(speed, [1,0,0,0,0,0,0,0,0,0,0,0]),
Row(speed, [1,1,0,0,0,0,0,0,0,0,0,0]),
Row(speed, [1,0,1,0,0,0,0,0,0,0,0,0]),
Row(speed, [1,0,0,1,0,0,0,0,0,0,0,0]),
Row(speed, [1,0,0,0,1,0,0,0,0,0,0,0]),
Row(speed, [1,0,0,0,0,1,0,0,0,0,0,0]),
Row(speed, [1,0,0,0,0,0,1,0,0,0,0,0]),
Row(speed, [1,0,0,0,0,0,0,1,0,0,0,0]),
Row(speed, [1,0,0,0,0,0,0,0,1,0,0,0]),
Row(speed, [1,0,0,0,0,0,0,0,0,1,0,0]),
Row(speed, [1,0,0,0,0,0,0,0,0,0,1,0]),
Row(speed, [1,0,0,0,0,0,0,0,0,0,0,1]),
Row(speed, [0,1,0,0,0,0,0,0,0,0,0,0]),
Row(speed, [1,0,0,0,0,0,0,0,0,0,0,0]),
Row(speed, [1,1,1,0,0,0,0,0,0,0,0,0]),
Row(speed, [1,1,0,1,0,0,0,0,0,0,0,0]),
Row(speed, [1,1,0,0,1,0,0,0,0,0,0,0]),
Row(speed, [1,1,0,0,0,1,0,0,0,0,0,0]),
Row(speed, [1,1,0,0,0,0,1,0,0,0,0,0]),
Row(speed, [1,1,0,0,0,0,0,1,0,0,0,0]),
Row(speed, [1,1,0,0,0,0,0,0,1,0,0,0]),
Row(speed, [1,1,0,0,0,0,0,0,0,1,0,0]),
Row(speed, [1,1,0,0,0,0,0,0,0,0,1,0]),
Row(speed, [1,1,0,0,0,0,0,0,0,0,0,1]),
Row(speed, [0,1,1,0,0,0,0,0,0,0,0,0]),
Row(speed, [1,0,1,0,0,0,0,0,0,0,0,0]),
Row(speed, [1,1,0,0,0,0,0,0,0,0,0,0]),
Row(speed, [1,1,1,1,0,0,0,0,0,0,0,0]),
Row(speed, [1,1,1,0,1,0,0,0,0,0,0,0]),
Row(speed, [1,1,1,0,0,1,0,0,0,0,0,0]),
Row(speed, [1,1,1,0,0,0,1,0,0,0,0,0]),
Row(speed, [1,1,1,0,0,0,0,1,0,0,0,0]),
Row(speed, [1,1,1,0,0,0,0,0,1,0,0,0]),
Row(speed, [1,1,1,0,0,0,0,0,0,1,0,0]),
Row(speed, [1,1,1,0,0,0,0,0,0,0,1,0]),
Row(speed, [1,1,1,0,0,0,0,0,0,0,0,1]),
Row(speed, [0,1,1,1,0,0,0,0,0,0,0,0]),
Row(speed, [1,0,1,1,0,0,0,0,0,0,0,0]),
Row(speed, [1,1,0,1,0,0,0,0,0,0,0,0]),
Row(speed, [1,1,1,0,0,0,0,0,0,0,0,0]),
Row(speed, [1,1,1,1,1,0,0,0,0,0,0,0]),
Row(speed, [1,1,1,1,0,1,0,0,0,0,0,0]),
Row(speed, [1,1,1,1,0,0,1,0,0,0,0,0]),
Row(speed, [1,1,1,1,0,0,0,1,0,0,0,0]),
Row(speed, [1,1,1,1,0,0,0,0,1,0,0,0]),
Row(speed, [1,1,1,1,0,0,0,0,0,1,0,0]),
Row(speed, [1,1,1,1,0,0,0,0,0,0,1,0]),
Row(speed, [1,1,1,1,0,0,0,0,0,0,0,1]),
Row(speed, [0,1,1,1,1,0,0,0,0,0,0,0]),
Row(speed, [1,0,1,1,1,0,0,0,0,0,0,0]),
Row(speed, [1,1,0,1,1,0,0,0,0,0,0,0]),
Row(speed, [1,1,1,0,1,0,0,0,0,0,0,0]),
Row(speed, [1,1,1,1,0,0,0,0,0,0,0,0]),
Row(speed, [1,1,1,1,1,1,0,0,0,0,0,0]),
Row(speed, [1,1,1,1,1,0,1,0,0,0,0,0]),
Row(speed, [1,1,1,1,1,0,0,1,0,0,0,0]),
Row(speed, [1,1,1,1,1,0,0,0,1,0,0,0]),
Row(speed, [1,1,1,1,1,0,0,0,0,1,0,0]),
Row(speed, [1,1,1,1,1,0,0,0,0,0,1,0]),
Row(speed, [1,1,1,1,1,0,0,0,0,0,0,1]),
Row(speed, [0,1,1,1,1,1,0,0,0,0,0,0]),
Row(speed, [1,0,1,1,1,1,0,0,0,0,0,0]),
Row(speed, [1,1,0,1,1,1,0,0,0,0,0,0]),
Row(speed, [1,1,1,0,1,1,0,0,0,0,0,0]),
Row(speed, [1,1,1,1,0,1,0,0,0,0,0,0]),
Row(speed, [1,1,1,1,1,0,0,0,0,0,0,0]),
Row(speed, [1,1,1,1,1,1,1,0,0,0,0,0]),
Row(speed, [1,1,1,1,1,1,0,1,0,0,0,0]),
Row(speed, [1,1,1,1,1,1,0,0,1,0,0,0]),
Row(speed, [1,1,1,1,1,1,0,0,0,1,0,0]),
Row(speed, [1,1,1,1,1,1,0,0,0,0,1,0]),
Row(speed, [1,1,1,1,1,1,0,0,0,0,0,1]),
Row(speed, [0,1,1,1,1,1,1,0,0,0,0,0]),
Row(speed, [1,0,1,1,1,1,1,0,0,0,0,0]),
Row(speed, [1,1,0,1,1,1,1,0,0,0,0,0]),
Row(speed, [1,1,1,0,1,1,1,0,0,0,0,0]),
Row(speed, [1,1,1,1,0,1,1,0,0,0,0,0]),
Row(speed, [1,1,1,1,1,0,1,0,0,0,0,0]),
Row(speed, [1,1,1,1,1,1,0,0,0,0,0,0]),
Row(speed, [1,1,1,1,1,1,1,1,0,0,0,0]),
Row(speed, [1,1,1,1,1,1,1,0,1,0,0,0]),
Row(speed, [1,1,1,1,1,1,1,0,0,1,0,0]),
Row(speed, [1,1,1,1,1,1,1,0,0,0,1,0]),
Row(speed, [1,1,1,1,1,1,1,0,0,0,0,1]),
Row(speed, [0,1,1,1,1,1,1,1,0,0,0,0]),
Row(speed, [1,0,1,1,1,1,1,1,0,0,0,0]),
Row(speed, [1,1,0,1,1,1,1,1,0,0,0,0]),
Row(speed, [1,1,1,0,1,1,1,1,0,0,0,0]),
Row(speed, [1,1,1,1,0,1,1,1,0,0,0,0]),
Row(speed, [1,1,1,1,1,0,1,1,0,0,0,0]),
Row(speed, [1,1,1,1,1,1,0,1,0,0,0,0]),
Row(speed, [1,1,1,1,1,1,1,0,0,0,0,0]),
Row(speed, [1,1,1,1,1,1,1,1,1,0,0,0]),
Row(speed, [1,1,1,1,1,1,1,1,0,1,0,0]),
Row(speed, [1,1,1,1,1,1,1,1,0,0,1,0]),
Row(speed, [1,1,1,1,1,1,1,1,0,0,0,1]),
Row(speed, [0,1,1,1,1,1,1,1,1,0,0,0]),
Row(speed, [1,0,1,1,1,1,1,1,1,0,0,0]),
Row(speed, [1,1,0,1,1,1,1,1,1,0,0,0]),
Row(speed, [1,1,1,0,1,1,1,1,1,0,0,0]),
Row(speed, [1,1,1,1,0,1,1,1,1,0,0,0]),
Row(speed, [1,1,1,1,1,0,1,1,1,0,0,0]),
Row(speed, [1,1,1,1,1,1,0,1,1,0,0,0]),
Row(speed, [1,1,1,1,1,1,1,0,1,0,0,0]),
Row(speed, [1,1,1,1,1,1,1,1,0,0,0,0]),
Row(speed, [1,1,1,1,1,1,1,1,1,1,0,0]),
Row(speed, [1,1,1,1,1,1,1,1,1,0,1,0]),
Row(speed, [1,1,1,1,1,1,1,1,1,0,0,1]),
Row(speed, [0,1,1,1,1,1,1,1,1,1,0,0]),
Row(speed, [1,0,1,1,1,1,1,1,1,1,0,0]),
Row(speed, [1,1,0,1,1,1,1,1,1,1,0,0]),
Row(speed, [1,1,1,0,1,1,1,1,1,1,0,0]),
Row(speed, [1,1,1,1,0,1,1,1,1,1,0,0]),
Row(speed, [1,1,1,1,1,0,1,1,1,1,0,0]),
Row(speed, [1,1,1,1,1,1,0,1,1,1,0,0]),
Row(speed, [1,1,1,1,1,1,1,0,1,1,0,0]),
Row(speed, [1,1,1,1,1,1,1,1,0,1,0,0]),
Row(speed, [1,1,1,1,1,1,1,1,1,0,0,0]),
Row(speed, [1,1,1,1,1,1,1,1,1,1,1,0]),
Row(speed, [1,1,1,1,1,1,1,1,1,1,0,1]),
Row(speed, [0,1,1,1,1,1,1,1,1,1,1,0]),
Row(speed, [1,0,1,1,1,1,1,1,1,1,1,0]),
Row(speed, [1,1,0,1,1,1,1,1,1,1,1,0]),
Row(speed, [1,1,1,0,1,1,1,1,1,1,1,0]),
Row(speed, [1,1,1,1,0,1,1,1,1,1,1,0]),
Row(speed, [1,1,1,1,1,0,1,1,1,1,1,0]),
Row(speed, [1,1,1,1,1,1,0,1,1,1,1,0]),
Row(speed, [1,1,1,1,1,1,1,0,1,1,1,0]),
Row(speed, [1,1,1,1,1,1,1,1,0,1,1,0]),
Row(speed, [1,1,1,1,1,1,1,1,1,0,1,0]),
Row(speed, [1,1,1,1,1,1,1,1,1,1,0,0]),
Row(speed, [1,1,1,1,1,1,1,1,1,1,1,1]),
Row(speed, [0,1,1,1,1,1,1,1,1,1,1,1]),
Row(speed, [1,0,1,1,1,1,1,1,1,1,1,1]),
Row(speed, [1,1,0,1,1,1,1,1,1,1,1,1]),
Row(speed, [1,1,1,0,1,1,1,1,1,1,1,1]),
Row(speed, [1,1,1,1,0,1,1,1,1,1,1,1]),
Row(speed, [1,1,1,1,1,0,1,1,1,1,1,1]),
Row(speed, [1,1,1,1,1,1,0,1,1,1,1,1]),
Row(speed, [1,1,1,1,1,1,1,0,1,1,1,1]),
Row(speed, [1,1,1,1,1,1,1,1,0,1,1,1]),
Row(speed, [1,1,1,1,1,1,1,1,1,0,1,1]),
Row(speed, [1,1,1,1,1,1,1,1,1,1,0,1]),
Row(speed, [1,1,1,1,1,1,1,1,1,1,1,0]),
]
)
def __init__(self): kitt = Kitt() Sequence.__init__(self, kitt.getRows())
