1
00:00:25,599 --> 00:00:28,230

okay everyone let's get started  uh welcome back um to  uh theory of computation lecture number  six  um  so  we have been  um  looking at  a number of different models of  computation  and um  last lecture actually was an important  one for us because we  shifted gears um from our restricted  models um  finite automata and pushdown automata  and their associated  um  generative models regular expressions  and  context-free grammars  to turing machines which are going to be  the model that we're going to which is  the model that we're going to be  sticking with for the rest of the  semester because that's going to be our  model as we're going to argue today for  a general purpose computer  so in the sense everything we've been  doing up till now has or up until that  point has been kind of a warm up  but it's been um nevertheless has gotten  the chance for us to introduce some  important concepts  uh that are um used in practice and also  will serve as good examples for us  moving forward and also just to get our  you know  get kind of  um  uh you know in a sense on the same page  uh so  what we're going to be doing today is  looking at the turing machine model in a  little bit more depth  one can  define turing machines in all sorts of  different ways  but it's going to turn out not to matter  because all of those different ways are  going to be equivalent to one another  and so  we are going to  stick with the very simplest version the  one we've already defined namely this uh  the simple one tape turning machine  but um  we're going to  basically justify that by looking at  some of these other models and proving  equivalent so we can we'll look  at multi-tape turing machines  we'll look at non-deterministic turing  machines  and we'll look at another model which is  slightly different but it's still based  on turing machines called an enumerator  and we'll show that those all in the end  um  give you the same class of languages and  so in that sense they're all equivalent  to one another  and that's going to be served as a kind  of a  motivator um kind of to in a sense  recapitulate some of the history of the  subject  um and going to lead to our um  discussion of what's called the church  turing thesis so we will uh  i'll get to that in due course  and we'll also talk about uh some  notation for  um  languages and  notations for turing machines and for  encoding objects to feed into turing  machines as input but we'll get to that  shortly as well  uh  so let's move on then we will  next  go into uh  a little review of what we did with for  touring machines and um just want to  make sure we're all together on that the  very important concept for us this term  so the turing machine model looks like  there's going to be this finite control  there's a tape with a head that can read  and write on the tape can move in both  directions the tape is infinite to the  to one side and so on as i mentioned  last time  the output of the turing machine is  either going to be a halt  accepting or rejecting or loop that the  machine may run forever with three  possible outcomes for any particular  input the machine may accept that input  by entering queue accept may halt and  reject by entering q reject and it might  reject by looping which means it just  never gets to the accept state or the uh  it never gets to any holding state it  just goes forever but we still consider  that to be rejecting the input just  it's rejecting by looping  okay um  and as we defined last time a language  is touring recognizable as or as we  typically write t recognizable if it's  the language of some turing machine  the collection of accepted strings from  that turing machine again just as before  machine may accept  zero strings one string many strings but  it always has one language  the collection of all accepted strings  um  now if you have a decider which is a  machine that never loops which always  holds on every input  then we say its language is a decidable  language  so we'll say language is turning  decidable or simply decidable  if it's the language of some  decider which is a turing machine that  always holds on all inputs  so we have those two distinct notions  turning recognizable languages and  turing decidable languages  um  now as we're going to argue this  lecture turing machines are going to be  our model of a general general purpose  computer so that's the way we're going  to think of computers as touring  machines um  and  why turing machines why didn't we pick  something else  well the fact is it doesn't matter and  that's going to be the point of this  lecture  all reasonable models of general purpose  computation  um you know unrestricted um  computation in the sense of not limited  memory um are all  going to be are all  have been shown um all the models that  we've ever encountered have also been  shown to be equivalent to one another um  and so you you're free to pick anyone  you like  and so for this course we're going to  pick turing machines because they're  very simple to argue about  mathematically and also they have a  sort of a some element of familiarity  in that you know they're they they feel  like um you know you well they um  they're more familiar than some of the  other models that have been proposed  that are out there um you know such as  you know rewriting systems lambda  calculus and so on because turing  machines feel like a primitive kind of  computer and in that sense they have a  certain familiarity  okay um so let's start talking about  variations on the turing machine model  and we're going to argue that it doesn't  matter it doesn't make any difference um  and then whether this is going to be  kind of a precursor to a discussion of a  bit of the history of the subject that  we'll go and get to in the second half  of the lecture  so um  a multi-tape turing machine is a turing  machine as you might imagine that has  more than one well it has one or  possibly more tapes and so a single tape  turning machine would be a special  version of a multi-tape turing machine  that's okay  but you might have more than one tape um  as i've shown in this diagram  now uh  how do we actually use a multi-tape  turing machine well you present the in  and we're going to see these coming up  for convenience sometimes it's it's nice  to be working with multiple tapes so  we're going to see these later on in the  semester a couple of times as well but  for now um  you know we'll we're setting the model  up so that  the input is going to be presented on a  special input tape um so that's where  the input appears and it's going to be  followed by blanks just as we had before  and now we have these potentially other  tapes possibly other tapes which are we  call them work tapes where the machine  can  write other stuff as it wishes and those  tapes are going to be initially blank  so just all blanks on them  all of the tapes are going to be read  and write so you can write on the input  tape obviously you can read on from the  input tape and you can read and write on  the other tapes as well  um  so what we want to first establish that  by having these additional tapes  you don't get additional power for the  machine in the sense that you're not  going to have  you won't have additional  languages that you can recognize by  virtue of having these additional tapes  i mean you could imagine that having  more tapes will allow you to do more  things  you know for example if you have a push  down automaton  with two stacks  you can do more languages than you can  with one stack  so it's conceivable that by having more  tapes you can do more languages than you  could with one with one tape  but in fact that's not the case  what one tape is as good as having many  tapes uh and we're going to prove that  you know we're going to  quickly sketch through the proof of that  fact um  so uh the theorem is that turing machine  a language is touring recognizable and  when we say turing recognizable for now  we mean just with one tape um so  that's the way we've defined it so a  language is turing recognizable if and  only if some multi-tape turing machine  recognizes that language  okay so really that another way of  saying that is  if you have a language that you can do  with a single tape you can do it with a  multi-tape and vice versa  so one direction that is immediate  because a single tape turing machine is  already a multi-tape turing machine that  just happens to have one tape  uh so the forward direction of that is  is um  there's nothing to say  that's just immediately true  um  but if we want to prove the reverse then  we're gonna have to do some work  and the work is going to be showing how  do you convert a multi-tape turing  machine to a single tape turing machine  so if we have something that's  recognized by a multi-tape turing  machine it's still turing recognizable  what that means is you can do it with a  single tape turning machine so we have  to show how to do the conversion  and i'm kind of you know i'll i'll i'll  show you that i think in a convincing  way but we know without getting into too  much detail  so here is an image of a multi-tape  turing machine  in during the course of its input so it  has already we've already started it off  um you know initially it starts off with  the um other tapes the work tapes being  all blank but now it's processed for a  while  and you know the head on the input tape  is now has moved off from its starting  position at the left end it's somewhere  in the middle it's written stuff on the  other  tapes and what we want to do is show how  to represent  that same information  on a single tape turing machine  in a way which allows the single tape  turing machine  to carry out  the steps of the multi-tape turing  machine but using only its single tape  by virtue of some kind of a data  structure which allows for the  simulation to cut to go  forward okay  so how is the simula the single tape  turning machine going to be simulating  going to be carrying out this the the  same effect  of having these multiple tapes on the  multi-tape turing machine  so here's a picture of the single tape  turning machine it just has one tape  by the way i should mention that all of  the tapes are infinite to the right um  in the multi-tape touring machine just  as we had for the single tape turning  machine  and now uh with this uh single tape  turning machine it's going to represent  the information that was on  that's present on these multiple tapes  but using only the single tape and the  way i'm choosing to do that is going to  be particularly simple  i'm going to just divide up so here i'm  saying it in words uh it's going to  simulate him by storing the contents of  the multi-tape  on the single tape in separate blocks  so i'm basically going to divide up the  single tape uh turing machines tape  into separate regions  where each one of those regions is going  to have the information that was on one  of the tapes  in the um multitape machine  so for example here is on the first tape  it's got aabba  well that's going to appear here in that  first block on the single tape turing  machine  okay  sort of seeing it float down to suggest  that it's coming from this multi-tape  turing machine but that's really been  developed by the simulation that the  single tape turning machine has  obviously the single tape turning  machine doesn't have any direct access  to the multi-tape machine but it's going  to be simulating  so  this is how we're showing the data is  being stored on the single tape machines  tape so in the second block it's going  to have the contents of the second uh  tape of the turing multi-tape machine  and the uh the final  um  uh region of the single  tapes this is the final block  so-called of the single tapes tape is  going to have single tape machines tape  it's going to have their the rest of the  um  the contents of the last  tape of of m  and then it's going to be followed by  the same infinitely many blanks that  each of these um  tapes  are going to have  following the portion that  they may have written during the course  of their computation  okay  so that's what the single tape turing  machine's tape is going to look like  during the course of its computation  it's going to have the informations  represented in these blocks  capturing all of the information that  the multi-tape turing machine has in a  perhaps somewhat less convenient way  because the multi-tape turing machine  you know we didn't really make this  explicit and in part because it doesn't  really matter we didn't say exactly how  the multi-tape turning machine operates  what i have in mind is that the  multi-tape turning machine  can read and move all of its heads  from all of its heads in one step  so in a single step of the multi-tape  machine it can it can obtain the  information that's underneath each of  its heads  feed that into its transition function  and then together with the state of the  multi-tape machine decide how to change  each of those locations and then how to  move each one of those heads  so it's kind of operating on all of the  tapes in parallel  okay so now uh how how does the actual  steps of the simulation of the single  tape you know  by the single tape um machine uh how  does it go  so first of all  besides  storing  the contents  of each of the tapes in in s's single  tape  there's some additional information that  it needs to record namely  um m  has  a head  for each one of its tapes  but s has just a single head  and each of m's heads could be in some  different location you know in this case  as i've shown it  on the first tape its head is in  location three on the second tape it's  in location two on the third tape it's a  location on the last tape is in location  one  uh  so where were we we were simulating  the multi-tape turing machine with the  single tape turing machine  and we had to keep track of where the  heads are  and so we're going to do that by writing  the locations on those blocks  okay so  we're going to have  a special  dot  as i've shown here to represent the  location of the head in that very first  block so the heads on the b i'm going to  dot the b and i'm going to do the same  thing  for the locations of the others  um heads  and how am i getting that effect well  we've had seen something like that  before where we just expand the tape  alphabet of s  to allow for  these dotted symbols as well as the uh  irregular symbols we also have expanded  it to include those delimiter markers  that separate the blocks from one one  another which i'm writing as a pound  sign um so we can just get that effect  simply by expanding the tape alphabet of  s  okay a few more details of s that are  just worth looking at just to make sure  we're kind of all understanding what's  happening  so for every time m takes one step  s has actually a lot of work to do  because one step of m it can move all of  those  read and move all of those heads all at  one shot  s has to scan  the entire tape  to see what those what's underneath  those in effect virtual heads which are  the locations of the dotted symbols it  has to see what's underneath each one of  those heads  to see how to update the transition you  know update its state to the next state  and then it has to scan again  to  change the location  change the contents of those of those  tape locations and also to move the head  left or right by moving the effectively  now moving the dot left or right so  that's pretty straightforward uh  uh  there's one  complication that can occur however um  which is that what happens if  um  on one of the tapes let's say  m  starts using writing more content  then you have room in that block  uh to store that information  you know so if the m like moves it has  one zero one suppose m you know after a  few steps moves his head into the  originally blank portion of the tape and  writes another symbol there we have to  put that symbol somewhere because we  have to record all that information and  the block is like full  so what do we do well in that case s  goes to like a little interrupt routine  and  uh  moves shifts all of the symbols um to  the right one place  to make open up  um a location here where it can write a  new symbol for  uh  carrying continuing the simulation  so with that in mind  uh  s can maintain the current contents of  each of m's tapes  and um let me just note that here shift  to add room is needed  and that's all that happens in this  during the course of the simulation okay  and if of course if  s  as it's simulating m  observes that m comes to an accept or  reject state  uh s should do the same  okay so that that's our description of  how the simulation of the the single  tape simulation of the multi-tape  machine works  right  okay let's turn to non-deterministic  machines  now  if you remember for fine art and i hope  you do for finite automata we had  equivalence between non-deterministic  and deterministic  um uh finite automata for pushdown  automata we did not have equivalence we  didn't prove that but we just stated it  as a fact there are certain languages  that you can do with non-deterministic  push-down automata which is the model we  typically hold as our standard so the  some things you can do with  non-deterministic push-down automata  that you cannot do with deterministic  push-down automatic um you really need  the non-determinism they're not not  equivalent  for turing machines  we're going to get the equivalents back  so we'll show that anything you can do  with a non-deterministic turing machine  in terms of language recognition you can  also do with a deterministic turing  machine so remember we kind of mentioned  this briefly last time  the  non-deterministic turing machine looks  exactly like a deterministic turing  machine except for the transition  function where we have this power set  which allows for  multiple different outcomes at a given  step instead of just a single outcome  that you would have in a deterministic  machine so we represent that with this  power set  here um  applied to the possibilities that um the  machine would have as the  next uh next step  okay  um so we're now going to prove a very  similar theorem that a is recognizable  by an ordinary  one tape turing machine that kind of  goes without saying so that's how we  defined it a is turning recognizable if  and only if some non-deterministic  turing machine recognizes that language  okay  um again remember we're using  non-determinism in the way we always do  namely that  a non-deterministic machine accepts if  there is some branch or some thread if  it's not a computation ends up at an  except  other branches might go forever or might  uh reject part with part of the way  through  but acceptance always overrules them if  any branch accepts that's how  non-determinism works for us  okay so now  the forward direction of this is again  just like before immediate because a  deterministic turing machine is a  special kind of not a deterministic  turing machine which never branches um  not deterministically on any of its  steps  so that forward direction is immediate  the backwards definition is where we're  going to have to do some work  converting our non-deterministic turing  machine to a deterministic machine and  we'll do so as follows we'll take a  non-deterministic turing machine  uh here's our picture and we're going to  now  um  imagine its computation in terms of a  tree  um  and uh so here is the non-deterministic  computation tree for n on some input w  so n for nondeterministic uh  here is the tree um somewhere down here  it might end up accepting and as i  mentioned that is going to be uh  defining the overall computation to be  accepting if there is some place here  that's accepting  and the only way it can be non-accepting  computation if there is no  except that occurs anywhere  and somehow if you're going to convert  this non-deterministic machine to a  deterministic machine  the deterministic machine is going to  have to get that same effect  though it only has determinant you know  it doesn't have the non-determinism so  how does it manage that  well it's really going to be carrying  out the simulation  you know  kind of as you would imagine doing it  yourself if you were told you had to  simulate a non-deterministic turing  machine  which is you're going to search that  tree of possibilities looking to see if  you find and accept if you do then you  accept if you if you don't well maybe  you'll go forever or maybe you'll manage  to search the entire tree and then you  will  say  no i accept uh no i reject um  okay so let's just see again what the  data structure of that deterministic  machine's tape is going to look like  um  so the way this simulation is going to  carry out and and you know you could  program this in a host of different ways  and in fact the textbook has a somewhat  different simulation but i think this  one here is  uh lends itself a little bit better um  and maybe it's a little simpler  for description um in this in this  setting uh  but there's lots of different ways of  improving these things so we're going to  m is going to simulate n  kind of a little bit similar to the  previous uh simulation it's going to  break the tape up into blocks  and it's going to now store in each  block  a different thread  at a particular point in time  of n's computation  so you imagine where  m is going to be simulating and  sort of  um  doing the same parallelism  but  doing the  getting the effect of the parallelism  not through the non-determinism but by  maintaining copies of each of the  threads  on its tape and then updating them  accordingly  so the idea is i think not not too  complicated um  so let's just see some of the some of  the details here so here here populating  those blocks with the contents of um  ends tape on different threads at a so  you know maybe that corresponds to um  ends tape you know after the fifth step  of n  um you know on each of those threads you  have these three possibilities let's say  written down as three different blocks  um now uh  remember in the case of the multi-tape  simulation we needed to record some  extra information  extra information in particular we had  to record the location of the heads  by using those dotted symbols we're  going to do that again because each one  of these threads might have their head  in some different location but we're  going to have to do more  but actually so let's do one other one  thing at a time we're going to store the  head location  here they are all written down  as dotted symbols  but now there's something that goes  further because in a multi-tape case  there was one global state  that the multitape machine was in of  course at any given time it's just one  has one finite control it's in one state  um  and  uh but but but in the case of the  non-deterministic machine that we're  simulating now  each thread can be in a different state  um  so whereas before we could keep track of  the multitapes during  the multi-tape machine state inside the  single tape machines finite control  now there could be many many different  states to keep track of  so you won't be able to store that in a  finite control anymore because there  could be some huge number of threads  active at any given stage and some of  them can be one state others can be in  different state and you know how do you  keep track of all that so we're going to  have to use the tape  we're going to actually write down which  state a given thread is in on that block  and we'll do that i'll show it like this  so writing down the state of each cert  in the block  by writing down symbols which correspond  to those uh states  so we're actually in a sense writing the  states down right on top of block using  symbols that correspond to those states  so again we're doing getting that effect  by increasing the tape alphabet  of m  to include  um  symbols that correspond to each of its  states  i'm going to write those symbols down so  here's the symbol for state q8 that says  well one of th that very first thread of  n's computation is in state q8 it's in  this third position of its t um on its  tape uh the head is on the third  position there and the tape contents is  aaba  that's how we represent that thread of  the computation  um including the state  okay  now  um  so am is going to carry out that step by  step  maintaining that information on its tape  there again  similar to before there might be some  special situations arising so for  example n is not non-deterministic so a  thread might fork  into uh two threads  what do we do then um well sort of the  you know the reasonable thing if there's  a forking thread  m then copies that block  makes two copies of the block  to correspond to the two or however many  copies you need to correspond to the  possibilities that um that thread is  branching into so you want to represent  them all on different blocks of m's tape  all right um and then if m ever finds  out that on one of the threads it's  entering the accept state  it can just shut down the whole  computation at that point and say accept  okay so  perhaps a little elaborate but i think  conceptually hopefully  um  not too bad um  now uh  uh let's move on then to talk about uh  somewhat of a different uh  looking  well sort of a different model in a way  um  uh which has some historical  significance and sometimes it's a  helpful way to look at uh  touring recognizability and you and  incidentally you have a homework problem  uh  on this um model  called an enumerator or turing  enumerator  so  uh here  it's going to operate somewhat  differently  first of all we're going to enhance the  turing machine model it's going to have  just a single tape but it's going to  also have a printer  okay so we're now  adding in  this new device into the turing machine  called the printer  and um  the  turing machine has  tape as before except  we never provide any input to the  machine  the tape always starts out fully blank  it's only used for reading and writing  uh only used for for like the keeping tr  for uh for for work  uh it's not where you present the input  so how do you talk about the language of  the machine  well what the way you work this machine  is you take this enumerator  uh it's a deterministic determination  with a printer as i mentioned you start  it off in blank tape and it you know  runs and runs and runs and periodically  it can print  a string under some sort of program  control which i'm not going to spell out  for you but you can imagine you might  have to define the machine in such a way  that when it goes into a certain print  state so we're not going to set that all  up  then whatever string is in a certain  region of the tape maybe from this the  start point up into the head location  that gets printed out  on the printer  and then it can print out other strings  in due course and so  periodically you think of this printer  as printing out a string um  under the control of the uh  the turing machine enumerator  um  and so  these print strings these strings that  could print out w1 w2 they appear  and  the machine might possibly go forever  and print infinitely many strings  or it might  go forever and only print finally many  strings or it might stop after a while  by entering a holding state accepting or  rejecting is irrelevant but enters a  halting state and then  the number the strings that it's print  out the finite really many strings it  printed out are just that's the output  of the machine  now the language of the machine is the  collection of all strings that it ever  prints out  so we're defining language in a somewhat  different way here it's not the strings  that it accepts it's a string that it  prints  so we think of this machine almost a  little bit analogous to like the regular  expression or the grammar in the sense  that it's a generative model it produces  the language rather than accepts the  strings in the language  this is not really a recognizer it's a  generator and the language of the  machine as i'm writing over here for an  enumerator here we say that it's  language is the collection of strings  that it prints  okay  now we will show that a language is  touring recognizable in the previous  sense uh you know  recognized by some ordinary turing  machine  if and only if it's the language of  summer numerator  and actually this is kind of a little  bit of an interesting proof uh you have  to do some work it's an if and only if  now neither direction is immediate  you're gonna have to do some work uh in  both directions one direction is a  little harder and the other will start  off with the easier direction let's say  we have an enumerator  i hope you hopefully you got this  concept of this turing machine which  periodically prints strings  when you've started it off on the empty  tape  um  uh so now what i'm going to construct  for you  is that turing machine  recognizer  defined from the enumerator so this  recognizer is going to be simulating the  enumerator  um so it's  basically the recognizer going to launch  the enumerator  it's going to start off simulating it  um  now if you want if it's convenient we we  can use several tapes we can use one  tape to simulate the recognizer and you  have other tapes available for  convenience if you want because we  already showed multi-tape and single  tape are equivalent so if you want to  think of m as having multiple types it's  not going to really be that important  relevant to my conversation um  but you're going to simulate e starting  on the blank input as you're supposed to  and then you're going to see whenever e  prints an x  you're going to see if x is the same as  the input to the recognizer  you you get the idea so we have a  recognizer it has an input string maybe  like  1 1 0 1.  and i want to know i want to accept that  string if it's one of the strings that  the enumerator e prints out  because that's what the recognizer do  it's supposed to accept all the strings  that the enumerator prints out so i got  this one one zero one what do i do i  launch i fire up that numerator i get it  going and i start watching the strings  it prints out  comparing them with my input string one  one zero one  if i ever see it print out a one one  zero one  great i i know i can accept because i  know it's in the enumerator's language  but if i compare and compare and compare  i never see  uh the enumerator ever printing out uh  my input string 1101  well i just keep simulating if e holds  well then i can hold and reject  if i've never seen that string coming  out as an output  if e doesn't hold well i'm just not  going to hold either i'm going to go  forever but then i'm going to be  rejecting my input by looping  okay so that's the proof  of converting  in this uh backward direction which is  the easier direction now let's look at  the forward direction which has a  certain wrinkle that in it that we're  going to have to get to  so now we're going to be building our  enumerator to simulate our recognizer  okay and the way we'll do that  is  the enumerator has to print out  all of the strings that the recognizer  would ever accept  so you kind of do the obvious thing  you're going to  take the numerator is going to start  simulating  the recognizer m on all possible strings  sort of you know one by one using doing  them in parallel taking turns you never  know you know we um maybe we didn't make  this so explicit but you don't have to  you know you can sort of time share  among several different possibilities  you run you know it's sort of like  having different blocks uh for the  machine diff you're gonna run  um  uh the enumerator is gonna run the  recognizer on uh  it's you know well let's just say it  does it sequentially runs it on the  empty string it runs it on the string  zero it runs it on the string one runs  it on the string zero zero these are all  the possible strings in sigma star you  you run the on all of them  and  whenever  the enumerator  uh  oh  this is wrong  whenever  um  so whenever  m accepts  then print  i can't  write very well  print  w  um  w i oops  okay  so let me just say it in words  you want to simulate emma on each wi  whenever you notice  m accepting wi you just print out w i  um  because you want to print out  all of the strings that m accepts  now what have the problem there is a  problem here so uh hopefully you're not  confused by this typo  um uh doing it sequentially like i just  described doesn't quite work so let me  just back that up here doing it  sequentially doesn't quite work  because emma might get stuck  looping on one of the wi's like you know  maybe when i feed w  zero into w  into m  m goes forever  because m is rejecting zero by looping  but maybe it also accepts one this next  string in the list the string one i'll  never get to one by just feeding the  strings into m one by one like this  what i really have to do is run all of  the strings in m in parallel  and the way i'm going to indicate that  is i'm going to simulate m on w1 to wi  for i steps for each possible i so i'm  going to run m  on  more and more strings for more and more  steps  okay until and every time i notice an m  accepts something i print it out  um  so i will fix this in the uh version of  the uh  file that i  um  publish on the website so if you're  still not getting it you can look there  um  uh but just to make things even worse i  have a check in which is going to  be about this one little point here  so i got a question where do we get the  wi strings the wi strings are simply the  list of all strings in sigma star  so we can under program control  we can  make m  go through every possible string like if  you had an odometer you're going to  first get to the empty string then you  go to the string zero then the string  one you can write a program which is  going to do that  and the turing machine can similarly  write write code to do that  to get to each possible string one by  one and then that's what the  enumerator is doing it's obtaining each  of those strings and then feeding them  into m  seeing what m does  what i'm trying to get at here is that  it's not good to feed them in  run m to completion on each one before  going to the next one you really kind of  have to do them all in parallel  uh  to avoid the problem of getting stuck on  one string that m is looping on  um  all right  so uh this is relevant to your homework  in fact  if i convert m to an enumerator  um  in this way  does that enumerator always print the  strings out in string order  string order is this order here  um  having them uh the having the shorter  strings coming up before the longer  strings and within strings of a certain  length just doing them in lexicographic  order  um  uh so  um  hopefully you follow that but since you  you know these are not  uh correctness that doesn't matter uh  for us let me launch that poll let's  i'll see how confused how random the  answer is here uh  so a fair amount of confusion if you're  confused obviously you're in good  company there um  okay about to shut this down  uh five seconds to go  okay ending in now  uh  all right so the correct answer as the  majority of you did yet is in fact that  the order is not going to be  uh respected here when he  prints things out  it might print out some things later in  the order before earlier things in the  order what's going to control how um  when he is going to print it out it  really is if m  accepts some strings more quickly in  fewer steps  then e might end up printing out that  string earlier in the list  um then some other string that might be  a shorter string  um because  uh the order in which e is go going to  now identify  that m is ex is accepting those strings  is is the um depends upon the speed with  which m is do actually doing the  accepting  so you have to um this is relevant to  one of your homeworks because if  uh what you're going to be asked to show  is that if you start with a decidable  language  instead of a recognizable language  then you can make it then you can make  an enumerator  which always prints out things in order  in the string order  okay  and um  and vice versa so if you have and if you  have a string which uh the numerator  which prints the things out in string  order then the language is it's  decidable  okay so need to think about that  one direction is a fairly simple  modification of what i just showed  the other direction is a little bit more  work um  so uh anyway why don't we uh  uh take our little coffee break here  uh  okay so that's an interesting question  so one question is if there's because  you know sigma has an infinite sigma  star is infinite  um  uh if i understand this question quite  correctly which says you know it's an  infinite number of strings here  uh how how does the machine even get  started because it has to go through and  enumerate all of it no it's not first  writing down all of those strings  um  because yeah you can write down and it  you can't do this infinite step of  writing all the strings what i had in  mind is you're going to take each string  in turn  first you're going to take the first  string on the list of sigma star  run m uh on that string and then the  next string and sigma star run it on  that string and so on string after  string  and so you're never going to have  infinitely many strings to deal with  it's just going to be more and more  strings as you're going along  and um  the question i was trying to get at is  whether you're going to  run each one to complete completion  before you get to the next one or you're  going to kind of try to do them all in  parallel which is what you need to do  for to prove this uh this there  um  won't there be infinitely many wi yes so  there are a similar question infinitely  many wi there are infinitely many wi but  you know it's just an infinite loop that  we're in one by one you're taking care  of  more and more  uh wi as you're going um  uh  let's see here  yes so e is another question is are we  running it all on all the strings in  parallel yes we are running things all  on running all of the strings in  parallel but  you know it's uh running them in  parallel but um these are  um  uh  you know it's we're not defining a  parallel turing machine it's running  them in parallel using time sharing  you know it runs a little bit in this  block runs a little bit and that block  and then another block and sort of  shifts around and sort of does a few  steps of each and that's how it's  getting the effect of the parallelism  um  okay  um  question is  would the enumerator essentially have a  print tape and a work tape yeah you  could think of it as having a print tape  you know however you want to formalize  it it's it it  doesn't matter i mean i'm being a little  whimsical but attaching it to a picture  of a  a real printer but yeah it's just you  think conceptually you can have a print  tape however you like to think about  it's fine um  um  how can we directly say that without  knowing the program of the printer  uh  the printer is just there's no  we don't have to get into the code the  structure of the printer the printer is  just  uh something where you say print a  string and it print and a string comes  out  that's all we know about the printer and  that's all we need to know  um  so there's no program for the printer uh  sorry if i  not understand your question your  question but the question literally says  how can we say that without knowing the  program of the printer  so if the machine is decidable why does  it have to print all strings in order  for example if one string is shorter and  can it be decided later  we well yeah if the  uh the reason why we want  so the question is if the machine is  decidable why does it have to print all  strings in order  uh because that's what i'm asking you to  do in the problem  that's what if you read the problem i  think it's number five  on the pset that's what i'm asking you  to do that's why you have to print it in  order  otherwise you wouldn't have to worry  about printing an order just because i'm  asking you to  okay  so i think we're at a time let's uh  let us move back into um  our our material  um  okay  second half church touring thesis  um  so church uh  this is going back into the bit of the  history of the subject back to the 1930s  um  back then people were uh interested in  formulating the notion of what do we  mean by algorithm they don't even call  it algorithm um and those they they call  it some people call it procedures some  people call it effective procedure  um some people called it  effective calculation um but you know  people had in their minds mathematicians  have been dealing for centuries  thousands of years with procedures for  doing things that's a very natural thing  and  mathematical logicians in particular  church and turing are touring somebody  you  surely obviously have heard of church  maybe not um  a  church was turing's thesis advisor in  fact um and  they both were coming out of the  mathematical logic field of mathematics  and uh using trying to use mathematical  logic to formalize this intuitive notion  of what we have had for for centuries  about what what a procedure is what is  it what is what is an algorithm  and um  back in those days you know they came up  with different ways of formalizing it um  uh so you know here we had this notion  of algorithm which is kind of intuitive  concept  touring proposed turing machine as a way  of capturing that informal way in  mathematically precise way  other people came up with other ways of  doing it  and back then it wasn't obvious that all  of those different formulations would  end up giving you equivalent concepts  equivalent notions um  and in fact they proved in fairly  elaborate detail  that the different methods that people  came up with it was a lambda calculus  there was uh rewriting systems there  were several methods that were proposed  for formalizing um this notion and they  all turned out to be equivalent to one  another  um  in today  that seems kind of obvious  even though i went to some effort to  prove that just to give you a feeling  for how those things uh  go  you know that you know if you have  programs if you have pascal and java say  and thinking about what you can do  mathematically in those i'm not talking  about their ability to interface with  you know windows and so on but just the  mathematical capabilities  the capability of doing mathematical  calculations or functions with a pascal  program or a java program  you know it would be absurd to think  there's some program that you can write  in java that you can't write in pascal  um  or python  and the reason is we know you can  compile python into java and you can  compile java back into python that tells  you that the two systems of two  programming languages are equivalent in  power um that wasn't obvious that from  the get-go to these folks so they um  observed that uh all of the different  efforts they came at formalizing  algorithm all were equivalent to one  another  that was that that was a kind of a  breakthrough moment when they realized  that they're all  that  not all the ways that they've come up  with and once they got the idea they  realized all reasonable ways of doing it  always going to be equivalent  um and so that suggested that  they've really captured this notion of  algorithm by any one of those methods  say a turing machine  and that's what they took you can't  prove that because algorithms are an  intuitive notion  but the fact that we're able to capture  that in a formal way that's what we call  today the church touring thesis  okay um  so um  that is uh  um  so any of these methods uh  capture the notion of algorithm as we  described  and that has had a big impact on  mathematics uh  so you know  i just want to  just give me one second here  all right here's a check-in on this one  so you know alan turing so here are some  facts which may or may not be true about  elementary  um so uh  now you get to pick all the ones that  apply um based on your knowledge  obviously this is not uh  something this is more for fun but um or  historical interest um  but here is uh  let's launch that poll see what how much  you know about  uh mr turing um  check all that apply  okay almost done  please  let's wrap it up  i think that's everybody  okay  two seconds please get credit for doing  this and polling in fact it's kind of  interesting here  uh  um  [Music]  uh he  you all do know that he was a code  breaker uh he was a  worked uh  in fact did was part of a team i think  led the team which broke the german code  um during world war ii  you know the turing test is a famous uh  thing for how do you characterize when  you have an intelligent machine um so he  definitely worked in ai  he worked in biology as well um he has a  paper that less well known to computer  to scientists but if you look him up um  on wikipedia where i get all my  information  uh  uh he actually and i knew this anyway uh  he has a very famous paper influential  paper  on how um  for example spots arise on um on tiger  on leopards and stripes on tigers and so  on um he gave a kind of mathematical  model for that which actually proves  actually is uh quite does capture things  in an accurate way uh as was shown  subsequent to that  uh was imprisoned for being gay in fact  as far as i know from his history he was  not imprisoned for being gay um he was  convicted  of being gay um and he was given a  choice to go to prison or to take  chemicals  to cure  him from being gay  and he opted not to go to prison and  take the chemicals  uh and uh sadly he committed suicide  two years after that  so um he was um  treated very treated very badly by uh  british society and british government  uh despite having the the great the work  that he had done  um  and um  you might think that he has been honored  by appearing on a british banknote  that's also not true um uh but the good  news is he's not uh currently on a  british banknote but he's going to be  on a british bank note starting next  year um  so that is uh  um  so that's uh  you know along with um winston churchill  and a number of other notable brits he's  going to be on the 50 pound banknote  okay um  so let us continue um  so as i mentioned uh the church thesis  is important for mathematics um and it  has to do with these hilbert problems i  don't know how many of you have  encountered that david hilbert was  widely considered to be the  perhaps the greatest mathematician of  his day  um  and um you know every four years  mathematicians get together for an  international congress called the  international congress mathematicians  it was you know email that's been going  on for over 100 years and he was invited  to the 1900  uh meeting to give a talk about anything  he wanted and what he decided to do in  during that presentation is give it is  present 23  uh  problems  that would be a challenge for  mathematicians for the coming century  um and um  uh  you know i we're running a little short  on time so i'm not going to go into them  some of these will talk about later uh  but the tenth problem here is about  algorithms  the tenth problem on hilbert's list  of called called hilbert's tenth problem  is a problem about algorithms and it  says given algorithm for solving what  are called diaphantine equations  um he didn't call it an algorithm you  could call it some uh  you know finite procedure or something  like that  but you know you what are the  diaphantine equations i'm glad you asked  uh  diaphantine equations  uh what are they well they're very  simple they're just polynomial equations  like  you know does this polynomial equal some  constant for example um but where you're  looking for the solutions  you know the polynomials are variables  you're looking for the solutions but  you're only allowing those solutions to  be integers  so here's an example um  so here i give you this polynomial  um here i'm setting it equal to 7  and i want to solve that equation  so it has these three variables x y and  z  so you have to find a solution there but  i'm only going to allow you to have  plug-ins integers and in fact there is a  solution in integers one two and minus  two if you plug it in you'll see it  works  all right uh now the general problem  that hilbert was addressing is suppose i  give you a polynomial  um let's say it said it it's set to zero  so we're looking for roots of the  polynomial but just some polynomial  equation you can always put it in this  form and i want to know  does it have a solution in integers  um and what i want what i'm looking for  is a procedure  which will tell me yes or no i want to  know um  give an algorithm to answer that  question for a given polynomial or using  the language of this course defining  this in terms of a language  uh decide this language give a give a  turing machine which will decide yes or  no for any given polynomial yes there is  a solution in integers no there is no  solution  okay  and um  uh that is a  um uh  um  that was what  um hilbert asked in his tenth problem  given algorithm now as we know now we  took um 70 years to get the answer that  um  that there is no such algorithm it's an  undecidable problem and we'll talk about  that a little bit later in the term but  um there is  d is not a decidable language  now um  there was no hope  of coming up with that answer  in 1900 or even in 1910  because we didn't have a formal idea of  what an algorithm is  that had to wait until the church turing  thesis  told us that algorithms really are  turing machines that there is a formal  way of saying what an algorithm is  and once you had that notion then you  could prove that there is no turing  machine but before that you had only  this vague notion intuitive notion of  what an algorithm is and so there was no  hope of ever answering that because the  in fact the answer is there is no such  algorithm  okay now um i'll give this as a little  exercise to you we're a little bit  running short on time but this language  d is in fact a recognizable language  so i would suggest you think about that  offline um  but basically you know you can try  plugging in different values for these  variables and if you ever find that you  know the um  that it evaluates to zero then you can  accept but otherwise you just have to  keep going and looking so  showing recognizability is very simple  but decidability is false  okay now  let's talk a little bit about encodings  for turing machines um  so  we're going to be working encodings and  turing machines so we're now going to be  working with um  turing machines going forward  we'll go as i you know we're going to  the input to those turing machines might  be polynomials might be strings they  might be other things too we might want  to feed automata  into the turing machines so the turing  machine can answer questions about the  automata  well don't forget turing machines take  as their input just strings  so we have to think about how we're  going to represent  something more complicated like an  automaton as a string  and i'm not going to get into the  details of that you could spell it out  in detail um but i think that's not too  interesting to get into that we're just  going to have develop a notation that  says if you have some object  o  it could be a polynomial it could be an  automaton it could be a graph it could  be whatever you're working with a table  i'm going to write  that o in these brackets  to mean an encoding of that object into  a string  and then you can feed the string into  the turing machine  okay  so that's how we're going to be thinking  of presenting turing machines with more  complicated objects and strings as input  because we're just going to represent  them as strings using some ways in which  i'm sure you're all familiar i mean  that's how you deal with representing  stuff when you're you know how to write  your programs anyway um but just to make  it formal and that's why we're going to  write it down in these brackets and if  you have a list of several objects that  you want to present together  to a turing machine we'll just write  them together within brackets like this  now for writing turing machines down  we're going to going forward we're going  to be using high-level english  descriptions um  we're not going to be worrying about  managing the like the stuff we've been  doing up till now i'm not going to ask  you to do it we're not going to do that  anymore and i'm not going to ask you to  do it managing where stuff goes on the  tapes and all that stuff that's too low  level  because really now that we have the  church turing thesis we're really  interested in talking about algorithms  we're not that interested in talking  about turing machines per se with  ancient algorithms um and what the power  of computation is  so um we're going to only be talking  about touring machines now in a high  higher level way and only when we need  to prove something about uh capabilities  we're going to come back to turing  machines i'm going to be proving things  you know about their limitations and so  on so our notation for running turing  machines is going to be  basically going to put the turing  machine inside these quotation marks and  we're going to know that we could if in  principle write out the touring machine  in a precise way in terms of states and  transition function and so on but we'll  never actually go ahead and do that  lengthy exercise  um so quick check in here  so one of the features well okay let me  not give this away so if x and y are  strings  you know i want to now have a way of  presenting two strings as a single  string as input to my machine because  i always think of my machine as getting  a single input  so would you suggest one way of  combining two strings into one which we  would be a good encoding is just to  concatenate those two strings together  is  would it be that would  would that be the way you would do it is  that a good way to do it or not such a  good way to do it um so let's uh  um  let's see here  i can get to that next  and think what you would want to have  happen  in a good encoding  okay  ready set  sold  uh share results  yeah i think most of you got the idea  that this is not a good way of combining  two strings into one um because  the problem is it's kind of ambiguous in  a sense you know that you could  if you combine two strings this way  what's what's important in an encoding  is that the machine when it gets the  encoding it can decode them back into  the original objects  and if you're just going to be sticking  the two strings together you don't know  where one string  ends and the next string begins  and so it's not going to be a good way  of combining things you you should  find a little bit more clever way of  either introducing another symbol or  it's doing something a little bit more  sophisticated which allow you to be able  to do the decoding as well as the  encoding in a unique way  okay so uh getting back to that notation  for a turing machine so here is the  machine we've already seen once before  for a to the kb to the kc to the k  i would write it now more simply than  managing all of the tapes that we had  the first time around which we did last  lecture i would just say i would give it  an input w  check if w is of the right form with the  things in the right order reject if it's  not  count the number of a's b's and c's and  w  except if all the counts are equal and  reject if not  we're not going to be that's going to be  good enough to be writing things at that  higher level when you're going to be  writing your algorithm descriptions you  just have to make sure that whatever  you're doing you can implement um you  know you you can't make uh you know you  you don't want to be doing tests which  are impossible or doing infinite  infinitely much work in one stage  that's not good um but as long as it's  clear that what you're doing  is doing only a finite amount of work in  every stage and it's something that you  could really implement you can write it  at a high in a high level  um  okay  i wanted to spend a few minutes talking  about problem set two but we a little  bit running out of time here um  uh in particular there was this problem  number five  where you show that a language is turing  recognizable if and only if there's a  decidable d  um  where c is turing recognizable where d  is now a collection of pairs we've got  some questions about the notation which  i hopefully answered now  so um  c  uh  is a set of x's such that there exists a  a string you can pair it with  so that the string x y is in  d um  let me try to give you a picture of that  uh  um  [Music]  so  i'm gonna think of d as a collection of  pairs of strings and it might be helpful  to think of the kind of  you know on the axes here  so if we have a pair of strings x y  which i have not yet packaged into a  single string i'm thinking of them as a  pair of two objects at this moment  uh think of d as so  you know just the x part is just below  here on the x-axis  um d you might want to think just  conceptually we want to think of it as a  collection of pairs  so it's like a subset of all of these  pairs  and  c is all of the  the x's that correspond to any pair in  here  um sometimes we call that the projection  because it's all the things that are  below  or the shadow if you had a light sitting  up here  it's all the things that are kind of  underneath a d um so i've written c here  kind of a little thicker if you can see  that so that's the c language  and um  what you're going to what there's a two  directions here one is a lot easier than  the other if i give you a decidable d  and i want to test whether something's  in c  so i give you an x i want to know is it  is x  in  c  well you now have to test is there some  y that i can pair with x where the pairs  in d  um  so you know you can start looking for  that y if you ever find one  you know that x is in c  there are infinitely many ways to look  for but don't forget  you know  you're only looking for a recognizer for  c  so  you know on the rejecting side you're  allowed to go forever  so i've kind of given you a way to think  about the easy direction the hard  direction  um  you need to think about um  how are you going to come up with that  decidable d if i give you c you have to  find a decidable d and now you're you're  bringing something down lower you're  starting with a recognizing recognizable  language and a decidable language which  is going to sort of be counterpart to  that in this sense is a simpler language  and the way it becomes simpler is that y  is going to help you  determine whether x is in c  um and i guess the thing that you should  i'll leave you with is that maybe we can  talk about this a little bit more on  tuesday i'll try to leave it a little  bit more time  if you want to test if something's in  c x is in c but i don't want to let you  go forever anymore because i want to be  a decidable language  and i'm going to use why to help you  what information would help you  guarantee  you get the right answer for x being in  c  but that you would  have to be sure you're getting the right  answer so it's you know why could just  be the answer but then you know you  don't know that that's you you have to  be convinced that you you have the right  answer you know why just saying what it  is i mean you could well i could say  that x is in d even when it's not true x  isn't c even when that's not true  but so one information would allow you  to check  that  x is in c  what would be helpful information to  check the x's and c  where you would avoid ever having to go  forever  a little bit too rushed here for that to  be helpful anyway let's just uh conclude  what we've done um just brief summary  here  um and i i i don't want to uh  um  keep you going keep you over time so  i'll just leave this up on the board um  i will uh  um  uh  see if there's any so  the lecture is over uh and you can take  off uh as you wish  um i will stick around for a couple of  minutes i have another meeting soon um  but uh i'll answer try to answer some  chats uh  all right um  people are commenting about this movie  about touring the imitation game uh you  know if you haven't seen that i  recommend it um  um and uh  is it a good idea to make y to be equal  to the repeated loop string hmm  i'm not sure about that  uh thank you for the  uh thank you everybody for  sending your kind notes  um  is it  church touring thesis the question is is  it in the book yes it's in the book kind  of similar to what i've already said but  yes  okay this is a good question here  the church turing thesis somebody asked  me is it proved in the book  there's nothing to prove  the church touring thesis  is an equivalence between the intuitive  and the formal  you can't prove something like that  you can just make it's really in a sense  a hypothesis  that the only thing you'll ever be able  to compute  um is something that you can do with a  turing machine  um i mean  that has something to do with the nature  of the physical world and i'm sure i  don't really think that's what people  had in mind it's that you know the the  kinds of things that we normally think  of being able to do with a  with a rest with a procedure  mathematically it's exactly the kinds of  things that you can do with the turing  machine um  so somebody's pointing out well  trying to be helpful here maybe these  folks are asking about equivalence of  various different computation models  being proved in the book not that church  drink these sits itself well  maybe that's  the the things that we proved in lecture  are also proved in the book um about the  equivalence of single tape machines  multitape machines non-deterministic  machines um those are all proved in the  book we don't those i mean there's lots  of models out there so we can spend a  lot of time proving equivalences um and  there are books that do spend a lot of  time proving equivalences but i think  you know  uh  we yeah i i think what we've given is  probably enough um  uh  so somebody that's a good question if if  you give an algorithm  okay if you give an algorithm you don't  need to give the actual machine uh going  forward unless somebody unless you're  explicitly asked to  um  uh but yes you don't you don't have to  give um  the  states and transitions anymore  um  okay so it's a little after four i think  we're going to  i think i'm going to move on to my next  meeting uh so i uh thank you for being  here and i will see you  on tuesday  you

