1
00:00:25,519 --> 00:00:26,710

all right why don't we get why don't we  get started it's uh  2 35  time to begin  so everyone welcome i'm back good to see  you all  and um  well this is a few of you  glad that you're here  um uh  so um  let's see  why don't i uh  get a layout as i usually do what  where we have been where we're going  today i'll talk a little tiny bit about  the homework because i've gotten a  couple questions on that  and then we'll jump in uh so we have  been um  talking about turing machines which is  going to be our  preferred model for the rest of the  semester since turing machines are the  model which we use to capture general  purpose general purpose computing  and we looked at  turing machines and various  um  variations on turing machines  multi-tapes non-deterministic and so on  um  it's a bit recapping  the history of the subject when people  looked at  a variety of different ways of  formalizing the notion of algorithm  and they  showed that all of those  different formalizations were equivalent  to one another which led to the church  turing thesis  that all of these models each of these  models really capture our intuitive idea  of what we mean by  a  procedure or an algorithm um  first for at least for addressing um  you know things like mathematical  problems and and precise uh precise  problems of that kind  so we talked about the church turing  thesis we also talked about a notation  for encodings and turing machines we'll  review that briefly  so today we're going to give a bunch of  examples of  turing machine algorithms for solving a  variety of different problems i should  just say algorithms are really nothing  special about turing machines during  machines are just going to be our formal  counterpart but from now on we're going  to use our um church touring thesis in a  way to just to talk about algorithms in  general because that's really our  interest turing machines is just you  know our way of  reasoning about them mathematically but  we're really ultimately interested in  understanding algorithms  um i'm gonna  in terms of the format of today's class  i'm gonna try a little experiment um  we're gonna have little breaks along the  way and uh in as well as the big coffee  break in the middle uh we're gonna have  a little mini breaks um because i  sometimes feel that there really isn't  enough time for people to be writing  chat uh you know questions in the chat  um  because things just are racing on and so  this way we'll have a little break after  the they have pretty much after each  slide some of them will be a little  longer than others for in case you have  questions you can pose them to me or to  the tas and we'll try to get back to you  on those  so um moving on then so today just as a  quick review uh  turing machines as we set them up  they have  on any input w they have three possible  outcomes the turing machine can hold and  accept  w can hold and reject w  or it can go forever on w which is  rejecting by looping in in our language  a turing machine can recognize a  language  the collection of all strings that it  accepts  and if the turing machine always halts  we say it decides the language and it's  a decider  and so therefore that language is a  decidable language or turing decidable  often we just say decidable because we  don't really have a notion of deciding  in other  models so we often talk about touring  recognizable or just decidable well  we'll sometimes just say recognizable  when we understand that we're talking  about turing machines  we briefly talked about encodings  um  when you write it inside brackets some  objects whatever they are it could be  strings could be machines could be  graphs it could be polynomials  we're representing them as strings  and maybe a collection of objects  together represented as a string  in order so that we can present that  information as an input to a machine  and we talk about  our languages or collections of strings  and a notation for writing a turing  machine is going to be simply that  english description  put inside quotation marks to represent  our informal way of talking about  the formal object that we could produce  if we wanted to but we're never going to  ask you to do that  okay um  so now um  let me see uh  let's just take a quick break as i  promised um  um  if there's any quick questions here you  can ask  [Music]  um  uh let's see  we get a lot of questions here um  all right why don't we move on and uh  some of these things are good questions  if there was something um  you know somebody asked can you how do  you tell if the machine is looping or if  it's really just taking a very long time  um  you can't  that's what we're gonna prove  not in today's lecture but we're gonna  prove that on thursday um  and so  that's uh you just can't tell so you're  gonna if if that's in reference to  problem five you're gonna have to find  some other way of doing solving that  problem without knowing whether the  machine is actually ever going to hold  um  and  somebody asked how can we tell if an  english description is possible for a  turing machine well i mean  um you can always  write down an english description uh for  any machine um  it's uh might be very uh  technical looking but if you can write  it down in a formal way as states and  transitions then you can certainly write  down an english description which would  just be follow those  follow those states um  okay let's let's move on um  so uh  okay this is going to be our first  example  of a  um algorithm that's going to answer a  question about automata  um  and it's a very simple problem it's a  very simple um  problem to solve because we want to  start out easy  um  and it's the problem we'll get the name  of the problem is the acceptance problem  for  deterministic finance acceptance problem  for dfas  and i'm going to express it as i always  do as a language  so this language here i'm calling it a  dfa which stands for the acceptance  problem for dfas  is the collection of pairs  b and w  b is it is a dfa  w is  uh considered to be  some other string which will be an input  to b we'll say well me thinking of it as  an input to be i put the two of them in  brackets to represent the pair of them  as a single string  and it's the you know we're not going to  make explicit what the form of the  encoding is the only important thing is  is that the encoding should be something  simple um but that the turing machine  can decode back into  the  dfa and this input string to that dfa  so  anything reasonable is going to be a  satisfactory encoding from us for us  so this is an encoded of the two of them  into a string and where b is a dfa and b  accepts w  so now if you want to test  if something's a member of adfa a  then  first of all you want to make sure that  the string itself that you're getting  really encodes  a dfa  and a string so it has to be of the  right form  and  uh once you know that  then you have the dfa you have the  string w  and you're then gonna do the obvious  thing which would be to simulate b on w  and see if it's actually accepting w  okay so that's that's what the content  of this slide is i'm just going to write  it down for you um  so i'm going to give a turing machine  which i'm going to call i'm going to  give the name of that turing machine  it's going to be d adfa  to help you remember  the function of this machine this is a  decider  for the language below the adfa language  this is just a name but so nothing fancy  going on here but just to help us  remember because i'm going to refer to  some of these during machines later on  so this is the decider for adfa and i'm  going to describe that machine for you  and that machine decides the adfa  language  um so what does that mean so that  machine i'm describing and now you in  english as i promised  i'm going to take an input string s  um and first it's going to check that s  has the right form  uh as i mentioned has the form which is  the encoding of a dfa and a w  um if it's not of that form the turing  machine should reject that input right  away  now i'm not going to go through the  details of how that turing machine is  going to work though i'll say a little  bit more this time this time only just  to give you a sense of how it actually  might carry that out  but you should believe that if you don't  believe it you can do it with a turing  machine believe you could do it with  your favorite programming language  that's good enough because that's going  to be that's equivalent to a turing  machine  so first you check that the inputs are  the right form then you're going to  simulate the computation of b on w  and then if b ends up in an except state  then we know b is accepting the input  and we should accept and we do  if b does not end up in an accept state  at the end of the end of w  um then we should reject because b is  not accepting w  okay that's my description of this  machine  let's just turn to a little bit of  details just to make sure we're  comfortable with this um  so here is our turing machine  d the decider for adfa  the input to the turing machine as i  mentioned is going to be  uh b and w provided it's of the right  form so that's what the string s is  supposed to be of that form um and what  does that mean it's just an encoding of  the of the machine w and the string  the machine  b and the string w  so here is  let me just write it down here is b  written down in some just completely  explicit way where you're just listing  the states of b  the alphabet of b  the transition function as a table the  start state and the set of um accepting  states just writing it down explicitly  as you might do it if you just want to  describe that machine in a completely  formal way  and then writing down what the string is  um whatever it is  once  d8fa has that as its input it can then  go ahead and do that computation  and you know just  to try to make it a little bit more  explicit i'm going to capture that here  by saying let's  give  uh that turing machine an extra tape  because we already know that the  multi-tape model is equivalent to the  single tape model make it our life  perhaps a little easier  and in the course of doing that  simulation what do we want to keep track  of well what is the current state of  uh b  the dfa as we're reading the the the  symbols of w  and where in w are we at right now so  i'll call that k which is the uh input  head location on w how many symbols of w  have we read  okay and that's what all i'm going to  say about uh what this turing machine d  looks like  but i'm happy to  um  oh there's one more thing i do want to  say further that's coming up um  uh because  pretty much all of the turing machines  that we're going to talk about today and  and going forward are going to often  want to check that their input is of the  correct form i don't want to repeat this  every time because that's going to be  kind of assumed so my shorthand for that  is to say my input is of the form i'm  looking for  and that has built into it the check  that the string the input string is of  that form and we're going to reject if  it is if it is not  so all of our turing machines are going  to start out  on input the string is of a certain form  and then go on and do something with it  okay um  and uh  i thought this is a good way to um  uh  okay so let me try to answer a few of  the questions um that that i've gotten  here uh  um  because i think this is important as a  way of getting us all started  um  now somebody asked me can we use  arguments of this form  um  ken is somebody asking can we use can we  uh  give our description of a procedure if  i'm understanding this correctly as  uh using some other programming language  well typically you just want to make  sure you're understood  if you want to do that on a homework i  wouldn't advocate writing your  algorithm in in java because it's just  going to be hard to read but to write it  down in some  pseudo programming language if you want  just to make sure it's clear that what  what you're doing um probably english is  going to be the easiest for you  um  um  even though this person says he feels it  would be easier to do it in terms of a  formal language well whatever's easier  as long as we can understand it  um now what another this is a good  question here that i got asked what if b  uh here's our b gets into a loop  on w  well that's not going to happen b is a  dfa dfas  on an um  they move from from state to state every  time they read a symbol of w  when they get to the end of w it's the  end of the story there's no more  computation to be done  so we know in exactly how many steps b  is ever going to take on it's going to  take the same number of steps as the  length of the input  that's how many moves it gets to make so  there's never b as the dfa never loops  so that would be a problem if it did  loop but it doesn't and there that input  never does a loop  so have we verified that d as a decider  well i think i just did  d is never going to be  this d  from my standpoint we've said enough  to be sure that d is a decider um  uh there's never any reason for d to be  for  that dadfa turing machine to be getting  into a loop um  the input head location is referring to  where we are on the string w yes  [Music]  and somebody's asking me is this the  level of detail for the homework yes  that's all i want it's all i'm looking  for  okay um  [Music]  let us move on uh  i'm gonna have to  uh otherwise never get anywhere there's  a lot of questions here they're good  questions  um so why don't we uh go on some of  these may get resolved as we're going to  look at additional examples because  that's all of today is pretty much  examples  uh let's talk about the similar problem  the acceptance problem but now for  anaphase  um  so now actually anaphase can loop um so  we have to think about what that  possibly could look at but let's  before we get ahead of ourselves so now  the acceptance problems for anaphase  looks very similar except b is going to  be an nfa  that's going to be a decidable language  too  um  and now we have turing machine a  d  a n f a the decider for a nfa that  decides a nfa  okay so now  uh as promised here is my new form for  writing our turing machine on input bw  we're we're assuming that b you know  based on on the context sometimes you  may want to say at this point what b and  w are but from the context we know what  they are they're going to be an nfa and  an input w for that nfa  oh so  what um i don't want to jump into the  solution uh  first before we actually look at the  solution of this we could you know d  uh the turing machine could simulate the  nfa on input w and you have to be  careful on that simulation that you  don't end up looping um because don't  forget  uh  an nfa could have um epsilon moves and  could be looping on those  epsilon moves and so  that would be a problem if you're not  careful about how you do that simulation  um  now i think if you were going to  simulate an nfa  um  you would be  you wouldn't follow  around loops forever um  uh and i think you can uh without  getting because this is not the way i'm  going to solve the problem you could  find a way to avoid getting caught in in  getting stuck in loops for an nfa um  so  uh even though  um  that looks like it could be a problem in  terms of looping forever it turns out  that it won't be a problem um  it wouldn't be a problem if you're  careful  but i'm not going to solve it that way  anyway because i'm going to illustrate a  different method for solving this  problem and that is we have exhibited  before a way of converting anaphase to  dfas  so my turing machine  is going to solve the a n f a problem by  converting its input which is an n of a  to an equivalent dfa i'm calling the  nfab and the dfa that i got converting  it into b prime  and what's nice about that is that first  of all we already know how to do that  conversion because we um  we essentially went over that in lecture  a few lectures back  and it's spelled out in full detail in  the textbook so that is a conversion we  know how to do we'll assume we know how  to do  and we can  implement that during that conversion on  a turing machine  then once we have the equivalent dfa  what do we do with that  well we've in the previous slide we  showed how to solve the problem for dfas  so if we can convert the anapha to a dfa  and then we already know how to solve  the problem for dfas then we're then  we're done so that's how i'm going to  say we're going to convert the nfa to a  dfa and then i'm going to run that  dadfa  problem on the new machine that i  produced  so remember that the um this machine  here decides the adfa prop  and now i'm going to accept if that new  machine uh if that if that previous  turing machine accepts the a dfa the the  adfa problem um  machine accepts  and um i'm gonna i'm gonna basically do  whatever it does if it accepts i'll  accept if it rejects then i'll reject  um  now um  this is  um  [Music]  uh  so  i guess the thing that this illustrates  is this idea of  using a conversion construction inside a  turing machine  and then a previously constructed turing  machine basically as a subroutine  um  all this is perfectly legal and it's the  kind of thing we're going to be doing a  lot of and that you should be used to  doing that get ready to be doing that on  your homework too  um  and in fact i'll give you a another  little extra hint that problem six can  be solved in this way  okay um  all right so here let's pause briefly um  uh  okay uh  got some interesting questions here  coming up um  uh  you know do somebody ask me do we meet  do we need to be explicit about how  we're going to simulate that uh nfa or  the dfa because we don't know how many  states it has  not knowing how many states you  you do know how many states it has once  it's presented to you on the input you  can see oh this is a machine that has 12  states  because you're given the machine  and then you can do the simulation  um let's see um  and someone is asking me about limits on  the simulation power of a turing machine  uh  that's a question that i'm going to  postpone to later because you're asking  if a turing machine can simulate itself  and we'll talk about things like that  but that's you know in in a few weeks  from now so i'll  hold off on that one um  decidable languages the collection of  decided somebody's asking me a good  question about closure properties of the  class of decidable languages are they  closed under intersection um union and  so on yes  the design  and  the decidable languages are also closed  under complement that should be  something you should think about  but yes that is true  um the recognizable languages however  are closed under union and intersection  but they are not closed under complement  um  so that would that we will prove on  thursday's lecture  so another question is could we have  just run b on w in this in solving this  problem instead of using the reduced  converting it to a new turing machine a  new mission  the b prime well you know yes we could  have just done that um i'm  okay  i think we better move on uh i don't  want to get too bogged down um here  got a lot of questions there so sorry if  i'm not getting to all of the questions  okay um  or you can write to the tas too  obviously i'm sure you are  okay so let's talk about a different  problem  emptiness problem for dfas  okay um  so  now we have here i'm going to give you  now a just  a dfa  b  and no input  and i'm going to ask  is the language of that dfa the the  empty set the empty language  you understand the problem first of all  i'm just handing you an um a dfa and i  want to know does this dfa accept any  strings at all or is it just some  dumb dfa it's just always  very negative dfa it just rejects  everything  um and has the empty language  okay how do you tell  not super hard um if you think about how  you would write a program to do that  or how you do it yourself  so that's a decidable language again um  so gonna give it now a touring machine  decider for that language  um  that decider says  uh well  i'm given that  dfa i want to know if its language is  empty  and the idea is just kind of what you  would think i'm going to see is there a  path from the start state of that dfa to  the an except state of the dfa if there  is such a path  then that dfa is going to have an input  which goes along that path and will be  accepted  and so the language won't be empty  there's no such path then clearly this  dfa can never accept anything  and so the language will be empty  okay now there are many different uh  you know  there are many different path algorithms  um i think would be a little bit  uh sparse of me just  you know  some of you know path algorithms some of  you don't know path checking algorithms  i would like you to just to if you were  giving this kind of an answer on  homework to give me some sense of how  that algorithm is going to work  um  don't be too high level about it  so the one i have in mind is kind of  breadth first search er  if you've heard of that but uh it's very  simple algorithm what i'm going to use  is a kind of a marking procedure so i'm  going to start off by coloring  the  here is this i should have indicated  this is my  dfa b  this is b over here um  should i try  taking a chance of writing on this thing  oops  this is b  oh great  that didn't help  uh  so this is b here and the way i'm going  to  test if it has a path if it accepts any  input is by seeing if there's a path  from the start state to any one of the  except states and i'm going to start it  by marking the start state and then  marking all states that i can get to  from previously marked states  and keep doing that i can't tell i can't  get to anything new  okay so here  there's going to be like a series of  iterations here marking more and more  states until there's nothing new to mark  and then i say did i mark any except  states  okay so let's just see how i write that  down in english  um  so i started marking the start state  uh i repeat until no new state is marked  and that  uh  i'm going to say mark every state that  has an incoming arrow from our  previously marked state  um accept and then once i'm done with  that repeat loop except if no accept  state is marked because that means don't  forget it's a little bit inverted from  what you might think i'm going to accept  if there's no  marked accept state because that means  there's no path  to an accept state from the start state  which means the language is empty  and edfa is the  dfas that have empty language so i  should be accepting those  so except if there's no um way to get to  an accept state no except status is  marked and rejected if some accept state  is marked because then the language is  not empty  okay so that's all i wanted to say about  that  um  can you somebody's asking can you just  say it's something like breadth first  search  as long as you know  the sketchier you are the more chances  that you're going to get caught by the  greater um who's knocking who's going to  be  um you know we have an army of people  grading these problems  and just to stay on this be on the safe  side of sketchiness  and say don't cut too many corners  because you might miss something um  chances are would be okay just to say  breadth research but you know i would  prefer if you you'd be safer if you said  a little bit more than that  okay  oh  um this is a good question here uh  somebody asks uh can we just run the dfa  on all shorts on all strings well first  of all  you know one thing  um to say something bad would be we'll  just feed in all possible strings into  the dfa  and if any one of them except if it  accepts any one of them then we know its  language is not empty  well that's not a good algorithm because  that's going to potentially run forever  um because you know there's lots of  strings there's infinitely many strings  to feed in to that um to that dfa and so  a turing machine  you know if it's trying to be a decider  had better not do any infinite  operations that are potentially going to  go forever um  now this is to be fair to the uh  proposer here the questioner here didn't  ask that says well can we feed an old  strings up to some bound um which would  be the number of states of the machine  in this case and yes that would work but  then you would have to argue  that that's enough  and yes  it is enough um but it wouldn't would  not be enough in answering the problem  just to say  feed it in that number of them and you  know we're done you would have to say  what  um  um  okay um  uh  um  a lot of questions here i'm gonna i'm  gonna move on uh  uh let's see equivalence problem for  dfas  now we're going to take take things to  the next level ask are there two  um uh i'm going to give you two dfas  and i want to know do they describe the  same language do they  do they recognize the same language  okay um  [Music]  so how are we going to do that  so that's a decidable language um here's  the decider  um  [Music]  my input now is going to be two dfas  again represented as a string because  that's what turing machines deal with as  their inputs  but they can unpack that string into two  dfas  and  there are several different ways to do  this problem and i'm sure i'm going to  get uh suggestions with other other ways  to go one thing you could do  is uh just to feed  in  strings up to a certain length  well because you can't just like before  you can't feed in all possible strings  and see if the machines ever behave  differently on any of them um because  that's infinite an infinite operation  and we're a decider we can't do that now  if you're if you want to talk about this  being a recognizer instead of a decider  then you might be able to do something  like that just to make sure you're end  up  you have to be just careful  um let me not say more on that right now  but  certainly for a decider you can't go  forever you can't have infinite  operations  um so  uh you would have to have a cutoff  so you can feed in all possible strings  up to some length say  into a and b and see if there's any  difference now we actually had a problem  on that in the whole in problem set one  um which said if two two dfas have um  unequal languages then they're going to  see a pl a difference that there's going  to be a string which acts differently on  them which is of length at most the  product of the number of states of those  two machines  so it  you know you can either reference that  uh problem that would be an out that  would be an adequate solution or reprove  it or whatever that would be fine in  fact there's you can do even better than  that as the optional problem showed you  only have to go up to the sum of the  number of states not up to the product  but that's actually very difficult to  show  but i don't i'm not going to prove it  that way  i'm going to prove it an entirely  different way which doesn't require any  analysis at all  no proofing proving something about  bounds um i'm going to take advantage of  something we've already shown  and which is i'm going to make a new  fine art automaton a new dfac  built out of a and b  which accepts all the strings on which a  and b disagree  i'll show you how to that's easy to do  so first of all let's in terms of a  picture let's understand what this is so  here we have this is the language of a  this is the language of b  written as a venn diagram and where are  those places where they disagree  um well they're you know either in a but  not in b or in b but not in a i'm  showing it to here in terms of the blue  region  um that actually has a name called the  symmetric difference  of these two of these two sets these are  this  this all of the members which are in  exactly one out of the two but not both  if you can make a machine c that would  accept  uh all of the strings in the blue region  then what do we do with that machine  we test if its language is empty  which is what we've already shown how to  do because if the blue region is empty  that means that l of a equals l of b  okay so  i'm going to make a machine a dfac where  the language of c is exactly that  symmetric difference it's all the  strings in a  intersect with the strings that are not  in b so in a and not in b or  in b and not it then not an a and take  the union of those two parts  and how do we know we can make c well we  have those closure constructions  which we showed several lectures back  those closure constructions can be  implemented on a turing machine  so a turn machine can build the dfac  and then  use that test from  a few slides back the emptiness though  last slide the emptiness tester for dfas  on c to see whether its language is  empty and now if c's language is empty  then we know we can accept because that  means the two the l of a equals l of b  otherwise we can reject  okay  so here's a now i'm going to ask you a  check  um you can also use that time to send me  a few more questions if you want  okay here's my check-in  okay now instead of testing equivalents  of finite of dfas i want to test the  equivalence of regular expressions  um  to  r1 r2 regular expressions are called the  eq regular expressions problem  equivalence of regular expressions can  we now conclude that this problem is  also decidable  either  immediately from stuff we've already  shown or yes but would take some  significant extra work or no because  intersection is not a regular operation  so let's see if i can pull that out here  launch the polling  um  here we go  okay i think we're just about done here  um  five oh five seconds more  okay ready set end  all right  yes the ant's correct answer is a we  have basically already shown this fact  um  because  what why is that because we  have shown that we can convert if you're  given two regular expressions and we  want to test whether they're equivalent  or whether they generate the same  language we can convert them both to  to finite automata  we can convert them to n phase and then  the n phase to dfas  and um then we can apply what we just  showed  about testing equivalence of dfas  so yes it really follows immediately  from stuff we've already shown the  conversion number one and then the  testing equivalents for dfas  um so there's not really any work to do  here and in fact what i'm trying to  illustrate  with this uh check-in  that once you've shown um how to do some  kind of a test for one model it have  going to apply for all of the equivalent  models that we've that we've shown to be  equivalent because the turing machine  can can do the constructions which show  the equivalence  um  okay uh so let's move on um  somebody didn't get the pole  did most people not get the pole  well i think most of you have gotten it  did you  i'm not seeing a lot of complaints so if  you didn't get the poll something is  wrong with your setup and you're going  to have to take the recorded uh uh  check-ins um that are  going to launch right after this lecture  is over sorry  but we just you should figure out what's  wrong with the setup there because i  think most people are getting these  okay  and with that we're going to take a  little break  and then we'll continue on afterwards  now let me know how this is is this  slowing us too you know should i  be speed a little speedier about the um  the  about the little mini breaks that we're  taking or um is this good for you  you know feedback is always i'm trying  to make this as good as i can for for  all of you  okay i i think there's a mixture between  people saying that these breaks are good  some says they're a little a little over  long so i'll try to  tighten them up a little um some some  some folks are saying what  more people should be  uh  asking the tas i don't know how the tas  are doing in terms of their i'll check  with them afterward how well this is  going for them in terms of uh questions  but i think some amount of break is good  um  so that we don't uh so there's time to  be asking asking questions um otherwise  what's the point of having a live  lecture  so we will start promptly  when this timer runs down  um so  uh  be ready to go in 55 seconds from now  just to confirm to show the decidability  of the equivalence of two regular  expressions do we need to show that we  can use a turing machine to convert them  to dfas first  well  i mean any procedure that you can give  if you want to test whether two  regular expressions are equivalent  you can give any procedure for doing  that deciding you want  um i'm just offering one one simple way  to do it that takes advantage of stuff  we've already shown but if you want to  dig down and do some analysis of those  regular expressions to show that they  describe the same language they generate  the same language be my guest i think  that's actually would be complicated to  do that that way okay so we're just  about um ready to go here  uh so let's continue um  uh  and let me take this timer off here  um  all right  now  we are going to talk a little about  context-free grammars  so we talked about decision problems for  finite automata let's talk about some  for grammars um  okay now i'm going to give us an  analogous problem i'm going to give you  a the except i'm calling it the  acceptance problem but just just for  consistency with everything else but  it's really the generating problem so  i'm giving you a grammar g a c a context  free grammar g  and a string that's in a string and i  want to know is it in the language of g  so does g generate w  i'm calling that the a cfg problem  so that's going to be a decidable again  so now let's just think about how that  these are getting slightly harder as  we're moving along  so i'm giving you  a  grammar  and a string  and i want to know does the grammar  generate that string  um  well you know it's not  totally trivial  to solve that  you know one thing you might try doing  is looking at all possible things  all possible derivations  from that grammar  and see if any one of them  leads to w  leads you to generate w  well you have to be careful  because  uh as i as we've shown in some of our  examples  um you actually could have um  because you're allowed to have variables  that can get converted to empty string  you might have very long intermediate  strings being generated from a grammar  which then ultimately give you a small  string of terminals that get generated  a small string in the language that gets  produced  and so it's not clear how you know you  certainly don't want to try every  possible derivation because there's  infinitely many different derivations  most of them generating of course things  that are irrelevant to the string w  but you have to know how to cut things  off  and it's not immediately obvious how you  do that  unless  you have  done  the homework problems that i asked you  to do which i'm sure very many of you  have not done the zerobot point x  problems because there that's going to  come in handy right now  and so i'll i'll help you through that  um  remember i'm hoping you should remember  but you may not have looked at it  uh something called chomsky normal form  which is for context-free grammars  but only allows the rules to be of a  special kind and they have to look like  this they can be a variable that goes to  two variables  on the right-hand side or a variable  that goes to a terminal  those are the only kinds of rules that  you're allowed  there's a special case for the empty  string but let's ignore that you know  for if you have you want to put the the  start variable can also go to the empty  string if you want to have a  the empty string in the language but  that's that's a special case let's  ignore that  these are the only two kinds of rules  that you can have in the chomsky normal  form gram  once you have a chomsky normal form  grammar  um well first of all there's two things  first of all you can always convert any  any context free grammar into chomsky  normal form so that's given in the  textbook  it's very it's sort of the you do the  obvious thing  i'm not going to spend time on it  and you don't have to know it it's it's  kind of just a little bit um  tedious but it's it's straightforward  and it's there if you if you're curious  um  but the second line is the thing that's  important to us  uh which is that if you have a grammar  which in is in chomsky normal form  and a string that's generated  every  derivation of that string  has exactly  two times the length of the string minus  one steps  it's actually if you think about it i  mean this dilemma is very easy to prove  um i think the homework problem  asks you to prove that in the  0.2 or whatever it was um and problem  set one or pub set two when i remember  um  because you can in order to do you know  rules of this kind allow you to make the  string one longer and rules of this kind  allow you to produce an uh an x a new  terminal symbol  and so you're really going to end up  having um  you know if if the length of w is n  you're going to have n minus one of  these and n of those that's why you get  two n minus one  steps but the point is i don't really  care exactly how many it's just that we  have a bound  and once you have that bound  life is good from the point of view of  um  giving a turing machine which is going  to  decide this language  because here's the turing machine what's  going to do with the first thing is it's  going to convert g into chomsky normal  form  that we assume we know how to do  now we're going to try all derivations  but only those of length  2  twice the length of the string minus 1.  um because if any derivation is going to  generate w it has to be this this many  steps  um  now that we know the grammar is in  chomsky normal form  okay so  we have converted this problem of one  that might be a very  unboundedly  lengthy problem into one way you know  it's going to terminate after some fixed  number of steps  and so therefore we can accept if any of  those uh generate w and reject not  okay and so oh so this is uh before  moving on so this uh answers the problem  shows that this language is decidable  the the acfg language  okay so that's something that  you know make sure you understand  um  uh  we're basically trying all derivations  of up to of a certain length because  that's all that's needed when the  grammar is in that form now we're going  to use that to prove a corollary  which is um  which is important for understanding how  everything fits together  and that corollary  states that every context-free language  is a decidable language  every content-free language is decidable  now why does that follow from this  well  um  suppose you have a context-free language  a  we know that language is generated by  some context free grammar g  okay that's what it means  so then  you can take that grammar g and you can  build it into a turing machine so  there's going to be a turing machine  which ha which is  uh  um  constructed  with the knowledge of g  um  and uh that turing machine is going to  take its w  and run the acfg algorithm  um with w combined with the g that's  already built into it  so it's just going to stick that grammar  g in front of w  and now run the ac of g decide  it's going to say does g generate w  well that's going to be yes  every time w is an a  and so this machine here now uh is going  to end up accepting  every string that's in a  because it's every string that g  generates  okay so um  uh  that is i think what i wanted to say  about this now  i feel that this corollary here  throws a little bit of a curveball  curveball um and um  uh we can just pause for a moment here  just to  uh make sure you're  understanding this  so let me  the tricky thing about this corollary  is  that i often get uh a question i often  get  where is  you know when we start off with a  context-free language  who gives a w how do we get g  because we need g to build the turing  machine um m sub g  so we know a is a context free language  but how do we know what g is  well the point is that  uh  we may not know  what g is but we know g exists  because that's a definition  of a being a context-free language  it must have a context-free grammar by  definition  and so because g exists  i now know my turn machine m sub g  exists  and that's enough to know  that  a is decidable because it has a decider  that exists  now if you're not going to tell me the  grammar for g  i'm not going to tell you  the turing machine which decides a  but i know that but both of them exist  so if you tell me g then i can tell you  the turing machine  okay so it's a subtle  tricky issue there a certain little  element maybe of sometimes people call  it non-constructive because we're just  in a sense showing just that something  is existing but um  you know it does the job for us because  it shows that a is a decidable language  okay so not so many questions here maybe  the tas are getting them so let's move  on um here's another check-in  uh  so now can we conclude that a  instead of a cfg a pda is decidable  hey  people are getting this one pretty fast  another 10 seconds  three seconds  okay i'm gonna shut it down  um  end polling  share results  yeah you know i  uh  so this  uh  problem here is apda is decidable it's  really in a sense i was almost wondering  whether or not to give this poll because  it has it's true for the same reason as  the as poll number one um because we  know how to convert pdas  or we stated we can convert pdas to cfgs  and you know that conversion is given in  the book we didn't do in lecture but i  just stated you have to know that fact  but not necessarily know how to do it  that's okay but the fact is true  um the conversion is in the book and it  could be implemented on a turing machine  so if you want to know whether a pda's  language is empty you convert it to a  context-free grammar and then use this  procedure here to test whether it's a  language  not empty i'm sorry  the acceptance problem i just want to  not accept i just want to know does the  pda accept some input  i'm saying it wrong so i want to know  does the pda accept some input i convert  that pda to a grammar  and then i see if the grammar generates  that input because it's an equivalent  grammar  um so again this is using the fact that  grammars and pdas are equivalent and  interconvertible from one to another  just like regular expressions in dfas  from the previous poll  so you need to be comfortable with that  uh because we're going to not even talk  about it anymore we're just going to be  treating those things going back and  forth between them without sometimes  without even any comment  okay  so let's move on uh  emptiness problem for cfgs hopefully  you're getting comfortable with the know  you know the terminology i'm using um so  now the emptiness problem for  context-free grammars  i'm just going to give you a grammar and  i want to know if its language is empty  okay so  remember we did this refined automata by  testing a path  can't you know we don't really have  paths here  you might think testing pairs and push  down automata that's not going to really  work because the stack is there so how  are we going to do that test well  there's something sort of like testing a  path um just working with the grammar  itself kind of working backwards from  the terminals now um i'll kind of  illustrate that here  here's imagine i'm giving you here's a  very simple  grammar and i want to know  does it generate  any strings any strings of term  obviously  only care about strings of terminals  because those are the things that are in  the in the language  so does this grammar generate any  strings  of terminals  so what we're going to answer that is by  a marking procedure but in a sense we're  going to start from the um from the  terminals and work backwards to see if  we can get to the start variable  so first we're going to mark all the  terminal symbols  and then we're going to mark  anything that goes  to a string of completely marked  symbols either terminals or variables  because anything that's marked we know  can derive a string of terminals that's  what it means anything that's that's  blue can derive a string of just  terminals and so now if you have a  collection of those  that are all marked  they together can generate some you know  string of terminals  um together  and so then you can mark the associated  variable so like t goes to a so that may  be over simple but we're going to mark t  here everywhere in the grammar so all  these t's are going to get marked  because we know that t can generate a  string of terminals  now let's take a look at r  r is going to a string  of symbols that are all marked  and that means those symbols can in turn  generate the strings of terminals so we  can mark r2  we can't get mark s because we don't  know yet whether s has some unmarked  thing that it goes to so we don't know  yet whether s can generate a string of  terminals but r we know right now so  we're going to mark r but we then now  that gets us to mark this r and so then  we can go backwards and we can mark s  and we keep doing that until there's  nothing new to mark and here we've  marked everything so clearly there's  nothing more you can mark but you might  stop before you've marked everything  and then you  see  whether you've marked the stark variable  or not and if you have you know the  language is not empty  okay so let's just go through this in in  in in text  for mark all occurrences of terminals in  g  then repeat until no new variables are  marked we mark all occurrences of  variables  a  if a goes to a string of symbols  and all of those symbols were already  marked  because those are the things that  already have been shown to generate a  string of terminals  and so now we're going to reject if the  start status start variable is marked  because that means that the language is  not empty and except if it's not  okay  so  um  let me just just i'll take a couple of  quick quick questions here  okay somebody  um  somebody asked whether  uh  if i understand other regular languages  also decidable well remember the regular  languages are context-free languages and  the context-free languages are decidable  so yes the regular languages are  decidable um  okay i don't know some of those are  going to be too long to answer and  they're trying to come up with  alternative solutions so i think we're  going to move on  um  all right we talked about  um  just like we did for the final automata  we talked about acceptance we talked  about emptiness we talked about  equivalence  so how about the equivalence problem for  context-free grammars  i'm going to give you now two  context-free grammars  and i'd like to know  are those two contexts free grammars  generating the same language  so how might you think about that  well  you know one thing uh you know following  some of the ideas that we've already had  um  you could try  feeding strings in to those grammars we  know how to test whether those  individual grammars can generate those  strings so you can just try feeding  strings in  to g and to h  and seeing whether those grammars ever  disagree  or whether they generate some string  find some string that say g generates  but h does not generate and we can test  that string by string  unfortunately we've got a lot of strings  to test  right that's gonna you know we we would  need to give some bound  if we were going to use that for a  procedure  not clear what the bound is  um  another idea  um  might be to use  the  uh closure construction  uh  that we had from before um so let's  let's mull that over um whether that  might work um but in fact um  [Music]  uh  let me give away the answer here  um  this language is not decidable  there's no algorithm  out there no turing machine but  therefore no algorithm  which can take two grammars  and test whether they generate the same  language or not  seems at first glance kind of surprising  such simple things as context-free  grammars can nonetheless be so  complicated  that there's no procedure out there  which can tell whether the two gram  those two grammars generate the same  language we will show that um  next week  a related problem which is related to  your homework  this uh that's due on  uh thursday uh is testing whether a  grammar is ambiguous  so given a grammar i'd like to know is  is that grammar and ambiguous  grammar or not i mean does it generate  some string  you know in the language of that grammar  in two possibly different ways two or  more different ways  so is there some string um that can be  generated  you know with two different parsers  um  so um the problem of testing whether  grammar is ambiguous  not decidable  so i'm asking you to do something hard  something hard  when you have to produce  that grammar which is unambiguous for  that language um in general  testing whether grammar is ambiguous or  not is not a decidable problem now  hopefully that the grammar that you'll  produce  uh  to show that um you know to get that  unambiguous grammar for that language  that i'm asking you to produce is not  going to require our graders to solve  some undecidable problem that it'll be  clear based on the construction of that  grammar why it's uh not ambiguous so  you'll have to hopefully say some  some explanation of what you're thinking  there  uh  okay um so that's uh  uh and we will prove  that uh the problem of testing ambiguity  is not decidable that's gonna be a  homework problem in problem set three  um okay uh  let's check in here kind of something  that i alluded to but didn't quite  didn't want to give away  uh why not use the same technique  that we use to show equivalence of dfas  is decidable to show that equivalence of  context-free grammars is decidable  obviously something goes wrong because  eqcfg is not decidable why doesn't that  same technique just work  um  well um  what's the answer  oh this is  got a real race here  another 15 seconds this one  it gives you something to mull over  um  all right let's end it  okay you're good to go  at least click something um okay ending  polling  sharing results  okay a bunch of you have thought well  cfgs are generators and dfas are  recognizers and that's the issue well  not really  because  you know you can  we could test  um  equivalence  of regular expressions those are  generators it's nothing to do with being  a generator or not um  um because you know we can convert  regular expressions to dfas and then and  then test equivalence for the dfa so  that it's not really a matter of a  matter of being generated that's not the  issue  the issue is that we can't follow the  same construction that we did to show  eqdfa as decidable because the  context-free  languages are not closed under those  operations we needed to make that  symmetric difference machine  if you remember how that worked  so then i closed under complementation  and not closer intersection we needed  both  in order to build that machine c  um which accepted all the strings that  are sort of in the difference  okay  so let's continue on um  let's move now to turing machines  uh this is where stuff is really going  to start to get interesting  i'm not hoping it's been interesting all  along but maybe even more interesting um  so  let's talk about the acceptance problem  for turing machines atm  this is going to be because this  language is going to become an old  friend  we're just getting just getting to know  it  uh so this is the problem you're given a  turing machine now in an input  and i want to know does m accept that  input  that term does that turning machine  accept its input  um  okay  so that's  going to not be a decidable problem  either so it kind of shifted gears from  a bunch of decidable things to a bunch  of undecidable things  so this is not a decidable language  we will prove that um  on thursday that's going to be the whole  point of thursday's lecture is proving  that atm is undecidable and that's going  to be really a jumping off point for  showing other problems are undecidable  um so that's going to be our first uh  proof of undecidability  um  but we do know  that atm is  recognizable  and that's worth  um  understanding  um for multiple reasons but for one  thing it's going to give us an example  of a problem which we know is  recognizable but not decidable as we  will as will prove undecidability but  it's also  um i think  of  of  of historical importance um  uh  uh this this algorithm for showing it  recognizable so let's go through that  algorithm for it's very simple sort of  doing the obvious thing um  the following turing machine i'm calling  you going to call it u  for a reason that i'll make clear in a  second  that's going to be a recognizer for atm  so it takes as input  an m and a w  and it's just going to simulate m w  pretty much the way  the  um  algorithm the the decider for adfa  worked  but now  the machine instead of being a dfa it's  a turing machine and the turing machine  might go  forever  and so the simulation may not stop  and that's the key difference which  makes it from a decider into a  recognizer  so that simulation um  so you're going to be simulating just  keeping track of the tape of m the  current state of m  um where you know and  proceeding  to modify the tape as m modifies it and  then  if m enters an accept state  then you know m is accepted as input so  you also will enter and accept state so  the machine u  enters the accept state if m observes  during the simulation that m enters an  accept state  uh furthermore if n m enters a reject  state  then u also enters a reject state  okay  now i want to say something beyond that  which i i want you to  pay attention to  um  which is the kind of thing i do see  sometimes people saying  uh we want you to reject if m never  holds  i mean that's also seems like what we  want  because if it never holds then m is  rejecting by looping so you should also  reject  but i don't like that  i don't like that line here  step four of the turing machine  because there's no way for a turing  machine to determine or at least as we  no obvious way uh and in fact it will  not be any way but certainly at this  point no obvious way for m to even tell  for you to tell whether m is holding or  not  uh well certainly tell that is to say it  never holds how can you make that  determination so this is not if i saw  this on a um  on a solution either on an exam or a  homework i would mark you off  this is no good  it's not a legal touring machine action  if m  does not hold on w  um then you should reject  that is correct and you can make that  reasoning external  to the  algorithm of you  but you is going to end up rejecting  because it never holds either  it never actually knows  that m is rejecting w in that case if m  is rejecting by looping it's just  blindly going along and doing the  simulation of m on w  um and we'll end up holding rejecting by  looping if m is rejecting by looping but  that's something that you can argue  if you need to make a proof or make some  sort of reasoning about the machine but  it's not part of the algorithm of the  machine  um  okay now what what's i think from a  historical standpoint it's interesting  about this machine you and why i'm  calling it you  is because this appeared this al this  machine you  appeared in turing's original paper  where he laid out turing machines he  didn't call them touring machines by the  way he called them computing machines  people afterward called them turing  machines  uh  but uh turing called this the universal  computing machine that's his language  actually i just looked at the paper  yesterday um just to refresh my memory  of it um and he gives the description of  the operation of view in gory detail  with all of the transitions and the  states he nails the whole thing down  takes pages and pages and pages  so he gives it gives it there  um so this is the original universal  uh computing mission universal turing  machine and this  it's more than just an idle curiosity  that disappeared in touring's paper  because this actually turned out to be  profoundly influential  in the in computer science because it  really was the first example of a  machine that operated based on a stored  program  it really was a revolutionary idea in  the in those days if you wanted to make  a machine that did something different  you had to wire the machine rewire the  machine  but here's a machine that operated based  on instructions  um  and the instructions in a sense are no  different than the data uh so this is  what's been  come to be known as the von neumann  architecture but von neumann himself  gave credit to turing machine for having  inspired inspired him to think of this  and some people argue that it's really  calling it the binomial a bunch of  people came up with this concept uh  around the same time maybe other people  too  you know there's babbage and so on and  others who um you know out of love lies  also who came up with notions of  programming but i think is a little  different than um  uh than this in concept but anyway  uh this nevertheless played an important  role in the history of the subject  so with that i think we're at a time i'm  going to um uh quickly review where  we've been um so we should just show the  decidability of various problems  um these are all languages that we uh  showed are decidable we showed that atm  is touring recognizable and i think that  was all we had for today um  so um i will uh we will  stop right here  i will stick around take a few questions  and our tas can take a few questions if  you want by chat  um and then i also have my office hours  which will start in like five minutes or  so once i get everything set up on my  head  um  okay  somebody wanted me to review this point  here which i'm happy to do  um  uh  you know  this code here that i'm describing in  english  um  needs to be something that you can  implement  on a turing machine  um  you know we're never going to go through  the  effort of  building the transition functions and  the states and so on but we need to be  sure that we could if  if we had to  and  how could you make  a turing machine do the test  that m doesn't hold  that's something we don't know how to do  i mean  i can see if m holds  enter i mean i can during the simulation  i can see that m has entered the  q reject state or the q accept state so  i can tell  while i'm simulating that it has halted  but  you know how would the machine or how  would you  know  that m is now how would you you know  someone says well  do x if m never holds  well how do you know him how how can you  do the test  that m is not holding  um  not  there's no obvious way to do that in  fact there is no way to do that but you  know as it stands right now you know the  proof would be on you  to um  to show how to implement that on a  machine and there's just no obvious way  to do that so i think that's why you  should you should only put down things  here which you're sure you could  implement  um  you know even if it might take a long  time so you don't have to worry about  how long it would take but you have to  put things down that you are sure you  could at least implement in principle  so someone has asked me about um  the equivalence problem for context-free  grammars uh being unsolvable  uh why couldn't the machine be a  human-level system of logic  so that  the computer could logically deduce  whether or not it was decidable  um  well  sort of that  you know we're taking a turn into  the subject of mathematical logic which  is supposed to kind of  uh formalize reasoning in a way um and  uh  in the end what it really is kind of  come down to that  there are certain  uh grammars  uh which are  equivalent  to one another  but  there's not going to be any way to prove  that they're equivalent in any  reasonable system  um  in equivalence you can always prove  right you can exhibit a string  that one you can show that this grammar  is generating it this grammar is not  generating  this other one is not so uh in  equivalence you can always prove but  equivalence  there are going to be certain pairs of  grammars which are going to be  beyond the capability of any reasonable  formal system to be able to prove that  they're equivalent because you can even  convert them and make those grammars  into something which talk about the  system itself  ultimately you're going to end up you  know with a russell paradox kind of  thing that's maybe going beyond more  than you want to know and i'm happy to  talk about it offline but you know  there's just no way to make a turing  machine which is going to implement sort  of human reasoning and then get the  right answer on all pairs of grammars  just cannot be done  bye bye i'm going to shut down the  meeting though  you