2
00:00:28,230 --> 00:00:31,509
okay everyone let's get started  uh welcome back um to  uh theory of computation lecture number  six  um  so  we have been  um  looking at  a number of different models of  computation  and um  last lecture actually was an important  one for us because we  shifted gears um from our restricted  models um  finite automata and pushdown automata  and their associated  um  generative models regular expressions  and  context-free grammars  to turing machines which are going to be  the model that we're going to which is  the model that we're going to be  sticking with for the rest of the  semester because that's going to be our  model as we're going to argue today for  a general purpose computer  so in the sense everything we've been  doing up till now has or up until that  point has been kind of a warm up  but it's been um nevertheless has gotten  the chance for us to introduce some  important concepts  uh that are um used in practice and also  will serve as good examples for us  moving forward and also just to get our  you know  get kind of  um  uh you know in a sense on the same page  uh so  what we're going to be doing today is  looking at the turing machine model in a  little bit more depth  one can  define turing machines in all sorts of  different ways  but it's going to turn out not to matter  because all of those different ways are  going to be equivalent to one another  and so  we are going to  stick with the very simplest version the  one we've already defined namely this uh  the simple one tape turning machine  but um  we're going to  basically justify that by looking at  some of these other models and proving  equivalent so we can we'll look  at multi-tape turing machines  we'll look at non-deterministic turing  machines  and we'll look at another model which is  slightly different but it's still based  on turing machines called an enumerator  and we'll show that those all in the end  um  give you the same class of languages and  so in that sense they're all equivalent  to one another  and that's going to be served as a kind  of a  motivator um kind of to in a sense  recapitulate some of the history of the  subject  um and going to lead to our um  discussion of what's called the church  turing thesis so we will uh  i'll get to that in due course  and we'll also talk about uh some  notation for  um  languages and  notations for turing machines and for  encoding objects to feed into turing  machines as input but we'll get to that  shortly as well  uh  so let's move on then we will  next  go into uh  a little review of what we did with for  touring machines and um just want to  make sure we're all together on that the  very important concept for us this term  so the turing machine model looks like  there's going to be this finite control  there's a tape with a head that can read  and write on the tape can move in both  directions the tape is infinite to the  to one side and so on as i mentioned  last time  the output of the turing machine is  either going to be a halt  accepting or rejecting or loop that the  machine may run forever with three  possible outcomes for any particular  input the machine may accept that input  by entering queue accept may halt and  reject by entering q reject and it might  reject by looping which means it just  never gets to the accept state or the uh  it never gets to any holding state it  just goes forever but we still consider  that to be rejecting the input just  it's rejecting by looping  okay um  and as we defined last time a language  is touring recognizable as or as we  typically write t recognizable if it's  the language of some turing machine  the collection of accepted strings from  that turing machine again just as before  machine may accept  zero strings one string many strings but  it always has one language  the collection of all accepted strings  um  now if you have a decider which is a  machine that never loops which always  holds on every input  then we say its language is a decidable  language  so we'll say language is turning  decidable or simply decidable  if it's the language of some  decider which is a turing machine that  always holds on all inputs  so we have those two distinct notions  turning recognizable languages and  turing decidable languages  um  now as we're going to argue this  lecture turing machines are going to be  our model of a general general purpose  computer so that's the way we're going  to think of computers as touring  machines um  and  why turing machines why didn't we pick  something else  well the fact is it doesn't matter and  that's going to be the point of this  lecture  all reasonable models of general purpose  computation  um you know unrestricted um  computation in the sense of not limited  memory um are all  going to be are all  have been shown um all the models that  we've ever encountered have also been  shown to be equivalent to one another um  and so you you're free to pick anyone  you like  and so for this course we're going to  pick turing machines because they're  very simple to argue about  mathematically and also they have a  sort of a some element of familiarity  in that you know they're they they feel  like um you know you well they um  they're more familiar than some of the  other models that have been proposed  that are out there um you know such as  you know rewriting systems lambda  calculus and so on because turing  machines feel like a primitive kind of  computer and in that sense they have a  certain familiarity  okay um so let's start talking about  variations on the turing machine model  and we're going to argue that it doesn't  matter it doesn't make any difference um  and then whether this is going to be  kind of a precursor to a discussion of a  bit of the history of the subject that  we'll go and get to in the second half  of the lecture  so um  a multi-tape turing machine is a turing  machine as you might imagine that has  more than one well it has one or  possibly more tapes and so a single tape  turning machine would be a special  version of a multi-tape turing machine  that's okay  but you might have more than one tape um  as i've shown in this diagram  now uh  how do we actually use a multi-tape  turing machine well you present the in  and we're going to see these coming up  for convenience sometimes it's it's nice  to be working with multiple tapes so  we're going to see these later on in the  semester a couple of times as well but  for now um  you know we'll we're setting the model  up so that  the input is going to be presented on a  special input tape um so that's where  the input appears and it's going to be  followed by blanks just as we had before  and now we have these potentially other  tapes possibly other tapes which are we  call them work tapes where the machine  can  write other stuff as it wishes and those  tapes are going to be initially blank  so just all blanks on them  all of the tapes are going to be read  and write so you can write on the input  tape obviously you can read on from the  input tape and you can read and write on  the other tapes as well  um  so what we want to first establish that  by having these additional tapes  you don't get additional power for the  machine in the sense that you're not  going to have  you won't have additional  languages that you can recognize by  virtue of having these additional tapes  i mean you could imagine that having  more tapes will allow you to do more  things  you know for example if you have a push  down automaton  with two stacks  you can do more languages than you can  with one stack  so it's conceivable that by having more  tapes you can do more languages than you  could with one with one tape  but in fact that's not the case  what one tape is as good as having many  tapes uh and we're going to prove that  you know we're going to  quickly sketch through the proof of that  fact um  so uh the theorem is that turing machine  a language is touring recognizable and  when we say turing recognizable for now  we mean just with one tape um so  that's the way we've defined it so a  language is turing recognizable if and  only if some multi-tape turing machine  recognizes that language  okay so really that another way of  saying that is  if you have a language that you can do  with a single tape you can do it with a  multi-tape and vice versa  so one direction that is immediate  because a single tape turing machine is  already a multi-tape turing machine that  just happens to have one tape  uh so the forward direction of that is  is um  there's nothing to say  that's just immediately true  um  but if we want to prove the reverse then  we're gonna have to do some work  and the work is going to be showing how  do you convert a multi-tape turing  machine to a single tape turing machine  so if we have something that's  recognized by a multi-tape turing  machine it's still turing recognizable  what that means is you can do it with a  single tape turning machine so we have  to show how to do the conversion  and i'm kind of you know i'll i'll i'll  show you that i think in a convincing  way but we know without getting into too  much detail  so here is an image of a multi-tape  turing machine  in during the course of its input so it  has already we've already started it off  um you know initially it starts off with  the um other tapes the work tapes being  all blank but now it's processed for a  while  and you know the head on the input tape  is now has moved off from its starting  position at the left end it's somewhere  in the middle it's written stuff on the  other  tapes and what we want to do is show how  to represent  that same information  on a single tape turing machine  in a way which allows the single tape  turing machine  to carry out  the steps of the multi-tape turing  machine but using only its single tape  by virtue of some kind of a data  structure which allows for the  simulation to cut to go  forward okay  so how is the simula the single tape  turning machine going to be simulating  going to be carrying out this the the  same effect  of having these multiple tapes on the  multi-tape turing machine  so here's a picture of the single tape  turning machine it just has one tape  by the way i should mention that all of  the tapes are infinite to the right um  in the multi-tape touring machine just  as we had for the single tape turning  machine  and now uh with this uh single tape  turning machine it's going to represent  the information that was on  that's present on these multiple tapes  but using only the single tape and the  way i'm choosing to do that is going to  be particularly simple  i'm going to just divide up so here i'm  saying it in words uh it's going to  simulate him by storing the contents of  the multi-tape  on the single tape in separate blocks  so i'm basically going to divide up the  single tape uh turing machines tape  into separate regions  where each one of those regions is going  to have the information that was on one  of the tapes  in the um multitape machine  so for example here is on the first tape  it's got aabba  well that's going to appear here in that  first block on the single tape turing  machine  okay  sort of seeing it float down to suggest  that it's coming from this multi-tape  turing machine but that's really been  developed by the simulation that the  single tape turning machine has  obviously the single tape turning  machine doesn't have any direct access  to the multi-tape machine but it's going  to be simulating  so  this is how we're showing the data is  being stored on the single tape machines  tape so in the second block it's going  to have the contents of the second uh  tape of the turing multi-tape machine  and the uh the final  um  uh region of the single  tapes this is the final block  so-called of the single tapes tape is  going to have single tape machines tape  it's going to have their the rest of the  um  the contents of the last  tape of of m  and then it's going to be followed by  the same infinitely many blanks that  each of these um  tapes  are going to have  following the portion that  they may have written during the course  of their computation  okay  so that's what the single tape turing  machine's tape is going to look like  during the course of its computation  it's going to have the informations  represented in these blocks  capturing all of the information that  the multi-tape turing machine has in a  perhaps somewhat less convenient way  because the multi-tape turing machine  you know we didn't really make this  explicit and in part because it doesn't  really matter we didn't say exactly how  the multi-tape turning machine operates  what i have in mind is that the  multi-tape turning machine  can read and move all of its heads  from all of its heads in one step  so in a single step of the multi-tape  machine it can it can obtain the  information that's underneath each of  its heads  feed that into its transition function  and then together with the state of the  multi-tape machine decide how to change  each of those locations and then how to  move each one of those heads  so it's kind of operating on all of the  tapes in parallel  okay so now uh how how does the actual  steps of the simulation of the single  tape you know  by the single tape um machine uh how  does it go  so first of all  besides  storing  the contents  of each of the tapes in in s's single  tape  there's some additional information that  it needs to record namely  um m  has  a head  for each one of its tapes  but s has just a single head  and each of m's heads could be in some  different location you know in this case  as i've shown it  on the first tape its head is in  location three on the second tape it's  in location two on the third tape it's a  location on the last tape is in location  one  uh  so where were we we were simulating  the multi-tape turing machine with the  single tape turing machine  and we had to keep track of where the  heads are  and so we're going to do that by writing  the locations on those blocks  okay so  we're going to have  a special  dot  as i've shown here to represent the  location of the head in that very first  block so the heads on the b i'm going to  dot the b and i'm going to do the same  thing  for the locations of the others  um heads  and how am i getting that effect well  we've had seen something like that  before where we just expand the tape  alphabet of s  to allow for  these dotted symbols as well as the uh  irregular symbols we also have expanded  it to include those delimiter markers  that separate the blocks from one one  another which i'm writing as a pound  sign um so we can just get that effect  simply by expanding the tape alphabet of  s  okay a few more details of s that are  just worth looking at just to make sure  we're kind of all understanding what's  happening  so for every time m takes one step  s has actually a lot of work to do  because one step of m it can move all of  those  read and move all of those heads all at  one shot  s has to scan  the entire tape  to see what those what's underneath  those in effect virtual heads which are  the locations of the dotted symbols it  has to see what's underneath each one of  those heads  to see how to update the transition you  know update its state to the next state  and then it has to scan again  to  change the location  change the contents of those of those  tape locations and also to move the head  left or right by moving the effectively  now moving the dot left or right so  that's pretty straightforward uh  uh  there's one  complication that can occur however um  which is that what happens if  um  on one of the tapes let's say  m  starts using writing more content  then you have room in that block  uh to store that information  you know so if the m like moves it has  one zero one suppose m you know after a  few steps moves his head into the  originally blank portion of the tape and  writes another symbol there we have to  put that symbol somewhere because we  have to record all that information and  the block is like full  so what do we do well in that case s  goes to like a little interrupt routine  and  uh  moves shifts all of the symbols um to  the right one place  to make open up  um a location here where it can write a  new symbol for  uh  carrying continuing the simulation  so with that in mind  uh  s can maintain the current contents of  each of m's tapes  and um let me just note that here shift  to add room is needed  and that's all that happens in this  during the course of the simulation okay  and if of course if  s  as it's simulating m  observes that m comes to an accept or  reject state  uh s should do the same  okay so that that's our description of  how the simulation of the the single  tape simulation of the multi-tape  machine works  right  okay let's turn to non-deterministic  machines  now  if you remember for fine art and i hope  you do for finite automata we had  equivalence between non-deterministic  and deterministic  um uh finite automata for pushdown  automata we did not have equivalence we  didn't prove that but we just stated it  as a fact there are certain languages  that you can do with non-deterministic  push-down automata which is the model we  typically hold as our standard so the  some things you can do with  non-deterministic push-down automata  that you cannot do with deterministic  push-down automatic um you really need  the non-determinism they're not not  equivalent  for turing machines  we're going to get the equivalents back  so we'll show that anything you can do  with a non-deterministic turing machine  in terms of language recognition you can  also do with a deterministic turing  machine so remember we kind of mentioned  this briefly last time  the  non-deterministic turing machine looks  exactly like a deterministic turing  machine except for the transition  function where we have this power set  which allows for  multiple different outcomes at a given  step instead of just a single outcome  that you would have in a deterministic  machine so we represent that with this  power set  here um  applied to the possibilities that um the  machine would have as the  next uh next step  okay  um so we're now going to prove a very  similar theorem that a is recognizable  by an ordinary  one tape turing machine that kind of  goes without saying so that's how we  defined it a is turning recognizable if  and only if some non-deterministic  turing machine recognizes that language  okay  um again remember we're using  non-determinism in the way we always do  namely that  a non-deterministic machine accepts if  there is some branch or some thread if  it's not a computation ends up at an  except  other branches might go forever or might  uh reject part with part of the way  through  but acceptance always overrules them if  any branch accepts that's how  non-determinism works for us  okay so now  the forward direction of this is again  just like before immediate because a  deterministic turing machine is a  special kind of not a deterministic  turing machine which never branches um  not deterministically on any of its  steps  so that forward direction is immediate  the backwards definition is where we're  going to have to do some work  converting our non-deterministic turing  machine to a deterministic machine and  we'll do so as follows we'll take a  non-deterministic turing machine  uh here's our picture and we're going to  now  um  imagine its computation in terms of a  tree  um  and uh so here is the non-deterministic  computation tree for n on some input w  so n for nondeterministic uh  here is the tree um somewhere down here  it might end up accepting and as i  mentioned that is going to be uh  defining the overall computation to be  accepting if there is some place here  that's accepting  and the only way it can be non-accepting  computation if there is no  except that occurs anywhere  and somehow if you're going to convert  this non-deterministic machine to a  deterministic machine  the deterministic machine is going to  have to get that same effect  though it only has determinant you know  it doesn't have the non-determinism so  how does it manage that  well it's really going to be carrying  out the simulation  you know  kind of as you would imagine doing it  yourself if you were told you had to  simulate a non-deterministic turing  machine  which is you're going to search that  tree of possibilities looking to see if  you find and accept if you do then you  accept if you if you don't well maybe  you'll go forever or maybe you'll manage  to search the entire tree and then you  will  say  no i accept uh no i reject um  okay so let's just see again what the  data structure of that deterministic  machine's tape is going to look like  um  so the way this simulation is going to  carry out and and you know you could  program this in a host of different ways  and in fact the textbook has a somewhat  different simulation but i think this  one here is  uh lends itself a little bit better um  and maybe it's a little simpler  for description um in this in this  setting uh  but there's lots of different ways of  improving these things so we're going to  m is going to simulate n  kind of a little bit similar to the  previous uh simulation it's going to  break the tape up into blocks  and it's going to now store in each  block  a different thread  at a particular point in time  of n's computation  so you imagine where  m is going to be simulating and  sort of  um  doing the same parallelism  but  doing the  getting the effect of the parallelism  not through the non-determinism but by  maintaining copies of each of the  threads  on its tape and then updating them  accordingly  so the idea is i think not not too  complicated um  so let's just see some of the some of  the details here so here here populating  those blocks with the contents of um  ends tape on different threads at a so  you know maybe that corresponds to um  ends tape you know after the fifth step  of n  um you know on each of those threads you  have these three possibilities let's say  written down as three different blocks  um now uh  remember in the case of the multi-tape  simulation we needed to record some  extra information  extra information in particular we had  to record the location of the heads  by using those dotted symbols we're  going to do that again because each one  of these threads might have their head  in some different location but we're  going to have to do more  but actually so let's do one other one  thing at a time we're going to store the  head location  here they are all written down  as dotted symbols  but now there's something that goes  further because in a multi-tape case  there was one global state  that the multitape machine was in of  course at any given time it's just one  has one finite control it's in one state  um  and  uh but but but in the case of the  non-deterministic machine that we're  simulating now  each thread can be in a different state  um  so whereas before we could keep track of  the multitapes during  the multi-tape machine state inside the  single tape machines finite control  now there could be many many different  states to keep track of  so you won't be able to store that in a  finite control anymore because there  could be some huge number of threads  active at any given stage and some of  them can be one state others can be in  different state and you know how do you  keep track of all that so we're going to  have to use the tape  we're going to actually write down which  state a given thread is in on that block  and we'll do that i'll show it like this  so writing down the state of each cert  in the block  by writing down symbols which correspond  to those uh states  so we're actually in a sense writing the  states down right on top of block using  symbols that correspond to those states  so again we're doing getting that effect  by increasing the tape alphabet  of m  to include  um  symbols that correspond to each of its  states  i'm going to write those symbols down so  here's the symbol for state q8 that says  well one of th that very first thread of  n's computation is in state q8 it's in  this third position of its t um on its  tape uh the head is on the third  position there and the tape contents is  aaba  that's how we represent that thread of  the computation  um including the state  okay  now  um  so am is going to carry out that step by  step  maintaining that information on its tape  there again  similar to before there might be some  special situations arising so for  example n is not non-deterministic so a  thread might fork  into uh two threads  what do we do then um well sort of the  you know the reasonable thing if there's  a forking thread  m then copies that block  makes two copies of the block  to correspond to the two or however many  copies you need to correspond to the  possibilities that um that thread is  branching into so you want to represent  them all on different blocks of m's tape  all right um and then if m ever finds  out that on one of the threads it's  entering the accept state  it can just shut down the whole  computation at that point and say accept  okay so  perhaps a little elaborate but i think  conceptually hopefully  um  not too bad um  now uh  uh let's move on then to talk about uh  somewhat of a different uh  looking  well sort of a different model in a way  um  uh which has some historical  significance and sometimes it's a  helpful way to look at uh  touring recognizability and you and  incidentally you have a homework problem  uh  on this um model  called an enumerator or turing  enumerator  so  uh here  it's going to operate somewhat  differently  first of all we're going to enhance the  turing machine model it's going to have  just a single tape but it's going to  also have a printer  okay so we're now  adding in  this new device into the turing machine  called the printer  and um  the  turing machine has  tape as before except  we never provide any input to the  machine  the tape always starts out fully blank  it's only used for reading and writing  uh only used for for like the keeping tr  for uh for for work  uh it's not where you present the input  so how do you talk about the language of  the machine  well what the way you work this machine  is you take this enumerator  uh it's a deterministic determination  with a printer as i mentioned you start  it off in blank tape and it you know  runs and runs and runs and periodically  it can print  a string under some sort of program  control which i'm not going to spell out  for you but you can imagine you might  have to define the machine in such a way  that when it goes into a certain print  state so we're not going to set that all  up  then whatever string is in a certain  region of the tape maybe from this the  start point up into the head location  that gets printed out  on the printer  and then it can print out other strings  in due course and so  periodically you think of this printer  as printing out a string um  under the control of the uh  the turing machine enumerator  um  and so  these print strings these strings that  could print out w1 w2 they appear  and  the machine might possibly go forever  and print infinitely many strings  or it might  go forever and only print finally many  strings or it might stop after a while  by entering a holding state accepting or  rejecting is irrelevant but enters a  halting state and then  the number the strings that it's print  out the finite really many strings it  printed out are just that's the output  of the machine  now the language of the machine is the  collection of all strings that it ever  prints out  so we're defining language in a somewhat  different way here it's not the strings  that it accepts it's a string that it  prints  so we think of this machine almost a  little bit analogous to like the regular  expression or the grammar in the sense  that it's a generative model it produces  the language rather than accepts the  strings in the language  this is not really a recognizer it's a  generator and the language of the  machine as i'm writing over here for an  enumerator here we say that it's  language is the collection of strings  that it prints  okay  now we will show that a language is  touring recognizable in the previous  sense uh you know  recognized by some ordinary turing  machine  if and only if it's the language of  summer numerator  and actually this is kind of a little  bit of an interesting proof uh you have  to do some work it's an if and only if  now neither direction is immediate  you're gonna have to do some work uh in  both directions one direction is a  little harder and the other will start  off with the easier direction let's say  we have an enumerator  i hope you hopefully you got this  concept of this turing machine which  periodically prints strings  when you've started it off on the empty  tape  um  uh so now what i'm going to construct  for you  is that turing machine  recognizer  defined from the enumerator so this  recognizer is going to be simulating the  enumerator  um so it's  basically the recognizer going to launch  the enumerator  it's going to start off simulating it  um  now if you want if it's convenient we we  can use several tapes we can use one  tape to simulate the recognizer and you  have other tapes available for  convenience if you want because we  already showed multi-tape and single  tape are equivalent so if you want to  think of m as having multiple types it's  not going to really be that important  relevant to my conversation um  but you're going to simulate e starting  on the blank input as you're supposed to  and then you're going to see whenever e  prints an x  you're going to see if x is the same as  the input to the recognizer  you you get the idea so we have a  recognizer it has an input string maybe  like  1 1 0 1.  and i want to know i want to accept that  string if it's one of the strings that  the enumerator e prints out  because that's what the recognizer do  it's supposed to accept all the strings  that the enumerator prints out so i got  this one one zero one what do i do i  launch i fire up that numerator i get it  going and i start watching the strings  it prints out  comparing them with my input string one  one zero one  if i ever see it print out a one one  zero one  great i i know i can accept because i  know it's in the enumerator's language  but if i compare and compare and compare  i never see  uh the enumerator ever printing out uh  my input string 1101  well i just keep simulating if e holds  well then i can hold and reject  if i've never seen that string coming  out as an output  if e doesn't hold well i'm just not  going to hold either i'm going to go  forever but then i'm going to be  rejecting my input by looping  okay so that's the proof  of converting  in this uh backward direction which is  the easier direction now let's look at  the forward direction which has a  certain wrinkle that in it that we're  going to have to get to  so now we're going to be building our  enumerator to simulate our recognizer  okay and the way we'll do that  is  the enumerator has to print out  all of the strings that the recognizer  would ever accept  so you kind of do the obvious thing  you're going to  take the numerator is going to start  simulating  the recognizer m on all possible strings  sort of you know one by one using doing  them in parallel taking turns you never  know you know we um maybe we didn't make  this so explicit but you don't have to  you know you can sort of time share  among several different possibilities  you run you know it's sort of like  having different blocks uh for the  machine diff you're gonna run  um  uh the enumerator is gonna run the  recognizer on uh  it's you know well let's just say it  does it sequentially runs it on the  empty string it runs it on the string  zero it runs it on the string one runs  it on the string zero zero these are all  the possible strings in sigma star you  you run the on all of them  and  whenever  the enumerator  uh  oh  this is wrong  whenever  um  so whenever  m accepts  then print  i can't  write very well  print  w  um  w i oops  okay  so let me just say it in words  you want to simulate emma on each wi  whenever you notice  m accepting wi you just print out w i  um  because you want to print out  all of the strings that m accepts  now what have the problem there is a  problem here so uh hopefully you're not  confused by this typo  um uh doing it sequentially like i just  described doesn't quite work so let me  just back that up here doing it  sequentially doesn't quite work  because emma might get stuck  looping on one of the wi's like you know  maybe when i feed w  zero into w  into m  m goes forever  because m is rejecting zero by looping  but maybe it also accepts one this next  string in the list the string one i'll  never get to one by just feeding the  strings into m one by one like this  what i really have to do is run all of  the strings in m in parallel  and the way i'm going to indicate that  is i'm going to simulate m on w1 to wi  for i steps for each possible i so i'm  going to run m  on  more and more strings for more and more  steps  okay until and every time i notice an m  accepts something i print it out  um  so i will fix this in the uh version of  the uh  file that i  um  publish on the website so if you're  still not getting it you can look there  um  uh but just to make things even worse i  have a check in which is going to  be about this one little point here  so i got a question where do we get the  wi strings the wi strings are simply the  list of all strings in sigma star  so we can under program control  we can  make m  go through every possible string like if  you had an odometer you're going to  first get to the empty string then you  go to the string zero then the string  one you can write a program which is  going to do that  and the turing machine can similarly  write write code to do that  to get to each possible string one by  one and then that's what the  enumerator is doing it's obtaining each  of those strings and then feeding them  into m  seeing what m does  what i'm trying to get at here is that  it's not good to feed them in  run m to completion on each one before  going to the next one you really kind of  have to do them all in parallel  uh  to avoid the problem of getting stuck on  one string that m is looping on  um  all right  so uh this is relevant to your homework  in fact  if i convert m to an enumerator  um  in this way  does that enumerator always print the  strings out in string order  string order is this order here  um  having them uh the having the shorter  strings coming up before the longer  strings and within strings of a certain  length just doing them in lexicographic  order  um  uh so  um  hopefully you follow that but since you  you know these are not  uh correctness that doesn't matter uh  for us let me launch that poll let's  i'll see how confused how random the  answer is here uh  so a fair amount of confusion if you're  confused obviously you're in good  company there um  okay about to shut this down  uh five seconds to go  okay ending in now  uh  all right so the correct answer as the  majority of you did yet is in fact that  the order is not going to be  uh respected here when he  prints things out  it might print out some things later in  the order before earlier things in the  order what's going to control how um  when he is going to print it out it  really is if m  accepts some strings more quickly in  fewer steps  then e might end up printing out that  string earlier in the list  um then some other string that might be  a shorter string  um because  uh the order in which e is go going to  now identify  that m is ex is accepting those strings  is is the um depends upon the speed with  which m is do actually doing the  accepting  so you have to um this is relevant to  one of your homeworks because if  uh what you're going to be asked to show  is that if you start with a decidable  language  instead of a recognizable language  then you can make it then you can make  an enumerator  which always prints out things in order  in the string order  okay  and um  and vice versa so if you have and if you  have a string which uh the numerator  which prints the things out in string  order then the language is it's  decidable  okay so need to think about that  one direction is a fairly simple  modification of what i just showed  the other direction is a little bit more  work um  so uh anyway why don't we uh  uh take our little coffee break here  uh  okay so that's an interesting question  so one question is if there's because  you know sigma has an infinite sigma  star is infinite  um  uh if i understand this question quite  correctly which says you know it's an  infinite number of strings here  uh how how does the machine even get  started because it has to go through and  enumerate all of it no it's not first  writing down all of those strings  um  because yeah you can write down and it  you can't do this infinite step of  writing all the strings what i had in  mind is you're going to take each string  in turn  first you're going to take the first  string on the list of sigma star  run m uh on that string and then the  next string and sigma star run it on  that string and so on string after  string  and so you're never going to have  infinitely many strings to deal with  it's just going to be more and more  strings as you're going along  and um  the question i was trying to get at is  whether you're going to  run each one to complete completion  before you get to the next one or you're  going to kind of try to do them all in  parallel which is what you need to do  for to prove this uh this there  um  won't there be infinitely many wi yes so  there are a similar question infinitely  many wi there are infinitely many wi but  you know it's just an infinite loop that  we're in one by one you're taking care  of  more and more  uh wi as you're going um  uh  let's see here  yes so e is another question is are we  running it all on all the strings in  parallel yes we are running things all  on running all of the strings in  parallel but  you know it's uh running them in  parallel but um these are  um  uh  you know it's we're not defining a  parallel turing machine it's running  them in parallel using time sharing  you know it runs a little bit in this  block runs a little bit and that block  and then another block and sort of  shifts around and sort of does a few  steps of each and that's how it's  getting the effect of the parallelism  um  okay  um  question is  would the enumerator essentially have a  print tape and a work tape yeah you  could think of it as having a print tape  you know however you want to formalize  it it's it it  doesn't matter i mean i'm being a little  whimsical but attaching it to a picture  of a  a real printer but yeah it's just you  think conceptually you can have a print  tape however you like to think about  it's fine um  um  how can we directly say that without  knowing the program of the printer  uh  the printer is just there's no  we don't have to get into the code the  structure of the printer the printer is  just  uh something where you say print a  string and it print and a string comes  out  that's all we know about the printer and  that's all we need to know  um  so there's no program for the printer uh  sorry if i  not understand your question your  question but the question literally says  how can we say that without knowing the  program of the printer  so if the machine is decidable why does  it have to print all strings in order  for example if one string is shorter and  can it be decided later  we well yeah if the  uh the reason why we want  so the question is if the machine is  decidable why does it have to print all  strings in order  uh because that's what i'm asking you to  do in the problem  that's what if you read the problem i  think it's number five  on the pset that's what i'm asking you  to do that's why you have to print it in  order  otherwise you wouldn't have to worry  about printing an order just because i'm  asking you to  okay  so i think we're at a time let's uh  let us move back into um  our our material  um  okay  second half church touring thesis  um  so church uh  this is going back into the bit of the  history of the subject back to the 1930s  um  back then people were uh interested in  formulating the notion of what do we  mean by algorithm they don't even call  it algorithm um and those they they call  it some people call it procedures some  people call it effective procedure  um some people called it  effective calculation um but you know  people had in their minds mathematicians  have been dealing for centuries  thousands of years with procedures for  doing things that's a very natural thing  and  mathematical logicians in particular  church and turing are touring somebody  you  surely obviously have heard of church  maybe not um  a  church was turing's thesis advisor in  fact um and  they both were coming out of the  mathematical logic field of mathematics  and uh using trying to use mathematical  logic to formalize this intuitive notion  of what we have had for for centuries  about what what a procedure is what is  it what is what is an algorithm  and um  back in those days you know they came up  with different ways of formalizing it um  uh so you know here we had this notion  of algorithm which is kind of intuitive  concept  touring proposed turing machine as a way  of capturing that informal way in  mathematically precise way  other people came up with other ways of  doing it  and back then it wasn't obvious that all  of those different formulations would  end up giving you equivalent concepts  equivalent notions um  and in fact they proved in fairly  elaborate detail  that the different methods that people  came up with it was a lambda calculus  there was uh rewriting systems there  were several methods that were proposed  for formalizing um this notion and they  all turned out to be equivalent to one  another  um  in today  that seems kind of obvious  even though i went to some effort to  prove that just to give you a feeling  for how those things uh  go  you know that you know if you have  programs if you have pascal and java say  and thinking about what you can do  mathematically in those i'm not talking  about their ability to interface with  you know windows and so on but just the  mathematical capabilities  the capability of doing mathematical  calculations or functions with a pascal  program or a java program  you know it would be absurd to think  there's some program that you can write  in java that you can't write in pascal  um  or python  and the reason is we know you can  compile python into java and you can  compile java back into python that tells  you that the two systems of two  programming languages are equivalent in  power um that wasn't obvious that from  the get-go to these folks so they um  observed that uh all of the different  efforts they came at formalizing  algorithm all were equivalent to one  another  that was that that was a kind of a  breakthrough moment when they realized  that they're all  that  not all the ways that they've come up  with and once they got the idea they  realized all reasonable ways of doing it  always going to be equivalent  um and so that suggested that  they've really captured this notion of  algorithm by any one of those methods  say a turing machine  and that's what they took you can't  prove that because algorithms are an  intuitive notion  but the fact that we're able to capture  that in a formal way that's what we call  today the church touring thesis  okay um  so um  that is uh  um  so any of these methods uh  capture the notion of algorithm as we  described  and that has had a big impact on  mathematics uh  so you know  i just want to  just give me one second here  all right here's a check-in on this one  so you know alan turing so here are some  facts which may or may not be true about  elementary  um so uh  now you get to pick all the ones that  apply um based on your knowledge  obviously this is not uh  something this is more for fun but um or  historical interest um  but here is uh  let's launch that poll see what how much  you know about  uh mr turing um  check all that apply  okay almost done  please  let's wrap it up  i think that's everybody  okay  two seconds please get credit for doing  this and polling in fact it's kind of  interesting here  uh  um  [Music]  uh he  you all do know that he was a code  breaker uh he was a  worked uh  in fact did was part of a team i think  led the team which broke the german code  um during world war ii  you know the turing test is a famous uh  thing for how do you characterize when  you have an intelligent machine um so he  definitely worked in ai  he worked in biology as well um he has a  paper that less well known to computer  to scientists but if you look him up um  on wikipedia where i get all my  information  uh  uh he actually and i knew this anyway uh  he has a very famous paper influential  paper  on how um  for example spots arise on um on tiger  on leopards and stripes on tigers and so  on um he gave a kind of mathematical  model for that which actually proves  actually is uh quite does capture things  in an accurate way uh as was shown  subsequent to that  uh was imprisoned for being gay in fact  as far as i know from his history he was  not imprisoned for being gay um he was  convicted  of being gay um and he was given a  choice to go to prison or to take  chemicals  to cure  him from being gay  and he opted not to go to prison and  take the chemicals  uh and uh sadly he committed suicide  two years after that  so um he was um  treated very treated very badly by uh  british society and british government  uh despite having the the great the work  that he had done  um  and um  you might think that he has been honored  by appearing on a british banknote  that's also not true um uh but the good  news is he's not uh currently on a  british banknote but he's going to be  on a british bank note starting next  year um  so that is uh  um  so that's uh  you know along with um winston churchill  and a number of other notable brits he's  going to be on the 50 pound banknote  okay um  so let us continue um  so as i mentioned uh the church thesis  is important for mathematics um and it  has to do with these hilbert problems i  don't know how many of you have  encountered that david hilbert was  widely considered to be the  perhaps the greatest mathematician of  his day  um  and um you know every four years  mathematicians get together for an  international congress called the  international congress mathematicians  it was you know email that's been going  on for over 100 years and he was invited  to the 1900  uh meeting to give a talk about anything  he wanted and what he decided to do in  during that presentation is give it is  present 23  uh  problems  that would be a challenge for  mathematicians for the coming century  um and um  uh  you know i we're running a little short  on time so i'm not going to go into them  some of these will talk about later uh  but the tenth problem here is about  algorithms  the tenth problem on hilbert's list  of called called hilbert's tenth problem  is a problem about algorithms and it  says given algorithm for solving what  are called diaphantine equations  um he didn't call it an algorithm you  could call it some uh  you know finite procedure or something  like that  but you know you what are the  diaphantine equations i'm glad you asked  uh  diaphantine equations  uh what are they well they're very  simple they're just polynomial equations  like  you know does this polynomial equal some  constant for example um but where you're  looking for the solutions  you know the polynomials are variables  you're looking for the solutions but  you're only allowing those solutions to  be integers  so here's an example um  so here i give you this polynomial  um here i'm setting it equal to 7  and i want to solve that equation  so it has these three variables x y and  z  so you have to find a solution there but  i'm only going to allow you to have  plug-ins integers and in fact there is a  solution in integers one two and minus  two if you plug it in you'll see it  works  all right uh now the general problem  that hilbert was addressing is suppose i  give you a polynomial  um let's say it said it it's set to zero  so we're looking for roots of the  polynomial but just some polynomial  equation you can always put it in this  form and i want to know  does it have a solution in integers  um and what i want what i'm looking for  is a procedure  which will tell me yes or no i want to  know um  give an algorithm to answer that  question for a given polynomial or using  the language of this course defining  this in terms of a language  uh decide this language give a give a  turing machine which will decide yes or  no for any given polynomial yes there is  a solution in integers no there is no  solution  okay  and um  uh that is a  um uh  um  that was what  um hilbert asked in his tenth problem  given algorithm now as we know now we  took um 70 years to get the answer that  um  that there is no such algorithm it's an  undecidable problem and we'll talk about  that a little bit later in the term but  um there is  d is not a decidable language  now um  there was no hope  of coming up with that answer  in 1900 or even in 1910  because we didn't have a formal idea of  what an algorithm is  that had to wait until the church turing  thesis  told us that algorithms really are  turing machines that there is a formal  way of saying what an algorithm is  and once you had that notion then you  could prove that there is no turing  machine but before that you had only  this vague notion intuitive notion of  what an algorithm is and so there was no  hope of ever answering that because the  in fact the answer is there is no such  algorithm  okay now um i'll give this as a little  exercise to you we're a little bit  running short on time but this language  d is in fact a recognizable language  so i would suggest you think about that  offline um  but basically you know you can try  plugging in different values for these  variables and if you ever find that you  know the um  that it evaluates to zero then you can  accept but otherwise you just have to  keep going and looking so  showing recognizability is very simple  but decidability is false  okay now  let's talk a little bit about encodings  for turing machines um  so  we're going to be working encodings and  turing machines so we're now going to be  working with um  turing machines going forward  we'll go as i you know we're going to  the input to those turing machines might  be polynomials might be strings they  might be other things too we might want  to feed automata  into the turing machines so the turing  machine can answer questions about the  automata  well don't forget turing machines take  as their input just strings  so we have to think about how we're  going to represent  something more complicated like an  automaton as a string  and i'm not going to get into the  details of that you could spell it out  in detail um but i think that's not too  interesting to get into that we're just  going to have develop a notation that  says if you have some object  o  it could be a polynomial it could be an  automaton it could be a graph it could  be whatever you're working with a table  i'm going to write  that o in these brackets  to mean an encoding of that object into  a string  and then you can feed the string into  the turing machine  okay  so that's how we're going to be thinking  of presenting turing machines with more  complicated objects and strings as input  because we're just going to represent  them as strings using some ways in which  i'm sure you're all familiar i mean  that's how you deal with representing  stuff when you're you know how to write  your programs anyway um but just to make  it formal and that's why we're going to  write it down in these brackets and if  you have a list of several objects that  you want to present together  to a turing machine we'll just write  them together within brackets like this  now for writing turing machines down  we're going to going forward we're going  to be using high-level english  descriptions um  we're not going to be worrying about  managing the like the stuff we've been  doing up till now i'm not going to ask  you to do it we're not going to do that  anymore and i'm not going to ask you to  do it managing where stuff goes on the  tapes and all that stuff that's too low  level  because really now that we have the  church turing thesis we're really  interested in talking about algorithms  we're not that interested in talking  about turing machines per se with  ancient algorithms um and what the power  of computation is  so um we're going to only be talking  about touring machines now in a high  higher level way and only when we need  to prove something about uh capabilities  we're going to come back to turing  machines i'm going to be proving things  you know about their limitations and so  on so our notation for running turing  machines is going to be  basically going to put the turing  machine inside these quotation marks and  we're going to know that we could if in  principle write out the touring machine  in a precise way in terms of states and  transition function and so on but we'll  never actually go ahead and do that  lengthy exercise  um so quick check in here  so one of the features well okay let me  not give this away so if x and y are  strings  you know i want to now have a way of  presenting two strings as a single  string as input to my machine because  i always think of my machine as getting  a single input  so would you suggest one way of  combining two strings into one which we  would be a good encoding is just to  concatenate those two strings together  is  would it be that would  would that be the way you would do it is  that a good way to do it or not such a  good way to do it um so let's uh  um  let's see here  i can get to that next  and think what you would want to have  happen  in a good encoding  okay  ready set  sold  uh share results  yeah i think most of you got the idea  that this is not a good way of combining  two strings into one um because  the problem is it's kind of ambiguous in  a sense you know that you could  if you combine two strings this way  what's what's important in an encoding  is that the machine when it gets the  encoding it can decode them back into  the original objects  and if you're just going to be sticking  the two strings together you don't know  where one string  ends and the next string begins  and so it's not going to be a good way  of combining things you you should  find a little bit more clever way of  either introducing another symbol or  it's doing something a little bit more  sophisticated which allow you to be able  to do the decoding as well as the  encoding in a unique way  okay so uh getting back to that notation  for a turing machine so here is the  machine we've already seen once before  for a to the kb to the kc to the k  i would write it now more simply than  managing all of the tapes that we had  the first time around which we did last  lecture i would just say i would give it  an input w  check if w is of the right form with the  things in the right order reject if it's  not  count the number of a's b's and c's and  w  except if all the counts are equal and  reject if not  we're not going to be that's going to be  good enough to be writing things at that  higher level when you're going to be  writing your algorithm descriptions you  just have to make sure that whatever  you're doing you can implement um you  know you you can't make uh you know you  you don't want to be doing tests which  are impossible or doing infinite  infinitely much work in one stage  that's not good um but as long as it's  clear that what you're doing  is doing only a finite amount of work in  every stage and it's something that you  could really implement you can write it  at a high in a high level  um  okay  i wanted to spend a few minutes talking  about problem set two but we a little  bit running out of time here um  uh in particular there was this problem  number five  where you show that a language is turing  recognizable if and only if there's a  decidable d  um  where c is turing recognizable where d  is now a collection of pairs we've got  some questions about the notation which  i hopefully answered now  so um  c  uh  is a set of x's such that there exists a  a string you can pair it with  so that the string x y is in  d um  let me try to give you a picture of that  uh  um  [Music]  so  i'm gonna think of d as a collection of  pairs of strings and it might be helpful  to think of the kind of  you know on the axes here  so if we have a pair of strings x y  which i have not yet packaged into a  single string i'm thinking of them as a  pair of two objects at this moment  uh think of d as so  you know just the x part is just below  here on the x-axis  um d you might want to think just  conceptually we want to think of it as a  collection of pairs  so it's like a subset of all of these  pairs  and  c is all of the  the x's that correspond to any pair in  here  um sometimes we call that the projection  because it's all the things that are  below  or the shadow if you had a light sitting  up here  it's all the things that are kind of  underneath a d um so i've written c here  kind of a little thicker if you can see  that so that's the c language  and um  what you're going to what there's a two  directions here one is a lot easier than  the other if i give you a decidable d  and i want to test whether something's  in c  so i give you an x i want to know is it  is x  in  c  well you now have to test is there some  y that i can pair with x where the pairs  in d  um  so you know you can start looking for  that y if you ever find one  you know that x is in c  there are infinitely many ways to look  for but don't forget  you know  you're only looking for a recognizer for  c  so  you know on the rejecting side you're  allowed to go forever  so i've kind of given you a way to think  about the easy direction the hard  direction  um  you need to think about um  how are you going to come up with that  decidable d if i give you c you have to  find a decidable d and now you're you're  bringing something down lower you're  starting with a recognizing recognizable  language and a decidable language which  is going to sort of be counterpart to  that in this sense is a simpler language  and the way it becomes simpler is that y  is going to help you  determine whether x is in c  um and i guess the thing that you should  i'll leave you with is that maybe we can  talk about this a little bit more on  tuesday i'll try to leave it a little  bit more time  if you want to test if something's in  c x is in c but i don't want to let you  go forever anymore because i want to be  a decidable language  and i'm going to use why to help you  what information would help you  guarantee  you get the right answer for x being in  c  but that you would  have to be sure you're getting the right  answer so it's you know why could just  be the answer but then you know you  don't know that that's you you have to  be convinced that you you have the right  answer you know why just saying what it  is i mean you could well i could say  that x is in d even when it's not true x  isn't c even when that's not true  but so one information would allow you  to check  that  x is in c  what would be helpful information to  check the x's and c  where you would avoid ever having to go  forever  a little bit too rushed here for that to  be helpful anyway let's just uh conclude  what we've done um just brief summary  here  um and i i i don't want to uh  um  keep you going keep you over time so  i'll just leave this up on the board um  i will uh  um  uh  see if there's any so  the lecture is over uh and you can take  off uh as you wish  um i will stick around for a couple of  minutes i have another meeting soon um  but uh i'll answer try to answer some  chats uh  all right um  people are commenting about this movie  about touring the imitation game uh you  know if you haven't seen that i  recommend it um  um and uh  is it a good idea to make y to be equal  to the repeated loop string hmm  i'm not sure about that  uh thank you for the  uh thank you everybody for  sending your kind notes  um  is it  church touring thesis the question is is  it in the book yes it's in the book kind  of similar to what i've already said but  yes  okay this is a good question here  the church turing thesis somebody asked  me is it proved in the book  there's nothing to prove  the church touring thesis  is an equivalence between the intuitive  and the formal  you can't prove something like that  you can just make it's really in a sense  a hypothesis  that the only thing you'll ever be able  to compute  um is something that you can do with a  turing machine  um i mean  that has something to do with the nature  of the physical world and i'm sure i  don't really think that's what people  had in mind it's that you know the the  kinds of things that we normally think  of being able to do with a  with a rest with a procedure  mathematically it's exactly the kinds of  things that you can do with the turing  machine um  so somebody's pointing out well  trying to be helpful here maybe these  folks are asking about equivalence of  various different computation models  being proved in the book not that church  drink these sits itself well  maybe that's  the the things that we proved in lecture  are also proved in the book um about the  equivalence of single tape machines  multitape machines non-deterministic  machines um those are all proved in the  book we don't those i mean there's lots  of models out there so we can spend a  lot of time proving equivalences um and  there are books that do spend a lot of  time proving equivalences but i think  you know  uh  we yeah i i think what we've given is  probably enough um  uh  so somebody that's a good question if if  you give an algorithm  okay if you give an algorithm you don't  need to give the actual machine uh going  forward unless somebody unless you're  explicitly asked to  um  uh but yes you don't you don't have to  give um  the  states and transitions anymore  um  okay so it's a little after four i think  we're going to  i think i'm going to move on to my next  meeting uh so i uh thank you for being  here and i will see you  on tuesday  you
 

3
00:00:31,509 --> 00:00:33,670

 

4
00:00:33,670 --> 00:00:33,680

 

5
00:00:33,680 --> 00:00:35,270


6
00:00:35,270 --> 00:00:35,280

 

7
00:00:35,280 --> 00:00:36,310


8
00:00:36,310 --> 00:00:36,320

 

9
00:00:36,320 --> 00:00:38,790


10
00:00:38,790 --> 00:00:41,030

 

11
00:00:41,030 --> 00:00:41,040

 

12
00:00:41,040 --> 00:00:43,510


13
00:00:43,510 --> 00:00:45,590

 

14
00:00:45,590 --> 00:00:46,950

 

15
00:00:46,950 --> 00:00:46,960

 

16
00:00:46,960 --> 00:00:49,110


17
00:00:49,110 --> 00:00:50,790

 

18
00:00:50,790 --> 00:00:53,270

 

19
00:00:53,270 --> 00:00:55,910

 

20
00:00:55,910 --> 00:00:59,670

 

21
00:00:59,670 --> 00:01:01,430

 

22
00:01:01,430 --> 00:01:03,670

 

23
00:01:03,670 --> 00:01:05,590

 

24
00:01:05,590 --> 00:01:05,600

 

25
00:01:05,600 --> 00:01:06,550