2
00:00:26,710 --> 00:00:29,269
all right why don't we get why don't we  get started it's uh  2 35  time to begin  so everyone welcome i'm back good to see  you all  and um  well this is a few of you  glad that you're here  um uh  so um  let's see  why don't i uh  get a layout as i usually do what  where we have been where we're going  today i'll talk a little tiny bit about  the homework because i've gotten a  couple questions on that  and then we'll jump in uh so we have  been um  talking about turing machines which is  going to be our  preferred model for the rest of the  semester since turing machines are the  model which we use to capture general  purpose general purpose computing  and we looked at  turing machines and various  um  variations on turing machines  multi-tapes non-deterministic and so on  um  it's a bit recapping  the history of the subject when people  looked at  a variety of different ways of  formalizing the notion of algorithm  and they  showed that all of those  different formalizations were equivalent  to one another which led to the church  turing thesis  that all of these models each of these  models really capture our intuitive idea  of what we mean by  a  procedure or an algorithm um  first for at least for addressing um  you know things like mathematical  problems and and precise uh precise  problems of that kind  so we talked about the church turing  thesis we also talked about a notation  for encodings and turing machines we'll  review that briefly  so today we're going to give a bunch of  examples of  turing machine algorithms for solving a  variety of different problems i should  just say algorithms are really nothing  special about turing machines during  machines are just going to be our formal  counterpart but from now on we're going  to use our um church touring thesis in a  way to just to talk about algorithms in  general because that's really our  interest turing machines is just you  know our way of  reasoning about them mathematically but  we're really ultimately interested in  understanding algorithms  um i'm gonna  in terms of the format of today's class  i'm gonna try a little experiment um  we're gonna have little breaks along the  way and uh in as well as the big coffee  break in the middle uh we're gonna have  a little mini breaks um because i  sometimes feel that there really isn't  enough time for people to be writing  chat uh you know questions in the chat  um  because things just are racing on and so  this way we'll have a little break after  the they have pretty much after each  slide some of them will be a little  longer than others for in case you have  questions you can pose them to me or to  the tas and we'll try to get back to you  on those  so um moving on then so today just as a  quick review uh  turing machines as we set them up  they have  on any input w they have three possible  outcomes the turing machine can hold and  accept  w can hold and reject w  or it can go forever on w which is  rejecting by looping in in our language  a turing machine can recognize a  language  the collection of all strings that it  accepts  and if the turing machine always halts  we say it decides the language and it's  a decider  and so therefore that language is a  decidable language or turing decidable  often we just say decidable because we  don't really have a notion of deciding  in other  models so we often talk about touring  recognizable or just decidable well  we'll sometimes just say recognizable  when we understand that we're talking  about turing machines  we briefly talked about encodings  um  when you write it inside brackets some  objects whatever they are it could be  strings could be machines could be  graphs it could be polynomials  we're representing them as strings  and maybe a collection of objects  together represented as a string  in order so that we can present that  information as an input to a machine  and we talk about  our languages or collections of strings  and a notation for writing a turing  machine is going to be simply that  english description  put inside quotation marks to represent  our informal way of talking about  the formal object that we could produce  if we wanted to but we're never going to  ask you to do that  okay um  so now um  let me see uh  let's just take a quick break as i  promised um  um  if there's any quick questions here you  can ask  [Music]  um  uh let's see  we get a lot of questions here um  all right why don't we move on and uh  some of these things are good questions  if there was something um  you know somebody asked can you how do  you tell if the machine is looping or if  it's really just taking a very long time  um  you can't  that's what we're gonna prove  not in today's lecture but we're gonna  prove that on thursday um  and so  that's uh you just can't tell so you're  gonna if if that's in reference to  problem five you're gonna have to find  some other way of doing solving that  problem without knowing whether the  machine is actually ever going to hold  um  and  somebody asked how can we tell if an  english description is possible for a  turing machine well i mean  um you can always  write down an english description uh for  any machine um  it's uh might be very uh  technical looking but if you can write  it down in a formal way as states and  transitions then you can certainly write  down an english description which would  just be follow those  follow those states um  okay let's let's move on um  so uh  okay this is going to be our first  example  of a  um algorithm that's going to answer a  question about automata  um  and it's a very simple problem it's a  very simple um  problem to solve because we want to  start out easy  um  and it's the problem we'll get the name  of the problem is the acceptance problem  for  deterministic finance acceptance problem  for dfas  and i'm going to express it as i always  do as a language  so this language here i'm calling it a  dfa which stands for the acceptance  problem for dfas  is the collection of pairs  b and w  b is it is a dfa  w is  uh considered to be  some other string which will be an input  to b we'll say well me thinking of it as  an input to be i put the two of them in  brackets to represent the pair of them  as a single string  and it's the you know we're not going to  make explicit what the form of the  encoding is the only important thing is  is that the encoding should be something  simple um but that the turing machine  can decode back into  the  dfa and this input string to that dfa  so  anything reasonable is going to be a  satisfactory encoding from us for us  so this is an encoded of the two of them  into a string and where b is a dfa and b  accepts w  so now if you want to test  if something's a member of adfa a  then  first of all you want to make sure that  the string itself that you're getting  really encodes  a dfa  and a string so it has to be of the  right form  and  uh once you know that  then you have the dfa you have the  string w  and you're then gonna do the obvious  thing which would be to simulate b on w  and see if it's actually accepting w  okay so that's that's what the content  of this slide is i'm just going to write  it down for you um  so i'm going to give a turing machine  which i'm going to call i'm going to  give the name of that turing machine  it's going to be d adfa  to help you remember  the function of this machine this is a  decider  for the language below the adfa language  this is just a name but so nothing fancy  going on here but just to help us  remember because i'm going to refer to  some of these during machines later on  so this is the decider for adfa and i'm  going to describe that machine for you  and that machine decides the adfa  language  um so what does that mean so that  machine i'm describing and now you in  english as i promised  i'm going to take an input string s  um and first it's going to check that s  has the right form  uh as i mentioned has the form which is  the encoding of a dfa and a w  um if it's not of that form the turing  machine should reject that input right  away  now i'm not going to go through the  details of how that turing machine is  going to work though i'll say a little  bit more this time this time only just  to give you a sense of how it actually  might carry that out  but you should believe that if you don't  believe it you can do it with a turing  machine believe you could do it with  your favorite programming language  that's good enough because that's going  to be that's equivalent to a turing  machine  so first you check that the inputs are  the right form then you're going to  simulate the computation of b on w  and then if b ends up in an except state  then we know b is accepting the input  and we should accept and we do  if b does not end up in an accept state  at the end of the end of w  um then we should reject because b is  not accepting w  okay that's my description of this  machine  let's just turn to a little bit of  details just to make sure we're  comfortable with this um  so here is our turing machine  d the decider for adfa  the input to the turing machine as i  mentioned is going to be  uh b and w provided it's of the right  form so that's what the string s is  supposed to be of that form um and what  does that mean it's just an encoding of  the of the machine w and the string  the machine  b and the string w  so here is  let me just write it down here is b  written down in some just completely  explicit way where you're just listing  the states of b  the alphabet of b  the transition function as a table the  start state and the set of um accepting  states just writing it down explicitly  as you might do it if you just want to  describe that machine in a completely  formal way  and then writing down what the string is  um whatever it is  once  d8fa has that as its input it can then  go ahead and do that computation  and you know just  to try to make it a little bit more  explicit i'm going to capture that here  by saying let's  give  uh that turing machine an extra tape  because we already know that the  multi-tape model is equivalent to the  single tape model make it our life  perhaps a little easier  and in the course of doing that  simulation what do we want to keep track  of well what is the current state of  uh b  the dfa as we're reading the the the  symbols of w  and where in w are we at right now so  i'll call that k which is the uh input  head location on w how many symbols of w  have we read  okay and that's what all i'm going to  say about uh what this turing machine d  looks like  but i'm happy to  um  oh there's one more thing i do want to  say further that's coming up um  uh because  pretty much all of the turing machines  that we're going to talk about today and  and going forward are going to often  want to check that their input is of the  correct form i don't want to repeat this  every time because that's going to be  kind of assumed so my shorthand for that  is to say my input is of the form i'm  looking for  and that has built into it the check  that the string the input string is of  that form and we're going to reject if  it is if it is not  so all of our turing machines are going  to start out  on input the string is of a certain form  and then go on and do something with it  okay um  and uh  i thought this is a good way to um  uh  okay so let me try to answer a few of  the questions um that that i've gotten  here uh  um  because i think this is important as a  way of getting us all started  um  now somebody asked me can we use  arguments of this form  um  ken is somebody asking can we use can we  uh  give our description of a procedure if  i'm understanding this correctly as  uh using some other programming language  well typically you just want to make  sure you're understood  if you want to do that on a homework i  wouldn't advocate writing your  algorithm in in java because it's just  going to be hard to read but to write it  down in some  pseudo programming language if you want  just to make sure it's clear that what  what you're doing um probably english is  going to be the easiest for you  um  um  even though this person says he feels it  would be easier to do it in terms of a  formal language well whatever's easier  as long as we can understand it  um now what another this is a good  question here that i got asked what if b  uh here's our b gets into a loop  on w  well that's not going to happen b is a  dfa dfas  on an um  they move from from state to state every  time they read a symbol of w  when they get to the end of w it's the  end of the story there's no more  computation to be done  so we know in exactly how many steps b  is ever going to take on it's going to  take the same number of steps as the  length of the input  that's how many moves it gets to make so  there's never b as the dfa never loops  so that would be a problem if it did  loop but it doesn't and there that input  never does a loop  so have we verified that d as a decider  well i think i just did  d is never going to be  this d  from my standpoint we've said enough  to be sure that d is a decider um  uh there's never any reason for d to be  for  that dadfa turing machine to be getting  into a loop um  the input head location is referring to  where we are on the string w yes  [Music]  and somebody's asking me is this the  level of detail for the homework yes  that's all i want it's all i'm looking  for  okay um  [Music]  let us move on uh  i'm gonna have to  uh otherwise never get anywhere there's  a lot of questions here they're good  questions  um so why don't we uh go on some of  these may get resolved as we're going to  look at additional examples because  that's all of today is pretty much  examples  uh let's talk about the similar problem  the acceptance problem but now for  anaphase  um  so now actually anaphase can loop um so  we have to think about what that  possibly could look at but let's  before we get ahead of ourselves so now  the acceptance problems for anaphase  looks very similar except b is going to  be an nfa  that's going to be a decidable language  too  um  and now we have turing machine a  d  a n f a the decider for a nfa that  decides a nfa  okay so now  uh as promised here is my new form for  writing our turing machine on input bw  we're we're assuming that b you know  based on on the context sometimes you  may want to say at this point what b and  w are but from the context we know what  they are they're going to be an nfa and  an input w for that nfa  oh so  what um i don't want to jump into the  solution uh  first before we actually look at the  solution of this we could you know d  uh the turing machine could simulate the  nfa on input w and you have to be  careful on that simulation that you  don't end up looping um because don't  forget  uh  an nfa could have um epsilon moves and  could be looping on those  epsilon moves and so  that would be a problem if you're not  careful about how you do that simulation  um  now i think if you were going to  simulate an nfa  um  you would be  you wouldn't follow  around loops forever um  uh and i think you can uh without  getting because this is not the way i'm  going to solve the problem you could  find a way to avoid getting caught in in  getting stuck in loops for an nfa um  so  uh even though  um  that looks like it could be a problem in  terms of looping forever it turns out  that it won't be a problem um  it wouldn't be a problem if you're  careful  but i'm not going to solve it that way  anyway because i'm going to illustrate a  different method for solving this  problem and that is we have exhibited  before a way of converting anaphase to  dfas  so my turing machine  is going to solve the a n f a problem by  converting its input which is an n of a  to an equivalent dfa i'm calling the  nfab and the dfa that i got converting  it into b prime  and what's nice about that is that first  of all we already know how to do that  conversion because we um  we essentially went over that in lecture  a few lectures back  and it's spelled out in full detail in  the textbook so that is a conversion we  know how to do we'll assume we know how  to do  and we can  implement that during that conversion on  a turing machine  then once we have the equivalent dfa  what do we do with that  well we've in the previous slide we  showed how to solve the problem for dfas  so if we can convert the anapha to a dfa  and then we already know how to solve  the problem for dfas then we're then  we're done so that's how i'm going to  say we're going to convert the nfa to a  dfa and then i'm going to run that  dadfa  problem on the new machine that i  produced  so remember that the um this machine  here decides the adfa prop  and now i'm going to accept if that new  machine uh if that if that previous  turing machine accepts the a dfa the the  adfa problem um  machine accepts  and um i'm gonna i'm gonna basically do  whatever it does if it accepts i'll  accept if it rejects then i'll reject  um  now um  this is  um  [Music]  uh  so  i guess the thing that this illustrates  is this idea of  using a conversion construction inside a  turing machine  and then a previously constructed turing  machine basically as a subroutine  um  all this is perfectly legal and it's the  kind of thing we're going to be doing a  lot of and that you should be used to  doing that get ready to be doing that on  your homework too  um  and in fact i'll give you a another  little extra hint that problem six can  be solved in this way  okay um  all right so here let's pause briefly um  uh  okay uh  got some interesting questions here  coming up um  uh  you know do somebody ask me do we meet  do we need to be explicit about how  we're going to simulate that uh nfa or  the dfa because we don't know how many  states it has  not knowing how many states you  you do know how many states it has once  it's presented to you on the input you  can see oh this is a machine that has 12  states  because you're given the machine  and then you can do the simulation  um let's see um  and someone is asking me about limits on  the simulation power of a turing machine  uh  that's a question that i'm going to  postpone to later because you're asking  if a turing machine can simulate itself  and we'll talk about things like that  but that's you know in in a few weeks  from now so i'll  hold off on that one um  decidable languages the collection of  decided somebody's asking me a good  question about closure properties of the  class of decidable languages are they  closed under intersection um union and  so on yes  the design  and  the decidable languages are also closed  under complement that should be  something you should think about  but yes that is true  um the recognizable languages however  are closed under union and intersection  but they are not closed under complement  um  so that would that we will prove on  thursday's lecture  so another question is could we have  just run b on w in this in solving this  problem instead of using the reduced  converting it to a new turing machine a  new mission  the b prime well you know yes we could  have just done that um i'm  okay  i think we better move on uh i don't  want to get too bogged down um here  got a lot of questions there so sorry if  i'm not getting to all of the questions  okay um  or you can write to the tas too  obviously i'm sure you are  okay so let's talk about a different  problem  emptiness problem for dfas  okay um  so  now we have here i'm going to give you  now a just  a dfa  b  and no input  and i'm going to ask  is the language of that dfa the the  empty set the empty language  you understand the problem first of all  i'm just handing you an um a dfa and i  want to know does this dfa accept any  strings at all or is it just some  dumb dfa it's just always  very negative dfa it just rejects  everything  um and has the empty language  okay how do you tell  not super hard um if you think about how  you would write a program to do that  or how you do it yourself  so that's a decidable language again um  so gonna give it now a touring machine  decider for that language  um  that decider says  uh well  i'm given that  dfa i want to know if its language is  empty  and the idea is just kind of what you  would think i'm going to see is there a  path from the start state of that dfa to  the an except state of the dfa if there  is such a path  then that dfa is going to have an input  which goes along that path and will be  accepted  and so the language won't be empty  there's no such path then clearly this  dfa can never accept anything  and so the language will be empty  okay now there are many different uh  you know  there are many different path algorithms  um i think would be a little bit  uh sparse of me just  you know  some of you know path algorithms some of  you don't know path checking algorithms  i would like you to just to if you were  giving this kind of an answer on  homework to give me some sense of how  that algorithm is going to work  um  don't be too high level about it  so the one i have in mind is kind of  breadth first search er  if you've heard of that but uh it's very  simple algorithm what i'm going to use  is a kind of a marking procedure so i'm  going to start off by coloring  the  here is this i should have indicated  this is my  dfa b  this is b over here um  should i try  taking a chance of writing on this thing  oops  this is b  oh great  that didn't help  uh  so this is b here and the way i'm going  to  test if it has a path if it accepts any  input is by seeing if there's a path  from the start state to any one of the  except states and i'm going to start it  by marking the start state and then  marking all states that i can get to  from previously marked states  and keep doing that i can't tell i can't  get to anything new  okay so here  there's going to be like a series of  iterations here marking more and more  states until there's nothing new to mark  and then i say did i mark any except  states  okay so let's just see how i write that  down in english  um  so i started marking the start state  uh i repeat until no new state is marked  and that  uh  i'm going to say mark every state that  has an incoming arrow from our  previously marked state  um accept and then once i'm done with  that repeat loop except if no accept  state is marked because that means don't  forget it's a little bit inverted from  what you might think i'm going to accept  if there's no  marked accept state because that means  there's no path  to an accept state from the start state  which means the language is empty  and edfa is the  dfas that have empty language so i  should be accepting those  so except if there's no um way to get to  an accept state no except status is  marked and rejected if some accept state  is marked because then the language is  not empty  okay so that's all i wanted to say about  that  um  can you somebody's asking can you just  say it's something like breadth first  search  as long as you know  the sketchier you are the more chances  that you're going to get caught by the  greater um who's knocking who's going to  be  um you know we have an army of people  grading these problems  and just to stay on this be on the safe  side of sketchiness  and say don't cut too many corners  because you might miss something um  chances are would be okay just to say  breadth research but you know i would  prefer if you you'd be safer if you said  a little bit more than that  okay  oh  um this is a good question here uh  somebody asks uh can we just run the dfa  on all shorts on all strings well first  of all  you know one thing  um to say something bad would be we'll  just feed in all possible strings into  the dfa  and if any one of them except if it  accepts any one of them then we know its  language is not empty  well that's not a good algorithm because  that's going to potentially run forever  um because you know there's lots of  strings there's infinitely many strings  to feed in to that um to that dfa and so  a turing machine  you know if it's trying to be a decider  had better not do any infinite  operations that are potentially going to  go forever um  now this is to be fair to the uh  proposer here the questioner here didn't  ask that says well can we feed an old  strings up to some bound um which would  be the number of states of the machine  in this case and yes that would work but  then you would have to argue  that that's enough  and yes  it is enough um but it wouldn't would  not be enough in answering the problem  just to say  feed it in that number of them and you  know we're done you would have to say  what  um  um  okay um  uh  um  a lot of questions here i'm gonna i'm  gonna move on uh  uh let's see equivalence problem for  dfas  now we're going to take take things to  the next level ask are there two  um uh i'm going to give you two dfas  and i want to know do they describe the  same language do they  do they recognize the same language  okay um  [Music]  so how are we going to do that  so that's a decidable language um here's  the decider  um  [Music]  my input now is going to be two dfas  again represented as a string because  that's what turing machines deal with as  their inputs  but they can unpack that string into two  dfas  and  there are several different ways to do  this problem and i'm sure i'm going to  get uh suggestions with other other ways  to go one thing you could do  is uh just to feed  in  strings up to a certain length  well because you can't just like before  you can't feed in all possible strings  and see if the machines ever behave  differently on any of them um because  that's infinite an infinite operation  and we're a decider we can't do that now  if you're if you want to talk about this  being a recognizer instead of a decider  then you might be able to do something  like that just to make sure you're end  up  you have to be just careful  um let me not say more on that right now  but  certainly for a decider you can't go  forever you can't have infinite  operations  um so  uh you would have to have a cutoff  so you can feed in all possible strings  up to some length say  into a and b and see if there's any  difference now we actually had a problem  on that in the whole in problem set one  um which said if two two dfas have um  unequal languages then they're going to  see a pl a difference that there's going  to be a string which acts differently on  them which is of length at most the  product of the number of states of those  two machines  so it  you know you can either reference that  uh problem that would be an out that  would be an adequate solution or reprove  it or whatever that would be fine in  fact there's you can do even better than  that as the optional problem showed you  only have to go up to the sum of the  number of states not up to the product  but that's actually very difficult to  show  but i don't i'm not going to prove it  that way  i'm going to prove it an entirely  different way which doesn't require any  analysis at all  no proofing proving something about  bounds um i'm going to take advantage of  something we've already shown  and which is i'm going to make a new  fine art automaton a new dfac  built out of a and b  which accepts all the strings on which a  and b disagree  i'll show you how to that's easy to do  so first of all let's in terms of a  picture let's understand what this is so  here we have this is the language of a  this is the language of b  written as a venn diagram and where are  those places where they disagree  um well they're you know either in a but  not in b or in b but not in a i'm  showing it to here in terms of the blue  region  um that actually has a name called the  symmetric difference  of these two of these two sets these are  this  this all of the members which are in  exactly one out of the two but not both  if you can make a machine c that would  accept  uh all of the strings in the blue region  then what do we do with that machine  we test if its language is empty  which is what we've already shown how to  do because if the blue region is empty  that means that l of a equals l of b  okay so  i'm going to make a machine a dfac where  the language of c is exactly that  symmetric difference it's all the  strings in a  intersect with the strings that are not  in b so in a and not in b or  in b and not it then not an a and take  the union of those two parts  and how do we know we can make c well we  have those closure constructions  which we showed several lectures back  those closure constructions can be  implemented on a turing machine  so a turn machine can build the dfac  and then  use that test from  a few slides back the emptiness though  last slide the emptiness tester for dfas  on c to see whether its language is  empty and now if c's language is empty  then we know we can accept because that  means the two the l of a equals l of b  otherwise we can reject  okay  so here's a now i'm going to ask you a  check  um you can also use that time to send me  a few more questions if you want  okay here's my check-in  okay now instead of testing equivalents  of finite of dfas i want to test the  equivalence of regular expressions  um  to  r1 r2 regular expressions are called the  eq regular expressions problem  equivalence of regular expressions can  we now conclude that this problem is  also decidable  either  immediately from stuff we've already  shown or yes but would take some  significant extra work or no because  intersection is not a regular operation  so let's see if i can pull that out here  launch the polling  um  here we go  okay i think we're just about done here  um  five oh five seconds more  okay ready set end  all right  yes the ant's correct answer is a we  have basically already shown this fact  um  because  what why is that because we  have shown that we can convert if you're  given two regular expressions and we  want to test whether they're equivalent  or whether they generate the same  language we can convert them both to  to finite automata  we can convert them to n phase and then  the n phase to dfas  and um then we can apply what we just  showed  about testing equivalence of dfas  so yes it really follows immediately  from stuff we've already shown the  conversion number one and then the  testing equivalents for dfas  um so there's not really any work to do  here and in fact what i'm trying to  illustrate  with this uh check-in  that once you've shown um how to do some  kind of a test for one model it have  going to apply for all of the equivalent  models that we've that we've shown to be  equivalent because the turing machine  can can do the constructions which show  the equivalence  um  okay uh so let's move on um  somebody didn't get the pole  did most people not get the pole  well i think most of you have gotten it  did you  i'm not seeing a lot of complaints so if  you didn't get the poll something is  wrong with your setup and you're going  to have to take the recorded uh uh  check-ins um that are  going to launch right after this lecture  is over sorry  but we just you should figure out what's  wrong with the setup there because i  think most people are getting these  okay  and with that we're going to take a  little break  and then we'll continue on afterwards  now let me know how this is is this  slowing us too you know should i  be speed a little speedier about the um  the  about the little mini breaks that we're  taking or um is this good for you  you know feedback is always i'm trying  to make this as good as i can for for  all of you  okay i i think there's a mixture between  people saying that these breaks are good  some says they're a little a little over  long so i'll try to  tighten them up a little um some some  some folks are saying what  more people should be  uh  asking the tas i don't know how the tas  are doing in terms of their i'll check  with them afterward how well this is  going for them in terms of uh questions  but i think some amount of break is good  um  so that we don't uh so there's time to  be asking asking questions um otherwise  what's the point of having a live  lecture  so we will start promptly  when this timer runs down  um so  uh  be ready to go in 55 seconds from now  just to confirm to show the decidability  of the equivalence of two regular  expressions do we need to show that we  can use a turing machine to convert them  to dfas first  well  i mean any procedure that you can give  if you want to test whether two  regular expressions are equivalent  you can give any procedure for doing  that deciding you want  um i'm just offering one one simple way  to do it that takes advantage of stuff  we've already shown but if you want to  dig down and do some analysis of those  regular expressions to show that they  describe the same language they generate  the same language be my guest i think  that's actually would be complicated to  do that that way okay so we're just  about um ready to go here  uh so let's continue um  uh  and let me take this timer off here  um  all right  now  we are going to talk a little about  context-free grammars  so we talked about decision problems for  finite automata let's talk about some  for grammars um  okay now i'm going to give us an  analogous problem i'm going to give you  a the except i'm calling it the  acceptance problem but just just for  consistency with everything else but  it's really the generating problem so  i'm giving you a grammar g a c a context  free grammar g  and a string that's in a string and i  want to know is it in the language of g  so does g generate w  i'm calling that the a cfg problem  so that's going to be a decidable again  so now let's just think about how that  these are getting slightly harder as  we're moving along  so i'm giving you  a  grammar  and a string  and i want to know does the grammar  generate that string  um  well you know it's not  totally trivial  to solve that  you know one thing you might try doing  is looking at all possible things  all possible derivations  from that grammar  and see if any one of them  leads to w  leads you to generate w  well you have to be careful  because  uh as i as we've shown in some of our  examples  um you actually could have um  because you're allowed to have variables  that can get converted to empty string  you might have very long intermediate  strings being generated from a grammar  which then ultimately give you a small  string of terminals that get generated  a small string in the language that gets  produced  and so it's not clear how you know you  certainly don't want to try every  possible derivation because there's  infinitely many different derivations  most of them generating of course things  that are irrelevant to the string w  but you have to know how to cut things  off  and it's not immediately obvious how you  do that  unless  you have  done  the homework problems that i asked you  to do which i'm sure very many of you  have not done the zerobot point x  problems because there that's going to  come in handy right now  and so i'll i'll help you through that  um  remember i'm hoping you should remember  but you may not have looked at it  uh something called chomsky normal form  which is for context-free grammars  but only allows the rules to be of a  special kind and they have to look like  this they can be a variable that goes to  two variables  on the right-hand side or a variable  that goes to a terminal  those are the only kinds of rules that  you're allowed  there's a special case for the empty  string but let's ignore that you know  for if you have you want to put the the  start variable can also go to the empty  string if you want to have a  the empty string in the language but  that's that's a special case let's  ignore that  these are the only two kinds of rules  that you can have in the chomsky normal  form gram  once you have a chomsky normal form  grammar  um well first of all there's two things  first of all you can always convert any  any context free grammar into chomsky  normal form so that's given in the  textbook  it's very it's sort of the you do the  obvious thing  i'm not going to spend time on it  and you don't have to know it it's it's  kind of just a little bit um  tedious but it's it's straightforward  and it's there if you if you're curious  um  but the second line is the thing that's  important to us  uh which is that if you have a grammar  which in is in chomsky normal form  and a string that's generated  every  derivation of that string  has exactly  two times the length of the string minus  one steps  it's actually if you think about it i  mean this dilemma is very easy to prove  um i think the homework problem  asks you to prove that in the  0.2 or whatever it was um and problem  set one or pub set two when i remember  um  because you can in order to do you know  rules of this kind allow you to make the  string one longer and rules of this kind  allow you to produce an uh an x a new  terminal symbol  and so you're really going to end up  having um  you know if if the length of w is n  you're going to have n minus one of  these and n of those that's why you get  two n minus one  steps but the point is i don't really  care exactly how many it's just that we  have a bound  and once you have that bound  life is good from the point of view of  um  giving a turing machine which is going  to  decide this language  because here's the turing machine what's  going to do with the first thing is it's  going to convert g into chomsky normal  form  that we assume we know how to do  now we're going to try all derivations  but only those of length  2  twice the length of the string minus 1.  um because if any derivation is going to  generate w it has to be this this many  steps  um  now that we know the grammar is in  chomsky normal form  okay so  we have converted this problem of one  that might be a very  unboundedly  lengthy problem into one way you know  it's going to terminate after some fixed  number of steps  and so therefore we can accept if any of  those uh generate w and reject not  okay and so oh so this is uh before  moving on so this uh answers the problem  shows that this language is decidable  the the acfg language  okay so that's something that  you know make sure you understand  um  uh  we're basically trying all derivations  of up to of a certain length because  that's all that's needed when the  grammar is in that form now we're going  to use that to prove a corollary  which is um  which is important for understanding how  everything fits together  and that corollary  states that every context-free language  is a decidable language  every content-free language is decidable  now why does that follow from this  well  um  suppose you have a context-free language  a  we know that language is generated by  some context free grammar g  okay that's what it means  so then  you can take that grammar g and you can  build it into a turing machine so  there's going to be a turing machine  which ha which is  uh  um  constructed  with the knowledge of g  um  and uh that turing machine is going to  take its w  and run the acfg algorithm  um with w combined with the g that's  already built into it  so it's just going to stick that grammar  g in front of w  and now run the ac of g decide  it's going to say does g generate w  well that's going to be yes  every time w is an a  and so this machine here now uh is going  to end up accepting  every string that's in a  because it's every string that g  generates  okay so um  uh  that is i think what i wanted to say  about this now  i feel that this corollary here  throws a little bit of a curveball  curveball um and um  uh we can just pause for a moment here  just to  uh make sure you're  understanding this  so let me  the tricky thing about this corollary  is  that i often get uh a question i often  get  where is  you know when we start off with a  context-free language  who gives a w how do we get g  because we need g to build the turing  machine um m sub g  so we know a is a context free language  but how do we know what g is  well the point is that  uh  we may not know  what g is but we know g exists  because that's a definition  of a being a context-free language  it must have a context-free grammar by  definition  and so because g exists  i now know my turn machine m sub g  exists  and that's enough to know  that  a is decidable because it has a decider  that exists  now if you're not going to tell me the  grammar for g  i'm not going to tell you  the turing machine which decides a  but i know that but both of them exist  so if you tell me g then i can tell you  the turing machine  okay so it's a subtle  tricky issue there a certain little  element maybe of sometimes people call  it non-constructive because we're just  in a sense showing just that something  is existing but um  you know it does the job for us because  it shows that a is a decidable language  okay so not so many questions here maybe  the tas are getting them so let's move  on um here's another check-in  uh  so now can we conclude that a  instead of a cfg a pda is decidable  hey  people are getting this one pretty fast  another 10 seconds  three seconds  okay i'm gonna shut it down  um  end polling  share results  yeah you know i  uh  so this  uh  problem here is apda is decidable it's  really in a sense i was almost wondering  whether or not to give this poll because  it has it's true for the same reason as  the as poll number one um because we  know how to convert pdas  or we stated we can convert pdas to cfgs  and you know that conversion is given in  the book we didn't do in lecture but i  just stated you have to know that fact  but not necessarily know how to do it  that's okay but the fact is true  um the conversion is in the book and it  could be implemented on a turing machine  so if you want to know whether a pda's  language is empty you convert it to a  context-free grammar and then use this  procedure here to test whether it's a  language  not empty i'm sorry  the acceptance problem i just want to  not accept i just want to know does the  pda accept some input  i'm saying it wrong so i want to know  does the pda accept some input i convert  that pda to a grammar  and then i see if the grammar generates  that input because it's an equivalent  grammar  um so again this is using the fact that  grammars and pdas are equivalent and  interconvertible from one to another  just like regular expressions in dfas  from the previous poll  so you need to be comfortable with that  uh because we're going to not even talk  about it anymore we're just going to be  treating those things going back and  forth between them without sometimes  without even any comment  okay  so let's move on uh  emptiness problem for cfgs hopefully  you're getting comfortable with the know  you know the terminology i'm using um so  now the emptiness problem for  context-free grammars  i'm just going to give you a grammar and  i want to know if its language is empty  okay so  remember we did this refined automata by  testing a path  can't you know we don't really have  paths here  you might think testing pairs and push  down automata that's not going to really  work because the stack is there so how  are we going to do that test well  there's something sort of like testing a  path um just working with the grammar  itself kind of working backwards from  the terminals now um i'll kind of  illustrate that here  here's imagine i'm giving you here's a  very simple  grammar and i want to know  does it generate  any strings any strings of term  obviously  only care about strings of terminals  because those are the things that are in  the in the language  so does this grammar generate any  strings  of terminals  so what we're going to answer that is by  a marking procedure but in a sense we're  going to start from the um from the  terminals and work backwards to see if  we can get to the start variable  so first we're going to mark all the  terminal symbols  and then we're going to mark  anything that goes  to a string of completely marked  symbols either terminals or variables  because anything that's marked we know  can derive a string of terminals that's  what it means anything that's that's  blue can derive a string of just  terminals and so now if you have a  collection of those  that are all marked  they together can generate some you know  string of terminals  um together  and so then you can mark the associated  variable so like t goes to a so that may  be over simple but we're going to mark t  here everywhere in the grammar so all  these t's are going to get marked  because we know that t can generate a  string of terminals  now let's take a look at r  r is going to a string  of symbols that are all marked  and that means those symbols can in turn  generate the strings of terminals so we  can mark r2  we can't get mark s because we don't  know yet whether s has some unmarked  thing that it goes to so we don't know  yet whether s can generate a string of  terminals but r we know right now so  we're going to mark r but we then now  that gets us to mark this r and so then  we can go backwards and we can mark s  and we keep doing that until there's  nothing new to mark and here we've  marked everything so clearly there's  nothing more you can mark but you might  stop before you've marked everything  and then you  see  whether you've marked the stark variable  or not and if you have you know the  language is not empty  okay so let's just go through this in in  in in text  for mark all occurrences of terminals in  g  then repeat until no new variables are  marked we mark all occurrences of  variables  a  if a goes to a string of symbols  and all of those symbols were already  marked  because those are the things that  already have been shown to generate a  string of terminals  and so now we're going to reject if the  start status start variable is marked  because that means that the language is  not empty and except if it's not  okay  so  um  let me just just i'll take a couple of  quick quick questions here  okay somebody  um  somebody asked whether  uh  if i understand other regular languages  also decidable well remember the regular  languages are context-free languages and  the context-free languages are decidable  so yes the regular languages are  decidable um  okay i don't know some of those are  going to be too long to answer and  they're trying to come up with  alternative solutions so i think we're  going to move on  um  all right we talked about  um  just like we did for the final automata  we talked about acceptance we talked  about emptiness we talked about  equivalence  so how about the equivalence problem for  context-free grammars  i'm going to give you now two  context-free grammars  and i'd like to know  are those two contexts free grammars  generating the same language  so how might you think about that  well  you know one thing uh you know following  some of the ideas that we've already had  um  you could try  feeding strings in to those grammars we  know how to test whether those  individual grammars can generate those  strings so you can just try feeding  strings in  to g and to h  and seeing whether those grammars ever  disagree  or whether they generate some string  find some string that say g generates  but h does not generate and we can test  that string by string  unfortunately we've got a lot of strings  to test  right that's gonna you know we we would  need to give some bound  if we were going to use that for a  procedure  not clear what the bound is  um  another idea  um  might be to use  the  uh closure construction  uh  that we had from before um so let's  let's mull that over um whether that  might work um but in fact um  [Music]  uh  let me give away the answer here  um  this language is not decidable  there's no algorithm  out there no turing machine but  therefore no algorithm  which can take two grammars  and test whether they generate the same  language or not  seems at first glance kind of surprising  such simple things as context-free  grammars can nonetheless be so  complicated  that there's no procedure out there  which can tell whether the two gram  those two grammars generate the same  language we will show that um  next week  a related problem which is related to  your homework  this uh that's due on  uh thursday uh is testing whether a  grammar is ambiguous  so given a grammar i'd like to know is  is that grammar and ambiguous  grammar or not i mean does it generate  some string  you know in the language of that grammar  in two possibly different ways two or  more different ways  so is there some string um that can be  generated  you know with two different parsers  um  so um the problem of testing whether  grammar is ambiguous  not decidable  so i'm asking you to do something hard  something hard  when you have to produce  that grammar which is unambiguous for  that language um in general  testing whether grammar is ambiguous or  not is not a decidable problem now  hopefully that the grammar that you'll  produce  uh  to show that um you know to get that  unambiguous grammar for that language  that i'm asking you to produce is not  going to require our graders to solve  some undecidable problem that it'll be  clear based on the construction of that  grammar why it's uh not ambiguous so  you'll have to hopefully say some  some explanation of what you're thinking  there  uh  okay um so that's uh  uh and we will prove  that uh the problem of testing ambiguity  is not decidable that's gonna be a  homework problem in problem set three  um okay uh  let's check in here kind of something  that i alluded to but didn't quite  didn't want to give away  uh why not use the same technique  that we use to show equivalence of dfas  is decidable to show that equivalence of  context-free grammars is decidable  obviously something goes wrong because  eqcfg is not decidable why doesn't that  same technique just work  um  well um  what's the answer  oh this is  got a real race here  another 15 seconds this one  it gives you something to mull over  um  all right let's end it  okay you're good to go  at least click something um okay ending  polling  sharing results  okay a bunch of you have thought well  cfgs are generators and dfas are  recognizers and that's the issue well  not really  because  you know you can  we could test  um  equivalence  of regular expressions those are  generators it's nothing to do with being  a generator or not um  um because you know we can convert  regular expressions to dfas and then and  then test equivalence for the dfa so  that it's not really a matter of a  matter of being generated that's not the  issue  the issue is that we can't follow the  same construction that we did to show  eqdfa as decidable because the  context-free  languages are not closed under those  operations we needed to make that  symmetric difference machine  if you remember how that worked  so then i closed under complementation  and not closer intersection we needed  both  in order to build that machine c  um which accepted all the strings that  are sort of in the difference  okay  so let's continue on um  let's move now to turing machines  uh this is where stuff is really going  to start to get interesting  i'm not hoping it's been interesting all  along but maybe even more interesting um  so  let's talk about the acceptance problem  for turing machines atm  this is going to be because this  language is going to become an old  friend  we're just getting just getting to know  it  uh so this is the problem you're given a  turing machine now in an input  and i want to know does m accept that  input  that term does that turning machine  accept its input  um  okay  so that's  going to not be a decidable problem  either so it kind of shifted gears from  a bunch of decidable things to a bunch  of undecidable things  so this is not a decidable language  we will prove that um  on thursday that's going to be the whole  point of thursday's lecture is proving  that atm is undecidable and that's going  to be really a jumping off point for  showing other problems are undecidable  um so that's going to be our first uh  proof of undecidability  um  but we do know  that atm is  recognizable  and that's worth  um  understanding  um for multiple reasons but for one  thing it's going to give us an example  of a problem which we know is  recognizable but not decidable as we  will as will prove undecidability but  it's also  um i think  of  of  of historical importance um  uh  uh this this algorithm for showing it  recognizable so let's go through that  algorithm for it's very simple sort of  doing the obvious thing um  the following turing machine i'm calling  you going to call it u  for a reason that i'll make clear in a  second  that's going to be a recognizer for atm  so it takes as input  an m and a w  and it's just going to simulate m w  pretty much the way  the  um  algorithm the the decider for adfa  worked  but now  the machine instead of being a dfa it's  a turing machine and the turing machine  might go  forever  and so the simulation may not stop  and that's the key difference which  makes it from a decider into a  recognizer  so that simulation um  so you're going to be simulating just  keeping track of the tape of m the  current state of m  um where you know and  proceeding  to modify the tape as m modifies it and  then  if m enters an accept state  then you know m is accepted as input so  you also will enter and accept state so  the machine u  enters the accept state if m observes  during the simulation that m enters an  accept state  uh furthermore if n m enters a reject  state  then u also enters a reject state  okay  now i want to say something beyond that  which i i want you to  pay attention to  um  which is the kind of thing i do see  sometimes people saying  uh we want you to reject if m never  holds  i mean that's also seems like what we  want  because if it never holds then m is  rejecting by looping so you should also  reject  but i don't like that  i don't like that line here  step four of the turing machine  because there's no way for a turing  machine to determine or at least as we  no obvious way uh and in fact it will  not be any way but certainly at this  point no obvious way for m to even tell  for you to tell whether m is holding or  not  uh well certainly tell that is to say it  never holds how can you make that  determination so this is not if i saw  this on a um  on a solution either on an exam or a  homework i would mark you off  this is no good  it's not a legal touring machine action  if m  does not hold on w  um then you should reject  that is correct and you can make that  reasoning external  to the  algorithm of you  but you is going to end up rejecting  because it never holds either  it never actually knows  that m is rejecting w in that case if m  is rejecting by looping it's just  blindly going along and doing the  simulation of m on w  um and we'll end up holding rejecting by  looping if m is rejecting by looping but  that's something that you can argue  if you need to make a proof or make some  sort of reasoning about the machine but  it's not part of the algorithm of the  machine  um  okay now what what's i think from a  historical standpoint it's interesting  about this machine you and why i'm  calling it you  is because this appeared this al this  machine you  appeared in turing's original paper  where he laid out turing machines he  didn't call them touring machines by the  way he called them computing machines  people afterward called them turing  machines  uh  but uh turing called this the universal  computing machine that's his language  actually i just looked at the paper  yesterday um just to refresh my memory  of it um and he gives the description of  the operation of view in gory detail  with all of the transitions and the  states he nails the whole thing down  takes pages and pages and pages  so he gives it gives it there  um so this is the original universal  uh computing mission universal turing  machine and this  it's more than just an idle curiosity  that disappeared in touring's paper  because this actually turned out to be  profoundly influential  in the in computer science because it  really was the first example of a  machine that operated based on a stored  program  it really was a revolutionary idea in  the in those days if you wanted to make  a machine that did something different  you had to wire the machine rewire the  machine  but here's a machine that operated based  on instructions  um  and the instructions in a sense are no  different than the data uh so this is  what's been  come to be known as the von neumann  architecture but von neumann himself  gave credit to turing machine for having  inspired inspired him to think of this  and some people argue that it's really  calling it the binomial a bunch of  people came up with this concept uh  around the same time maybe other people  too  you know there's babbage and so on and  others who um you know out of love lies  also who came up with notions of  programming but i think is a little  different than um  uh than this in concept but anyway  uh this nevertheless played an important  role in the history of the subject  so with that i think we're at a time i'm  going to um uh quickly review where  we've been um so we should just show the  decidability of various problems  um these are all languages that we uh  showed are decidable we showed that atm  is touring recognizable and i think that  was all we had for today um  so um i will uh we will  stop right here  i will stick around take a few questions  and our tas can take a few questions if  you want by chat  um and then i also have my office hours  which will start in like five minutes or  so once i get everything set up on my  head  um  okay  somebody wanted me to review this point  here which i'm happy to do  um  uh  you know  this code here that i'm describing in  english  um  needs to be something that you can  implement  on a turing machine  um  you know we're never going to go through  the  effort of  building the transition functions and  the states and so on but we need to be  sure that we could if  if we had to  and  how could you make  a turing machine do the test  that m doesn't hold  that's something we don't know how to do  i mean  i can see if m holds  enter i mean i can during the simulation  i can see that m has entered the  q reject state or the q accept state so  i can tell  while i'm simulating that it has halted  but  you know how would the machine or how  would you  know  that m is now how would you you know  someone says well  do x if m never holds  well how do you know him how how can you  do the test  that m is not holding  um  not  there's no obvious way to do that in  fact there is no way to do that but you  know as it stands right now you know the  proof would be on you  to um  to show how to implement that on a  machine and there's just no obvious way  to do that so i think that's why you  should you should only put down things  here which you're sure you could  implement  um  you know even if it might take a long  time so you don't have to worry about  how long it would take but you have to  put things down that you are sure you  could at least implement in principle  so someone has asked me about um  the equivalence problem for context-free  grammars uh being unsolvable  uh why couldn't the machine be a  human-level system of logic  so that  the computer could logically deduce  whether or not it was decidable  um  well  sort of that  you know we're taking a turn into  the subject of mathematical logic which  is supposed to kind of  uh formalize reasoning in a way um and  uh  in the end what it really is kind of  come down to that  there are certain  uh grammars  uh which are  equivalent  to one another  but  there's not going to be any way to prove  that they're equivalent in any  reasonable system  um  in equivalence you can always prove  right you can exhibit a string  that one you can show that this grammar  is generating it this grammar is not  generating  this other one is not so uh in  equivalence you can always prove but  equivalence  there are going to be certain pairs of  grammars which are going to be  beyond the capability of any reasonable  formal system to be able to prove that  they're equivalent because you can even  convert them and make those grammars  into something which talk about the  system itself  ultimately you're going to end up you  know with a russell paradox kind of  thing that's maybe going beyond more  than you want to know and i'm happy to  talk about it offline but you know  there's just no way to make a turing  machine which is going to implement sort  of human reasoning and then get the  right answer on all pairs of grammars  just cannot be done  bye bye i'm going to shut down the  meeting though  you
 