26
00:01:06,550 --> 00:01:08,950

 

27
00:01:08,950 --> 00:01:08,960

 

28
00:01:08,960 --> 00:01:10,870


29
00:01:10,870 --> 00:01:12,469

 

30
00:01:12,469 --> 00:01:15,270

 

31
00:01:15,270 --> 00:01:17,109

 

32
00:01:17,109 --> 00:01:17,990

 

33
00:01:17,990 --> 00:01:19,109

 

34
00:01:19,109 --> 00:01:21,350

 

35
00:01:21,350 --> 00:01:23,429

 

36
00:01:23,429 --> 00:01:26,630

 

37
00:01:26,630 --> 00:01:27,910

 

38
00:01:27,910 --> 00:01:30,149

 

39
00:01:30,149 --> 00:01:32,550

 

40
00:01:32,550 --> 00:01:35,109

 

41
00:01:35,109 --> 00:01:36,789

 

42
00:01:36,789 --> 00:01:38,310

 

43
00:01:38,310 --> 00:01:41,350

 

44
00:01:41,350 --> 00:01:43,190

 

45
00:01:43,190 --> 00:01:45,910

 

46
00:01:45,910 --> 00:01:46,789

 

47
00:01:46,789 --> 00:01:48,230

 

48
00:01:48,230 --> 00:01:48,240

 

49
00:01:48,240 --> 00:01:49,670


50
00:01:49,670 --> 00:01:52,870

 

51
00:01:52,870 --> 00:01:55,350

 

52
00:01:55,350 --> 00:02:02,630

 

53
00:02:02,630 --> 00:02:05,109

 

54
00:02:05,109 --> 00:02:07,590

 

55
00:02:07,590 --> 00:02:09,109

 

56
00:02:09,109 --> 00:02:11,029

 

57
00:02:11,029 --> 00:02:12,229

 

58
00:02:12,229 --> 00:02:14,070

 

59
00:02:14,070 --> 00:02:15,990

 

60
00:02:15,990 --> 00:02:18,390

 

61
00:02:18,390 --> 00:02:19,670

 

62
00:02:19,670 --> 00:02:21,270

 

63
00:02:21,270 --> 00:02:23,190

 

64
00:02:23,190 --> 00:02:26,150

 

65
00:02:26,150 --> 00:02:28,229

 

66
00:02:28,229 --> 00:02:29,510

 

67
00:02:29,510 --> 00:02:31,030

 

68
00:02:31,030 --> 00:02:33,509

 

69
00:02:33,509 --> 00:02:34,869

 

70
00:02:34,869 --> 00:02:38,390

 

71
00:02:38,390 --> 00:02:40,630

 

72
00:02:40,630 --> 00:02:42,229

 

73
00:02:42,229 --> 00:02:42,239

 

74
00:02:42,239 --> 00:02:43,190


75
00:02:43,190 --> 00:02:44,550

 

76
00:02:44,550 --> 00:02:46,309

 

77
00:02:46,309 --> 00:02:49,110

 

78
00:02:49,110 --> 00:02:51,589

 

79
00:02:51,589 --> 00:02:51,599

 

80
00:02:51,599 --> 00:02:52,470


81
00:02:52,470 --> 00:02:55,670

 

82
00:02:55,670 --> 00:02:57,190

 

83
00:02:57,190 --> 00:02:58,869

 

84
00:02:58,869 --> 00:03:00,630

 

85
00:03:00,630 --> 00:03:01,910

 

86
00:03:01,910 --> 00:03:05,110

 

87
00:03:05,110 --> 00:03:06,790

 

88
00:03:06,790 --> 00:03:06,800

 

89
00:03:06,800 --> 00:03:07,830


90
00:03:07,830 --> 00:03:11,030

 

91
00:03:11,030 --> 00:03:12,949

 

92
00:03:12,949 --> 00:03:15,589

 

93
00:03:15,589 --> 00:03:19,270

 

94
00:03:19,270 --> 00:03:21,030

 

95
00:03:21,030 --> 00:03:23,430

 

96
00:03:23,430 --> 00:03:23,440

 

97
00:03:23,440 --> 00:03:24,710


98
00:03:24,710 --> 00:03:26,949

 

99
00:03:26,949 --> 00:03:29,509

 

100
00:03:29,509 --> 00:03:31,670

 

101
00:03:31,670 --> 00:03:33,990

 

102
00:03:33,990 --> 00:03:35,589

 

103
00:03:35,589 --> 00:03:35,599

 

104
00:03:35,599 --> 00:03:36,470


105
00:03:36,470 --> 00:03:40,229

 

106
00:03:40,229 --> 00:03:40,239

 

107
00:03:40,239 --> 00:03:42,070


108
00:03:42,070 --> 00:03:44,949

 

109
00:03:44,949 --> 00:03:47,030

 

110
00:03:47,030 --> 00:03:49,350

 

111
00:03:49,350 --> 00:03:50,789

 

112
00:03:50,789 --> 00:03:53,350

 

113
00:03:53,350 --> 00:03:55,350

 

114
00:03:55,350 --> 00:03:57,429

 

115
00:03:57,429 --> 00:04:00,470

 

116
00:04:00,470 --> 00:04:02,229

 

117
00:04:02,229 --> 00:04:04,149

 

118
00:04:04,149 --> 00:04:06,869

 

119
00:04:06,869 --> 00:04:09,990

 

120
00:04:09,990 --> 00:04:11,750

 

121
00:04:11,750 --> 00:04:13,830

 

122
00:04:13,830 --> 00:04:16,710

 

123
00:04:16,710 --> 00:04:18,550

 

124
00:04:18,550 --> 00:04:20,550

 

125
00:04:20,550 --> 00:04:23,110

 

126
00:04:23,110 --> 00:04:25,590

 

127
00:04:25,590 --> 00:04:29,189

 

128
00:04:29,189 --> 00:04:31,110

 

129
00:04:31,110 --> 00:04:34,070

 

130
00:04:34,070 --> 00:04:35,990

 

131
00:04:35,990 --> 00:04:37,990

 

132
00:04:37,990 --> 00:04:40,230

 

133
00:04:40,230 --> 00:04:43,510

 

134
00:04:43,510 --> 00:04:45,270

 

135
00:04:45,270 --> 00:04:47,830

 

136
00:04:47,830 --> 00:04:50,070

 

137
00:04:50,070 --> 00:04:52,469

 

138
00:04:52,469 --> 00:04:55,030

 

139
00:04:55,030 --> 00:04:57,830

 

140
00:04:57,830 --> 00:05:00,629

 

141
00:05:00,629 --> 00:05:02,390

 

142
00:05:02,390 --> 00:05:05,430

 

143
00:05:05,430 --> 00:05:08,550

 

144
00:05:08,550 --> 00:05:11,270

 

145
00:05:11,270 --> 00:05:11,280

 

146
00:05:11,280 --> 00:05:12,070


147
00:05:12,070 --> 00:05:14,390

 

148
00:05:14,390 --> 00:05:16,550

 

149
00:05:16,550 --> 00:05:18,870

 

150
00:05:18,870 --> 00:05:22,230

 

151
00:05:22,230 --> 00:05:22,240

 

152
00:05:22,240 --> 00:05:23,350


153
00:05:23,350 --> 00:05:25,029

 

154
00:05:25,029 --> 00:05:27,350

 

155
00:05:27,350 --> 00:05:30,150

 

156
00:05:30,150 --> 00:05:32,790

 

157
00:05:32,790 --> 00:05:35,830

 

158
00:05:35,830 --> 00:05:38,070

 

159
00:05:38,070 --> 00:05:39,909

 

160
00:05:39,909 --> 00:05:42,150

 

161
00:05:42,150 --> 00:05:42,160

 

162
00:05:42,160 --> 00:05:43,990


163
00:05:43,990 --> 00:05:46,150

 

164
00:05:46,150 --> 00:05:47,749

 

165
00:05:47,749 --> 00:05:49,749

 

166
00:05:49,749 --> 00:05:51,029

 

167
00:05:51,029 --> 00:05:52,390

 

168
00:05:52,390 --> 00:05:54,790

 

169
00:05:54,790 --> 00:05:54,800

 

170
00:05:54,800 --> 00:05:56,070


171
00:05:56,070 --> 00:05:58,390

 

172
00:05:58,390 --> 00:05:59,510

 

173
00:05:59,510 --> 00:06:01,430

 

174
00:06:01,430 --> 00:06:02,550

 

175
00:06:02,550 --> 00:06:02,560

 

176
00:06:02,560 --> 00:06:04,230


177
00:06:04,230 --> 00:06:06,390

 

178
00:06:06,390 --> 00:06:06,400

 

179
00:06:06,400 --> 00:06:07,670


180
00:06:07,670 --> 00:06:11,590

 

181
00:06:11,590 --> 00:06:13,590

 

182
00:06:13,590 --> 00:06:16,230

 

183
00:06:16,230 --> 00:06:18,230

 

184
00:06:18,230 --> 00:06:20,629

 

185
00:06:20,629 --> 00:06:22,230

 

186
00:06:22,230 --> 00:06:24,790

 

187
00:06:24,790 --> 00:06:26,870

 

188
00:06:26,870 --> 00:06:27,909

 

189
00:06:27,909 --> 00:06:29,590

 

190
00:06:29,590 --> 00:06:31,830

 

191
00:06:31,830 --> 00:06:33,590

 

192
00:06:33,590 --> 00:06:36,390

 

193
00:06:36,390 --> 00:06:40,150

 

194
00:06:40,150 --> 00:06:43,029

 

195
00:06:43,029 --> 00:06:46,390

 

196
00:06:46,390 --> 00:06:48,309

 

197
00:06:48,309 --> 00:06:49,749

 

198
00:06:49,749 --> 00:06:52,950

 

199
00:06:52,950 --> 00:06:54,710

 

200
00:06:54,710 --> 00:06:56,550

 

201
00:06:56,550 --> 00:06:58,469

 

202
00:06:58,469 --> 00:07:00,309

 

203
00:07:00,309 --> 00:07:02,870

 

204
00:07:02,870 --> 00:07:06,790

 

205
00:07:06,790 --> 00:07:09,350

 

206
00:07:09,350 --> 00:07:10,870

 

207
00:07:10,870 --> 00:07:14,230

 

208
00:07:14,230 --> 00:07:15,430

 

209
00:07:15,430 --> 00:07:18,230

 

210
00:07:18,230 --> 00:07:19,830

 

211
00:07:19,830 --> 00:07:21,270

 

212
00:07:21,270 --> 00:07:22,790

 

213
00:07:22,790 --> 00:07:24,230

 

214
00:07:24,230 --> 00:07:26,629

 

215
00:07:26,629 --> 00:07:28,629

 

216
00:07:28,629 --> 00:07:30,870

 

217
00:07:30,870 --> 00:07:33,830

 

218
00:07:33,830 --> 00:07:36,629

 

219
00:07:36,629 --> 00:07:38,469

 

220
00:07:38,469 --> 00:07:39,749

 

221
00:07:39,749 --> 00:07:41,909

 

222
00:07:41,909 --> 00:07:44,869

 

223
00:07:44,869 --> 00:07:46,710

 

224
00:07:46,710 --> 00:07:48,550

 

225
00:07:48,550 --> 00:07:50,550

 

226
00:07:50,550 --> 00:07:52,150

 

227
00:07:52,150 --> 00:07:54,390

 

228
00:07:54,390 --> 00:07:56,390

 

229
00:07:56,390 --> 00:07:57,830

 

230
00:07:57,830 --> 00:08:00,230

 

231
00:08:00,230 --> 00:08:01,589

 

232
00:08:01,589 --> 00:08:03,749

 

233
00:08:03,749 --> 00:08:05,029

 

234
00:08:05,029 --> 00:08:07,110

 

235
00:08:07,110 --> 00:08:09,510

 

236
00:08:09,510 --> 00:08:11,189

 

237
00:08:11,189 --> 00:08:13,990

 

238
00:08:13,990 --> 00:08:16,150

 

239
00:08:16,150 --> 00:08:19,189

 

240
00:08:19,189 --> 00:08:21,189

 

241
00:08:21,189 --> 00:08:21,199

 

242
00:08:21,199 --> 00:08:23,990


243
00:08:23,990 --> 00:08:26,070

 

244
00:08:26,070 --> 00:08:28,070

 

245
00:08:28,070 --> 00:08:31,510

 

246
00:08:31,510 --> 00:08:33,029

 

247
00:08:33,029 --> 00:08:35,110

 

248
00:08:35,110 --> 00:08:37,110

 

249
00:08:37,110 --> 00:08:38,870

 

250
00:08:38,870 --> 00:08:40,790

 

251
00:08:40,790 --> 00:08:40,800

 

252
00:08:40,800 --> 00:08:42,070


253
00:08:42,070 --> 00:08:44,790

 

254
00:08:44,790 --> 00:08:47,269

 

255
00:08:47,269 --> 00:08:50,230

 

256
00:08:50,230 --> 00:08:52,070

 

257
00:08:52,070 --> 00:08:56,550

 

258
00:08:56,550 --> 00:08:59,990

 

259
00:08:59,990 --> 00:09:02,389

 

260
00:09:02,389 --> 00:09:04,470

 

261
00:09:04,470 --> 00:09:06,389

 

262
00:09:06,389 --> 00:09:08,630

 

263
00:09:08,630 --> 00:09:08,640

 

264
00:09:08,640 --> 00:09:10,230


265
00:09:10,230 --> 00:09:12,870

 

266
00:09:12,870 --> 00:09:14,389

 

267
00:09:14,389 --> 00:09:16,630

 

268
00:09:16,630 --> 00:09:18,389

 

269
00:09:18,389 --> 00:09:19,910

 

270
00:09:19,910 --> 00:09:21,990

 

271
00:09:21,990 --> 00:09:23,750

 

272
00:09:23,750 --> 00:09:27,269

 

273
00:09:27,269 --> 00:09:29,430

 

274
00:09:29,430 --> 00:09:31,430

 

275
00:09:31,430 --> 00:09:33,670

 

276
00:09:33,670 --> 00:09:35,430

 

277
00:09:35,430 --> 00:09:37,509

 

278
00:09:37,509 --> 00:09:39,509

 

279
00:09:39,509 --> 00:09:42,710

 

280
00:09:42,710 --> 00:09:45,110

 

281
00:09:45,110 --> 00:09:47,269

 

282
00:09:47,269 --> 00:09:50,870

 

283
00:09:50,870 --> 00:09:52,630

 

284
00:09:52,630 --> 00:09:54,949

 

285
00:09:54,949 --> 00:09:57,030

 

286
00:09:57,030 --> 00:10:00,230

 

287
00:10:00,230 --> 00:10:01,910

 

288
00:10:01,910 --> 00:10:03,509

 

289
00:10:03,509 --> 00:10:05,030

 

290
00:10:05,030 --> 00:10:06,870

 

291
00:10:06,870 --> 00:10:09,509

 

292
00:10:09,509 --> 00:10:11,829

 

293
00:10:11,829 --> 00:10:14,389

 

294
00:10:14,389 --> 00:10:16,230

 

295
00:10:16,230 --> 00:10:18,550

 

296
00:10:18,550 --> 00:10:21,750

 

297
00:10:21,750 --> 00:10:23,509

 

298
00:10:23,509 --> 00:10:24,949

 

299
00:10:24,949 --> 00:10:26,870

 

300
00:10:26,870 --> 00:10:26,880

 

301
00:10:26,880 --> 00:10:28,310


302
00:10:28,310 --> 00:10:30,069

 

303
00:10:30,069 --> 00:10:32,550

 

304
00:10:32,550 --> 00:10:34,069

 

305
00:10:34,069 --> 00:10:36,310

 

306
00:10:36,310 --> 00:10:39,030

 

307
00:10:39,030 --> 00:10:40,470

 

308
00:10:40,470 --> 00:10:42,069

 

309
00:10:42,069 --> 00:10:44,550

 

310
00:10:44,550 --> 00:10:46,310

 

311
00:10:46,310 --> 00:10:47,829

 

312
00:10:47,829 --> 00:10:50,870

 

313
00:10:50,870 --> 00:10:53,269

 

314
00:10:53,269 --> 00:10:55,110

 

315
00:10:55,110 --> 00:10:56,870

 

316
00:10:56,870 --> 00:10:58,790

 

317
00:10:58,790 --> 00:11:01,350

 

318
00:11:01,350 --> 00:11:02,870

 

319
00:11:02,870 --> 00:11:05,590

 

320
00:11:05,590 --> 00:11:08,230

 

321
00:11:08,230 --> 00:11:10,230

 

322
00:11:10,230 --> 00:11:13,110

 

323
00:11:13,110 --> 00:11:15,750

 

324
00:11:15,750 --> 00:11:15,760

 

325
00:11:15,760 --> 00:11:16,710


326
00:11:16,710 --> 00:11:19,350

 

327
00:11:19,350 --> 00:11:21,350

 

328
00:11:21,350 --> 00:11:23,030

 

329
00:11:23,030 --> 00:11:25,509

 

330
00:11:25,509 --> 00:11:25,519

 

331
00:11:25,519 --> 00:11:26,829


332
00:11:26,829 --> 00:11:30,069

 

333
00:11:30,069 --> 00:11:32,630

 

334
00:11:32,630 --> 00:11:35,269

 

335
00:11:35,269 --> 00:11:37,910

 

336
00:11:37,910 --> 00:11:39,990

 

337
00:11:39,990 --> 00:11:41,509

 

338
00:11:41,509 --> 00:11:43,590

 

339
00:11:43,590 --> 00:11:46,069

 

340
00:11:46,069 --> 00:11:49,190

 

341
00:11:49,190 --> 00:11:51,190

 

342
00:11:51,190 --> 00:11:52,470

 

343
00:11:52,470 --> 00:11:54,829

 

344
00:11:54,829 --> 00:11:56,790

 

345
00:11:56,790 --> 00:11:59,110

 

346
00:11:59,110 --> 00:12:00,870

 

347
00:12:00,870 --> 00:12:03,750

 

348
00:12:03,750 --> 00:12:05,190

 

349
00:12:05,190 --> 00:12:07,110

 

350
00:12:07,110 --> 00:12:08,870

 

351
00:12:08,870 --> 00:12:10,550

 

352
00:12:10,550 --> 00:12:13,750

 

353
00:12:13,750 --> 00:12:15,269

 

354
00:12:15,269 --> 00:12:18,150

 

355
00:12:18,150 --> 00:12:19,670

 

356
00:12:19,670 --> 00:12:21,110

 

357
00:12:21,110 --> 00:12:21,120

 

358
00:12:21,120 --> 00:12:22,150


359
00:12:22,150 --> 00:12:24,550

 

360
00:12:24,550 --> 00:12:26,790

 

361
00:12:26,790 --> 00:12:29,110

 

362
00:12:29,110 --> 00:12:31,030

 

363
00:12:31,030 --> 00:12:33,269

 

364
00:12:33,269 --> 00:12:34,629

 

365
00:12:34,629 --> 00:12:36,629

 

366
00:12:36,629 --> 00:12:39,350

 

367
00:12:39,350 --> 00:12:41,750

 

368
00:12:41,750 --> 00:12:43,670

 

369
00:12:43,670 --> 00:12:44,870

 

370
00:12:44,870 --> 00:12:47,829

 

371
00:12:47,829 --> 00:12:50,550

 

372
00:12:50,550 --> 00:12:53,990

 

373
00:12:53,990 --> 00:12:56,550

 

374
00:12:56,550 --> 00:12:58,710

 

375
00:12:58,710 --> 00:13:00,949

 

376
00:13:00,949 --> 00:13:02,949

 

377
00:13:02,949 --> 00:13:07,030

 

378
00:13:07,030 --> 00:13:09,350

 

379
00:13:09,350 --> 00:13:11,590

 

380
00:13:11,590 --> 00:13:13,350

 

381
00:13:13,350 --> 00:13:15,190

 