3
00:00:29,269 --> 00:00:30,550

 

4
00:00:30,550 --> 00:00:32,630

 

5
00:00:32,630 --> 00:00:35,510

 

6
00:00:35,510 --> 00:00:36,549

 

7
00:00:36,549 --> 00:00:38,389

 

8
00:00:38,389 --> 00:00:40,630

 

9
00:00:40,630 --> 00:00:42,830

 

10
00:00:42,830 --> 00:00:44,150

 

11
00:00:44,150 --> 00:00:46,790

 

12
00:00:46,790 --> 00:00:48,069

 

13
00:00:48,069 --> 00:00:49,670

 

14
00:00:49,670 --> 00:00:52,069

 

15
00:00:52,069 --> 00:00:53,590

 

16
00:00:53,590 --> 00:00:55,510

 

17
00:00:55,510 --> 00:00:56,709

 

18
00:00:56,709 --> 00:00:58,630

 

19
00:00:58,630 --> 00:01:02,229

 

20
00:01:02,229 --> 00:01:04,549

 

21
00:01:04,549 --> 00:01:06,789

 

22
00:01:06,789 --> 00:01:08,950

 

23
00:01:08,950 --> 00:01:10,630

 

24
00:01:10,630 --> 00:01:14,070

 

25
00:01:14,070 --> 00:01:16,950

 