382
00:13:15,190 --> 00:13:15,200

 

383
00:13:15,200 --> 00:13:16,150


384
00:13:16,150 --> 00:13:16,160

 

385
00:13:16,160 --> 00:13:18,230


386
00:13:18,230 --> 00:13:20,389

 

387
00:13:20,389 --> 00:13:22,310

 

388
00:13:22,310 --> 00:13:24,629

 

389
00:13:24,629 --> 00:13:26,870

 

390
00:13:26,870 --> 00:13:28,150

 

391
00:13:28,150 --> 00:13:29,430

 

392
00:13:29,430 --> 00:13:31,829

 

393
00:13:31,829 --> 00:13:33,670

 

394
00:13:33,670 --> 00:13:35,509

 

395
00:13:35,509 --> 00:13:35,519

 

396
00:13:35,519 --> 00:13:36,310


397
00:13:36,310 --> 00:13:37,829

 

398
00:13:37,829 --> 00:13:40,069

 

399
00:13:40,069 --> 00:13:42,230

 

400
00:13:42,230 --> 00:13:44,629

 

401
00:13:44,629 --> 00:13:49,030

 

402
00:13:49,030 --> 00:13:51,030

 

403
00:13:51,030 --> 00:13:51,040

 

404
00:13:51,040 --> 00:13:52,310


405
00:13:52,310 --> 00:13:54,710

 

406
00:13:54,710 --> 00:13:57,670

 

407
00:13:57,670 --> 00:14:00,230

 

408
00:14:00,230 --> 00:14:02,150

 

409
00:14:02,150 --> 00:14:04,470

 

410
00:14:04,470 --> 00:14:04,480

 

411
00:14:04,480 --> 00:14:06,389


412
00:14:06,389 --> 00:14:08,069

 

413
00:14:08,069 --> 00:14:09,910

 

414
00:14:09,910 --> 00:14:11,269

 

415
00:14:11,269 --> 00:14:13,269

 

416
00:14:13,269 --> 00:14:16,310

 

417
00:14:16,310 --> 00:14:16,320

 

418
00:14:16,320 --> 00:14:17,350


419
00:14:17,350 --> 00:14:19,030

 

420
00:14:19,030 --> 00:14:21,430

 

421
00:14:21,430 --> 00:14:23,030

 

422
00:14:23,030 --> 00:14:24,949

 

423
00:14:24,949 --> 00:14:24,959

 

424
00:14:24,959 --> 00:14:26,310


425
00:14:26,310 --> 00:14:27,990

 

426
00:14:27,990 --> 00:14:29,990

 

427
00:14:29,990 --> 00:14:31,910

 

428
00:14:31,910 --> 00:14:33,189

 

429
00:14:33,189 --> 00:14:35,430

 

430
00:14:35,430 --> 00:14:36,949

 

431
00:14:36,949 --> 00:14:38,949

 

432
00:14:38,949 --> 00:14:41,030

 

433
00:14:41,030 --> 00:14:43,350

 

434
00:14:43,350 --> 00:14:44,550

 

435
00:14:44,550 --> 00:14:46,470

 

436
00:14:46,470 --> 00:14:47,910

 

437
00:14:47,910 --> 00:14:49,750

 

438
00:14:49,750 --> 00:14:51,110

 

439
00:14:51,110 --> 00:14:52,870

 

440
00:14:52,870 --> 00:14:56,629

 

441
00:14:56,629 --> 00:15:00,230

 

442
00:15:00,230 --> 00:15:01,990

 

443
00:15:01,990 --> 00:15:03,990

 

444
00:15:03,990 --> 00:15:06,069

 

445
00:15:06,069 --> 00:15:07,670

 

446
00:15:07,670 --> 00:15:10,230

 

447
00:15:10,230 --> 00:15:11,670

 

448
00:15:11,670 --> 00:15:14,629

 

449
00:15:14,629 --> 00:15:16,949

 

450
00:15:16,949 --> 00:15:19,030

 

451
00:15:19,030 --> 00:15:20,629

 

452
00:15:20,629 --> 00:15:24,310

 

453
00:15:24,310 --> 00:15:27,509

 

454
00:15:27,509 --> 00:15:29,670

 

455
00:15:29,670 --> 00:15:31,509

 

456
00:15:31,509 --> 00:15:34,310

 

457
00:15:34,310 --> 00:15:35,590

 

458
00:15:35,590 --> 00:15:37,670

 

459
00:15:37,670 --> 00:15:37,680

 

460
00:15:37,680 --> 00:15:39,189


461
00:15:39,189 --> 00:15:39,199

 

462
00:15:39,199 --> 00:15:40,470


463
00:15:40,470 --> 00:15:42,230

 

464
00:15:42,230 --> 00:15:46,150

 

465
00:15:46,150 --> 00:15:46,160

 

466
00:15:46,160 --> 00:15:48,230


467
00:15:48,230 --> 00:15:49,670

 

468
00:15:49,670 --> 00:15:52,870

 

469
00:15:52,870 --> 00:15:54,949

 

470
00:15:54,949 --> 00:15:54,959

 

471
00:15:54,959 --> 00:15:56,069


472
00:15:56,069 --> 00:15:57,189

 

473
00:15:57,189 --> 00:16:00,550

 

474
00:16:00,550 --> 00:16:03,670

 

475
00:16:03,670 --> 00:16:05,590

 

476
00:16:05,590 --> 00:16:07,749

 

477
00:16:07,749 --> 00:16:09,350

 

478
00:16:09,350 --> 00:16:11,509

 

479
00:16:11,509 --> 00:16:13,269

 

480
00:16:13,269 --> 00:16:15,110

 

481
00:16:15,110 --> 00:16:17,189

 

482
00:16:17,189 --> 00:16:17,199

 

483
00:16:17,199 --> 00:16:18,150


484
00:16:18,150 --> 00:16:18,160

 

485
00:16:18,160 --> 00:16:19,110


486
00:16:19,110 --> 00:16:22,470

 

487
00:16:22,470 --> 00:16:24,230

 

488
00:16:24,230 --> 00:16:26,389

 

489
00:16:26,389 --> 00:16:27,829

 

490
00:16:27,829 --> 00:16:30,310

 

491
00:16:30,310 --> 00:16:31,829

 

492
00:16:31,829 --> 00:16:35,509

 

493
00:16:35,509 --> 00:16:37,110

 

494
00:16:37,110 --> 00:16:38,949

 

495
00:16:38,949 --> 00:16:40,310

 

496
00:16:40,310 --> 00:16:40,320

 

497
00:16:40,320 --> 00:16:41,509


498
00:16:41,509 --> 00:16:43,829

 

499
00:16:43,829 --> 00:16:46,870

 

500
00:16:46,870 --> 00:16:48,870

 

501
00:16:48,870 --> 00:16:51,189

 

502
00:16:51,189 --> 00:16:51,199

 

503
00:16:51,199 --> 00:16:52,470


504
00:16:52,470 --> 00:16:54,550

 

505
00:16:54,550 --> 00:16:57,350

 

506
00:16:57,350 --> 00:16:59,910

 

507
00:16:59,910 --> 00:17:01,430

 

508
00:17:01,430 --> 00:17:04,069

 

509
00:17:04,069 --> 00:17:05,990

 

510
00:17:05,990 --> 00:17:07,510

 

511
00:17:07,510 --> 00:17:10,069

 

512
00:17:10,069 --> 00:17:12,470

 

513
00:17:12,470 --> 00:17:14,309

 

514
00:17:14,309 --> 00:17:15,990

 

515
00:17:15,990 --> 00:17:17,189

 

516
00:17:17,189 --> 00:17:20,150

 

517
00:17:20,150 --> 00:17:23,029

 

518
00:17:23,029 --> 00:17:23,039

 

519
00:17:23,039 --> 00:17:23,990


520
00:17:23,990 --> 00:17:26,789

 

521
00:17:26,789 --> 00:17:28,950

 

522
00:17:28,950 --> 00:17:30,630

 

523
00:17:30,630 --> 00:17:30,640

 

524
00:17:30,640 --> 00:17:32,710


525
00:17:32,710 --> 00:17:37,029

 

526
00:17:37,029 --> 00:17:38,950

 

527
00:17:38,950 --> 00:17:41,110

 

528
00:17:41,110 --> 00:17:41,120

 

529
00:17:41,120 --> 00:17:41,830


530
00:17:41,830 --> 00:17:43,750

 

531
00:17:43,750 --> 00:17:44,870

 

532
00:17:44,870 --> 00:17:47,029

 

533
00:17:47,029 --> 00:17:49,350

 

534
00:17:49,350 --> 00:17:51,909

 

535
00:17:51,909 --> 00:17:55,110

 

536
00:17:55,110 --> 00:17:57,590

 

537
00:17:57,590 --> 00:17:59,350

 

538
00:17:59,350 --> 00:18:02,630

 

539
00:18:02,630 --> 00:18:04,390

 

540
00:18:04,390 --> 00:18:07,510

 

541
00:18:07,510 --> 00:18:09,830

 

542
00:18:09,830 --> 00:18:09,840

 

543
00:18:09,840 --> 00:18:12,230


544
00:18:12,230 --> 00:18:14,470

 

545
00:18:14,470 --> 00:18:16,390

 

546
00:18:16,390 --> 00:18:18,470

 

547
00:18:18,470 --> 00:18:20,470

 

548
00:18:20,470 --> 00:18:22,470

 

549
00:18:22,470 --> 00:18:25,990

 

550
00:18:25,990 --> 00:18:26,000

 

551
00:18:26,000 --> 00:18:27,029


552
00:18:27,029 --> 00:18:28,470

 

553
00:18:28,470 --> 00:18:31,750

 

554
00:18:31,750 --> 00:18:34,710

 

555
00:18:34,710 --> 00:18:34,720

 

556
00:18:34,720 --> 00:18:36,070


557
00:18:36,070 --> 00:18:38,710

 

558
00:18:38,710 --> 00:18:38,720

 

559
00:18:38,720 --> 00:18:40,230


560
00:18:40,230 --> 00:18:44,230

 

561
00:18:44,230 --> 00:18:47,190

 

562
00:18:47,190 --> 00:18:50,789

 

563
00:18:50,789 --> 00:18:53,029

 

564
00:18:53,029 --> 00:18:56,150

 

565
00:18:56,150 --> 00:18:58,310

 

566
00:18:58,310 --> 00:19:00,070

 

567
00:19:00,070 --> 00:19:02,150

 

568
00:19:02,150 --> 00:19:03,750

 

569
00:19:03,750 --> 00:19:05,270

 

570
00:19:05,270 --> 00:19:07,510

 

571
00:19:07,510 --> 00:19:10,710

 

572
00:19:10,710 --> 00:19:13,190

 

573
00:19:13,190 --> 00:19:13,200

 

574
00:19:13,200 --> 00:19:14,230


575
00:19:14,230 --> 00:19:14,240

 

576
00:19:14,240 --> 00:19:16,390


577
00:19:16,390 --> 00:19:20,549

 

578
00:19:20,549 --> 00:19:22,549

 

579
00:19:22,549 --> 00:19:24,470

 

580
00:19:24,470 --> 00:19:26,870

 

581
00:19:26,870 --> 00:19:28,710

 

582
00:19:28,710 --> 00:19:28,720

 

583
00:19:28,720 --> 00:19:29,669


584
00:19:29,669 --> 00:19:33,029

 

585
00:19:33,029 --> 00:19:34,789

 

586
00:19:34,789 --> 00:19:34,799

 

587
00:19:34,799 --> 00:19:36,230


588
00:19:36,230 --> 00:19:39,430

 

589
00:19:39,430 --> 00:19:40,950

 

590
00:19:40,950 --> 00:19:43,990

 

591
00:19:43,990 --> 00:19:46,310

 

592
00:19:46,310 --> 00:19:48,230

 

593
00:19:48,230 --> 00:19:50,789

 

594
00:19:50,789 --> 00:19:53,190

 

595
00:19:53,190 --> 00:19:53,200

 

596
00:19:53,200 --> 00:19:54,230


597
00:19:54,230 --> 00:19:56,150

 

598
00:19:56,150 --> 00:19:58,070

 

599
00:19:58,070 --> 00:19:59,590

 

600
00:19:59,590 --> 00:20:02,789

 

601
00:20:02,789 --> 00:20:04,789

 

602
00:20:04,789 --> 00:20:07,190

 

603
00:20:07,190 --> 00:20:08,710

 

604
00:20:08,710 --> 00:20:10,390

 

605
00:20:10,390 --> 00:20:10,400

 

606
00:20:10,400 --> 00:20:11,430


607
00:20:11,430 --> 00:20:13,029

 

608
00:20:13,029 --> 00:20:13,039

 

609
00:20:13,039 --> 00:20:14,149


610
00:20:14,149 --> 00:20:14,159

 

611
00:20:14,159 --> 00:20:15,669


612
00:20:15,669 --> 00:20:17,830

 

613
00:20:17,830 --> 00:20:20,470

 

614
00:20:20,470 --> 00:20:22,470

 

615
00:20:22,470 --> 00:20:23,990

 

616
00:20:23,990 --> 00:20:27,190

 

617
00:20:27,190 --> 00:20:29,510

 

618
00:20:29,510 --> 00:20:31,430

 

619
00:20:31,430 --> 00:20:33,270

 

620
00:20:33,270 --> 00:20:35,029

 

621
00:20:35,029 --> 00:20:37,029

 

622
00:20:37,029 --> 00:20:39,350

 

623
00:20:39,350 --> 00:20:40,310

 

624
00:20:40,310 --> 00:20:41,830

 

625
00:20:41,830 --> 00:20:43,830

 

626
00:20:43,830 --> 00:20:46,230

 

627
00:20:46,230 --> 00:20:48,149

 

628
00:20:48,149 --> 00:20:48,159

 

629
00:20:48,159 --> 00:20:49,190


630
00:20:49,190 --> 00:20:50,950

 

631
00:20:50,950 --> 00:20:53,909

 

632
00:20:53,909 --> 00:20:56,470

 

633
00:20:56,470 --> 00:20:58,070

 

634
00:20:58,070 --> 00:20:59,990

 

635
00:20:59,990 --> 00:21:01,430

 

636
00:21:01,430 --> 00:21:03,029

 

637
00:21:03,029 --> 00:21:04,870

 

638
00:21:04,870 --> 00:21:04,880

 

639
00:21:04,880 --> 00:21:05,669


640
00:21:05,669 --> 00:21:07,510

 

641
00:21:07,510 --> 00:21:09,430

 

642
00:21:09,430 --> 00:21:11,110

 

643
00:21:11,110 --> 00:21:13,270

 

644
00:21:13,270 --> 00:21:14,950

 

645
00:21:14,950 --> 00:21:17,830

 

646
00:21:17,830 --> 00:21:19,590

 

647
00:21:19,590 --> 00:21:21,669

 

648
00:21:21,669 --> 00:21:23,590

 

649
00:21:23,590 --> 00:21:24,870

 

650
00:21:24,870 --> 00:21:27,110

 

651
00:21:27,110 --> 00:21:30,070

 

652
00:21:30,070 --> 00:21:32,070

 

653
00:21:32,070 --> 00:21:35,029

 

654
00:21:35,029 --> 00:21:35,039

 

655
00:21:35,039 --> 00:21:35,830


656
00:21:35,830 --> 00:21:37,510

 

657
00:21:37,510 --> 00:21:39,990

 

658
00:21:39,990 --> 00:21:41,510

 

659
00:21:41,510 --> 00:21:42,950

 

660
00:21:42,950 --> 00:21:44,549

 

661
00:21:44,549 --> 00:21:46,870

 

662
00:21:46,870 --> 00:21:48,549

 

663
00:21:48,549 --> 00:21:51,190

 

664
00:21:51,190 --> 00:21:51,200

 

665
00:21:51,200 --> 00:21:53,350


666
00:21:53,350 --> 00:21:54,870

 

667
00:21:54,870 --> 00:21:57,270

 

668
00:21:57,270 --> 00:21:59,029

 

669
00:21:59,029 --> 00:22:01,590

 

670
00:22:01,590 --> 00:22:03,510

 

671
00:22:03,510 --> 00:22:05,270

 

672
00:22:05,270 --> 00:22:05,280

 

673
00:22:05,280 --> 00:22:06,230


674
00:22:06,230 --> 00:22:08,789

 

675
00:22:08,789 --> 00:22:11,110

 

676
00:22:11,110 --> 00:22:11,120

 

677
00:22:11,120 --> 00:22:12,710


678
00:22:12,710 --> 00:22:15,270

 

679
00:22:15,270 --> 00:22:16,710

 

680
00:22:16,710 --> 00:22:18,950

 

681
00:22:18,950 --> 00:22:21,590

 

682
00:22:21,590 --> 00:22:23,590

 

683
00:22:23,590 --> 00:22:25,669

 

684
00:22:25,669 --> 00:22:27,350

 

685
00:22:27,350 --> 00:22:29,669

 

686
00:22:29,669 --> 00:22:31,990

 

687
00:22:31,990 --> 00:22:33,590

 

688
00:22:33,590 --> 00:22:33,600

 

689
00:22:33,600 --> 00:22:35,430


690
00:22:35,430 --> 00:22:37,990

 

691
00:22:37,990 --> 00:22:39,510

 

692
00:22:39,510 --> 00:22:41,190

 

693
00:22:41,190 --> 00:22:42,870

 

694
00:22:42,870 --> 00:22:44,870

 

695
00:22:44,870 --> 00:22:46,630

 

696
00:22:46,630 --> 00:22:48,789

 

697
00:22:48,789 --> 00:22:50,789

 

698
00:22:50,789 --> 00:22:50,799

 

699
00:22:50,799 --> 00:22:51,750


700
00:22:51,750 --> 00:22:51,760

 

701
00:22:51,760 --> 00:22:52,870


702
00:22:52,870 --> 00:22:55,110

 

703
00:22:55,110 --> 00:22:55,120

 

704
00:22:55,120 --> 00:22:56,070


705
00:22:56,070 --> 00:22:56,080

 

706
00:22:56,080 --> 00:22:57,110


707
00:22:57,110 --> 00:22:59,350

 

708
00:22:59,350 --> 00:23:02,870

 

709
00:23:02,870 --> 00:23:06,710

 

710
00:23:06,710 --> 00:23:09,830

 

711
00:23:09,830 --> 00:23:11,909

 

712
00:23:11,909 --> 00:23:15,029

 

713
00:23:15,029 --> 00:23:17,510

 

714
00:23:17,510 --> 00:23:19,590

 

715
00:23:19,590 --> 00:23:21,110

 

716
00:23:21,110 --> 00:23:23,590

 

717
00:23:23,590 --> 00:23:25,990

 

718
00:23:25,990 --> 00:23:28,470

 

719
00:23:28,470 --> 00:23:30,149

 

720
00:23:30,149 --> 00:23:31,669

 

721
00:23:31,669 --> 00:23:33,510

 

722
00:23:33,510 --> 00:23:35,350

 

723
00:23:35,350 --> 00:23:37,669

 

724
00:23:37,669 --> 00:23:39,669

 

725
00:23:39,669 --> 00:23:41,350

 

726
00:23:41,350 --> 00:23:43,029

 

727
00:23:43,029 --> 00:23:45,510

 

728
00:23:45,510 --> 00:23:47,269

 

729
00:23:47,269 --> 00:23:48,390

 

730
00:23:48,390 --> 00:23:49,990

 

731
00:23:49,990 --> 00:23:53,110

 

732
00:23:53,110 --> 00:23:54,789

 

733
00:23:54,789 --> 00:23:54,799

 

734
00:23:54,799 --> 00:23:55,669


735
00:23:55,669 --> 00:23:57,350

 

736
00:23:57,350 --> 00:24:00,149

 

737
00:24:00,149 --> 00:24:02,070

 

738
00:24:02,070 --> 00:24:04,630

 

739
00:24:04,630 --> 00:24:06,950

 

740
00:24:06,950 --> 00:24:08,789

 

741
00:24:08,789 --> 00:24:08,799

 

742
00:24:08,799 --> 00:24:09,830


743
00:24:09,830 --> 00:24:09,840

 

744
00:24:09,840 --> 00:24:11,110


745
00:24:11,110 --> 00:24:14,950

 

746
00:24:14,950 --> 00:24:17,510

 

747
00:24:17,510 --> 00:24:19,669

 

748
00:24:19,669 --> 00:24:21,750

 

749
00:24:21,750 --> 00:24:21,760

 

750
00:24:21,760 --> 00:24:23,110


751
00:24:23,110 --> 00:24:25,350

 

752
00:24:25,350 --> 00:24:27,190

 

753
00:24:27,190 --> 00:24:29,190

 

754
00:24:29,190 --> 00:24:31,190

 

755
00:24:31,190 --> 00:24:33,110

 

756
00:24:33,110 --> 00:24:34,230

 

757
00:24:34,230 --> 00:24:36,549

 

758
00:24:36,549 --> 00:24:38,310

 

759
00:24:38,310 --> 00:24:41,029

 

760
00:24:41,029 --> 00:24:43,430

 

761
00:24:43,430 --> 00:24:44,549

 

762
00:24:44,549 --> 00:24:47,669

 

763
00:24:47,669 --> 00:24:49,830

 

764
00:24:49,830 --> 00:24:51,190

 

765
00:24:51,190 --> 00:24:54,470

 

766
00:24:54,470 --> 00:24:57,590

 

767
00:24:57,590 --> 00:24:59,590

 

768
00:24:59,590 --> 00:24:59,600

 

769
00:24:59,600 --> 00:25:02,310


770
00:25:02,310 --> 00:25:04,230

 

771
00:25:04,230 --> 00:25:06,470

 

772
00:25:06,470 --> 00:25:09,510

 

773
00:25:09,510 --> 00:25:11,430

 

774
00:25:11,430 --> 00:25:14,630

 

775
00:25:14,630 --> 00:25:16,149

 

776
00:25:16,149 --> 00:25:16,159

 

777
00:25:16,159 --> 00:25:17,590


778
00:25:17,590 --> 00:25:20,390

 

779
00:25:20,390 --> 00:25:20,400

 

780
00:25:20,400 --> 00:25:21,269


781
00:25:21,269 --> 00:25:22,549

 

782
00:25:22,549 --> 00:25:24,390

 

783
00:25:24,390 --> 00:25:27,029

 

784
00:25:27,029 --> 00:25:29,110

 

785
00:25:29,110 --> 00:25:29,120

 

786
00:25:29,120 --> 00:25:30,070


787
00:25:30,070 --> 00:25:32,390

 

788
00:25:32,390 --> 00:25:32,400

 

789
00:25:32,400 --> 00:25:34,470


790
00:25:34,470 --> 00:25:36,789

 

791
00:25:36,789 --> 00:25:39,510

 

792
00:25:39,510 --> 00:25:40,950

 

793
00:25:40,950 --> 00:25:43,830

 

794
00:25:43,830 --> 00:25:47,750

 

795
00:25:47,750 --> 00:25:51,190

 

796
00:25:51,190 --> 00:25:54,149

 

797
00:25:54,149 --> 00:25:57,830

 

798
00:25:57,830 --> 00:25:58,870

 

799
00:25:58,870 --> 00:26:01,750

 

800
00:26:01,750 --> 00:26:04,470

 

801
00:26:04,470 --> 00:26:08,870

 

802
00:26:08,870 --> 00:26:12,390

 

803
00:26:12,390 --> 00:26:14,230

 

804
00:26:14,230 --> 00:26:16,310

 

805
00:26:16,310 --> 00:26:17,830

 

806
00:26:17,830 --> 00:26:19,590

 

807
00:26:19,590 --> 00:26:22,630

 

808
00:26:22,630 --> 00:26:24,149

 

809
00:26:24,149 --> 00:26:26,149

 

810
00:26:26,149 --> 00:26:27,750

 

811
00:26:27,750 --> 00:26:29,269

 

812
00:26:29,269 --> 00:26:30,630

 

813
00:26:30,630 --> 00:26:32,310

 

814
00:26:32,310 --> 00:26:33,750

 

815
00:26:33,750 --> 00:26:35,830

 

816
00:26:35,830 --> 00:26:38,470

 

817
00:26:38,470 --> 00:26:40,149

 

818
00:26:40,149 --> 00:26:41,750

 

819
00:26:41,750 --> 00:26:46,710

 

820
00:26:46,710 --> 00:26:49,750

 

821
00:26:49,750 --> 00:26:52,070

 

822
00:26:52,070 --> 00:26:53,830

 

823
00:26:53,830 --> 00:26:56,230

 

824
00:26:56,230 --> 00:26:56,240

 

825
00:26:56,240 --> 00:26:57,269


826
00:26:57,269 --> 00:26:57,279

 

827
00:26:57,279 --> 00:26:58,870


828
00:26:58,870 --> 00:27:00,789

 

829
00:27:00,789 --> 00:27:02,789

 

830
00:27:02,789 --> 00:27:04,310

 

831
00:27:04,310 --> 00:27:08,630

 

832
00:27:08,630 --> 00:27:08,640

 

833
00:27:08,640 --> 00:27:09,430


834
00:27:09,430 --> 00:27:11,990

 

835
00:27:11,990 --> 00:27:13,590

 

836
00:27:13,590 --> 00:27:16,070

 

837
00:27:16,070 --> 00:27:19,110

 

838
00:27:19,110 --> 00:27:20,710

 

839
00:27:20,710 --> 00:27:22,630

 

840
00:27:22,630 --> 00:27:24,149

 

841
00:27:24,149 --> 00:27:25,669

 

842
00:27:25,669 --> 00:27:27,269

 

843
00:27:27,269 --> 00:27:29,190

 

844
00:27:29,190 --> 00:27:30,710

 

845
00:27:30,710 --> 00:27:31,990

 

846
00:27:31,990 --> 00:27:33,669

 

847
00:27:33,669 --> 00:27:35,110

 

848
00:27:35,110 --> 00:27:37,350

 

849
00:27:37,350 --> 00:27:41,669

 

850
00:27:41,669 --> 00:27:44,630

 

851
00:27:44,630 --> 00:27:46,230

 

852
00:27:46,230 --> 00:27:48,549

 

853
00:27:48,549 --> 00:27:52,630

 

854
00:27:52,630 --> 00:27:56,070

 

855
00:27:56,070 --> 00:27:57,830

 

856
00:27:57,830 --> 00:27:59,909

 

857
00:27:59,909 --> 00:28:01,669

 

858
00:28:01,669 --> 00:28:04,149

 

859
00:28:04,149 --> 00:28:06,870

 

860
00:28:06,870 --> 00:28:08,310

 

861
00:28:08,310 --> 00:28:10,070

 

862
00:28:10,070 --> 00:28:10,080

 

863
00:28:10,080 --> 00:28:11,269


864
00:28:11,269 --> 00:28:13,830

 

865
00:28:13,830 --> 00:28:13,840

 

866
00:28:13,840 --> 00:28:15,350


867
00:28:15,350 --> 00:28:16,870

 

868
00:28:16,870 --> 00:28:19,830

 

869
00:28:19,830 --> 00:28:22,310

 

870
00:28:22,310 --> 00:28:25,350

 

871
00:28:25,350 --> 00:28:29,190

 

872
00:28:29,190 --> 00:28:30,789

 

873
00:28:30,789 --> 00:28:33,350

 

874
00:28:33,350 --> 00:28:33,360

 

875
00:28:33,360 --> 00:28:35,190


876
00:28:35,190 --> 00:28:36,870

 

877
00:28:36,870 --> 00:28:38,630

 

878
00:28:38,630 --> 00:28:40,870

 

879
00:28:40,870 --> 00:28:40,880

 

880
00:28:40,880 --> 00:28:42,070


881
00:28:42,070 --> 00:28:42,080

 

882
00:28:42,080 --> 00:28:43,350


883
00:28:43,350 --> 00:28:43,360

 

884
00:28:43,360 --> 00:28:44,389


885
00:28:44,389 --> 00:28:47,110

 

886
00:28:47,110 --> 00:28:47,120

 

887
00:28:47,120 --> 00:28:47,990


888
00:28:47,990 --> 00:28:50,389

 

889
00:28:50,389 --> 00:28:51,750

 

890
00:28:51,750 --> 00:28:53,190

 

891
00:28:53,190 --> 00:28:55,110

 

892
00:28:55,110 --> 00:28:57,909

 

893
00:28:57,909 --> 00:29:00,230

 

894
00:29:00,230 --> 00:29:02,789

 

895
00:29:02,789 --> 00:29:06,950

 

896
00:29:06,950 --> 00:29:08,950

 

897
00:29:08,950 --> 00:29:10,630

 

898
00:29:10,630 --> 00:29:13,110

 

899
00:29:13,110 --> 00:29:15,110

 

900
00:29:15,110 --> 00:29:17,669

 

901
00:29:17,669 --> 00:29:19,909

 

902
00:29:19,909 --> 00:29:23,029

 

903
00:29:23,029 --> 00:29:24,950

 

904
00:29:24,950 --> 00:29:28,789

 

905
00:29:28,789 --> 00:29:32,230

 

906
00:29:32,230 --> 00:29:34,789

 

907
00:29:34,789 --> 00:29:36,470

 

908
00:29:36,470 --> 00:29:37,669

 

909
00:29:37,669 --> 00:29:43,269

 

910
00:29:43,269 --> 00:29:44,789

 

911
00:29:44,789 --> 00:29:46,549

 

912
00:29:46,549 --> 00:29:48,470

 

913
00:29:48,470 --> 00:29:48,480

 

914
00:29:48,480 --> 00:29:49,830


915
00:29:49,830 --> 00:29:52,389

 

916
00:29:52,389 --> 00:29:54,470

 

917
00:29:54,470 --> 00:29:59,110

 

918
00:29:59,110 --> 00:30:01,590

 

919
00:30:01,590 --> 00:30:01,600

 

920
00:30:01,600 --> 00:30:02,470


921
00:30:02,470 --> 00:30:04,230

 

922
00:30:04,230 --> 00:30:04,240

 

923
00:30:04,240 --> 00:30:05,110


924
00:30:05,110 --> 00:30:06,630

 

925
00:30:06,630 --> 00:30:07,990

 

926
00:30:07,990 --> 00:30:10,389

 

927
00:30:10,389 --> 00:30:12,389

 

928
00:30:12,389 --> 00:30:14,470

 

929
00:30:14,470 --> 00:30:14,480

 

930
00:30:14,480 --> 00:30:15,669


931
00:30:15,669 --> 00:30:18,470

 

932
00:30:18,470 --> 00:30:20,070

 

933
00:30:20,070 --> 00:30:20,080

 

934
00:30:20,080 --> 00:30:23,029


935
00:30:23,029 --> 00:30:23,039

 

936
00:30:23,039 --> 00:30:24,710


937
00:30:24,710 --> 00:30:26,710

 

938
00:30:26,710 --> 00:30:27,990

 

939
00:30:27,990 --> 00:30:28,000

 

940
00:30:28,000 --> 00:30:30,070


941
00:30:30,070 --> 00:30:32,470

 

942
00:30:32,470 --> 00:30:34,230

 

943
00:30:34,230 --> 00:30:35,990

 

944
00:30:35,990 --> 00:30:39,190

 

945
00:30:39,190 --> 00:30:41,110

 

946
00:30:41,110 --> 00:30:42,389

 

947
00:30:42,389 --> 00:30:45,029

 

948
00:30:45,029 --> 00:30:47,590

 

949
00:30:47,590 --> 00:30:50,710

 

950
00:30:50,710 --> 00:30:50,720

 

951
00:30:50,720 --> 00:30:51,430


952
00:30:51,430 --> 00:30:53,350

 

953
00:30:53,350 --> 00:30:55,830

 

954
00:30:55,830 --> 00:30:57,669

 

955
00:30:57,669 --> 00:30:57,679

 

956
00:30:57,679 --> 00:30:59,190


957
00:30:59,190 --> 00:31:01,990

 

958
00:31:01,990 --> 00:31:04,470

 

959
00:31:04,470 --> 00:31:07,110

 

960
00:31:07,110 --> 00:31:09,909

 

961
00:31:09,909 --> 00:31:12,549

 

962
00:31:12,549 --> 00:31:14,070

 

963
00:31:14,070 --> 00:31:15,350

 

964
00:31:15,350 --> 00:31:17,269

 

965
00:31:17,269 --> 00:31:19,110

 

966
00:31:19,110 --> 00:31:20,789

 

967
00:31:20,789 --> 00:31:22,630

 

968
00:31:22,630 --> 00:31:25,110

 

969
00:31:25,110 --> 00:31:27,909

 

970
00:31:27,909 --> 00:31:29,669

 

971
00:31:29,669 --> 00:31:31,830

 

972
00:31:31,830 --> 00:31:33,509

 

973
00:31:33,509 --> 00:31:35,350

 

974
00:31:35,350 --> 00:31:37,830

 

975
00:31:37,830 --> 00:31:39,590

 

976
00:31:39,590 --> 00:31:41,590

 

977
00:31:41,590 --> 00:31:41,600

 

978
00:31:41,600 --> 00:31:42,310


979
00:31:42,310 --> 00:31:44,230

 

980
00:31:44,230 --> 00:31:46,950

 

981
00:31:46,950 --> 00:31:49,269

 

982
00:31:49,269 --> 00:31:51,509

 

983
00:31:51,509 --> 00:31:53,190

 

984
00:31:53,190 --> 00:31:55,830

 

985
00:31:55,830 --> 00:31:58,070

 

986
00:31:58,070 --> 00:32:00,630

 

987
00:32:00,630 --> 00:32:04,070

 

988
00:32:04,070 --> 00:32:06,549

 

989
00:32:06,549 --> 00:32:08,549

 

990
00:32:08,549 --> 00:32:08,559

 

991
00:32:08,559 --> 00:32:09,509


992
00:32:09,509 --> 00:32:10,549

 

993
00:32:10,549 --> 00:32:12,470

 

994
00:32:12,470 --> 00:32:16,710

 

995
00:32:16,710 --> 00:32:16,720

 

996
00:32:16,720 --> 00:32:17,669


997
00:32:17,669 --> 00:32:20,310

 

998
00:32:20,310 --> 00:32:22,389

 

999
00:32:22,389 --> 00:32:23,750

 

1000
00:32:23,750 --> 00:32:25,669

 

1001
00:32:25,669 --> 00:32:28,230

 

1002
00:32:28,230 --> 00:32:30,549

 

1003
00:32:30,549 --> 00:32:32,389

 

1004
00:32:32,389 --> 00:32:34,710

 

1005
00:32:34,710 --> 00:32:36,230

 

1006
00:32:36,230 --> 00:32:37,669

 

1007
00:32:37,669 --> 00:32:39,430

 

1008
00:32:39,430 --> 00:32:40,710

 

1009
00:32:40,710 --> 00:32:43,110

 

1010
00:32:43,110 --> 00:32:45,190

 

1011
00:32:45,190 --> 00:32:49,750

 

1012
00:32:49,750 --> 00:32:51,430

 

1013
00:32:51,430 --> 00:32:53,110

 

1014
00:32:53,110 --> 00:32:55,350

 

1015
00:32:55,350 --> 00:32:55,360

 

1016
00:32:55,360 --> 00:32:57,430


1017
00:32:57,430 --> 00:32:59,430

 

1018
00:32:59,430 --> 00:33:01,590

 

1019
00:33:01,590 --> 00:33:03,909

 

1020
00:33:03,909 --> 00:33:06,630

 

1021
00:33:06,630 --> 00:33:08,950

 

1022
00:33:08,950 --> 00:33:13,190

 

1023
00:33:13,190 --> 00:33:15,190

 

1024
00:33:15,190 --> 00:33:16,870

 

1025
00:33:16,870 --> 00:33:19,190

 

1026
00:33:19,190 --> 00:33:20,789

 

1027
00:33:20,789 --> 00:33:22,630

 

1028
00:33:22,630 --> 00:33:25,509

 

1029
00:33:25,509 --> 00:33:25,519

 

1030
00:33:25,519 --> 00:33:26,389


1031
00:33:26,389 --> 00:33:28,470

 

1032
00:33:28,470 --> 00:33:30,310

 

1033
00:33:30,310 --> 00:33:32,870

 

1034
00:33:32,870 --> 00:33:34,630

 

1035
00:33:34,630 --> 00:33:34,640

 

1036
00:33:34,640 --> 00:33:35,430


1037
00:33:35,430 --> 00:33:37,509

 

1038
00:33:37,509 --> 00:33:39,590

 

1039
00:33:39,590 --> 00:33:40,789

 

1040
00:33:40,789 --> 00:33:42,549

 

1041
00:33:42,549 --> 00:33:44,549

 

1042
00:33:44,549 --> 00:33:46,470

 

1043
00:33:46,470 --> 00:33:48,710

 

1044
00:33:48,710 --> 00:33:50,070

 

1045
00:33:50,070 --> 00:33:51,669

 

1046
00:33:51,669 --> 00:33:53,830

 

1047
00:33:53,830 --> 00:33:57,830

 

1048
00:33:57,830 --> 00:33:59,269

 

1049
00:33:59,269 --> 00:34:01,350

 

1050
00:34:01,350 --> 00:34:03,830

 

1051
00:34:03,830 --> 00:34:05,669

 

1052
00:34:05,669 --> 00:34:05,679

 

1053
00:34:05,679 --> 00:34:06,630


1054
00:34:06,630 --> 00:34:06,640

 

1055
00:34:06,640 --> 00:34:09,190


1056
00:34:09,190 --> 00:34:11,270

 

1057
00:34:11,270 --> 00:34:12,790

 

1058
00:34:12,790 --> 00:34:14,470

 

1059
00:34:14,470 --> 00:34:14,480

 

1060
00:34:14,480 --> 00:34:17,349


1061
00:34:17,349 --> 00:34:20,470

 

1062
00:34:20,470 --> 00:34:22,470

 

1063
00:34:22,470 --> 00:34:22,480

 

1064
00:34:22,480 --> 00:34:23,990


1065
00:34:23,990 --> 00:34:25,990

 

1066
00:34:25,990 --> 00:34:28,550

 

1067
00:34:28,550 --> 00:34:30,069

 

1068
00:34:30,069 --> 00:34:32,829

 

1069
00:34:32,829 --> 00:34:32,839

 

1070
00:34:32,839 --> 00:34:34,389


1071
00:34:34,389 --> 00:34:36,629

 

1072
00:34:36,629 --> 00:34:38,310

 

1073
00:34:38,310 --> 00:34:40,629

 

1074
00:34:40,629 --> 00:34:42,389

 

1075
00:34:42,389 --> 00:34:43,909

 

1076
00:34:43,909 --> 00:34:45,669

 

1077
00:34:45,669 --> 00:34:47,829

 

1078
00:34:47,829 --> 00:34:49,430

 

1079
00:34:49,430 --> 00:34:50,950

 

1080
00:34:50,950 --> 00:34:53,750

 

1081
00:34:53,750 --> 00:34:55,589

 

1082
00:34:55,589 --> 00:34:58,390

 

1083
00:34:58,390 --> 00:35:00,150

 

1084
00:35:00,150 --> 00:35:01,670

 

1085
00:35:01,670 --> 00:35:04,870

 

1086
00:35:04,870 --> 00:35:07,589

 

1087
00:35:07,589 --> 00:35:09,670

 

1088
00:35:09,670 --> 00:35:11,910

 

1089
00:35:11,910 --> 00:35:11,920

 

1090
00:35:11,920 --> 00:35:12,710


1091
00:35:12,710 --> 00:35:14,710

 

1092
00:35:14,710 --> 00:35:16,630

 

1093
00:35:16,630 --> 00:35:19,270

 

1094
00:35:19,270 --> 00:35:21,990

 

1095
00:35:21,990 --> 00:35:23,349

 

1096
00:35:23,349 --> 00:35:25,030

 

1097
00:35:25,030 --> 00:35:27,030

 

1098
00:35:27,030 --> 00:35:29,349

 

1099
00:35:29,349 --> 00:35:31,990

 

1100
00:35:31,990 --> 00:35:33,829

 

1101
00:35:33,829 --> 00:35:35,270

 

1102
00:35:35,270 --> 00:35:37,190

 

1103
00:35:37,190 --> 00:35:38,950

 

1104
00:35:38,950 --> 00:35:40,630

 

1105
00:35:40,630 --> 00:35:42,829

 

1106
00:35:42,829 --> 00:35:45,430

 

1107
00:35:45,430 --> 00:35:48,069

 

1108
00:35:48,069 --> 00:35:50,310

 

1109
00:35:50,310 --> 00:35:51,750

 

1110
00:35:51,750 --> 00:35:54,870

 

1111
00:35:54,870 --> 00:35:57,270

 

1112
00:35:57,270 --> 00:35:59,510

 

1113
00:35:59,510 --> 00:36:01,990

 

1114
00:36:01,990 --> 00:36:03,589

 

1115
00:36:03,589 --> 00:36:06,069

 

1116
00:36:06,069 --> 00:36:08,150

 

1117
00:36:08,150 --> 00:36:09,349

 

1118
00:36:09,349 --> 00:36:10,790

 

1119
00:36:10,790 --> 00:36:14,069

 

1120
00:36:14,069 --> 00:36:16,150

 

1121
00:36:16,150 --> 00:36:17,750

 

1122
00:36:17,750 --> 00:36:19,670

 

1123
00:36:19,670 --> 00:36:21,030

 

1124
00:36:21,030 --> 00:36:22,710

 

1125
00:36:22,710 --> 00:36:24,470

 

1126
00:36:24,470 --> 00:36:26,870

 

1127
00:36:26,870 --> 00:36:28,230

 

1128
00:36:28,230 --> 00:36:31,589

 

1129
00:36:31,589 --> 00:36:33,910

 

1130
00:36:33,910 --> 00:36:33,920

 

1131
00:36:33,920 --> 00:36:35,349


1132
00:36:35,349 --> 00:36:38,470

 

1133
00:36:38,470 --> 00:36:40,950

 

1134
00:36:40,950 --> 00:36:44,870

 

1135
00:36:44,870 --> 00:36:46,950

 

1136
00:36:46,950 --> 00:36:48,150

 

1137
00:36:48,150 --> 00:36:50,630

 

1138
00:36:50,630 --> 00:36:50,640

 

1139
00:36:50,640 --> 00:36:52,069


1140
00:36:52,069 --> 00:36:55,910

 

1141
00:36:55,910 --> 00:36:58,069

 

1142
00:36:58,069 --> 00:37:00,550

 

1143
00:37:00,550 --> 00:37:03,109

 

1144
00:37:03,109 --> 00:37:04,950

 

1145
00:37:04,950 --> 00:37:06,390

 

1146
00:37:06,390 --> 00:37:08,310

 

1147
00:37:08,310 --> 00:37:09,990

 

1148
00:37:09,990 --> 00:37:11,589

 

1149
00:37:11,589 --> 00:37:13,589

 

1150
00:37:13,589 --> 00:37:13,599

 

1151
00:37:13,599 --> 00:37:15,430


1152
00:37:15,430 --> 00:37:17,670

 

1153
00:37:17,670 --> 00:37:20,950

 

1154
00:37:20,950 --> 00:37:22,310

 

1155
00:37:22,310 --> 00:37:24,150

 

1156
00:37:24,150 --> 00:37:26,150

 

1157
00:37:26,150 --> 00:37:28,230

 

1158
00:37:28,230 --> 00:37:30,870

 

1159
00:37:30,870 --> 00:37:32,950

 

1160
00:37:32,950 --> 00:37:35,109

 

1161
00:37:35,109 --> 00:37:35,119

 

1162
00:37:35,119 --> 00:37:36,790


1163
00:37:36,790 --> 00:37:36,800

 

1164
00:37:36,800 --> 00:37:37,990


1165
00:37:37,990 --> 00:37:39,910

 

1166
00:37:39,910 --> 00:37:39,920

 

1167
00:37:39,920 --> 00:37:42,870


1168
00:37:42,870 --> 00:37:42,880

 

1169
00:37:42,880 --> 00:37:44,470


1170
00:37:44,470 --> 00:37:46,310

 

1171
00:37:46,310 --> 00:37:46,320

 

1172
00:37:46,320 --> 00:37:47,910


1173
00:37:47,910 --> 00:37:47,920

 

1174
00:37:47,920 --> 00:37:53,589


1175
00:37:53,589 --> 00:37:59,109

 

1176
00:37:59,109 --> 00:38:03,510

 

1177
00:38:03,510 --> 00:38:05,030

 

1178
00:38:05,030 --> 00:38:06,069

 

1179
00:38:06,069 --> 00:38:07,670

 

1180
00:38:07,670 --> 00:38:07,680

 

1181
00:38:07,680 --> 00:38:09,190


1182
00:38:09,190 --> 00:38:09,200

 

1183
00:38:09,200 --> 00:38:12,550


1184
00:38:12,550 --> 00:38:12,560

 

1185
00:38:12,560 --> 00:38:13,510


1186
00:38:13,510 --> 00:38:18,710

 

1187
00:38:18,710 --> 00:38:18,720

 

1188
00:38:18,720 --> 00:38:19,750


1189
00:38:19,750 --> 00:38:22,390

 

1190
00:38:22,390 --> 00:38:25,270

 

1191
00:38:25,270 --> 00:38:27,270

 

1192
00:38:27,270 --> 00:38:32,230

 

1193
00:38:32,230 --> 00:38:32,240

 

1194
00:38:32,240 --> 00:38:33,349


1195
00:38:33,349 --> 00:38:35,190

 

1196
00:38:35,190 --> 00:38:38,310

 

1197
00:38:38,310 --> 00:38:40,150

 

1198
00:38:40,150 --> 00:38:42,550

 

1199
00:38:42,550 --> 00:38:44,829

 

1200
00:38:44,829 --> 00:38:48,230

 

1201
00:38:48,230 --> 00:38:50,550

 

1202
00:38:50,550 --> 00:38:52,310

 

1203
00:38:52,310 --> 00:38:54,630

 

1204
00:38:54,630 --> 00:38:57,430

 

1205
00:38:57,430 --> 00:39:00,390

 

1206
00:39:00,390 --> 00:39:02,630

 

1207
00:39:02,630 --> 00:39:04,390

 

1208
00:39:04,390 --> 00:39:05,430

 

1209
00:39:05,430 --> 00:39:07,349

 

1210
00:39:07,349 --> 00:39:10,150

 

1211
00:39:10,150 --> 00:39:12,390

 

1212
00:39:12,390 --> 00:39:15,349

 

1213
00:39:15,349 --> 00:39:17,430

 

1214
00:39:17,430 --> 00:39:21,109

 

1215
00:39:21,109 --> 00:39:23,270

 

1216
00:39:23,270 --> 00:39:26,230

 

1217
00:39:26,230 --> 00:39:28,950

 

1218
00:39:28,950 --> 00:39:32,470

 

1219
00:39:32,470 --> 00:39:35,349

 

1220
00:39:35,349 --> 00:39:38,790

 

1221
00:39:38,790 --> 00:39:38,800

 

1222
00:39:38,800 --> 00:39:40,710


1223
00:39:40,710 --> 00:39:43,270

 

1224
00:39:43,270 --> 00:39:43,280

 

1225
00:39:43,280 --> 00:39:46,230


1226
00:39:46,230 --> 00:39:49,030

 

1227
00:39:49,030 --> 00:39:53,510

 

1228
00:39:53,510 --> 00:39:53,520

 

1229
00:39:53,520 --> 00:39:57,589


1230
00:39:57,589 --> 00:40:00,710

 

1231
00:40:00,710 --> 00:40:02,150

 

1232
00:40:02,150 --> 00:40:03,910

 

1233
00:40:03,910 --> 00:40:03,920

 

1234
00:40:03,920 --> 00:40:05,030


1235
00:40:05,030 --> 00:40:07,270

 

1236
00:40:07,270 --> 00:40:09,750

 

1237
00:40:09,750 --> 00:40:09,760

 

1238
00:40:09,760 --> 00:40:11,030


1239
00:40:11,030 --> 00:40:12,870

 

1240
00:40:12,870 --> 00:40:14,870

 

1241
00:40:14,870 --> 00:40:17,589

 

1242
00:40:17,589 --> 00:40:18,950

 

1243
00:40:18,950 --> 00:40:22,069

 

1244
00:40:22,069 --> 00:40:25,109

 

1245
00:40:25,109 --> 00:40:28,550

 

1246
00:40:28,550 --> 00:40:29,750

 

1247
00:40:29,750 --> 00:40:31,510

 

1248
00:40:31,510 --> 00:40:33,430

 

1249
00:40:33,430 --> 00:40:35,190

 

1250
00:40:35,190 --> 00:40:36,630

 

1251
00:40:36,630 --> 00:40:38,470

 

1252
00:40:38,470 --> 00:40:40,150

 

1253
00:40:40,150 --> 00:40:42,309

 

1254
00:40:42,309 --> 00:40:43,670

 

1255
00:40:43,670 --> 00:40:46,069

 

1256
00:40:46,069 --> 00:40:48,390

 

1257
00:40:48,390 --> 00:40:51,270

 

1258
00:40:51,270 --> 00:40:53,030

 

1259
00:40:53,030 --> 00:40:54,550

 

1260
00:40:54,550 --> 00:40:56,069

 

1261
00:40:56,069 --> 00:40:57,589

 

1262
00:40:57,589 --> 00:40:59,589

 

1263
00:40:59,589 --> 00:41:02,470

 

1264
00:41:02,470 --> 00:41:04,870

 

1265
00:41:04,870 --> 00:41:06,630

 

1266
00:41:06,630 --> 00:41:09,510

 

1267
00:41:09,510 --> 00:41:09,520

 

1268
00:41:09,520 --> 00:41:10,870


1269
00:41:10,870 --> 00:41:13,190

 

1270
00:41:13,190 --> 00:41:16,309

 

1271
00:41:16,309 --> 00:41:16,319

 

1272
00:41:16,319 --> 00:41:17,190


1273
00:41:17,190 --> 00:41:18,150

 

1274
00:41:18,150 --> 00:41:21,510

 

1275
00:41:21,510 --> 00:41:22,630

 

1276
00:41:22,630 --> 00:41:25,430

 

1277
00:41:25,430 --> 00:41:25,440

 

1278
00:41:25,440 --> 00:41:26,390


1279
00:41:26,390 --> 00:41:27,750

 

1280
00:41:27,750 --> 00:41:29,670

 

1281
00:41:29,670 --> 00:41:32,069

 

1282
00:41:32,069 --> 00:41:34,550

 

1283
00:41:34,550 --> 00:41:34,560

 

1284
00:41:34,560 --> 00:41:35,670


1285
00:41:35,670 --> 00:41:38,069

 

1286
00:41:38,069 --> 00:41:39,670

 

1287
00:41:39,670 --> 00:41:41,670

 

1288
00:41:41,670 --> 00:41:43,670

 

1289
00:41:43,670 --> 00:41:43,680

 

1290
00:41:43,680 --> 00:41:46,230


1291
00:41:46,230 --> 00:41:46,240

 

1292
00:41:46,240 --> 00:41:47,349


1293
00:41:47,349 --> 00:41:48,390

 

1294
00:41:48,390 --> 00:41:48,400

 

1295
00:41:48,400 --> 00:41:49,349


1296
00:41:49,349 --> 00:41:51,270

 

1297
00:41:51,270 --> 00:41:53,430

 

1298
00:41:53,430 --> 00:41:55,750

 

1299
00:41:55,750 --> 00:41:57,510

 

1300
00:41:57,510 --> 00:41:59,750

 

1301
00:41:59,750 --> 00:42:05,670

 

1302
00:42:05,670 --> 00:42:07,670

 

1303
00:42:07,670 --> 00:42:09,349

 

1304
00:42:09,349 --> 00:42:11,190

 

1305
00:42:11,190 --> 00:42:13,430

 

1306
00:42:13,430 --> 00:42:16,710

 

1307
00:42:16,710 --> 00:42:19,910

 

1308
00:42:19,910 --> 00:42:19,920

 

1309
00:42:19,920 --> 00:42:22,710


1310
00:42:22,710 --> 00:42:24,790

 

1311
00:42:24,790 --> 00:42:26,870

 

1312
00:42:26,870 --> 00:42:29,030

 

1313
00:42:29,030 --> 00:42:32,069

 

1314
00:42:32,069 --> 00:42:33,750

 

1315
00:42:33,750 --> 00:42:35,670

 

1316
00:42:35,670 --> 00:42:37,510

 

1317
00:42:37,510 --> 00:42:40,150

 

1318
00:42:40,150 --> 00:42:42,470

 

1319
00:42:42,470 --> 00:42:45,670

 

1320
00:42:45,670 --> 00:42:48,230

 

1321
00:42:48,230 --> 00:42:50,150

 

1322
00:42:50,150 --> 00:42:53,270

 

1323
00:42:53,270 --> 00:42:56,470

 

1324
00:42:56,470 --> 00:42:59,430

 

1325
00:42:59,430 --> 00:43:01,270

 

1326
00:43:01,270 --> 00:43:04,390

 

1327
00:43:04,390 --> 00:43:07,270

 

1328
00:43:07,270 --> 00:43:08,950

 

1329
00:43:08,950 --> 00:43:11,910

 

1330
00:43:11,910 --> 00:43:14,710

 

1331
00:43:14,710 --> 00:43:16,790

 

1332
00:43:16,790 --> 00:43:16,800

 

1333
00:43:16,800 --> 00:43:18,710


1334
00:43:18,710 --> 00:43:21,829

 

1335
00:43:21,829 --> 00:43:24,309

 

1336
00:43:24,309 --> 00:43:27,349

 

1337
00:43:27,349 --> 00:43:30,710

 

1338
00:43:30,710 --> 00:43:30,720

 

1339
00:43:30,720 --> 00:43:31,670


1340
00:43:31,670 --> 00:43:34,309

 

1341
00:43:34,309 --> 00:43:36,790

 

1342
00:43:36,790 --> 00:43:38,309

 

1343
00:43:38,309 --> 00:43:40,870

 

1344
00:43:40,870 --> 00:43:43,430

 

1345
00:43:43,430 --> 00:43:43,440

 

1346
00:43:43,440 --> 00:43:44,710


1347
00:43:44,710 --> 00:43:46,550

 

1348
00:43:46,550 --> 00:43:48,950

 

1349
00:43:48,950 --> 00:43:50,950

 

1350
00:43:50,950 --> 00:43:52,150

 

1351
00:43:52,150 --> 00:43:53,750

 

1352
00:43:53,750 --> 00:43:53,760

 

1353
00:43:53,760 --> 00:43:56,550


1354
00:43:56,550 --> 00:44:00,950

 

1355
00:44:00,950 --> 00:44:02,870

 

1356
00:44:02,870 --> 00:44:06,069

 

1357
00:44:06,069 --> 00:44:07,670

 

1358
00:44:07,670 --> 00:44:09,349

 

1359
00:44:09,349 --> 00:44:12,950

 

1360
00:44:12,950 --> 00:44:15,829

 

1361
00:44:15,829 --> 00:44:15,839

 

1362
00:44:15,839 --> 00:44:17,190


1363
00:44:17,190 --> 00:44:18,870

 

1364
00:44:18,870 --> 00:44:20,790

 

1365
00:44:20,790 --> 00:44:23,190

 

1366
00:44:23,190 --> 00:44:25,109

 

1367
00:44:25,109 --> 00:44:25,119

 

1368
00:44:25,119 --> 00:44:26,150


1369
00:44:26,150 --> 00:44:28,150

 

1370
00:44:28,150 --> 00:44:29,750

 

1371
00:44:29,750 --> 00:44:31,990

 

1372
00:44:31,990 --> 00:44:34,470

 

1373
00:44:34,470 --> 00:44:36,470

 

1374
00:44:36,470 --> 00:44:39,349

 

1375
00:44:39,349 --> 00:44:41,670

 

1376
00:44:41,670 --> 00:44:41,680

 

1377
00:44:41,680 --> 00:44:43,430


1378
00:44:43,430 --> 00:44:44,870

 