26
00:01:16,950 --> 00:01:20,149

 

27
00:01:20,149 --> 00:01:22,630

 

28
00:01:22,630 --> 00:01:24,830

 

29
00:01:24,830 --> 00:01:24,840

 

30
00:01:24,840 --> 00:01:26,710


31
00:01:26,710 --> 00:01:28,710

 

32
00:01:28,710 --> 00:01:32,069

 

33
00:01:32,069 --> 00:01:32,079

 

34
00:01:32,079 --> 00:01:33,429


35
00:01:33,429 --> 00:01:35,270

 

36
00:01:35,270 --> 00:01:37,270

 

37
00:01:37,270 --> 00:01:38,390

 

38
00:01:38,390 --> 00:01:40,789

 

39
00:01:40,789 --> 00:01:43,270

 

40
00:01:43,270 --> 00:01:44,789

 

41
00:01:44,789 --> 00:01:47,030

 

42
00:01:47,030 --> 00:01:49,350

 

43
00:01:49,350 --> 00:01:51,429

 

44
00:01:51,429 --> 00:01:52,830

 

45
00:01:52,830 --> 00:01:55,429

 

46
00:01:55,429 --> 00:01:58,230

 

47
00:01:58,230 --> 00:02:00,069

 

48
00:02:00,069 --> 00:02:00,079

 

49
00:02:00,079 --> 00:02:01,510


50
00:02:01,510 --> 00:02:05,670

 

51
00:02:05,670 --> 00:02:09,029

 

52
00:02:09,029 --> 00:02:10,389

 

53
00:02:10,389 --> 00:02:12,949

 

54
00:02:12,949 --> 00:02:15,270

 

55
00:02:15,270 --> 00:02:16,790

 

56
00:02:16,790 --> 00:02:19,030

 

57
00:02:19,030 --> 00:02:20,869

 

58
00:02:20,869 --> 00:02:24,070

 

59
00:02:24,070 --> 00:02:25,430

 

60
00:02:25,430 --> 00:02:28,150

 

61
00:02:28,150 --> 00:02:29,910

 

62
00:02:29,910 --> 00:02:31,830

 

63
00:02:31,830 --> 00:02:33,430

 

64
00:02:33,430 --> 00:02:34,949

 

65
00:02:34,949 --> 00:02:37,190

 

66
00:02:37,190 --> 00:02:39,589

 

67
00:02:39,589 --> 00:02:43,110

 

68
00:02:43,110 --> 00:02:44,790

 

69
00:02:44,790 --> 00:02:45,750

 

70
00:02:45,750 --> 00:02:47,910

 

71
00:02:47,910 --> 00:02:50,309

 

72
00:02:50,309 --> 00:02:51,990

 

73
00:02:51,990 --> 00:02:53,350

 

74
00:02:53,350 --> 00:02:55,509

 

75
00:02:55,509 --> 00:02:57,509

 

76
00:02:57,509 --> 00:02:59,750

 

77
00:02:59,750 --> 00:03:02,869

 

78
00:03:02,869 --> 00:03:04,710

 

79
00:03:04,710 --> 00:03:07,509

 

80
00:03:07,509 --> 00:03:08,869

 

81
00:03:08,869 --> 00:03:11,030

 

82
00:03:11,030 --> 00:03:12,470

 

83
00:03:12,470 --> 00:03:15,430

 

84
00:03:15,430 --> 00:03:18,070

 

85
00:03:18,070 --> 00:03:18,080

 

86
00:03:18,080 --> 00:03:18,949


87
00:03:18,949 --> 00:03:21,430

 

88
00:03:21,430 --> 00:03:23,110

 

89
00:03:23,110 --> 00:03:24,550

 

90
00:03:24,550 --> 00:03:25,910

 

91
00:03:25,910 --> 00:03:28,470

 

92
00:03:28,470 --> 00:03:30,149

 

93
00:03:30,149 --> 00:03:32,630

 

94
00:03:32,630 --> 00:03:34,149

 

95
00:03:34,149 --> 00:03:37,750

 

96
00:03:37,750 --> 00:03:40,229

 

97
00:03:40,229 --> 00:03:43,750

 

98
00:03:43,750 --> 00:03:44,949

 

99
00:03:44,949 --> 00:03:48,149

 

100
00:03:48,149 --> 00:03:50,149

 

101
00:03:50,149 --> 00:03:50,159

 

102
00:03:50,159 --> 00:03:51,110


103
00:03:51,110 --> 00:03:54,309

 

104
00:03:54,309 --> 00:03:57,509

 

105
00:03:57,509 --> 00:04:02,470

 

106
00:04:02,470 --> 00:04:04,390

 

107
00:04:04,390 --> 00:04:04,400

 

108
00:04:04,400 --> 00:04:05,670


109
00:04:05,670 --> 00:04:07,110

 

110
00:04:07,110 --> 00:04:07,120

 

111
00:04:07,120 --> 00:04:08,550


112
00:04:08,550 --> 00:04:10,630

 

113
00:04:10,630 --> 00:04:12,390

 

114
00:04:12,390 --> 00:04:13,589

 

115
00:04:13,589 --> 00:04:15,429

 

116
00:04:15,429 --> 00:04:17,430

 

117
00:04:17,430 --> 00:04:19,270

 

118
00:04:19,270 --> 00:04:21,509

 

119
00:04:21,509 --> 00:04:22,790

 

120
00:04:22,790 --> 00:04:24,950

 

121
00:04:24,950 --> 00:04:27,030

 

122
00:04:27,030 --> 00:04:28,550

 

123
00:04:28,550 --> 00:04:30,390

 

124
00:04:30,390 --> 00:04:33,189

 

125
00:04:33,189 --> 00:04:35,510

 

126
00:04:35,510 --> 00:04:35,520

 

127
00:04:35,520 --> 00:04:37,270


128
00:04:37,270 --> 00:04:39,430

 

129
00:04:39,430 --> 00:04:40,870

 

130
00:04:40,870 --> 00:04:42,870

 

131
00:04:42,870 --> 00:04:46,150

 

132
00:04:46,150 --> 00:04:49,350

 

133
00:04:49,350 --> 00:04:50,710

 

134
00:04:50,710 --> 00:04:52,870

 

135
00:04:52,870 --> 00:04:54,390

 

136
00:04:54,390 --> 00:04:57,270

 

137
00:04:57,270 --> 00:04:58,629

 

138
00:04:58,629 --> 00:05:02,710

 

139
00:05:02,710 --> 00:05:04,230

 

140
00:05:04,230 --> 00:05:06,950

 

141
00:05:06,950 --> 00:05:08,870

 

142
00:05:08,870 --> 00:05:11,350

 

143
00:05:11,350 --> 00:05:13,510

 

144
00:05:13,510 --> 00:05:15,510

 

145
00:05:15,510 --> 00:05:17,189

 

146
00:05:17,189 --> 00:05:19,749

 

147
00:05:19,749 --> 00:05:21,590

 

148
00:05:21,590 --> 00:05:27,749

 

149
00:05:27,749 --> 00:05:31,590

 

150
00:05:31,590 --> 00:05:33,110

 

151
00:05:33,110 --> 00:05:38,870

 

152
00:05:38,870 --> 00:05:38,880

 

153
00:05:38,880 --> 00:05:40,390


154
00:05:40,390 --> 00:05:41,909

 

155
00:05:41,909 --> 00:05:43,450

 

156
00:05:43,450 --> 00:05:43,460

 

157
00:05:43,460 --> 00:05:57,990


158
00:05:57,990 --> 00:05:58,000

 

159
00:05:58,000 --> 00:06:11,189


160
00:06:11,189 --> 00:06:13,189

 

161
00:06:13,189 --> 00:06:17,990

 

162
00:06:17,990 --> 00:06:20,390

 

163
00:06:20,390 --> 00:06:21,749

 

164
00:06:21,749 --> 00:06:23,590

 

165
00:06:23,590 --> 00:06:25,749

 

166
00:06:25,749 --> 00:06:28,469

 

167
00:06:28,469 --> 00:06:30,790

 

168
00:06:30,790 --> 00:06:30,800

 

169
00:06:30,800 --> 00:06:31,909


170
00:06:31,909 --> 00:06:33,430

 

171
00:06:33,430 --> 00:06:35,029

 

172
00:06:35,029 --> 00:06:36,309

 

173
00:06:36,309 --> 00:06:38,710

 

174
00:06:38,710 --> 00:06:39,909

 

175
00:06:39,909 --> 00:06:41,749

 

176
00:06:41,749 --> 00:06:43,430

 

177
00:06:43,430 --> 00:06:45,350

 

178
00:06:45,350 --> 00:06:46,710

 

179
00:06:46,710 --> 00:06:48,309

 

180
00:06:48,309 --> 00:06:50,390

 

181
00:06:50,390 --> 00:06:50,400

 

182
00:06:50,400 --> 00:06:54,469


183
00:06:54,469 --> 00:06:54,479

 

184
00:06:54,479 --> 00:06:55,589


185
00:06:55,589 --> 00:06:57,189

 

186
00:06:57,189 --> 00:06:58,790

 

187
00:06:58,790 --> 00:07:01,029

 

188
00:07:01,029 --> 00:07:04,150

 

189
00:07:04,150 --> 00:07:06,150

 

190
00:07:06,150 --> 00:07:07,749

 

191
00:07:07,749 --> 00:07:10,629

 

192
00:07:10,629 --> 00:07:12,390

 

193
00:07:12,390 --> 00:07:14,790

 

194
00:07:14,790 --> 00:07:16,309

 

195
00:07:16,309 --> 00:07:18,309

 

196
00:07:18,309 --> 00:07:20,070

 

197
00:07:20,070 --> 00:07:22,550

 

198
00:07:22,550 --> 00:07:25,350

 

199
00:07:25,350 --> 00:07:29,110

 

200
00:07:29,110 --> 00:07:30,950

 

201
00:07:30,950 --> 00:07:30,960

 

202
00:07:30,960 --> 00:07:32,390


203
00:07:32,390 --> 00:07:34,309

 

204
00:07:34,309 --> 00:07:37,270

 

205
00:07:37,270 --> 00:07:40,230

 

206
00:07:40,230 --> 00:07:40,240

 

207
00:07:40,240 --> 00:07:41,270


208
00:07:41,270 --> 00:07:42,870

 

209
00:07:42,870 --> 00:07:45,589

 

210
00:07:45,589 --> 00:07:47,270

 

211
00:07:47,270 --> 00:07:48,869

 

212
00:07:48,869 --> 00:07:48,879

 

213
00:07:48,879 --> 00:07:49,670


214
00:07:49,670 --> 00:07:51,350

 

215
00:07:51,350 --> 00:07:53,749

 

216
00:07:53,749 --> 00:07:53,759

 

217
00:07:53,759 --> 00:07:54,869


218
00:07:54,869 --> 00:07:57,110

 

219
00:07:57,110 --> 00:07:59,350

 

220
00:07:59,350 --> 00:08:01,430

 

221
00:08:01,430 --> 00:08:03,990

 

222
00:08:03,990 --> 00:08:06,629

 

223
00:08:06,629 --> 00:08:08,309

 

224
00:08:08,309 --> 00:08:10,710

 

225
00:08:10,710 --> 00:08:14,150

 

226
00:08:14,150 --> 00:08:15,589

 

227
00:08:15,589 --> 00:08:17,510

 

228
00:08:17,510 --> 00:08:19,110

 

229
00:08:19,110 --> 00:08:20,710

 

230
00:08:20,710 --> 00:08:22,710

 

231
00:08:22,710 --> 00:08:24,629

 

232
00:08:24,629 --> 00:08:27,029

 

233
00:08:27,029 --> 00:08:29,510

 

234
00:08:29,510 --> 00:08:31,110

 

235
00:08:31,110 --> 00:08:33,029

 

236
00:08:33,029 --> 00:08:34,949

 

237
00:08:34,949 --> 00:08:36,949

 

238
00:08:36,949 --> 00:08:38,709

 

239
00:08:38,709 --> 00:08:41,990

 

240
00:08:41,990 --> 00:08:44,630

 

241
00:08:44,630 --> 00:08:44,640

 

242
00:08:44,640 --> 00:08:45,750


243
00:08:45,750 --> 00:08:48,949

 

244
00:08:48,949 --> 00:08:48,959

 

245
00:08:48,959 --> 00:08:49,670


246
00:08:49,670 --> 00:08:51,750

 

247
00:08:51,750 --> 00:08:54,870

 

248
00:08:54,870 --> 00:08:57,110

 

249
00:08:57,110 --> 00:09:00,070

 

250
00:09:00,070 --> 00:09:01,509

 

251
00:09:01,509 --> 00:09:03,430

 

252
00:09:03,430 --> 00:09:07,910

 

253
00:09:07,910 --> 00:09:07,920

 

254
00:09:07,920 --> 00:09:09,030


255
00:09:09,030 --> 00:09:10,470

 

256
00:09:10,470 --> 00:09:13,430

 

257
00:09:13,430 --> 00:09:15,590

 

258
00:09:15,590 --> 00:09:16,870

 

259
00:09:16,870 --> 00:09:18,470

 

260
00:09:18,470 --> 00:09:20,150

 

261
00:09:20,150 --> 00:09:20,160

 

262
00:09:20,160 --> 00:09:21,269


263
00:09:21,269 --> 00:09:22,870

 

264
00:09:22,870 --> 00:09:24,870

 

265
00:09:24,870 --> 00:09:26,150

 

266
00:09:26,150 --> 00:09:28,070

 

267
00:09:28,070 --> 00:09:31,190

 

268
00:09:31,190 --> 00:09:35,269

 

269
00:09:35,269 --> 00:09:37,590

 

270
00:09:37,590 --> 00:09:38,949

 

271
00:09:38,949 --> 00:09:40,630

 

272
00:09:40,630 --> 00:09:42,070

 

273
00:09:42,070 --> 00:09:43,269

 

274
00:09:43,269 --> 00:09:44,630

 

275
00:09:44,630 --> 00:09:49,030

 

276
00:09:49,030 --> 00:09:50,630

 

277
00:09:50,630 --> 00:09:52,470

 

278
00:09:52,470 --> 00:09:52,480

 

279
00:09:52,480 --> 00:09:54,150


280
00:09:54,150 --> 00:09:57,269

 

281
00:09:57,269 --> 00:09:59,269

 

282
00:09:59,269 --> 00:10:01,350

 

283
00:10:01,350 --> 00:10:03,350

 

284
00:10:03,350 --> 00:10:06,790

 

285
00:10:06,790 --> 00:10:09,750

 

286
00:10:09,750 --> 00:10:11,430

 

287
00:10:11,430 --> 00:10:13,590

 

288
00:10:13,590 --> 00:10:13,600

 

289
00:10:13,600 --> 00:10:15,590


290
00:10:15,590 --> 00:10:17,990

 

291
00:10:17,990 --> 00:10:19,829

 

292
00:10:19,829 --> 00:10:21,910

 

293
00:10:21,910 --> 00:10:25,190

 

294
00:10:25,190 --> 00:10:27,829

 

295
00:10:27,829 --> 00:10:29,670

 

296
00:10:29,670 --> 00:10:32,550

 

297
00:10:32,550 --> 00:10:36,389

 

298
00:10:36,389 --> 00:10:38,790

 

299
00:10:38,790 --> 00:10:40,389

 

300
00:10:40,389 --> 00:10:40,399

 

301
00:10:40,399 --> 00:10:41,990


302
00:10:41,990 --> 00:10:43,269

 

303
00:10:43,269 --> 00:10:44,870

 

304
00:10:44,870 --> 00:10:46,710

 

305
00:10:46,710 --> 00:10:49,750

 

306
00:10:49,750 --> 00:10:51,509

 

307
00:10:51,509 --> 00:10:52,949

 

308
00:10:52,949 --> 00:10:55,509

 

309
00:10:55,509 --> 00:10:56,710

 

310
00:10:56,710 --> 00:10:57,829

 

311
00:10:57,829 --> 00:10:59,030

 

312
00:10:59,030 --> 00:11:00,069

 

313
00:11:00,069 --> 00:11:01,350

 

314
00:11:01,350 --> 00:11:01,360

 

315
00:11:01,360 --> 00:11:03,509


316
00:11:03,509 --> 00:11:04,949

 

317
00:11:04,949 --> 00:11:06,389

 

318
00:11:06,389 --> 00:11:08,870

 

319
00:11:08,870 --> 00:11:11,509

 

320
00:11:11,509 --> 00:11:13,190

 

321
00:11:13,190 --> 00:11:15,269

 

322
00:11:15,269 --> 00:11:17,509

 

323
00:11:17,509 --> 00:11:19,590

 

324
00:11:19,590 --> 00:11:22,550

 

325
00:11:22,550 --> 00:11:23,990

 

326
00:11:23,990 --> 00:11:26,230

 

327
00:11:26,230 --> 00:11:26,240

 

328
00:11:26,240 --> 00:11:28,710


329
00:11:28,710 --> 00:11:30,550

 

330
00:11:30,550 --> 00:11:31,829

 

331
00:11:31,829 --> 00:11:33,990

 

332
00:11:33,990 --> 00:11:37,350

 

333
00:11:37,350 --> 00:11:40,710

 

334
00:11:40,710 --> 00:11:42,230

 

335
00:11:42,230 --> 00:11:43,990

 

336
00:11:43,990 --> 00:11:46,630

 

337
00:11:46,630 --> 00:11:48,310

 

338
00:11:48,310 --> 00:11:50,949

 

339
00:11:50,949 --> 00:11:52,949

 

340
00:11:52,949 --> 00:11:55,509

 

341
00:11:55,509 --> 00:11:56,550

 

342
00:11:56,550 --> 00:11:58,790

 

343
00:11:58,790 --> 00:12:00,150

 

344
00:12:00,150 --> 00:12:02,550

 

345
00:12:02,550 --> 00:12:04,150

 

346
00:12:04,150 --> 00:12:06,230

 

347
00:12:06,230 --> 00:12:07,509

 

348
00:12:07,509 --> 00:12:09,110

 

349
00:12:09,110 --> 00:12:11,670

 

350
00:12:11,670 --> 00:12:14,069

 

351
00:12:14,069 --> 00:12:16,230

 

352
00:12:16,230 --> 00:12:18,150

 

353
00:12:18,150 --> 00:12:19,910

 

354
00:12:19,910 --> 00:12:21,030

 

355
00:12:21,030 --> 00:12:23,590

 

356
00:12:23,590 --> 00:12:26,550

 

357
00:12:26,550 --> 00:12:26,560

 

358
00:12:26,560 --> 00:12:27,670


359
00:12:27,670 --> 00:12:30,710

 

360
00:12:30,710 --> 00:12:33,110

 

361
00:12:33,110 --> 00:12:35,110

 

362
00:12:35,110 --> 00:12:36,550

 

363
00:12:36,550 --> 00:12:38,790

 

364
00:12:38,790 --> 00:12:40,230

 

365
00:12:40,230 --> 00:12:40,240

 

366
00:12:40,240 --> 00:12:41,110


367
00:12:41,110 --> 00:12:43,110

 

368
00:12:43,110 --> 00:12:44,310

 

369
00:12:44,310 --> 00:12:45,990

 

370
00:12:45,990 --> 00:12:47,590

 

371
00:12:47,590 --> 00:12:49,190

 

372
00:12:49,190 --> 00:12:50,470

 

373
00:12:50,470 --> 00:12:52,150

 

374
00:12:52,150 --> 00:12:55,430

 

375
00:12:55,430 --> 00:12:56,710

 

376
00:12:56,710 --> 00:12:59,590

 

377
00:12:59,590 --> 00:13:00,949

 

378
00:13:00,949 --> 00:13:03,269

 

379
00:13:03,269 --> 00:13:06,069

 

380
00:13:06,069 --> 00:13:09,509

 

381
00:13:09,509 --> 00:13:12,150

 

382
00:13:12,150 --> 00:13:14,550

 

383
00:13:14,550 --> 00:13:18,230

 

384
00:13:18,230 --> 00:13:19,430

 

385
00:13:19,430 --> 00:13:21,430

 

386
00:13:21,430 --> 00:13:21,440

 

387
00:13:21,440 --> 00:13:22,389


388
00:13:22,389 --> 00:13:23,910

 

389
00:13:23,910 --> 00:13:26,949

 

390
00:13:26,949 --> 00:13:29,110

 

391
00:13:29,110 --> 00:13:30,949

 

392
00:13:30,949 --> 00:13:32,629

 

393
00:13:32,629 --> 00:13:34,949

 

394
00:13:34,949 --> 00:13:36,870

 

395
00:13:36,870 --> 00:13:38,870

 

396
00:13:38,870 --> 00:13:40,230

 

397
00:13:40,230 --> 00:13:42,870

 

398
00:13:42,870 --> 00:13:45,509

 

399
00:13:45,509 --> 00:13:46,790

 

400
00:13:46,790 --> 00:13:49,350

 

401
00:13:49,350 --> 00:13:51,269

 

402
00:13:51,269 --> 00:13:53,590

 

403
00:13:53,590 --> 00:13:55,350

 

404
00:13:55,350 --> 00:13:57,430

 

405
00:13:57,430 --> 00:13:59,350

 

406
00:13:59,350 --> 00:14:02,310

 

407
00:14:02,310 --> 00:14:05,189

 

408
00:14:05,189 --> 00:14:06,550

 

409
00:14:06,550 --> 00:14:08,230

 

410
00:14:08,230 --> 00:14:11,990

 

411
00:14:11,990 --> 00:14:12,000

 

412
00:14:12,000 --> 00:14:13,110


413
00:14:13,110 --> 00:14:14,790

 