1379
00:44:44,870 --> 00:44:46,390

 

1380
00:44:46,390 --> 00:44:48,150

 

1381
00:44:48,150 --> 00:44:50,630

 

1382
00:44:50,630 --> 00:44:51,750

 

1383
00:44:51,750 --> 00:44:52,790

 

1384
00:44:52,790 --> 00:44:55,589

 

1385
00:44:55,589 --> 00:44:58,230

 

1386
00:44:58,230 --> 00:44:59,750

 

1387
00:44:59,750 --> 00:45:01,510

 

1388
00:45:01,510 --> 00:45:01,520

 

1389
00:45:01,520 --> 00:45:02,950


1390
00:45:02,950 --> 00:45:04,230

 

1391
00:45:04,230 --> 00:45:05,829

 

1392
00:45:05,829 --> 00:45:07,109

 

1393
00:45:07,109 --> 00:45:09,109

 

1394
00:45:09,109 --> 00:45:10,710

 

1395
00:45:10,710 --> 00:45:12,390

 

1396
00:45:12,390 --> 00:45:15,030

 

1397
00:45:15,030 --> 00:45:16,790

 

1398
00:45:16,790 --> 00:45:18,710

 

1399
00:45:18,710 --> 00:45:19,990

 

1400
00:45:19,990 --> 00:45:22,150

 

1401
00:45:22,150 --> 00:45:25,109

 

1402
00:45:25,109 --> 00:45:25,119

 

1403
00:45:25,119 --> 00:45:26,230


1404
00:45:26,230 --> 00:45:28,550

 

1405
00:45:28,550 --> 00:45:30,230

 

1406
00:45:30,230 --> 00:45:32,950

 

1407
00:45:32,950 --> 00:45:34,630

 

1408
00:45:34,630 --> 00:45:36,950

 

1409
00:45:36,950 --> 00:45:36,960

 

1410
00:45:36,960 --> 00:45:37,589


1411
00:45:37,589 --> 00:45:38,950

 

1412
00:45:38,950 --> 00:45:42,710

 

1413
00:45:42,710 --> 00:45:42,720

 

1414
00:45:42,720 --> 00:45:44,390


1415
00:45:44,390 --> 00:45:47,270

 

1416
00:45:47,270 --> 00:45:49,750

 

1417
00:45:49,750 --> 00:45:51,349

 

1418
00:45:51,349 --> 00:45:53,510

 

1419
00:45:53,510 --> 00:45:54,950

 

1420
00:45:54,950 --> 00:45:57,190

 

1421
00:45:57,190 --> 00:45:59,109

 

1422
00:45:59,109 --> 00:46:02,790

 

1423
00:46:02,790 --> 00:46:02,800

 

1424
00:46:02,800 --> 00:46:04,309


1425
00:46:04,309 --> 00:46:04,319

 

1426
00:46:04,319 --> 00:46:05,270


1427
00:46:05,270 --> 00:46:06,870

 

1428
00:46:06,870 --> 00:46:09,109

 

1429
00:46:09,109 --> 00:46:11,190

 

1430
00:46:11,190 --> 00:46:12,870

 

1431
00:46:12,870 --> 00:46:14,790

 

1432
00:46:14,790 --> 00:46:16,470

 

1433
00:46:16,470 --> 00:46:17,990

 

1434
00:46:17,990 --> 00:46:19,109

 

1435
00:46:19,109 --> 00:46:21,990

 

1436
00:46:21,990 --> 00:46:22,000

 

1437
00:46:22,000 --> 00:46:28,630


1438
00:46:28,630 --> 00:46:28,640

 

1439
00:46:28,640 --> 00:46:29,990


1440
00:46:29,990 --> 00:46:30,000

 

1441
00:46:30,000 --> 00:46:36,470


1442
00:46:36,470 --> 00:46:37,990

 

1443
00:46:37,990 --> 00:46:39,430

 

1444
00:46:39,430 --> 00:46:41,190

 

1445
00:46:41,190 --> 00:46:42,870

 

1446
00:46:42,870 --> 00:46:44,550

 

1447
00:46:44,550 --> 00:46:46,950

 

1448
00:46:46,950 --> 00:46:48,470

 

1449
00:46:48,470 --> 00:46:50,870

 

1450
00:46:50,870 --> 00:46:52,870

 

1451
00:46:52,870 --> 00:46:55,270

 

1452
00:46:55,270 --> 00:46:57,270

 

1453
00:46:57,270 --> 00:46:59,430

 

1454
00:46:59,430 --> 00:47:01,109

 

1455
00:47:01,109 --> 00:47:01,119

 

1456
00:47:01,119 --> 00:47:02,230


1457
00:47:02,230 --> 00:47:04,710

 

1458
00:47:04,710 --> 00:47:08,390

 

1459
00:47:08,390 --> 00:47:08,400

 

1460
00:47:08,400 --> 00:47:10,870


1461
00:47:10,870 --> 00:47:13,270

 

1462
00:47:13,270 --> 00:47:15,270

 

1463
00:47:15,270 --> 00:47:17,030

 

1464
00:47:17,030 --> 00:47:17,040

 

1465
00:47:17,040 --> 00:47:18,230


1466
00:47:18,230 --> 00:47:20,230

 

1467
00:47:20,230 --> 00:47:22,230

 

1468
00:47:22,230 --> 00:47:22,240

 

1469
00:47:22,240 --> 00:47:22,950


1470
00:47:22,950 --> 00:47:24,390

 

1471
00:47:24,390 --> 00:47:25,990

 

1472
00:47:25,990 --> 00:47:26,000

 

1473
00:47:26,000 --> 00:47:26,950


1474
00:47:26,950 --> 00:47:29,750

 

1475
00:47:29,750 --> 00:47:31,030

 

1476
00:47:31,030 --> 00:47:32,309

 

1477
00:47:32,309 --> 00:47:33,829

 

1478
00:47:33,829 --> 00:47:35,990

 

1479
00:47:35,990 --> 00:47:39,990

 

1480
00:47:39,990 --> 00:47:42,150

 

1481
00:47:42,150 --> 00:47:44,549

 

1482
00:47:44,549 --> 00:47:46,309

 

1483
00:47:46,309 --> 00:47:48,710

 

1484
00:47:48,710 --> 00:47:51,190

 

1485
00:47:51,190 --> 00:47:54,390

 

1486
00:47:54,390 --> 00:47:55,910

 

1487
00:47:55,910 --> 00:47:57,990

 

1488
00:47:57,990 --> 00:48:00,150

 

1489
00:48:00,150 --> 00:48:01,910

 

1490
00:48:01,910 --> 00:48:03,430

 

1491
00:48:03,430 --> 00:48:05,349

 

1492
00:48:05,349 --> 00:48:07,430

 

1493
00:48:07,430 --> 00:48:09,510

 

1494
00:48:09,510 --> 00:48:11,190

 

1495
00:48:11,190 --> 00:48:11,200

 

1496
00:48:11,200 --> 00:48:12,309


1497
00:48:12,309 --> 00:48:13,349

 

1498
00:48:13,349 --> 00:48:14,790

 

1499
00:48:14,790 --> 00:48:16,950

 

1500
00:48:16,950 --> 00:48:16,960

 

1501
00:48:16,960 --> 00:48:17,750


1502
00:48:17,750 --> 00:48:21,510

 

1503
00:48:21,510 --> 00:48:24,549

 

1504
00:48:24,549 --> 00:48:26,470

 

1505
00:48:26,470 --> 00:48:26,480

 

1506
00:48:26,480 --> 00:48:27,910


1507
00:48:27,910 --> 00:48:27,920

 

1508
00:48:27,920 --> 00:48:28,870


1509
00:48:28,870 --> 00:48:31,510

 

1510
00:48:31,510 --> 00:48:31,520

 

1511
00:48:31,520 --> 00:48:32,630


1512
00:48:32,630 --> 00:48:34,790

 

1513
00:48:34,790 --> 00:48:36,549

 

1514
00:48:36,549 --> 00:48:39,190

 

1515
00:48:39,190 --> 00:48:39,200

 

1516
00:48:39,200 --> 00:48:41,030


1517
00:48:41,030 --> 00:48:44,790

 

1518
00:48:44,790 --> 00:48:46,790

 

1519
00:48:46,790 --> 00:48:48,470

 

1520
00:48:48,470 --> 00:48:50,790

 

1521
00:48:50,790 --> 00:48:53,030

 

1522
00:48:53,030 --> 00:48:55,190

 

1523
00:48:55,190 --> 00:48:58,950

 

1524
00:48:58,950 --> 00:49:01,910

 

1525
00:49:01,910 --> 00:49:03,829

 

1526
00:49:03,829 --> 00:49:05,109

 

1527
00:49:05,109 --> 00:49:07,750

 

1528
00:49:07,750 --> 00:49:10,309

 

1529
00:49:10,309 --> 00:49:10,319

 

1530
00:49:10,319 --> 00:49:11,190


1531
00:49:11,190 --> 00:49:13,750

 

1532
00:49:13,750 --> 00:49:16,150

 

1533
00:49:16,150 --> 00:49:16,160

 

1534
00:49:16,160 --> 00:49:16,790


1535
00:49:16,790 --> 00:49:18,870

 

1536
00:49:18,870 --> 00:49:20,549

 

1537
00:49:20,549 --> 00:49:20,559

 

1538
00:49:20,559 --> 00:49:21,270


1539
00:49:21,270 --> 00:49:23,510

 

1540
00:49:23,510 --> 00:49:25,990

 

1541
00:49:25,990 --> 00:49:28,230

 

1542
00:49:28,230 --> 00:49:31,670

 

1543
00:49:31,670 --> 00:49:34,230

 

1544
00:49:34,230 --> 00:49:37,430

 

1545
00:49:37,430 --> 00:49:40,150

 

1546
00:49:40,150 --> 00:49:42,150

 

1547
00:49:42,150 --> 00:49:46,309

 

1548
00:49:46,309 --> 00:49:47,670

 

1549
00:49:47,670 --> 00:49:49,270

 

1550
00:49:49,270 --> 00:49:52,230

 

1551
00:49:52,230 --> 00:49:54,150

 

1552
00:49:54,150 --> 00:49:56,069

 

1553
00:49:56,069 --> 00:49:56,079

 

1554
00:49:56,079 --> 00:49:57,190


1555
00:49:57,190 --> 00:49:59,030

 

1556
00:49:59,030 --> 00:50:01,349

 

1557
00:50:01,349 --> 00:50:03,349

 

1558
00:50:03,349 --> 00:50:05,190

 

1559
00:50:05,190 --> 00:50:08,069

 

1560
00:50:08,069 --> 00:50:10,950

 

1561
00:50:10,950 --> 00:50:13,190

 

1562
00:50:13,190 --> 00:50:15,750

 

1563
00:50:15,750 --> 00:50:18,069

 

1564
00:50:18,069 --> 00:50:20,390

 

1565
00:50:20,390 --> 00:50:21,990

 

1566
00:50:21,990 --> 00:50:23,589

 

1567
00:50:23,589 --> 00:50:25,829

 

1568
00:50:25,829 --> 00:50:28,549

 

1569
00:50:28,549 --> 00:50:30,069

 

1570
00:50:30,069 --> 00:50:32,790

 

1571
00:50:32,790 --> 00:50:34,069

 

1572
00:50:34,069 --> 00:50:34,079

 

1573
00:50:34,079 --> 00:50:34,950


1574
00:50:34,950 --> 00:50:34,960

 

1575
00:50:34,960 --> 00:50:35,750


1576
00:50:35,750 --> 00:50:37,349

 

1577
00:50:37,349 --> 00:50:39,190

 

1578
00:50:39,190 --> 00:50:40,710

 

1579
00:50:40,710 --> 00:50:42,549

 

1580
00:50:42,549 --> 00:50:44,230

 

1581
00:50:44,230 --> 00:50:44,240

 

1582
00:50:44,240 --> 00:50:45,109


1583
00:50:45,109 --> 00:50:47,910

 

1584
00:50:47,910 --> 00:50:51,430

 

1585
00:50:51,430 --> 00:50:53,030

 

1586
00:50:53,030 --> 00:50:55,430

 

1587
00:50:55,430 --> 00:50:57,829

 

1588
00:50:57,829 --> 00:50:59,910

 

1589
00:50:59,910 --> 00:51:03,109

 

1590
00:51:03,109 --> 00:51:05,270

 

1591
00:51:05,270 --> 00:51:08,470

 

1592
00:51:08,470 --> 00:51:11,430

 

1593
00:51:11,430 --> 00:51:12,710

 

1594
00:51:12,710 --> 00:51:14,230

 

1595
00:51:14,230 --> 00:51:16,710

 

1596
00:51:16,710 --> 00:51:16,720

 

1597
00:51:16,720 --> 00:51:17,910


1598
00:51:17,910 --> 00:51:21,030

 

1599
00:51:21,030 --> 00:51:22,950

 

1600
00:51:22,950 --> 00:51:25,430

 

1601
00:51:25,430 --> 00:51:27,430

 

1602
00:51:27,430 --> 00:51:29,829

 

1603
00:51:29,829 --> 00:51:31,270

 

1604
00:51:31,270 --> 00:51:33,589

 

1605
00:51:33,589 --> 00:51:36,790

 

1606
00:51:36,790 --> 00:51:39,510

 

1607
00:51:39,510 --> 00:51:41,349

 

1608
00:51:41,349 --> 00:51:42,790

 

1609
00:51:42,790 --> 00:51:42,800

 

1610
00:51:42,800 --> 00:51:43,990


1611
00:51:43,990 --> 00:51:45,430

 

1612
00:51:45,430 --> 00:51:47,190

 

1613
00:51:47,190 --> 00:51:48,710

 

1614
00:51:48,710 --> 00:51:48,720

 

1615
00:51:48,720 --> 00:51:49,670


1616
00:51:49,670 --> 00:51:51,190

 

1617
00:51:51,190 --> 00:51:52,390

 

1618
00:51:52,390 --> 00:51:54,390

 

1619
00:51:54,390 --> 00:51:56,230

 

1620
00:51:56,230 --> 00:52:00,069

 

1621
00:52:00,069 --> 00:52:02,790

 

1622
00:52:02,790 --> 00:52:04,950

 

1623
00:52:04,950 --> 00:52:06,390

 

1624
00:52:06,390 --> 00:52:08,069

 

1625
00:52:08,069 --> 00:52:10,069

 

1626
00:52:10,069 --> 00:52:11,750

 

1627
00:52:11,750 --> 00:52:13,270

 

1628
00:52:13,270 --> 00:52:15,510

 

1629
00:52:15,510 --> 00:52:19,030

 

1630
00:52:19,030 --> 00:52:20,470

 

1631
00:52:20,470 --> 00:52:22,309

 

1632
00:52:22,309 --> 00:52:24,309

 

1633
00:52:24,309 --> 00:52:24,319

 

1634
00:52:24,319 --> 00:52:25,109


1635
00:52:25,109 --> 00:52:28,309

 

1636
00:52:28,309 --> 00:52:30,150

 

1637
00:52:30,150 --> 00:52:30,160

 

1638
00:52:30,160 --> 00:52:32,069


1639
00:52:32,069 --> 00:52:33,589

 

1640
00:52:33,589 --> 00:52:35,430

 

1641
00:52:35,430 --> 00:52:36,630

 

1642
00:52:36,630 --> 00:52:38,549

 

1643
00:52:38,549 --> 00:52:42,710

 

1644
00:52:42,710 --> 00:52:45,190

 

1645
00:52:45,190 --> 00:52:48,069

 

1646
00:52:48,069 --> 00:52:50,710

 

1647
00:52:50,710 --> 00:52:50,720

 

1648
00:52:50,720 --> 00:52:52,150


1649
00:52:52,150 --> 00:52:54,549

 

1650
00:52:54,549 --> 00:52:55,990

 

1651
00:52:55,990 --> 00:52:57,829

 

1652
00:52:57,829 --> 00:53:00,549

 

1653
00:53:00,549 --> 00:53:03,589

 

1654
00:53:03,589 --> 00:53:05,910

 

1655
00:53:05,910 --> 00:53:07,990

 

1656
00:53:07,990 --> 00:53:10,150

 

1657
00:53:10,150 --> 00:53:11,430

 

1658
00:53:11,430 --> 00:53:17,990

 

1659
00:53:17,990 --> 00:53:24,630

 

1660
00:53:24,630 --> 00:53:26,230

 

1661
00:53:26,230 --> 00:53:26,240

 

1662
00:53:26,240 --> 00:53:28,309


1663
00:53:28,309 --> 00:53:29,670

 

1664
00:53:29,670 --> 00:53:32,069

 

1665
00:53:32,069 --> 00:53:32,079

 

1666
00:53:32,079 --> 00:53:33,190


1667
00:53:33,190 --> 00:53:35,190

 

1668
00:53:35,190 --> 00:53:37,349

 

1669
00:53:37,349 --> 00:53:38,710

 

1670
00:53:38,710 --> 00:53:38,720

 

1671
00:53:38,720 --> 00:53:40,549


1672
00:53:40,549 --> 00:53:40,559

 

1673
00:53:40,559 --> 00:53:41,920


1674
00:53:41,920 --> 00:53:41,930

 

1675
00:53:41,930 --> 00:53:44,549


1676
00:53:44,549 --> 00:53:46,470

 

1677
00:53:46,470 --> 00:53:48,069

 

1678
00:53:48,069 --> 00:53:51,589

 

1679
00:53:51,589 --> 00:53:52,790

 

1680
00:53:52,790 --> 00:53:54,950

 

1681
00:53:54,950 --> 00:53:57,190

 

1682
00:53:57,190 --> 00:53:59,829

 

1683
00:53:59,829 --> 00:54:02,710

 

1684
00:54:02,710 --> 00:54:04,630

 

1685
00:54:04,630 --> 00:54:06,790

 

1686
00:54:06,790 --> 00:54:08,470

 

1687
00:54:08,470 --> 00:54:10,710

 

1688
00:54:10,710 --> 00:54:12,630

 

1689
00:54:12,630 --> 00:54:15,270

 

1690
00:54:15,270 --> 00:54:17,270

 

1691
00:54:17,270 --> 00:54:17,280

 

1692
00:54:17,280 --> 00:54:18,390


1693
00:54:18,390 --> 00:54:18,400

 

1694
00:54:18,400 --> 00:54:19,910


1695
00:54:19,910 --> 00:54:22,309

 

1696
00:54:22,309 --> 00:54:24,390

 

1697
00:54:24,390 --> 00:54:24,400

 

1698
00:54:24,400 --> 00:54:25,270


1699
00:54:25,270 --> 00:54:27,829

 

1700
00:54:27,829 --> 00:54:32,150

 

1701
00:54:32,150 --> 00:54:34,630

 

1702
00:54:34,630 --> 00:54:36,789

 

1703
00:54:36,789 --> 00:54:38,870

 

1704
00:54:38,870 --> 00:54:41,190

 

1705
00:54:41,190 --> 00:54:43,829

 

1706
00:54:43,829 --> 00:54:45,270

 

1707
00:54:45,270 --> 00:54:47,589

 

1708
00:54:47,589 --> 00:54:49,510

 

1709
00:54:49,510 --> 00:54:52,470

 

1710
00:54:52,470 --> 00:54:52,480

 

1711
00:54:52,480 --> 00:54:53,670


1712
00:54:53,670 --> 00:54:56,470

 

1713
00:54:56,470 --> 00:54:58,789

 

1714
00:54:58,789 --> 00:54:58,799

 

1715
00:54:58,799 --> 00:54:59,910


1716
00:54:59,910 --> 00:55:01,670

 

1717
00:55:01,670 --> 00:55:03,670

 

1718
00:55:03,670 --> 00:55:05,750

 

1719
00:55:05,750 --> 00:55:07,349

 

1720
00:55:07,349 --> 00:55:11,510

 

1721
00:55:11,510 --> 00:55:13,510

 

1722
00:55:13,510 --> 00:55:17,109

 

1723
00:55:17,109 --> 00:55:19,910

 

1724
00:55:19,910 --> 00:55:21,750

 

1725
00:55:21,750 --> 00:55:24,230

 

1726
00:55:24,230 --> 00:55:25,589

 

1727
00:55:25,589 --> 00:55:25,599

 

1728
00:55:25,599 --> 00:55:26,710


1729
00:55:26,710 --> 00:55:28,069

 

1730
00:55:28,069 --> 00:55:29,990

 

1731
00:55:29,990 --> 00:55:31,589

 

1732
00:55:31,589 --> 00:55:34,870

 

1733
00:55:34,870 --> 00:55:37,829

 

1734
00:55:37,829 --> 00:55:39,990

 

1735
00:55:39,990 --> 00:55:41,750

 

1736
00:55:41,750 --> 00:55:43,349

 

1737
00:55:43,349 --> 00:55:45,670

 

1738
00:55:45,670 --> 00:55:45,680

 

1739
00:55:45,680 --> 00:55:47,190


1740
00:55:47,190 --> 00:55:48,870

 

1741
00:55:48,870 --> 00:55:51,510

 

1742
00:55:51,510 --> 00:55:54,150

 

1743
00:55:54,150 --> 00:55:58,069

 

1744
00:55:58,069 --> 00:55:59,510

 

1745
00:55:59,510 --> 00:56:02,950

 

1746
00:56:02,950 --> 00:56:05,510

 

1747
00:56:05,510 --> 00:56:08,230

 

1748
00:56:08,230 --> 00:56:09,829

 

1749
00:56:09,829 --> 00:56:11,109

 

1750
00:56:11,109 --> 00:56:12,630

 

1751
00:56:12,630 --> 00:56:14,470

 

1752
00:56:14,470 --> 00:56:15,990

 

1753
00:56:15,990 --> 00:56:17,030

 

1754
00:56:17,030 --> 00:56:17,040

 

1755
00:56:17,040 --> 00:56:17,910


1756
00:56:17,910 --> 00:56:20,950

 

1757
00:56:20,950 --> 00:56:22,470

 

1758
00:56:22,470 --> 00:56:24,069

 

1759
00:56:24,069 --> 00:56:26,390

 

1760
00:56:26,390 --> 00:56:28,470

 

1761
00:56:28,470 --> 00:56:30,789

 

1762
00:56:30,789 --> 00:56:32,549

 

1763
00:56:32,549 --> 00:56:34,470

 

1764
00:56:34,470 --> 00:56:36,789

 

1765
00:56:36,789 --> 00:56:39,910

 

1766
00:56:39,910 --> 00:56:42,069

 

1767
00:56:42,069 --> 00:56:42,079

 

1768
00:56:42,079 --> 00:56:42,829


1769
00:56:42,829 --> 00:56:42,839

 

1770
00:56:42,839 --> 00:56:44,390


1771
00:56:44,390 --> 00:56:45,910

 

1772
00:56:45,910 --> 00:56:50,390

 

1773
00:56:50,390 --> 00:56:52,789

 

1774
00:56:52,789 --> 00:56:52,799

 

1775
00:56:52,799 --> 00:56:53,750


1776
00:56:53,750 --> 00:56:55,670

 

1777
00:56:55,670 --> 00:56:57,109

 

1778
00:56:57,109 --> 00:56:59,270

 

1779
00:56:59,270 --> 00:57:01,190

 

1780
00:57:01,190 --> 00:57:01,200

 

1781
00:57:01,200 --> 00:57:02,230


1782
00:57:02,230 --> 00:57:04,470

 

1783
00:57:04,470 --> 00:57:07,270

 

1784
00:57:07,270 --> 00:57:08,870

 

1785
00:57:08,870 --> 00:57:11,109

 

1786
00:57:11,109 --> 00:57:14,549

 

1787
00:57:14,549 --> 00:57:16,309

 

1788
00:57:16,309 --> 00:57:19,510

 

1789
00:57:19,510 --> 00:57:21,030

 

1790
00:57:21,030 --> 00:57:22,069

 

1791
00:57:22,069 --> 00:57:23,750

 

1792
00:57:23,750 --> 00:57:26,549

 

1793
00:57:26,549 --> 00:57:26,559

 

1794
00:57:26,559 --> 00:57:27,829


1795
00:57:27,829 --> 00:57:29,750

 

1796
00:57:29,750 --> 00:57:31,270

 

1797
00:57:31,270 --> 00:57:33,589

 

1798
00:57:33,589 --> 00:57:33,599

 

1799
00:57:33,599 --> 00:57:34,309


1800
00:57:34,309 --> 00:57:36,150

 

1801
00:57:36,150 --> 00:57:39,109

 

1802
00:57:39,109 --> 00:57:41,349

 

1803
00:57:41,349 --> 00:57:42,710

 

1804
00:57:42,710 --> 00:57:43,990

 

1805
00:57:43,990 --> 00:57:45,670

 

1806
00:57:45,670 --> 00:57:47,430

 

1807
00:57:47,430 --> 00:57:49,750

 

1808
00:57:49,750 --> 00:57:51,990

 

1809
00:57:51,990 --> 00:57:54,470

 

1810
00:57:54,470 --> 00:57:57,109

 

1811
00:57:57,109 --> 00:57:59,270

 

1812
00:57:59,270 --> 00:57:59,280

 

1813
00:57:59,280 --> 00:58:00,069


1814
00:58:00,069 --> 00:58:02,069

 

1815
00:58:02,069 --> 00:58:03,510

 

1816
00:58:03,510 --> 00:58:05,990

 

1817
00:58:05,990 --> 00:58:08,390

 

1818
00:58:08,390 --> 00:58:09,589

 

1819
00:58:09,589 --> 00:58:09,599

 

1820
00:58:09,599 --> 00:58:11,190


1821
00:58:11,190 --> 00:58:13,349

 

1822
00:58:13,349 --> 00:58:15,750

 

1823
00:58:15,750 --> 00:58:17,990

 

1824
00:58:17,990 --> 00:58:20,230

 

1825
00:58:20,230 --> 00:58:21,430

 

1826
00:58:21,430 --> 00:58:22,789

 

1827
00:58:22,789 --> 00:58:24,069

 

1828
00:58:24,069 --> 00:58:26,309

 

1829
00:58:26,309 --> 00:58:28,950

 

1830
00:58:28,950 --> 00:58:31,510

 

1831
00:58:31,510 --> 00:58:33,510

 

1832
00:58:33,510 --> 00:58:36,309

 

1833
00:58:36,309 --> 00:58:37,750

 

1834
00:58:37,750 --> 00:58:39,750

 

1835
00:58:39,750 --> 00:58:41,990

 

1836
00:58:41,990 --> 00:58:44,069

 

1837
00:58:44,069 --> 00:58:46,630

 

1838
00:58:46,630 --> 00:58:49,430

 

1839
00:58:49,430 --> 00:58:51,109

 

1840
00:58:51,109 --> 00:58:53,510

 

1841
00:58:53,510 --> 00:58:55,430

 

1842
00:58:55,430 --> 00:58:55,440

 

1843
00:58:55,440 --> 00:58:57,109


1844
00:58:57,109 --> 00:58:57,119

 

1845
00:58:57,119 --> 00:58:58,710


1846
00:58:58,710 --> 00:59:00,069

 

1847
00:59:00,069 --> 00:59:02,829

 

1848
00:59:02,829 --> 00:59:05,190

 

1849
00:59:05,190 --> 00:59:05,200

 

1850
00:59:05,200 --> 00:59:08,069


1851
00:59:08,069 --> 00:59:09,510

 

1852
00:59:09,510 --> 00:59:13,109

 

1853
00:59:13,109 --> 00:59:16,069

 

1854
00:59:16,069 --> 00:59:19,510

 

1855
00:59:19,510 --> 00:59:19,520

 

1856
00:59:19,520 --> 00:59:20,710


1857
00:59:20,710 --> 00:59:23,030

 

1858
00:59:23,030 --> 00:59:25,190

 

1859
00:59:25,190 --> 00:59:27,430

 

1860
00:59:27,430 --> 00:59:29,829

 

1861
00:59:29,829 --> 00:59:32,789

 

1862
00:59:32,789 --> 00:59:34,710

 

1863
00:59:34,710 --> 00:59:36,710

 

1864
00:59:36,710 --> 00:59:38,710

 

1865
00:59:38,710 --> 00:59:41,829

 

1866
00:59:41,829 --> 00:59:43,589

 

1867
00:59:43,589 --> 00:59:45,430

 

1868
00:59:45,430 --> 00:59:47,990

 

1869
00:59:47,990 --> 00:59:48,000

 

1870
00:59:48,000 --> 00:59:49,349


1871
00:59:49,349 --> 00:59:51,670

 

1872
00:59:51,670 --> 00:59:54,069

 

1873
00:59:54,069 --> 00:59:56,950

 

1874
00:59:56,950 --> 00:59:59,030

 

1875
00:59:59,030 --> 01:00:01,349

 

1876
01:00:01,349 --> 01:00:03,109

 

1877
01:00:03,109 --> 01:00:04,789

 

1878
01:00:04,789 --> 01:00:06,789

 

1879
01:00:06,789 --> 01:00:08,549

 

1880
01:00:08,549 --> 01:00:10,390

 

1881
01:00:10,390 --> 01:00:10,400

 

1882
01:00:10,400 --> 01:00:12,470


1883
01:00:12,470 --> 01:00:15,109

 

1884
01:00:15,109 --> 01:00:16,549

 

1885
01:00:16,549 --> 01:00:18,870

 

1886
01:00:18,870 --> 01:00:22,390

 

1887
01:00:22,390 --> 01:00:23,990

 

1888
01:00:23,990 --> 01:00:25,670

 

1889
01:00:25,670 --> 01:00:27,670

 

1890
01:00:27,670 --> 01:00:29,589

 

1891
01:00:29,589 --> 01:00:32,230

 

1892
01:00:32,230 --> 01:00:33,910

 

1893
01:00:33,910 --> 01:00:36,069

 

1894
01:00:36,069 --> 01:00:37,829

 

1895
01:00:37,829 --> 01:00:40,069

 

1896
01:00:40,069 --> 01:00:42,870

 

1897
01:00:42,870 --> 01:00:46,309

 

1898
01:00:46,309 --> 01:00:48,470

 

1899
01:00:48,470 --> 01:00:50,230

 

1900
01:00:50,230 --> 01:00:52,230

 

1901
01:00:52,230 --> 01:00:52,240

 

1902
01:00:52,240 --> 01:00:53,109


1903
01:00:53,109 --> 01:00:55,270

 

1904
01:00:55,270 --> 01:00:56,710

 

1905
01:00:56,710 --> 01:00:59,510

 

1906
01:00:59,510 --> 01:01:01,670

 

1907
01:01:01,670 --> 01:01:05,030

 

1908
01:01:05,030 --> 01:01:06,950

 

1909
01:01:06,950 --> 01:01:09,750

 

1910
01:01:09,750 --> 01:01:11,589

 

1911
01:01:11,589 --> 01:01:13,109

 

1912
01:01:13,109 --> 01:01:14,950

 

1913
01:01:14,950 --> 01:01:16,630

 

1914
01:01:16,630 --> 01:01:16,640

 

1915
01:01:16,640 --> 01:01:17,829


1916
01:01:17,829 --> 01:01:19,510

 

1917
01:01:19,510 --> 01:01:21,750

 

1918
01:01:21,750 --> 01:01:23,270

 

1919
01:01:23,270 --> 01:01:25,109

 

1920
01:01:25,109 --> 01:01:26,630

 

1921
01:01:26,630 --> 01:01:28,710

 

1922
01:01:28,710 --> 01:01:29,990

 

1923
01:01:29,990 --> 01:01:31,990

 

1924
01:01:31,990 --> 01:01:34,230

 

1925
01:01:34,230 --> 01:01:36,069

 

1926
01:01:36,069 --> 01:01:37,910

 

1927
01:01:37,910 --> 01:01:40,549

 

1928
01:01:40,549 --> 01:01:40,559

 

1929
01:01:40,559 --> 01:01:41,670


1930
01:01:41,670 --> 01:01:43,349

 

1931
01:01:43,349 --> 01:01:44,950

 

1932
01:01:44,950 --> 01:01:47,430

 

1933
01:01:47,430 --> 01:01:48,950

 

1934
01:01:48,950 --> 01:01:51,030

 

1935
01:01:51,030 --> 01:01:53,349

 

1936
01:01:53,349 --> 01:01:54,710

 

1937
01:01:54,710 --> 01:01:55,990

 

1938
01:01:55,990 --> 01:01:58,789

 

1939
01:01:58,789 --> 01:01:58,799

 

1940
01:01:58,799 --> 01:02:00,710


1941
01:02:00,710 --> 01:02:01,990

 

1942
01:02:01,990 --> 01:02:04,470

 

1943
01:02:04,470 --> 01:02:07,190

 

1944
01:02:07,190 --> 01:02:08,549

 

1945
01:02:08,549 --> 01:02:10,470

 

1946
01:02:10,470 --> 01:02:11,910

 

1947
01:02:11,910 --> 01:02:13,829

 

1948
01:02:13,829 --> 01:02:15,510

 

1949
01:02:15,510 --> 01:02:17,589

 

1950
01:02:17,589 --> 01:02:18,789

 

1951
01:02:18,789 --> 01:02:20,630

 

1952
01:02:20,630 --> 01:02:22,390

 

1953
01:02:22,390 --> 01:02:24,549

 

1954
01:02:24,549 --> 01:02:26,150

 

1955
01:02:26,150 --> 01:02:29,510

 

1956
01:02:29,510 --> 01:02:32,390

 

1957
01:02:32,390 --> 01:02:33,670

 

1958
01:02:33,670 --> 01:02:35,029

 

1959
01:02:35,029 --> 01:02:37,029

 

1960
01:02:37,029 --> 01:02:38,230

 

1961
01:02:38,230 --> 01:02:39,990

 

1962
01:02:39,990 --> 01:02:41,670

 

1963
01:02:41,670 --> 01:02:42,870

 

1964
01:02:42,870 --> 01:02:44,309

 

1965
01:02:44,309 --> 01:02:46,789

 

1966
01:02:46,789 --> 01:02:48,390

 

1967
01:02:48,390 --> 01:02:48,400

 

1968
01:02:48,400 --> 01:02:49,430


1969
01:02:49,430 --> 01:02:51,190

 

1970
01:02:51,190 --> 01:02:53,349

 

1971
01:02:53,349 --> 01:02:54,870

 

1972
01:02:54,870 --> 01:02:55,829

 

1973
01:02:55,829 --> 01:02:57,349

 

1974
01:02:57,349 --> 01:02:59,829

 

1975
01:02:59,829 --> 01:03:01,510

 

1976
01:03:01,510 --> 01:03:03,670

 

1977
01:03:03,670 --> 01:03:05,349

 

1978
01:03:05,349 --> 01:03:07,510

 

1979
01:03:07,510 --> 01:03:10,470

 

1980
01:03:10,470 --> 01:03:11,589

 

1981
01:03:11,589 --> 01:03:13,190

 

1982
01:03:13,190 --> 01:03:15,190

 

1983
01:03:15,190 --> 01:03:17,910

 

1984
01:03:17,910 --> 01:03:20,710

 

1985
01:03:20,710 --> 01:03:22,470

 

1986
01:03:22,470 --> 01:03:25,190

 

1987
01:03:25,190 --> 01:03:27,430

 

1988
01:03:27,430 --> 01:03:29,910

 

1989
01:03:29,910 --> 01:03:31,829

 

1990
01:03:31,829 --> 01:03:33,349

 

1991
01:03:33,349 --> 01:03:35,829

 

1992
01:03:35,829 --> 01:03:37,829

 

1993
01:03:37,829 --> 01:03:41,990

 

1994
01:03:41,990 --> 01:03:44,549

 

1995
01:03:44,549 --> 01:03:46,230

 

1996
01:03:46,230 --> 01:03:46,240

 

1997
01:03:46,240 --> 01:03:48,789


1998
01:03:48,789 --> 01:03:51,190

 

1999
01:03:51,190 --> 01:03:53,190

 

2000
01:03:53,190 --> 01:03:55,670

 

2001
01:03:55,670 --> 01:03:57,190

 

2002
01:03:57,190 --> 01:03:59,270

 

2003
01:03:59,270 --> 01:04:02,069

 

2004
01:04:02,069 --> 01:04:04,789

 

2005
01:04:04,789 --> 01:04:06,789

 

2006
01:04:06,789 --> 01:04:11,109

 

2007
01:04:11,109 --> 01:04:11,119

 

2008
01:04:11,119 --> 01:04:11,990


2009
01:04:11,990 --> 01:04:13,829

 

2010
01:04:13,829 --> 01:04:15,430

 

2011
01:04:15,430 --> 01:04:17,430

 

2012
01:04:17,430 --> 01:04:21,430

 

2013
01:04:21,430 --> 01:04:21,440

 

2014
01:04:21,440 --> 01:04:23,190


2015
01:04:23,190 --> 01:04:26,069

 

2016
01:04:26,069 --> 01:04:32,630

 

2017
01:04:32,630 --> 01:04:34,150

 

2018
01:04:34,150 --> 01:04:34,160

 

2019
01:04:34,160 --> 01:04:35,109


2020
01:04:35,109 --> 01:04:38,950

 

2021
01:04:38,950 --> 01:04:38,960

 

2022
01:04:38,960 --> 01:04:41,589


2023
01:04:41,589 --> 01:04:42,710

 

2024
01:04:42,710 --> 01:04:42,720

 

2025
01:04:42,720 --> 01:04:44,309


2026
01:04:44,309 --> 01:04:46,549

 

2027
01:04:46,549 --> 01:04:48,150

 

2028
01:04:48,150 --> 01:04:50,470

 

2029
01:04:50,470 --> 01:04:53,430

 

2030
01:04:53,430 --> 01:04:55,349

 

2031
01:04:55,349 --> 01:04:57,910

 

2032
01:04:57,910 --> 01:04:59,750

 

2033
01:04:59,750 --> 01:05:02,309

 

2034
01:05:02,309 --> 01:05:04,069

 

2035
01:05:04,069 --> 01:05:06,150

 

2036
01:05:06,150 --> 01:05:07,750

 

2037
01:05:07,750 --> 01:05:08,950

 

2038
01:05:08,950 --> 01:05:10,870

 

2039
01:05:10,870 --> 01:05:12,309

 

2040
01:05:12,309 --> 01:05:14,309

 

2041
01:05:14,309 --> 01:05:16,230

 

2042
01:05:16,230 --> 01:05:18,150

 

2043
01:05:18,150 --> 01:05:20,230

 

2044
01:05:20,230 --> 01:05:22,150

 

2045
01:05:22,150 --> 01:05:23,349

 

2046
01:05:23,349 --> 01:05:25,670

 

2047
01:05:25,670 --> 01:05:27,430

 

2048
01:05:27,430 --> 01:05:30,549

 

2049
01:05:30,549 --> 01:05:33,750

 

2050
01:05:33,750 --> 01:05:35,829

 

2051
01:05:35,829 --> 01:05:38,470

 

2052
01:05:38,470 --> 01:05:41,349

 

2053
01:05:41,349 --> 01:05:43,190

 

2054
01:05:43,190 --> 01:05:45,029

 

2055
01:05:45,029 --> 01:05:46,789

 

2056
01:05:46,789 --> 01:05:48,789

 

2057
01:05:48,789 --> 01:05:50,470

 

2058
01:05:50,470 --> 01:05:52,390

 

2059
01:05:52,390 --> 01:05:54,470

 

2060
01:05:54,470 --> 01:05:54,480

 

2061
01:05:54,480 --> 01:05:55,270


2062
01:05:55,270 --> 01:05:56,950

 

2063
01:05:56,950 --> 01:05:56,960

 

2064
01:05:56,960 --> 01:05:57,750


2065
01:05:57,750 --> 01:05:59,270

 

2066
01:05:59,270 --> 01:06:00,549

 

2067
01:06:00,549 --> 01:06:02,309

 

2068
01:06:02,309 --> 01:06:04,710

 

2069
01:06:04,710 --> 01:06:06,069

 

2070
01:06:06,069 --> 01:06:08,630

 

2071
01:06:08,630 --> 01:06:10,230

 

2072
01:06:10,230 --> 01:06:12,789

 

2073
01:06:12,789 --> 01:06:15,430

 

2074
01:06:15,430 --> 01:06:16,950

 

2075
01:06:16,950 --> 01:06:19,349

 

2076
01:06:19,349 --> 01:06:22,470

 

2077
01:06:22,470 --> 01:06:24,870

 

2078
01:06:24,870 --> 01:06:26,390

 

2079
01:06:26,390 --> 01:06:27,990

 

2080
01:06:27,990 --> 01:06:29,190

 

2081
01:06:29,190 --> 01:06:30,789

 

2082
01:06:30,789 --> 01:06:32,630

 

2083
01:06:32,630 --> 01:06:32,640

 

2084
01:06:32,640 --> 01:06:33,750


2085
01:06:33,750 --> 01:06:33,760

 

2086
01:06:33,760 --> 01:06:35,349


2087
01:06:35,349 --> 01:06:37,029

 

2088
01:06:37,029 --> 01:06:38,789

 

2089
01:06:38,789 --> 01:06:41,349

 

2090
01:06:41,349 --> 01:06:43,589

 

2091
01:06:43,589 --> 01:06:44,870

 

2092
01:06:44,870 --> 01:06:46,950

 

2093
01:06:46,950 --> 01:06:48,549

 

2094
01:06:48,549 --> 01:06:50,150

 

2095
01:06:50,150 --> 01:06:50,160

 

2096
01:06:50,160 --> 01:06:51,589


2097
01:06:51,589 --> 01:06:55,109

 

2098
01:06:55,109 --> 01:06:56,950

 

2099
01:06:56,950 --> 01:06:58,870

 

2100
01:06:58,870 --> 01:07:01,270

 

2101
01:07:01,270 --> 01:07:02,630

 

2102
01:07:02,630 --> 01:07:02,640

 

2103
01:07:02,640 --> 01:07:04,150


2104
01:07:04,150 --> 01:07:04,160

 

2105
01:07:04,160 --> 01:07:05,029


2106
01:07:05,029 --> 01:07:08,309

 

2107
01:07:08,309 --> 01:07:10,630

 

2108
01:07:10,630 --> 01:07:12,829

 

2109
01:07:12,829 --> 01:07:15,270

 

2110
01:07:15,270 --> 01:07:16,870

 

2111
01:07:16,870 --> 01:07:16,880

 

2112
01:07:16,880 --> 01:07:17,910


2113
01:07:17,910 --> 01:07:17,920

 

2114
01:07:17,920 --> 01:07:18,520


2115
01:07:18,520 --> 01:07:18,530

 

2116
01:07:18,530 --> 01:07:19,829


2117
01:07:19,829 --> 01:07:19,839

 

2118
01:07:19,839 --> 01:07:20,870


2119
01:07:20,870 --> 01:07:22,630

 

2120
01:07:22,630 --> 01:07:24,230

 

2121
01:07:24,230 --> 01:07:26,230

 

2122
01:07:26,230 --> 01:07:28,470

 

2123
01:07:28,470 --> 01:07:31,190

 

2124
01:07:31,190 --> 01:07:33,349

 

2125
01:07:33,349 --> 01:07:34,789

 

2126
01:07:34,789 --> 01:07:37,510

 

2127
01:07:37,510 --> 01:07:40,390

 

2128
01:07:40,390 --> 01:07:43,029

 

2129
01:07:43,029 --> 01:07:44,789

 

2130
01:07:44,789 --> 01:07:46,870

 

2131
01:07:46,870 --> 01:07:48,789

 

2132
01:07:48,789 --> 01:07:50,390

 

2133
01:07:50,390 --> 01:07:52,710

 

2134
01:07:52,710 --> 01:07:52,720

 

2135
01:07:52,720 --> 01:07:53,750


2136
01:07:53,750 --> 01:07:53,760

 

2137
01:07:53,760 --> 01:07:55,109


2138
01:07:55,109 --> 01:07:57,670

 

2139
01:07:57,670 --> 01:08:01,349

 

2140
01:08:01,349 --> 01:08:01,359

 

2141
01:08:01,359 --> 01:08:02,549


2142
01:08:02,549 --> 01:08:05,510

 

2143
01:08:05,510 --> 01:08:07,029

 

2144
01:08:07,029 --> 01:08:07,039

 

2145
01:08:07,039 --> 01:08:07,990


2146
01:08:07,990 --> 01:08:10,390

 

2147
01:08:10,390 --> 01:08:11,510

 

2148
01:08:11,510 --> 01:08:13,029

 

2149
01:08:13,029 --> 01:08:16,149

 

2150
01:08:16,149 --> 01:08:17,510

 

2151
01:08:17,510 --> 01:08:19,669

 

2152
01:08:19,669 --> 01:08:22,149

 

2153
01:08:22,149 --> 01:08:23,749

 

2154
01:08:23,749 --> 01:08:25,590

 

2155
01:08:25,590 --> 01:08:29,590

 

2156
01:08:29,590 --> 01:08:31,349

 

2157
01:08:31,349 --> 01:08:32,709

 

2158
01:08:32,709 --> 01:08:34,630

 

2159
01:08:34,630 --> 01:08:36,149

 

2160
01:08:36,149 --> 01:08:36,159

 

2161
01:08:36,159 --> 01:08:36,829


2162
01:08:36,829 --> 01:08:36,839

 

2163
01:08:36,839 --> 01:08:38,470


2164
01:08:38,470 --> 01:08:40,709

 

2165
01:08:40,709 --> 01:08:43,749

 

2166
01:08:43,749 --> 01:08:45,510

 

2167
01:08:45,510 --> 01:08:45,520

 

2168
01:08:45,520 --> 01:08:46,789


2169
01:08:46,789 --> 01:08:48,229

 

2170
01:08:48,229 --> 01:08:50,789

 

2171
01:08:50,789 --> 01:08:53,030

 

2172
01:08:53,030 --> 01:08:55,030

 

2173
01:08:55,030 --> 01:08:57,030

 

2174
01:08:57,030 --> 01:08:58,070

 

2175
01:08:58,070 --> 01:09:00,070

 

2176
01:09:00,070 --> 01:09:00,080

 

2177
01:09:00,080 --> 01:09:01,910


2178
01:09:01,910 --> 01:09:01,920

 

2179
01:09:01,920 --> 01:09:02,789


2180
01:09:02,789 --> 01:09:04,630

 

2181
01:09:04,630 --> 01:09:06,470

 

2182
01:09:06,470 --> 01:09:09,030

 

2183
01:09:09,030 --> 01:09:10,950

 

2184
01:09:10,950 --> 01:09:10,960

 

2185
01:09:10,960 --> 01:09:12,149


2186
01:09:12,149 --> 01:09:12,159

 

2187
01:09:12,159 --> 01:09:13,829


2188
01:09:13,829 --> 01:09:16,149

 

2189
01:09:16,149 --> 01:09:17,669

 

2190
01:09:17,669 --> 01:09:20,309

 

2191
01:09:20,309 --> 01:09:23,269

 

2192
01:09:23,269 --> 01:09:24,709

 

2193
01:09:24,709 --> 01:09:26,950

 

2194
01:09:26,950 --> 01:09:29,189

 

2195
01:09:29,189 --> 01:09:30,709

 

2196
01:09:30,709 --> 01:09:33,110

 

2197
01:09:33,110 --> 01:09:35,430

 

2198
01:09:35,430 --> 01:09:37,510

 

2199
01:09:37,510 --> 01:09:41,189

 

2200
01:09:41,189 --> 01:09:44,229

 

2201
01:09:44,229 --> 01:09:45,990

 

2202
01:09:45,990 --> 01:09:47,749

 

2203
01:09:47,749 --> 01:09:49,430

 

2204
01:09:49,430 --> 01:09:53,030

 

2205
01:09:53,030 --> 01:09:55,910

 

2206
01:09:55,910 --> 01:09:58,390

 

2207
01:09:58,390 --> 01:10:00,070

 

2208
01:10:00,070 --> 01:10:02,229

 

2209
01:10:02,229 --> 01:10:05,030

 

2210
01:10:05,030 --> 01:10:07,830

 

2211
01:10:07,830 --> 01:10:07,840

 

2212
01:10:07,840 --> 01:10:09,189


2213
01:10:09,189 --> 01:10:11,669

 

2214
01:10:11,669 --> 01:10:11,679

 

2215
01:10:11,679 --> 01:10:12,950


2216
01:10:12,950 --> 01:10:15,110

 

2217
01:10:15,110 --> 01:10:16,550

 

2218
01:10:16,550 --> 01:10:19,189

 

2219
01:10:19,189 --> 01:10:21,430

 

2220
01:10:21,430 --> 01:10:22,790

 

2221
01:10:22,790 --> 01:10:24,630

 

2222
01:10:24,630 --> 01:10:26,950

 

2223
01:10:26,950 --> 01:10:29,030

 

2224
01:10:29,030 --> 01:10:32,390

 

2225
01:10:32,390 --> 01:10:34,229

 

2226
01:10:34,229 --> 01:10:36,070

 

2227
01:10:36,070 --> 01:10:37,510

 

2228
01:10:37,510 --> 01:10:37,520

 

2229
01:10:37,520 --> 01:10:38,470


2230
01:10:38,470 --> 01:10:39,910

 

2231
01:10:39,910 --> 01:10:41,750

 

2232
01:10:41,750 --> 01:10:43,590

 

2233
01:10:43,590 --> 01:10:45,350

 

2234
01:10:45,350 --> 01:10:45,360

 

2235
01:10:45,360 --> 01:10:46,870


2236
01:10:46,870 --> 01:10:48,709

 

2237
01:10:48,709 --> 01:10:52,149

 

2238
01:10:52,149 --> 01:10:54,950

 

2239
01:10:54,950 --> 01:10:54,960

 

2240
01:10:54,960 --> 01:10:55,910


2241
01:10:55,910 --> 01:11:00,630

 

2242
01:11:00,630 --> 01:11:00,640

 

2243
01:11:00,640 --> 01:11:01,590


2244
01:11:01,590 --> 01:11:03,669

 

2245
01:11:03,669 --> 01:11:05,990

 

2246
01:11:05,990 --> 01:11:07,910

 

2247
01:11:07,910 --> 01:11:07,920

 

2248
01:11:07,920 --> 01:11:09,750


2249
01:11:09,750 --> 01:11:09,760

 

2250
01:11:09,760 --> 01:11:10,709


2251
01:11:10,709 --> 01:11:12,950

 

2252
01:11:12,950 --> 01:11:15,189

 

2253
01:11:15,189 --> 01:11:17,110

 

2254
01:11:17,110 --> 01:11:18,709

 

2255
01:11:18,709 --> 01:11:20,709

 

2256
01:11:20,709 --> 01:11:22,470

 

2257
01:11:22,470 --> 01:11:28,070

 

2258
01:11:28,070 --> 01:11:30,630

 

2259
01:11:30,630 --> 01:11:32,470

 

2260
01:11:32,470 --> 01:11:35,270

 

2261
01:11:35,270 --> 01:11:36,470

 

2262
01:11:36,470 --> 01:11:39,990

 

2263
01:11:39,990 --> 01:11:43,189

 

2264
01:11:43,189 --> 01:11:45,990

 

2265
01:11:45,990 --> 01:11:49,590

 

2266
01:11:49,590 --> 01:11:51,270

 

2267
01:11:51,270 --> 01:11:52,830

 

2268
01:11:52,830 --> 01:11:55,350

 

2269
01:11:55,350 --> 01:11:57,590

 

2270
01:11:57,590 --> 01:11:57,600

 

2271
01:11:57,600 --> 01:11:58,470


2272
01:11:58,470 --> 01:12:02,149

 

2273
01:12:02,149 --> 01:12:04,070

 

2274
01:12:04,070 --> 01:12:06,070

 

2275
01:12:06,070 --> 01:12:07,830

 

2276
01:12:07,830 --> 01:12:07,840

 

2277
01:12:07,840 --> 01:12:16,470


2278
01:12:16,470 --> 01:12:19,750

 

2279
01:12:19,750 --> 01:12:21,510

 

2280
01:12:21,510 --> 01:12:24,070

 

2281
01:12:24,070 --> 01:12:25,830

 

2282
01:12:25,830 --> 01:12:27,669

 

2283
01:12:27,669 --> 01:12:30,550

 

2284
01:12:30,550 --> 01:12:32,070

 

2285
01:12:32,070 --> 01:12:35,189

 

2286
01:12:35,189 --> 01:12:37,430

 

2287
01:12:37,430 --> 01:12:38,950

 

2288
01:12:38,950 --> 01:12:40,630

 

2289
01:12:40,630 --> 01:12:41,910

 

2290
01:12:41,910 --> 01:12:43,750

 

2291
01:12:43,750 --> 01:12:45,030

 

2292
01:12:45,030 --> 01:12:46,870

 

2293
01:12:46,870 --> 01:12:48,229

 

2294
01:12:48,229 --> 01:12:50,070

 

2295
01:12:50,070 --> 01:12:51,270

 

2296
01:12:51,270 --> 01:12:53,910

 

2297
01:12:53,910 --> 01:12:55,510

 

2298
01:12:55,510 --> 01:12:57,350

 

2299
01:12:57,350 --> 01:12:59,590

 

2300
01:12:59,590 --> 01:13:01,669

 

2301
01:13:01,669 --> 01:13:02,830

 

2302
01:13:02,830 --> 01:13:06,630

 

2303
01:13:06,630 --> 01:13:08,630

 

2304
01:13:08,630 --> 01:13:10,550

 

2305
01:13:10,550 --> 01:13:12,630

 

2306
01:13:12,630 --> 01:13:14,870

 

2307
01:13:14,870 --> 01:13:16,550

 

2308
01:13:16,550 --> 01:13:19,350

 

2309
01:13:19,350 --> 01:13:21,110

 

2310
01:13:21,110 --> 01:13:22,630

 

2311
01:13:22,630 --> 01:13:24,630

 

2312
01:13:24,630 --> 01:13:26,630

 

2313
01:13:26,630 --> 01:13:28,550

 

2314
01:13:28,550 --> 01:13:30,790

 

2315
01:13:30,790 --> 01:13:33,430

 

2316
01:13:33,430 --> 01:13:34,950

 

2317
01:13:34,950 --> 01:13:37,590

 

2318
01:13:37,590 --> 01:13:38,950

 

2319
01:13:38,950 --> 01:13:41,990

 

2320
01:13:41,990 --> 01:13:43,189

 

2321
01:13:43,189 --> 01:13:43,199

 

2322
01:13:43,199 --> 01:13:45,189


2323
01:13:45,189 --> 01:13:47,270

 

2324
01:13:47,270 --> 01:13:50,470

 

2325
01:13:50,470 --> 01:13:50,480

 

2326
01:13:50,480 --> 01:13:53,030


2327
01:13:53,030 --> 01:13:54,870

 

2328
01:13:54,870 --> 01:13:57,990

 

2329
01:13:57,990 --> 01:13:59,750

 

2330
01:13:59,750 --> 01:14:01,910

 

2331
01:14:01,910 --> 01:14:03,669

 

2332
01:14:03,669 --> 01:14:05,430

 

2333
01:14:05,430 --> 01:14:05,440

 

2334
01:14:05,440 --> 01:14:06,870


2335
01:14:06,870 --> 01:14:08,390

 

2336
01:14:08,390 --> 01:14:10,870

 

2337
01:14:10,870 --> 01:14:10,880

 

2338
01:14:10,880 --> 01:14:12,149


2339
01:14:12,149 --> 01:14:14,390

 

2340
01:14:14,390 --> 01:14:14,400

 

2341
01:14:14,400 --> 01:14:17,910


2342
01:14:17,910 --> 01:14:19,590

 

2343
01:14:19,590 --> 01:14:21,990

 

2344
01:14:21,990 --> 01:14:23,510

 

2345
01:14:23,510 --> 01:14:26,229

 

2346
01:14:26,229 --> 01:14:28,550

 

2347
01:14:28,550 --> 01:14:48,630

 

2348
01:14:48,630 --> 01:14:48,640

 

2349
01:14:48,640 --> 01:14:50,719