414
00:14:14,790 --> 00:14:17,269

 

415
00:14:17,269 --> 00:14:19,030

 

416
00:14:19,030 --> 00:14:19,040

 

417
00:14:19,040 --> 00:14:21,110


418
00:14:21,110 --> 00:14:22,710

 

419
00:14:22,710 --> 00:14:24,790

 

420
00:14:24,790 --> 00:14:24,800

 

421
00:14:24,800 --> 00:14:25,670


422
00:14:25,670 --> 00:14:26,949

 

423
00:14:26,949 --> 00:14:28,629

 

424
00:14:28,629 --> 00:14:28,639

 

425
00:14:28,639 --> 00:14:31,189


426
00:14:31,189 --> 00:14:34,790

 

427
00:14:34,790 --> 00:14:34,800

 

428
00:14:34,800 --> 00:14:36,389


429
00:14:36,389 --> 00:14:38,470

 

430
00:14:38,470 --> 00:14:40,629

 

431
00:14:40,629 --> 00:14:43,030

 

432
00:14:43,030 --> 00:14:44,310

 

433
00:14:44,310 --> 00:14:45,750

 

434
00:14:45,750 --> 00:14:47,590

 

435
00:14:47,590 --> 00:14:50,470

 

436
00:14:50,470 --> 00:14:52,629

 

437
00:14:52,629 --> 00:14:54,150

 

438
00:14:54,150 --> 00:14:55,350

 

439
00:14:55,350 --> 00:14:57,189

 

440
00:14:57,189 --> 00:14:58,949

 

441
00:14:58,949 --> 00:15:00,790

 

442
00:15:00,790 --> 00:15:02,470

 

443
00:15:02,470 --> 00:15:02,480

 

444
00:15:02,480 --> 00:15:04,629


445
00:15:04,629 --> 00:15:04,639

 

446
00:15:04,639 --> 00:15:06,150


447
00:15:06,150 --> 00:15:08,150

 

448
00:15:08,150 --> 00:15:10,389

 

449
00:15:10,389 --> 00:15:12,790

 

450
00:15:12,790 --> 00:15:14,790

 

451
00:15:14,790 --> 00:15:17,030

 

452
00:15:17,030 --> 00:15:20,870

 

453
00:15:20,870 --> 00:15:23,829

 

454
00:15:23,829 --> 00:15:26,069

 

455
00:15:26,069 --> 00:15:28,230

 

456
00:15:28,230 --> 00:15:30,150

 

457
00:15:30,150 --> 00:15:32,069

 

458
00:15:32,069 --> 00:15:34,470

 

459
00:15:34,470 --> 00:15:36,389

 

460
00:15:36,389 --> 00:15:38,150

 

461
00:15:38,150 --> 00:15:39,350

 

462
00:15:39,350 --> 00:15:41,030

 

463
00:15:41,030 --> 00:15:43,350

 

464
00:15:43,350 --> 00:15:45,350

 

465
00:15:45,350 --> 00:15:46,629

 

466
00:15:46,629 --> 00:15:48,069

 

467
00:15:48,069 --> 00:15:49,910

 

468
00:15:49,910 --> 00:15:53,430

 

469
00:15:53,430 --> 00:15:55,110

 

470
00:15:55,110 --> 00:15:57,910

 

471
00:15:57,910 --> 00:16:00,790

 

472
00:16:00,790 --> 00:16:03,110

 

473
00:16:03,110 --> 00:16:05,749

 

474
00:16:05,749 --> 00:16:07,749

 

475
00:16:07,749 --> 00:16:09,749

 

476
00:16:09,749 --> 00:16:12,150

 

477
00:16:12,150 --> 00:16:16,069

 

478
00:16:16,069 --> 00:16:18,629

 

479
00:16:18,629 --> 00:16:18,639

 

480
00:16:18,639 --> 00:16:19,350


481
00:16:19,350 --> 00:16:22,310

 

482
00:16:22,310 --> 00:16:24,389

 

483
00:16:24,389 --> 00:16:26,069

 

484
00:16:26,069 --> 00:16:29,060

 

485
00:16:29,060 --> 00:16:29,070

 

486
00:16:29,070 --> 00:16:34,389


487
00:16:34,389 --> 00:16:35,670

 

488
00:16:35,670 --> 00:16:37,829

 

489
00:16:37,829 --> 00:16:39,350

 

490
00:16:39,350 --> 00:16:39,360

 

491
00:16:39,360 --> 00:16:41,350


492
00:16:41,350 --> 00:16:42,630

 

493
00:16:42,630 --> 00:16:42,640

 

494
00:16:42,640 --> 00:16:44,310


495
00:16:44,310 --> 00:16:47,030

 

496
00:16:47,030 --> 00:16:48,470

 

497
00:16:48,470 --> 00:16:50,230

 

498
00:16:50,230 --> 00:16:51,509

 

499
00:16:51,509 --> 00:16:51,519

 

500
00:16:51,519 --> 00:16:52,550


501
00:16:52,550 --> 00:16:55,269

 

502
00:16:55,269 --> 00:16:57,030

 

503
00:16:57,030 --> 00:16:58,389

 

504
00:16:58,389 --> 00:16:59,829

 

505
00:16:59,829 --> 00:16:59,839

 

506
00:16:59,839 --> 00:17:01,189


507
00:17:01,189 --> 00:17:03,910

 

508
00:17:03,910 --> 00:17:05,350

 

509
00:17:05,350 --> 00:17:05,360

 

510
00:17:05,360 --> 00:17:07,669


511
00:17:07,669 --> 00:17:07,679

 

512
00:17:07,679 --> 00:17:09,110


513
00:17:09,110 --> 00:17:11,909

 

514
00:17:11,909 --> 00:17:13,669

 

515
00:17:13,669 --> 00:17:15,590

 

516
00:17:15,590 --> 00:17:17,429

 

517
00:17:17,429 --> 00:17:19,110

 

518
00:17:19,110 --> 00:17:20,870

 

519
00:17:20,870 --> 00:17:23,909

 

520
00:17:23,909 --> 00:17:25,350

 

521
00:17:25,350 --> 00:17:25,360

 

522
00:17:25,360 --> 00:17:26,230


523
00:17:26,230 --> 00:17:26,240

 

524
00:17:26,240 --> 00:17:27,270


525
00:17:27,270 --> 00:17:29,669

 

526
00:17:29,669 --> 00:17:29,679

 

527
00:17:29,679 --> 00:17:30,630


528
00:17:30,630 --> 00:17:32,870

 

529
00:17:32,870 --> 00:17:34,950

 

530
00:17:34,950 --> 00:17:36,150

 

531
00:17:36,150 --> 00:17:38,470

 

532
00:17:38,470 --> 00:17:41,110

 

533
00:17:41,110 --> 00:17:44,950

 

534
00:17:44,950 --> 00:17:46,789

 

535
00:17:46,789 --> 00:17:48,789

 

536
00:17:48,789 --> 00:17:50,549

 

537
00:17:50,549 --> 00:17:52,390

 

538
00:17:52,390 --> 00:17:55,350

 

539
00:17:55,350 --> 00:17:56,789

 

540
00:17:56,789 --> 00:17:59,110

 

541
00:17:59,110 --> 00:18:01,430

 

542
00:18:01,430 --> 00:18:03,510

 

543
00:18:03,510 --> 00:18:06,789

 

544
00:18:06,789 --> 00:18:09,029

 

545
00:18:09,029 --> 00:18:11,430

 

546
00:18:11,430 --> 00:18:13,190

 

547
00:18:13,190 --> 00:18:15,590

 

548
00:18:15,590 --> 00:18:15,600

 

549
00:18:15,600 --> 00:18:16,470


550
00:18:16,470 --> 00:18:16,480

 

551
00:18:16,480 --> 00:18:17,430


552
00:18:17,430 --> 00:18:21,510

 

553
00:18:21,510 --> 00:18:23,430

 

554
00:18:23,430 --> 00:18:25,350

 

555
00:18:25,350 --> 00:18:27,590

 

556
00:18:27,590 --> 00:18:31,510

 

557
00:18:31,510 --> 00:18:31,520

 

558
00:18:31,520 --> 00:18:33,430


559
00:18:33,430 --> 00:18:34,950

 

560
00:18:34,950 --> 00:18:37,029

 

561
00:18:37,029 --> 00:18:37,039

 

562
00:18:37,039 --> 00:18:37,830


563
00:18:37,830 --> 00:18:40,150

 

564
00:18:40,150 --> 00:18:41,830

 

565
00:18:41,830 --> 00:18:44,549

 

566
00:18:44,549 --> 00:18:47,430

 

567
00:18:47,430 --> 00:18:48,549

 

568
00:18:48,549 --> 00:18:50,390

 

569
00:18:50,390 --> 00:18:54,070

 

570
00:18:54,070 --> 00:18:58,150

 

571
00:18:58,150 --> 00:18:58,160

 

572
00:18:58,160 --> 00:18:59,029


573
00:18:59,029 --> 00:19:01,270

 

574
00:19:01,270 --> 00:19:01,280

 

575
00:19:01,280 --> 00:19:02,390


576
00:19:02,390 --> 00:19:03,990

 

577
00:19:03,990 --> 00:19:05,909

 

578
00:19:05,909 --> 00:19:08,310

 

579
00:19:08,310 --> 00:19:09,510

 

580
00:19:09,510 --> 00:19:09,520

 

581
00:19:09,520 --> 00:19:10,390


582
00:19:10,390 --> 00:19:11,990

 

583
00:19:11,990 --> 00:19:13,909

 

584
00:19:13,909 --> 00:19:15,190

 

585
00:19:15,190 --> 00:19:17,990

 

586
00:19:17,990 --> 00:19:21,590

 

587
00:19:21,590 --> 00:19:21,600

 

588
00:19:21,600 --> 00:19:24,950


589
00:19:24,950 --> 00:19:27,270

 

590
00:19:27,270 --> 00:19:30,390

 

591
00:19:30,390 --> 00:19:32,789

 

592
00:19:32,789 --> 00:19:35,190

 

593
00:19:35,190 --> 00:19:37,750

 

594
00:19:37,750 --> 00:19:40,230

 

595
00:19:40,230 --> 00:19:42,950

 

596
00:19:42,950 --> 00:19:44,310

 

597
00:19:44,310 --> 00:19:46,710

 

598
00:19:46,710 --> 00:19:49,190

 

599
00:19:49,190 --> 00:19:50,789

 

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

 

601
00:19:53,190 --> 00:19:55,270

 

602
00:19:55,270 --> 00:19:56,630

 

603
00:19:56,630 --> 00:19:58,470

 

604
00:19:58,470 --> 00:19:59,750

 

605
00:19:59,750 --> 00:20:01,830

 

606
00:20:01,830 --> 00:20:04,149

 

607
00:20:04,149 --> 00:20:07,590

 

608
00:20:07,590 --> 00:20:09,350

 

609
00:20:09,350 --> 00:20:11,510

 

610
00:20:11,510 --> 00:20:15,110

 

611
00:20:15,110 --> 00:20:17,430

 

612
00:20:17,430 --> 00:20:18,710

 

613
00:20:18,710 --> 00:20:20,710

 

614
00:20:20,710 --> 00:20:22,630

 

615
00:20:22,630 --> 00:20:24,549

 

616
00:20:24,549 --> 00:20:27,190

 

617
00:20:27,190 --> 00:20:27,200

 

618
00:20:27,200 --> 00:20:29,990


619
00:20:29,990 --> 00:20:32,230

 

620
00:20:32,230 --> 00:20:32,240

 

621
00:20:32,240 --> 00:20:33,350


622
00:20:33,350 --> 00:20:35,669

 

623
00:20:35,669 --> 00:20:39,669

 

624
00:20:39,669 --> 00:20:41,750

 

625
00:20:41,750 --> 00:20:45,590

 

626
00:20:45,590 --> 00:20:49,669

 

627
00:20:49,669 --> 00:20:51,830

 

628
00:20:51,830 --> 00:20:53,270

 

629
00:20:53,270 --> 00:20:55,430

 

630
00:20:55,430 --> 00:20:57,750

 

631
00:20:57,750 --> 00:21:00,830

 

632
00:21:00,830 --> 00:21:00,840

 

633
00:21:00,840 --> 00:21:02,549


634
00:21:02,549 --> 00:21:04,149

 

635
00:21:04,149 --> 00:21:05,669

 

636
00:21:05,669 --> 00:21:05,679

 

637
00:21:05,679 --> 00:21:06,200


638
00:21:06,200 --> 00:21:06,210

 

639
00:21:06,210 --> 00:21:07,750


640
00:21:07,750 --> 00:21:07,760

 

641
00:21:07,760 --> 00:21:10,950


642
00:21:10,950 --> 00:21:10,960

 

643
00:21:10,960 --> 00:21:11,750


644
00:21:11,750 --> 00:21:14,549

 

645
00:21:14,549 --> 00:21:16,549

 

646
00:21:16,549 --> 00:21:18,549

 

647
00:21:18,549 --> 00:21:19,750

 

648
00:21:19,750 --> 00:21:21,750

 

649
00:21:21,750 --> 00:21:24,950

 

650
00:21:24,950 --> 00:21:24,960

 

651
00:21:24,960 --> 00:21:25,990


652
00:21:25,990 --> 00:21:28,230

 

653
00:21:28,230 --> 00:21:29,750

 

654
00:21:29,750 --> 00:21:31,430

 

655
00:21:31,430 --> 00:21:33,110

 

656
00:21:33,110 --> 00:21:37,669

 

657
00:21:37,669 --> 00:21:37,679

 

658
00:21:37,679 --> 00:21:38,549


659
00:21:38,549 --> 00:21:40,710

 

660
00:21:40,710 --> 00:21:44,149

 

661
00:21:44,149 --> 00:21:48,710

 

662
00:21:48,710 --> 00:21:51,029

 

663
00:21:51,029 --> 00:21:58,870

 

664
00:21:58,870 --> 00:21:58,880

 

665
00:21:58,880 --> 00:22:01,350


666
00:22:01,350 --> 00:22:03,190

 

667
00:22:03,190 --> 00:22:04,789

 

668
00:22:04,789 --> 00:22:07,350

 

669
00:22:07,350 --> 00:22:07,360

 

670
00:22:07,360 --> 00:22:09,909


671
00:22:09,909 --> 00:22:11,750

 

672
00:22:11,750 --> 00:22:13,350

 

673
00:22:13,350 --> 00:22:16,070

 

674
00:22:16,070 --> 00:22:17,990

 

675
00:22:17,990 --> 00:22:19,830

 

676
00:22:19,830 --> 00:22:21,750

 

677
00:22:21,750 --> 00:22:23,750

 

678
00:22:23,750 --> 00:22:26,390

 

679
00:22:26,390 --> 00:22:28,630

 

680
00:22:28,630 --> 00:22:28,640

 

681
00:22:28,640 --> 00:22:29,750


682
00:22:29,750 --> 00:22:31,909

 

683
00:22:31,909 --> 00:22:38,830

 

684
00:22:38,830 --> 00:22:44,230

 

685
00:22:44,230 --> 00:22:46,630

 

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

 

687
00:22:48,789 --> 00:22:48,799

 

688
00:22:48,799 --> 00:22:49,590


689
00:22:49,590 --> 00:22:50,789

 

690
00:22:50,789 --> 00:22:53,350

 

691
00:22:53,350 --> 00:22:55,270

 

692
00:22:55,270 --> 00:22:56,630

 

693
00:22:56,630 --> 00:22:59,190

 

694
00:22:59,190 --> 00:23:00,950

 

695
00:23:00,950 --> 00:23:05,350

 

696
00:23:05,350 --> 00:23:07,110

 

697
00:23:07,110 --> 00:23:08,630

 

698
00:23:08,630 --> 00:23:11,110

 

699
00:23:11,110 --> 00:23:13,590

 

700
00:23:13,590 --> 00:23:16,230

 

701
00:23:16,230 --> 00:23:17,909

 

702
00:23:17,909 --> 00:23:19,430

 

703
00:23:19,430 --> 00:23:19,440

 

704
00:23:19,440 --> 00:23:20,710


705
00:23:20,710 --> 00:23:22,470

 

706
00:23:22,470 --> 00:23:24,070

 

707
00:23:24,070 --> 00:23:25,750

 

708
00:23:25,750 --> 00:23:27,510

 

709
00:23:27,510 --> 00:23:30,310

 

710
00:23:30,310 --> 00:23:32,870

 

711
00:23:32,870 --> 00:23:35,669

 

712
00:23:35,669 --> 00:23:35,679

 

713
00:23:35,679 --> 00:23:36,390


714
00:23:36,390 --> 00:23:38,390

 

715
00:23:38,390 --> 00:23:45,669

 

716
00:23:45,669 --> 00:23:47,350

 

717
00:23:47,350 --> 00:23:49,830

 

718
00:23:49,830 --> 00:23:51,669

 

719
00:23:51,669 --> 00:23:53,430

 

720
00:23:53,430 --> 00:23:55,430

 

721
00:23:55,430 --> 00:23:58,390

 

722
00:23:58,390 --> 00:24:01,750

 

723
00:24:01,750 --> 00:24:01,760

 

724
00:24:01,760 --> 00:24:02,789


725
00:24:02,789 --> 00:24:04,390

 

726
00:24:04,390 --> 00:24:07,029

 

727
00:24:07,029 --> 00:24:08,950

 

728
00:24:08,950 --> 00:24:12,789

 

729
00:24:12,789 --> 00:24:15,029

 

730
00:24:15,029 --> 00:24:16,549

 

731
00:24:16,549 --> 00:24:18,549

 

732
00:24:18,549 --> 00:24:19,990

 

733
00:24:19,990 --> 00:24:20,000

 

734
00:24:20,000 --> 00:24:21,190


735
00:24:21,190 --> 00:24:24,390

 

736
00:24:24,390 --> 00:24:27,110

 

737
00:24:27,110 --> 00:24:27,120

 

738
00:24:27,120 --> 00:24:27,909


739
00:24:27,909 --> 00:24:30,310

 

740
00:24:30,310 --> 00:24:33,029

 

741
00:24:33,029 --> 00:24:35,110

 

742
00:24:35,110 --> 00:24:35,120

 

743
00:24:35,120 --> 00:24:36,630


744
00:24:36,630 --> 00:24:38,470

 

745
00:24:38,470 --> 00:24:39,909

 

746
00:24:39,909 --> 00:24:42,310

 

747
00:24:42,310 --> 00:24:45,990

 

748
00:24:45,990 --> 00:24:47,590

 

749
00:24:47,590 --> 00:24:50,310

 

750
00:24:50,310 --> 00:24:52,310

 

751
00:24:52,310 --> 00:24:55,269

 

752
00:24:55,269 --> 00:24:57,830

 

753
00:24:57,830 --> 00:24:59,590

 

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

 

755
00:24:59,600 --> 00:25:01,110


756
00:25:01,110 --> 00:25:03,909

 

757
00:25:03,909 --> 00:25:06,630

 

758
00:25:06,630 --> 00:25:08,870

 

759
00:25:08,870 --> 00:25:11,430

 

760
00:25:11,430 --> 00:25:14,310

 

761
00:25:14,310 --> 00:25:16,950

 

762
00:25:16,950 --> 00:25:19,190

 

763
00:25:19,190 --> 00:25:20,950

 

764
00:25:20,950 --> 00:25:20,960

 

765
00:25:20,960 --> 00:25:22,230


766
00:25:22,230 --> 00:25:23,990

 

767
00:25:23,990 --> 00:25:25,350

 

768
00:25:25,350 --> 00:25:26,710

 

769
00:25:26,710 --> 00:25:28,549

 

770
00:25:28,549 --> 00:25:28,559

 

771
00:25:28,559 --> 00:25:29,750


772
00:25:29,750 --> 00:25:31,669

 

773
00:25:31,669 --> 00:25:33,430

 

774
00:25:33,430 --> 00:25:36,310

 

775
00:25:36,310 --> 00:25:38,230

 

776
00:25:38,230 --> 00:25:39,510

 

777
00:25:39,510 --> 00:25:41,350

 

778
00:25:41,350 --> 00:25:43,750

 

779
00:25:43,750 --> 00:25:43,760

 

780
00:25:43,760 --> 00:25:44,789


781
00:25:44,789 --> 00:25:47,110

 

782
00:25:47,110 --> 00:25:49,350

 

783
00:25:49,350 --> 00:25:51,510

 

784
00:25:51,510 --> 00:25:53,990

 

785
00:25:53,990 --> 00:25:56,789

 

786
00:25:56,789 --> 00:25:58,230

 

787
00:25:58,230 --> 00:26:00,549

 

788
00:26:00,549 --> 00:26:03,269

 

789
00:26:03,269 --> 00:26:05,990

 

790
00:26:05,990 --> 00:26:07,110

 

791
00:26:07,110 --> 00:26:08,710

 

792
00:26:08,710 --> 00:26:11,269

 

793
00:26:11,269 --> 00:26:12,710

 

794
00:26:12,710 --> 00:26:13,990

 

795
00:26:13,990 --> 00:26:16,149

 

796
00:26:16,149 --> 00:26:17,830

 

797
00:26:17,830 --> 00:26:17,840

 

798
00:26:17,840 --> 00:26:18,950


799
00:26:18,950 --> 00:26:22,470

 

800
00:26:22,470 --> 00:26:25,430

 

801
00:26:25,430 --> 00:26:27,350

 

802
00:26:27,350 --> 00:26:29,350

 

803
00:26:29,350 --> 00:26:31,269

 

804
00:26:31,269 --> 00:26:33,590

 

805
00:26:33,590 --> 00:26:35,430

 

806
00:26:35,430 --> 00:26:35,440

 

807
00:26:35,440 --> 00:26:36,310


808
00:26:36,310 --> 00:26:37,830

 

809
00:26:37,830 --> 00:26:39,110

 

810
00:26:39,110 --> 00:26:41,669

 

811
00:26:41,669 --> 00:26:45,269

 

812
00:26:45,269 --> 00:26:46,789

 

813
00:26:46,789 --> 00:26:49,590

 

814
00:26:49,590 --> 00:26:49,600

 

815
00:26:49,600 --> 00:26:51,510


816
00:26:51,510 --> 00:26:54,310

 

817
00:26:54,310 --> 00:26:56,230

 

818
00:26:56,230 --> 00:26:57,430

 

819
00:26:57,430 --> 00:26:57,440

 

820
00:26:57,440 --> 00:26:59,110


821
00:26:59,110 --> 00:27:01,350

 

822
00:27:01,350 --> 00:27:01,360

 

823
00:27:01,360 --> 00:27:02,070


824
00:27:02,070 --> 00:27:04,870

 

825
00:27:04,870 --> 00:27:07,269

 

826
00:27:07,269 --> 00:27:08,710

 

827
00:27:08,710 --> 00:27:11,430

 

828
00:27:11,430 --> 00:27:13,510

 

829
00:27:13,510 --> 00:27:15,510

 

830
00:27:15,510 --> 00:27:17,510

 

831
00:27:17,510 --> 00:27:19,110

 

832
00:27:19,110 --> 00:27:21,750

 

833
00:27:21,750 --> 00:27:23,110

 

834
00:27:23,110 --> 00:27:24,470

 

835
00:27:24,470 --> 00:27:26,710

 

836
00:27:26,710 --> 00:27:29,510

 

837
00:27:29,510 --> 00:27:31,269

 

838
00:27:31,269 --> 00:27:31,279

 

839
00:27:31,279 --> 00:27:34,630


840
00:27:34,630 --> 00:27:36,549

 

841
00:27:36,549 --> 00:27:37,830

 

842
00:27:37,830 --> 00:27:37,840

 

843
00:27:37,840 --> 00:27:38,950


844
00:27:38,950 --> 00:27:41,590

 

845
00:27:41,590 --> 00:27:44,710

 

846
00:27:44,710 --> 00:27:45,909

 

847
00:27:45,909 --> 00:27:45,919

 

848
00:27:45,919 --> 00:27:46,950


849
00:27:46,950 --> 00:27:48,310

 

850
00:27:48,310 --> 00:27:49,669

 

851
00:27:49,669 --> 00:27:52,549

 

852
00:27:52,549 --> 00:27:54,549

 

853
00:27:54,549 --> 00:27:57,669

 

854
00:27:57,669 --> 00:28:00,310

 

855
00:28:00,310 --> 00:28:01,830

 

856
00:28:01,830 --> 00:28:03,269

 

857
00:28:03,269 --> 00:28:05,269

 

858
00:28:05,269 --> 00:28:07,430

 

859
00:28:07,430 --> 00:28:09,029

 

860
00:28:09,029 --> 00:28:10,870

 

861
00:28:10,870 --> 00:28:13,190

 

862
00:28:13,190 --> 00:28:15,750

 

863
00:28:15,750 --> 00:28:17,669

 

864
00:28:17,669 --> 00:28:19,669

 

865
00:28:19,669 --> 00:28:22,710

 

866
00:28:22,710 --> 00:28:24,310

 

867
00:28:24,310 --> 00:28:26,549

 

868
00:28:26,549 --> 00:28:27,909

 

869
00:28:27,909 --> 00:28:30,149

 

870
00:28:30,149 --> 00:28:32,149

 

871
00:28:32,149 --> 00:28:32,159

 

872
00:28:32,159 --> 00:28:33,430


873
00:28:33,430 --> 00:28:33,440

 

874
00:28:33,440 --> 00:28:34,870


875
00:28:34,870 --> 00:28:36,230

 

876
00:28:36,230 --> 00:28:37,350

 

877
00:28:37,350 --> 00:28:37,360

 

878
00:28:37,360 --> 00:28:38,470


879
00:28:38,470 --> 00:28:40,389

 

880
00:28:40,389 --> 00:28:42,870

 

881
00:28:42,870 --> 00:28:44,070

 

882
00:28:44,070 --> 00:28:46,549

 

883
00:28:46,549 --> 00:28:46,559

 

884
00:28:46,559 --> 00:28:47,430


885
00:28:47,430 --> 00:28:49,750

 

886
00:28:49,750 --> 00:28:51,350

 

887
00:28:51,350 --> 00:28:53,990

 

888
00:28:53,990 --> 00:28:55,990

 

889
00:28:55,990 --> 00:28:57,909

 

890
00:28:57,909 --> 00:29:00,549

 

891
00:29:00,549 --> 00:29:01,990

 

892
00:29:01,990 --> 00:29:03,430

 

893
00:29:03,430 --> 00:29:05,590

 

894
00:29:05,590 --> 00:29:07,110

 

895
00:29:07,110 --> 00:29:07,120

 

896
00:29:07,120 --> 00:29:08,789


897
00:29:08,789 --> 00:29:08,799

 

898
00:29:08,799 --> 00:29:11,190


899
00:29:11,190 --> 00:29:13,830

 

900
00:29:13,830 --> 00:29:17,350

 

901
00:29:17,350 --> 00:29:19,909

 

902
00:29:19,909 --> 00:29:20,789

 

903
00:29:20,789 --> 00:29:22,549

 

904
00:29:22,549 --> 00:29:25,909

 

905
00:29:25,909 --> 00:29:28,549

 

906
00:29:28,549 --> 00:29:30,070

 

907
00:29:30,070 --> 00:29:32,070

 

908
00:29:32,070 --> 00:29:33,909

 

909
00:29:33,909 --> 00:29:36,389

 

910
00:29:36,389 --> 00:29:38,710

 

911
00:29:38,710 --> 00:29:41,669

 

912
00:29:41,669 --> 00:29:43,669

 

913
00:29:43,669 --> 00:29:45,190

 

914
00:29:45,190 --> 00:29:48,230

 

915
00:29:48,230 --> 00:29:49,510

 

916
00:29:49,510 --> 00:29:51,990

 

917
00:29:51,990 --> 00:29:54,070

 

918
00:29:54,070 --> 00:29:55,510

 

919
00:29:55,510 --> 00:29:58,310

 

920
00:29:58,310 --> 00:30:00,389

 

921
00:30:00,389 --> 00:30:02,470

 

922
00:30:02,470 --> 00:30:05,269

 

923
00:30:05,269 --> 00:30:09,110

 

924
00:30:09,110 --> 00:30:10,789

 

925
00:30:10,789 --> 00:30:12,870

 

926
00:30:12,870 --> 00:30:14,710

 

927
00:30:14,710 --> 00:30:17,110

 

928
00:30:17,110 --> 00:30:18,149

 

929
00:30:18,149 --> 00:30:20,310

 

930
00:30:20,310 --> 00:30:21,590

 

931
00:30:21,590 --> 00:30:22,870

 

932
00:30:22,870 --> 00:30:24,789

 

933
00:30:24,789 --> 00:30:26,310

 

934
00:30:26,310 --> 00:30:26,320

 

935
00:30:26,320 --> 00:30:27,510


936
00:30:27,510 --> 00:30:27,520

 

937
00:30:27,520 --> 00:30:30,149


938
00:30:30,149 --> 00:30:30,159

 

939
00:30:30,159 --> 00:30:32,389


940
00:30:32,389 --> 00:30:37,190

 

941
00:30:37,190 --> 00:30:37,200

 

942
00:30:37,200 --> 00:30:39,029


943
00:30:39,029 --> 00:30:39,039

 

944
00:30:39,039 --> 00:30:39,990


945
00:30:39,990 --> 00:30:41,590

 

946
00:30:41,590 --> 00:30:45,110

 

947
00:30:45,110 --> 00:30:47,190

 

948
00:30:47,190 --> 00:30:47,200

 

949
00:30:47,200 --> 00:30:48,789


950
00:30:48,789 --> 00:30:50,470

 

951
00:30:50,470 --> 00:30:53,909

 

952
00:30:53,909 --> 00:30:58,950

 

953
00:30:58,950 --> 00:31:00,789

 

954
00:31:00,789 --> 00:31:02,549

 

955
00:31:02,549 --> 00:31:04,950

 

956
00:31:04,950 --> 00:31:05,860

 

957
00:31:05,860 --> 00:31:05,870

 

958
00:31:05,870 --> 00:31:07,750


959
00:31:07,750 --> 00:31:09,350

 

960
00:31:09,350 --> 00:31:12,310

 

961
00:31:12,310 --> 00:31:13,669

 

962
00:31:13,669 --> 00:31:13,679

 

963
00:31:13,679 --> 00:31:14,090


964
00:31:14,090 --> 00:31:14,100

 

965
00:31:14,100 --> 00:31:15,990


966
00:31:15,990 --> 00:31:19,350

 

967
00:31:19,350 --> 00:31:21,269

 

968
00:31:21,269 --> 00:31:22,870

 

969
00:31:22,870 --> 00:31:24,230

 

970
00:31:24,230 --> 00:31:26,950

 

971
00:31:26,950 --> 00:31:26,960

 

972
00:31:26,960 --> 00:31:28,310


973
00:31:28,310 --> 00:31:28,320

 

974
00:31:28,320 --> 00:31:29,350


975
00:31:29,350 --> 00:31:31,029

 

976
00:31:31,029 --> 00:31:32,789

 

977
00:31:32,789 --> 00:31:35,110

 

978
00:31:35,110 --> 00:31:37,269

 

979
00:31:37,269 --> 00:31:39,830

 

980
00:31:39,830 --> 00:31:39,840

 

981
00:31:39,840 --> 00:31:41,110


982
00:31:41,110 --> 00:31:44,149

 

983
00:31:44,149 --> 00:31:45,990

 

984
00:31:45,990 --> 00:31:48,070

 

985
00:31:48,070 --> 00:31:49,669

 

986
00:31:49,669 --> 00:31:53,029

 

987
00:31:53,029 --> 00:31:54,950

 

988
00:31:54,950 --> 00:31:57,110

 

989
00:31:57,110 --> 00:31:59,269

 

990
00:31:59,269 --> 00:32:02,470

 

991
00:32:02,470 --> 00:32:04,149

 

992
00:32:04,149 --> 00:32:05,990

 

993
00:32:05,990 --> 00:32:06,000

 

994
00:32:06,000 --> 00:32:06,870


995
00:32:06,870 --> 00:32:08,630

 

996
00:32:08,630 --> 00:32:10,789

 

997
00:32:10,789 --> 00:32:10,799

 

998
00:32:10,799 --> 00:32:12,630


999
00:32:12,630 --> 00:32:14,549

 

1000
00:32:14,549 --> 00:32:16,549

 

1001
00:32:16,549 --> 00:32:16,559

 

1002
00:32:16,559 --> 00:32:18,070


1003
00:32:18,070 --> 00:32:19,909

 

1004
00:32:19,909 --> 00:32:23,350

 

1005
00:32:23,350 --> 00:32:25,509

 

1006
00:32:25,509 --> 00:32:27,509

 

1007
00:32:27,509 --> 00:32:29,190

 

1008
00:32:29,190 --> 00:32:30,789

 

1009
00:32:30,789 --> 00:32:33,350

 

1010
00:32:33,350 --> 00:32:37,750

 

1011
00:32:37,750 --> 00:32:39,750

 

1012
00:32:39,750 --> 00:32:42,149

 

1013
00:32:42,149 --> 00:32:43,909

 

1014
00:32:43,909 --> 00:32:46,549

 

1015
00:32:46,549 --> 00:32:48,389

 

1016
00:32:48,389 --> 00:32:49,590

 

1017
00:32:49,590 --> 00:32:51,110

 

1018
00:32:51,110 --> 00:32:53,029

 

1019
00:32:53,029 --> 00:32:54,870

 

1020
00:32:54,870 --> 00:32:56,630

 

1021
00:32:56,630 --> 00:32:58,310

 

1022
00:32:58,310 --> 00:32:59,750

 

1023
00:32:59,750 --> 00:33:01,669

 

1024
00:33:01,669 --> 00:33:03,269

 

1025
00:33:03,269 --> 00:33:05,269

 

1026
00:33:05,269 --> 00:33:06,710

 

1027
00:33:06,710 --> 00:33:06,720

 

1028
00:33:06,720 --> 00:33:08,549


1029
00:33:08,549 --> 00:33:10,310

 

1030
00:33:10,310 --> 00:33:11,509

 

1031
00:33:11,509 --> 00:33:12,789

 

1032
00:33:12,789 --> 00:33:14,389

 

1033
00:33:14,389 --> 00:33:16,070

 

1034
00:33:16,070 --> 00:33:17,990

 

1035
00:33:17,990 --> 00:33:21,029

 

1036
00:33:21,029 --> 00:33:23,750

 

1037
00:33:23,750 --> 00:33:26,310

 

1038
00:33:26,310 --> 00:33:29,990

 

1039
00:33:29,990 --> 00:33:31,509

 

1040
00:33:31,509 --> 00:33:34,310

 

1041
00:33:34,310 --> 00:33:36,310

 

1042
00:33:36,310 --> 00:33:39,269

 

1043
00:33:39,269 --> 00:33:40,630

 

1044
00:33:40,630 --> 00:33:42,310

 

1045
00:33:42,310 --> 00:33:45,509

 

1046
00:33:45,509 --> 00:33:48,070

 

1047
00:33:48,070 --> 00:33:50,070

 

1048
00:33:50,070 --> 00:33:52,470

 

1049
00:33:52,470 --> 00:33:55,269

 

1050
00:33:55,269 --> 00:33:57,509

 

1051
00:33:57,509 --> 00:33:59,750

 

1052
00:33:59,750 --> 00:33:59,760

 

1053
00:33:59,760 --> 00:34:01,269


1054
00:34:01,269 --> 00:34:03,350

 

1055
00:34:03,350 --> 00:34:04,950

 

1056
00:34:04,950 --> 00:34:07,669

 

1057
00:34:07,669 --> 00:34:07,679

 

1058
00:34:07,679 --> 00:34:08,389


1059
00:34:08,389 --> 00:34:10,470

 

1060
00:34:10,470 --> 00:34:15,750

 

1061
00:34:15,750 --> 00:34:18,470

 

1062
00:34:18,470 --> 00:34:18,480

 

1063
00:34:18,480 --> 00:34:20,230


1064
00:34:20,230 --> 00:34:22,310

 

1065
00:34:22,310 --> 00:34:26,470

 

1066
00:34:26,470 --> 00:34:28,950

 

1067
00:34:28,950 --> 00:34:30,710

 

1068
00:34:30,710 --> 00:34:33,349

 

1069
00:34:33,349 --> 00:34:38,629

 

1070
00:34:38,629 --> 00:34:39,829

 

1071
00:34:39,829 --> 00:34:42,790

 

1072
00:34:42,790 --> 00:34:44,950

 

1073
00:34:44,950 --> 00:34:46,230

 

1074
00:34:46,230 --> 00:34:47,589

 

1075
00:34:47,589 --> 00:34:49,190

 

1076
00:34:49,190 --> 00:34:51,990

 

1077
00:34:51,990 --> 00:34:53,990

 

1078
00:34:53,990 --> 00:34:55,990

 

1079
00:34:55,990 --> 00:34:58,230

 

1080
00:34:58,230 --> 00:35:02,470

 

1081
00:35:02,470 --> 00:35:04,310

 

1082
00:35:04,310 --> 00:35:05,910

 

1083
00:35:05,910 --> 00:35:09,270

 

1084
00:35:09,270 --> 00:35:12,550

 

1085
00:35:12,550 --> 00:35:13,589

 

1086
00:35:13,589 --> 00:35:16,430

 

1087
00:35:16,430 --> 00:35:19,510

 

1088
00:35:19,510 --> 00:35:23,510

 

1089
00:35:23,510 --> 00:35:25,030

 

1090
00:35:25,030 --> 00:35:27,990

 

1091
00:35:27,990 --> 00:35:29,510

 

1092
00:35:29,510 --> 00:35:32,630

 

1093
00:35:32,630 --> 00:35:35,430

 

1094
00:35:35,430 --> 00:35:35,440

 

1095
00:35:35,440 --> 00:35:36,230


1096
00:35:36,230 --> 00:35:37,829

 

1097
00:35:37,829 --> 00:35:37,839

 

1098
00:35:37,839 --> 00:35:39,430


1099
00:35:39,430 --> 00:35:42,310

 

1100
00:35:42,310 --> 00:35:44,470

 

1101
00:35:44,470 --> 00:35:46,390

 

1102
00:35:46,390 --> 00:35:48,470

 

1103
00:35:48,470 --> 00:35:51,270

 

1104
00:35:51,270 --> 00:35:55,109

 

1105
00:35:55,109 --> 00:35:55,119

 

1106
00:35:55,119 --> 00:35:56,150


1107
00:35:56,150 --> 00:35:56,160

 

1108
00:35:56,160 --> 00:35:57,109


1109
00:35:57,109 --> 00:35:59,349

 

1110
00:35:59,349 --> 00:36:01,589

 

1111
00:36:01,589 --> 00:36:03,349

 

1112
00:36:03,349 --> 00:36:05,349

 

1113
00:36:05,349 --> 00:36:07,670

 

1114
00:36:07,670 --> 00:36:07,680

 

1115
00:36:07,680 --> 00:36:08,710


1116
00:36:08,710 --> 00:36:10,069

 

1117
00:36:10,069 --> 00:36:12,630

 

1118
00:36:12,630 --> 00:36:15,030

 

1119
00:36:15,030 --> 00:36:16,790

 

1120
00:36:16,790 --> 00:36:18,630

 

1121
00:36:18,630 --> 00:36:20,550

 

1122
00:36:20,550 --> 00:36:20,560

 

1123
00:36:20,560 --> 00:36:22,630


1124
00:36:22,630 --> 00:36:26,310

 

1125
00:36:26,310 --> 00:36:31,190

 

1126
00:36:31,190 --> 00:36:31,200

 

1127
00:36:31,200 --> 00:36:32,230


1128
00:36:32,230 --> 00:36:36,710

 

1129
00:36:36,710 --> 00:36:42,630

 

1130
00:36:42,630 --> 00:36:47,430

 

1131
00:36:47,430 --> 00:36:49,750

 

1132
00:36:49,750 --> 00:36:52,230

 

1133
00:36:52,230 --> 00:36:52,240

 

1134
00:36:52,240 --> 00:36:53,270


1135
00:36:53,270 --> 00:36:53,280

 

1136
00:36:53,280 --> 00:36:54,470


1137
00:36:54,470 --> 00:36:56,950

 

1138
00:36:56,950 --> 00:36:59,829

 

1139
00:36:59,829 --> 00:37:01,670

 

1140
00:37:01,670 --> 00:37:03,510

 

1141
00:37:03,510 --> 00:37:04,790

 

1142
00:37:04,790 --> 00:37:09,030

 

1143
00:37:09,030 --> 00:37:10,710

 

1144
00:37:10,710 --> 00:37:12,630

 

1145
00:37:12,630 --> 00:37:15,589

 

1146
00:37:15,589 --> 00:37:18,630

 

1147
00:37:18,630 --> 00:37:18,640

 

1148
00:37:18,640 --> 00:37:19,670


1149
00:37:19,670 --> 00:37:22,630

 

1150
00:37:22,630 --> 00:37:24,470

 

1151
00:37:24,470 --> 00:37:25,829

 

1152
00:37:25,829 --> 00:37:27,829

 

1153
00:37:27,829 --> 00:37:30,870

 

1154
00:37:30,870 --> 00:37:32,950

 

1155
00:37:32,950 --> 00:37:34,550

 

1156
00:37:34,550 --> 00:37:34,560

 

1157
00:37:34,560 --> 00:37:35,589


1158
00:37:35,589 --> 00:37:37,910

 

1159
00:37:37,910 --> 00:37:40,870

 

1160
00:37:40,870 --> 00:37:43,829

 

1161
00:37:43,829 --> 00:37:45,829

 

1162
00:37:45,829 --> 00:37:47,589

 

1163
00:37:47,589 --> 00:37:49,030

 

1164
00:37:49,030 --> 00:37:50,870

 

1165
00:37:50,870 --> 00:37:52,150

 

1166
00:37:52,150 --> 00:37:52,160

 

1167
00:37:52,160 --> 00:37:54,390


1168
00:37:54,390 --> 00:37:59,190

 

1169
00:37:59,190 --> 00:38:01,030

 

1170
00:38:01,030 --> 00:38:03,510

 

1171
00:38:03,510 --> 00:38:06,630

 

1172
00:38:06,630 --> 00:38:08,550

 

1173
00:38:08,550 --> 00:38:10,550

 

1174
00:38:10,550 --> 00:38:12,470

 

1175
00:38:12,470 --> 00:38:14,470

 

1176
00:38:14,470 --> 00:38:18,550

 

1177
00:38:18,550 --> 00:38:20,550

 

1178
00:38:20,550 --> 00:38:22,069

 

1179
00:38:22,069 --> 00:38:23,990

 

1180
00:38:23,990 --> 00:38:25,430

 

1181
00:38:25,430 --> 00:38:26,550

 

1182
00:38:26,550 --> 00:38:28,550

 

1183
00:38:28,550 --> 00:38:28,560

 

1184
00:38:28,560 --> 00:38:29,510


1185
00:38:29,510 --> 00:38:30,390

 

1186
00:38:30,390 --> 00:38:31,510

 

1187
00:38:31,510 --> 00:38:33,910

 

1188
00:38:33,910 --> 00:38:35,990

 

1189
00:38:35,990 --> 00:38:38,230

 

1190
00:38:38,230 --> 00:38:41,430

 

1191
00:38:41,430 --> 00:38:41,440

 

1192
00:38:41,440 --> 00:38:42,310


1193
00:38:42,310 --> 00:38:43,910

 

1194
00:38:43,910 --> 00:38:47,190

 

1195
00:38:47,190 --> 00:38:48,950

 

1196
00:38:48,950 --> 00:38:50,870

 

1197
00:38:50,870 --> 00:38:52,550

 

1198
00:38:52,550 --> 00:38:54,790

 

1199
00:38:54,790 --> 00:38:56,870

 

1200
00:38:56,870 --> 00:38:58,630

 

1201
00:38:58,630 --> 00:39:00,710

 

1202
00:39:00,710 --> 00:39:03,030

 

1203
00:39:03,030 --> 00:39:04,790

 

1204
00:39:04,790 --> 00:39:06,310

 

1205
00:39:06,310 --> 00:39:06,320

 

1206
00:39:06,320 --> 00:39:08,069


1207
00:39:08,069 --> 00:39:09,990

 

1208
00:39:09,990 --> 00:39:11,750

 

1209
00:39:11,750 --> 00:39:13,670

 

1210
00:39:13,670 --> 00:39:16,310

 

1211
00:39:16,310 --> 00:39:18,630

 

1212
00:39:18,630 --> 00:39:18,640

 

1213
00:39:18,640 --> 00:39:19,589


1214
00:39:19,589 --> 00:39:21,510

 

1215
00:39:21,510 --> 00:39:23,750

 

1216
00:39:23,750 --> 00:39:24,950

 

1217
00:39:24,950 --> 00:39:24,960

 

1218
00:39:24,960 --> 00:39:30,310


1219
00:39:30,310 --> 00:39:32,870

 

1220
00:39:32,870 --> 00:39:34,790

 

1221
00:39:34,790 --> 00:39:36,710

 

1222
00:39:36,710 --> 00:39:36,720

 

1223
00:39:36,720 --> 00:39:39,190


1224
00:39:39,190 --> 00:39:49,990

 

1225
00:39:49,990 --> 00:39:52,630

 

1226
00:39:52,630 --> 00:39:53,750

 

1227
00:39:53,750 --> 00:39:55,589

 

1228
00:39:55,589 --> 00:39:56,950

 

1229
00:39:56,950 --> 00:39:59,109

 

1230
00:39:59,109 --> 00:39:59,119

 

1231
00:39:59,119 --> 00:40:00,790


1232
00:40:00,790 --> 00:40:03,670

 

1233
00:40:03,670 --> 00:40:05,510

 

1234
00:40:05,510 --> 00:40:08,150

 

1235
00:40:08,150 --> 00:40:11,190

 

1236
00:40:11,190 --> 00:40:13,349

 

1237
00:40:13,349 --> 00:40:15,990

 

1238
00:40:15,990 --> 00:40:17,990

 

1239
00:40:17,990 --> 00:40:20,230

 

1240
00:40:20,230 --> 00:40:22,390

 

1241
00:40:22,390 --> 00:40:24,550

 

1242
00:40:24,550 --> 00:40:26,870

 

1243
00:40:26,870 --> 00:40:29,030

 

1244
00:40:29,030 --> 00:40:31,030

 

1245
00:40:31,030 --> 00:40:33,349

 

1246
00:40:33,349 --> 00:40:35,750

 

1247
00:40:35,750 --> 00:40:40,230

 

1248
00:40:40,230 --> 00:40:40,240

 

1249
00:40:40,240 --> 00:40:41,589


1250
00:40:41,589 --> 00:40:44,790

 

1251
00:40:44,790 --> 00:40:44,800

 

1252
00:40:44,800 --> 00:40:47,349


1253
00:40:47,349 --> 00:40:48,710

 

1254
00:40:48,710 --> 00:40:48,720

 

1255
00:40:48,720 --> 00:40:50,390


1256
00:40:50,390 --> 00:40:51,589

 

1257
00:40:51,589 --> 00:40:53,430

 

1258
00:40:53,430 --> 00:40:55,750

 

1259
00:40:55,750 --> 00:40:57,750

 

1260
00:40:57,750 --> 00:41:01,030

 

1261
00:41:01,030 --> 00:41:02,230

 

1262
00:41:02,230 --> 00:41:03,670

 

1263
00:41:03,670 --> 00:41:05,589

 

1264
00:41:05,589 --> 00:41:07,670

 

1265
00:41:07,670 --> 00:41:09,030

 

1266
00:41:09,030 --> 00:41:11,030

 

1267
00:41:11,030 --> 00:41:14,150

 

1268
00:41:14,150 --> 00:41:15,589

 

1269
00:41:15,589 --> 00:41:18,550

 

1270
00:41:18,550 --> 00:41:20,230

 

1271
00:41:20,230 --> 00:41:23,190

 

1272
00:41:23,190 --> 00:41:26,550

 

1273
00:41:26,550 --> 00:41:28,790

 

1274
00:41:28,790 --> 00:41:31,510

 

1275
00:41:31,510 --> 00:41:33,030

 

1276
00:41:33,030 --> 00:41:34,390

 

1277
00:41:34,390 --> 00:41:36,630

 

1278
00:41:36,630 --> 00:41:36,640

 

1279
00:41:36,640 --> 00:41:37,430


1280
00:41:37,430 --> 00:41:37,440

 

1281
00:41:37,440 --> 00:41:40,309


1282
00:41:40,309 --> 00:41:41,910

 

1283
00:41:41,910 --> 00:41:43,990

 

1284
00:41:43,990 --> 00:41:48,069

 

1285
00:41:48,069 --> 00:41:48,079

 

1286
00:41:48,079 --> 00:41:49,589


1287
00:41:49,589 --> 00:41:51,190

 

1288
00:41:51,190 --> 00:41:52,950

 

1289
00:41:52,950 --> 00:41:54,550

 

1290
00:41:54,550 --> 00:41:56,710

 

1291
00:41:56,710 --> 00:41:59,430

 

1292
00:41:59,430 --> 00:42:01,670

 

1293
00:42:01,670 --> 00:42:03,670

 

1294
00:42:03,670 --> 00:42:05,589

 

1295
00:42:05,589 --> 00:42:07,349

 

1296
00:42:07,349 --> 00:42:10,550

 

1297
00:42:10,550 --> 00:42:13,030

 

1298
00:42:13,030 --> 00:42:13,040

 

1299
00:42:13,040 --> 00:42:14,150


1300
00:42:14,150 --> 00:42:16,470

 

1301
00:42:16,470 --> 00:42:16,480

 

1302
00:42:16,480 --> 00:42:17,670


1303
00:42:17,670 --> 00:42:21,030

 

1304
00:42:21,030 --> 00:42:23,829

 

1305
00:42:23,829 --> 00:42:26,710

 

1306
00:42:26,710 --> 00:42:30,150

 

1307
00:42:30,150 --> 00:42:32,630

 

1308
00:42:32,630 --> 00:42:35,750

 

1309
00:42:35,750 --> 00:42:39,030

 

1310
00:42:39,030 --> 00:42:40,710

 

1311
00:42:40,710 --> 00:42:40,720

 

1312
00:42:40,720 --> 00:42:43,510


1313
00:42:43,510 --> 00:42:46,309

 

1314
00:42:46,309 --> 00:42:48,069

 

1315
00:42:48,069 --> 00:42:49,510

 

1316
00:42:49,510 --> 00:42:52,069

 

1317
00:42:52,069 --> 00:42:53,990

 

1318
00:42:53,990 --> 00:42:56,790

 

1319
00:42:56,790 --> 00:42:58,950

 

1320
00:42:58,950 --> 00:42:58,960

 

1321
00:42:58,960 --> 00:43:00,230


1322
00:43:00,230 --> 00:43:01,829

 

1323
00:43:01,829 --> 00:43:04,790

 

1324
00:43:04,790 --> 00:43:04,800

 

1325
00:43:04,800 --> 00:43:06,630


1326
00:43:06,630 --> 00:43:07,750

 

1327
00:43:07,750 --> 00:43:07,760

 

1328
00:43:07,760 --> 00:43:09,670


1329
00:43:09,670 --> 00:43:11,910

 

1330
00:43:11,910 --> 00:43:13,430

 

1331
00:43:13,430 --> 00:43:15,430

 

1332
00:43:15,430 --> 00:43:17,910

 

1333
00:43:17,910 --> 00:43:19,990

 

1334
00:43:19,990 --> 00:43:22,870

 

1335
00:43:22,870 --> 00:43:22,880

 

1336
00:43:22,880 --> 00:43:24,829


1337
00:43:24,829 --> 00:43:27,270

 

1338
00:43:27,270 --> 00:43:29,670

 

1339
00:43:29,670 --> 00:43:33,910

 

1340
00:43:33,910 --> 00:43:36,550

 

1341
00:43:36,550 --> 00:43:38,390

 

1342
00:43:38,390 --> 00:43:41,510

 

1343
00:43:41,510 --> 00:43:43,670

 

1344
00:43:43,670 --> 00:43:45,670

 

1345
00:43:45,670 --> 00:43:47,030

 

1346
00:43:47,030 --> 00:43:48,710

 

1347
00:43:48,710 --> 00:43:50,150

 

1348
00:43:50,150 --> 00:43:51,430

 

1349
00:43:51,430 --> 00:43:52,630

 

1350
00:43:52,630 --> 00:43:54,710

 

1351
00:43:54,710 --> 00:43:56,309

 

1352
00:43:56,309 --> 00:43:57,910

 

1353
00:43:57,910 --> 00:44:00,069

 

1354
00:44:00,069 --> 00:44:01,270

 

1355
00:44:01,270 --> 00:44:03,030

 

1356
00:44:03,030 --> 00:44:05,670

 

1357
00:44:05,670 --> 00:44:07,589

 

1358
00:44:07,589 --> 00:44:09,589

 

1359
00:44:09,589 --> 00:44:12,069

 

1360
00:44:12,069 --> 00:44:14,309

 

1361
00:44:14,309 --> 00:44:14,319

 

1362
00:44:14,319 --> 00:44:15,349


1363
00:44:15,349 --> 00:44:17,589

 

1364
00:44:17,589 --> 00:44:20,630

 

1365
00:44:20,630 --> 00:44:22,309

 

1366
00:44:22,309 --> 00:44:24,069

 

1367
00:44:24,069 --> 00:44:24,079

 

1368
00:44:24,079 --> 00:44:25,270


1369
00:44:25,270 --> 00:44:26,870

 

1370
00:44:26,870 --> 00:44:28,550

 

1371
00:44:28,550 --> 00:44:30,470

 

1372
00:44:30,470 --> 00:44:32,150

 

1373
00:44:32,150 --> 00:44:34,150

 

1374
00:44:34,150 --> 00:44:36,950

 

1375
00:44:36,950 --> 00:44:40,150

 

1376
00:44:40,150 --> 00:44:40,160

 

1377
00:44:40,160 --> 00:44:41,190


1378
00:44:41,190 --> 00:44:42,710

 

1379
00:44:42,710 --> 00:44:45,510

 

1380
00:44:45,510 --> 00:44:48,069

 

1381
00:44:48,069 --> 00:44:50,390

 

1382
00:44:50,390 --> 00:44:53,190

 

1383
00:44:53,190 --> 00:44:53,200

 

1384
00:44:53,200 --> 00:44:54,230


1385
00:44:54,230 --> 00:44:56,550

 

1386
00:44:56,550 --> 00:44:58,550

 

1387
00:44:58,550 --> 00:45:01,190

 

1388
00:45:01,190 --> 00:45:03,990

 

1389
00:45:03,990 --> 00:45:05,510

 

1390
00:45:05,510 --> 00:45:07,670

 

1391
00:45:07,670 --> 00:45:09,990

 

1392
00:45:09,990 --> 00:45:12,069

 

1393
00:45:12,069 --> 00:45:14,870

 

1394
00:45:14,870 --> 00:45:17,109

 

1395
00:45:17,109 --> 00:45:17,119

 

1396
00:45:17,119 --> 00:45:18,550


1397
00:45:18,550 --> 00:45:23,430

 

1398
00:45:23,430 --> 00:45:25,270

 

1399
00:45:25,270 --> 00:45:27,589

 

1400
00:45:27,589 --> 00:45:30,390

 

1401
00:45:30,390 --> 00:45:31,750

 

1402
00:45:31,750 --> 00:45:33,829

 

1403
00:45:33,829 --> 00:45:35,829

 

1404
00:45:35,829 --> 00:45:38,470

 

1405
00:45:38,470 --> 00:45:39,829

 

1406
00:45:39,829 --> 00:45:42,390

 

1407
00:45:42,390 --> 00:45:44,829

 

1408
00:45:44,829 --> 00:45:47,750

 

1409
00:45:47,750 --> 00:45:49,670

 

1410
00:45:49,670 --> 00:45:51,030

 

1411
00:45:51,030 --> 00:45:52,790

 

1412
00:45:52,790 --> 00:45:55,750

 

1413
00:45:55,750 --> 00:45:55,760

 

1414
00:45:55,760 --> 00:45:56,630


1415
00:45:56,630 --> 00:45:58,390

 

1416
00:45:58,390 --> 00:45:58,400

 

1417
00:45:58,400 --> 00:45:59,030


1418
00:45:59,030 --> 00:46:02,710

 

1419
00:46:02,710 --> 00:46:04,309

 

1420
00:46:04,309 --> 00:46:05,910

 

1421
00:46:05,910 --> 00:46:07,750

 

1422
00:46:07,750 --> 00:46:07,760

 

1423
00:46:07,760 --> 00:46:10,069


1424
00:46:10,069 --> 00:46:12,470

 

1425
00:46:12,470 --> 00:46:14,390

 

1426
00:46:14,390 --> 00:46:17,670

 

1427
00:46:17,670 --> 00:46:17,680

 

1428
00:46:17,680 --> 00:46:19,190


1429
00:46:19,190 --> 00:46:24,150

 

1430
00:46:24,150 --> 00:46:27,109

 

1431
00:46:27,109 --> 00:46:29,750

 

1432
00:46:29,750 --> 00:46:29,760

 

1433
00:46:29,760 --> 00:46:31,109


1434
00:46:31,109 --> 00:46:31,119

 

1435
00:46:31,119 --> 00:46:32,470


1436
00:46:32,470 --> 00:46:34,069

 

1437
00:46:34,069 --> 00:46:36,550

 

1438
00:46:36,550 --> 00:46:38,870

 

1439
00:46:38,870 --> 00:46:42,069

 

1440
00:46:42,069 --> 00:46:43,750

 

1441
00:46:43,750 --> 00:46:43,760

 

1442
00:46:43,760 --> 00:46:45,109


1443
00:46:45,109 --> 00:46:46,870

 

1444
00:46:46,870 --> 00:46:48,550

 

1445
00:46:48,550 --> 00:46:50,150

 

1446
00:46:50,150 --> 00:46:52,870

 

1447
00:46:52,870 --> 00:46:56,790

 

1448
00:46:56,790 --> 00:46:59,829

 

1449
00:46:59,829 --> 00:47:03,829

 

1450
00:47:03,829 --> 00:47:06,470

 

1451
00:47:06,470 --> 00:47:09,109

 

1452
00:47:09,109 --> 00:47:10,950

 

1453
00:47:10,950 --> 00:47:13,829

 

1454
00:47:13,829 --> 00:47:13,839

 

1455
00:47:13,839 --> 00:47:15,030


1456
00:47:15,030 --> 00:47:15,040

 

1457
00:47:15,040 --> 00:47:15,910


1458
00:47:15,910 --> 00:47:17,990

 

1459
00:47:17,990 --> 00:47:20,470

 

1460
00:47:20,470 --> 00:47:21,829

 

1461
00:47:21,829 --> 00:47:24,710

 

1462
00:47:24,710 --> 00:47:27,430

 

1463
00:47:27,430 --> 00:47:29,589

 

1464
00:47:29,589 --> 00:47:31,510

 

1465
00:47:31,510 --> 00:47:33,349

 

1466
00:47:33,349 --> 00:47:36,309

 

1467
00:47:36,309 --> 00:47:39,030

 

1468
00:47:39,030 --> 00:47:41,270

 

1469
00:47:41,270 --> 00:47:43,190

 

1470
00:47:43,190 --> 00:47:45,750

 

1471
00:47:45,750 --> 00:47:45,760

 

1472
00:47:45,760 --> 00:47:46,549


1473
00:47:46,549 --> 00:47:46,559

 

1474
00:47:46,559 --> 00:47:47,510


1475
00:47:47,510 --> 00:47:50,950

 

1476
00:47:50,950 --> 00:47:50,960

 

1477
00:47:50,960 --> 00:47:52,470


1478
00:47:52,470 --> 00:47:55,030

 

1479
00:47:55,030 --> 00:48:00,069

 

1480
00:48:00,069 --> 00:48:02,230

 

1481
00:48:02,230 --> 00:48:03,270

 

1482
00:48:03,270 --> 00:48:06,870

 

1483
00:48:06,870 --> 00:48:08,630

 

1484
00:48:08,630 --> 00:48:10,069

 

1485
00:48:10,069 --> 00:48:12,150

 

1486
00:48:12,150 --> 00:48:12,160

 

1487
00:48:12,160 --> 00:48:13,030


1488
00:48:13,030 --> 00:48:13,040

 

1489
00:48:13,040 --> 00:48:15,270


1490
00:48:15,270 --> 00:48:15,280

 

1491
00:48:15,280 --> 00:48:16,549


1492
00:48:16,549 --> 00:48:19,990

 

1493
00:48:19,990 --> 00:48:20,000

 

1494
00:48:20,000 --> 00:48:21,030


1495
00:48:21,030 --> 00:48:23,349

 

1496
00:48:23,349 --> 00:48:25,030

 

1497
00:48:25,030 --> 00:48:28,870

 

1498
00:48:28,870 --> 00:48:31,670

 

1499
00:48:31,670 --> 00:48:33,270

 

1500
00:48:33,270 --> 00:48:34,790

 

1501
00:48:34,790 --> 00:48:36,630

 

1502
00:48:36,630 --> 00:48:40,630

 

1503
00:48:40,630 --> 00:48:43,349

 

1504
00:48:43,349 --> 00:48:45,990

 

1505
00:48:45,990 --> 00:48:49,750

 

1506
00:48:49,750 --> 00:48:52,549

 

1507
00:48:52,549 --> 00:48:54,630

 

1508
00:48:54,630 --> 00:48:56,630

 

1509
00:48:56,630 --> 00:48:58,390

 

1510
00:48:58,390 --> 00:48:58,400

 

1511
00:48:58,400 --> 00:49:00,309


1512
00:49:00,309 --> 00:49:02,630

 

1513
00:49:02,630 --> 00:49:02,640

 

1514
00:49:02,640 --> 00:49:03,990


1515
00:49:03,990 --> 00:49:06,230

 

1516
00:49:06,230 --> 00:49:08,950

 

1517
00:49:08,950 --> 00:49:11,589

 

1518
00:49:11,589 --> 00:49:13,349

 

1519
00:49:13,349 --> 00:49:16,390

 

1520
00:49:16,390 --> 00:49:18,309

 

1521
00:49:18,309 --> 00:49:19,349

 

1522
00:49:19,349 --> 00:49:21,430

 

1523
00:49:21,430 --> 00:49:27,589

 

1524
00:49:27,589 --> 00:49:28,790

 

1525
00:49:28,790 --> 00:49:33,510

 

1526
00:49:33,510 --> 00:49:33,520

 

1527
00:49:33,520 --> 00:49:34,390


1528
00:49:34,390 --> 00:49:37,109

 

1529
00:49:37,109 --> 00:49:37,119

 

1530
00:49:37,119 --> 00:49:37,829


1531
00:49:37,829 --> 00:49:39,430

 

1532
00:49:39,430 --> 00:49:41,190

 

1533
00:49:41,190 --> 00:49:43,109

 

1534
00:49:43,109 --> 00:49:48,549

 

1535
00:49:48,549 --> 00:49:50,870

 

1536
00:49:50,870 --> 00:49:54,390

 

1537
00:49:54,390 --> 00:49:56,150

 

1538
00:49:56,150 --> 00:49:58,870

 

1539
00:49:58,870 --> 00:50:02,790

 

1540
00:50:02,790 --> 00:50:02,800

 

1541
00:50:02,800 --> 00:50:04,230


1542
00:50:04,230 --> 00:50:05,829

 

1543
00:50:05,829 --> 00:50:08,710

 

1544
00:50:08,710 --> 00:50:10,790

 

1545
00:50:10,790 --> 00:50:14,309

 

1546
00:50:14,309 --> 00:50:16,710

 

1547
00:50:16,710 --> 00:50:16,720

 

1548
00:50:16,720 --> 00:50:19,030


1549
00:50:19,030 --> 00:50:21,109

 

1550
00:50:21,109 --> 00:50:23,349

 

1551
00:50:23,349 --> 00:50:23,359

 

1552
00:50:23,359 --> 00:50:24,870


1553
00:50:24,870 --> 00:50:26,870

 

1554
00:50:26,870 --> 00:50:26,880

 

1555
00:50:26,880 --> 00:50:27,670


1556
00:50:27,670 --> 00:50:30,069

 

1557
00:50:30,069 --> 00:50:32,069

 

1558
00:50:32,069 --> 00:50:33,829

 

1559
00:50:33,829 --> 00:50:35,349

 

1560
00:50:35,349 --> 00:50:37,109

 

1561
00:50:37,109 --> 00:50:40,870

 

1562
00:50:40,870 --> 00:50:44,470

 

1563
00:50:44,470 --> 00:50:46,710

 

1564
00:50:46,710 --> 00:50:49,750

 

1565
00:50:49,750 --> 00:50:51,270

 

1566
00:50:51,270 --> 00:50:53,270

 

1567
00:50:53,270 --> 00:50:55,190

 

1568
00:50:55,190 --> 00:50:56,549

 

1569
00:50:56,549 --> 00:50:58,150

 

1570
00:50:58,150 --> 00:51:01,510

 

1571
00:51:01,510 --> 00:51:03,589

 

1572
00:51:03,589 --> 00:51:06,710

 

1573
00:51:06,710 --> 00:51:08,790

 

1574
00:51:08,790 --> 00:51:10,549

 

1575
00:51:10,549 --> 00:51:13,510

 

1576
00:51:13,510 --> 00:51:13,520

 

1577
00:51:13,520 --> 00:51:15,030


1578
00:51:15,030 --> 00:51:18,069

 

1579
00:51:18,069 --> 00:51:34,829

 

1580
00:51:34,829 --> 00:51:34,839

 

1581
00:51:34,839 --> 00:51:36,549


1582
00:51:36,549 --> 00:51:42,470

 

1583
00:51:42,470 --> 00:51:51,270

 

1584
00:51:51,270 --> 00:51:53,750

 

1585
00:51:53,750 --> 00:51:56,470

 

1586
00:51:56,470 --> 00:51:56,480

 

1587
00:51:56,480 --> 00:51:57,589


1588
00:51:57,589 --> 00:51:59,589

 

1589
00:51:59,589 --> 00:52:02,230

 

1590
00:52:02,230 --> 00:52:05,349

 

1591
00:52:05,349 --> 00:52:05,359

 

1592
00:52:05,359 --> 00:52:07,829


1593
00:52:07,829 --> 00:52:09,109

 

1594
00:52:09,109 --> 00:52:09,119

 

1595
00:52:09,119 --> 00:52:10,069


1596
00:52:10,069 --> 00:52:13,589

 

1597
00:52:13,589 --> 00:52:15,589

 

1598
00:52:15,589 --> 00:52:17,109

 

1599
00:52:17,109 --> 00:52:19,030

 

1600
00:52:19,030 --> 00:52:21,670

 

1601
00:52:21,670 --> 00:52:23,750

 

1602
00:52:23,750 --> 00:52:29,750

 

1603
00:52:29,750 --> 00:52:31,510

 

1604
00:52:31,510 --> 00:52:32,950

 

1605
00:52:32,950 --> 00:52:34,710

 

1606
00:52:34,710 --> 00:52:36,470

 

1607
00:52:36,470 --> 00:52:39,349

 

1608
00:52:39,349 --> 00:52:41,349

 

1609
00:52:41,349 --> 00:52:43,270

 

1610
00:52:43,270 --> 00:52:46,150

 

1611
00:52:46,150 --> 00:52:48,230

 

1612
00:52:48,230 --> 00:52:50,069

 

1613
00:52:50,069 --> 00:52:51,829

 

1614
00:52:51,829 --> 00:52:51,839

 

1615
00:52:51,839 --> 00:52:56,069


1616
00:52:56,069 --> 00:52:58,630

 

1617
00:52:58,630 --> 00:53:00,230

 

1618
00:53:00,230 --> 00:53:02,790

 

1619
00:53:02,790 --> 00:53:05,109

 

1620
00:53:05,109 --> 00:53:07,030

 

1621
00:53:07,030 --> 00:53:09,589

 

1622
00:53:09,589 --> 00:53:12,150

 

1623
00:53:12,150 --> 00:53:13,990

 

1624
00:53:13,990 --> 00:53:15,750

 

1625
00:53:15,750 --> 00:53:15,760

 

1626
00:53:15,760 --> 00:53:17,349


1627
00:53:17,349 --> 00:53:20,230

 

1628
00:53:20,230 --> 00:53:22,870

 

1629
00:53:22,870 --> 00:53:25,349

 

1630
00:53:25,349 --> 00:53:27,349

 

1631
00:53:27,349 --> 00:53:29,510

 

1632
00:53:29,510 --> 00:53:31,750

 

1633
00:53:31,750 --> 00:53:33,589

 

1634
00:53:33,589 --> 00:53:34,870

 

1635
00:53:34,870 --> 00:53:36,470

 

1636
00:53:36,470 --> 00:53:38,549

 

1637
00:53:38,549 --> 00:53:41,270

 

1638
00:53:41,270 --> 00:53:41,280

 

1639
00:53:41,280 --> 00:53:43,750


1640
00:53:43,750 --> 00:53:46,870

 

1641
00:53:46,870 --> 00:53:49,829

 

1642
00:53:49,829 --> 00:53:51,430

 

1643
00:53:51,430 --> 00:53:53,829

 

1644
00:53:53,829 --> 00:53:55,190

 

1645
00:53:55,190 --> 00:53:57,670

 

1646
00:53:57,670 --> 00:53:59,510

 

1647
00:53:59,510 --> 00:54:03,190

 

1648
00:54:03,190 --> 00:54:04,309

 

1649
00:54:04,309 --> 00:54:06,150

 

1650
00:54:06,150 --> 00:54:07,829

 

1651
00:54:07,829 --> 00:54:09,270

 

1652
00:54:09,270 --> 00:54:10,549

 

1653
00:54:10,549 --> 00:54:11,990

 

1654
00:54:11,990 --> 00:54:13,510

 

1655
00:54:13,510 --> 00:54:15,670

 

1656
00:54:15,670 --> 00:54:17,190

 

1657
00:54:17,190 --> 00:54:19,430

 

1658
00:54:19,430 --> 00:54:22,829

 

1659
00:54:22,829 --> 00:54:25,190

 

1660
00:54:25,190 --> 00:54:27,910

 

1661
00:54:27,910 --> 00:54:29,829

 

1662
00:54:29,829 --> 00:54:32,390

 

1663
00:54:32,390 --> 00:54:34,470

 

1664
00:54:34,470 --> 00:54:37,190

 

1665
00:54:37,190 --> 00:54:38,390

 

1666
00:54:38,390 --> 00:54:40,309

 

1667
00:54:40,309 --> 00:54:40,319

 

1668
00:54:40,319 --> 00:54:41,270


1669
00:54:41,270 --> 00:54:42,710

 

1670
00:54:42,710 --> 00:54:43,829

 

1671
00:54:43,829 --> 00:54:45,750

 

1672
00:54:45,750 --> 00:54:47,270

 

1673
00:54:47,270 --> 00:54:47,280

 

1674
00:54:47,280 --> 00:54:48,710


1675
00:54:48,710 --> 00:54:50,950

 

1676
00:54:50,950 --> 00:54:53,589

 

1677
00:54:53,589 --> 00:54:55,750

 

1678
00:54:55,750 --> 00:54:57,910

 

1679
00:54:57,910 --> 00:55:00,230

 

1680
00:55:00,230 --> 00:55:02,630

 

1681
00:55:02,630 --> 00:55:03,910

 

1682
00:55:03,910 --> 00:55:06,309

 

1683
00:55:06,309 --> 00:55:08,150

 

1684
00:55:08,150 --> 00:55:11,270

 

1685
00:55:11,270 --> 00:55:15,430

 

1686
00:55:15,430 --> 00:55:19,109

 

1687
00:55:19,109 --> 00:55:21,510

 

1688
00:55:21,510 --> 00:55:23,510

 

1689
00:55:23,510 --> 00:55:25,510

 

1690
00:55:25,510 --> 00:55:27,510

 

1691
00:55:27,510 --> 00:55:29,510

 

1692
00:55:29,510 --> 00:55:31,109

 

1693
00:55:31,109 --> 00:55:33,190

 

1694
00:55:33,190 --> 00:55:35,910

 

1695
00:55:35,910 --> 00:55:37,430

 

1696
00:55:37,430 --> 00:55:38,950

 

1697
00:55:38,950 --> 00:55:40,710

 

1698
00:55:40,710 --> 00:55:44,150

 

1699
00:55:44,150 --> 00:55:47,670

 

1700
00:55:47,670 --> 00:55:49,589

 

1701
00:55:49,589 --> 00:55:50,950

 

1702
00:55:50,950 --> 00:55:53,270

 

1703
00:55:53,270 --> 00:55:56,390

 

1704
00:55:56,390 --> 00:55:58,630

 

1705
00:55:58,630 --> 00:56:00,870

 

1706
00:56:00,870 --> 00:56:03,430

 

1707
00:56:03,430 --> 00:56:05,910

 

1708
00:56:05,910 --> 00:56:07,510

 

1709
00:56:07,510 --> 00:56:09,190

 

1710
00:56:09,190 --> 00:56:11,349

 

1711
00:56:11,349 --> 00:56:14,069

 

1712
00:56:14,069 --> 00:56:15,510

 

1713
00:56:15,510 --> 00:56:17,349

 

1714
00:56:17,349 --> 00:56:20,069

 

1715
00:56:20,069 --> 00:56:21,910

 

1716
00:56:21,910 --> 00:56:24,230

 

1717
00:56:24,230 --> 00:56:27,430

 

1718
00:56:27,430 --> 00:56:29,910

 

1719
00:56:29,910 --> 00:56:31,670

 

1720
00:56:31,670 --> 00:56:33,030

 

1721
00:56:33,030 --> 00:56:35,270

 

1722
00:56:35,270 --> 00:56:37,510

 

1723
00:56:37,510 --> 00:56:39,750

 

1724
00:56:39,750 --> 00:56:39,760

 

1725
00:56:39,760 --> 00:56:40,630


1726
00:56:40,630 --> 00:56:42,710

 

1727
00:56:42,710 --> 00:56:45,190

 

1728
00:56:45,190 --> 00:56:48,470

 

1729
00:56:48,470 --> 00:56:51,190

 

1730
00:56:51,190 --> 00:56:53,270

 

1731
00:56:53,270 --> 00:56:55,430

 

1732
00:56:55,430 --> 00:56:55,440

 

1733
00:56:55,440 --> 00:56:56,230


1734
00:56:56,230 --> 00:56:57,990

 

1735
00:56:57,990 --> 00:56:59,910

 

1736
00:56:59,910 --> 00:56:59,920

 

1737
00:56:59,920 --> 00:57:01,109


1738
00:57:01,109 --> 00:57:01,119

 

1739
00:57:01,119 --> 00:57:02,150


1740
00:57:02,150 --> 00:57:05,430

 

1741
00:57:05,430 --> 00:57:07,349

 

1742
00:57:07,349 --> 00:57:07,359

 

1743
00:57:07,359 --> 00:57:08,710


1744
00:57:08,710 --> 00:57:09,990

 

1745
00:57:09,990 --> 00:57:12,470

 

1746
00:57:12,470 --> 00:57:14,710

 

1747
00:57:14,710 --> 00:57:16,309

 

1748
00:57:16,309 --> 00:57:18,150

 

1749
00:57:18,150 --> 00:57:19,990

 

1750
00:57:19,990 --> 00:57:23,910

 

1751
00:57:23,910 --> 00:57:23,920

 

1752
00:57:23,920 --> 00:57:25,109


1753
00:57:25,109 --> 00:57:25,119

 

1754
00:57:25,119 --> 00:57:27,030


1755
00:57:27,030 --> 00:57:27,040

 

1756
00:57:27,040 --> 00:57:33,109


1757
00:57:33,109 --> 00:57:35,030

 

1758
00:57:35,030 --> 00:57:44,150

 

1759
00:57:44,150 --> 00:57:46,069

 

1760
00:57:46,069 --> 00:57:46,079

 

1761
00:57:46,079 --> 00:57:47,750


1762
00:57:47,750 --> 00:57:49,190

 

1763
00:57:49,190 --> 00:57:49,200

 

1764
00:57:49,200 --> 00:57:50,950


1765
00:57:50,950 --> 00:57:53,030

 

1766
00:57:53,030 --> 00:57:55,030

 

1767
00:57:55,030 --> 00:57:57,109

 

1768
00:57:57,109 --> 00:57:59,109

 

1769
00:57:59,109 --> 00:58:00,549

 

1770
00:58:00,549 --> 00:58:10,789

 

1771
00:58:10,789 --> 00:58:12,549

 

1772
00:58:12,549 --> 00:58:14,230

 

1773
00:58:14,230 --> 00:58:16,069

 

1774
00:58:16,069 --> 00:58:17,829

 

1775
00:58:17,829 --> 00:58:18,950

 

1776
00:58:18,950 --> 00:58:18,960

 

1777
00:58:18,960 --> 00:58:20,630


1778
00:58:20,630 --> 00:58:23,030

 

1779
00:58:23,030 --> 00:58:23,040

 

1780
00:58:23,040 --> 00:58:23,829


1781
00:58:23,829 --> 00:58:26,950

 

1782
00:58:26,950 --> 00:58:28,950

 

1783
00:58:28,950 --> 00:58:30,710

 

1784
00:58:30,710 --> 00:58:30,720

 

1785
00:58:30,720 --> 00:58:33,270


1786
00:58:33,270 --> 00:58:35,670

 

1787
00:58:35,670 --> 00:58:37,750

 

1788
00:58:37,750 --> 00:58:39,190

 

1789
00:58:39,190 --> 00:58:41,829

 

1790
00:58:41,829 --> 00:58:43,990

 

1791
00:58:43,990 --> 00:58:46,230

 

1792
00:58:46,230 --> 00:58:50,150

 

1793
00:58:50,150 --> 00:58:52,870

 

1794
00:58:52,870 --> 00:58:52,880

 

1795
00:58:52,880 --> 00:58:54,309


1796
00:58:54,309 --> 00:58:56,470

 

1797
00:58:56,470 --> 00:58:58,789

 

1798
00:58:58,789 --> 00:58:58,799

 

1799
00:58:58,799 --> 00:58:59,750


1800
00:58:59,750 --> 00:59:01,270

 

1801
00:59:01,270 --> 00:59:03,589

 

1802
00:59:03,589 --> 00:59:04,870

 

1803
00:59:04,870 --> 00:59:07,750

 

1804
00:59:07,750 --> 00:59:09,510

 

1805
00:59:09,510 --> 00:59:11,270

 

1806
00:59:11,270 --> 00:59:13,270

 

1807
00:59:13,270 --> 00:59:15,430

 

1808
00:59:15,430 --> 00:59:15,440

 

1809
00:59:15,440 --> 00:59:16,630


1810
00:59:16,630 --> 00:59:18,309

 

1811
00:59:18,309 --> 00:59:20,470

 

1812
00:59:20,470 --> 00:59:22,630

 

1813
00:59:22,630 --> 00:59:24,950

 

1814
00:59:24,950 --> 00:59:26,549

 

1815
00:59:26,549 --> 00:59:27,910

 

1816
00:59:27,910 --> 00:59:30,230

 

1817
00:59:30,230 --> 00:59:32,390

 

1818
00:59:32,390 --> 00:59:33,829

 

1819
00:59:33,829 --> 00:59:33,839

 

1820
00:59:33,839 --> 00:59:35,349


1821
00:59:35,349 --> 00:59:37,589

 

1822
00:59:37,589 --> 00:59:37,599

 

1823
00:59:37,599 --> 00:59:39,670


1824
00:59:39,670 --> 00:59:41,109

 

1825
00:59:41,109 --> 00:59:41,119

 

1826
00:59:41,119 --> 00:59:42,309


1827
00:59:42,309 --> 00:59:44,390

 

1828
00:59:44,390 --> 00:59:44,400

 

1829
00:59:44,400 --> 00:59:45,589


1830
00:59:45,589 --> 00:59:47,430

 

1831
00:59:47,430 --> 00:59:47,440

 

1832
00:59:47,440 --> 00:59:48,309


1833
00:59:48,309 --> 00:59:51,270

 

1834
00:59:51,270 --> 00:59:53,750

 

1835
00:59:53,750 --> 00:59:56,900

 

1836
00:59:56,900 --> 00:59:56,910

 

1837
00:59:56,910 --> 00:59:59,030


1838
00:59:59,030 --> 00:59:59,040

 

1839
00:59:59,040 --> 01:00:00,549


1840
01:00:00,549 --> 01:00:02,789

 

1841
01:00:02,789 --> 01:00:02,799

 

1842
01:00:02,799 --> 01:00:04,630


1843
01:00:04,630 --> 01:00:07,510

 

1844
01:00:07,510 --> 01:00:09,270

 

1845
01:00:09,270 --> 01:00:10,789

 

1846
01:00:10,789 --> 01:00:12,630

 

1847
01:00:12,630 --> 01:00:15,109

 

1848
01:00:15,109 --> 01:00:17,109

 

1849
01:00:17,109 --> 01:00:19,829

 

1850
01:00:19,829 --> 01:00:23,270

 

1851
01:00:23,270 --> 01:00:25,109

 

1852
01:00:25,109 --> 01:00:27,349

 

1853
01:00:27,349 --> 01:00:27,359

 

1854
01:00:27,359 --> 01:00:28,630


1855
01:00:28,630 --> 01:00:30,549

 

1856
01:00:30,549 --> 01:00:33,109

 

1857
01:00:33,109 --> 01:00:34,470

 

1858
01:00:34,470 --> 01:00:37,030

 

1859
01:00:37,030 --> 01:00:40,710

 

1860
01:00:40,710 --> 01:00:42,870

 

1861
01:00:42,870 --> 01:00:44,470

 

1862
01:00:44,470 --> 01:00:47,109

 

1863
01:00:47,109 --> 01:00:49,910

 

1864
01:00:49,910 --> 01:00:53,510

 

1865
01:00:53,510 --> 01:00:56,630

 

1866
01:00:56,630 --> 01:00:58,789

 

1867
01:00:58,789 --> 01:01:01,109

 

1868
01:01:01,109 --> 01:01:03,430

 

1869
01:01:03,430 --> 01:01:05,349

 

1870
01:01:05,349 --> 01:01:07,270

 

1871
01:01:07,270 --> 01:01:08,710

 

1872
01:01:08,710 --> 01:01:11,349

 

1873
01:01:11,349 --> 01:01:11,359

 

1874
01:01:11,359 --> 01:01:12,630


1875
01:01:12,630 --> 01:01:15,030

 

1876
01:01:15,030 --> 01:01:15,040

 

1877
01:01:15,040 --> 01:01:16,309


1878
01:01:16,309 --> 01:01:18,549

 

1879
01:01:18,549 --> 01:01:20,230

 

1880
01:01:20,230 --> 01:01:22,230

 

1881
01:01:22,230 --> 01:01:23,670

 

1882
01:01:23,670 --> 01:01:25,430

 

1883
01:01:25,430 --> 01:01:27,190

 

1884
01:01:27,190 --> 01:01:30,710

 

1885
01:01:30,710 --> 01:01:33,109

 

1886
01:01:33,109 --> 01:01:35,589

 

1887
01:01:35,589 --> 01:01:38,630

 

1888
01:01:38,630 --> 01:01:40,390

 

1889
01:01:40,390 --> 01:01:40,400

 

1890
01:01:40,400 --> 01:01:41,750


1891
01:01:41,750 --> 01:01:41,760

 

1892
01:01:41,760 --> 01:01:42,630


1893
01:01:42,630 --> 01:01:45,670

 

1894
01:01:45,670 --> 01:01:47,750

 

1895
01:01:47,750 --> 01:01:49,589

 

1896
01:01:49,589 --> 01:01:52,390

 

1897
01:01:52,390 --> 01:01:54,230

 

1898
01:01:54,230 --> 01:01:56,069

 

1899
01:01:56,069 --> 01:01:59,029

 

1900
01:01:59,029 --> 01:02:01,109

 

1901
01:02:01,109 --> 01:02:03,190

 

1902
01:02:03,190 --> 01:02:03,200

 

1903
01:02:03,200 --> 01:02:04,870


1904
01:02:04,870 --> 01:02:04,880

 

1905
01:02:04,880 --> 01:02:06,549


1906
01:02:06,549 --> 01:02:09,510

 

1907
01:02:09,510 --> 01:02:11,190

 

1908
01:02:11,190 --> 01:02:13,750

 

1909
01:02:13,750 --> 01:02:15,349

 

1910
01:02:15,349 --> 01:02:18,630

 

1911
01:02:18,630 --> 01:02:21,270

 

1912
01:02:21,270 --> 01:02:23,510

 

1913
01:02:23,510 --> 01:02:25,829

 

1914
01:02:25,829 --> 01:02:27,589

 

1915
01:02:27,589 --> 01:02:30,630

 

1916
01:02:30,630 --> 01:02:33,510

 

1917
01:02:33,510 --> 01:02:35,829

 

1918
01:02:35,829 --> 01:02:37,430

 

1919
01:02:37,430 --> 01:02:40,470

 

1920
01:02:40,470 --> 01:02:43,349

 

1921
01:02:43,349 --> 01:02:45,270

 

1922
01:02:45,270 --> 01:02:45,280

 

1923
01:02:45,280 --> 01:02:46,829


1924
01:02:46,829 --> 01:02:51,349

 

1925
01:02:51,349 --> 01:03:03,109

 

1926
01:03:03,109 --> 01:03:04,470

 

1927
01:03:04,470 --> 01:03:11,510

 

1928
01:03:11,510 --> 01:03:15,190

 

1929
01:03:15,190 --> 01:03:17,589

 

1930
01:03:17,589 --> 01:03:17,599

 

1931
01:03:17,599 --> 01:03:24,150


1932
01:03:24,150 --> 01:03:26,309

 

1933
01:03:26,309 --> 01:03:27,990

 

1934
01:03:27,990 --> 01:03:31,510

 

1935
01:03:31,510 --> 01:03:31,520

 

1936
01:03:31,520 --> 01:03:35,670


1937
01:03:35,670 --> 01:03:37,510

 

1938
01:03:37,510 --> 01:03:40,150

 

1939
01:03:40,150 --> 01:03:42,150

 

1940
01:03:42,150 --> 01:03:45,270

 

1941
01:03:45,270 --> 01:03:46,710

 

1942
01:03:46,710 --> 01:03:46,720

 

1943
01:03:46,720 --> 01:03:48,069


1944
01:03:48,069 --> 01:03:49,750

 

1945
01:03:49,750 --> 01:03:51,109

 

1946
01:03:51,109 --> 01:03:51,119

 

1947
01:03:51,119 --> 01:03:52,230


1948
01:03:52,230 --> 01:03:52,240

 

1949
01:03:52,240 --> 01:03:53,510


1950
01:03:53,510 --> 01:03:55,270

 

1951
01:03:55,270 --> 01:03:57,109

 

1952
01:03:57,109 --> 01:04:00,870

 

1953
01:04:00,870 --> 01:04:02,470

 

1954
01:04:02,470 --> 01:04:04,950

 

1955
01:04:04,950 --> 01:04:07,109

 

1956
01:04:07,109 --> 01:04:08,710

 

1957
01:04:08,710 --> 01:04:10,309

 

1958
01:04:10,309 --> 01:04:10,319

 

1959
01:04:10,319 --> 01:04:11,829


1960
01:04:11,829 --> 01:04:14,390

 

1961
01:04:14,390 --> 01:04:16,470

 

1962
01:04:16,470 --> 01:04:18,870

 

1963
01:04:18,870 --> 01:04:18,880

 

1964
01:04:18,880 --> 01:04:20,230


1965
01:04:20,230 --> 01:04:22,390

 

1966
01:04:22,390 --> 01:04:24,630

 

1967
01:04:24,630 --> 01:04:26,870

 

1968
01:04:26,870 --> 01:04:29,670

 

1969
01:04:29,670 --> 01:04:31,349

 

1970
01:04:31,349 --> 01:04:33,109

 

1971
01:04:33,109 --> 01:04:33,119

 

1972
01:04:33,119 --> 01:04:34,230


1973
01:04:34,230 --> 01:04:36,470

 

1974
01:04:36,470 --> 01:04:38,950

 

1975
01:04:38,950 --> 01:04:42,069

 

1976
01:04:42,069 --> 01:04:42,079

 

1977
01:04:42,079 --> 01:04:43,349


1978
01:04:43,349 --> 01:04:46,069

 

1979
01:04:46,069 --> 01:04:48,309

 

1980
01:04:48,309 --> 01:04:50,150

 

1981
01:04:50,150 --> 01:04:51,829

 

1982
01:04:51,829 --> 01:04:53,430

 

1983
01:04:53,430 --> 01:04:57,109

 

1984
01:04:57,109 --> 01:04:57,119

 

1985
01:04:57,119 --> 01:04:58,470


1986
01:04:58,470 --> 01:05:00,150

 

1987
01:05:00,150 --> 01:05:02,150

 

1988
01:05:02,150 --> 01:05:03,589

 

1989
01:05:03,589 --> 01:05:04,950

 

1990
01:05:04,950 --> 01:05:04,960

 

1991
01:05:04,960 --> 01:05:06,309


1992
01:05:06,309 --> 01:05:08,069

 

1993
01:05:08,069 --> 01:05:08,079

 

1994
01:05:08,079 --> 01:05:09,430


1995
01:05:09,430 --> 01:05:11,270

 

1996
01:05:11,270 --> 01:05:13,910

 

1997
01:05:13,910 --> 01:05:16,710

 

1998
01:05:16,710 --> 01:05:16,720

 

1999
01:05:16,720 --> 01:05:18,150


2000
01:05:18,150 --> 01:05:19,589

 

2001
01:05:19,589 --> 01:05:21,029

 

2002
01:05:21,029 --> 01:05:21,039

 

2003
01:05:21,039 --> 01:05:23,109


2004
01:05:23,109 --> 01:05:23,119

 

2005
01:05:23,119 --> 01:05:23,910


2006
01:05:23,910 --> 01:05:25,109

 

2007
01:05:25,109 --> 01:05:26,710

 

2008
01:05:26,710 --> 01:05:28,390

 

2009
01:05:28,390 --> 01:05:29,910

 

2010
01:05:29,910 --> 01:05:32,470

 

2011
01:05:32,470 --> 01:05:34,630

 

2012
01:05:34,630 --> 01:05:36,630

 

2013
01:05:36,630 --> 01:05:38,309

 

2014
01:05:38,309 --> 01:05:40,230

 

2015
01:05:40,230 --> 01:05:42,789

 

2016
01:05:42,789 --> 01:05:44,549

 

2017
01:05:44,549 --> 01:05:47,029

 

2018
01:05:47,029 --> 01:05:49,990

 

2019
01:05:49,990 --> 01:05:52,069

 

2020
01:05:52,069 --> 01:05:52,079

 

2021
01:05:52,079 --> 01:05:54,069


2022
01:05:54,069 --> 01:05:55,510

 

2023
01:05:55,510 --> 01:05:57,190

 

2024
01:05:57,190 --> 01:05:57,200

 

2025
01:05:57,200 --> 01:05:58,710


2026
01:05:58,710 --> 01:06:00,630

 

2027
01:06:00,630 --> 01:06:00,640

 

2028
01:06:00,640 --> 01:06:01,670


2029
01:06:01,670 --> 01:06:01,680

 

2030
01:06:01,680 --> 01:06:03,190


2031
01:06:03,190 --> 01:06:06,150

 

2032
01:06:06,150 --> 01:06:07,990

 

2033
01:06:07,990 --> 01:06:09,430

 

2034
01:06:09,430 --> 01:06:11,750

 

2035
01:06:11,750 --> 01:06:14,150

 

2036
01:06:14,150 --> 01:06:15,270

 

2037
01:06:15,270 --> 01:06:17,270

 

2038
01:06:17,270 --> 01:06:17,280

 

2039
01:06:17,280 --> 01:06:18,870


2040
01:06:18,870 --> 01:06:21,910

 

2041
01:06:21,910 --> 01:06:21,920

 

2042
01:06:21,920 --> 01:06:23,029


2043
01:06:23,029 --> 01:06:25,990

 

2044
01:06:25,990 --> 01:06:27,589

 

2045
01:06:27,589 --> 01:06:29,589

 

2046
01:06:29,589 --> 01:06:32,470

 

2047
01:06:32,470 --> 01:06:34,069

 

2048
01:06:34,069 --> 01:06:36,230

 

2049
01:06:36,230 --> 01:06:37,990

 

2050
01:06:37,990 --> 01:06:38,000

 

2051
01:06:38,000 --> 01:06:38,870


2052
01:06:38,870 --> 01:06:41,750

 

2053
01:06:41,750 --> 01:06:43,990

 

2054
01:06:43,990 --> 01:06:46,789

 

2055
01:06:46,789 --> 01:06:49,190

 

2056
01:06:49,190 --> 01:06:50,789

 

2057
01:06:50,789 --> 01:06:50,799

 

2058
01:06:50,799 --> 01:06:51,829


2059
01:06:51,829 --> 01:06:51,839

 

2060
01:06:51,839 --> 01:06:53,670


2061
01:06:53,670 --> 01:06:56,549

 

2062
01:06:56,549 --> 01:06:56,559

 

2063
01:06:56,559 --> 01:06:57,430


2064
01:06:57,430 --> 01:06:58,870

 

2065
01:06:58,870 --> 01:07:01,430

 

2066
01:07:01,430 --> 01:07:03,109

 

2067
01:07:03,109 --> 01:07:04,230

 

2068
01:07:04,230 --> 01:07:04,240

 

2069
01:07:04,240 --> 01:07:05,270


2070
01:07:05,270 --> 01:07:08,309

 

2071
01:07:08,309 --> 01:07:09,589

 

2072
01:07:09,589 --> 01:07:11,349

 

2073
01:07:11,349 --> 01:07:11,359

 

2074
01:07:11,359 --> 01:07:12,789


2075
01:07:12,789 --> 01:07:15,510

 

2076
01:07:15,510 --> 01:07:16,870

 

2077
01:07:16,870 --> 01:07:19,510

 

2078
01:07:19,510 --> 01:07:21,109

 

2079
01:07:21,109 --> 01:07:24,230

 

2080
01:07:24,230 --> 01:07:24,240

 

2081
01:07:24,240 --> 01:07:25,670


2082
01:07:25,670 --> 01:07:28,470

 

2083
01:07:28,470 --> 01:07:28,480

 

2084
01:07:28,480 --> 01:07:30,069


2085
01:07:30,069 --> 01:07:32,710

 

2086
01:07:32,710 --> 01:07:34,630

 

2087
01:07:34,630 --> 01:07:36,710

 

2088
01:07:36,710 --> 01:07:38,069

 

2089
01:07:38,069 --> 01:07:40,710

 

2090
01:07:40,710 --> 01:07:42,390

 

2091
01:07:42,390 --> 01:07:44,230

 

2092
01:07:44,230 --> 01:07:47,910

 

2093
01:07:47,910 --> 01:07:47,920

 

2094
01:07:47,920 --> 01:07:49,670


2095
01:07:49,670 --> 01:07:54,309

 

2096
01:07:54,309 --> 01:07:54,319

 

2097
01:07:54,319 --> 01:07:55,589


2098
01:07:55,589 --> 01:07:57,510

 

2099
01:07:57,510 --> 01:08:00,069

 

2100
01:08:00,069 --> 01:08:02,789

 

2101
01:08:02,789 --> 01:08:02,799

 

2102
01:08:02,799 --> 01:08:05,670


2103
01:08:05,670 --> 01:08:07,670

 

2104
01:08:07,670 --> 01:08:10,150

 

2105
01:08:10,150 --> 01:08:13,349

 

2106
01:08:13,349 --> 01:08:13,359

 

2107
01:08:13,359 --> 01:08:15,910


2108
01:08:15,910 --> 01:08:18,630

 

2109
01:08:18,630 --> 01:08:18,640

 

2110
01:08:18,640 --> 01:08:19,990


2111
01:08:19,990 --> 01:08:22,309

 

2112
01:08:22,309 --> 01:08:24,709

 

2113
01:08:24,709 --> 01:08:24,719

 

2114
01:08:24,719 --> 01:08:26,630


2115
01:08:26,630 --> 01:08:28,709

 

2116
01:08:28,709 --> 01:08:31,030

 

2117
01:08:31,030 --> 01:08:33,669

 

2118
01:08:33,669 --> 01:08:35,430

 

2119
01:08:35,430 --> 01:08:38,070

 

2120
01:08:38,070 --> 01:08:40,870

 

2121
01:08:40,870 --> 01:08:42,630

 

2122
01:08:42,630 --> 01:08:46,470

 

2123
01:08:46,470 --> 01:08:48,149

 

2124
01:08:48,149 --> 01:08:48,159

 

2125
01:08:48,159 --> 01:08:50,149


2126
01:08:50,149 --> 01:08:52,550

 

2127
01:08:52,550 --> 01:08:54,309

 

2128
01:08:54,309 --> 01:08:57,189

 

2129
01:08:57,189 --> 01:08:59,110

 

2130
01:08:59,110 --> 01:09:01,510

 

2131
01:09:01,510 --> 01:09:04,070

 

2132
01:09:04,070 --> 01:09:05,510

 

2133
01:09:05,510 --> 01:09:09,030

 

2134
01:09:09,030 --> 01:09:10,550

 

2135
01:09:10,550 --> 01:09:14,789

 

2136
01:09:14,789 --> 01:09:17,189

 

2137
01:09:17,189 --> 01:09:19,030

 

2138
01:09:19,030 --> 01:09:20,870

 

2139
01:09:20,870 --> 01:09:22,229

 

2140
01:09:22,229 --> 01:09:23,669

 

2141
01:09:23,669 --> 01:09:25,669

 

2142
01:09:25,669 --> 01:09:28,309

 

2143
01:09:28,309 --> 01:09:30,309

 

2144
01:09:30,309 --> 01:09:33,510

 

2145
01:09:33,510 --> 01:09:35,269

 

2146
01:09:35,269 --> 01:09:36,870

 

2147
01:09:36,870 --> 01:09:39,669

 

2148
01:09:39,669 --> 01:09:42,070

 

2149
01:09:42,070 --> 01:09:44,149

 

2150
01:09:44,149 --> 01:09:47,189

 

2151
01:09:47,189 --> 01:09:48,870

 

2152
01:09:48,870 --> 01:09:50,709

 

2153
01:09:50,709 --> 01:09:51,990

 

2154
01:09:51,990 --> 01:09:52,000

 

2155
01:09:52,000 --> 01:09:54,229


2156
01:09:54,229 --> 01:09:54,239

 

2157
01:09:54,239 --> 01:09:56,149


2158
01:09:56,149 --> 01:09:58,149

 

2159
01:09:58,149 --> 01:10:00,070

 

2160
01:10:00,070 --> 01:10:01,510

 

2161
01:10:01,510 --> 01:10:02,870

 

2162
01:10:02,870 --> 01:10:05,510

 

2163
01:10:05,510 --> 01:10:06,950

 

2164
01:10:06,950 --> 01:10:09,270

 

2165
01:10:09,270 --> 01:10:11,030

 

2166
01:10:11,030 --> 01:10:12,310

 

2167
01:10:12,310 --> 01:10:13,910

 

2168
01:10:13,910 --> 01:10:15,350

 

2169
01:10:15,350 --> 01:10:15,360

 

2170
01:10:15,360 --> 01:10:16,390


2171
01:10:16,390 --> 01:10:16,400

 

2172
01:10:16,400 --> 01:10:17,669


2173
01:10:17,669 --> 01:10:20,630

 

2174
01:10:20,630 --> 01:10:22,229

 

2175
01:10:22,229 --> 01:10:23,590

 

2176
01:10:23,590 --> 01:10:26,149

 

2177
01:10:26,149 --> 01:10:29,030

 

2178
01:10:29,030 --> 01:10:31,750

 

2179
01:10:31,750 --> 01:10:33,510

 

2180
01:10:33,510 --> 01:10:35,350

 

2181
01:10:35,350 --> 01:10:38,550

 

2182
01:10:38,550 --> 01:10:41,590

 

2183
01:10:41,590 --> 01:10:45,270

 

2184
01:10:45,270 --> 01:10:47,430

 

2185
01:10:47,430 --> 01:10:49,430

 

2186
01:10:49,430 --> 01:10:51,510

 

2187
01:10:51,510 --> 01:10:53,430

 

2188
01:10:53,430 --> 01:10:55,110

 

2189
01:10:55,110 --> 01:10:58,310

 

2190
01:10:58,310 --> 01:11:00,550

 

2191
01:11:00,550 --> 01:11:02,630

 

2192
01:11:02,630 --> 01:11:05,750

 

2193
01:11:05,750 --> 01:11:05,760

 

2194
01:11:05,760 --> 01:11:07,990


2195
01:11:07,990 --> 01:11:10,070

 

2196
01:11:10,070 --> 01:11:12,149

 

2197
01:11:12,149 --> 01:11:14,229

 

2198
01:11:14,229 --> 01:11:15,910

 

2199
01:11:15,910 --> 01:11:15,920

 

2200
01:11:15,920 --> 01:11:17,590


2201
01:11:17,590 --> 01:11:19,430

 

2202
01:11:19,430 --> 01:11:20,950

 

2203
01:11:20,950 --> 01:11:20,960

 

2204
01:11:20,960 --> 01:11:22,790


2205
01:11:22,790 --> 01:11:24,390

 

2206
01:11:24,390 --> 01:11:27,669

 

2207
01:11:27,669 --> 01:11:29,590

 

2208
01:11:29,590 --> 01:11:31,110

 

2209
01:11:31,110 --> 01:11:33,590

 

2210
01:11:33,590 --> 01:11:35,590

 

2211
01:11:35,590 --> 01:11:38,390

 

2212
01:11:38,390 --> 01:11:40,310

 

2213
01:11:40,310 --> 01:11:41,910

 

2214
01:11:41,910 --> 01:11:43,750

 

2215
01:11:43,750 --> 01:11:45,510

 

2216
01:11:45,510 --> 01:11:45,520

 

2217
01:11:45,520 --> 01:11:46,229


2218
01:11:46,229 --> 01:11:48,070

 

2219
01:11:48,070 --> 01:11:51,430

 

2220
01:11:51,430 --> 01:11:53,270

 

2221
01:11:53,270 --> 01:11:54,870

 

2222
01:11:54,870 --> 01:11:56,630

 

2223
01:11:56,630 --> 01:11:59,830

 

2224
01:11:59,830 --> 01:12:02,229

 

2225
01:12:02,229 --> 01:12:04,310

 

2226
01:12:04,310 --> 01:12:06,310

 

2227
01:12:06,310 --> 01:12:09,350

 

2228
01:12:09,350 --> 01:12:11,510

 

2229
01:12:11,510 --> 01:12:13,990

 

2230
01:12:13,990 --> 01:12:17,750

 

2231
01:12:17,750 --> 01:12:20,070

 

2232
01:12:20,070 --> 01:12:22,870

 

2233
01:12:22,870 --> 01:12:25,430

 

2234
01:12:25,430 --> 01:12:29,030

 

2235
01:12:29,030 --> 01:12:30,870

 

2236
01:12:30,870 --> 01:12:33,030

 

2237
01:12:33,030 --> 01:12:35,110

 

2238
01:12:35,110 --> 01:12:37,110

 

2239
01:12:37,110 --> 01:12:39,350

 

2240
01:12:39,350 --> 01:12:41,189

 

2241
01:12:41,189 --> 01:12:42,709

 

2242
01:12:42,709 --> 01:12:42,719

 

2243
01:12:42,719 --> 01:12:44,470


2244
01:12:44,470 --> 01:12:44,480

 

2245
01:12:44,480 --> 01:12:45,830


2246
01:12:45,830 --> 01:12:45,840

 

2247
01:12:45,840 --> 01:12:48,390


2248
01:12:48,390 --> 01:12:50,390

 

2249
01:12:50,390 --> 01:12:53,830

 

2250
01:12:53,830 --> 01:12:53,840

 

2251
01:12:53,840 --> 01:12:56,229


2252
01:12:56,229 --> 01:12:56,239

 

2253
01:12:56,239 --> 01:12:57,430


2254
01:12:57,430 --> 01:12:59,110

 

2255
01:12:59,110 --> 01:13:00,950

 

2256
01:13:00,950 --> 01:13:00,960

 

2257
01:13:00,960 --> 01:13:02,149


2258
01:13:02,149 --> 01:13:02,159

 

2259
01:13:02,159 --> 01:13:03,590


2260
01:13:03,590 --> 01:13:06,070

 

2261
01:13:06,070 --> 01:13:06,080

 

2262
01:13:06,080 --> 01:13:08,070


2263
01:13:08,070 --> 01:13:10,470

 

2264
01:13:10,470 --> 01:13:10,480

 

2265
01:13:10,480 --> 01:13:11,430


2266
01:13:11,430 --> 01:13:12,709

 

2267
01:13:12,709 --> 01:13:12,719

 

2268
01:13:12,719 --> 01:13:13,669


2269
01:13:13,669 --> 01:13:15,270

 

2270
01:13:15,270 --> 01:13:17,110

 

2271
01:13:17,110 --> 01:13:19,910

 

2272
01:13:19,910 --> 01:13:22,070

 

2273
01:13:22,070 --> 01:13:23,510

 

2274
01:13:23,510 --> 01:13:23,520

 

2275
01:13:23,520 --> 01:13:24,950


2276
01:13:24,950 --> 01:13:27,830

 

2277
01:13:27,830 --> 01:13:31,030

 

2278
01:13:31,030 --> 01:13:33,430

 

2279
01:13:33,430 --> 01:13:35,189

 

2280
01:13:35,189 --> 01:13:36,149

 

2281
01:13:36,149 --> 01:13:38,149

 

2282
01:13:38,149 --> 01:13:40,550

 

2283
01:13:40,550 --> 01:13:42,550

 

2284
01:13:42,550 --> 01:13:45,510

 

2285
01:13:45,510 --> 01:13:46,950

 

2286
01:13:46,950 --> 01:13:50,229

 

2287
01:13:50,229 --> 01:13:50,239

 

2288
01:13:50,239 --> 01:13:51,270


2289
01:13:51,270 --> 01:13:53,270

 

2290
01:13:53,270 --> 01:13:54,390

 

2291
01:13:54,390 --> 01:13:54,400

 

2292
01:13:54,400 --> 01:13:55,189


2293
01:13:55,189 --> 01:13:56,870

 

2294
01:13:56,870 --> 01:13:58,950

 

2295
01:13:58,950 --> 01:14:01,270

 

2296
01:14:01,270 --> 01:14:03,350

 

2297
01:14:03,350 --> 01:14:04,709

 

2298
01:14:04,709 --> 01:14:06,390

 

2299
01:14:06,390 --> 01:14:06,400

 

2300
01:14:06,400 --> 01:14:08,390


2301
01:14:08,390 --> 01:14:08,400

 

2302
01:14:08,400 --> 01:14:09,430


2303
01:14:09,430 --> 01:14:11,110

 

2304
01:14:11,110 --> 01:14:12,950

 

2305
01:14:12,950 --> 01:14:14,870

 

2306
01:14:14,870 --> 01:14:16,630

 

2307
01:14:16,630 --> 01:14:18,229

 

2308
01:14:18,229 --> 01:14:20,790

 

2309
01:14:20,790 --> 01:14:23,030

 

2310
01:14:23,030 --> 01:14:24,950

 

2311
01:14:24,950 --> 01:14:26,790

 

2312
01:14:26,790 --> 01:14:28,229

 

2313
01:14:28,229 --> 01:14:28,239

 

2314
01:14:28,239 --> 01:14:29,350


2315
01:14:29,350 --> 01:14:29,360

 

2316
01:14:29,360 --> 01:14:30,310


2317
01:14:30,310 --> 01:14:31,669

 

2318
01:14:31,669 --> 01:14:33,990

 

2319
01:14:33,990 --> 01:14:36,390

 

2320
01:14:36,390 --> 01:14:37,910

 

2321
01:14:37,910 --> 01:14:42,390

 

2322
01:14:42,390 --> 01:14:47,270

 

2323
01:14:47,270 --> 01:14:48,870

 

2324
01:14:48,870 --> 01:14:51,990

 

2325
01:14:51,990 --> 01:14:53,910

 

2326
01:14:53,910 --> 01:14:56,709

 

2327
01:14:56,709 --> 01:14:58,390

 

2328
01:14:58,390 --> 01:15:00,310

 

2329
01:15:00,310 --> 01:15:03,189

 

2330
01:15:03,189 --> 01:15:03,199

 

2331
01:15:03,199 --> 01:15:05,030


2332
01:15:05,030 --> 01:15:05,040

 

2333
01:15:05,040 --> 01:15:06,390


2334
01:15:06,390 --> 01:15:08,790

 

2335
01:15:08,790 --> 01:15:11,110

 

2336
01:15:11,110 --> 01:15:13,110

 

2337
01:15:13,110 --> 01:15:14,790

 

2338
01:15:14,790 --> 01:15:20,229

 

2339
01:15:20,229 --> 01:15:20,239

 

2340
01:15:20,239 --> 01:15:21,510


2341
01:15:21,510 --> 01:15:22,870

 

2342
01:15:22,870 --> 01:15:25,590

 

2343
01:15:25,590 --> 01:15:27,430

 

2344
01:15:27,430 --> 01:15:28,950

 

2345
01:15:28,950 --> 01:15:32,149

 

2346
01:15:32,149 --> 01:15:32,159

 

2347
01:15:32,159 --> 01:15:33,669


2348
01:15:33,669 --> 01:15:36,070

 

2349
01:15:36,070 --> 01:15:36,080

 

2350
01:15:36,080 --> 01:15:37,430


2351
01:15:37,430 --> 01:15:39,750

 

2352
01:15:39,750 --> 01:15:41,030

 

2353
01:15:41,030 --> 01:15:44,470

 

2354
01:15:44,470 --> 01:15:44,480

 

2355
01:15:44,480 --> 01:15:45,669


2356
01:15:45,669 --> 01:15:47,910

 

2357
01:15:47,910 --> 01:15:49,750

 

2358
01:15:49,750 --> 01:15:51,910

 

2359
01:15:51,910 --> 01:15:54,070

 

2360
01:15:54,070 --> 01:15:54,080

 

2361
01:15:54,080 --> 01:15:55,189


2362
01:15:55,189 --> 01:15:57,510

 

2363
01:15:57,510 --> 01:15:58,950

 

2364
01:15:58,950 --> 01:15:58,960

 

2365
01:15:58,960 --> 01:16:00,709


2366
01:16:00,709 --> 01:16:01,910

 

2367
01:16:01,910 --> 01:16:04,310

 

2368
01:16:04,310 --> 01:16:06,630

 

2369
01:16:06,630 --> 01:16:08,310

 

2370
01:16:08,310 --> 01:16:10,709

 

2371
01:16:10,709 --> 01:16:12,229

 

2372
01:16:12,229 --> 01:16:14,310

 

2373
01:16:14,310 --> 01:16:15,990

 

2374
01:16:15,990 --> 01:16:17,510

 

2375
01:16:17,510 --> 01:16:19,110

 

2376
01:16:19,110 --> 01:16:21,270

 

2377
01:16:21,270 --> 01:16:22,550

 

2378
01:16:22,550 --> 01:16:25,830

 

2379
01:16:25,830 --> 01:16:27,590

 

2380
01:16:27,590 --> 01:16:29,270

 

2381
01:16:29,270 --> 01:16:31,189

 

2382
01:16:31,189 --> 01:16:32,950

 

2383
01:16:32,950 --> 01:16:34,630

 

2384
01:16:34,630 --> 01:16:37,350

 

2385
01:16:37,350 --> 01:16:50,390

 

2386
01:16:50,390 --> 01:16:50,400

 

2387
01:16:50,400 --> 01:16:52,480