1
00:00:24,880 --> 00:00:26,550

okay  hi everybody  let's get started  so  um  it's been a while since we uh  came together in a lecture last week we  had the holiday we had the midterm  um  so uh with that um  where what have we been doing um we  finished the first half of the course um  you know about two weeks ago  where we talked uh we were talking about  computability theory we have shifted  into the second half talking about  complexity theory um so  get your mind uh back to that  uh we um discussed the various different  models um  [Music]  and and and ways of measuring uh  complexity on different models um  at least in terms of the amount of time  that's used and in the end we settled on  the one tape turing machine which is the  same model we had been working with in  the first half of the course and argued  that um  though there  the measures of complexity are going to  differ somewhat from model to model  they're not going to matter  different by more than a polynomial  amount and so  since the kinds of questions we're going  to be asking  uh are going to be um basically whether  problems are polynomial or not uh it's  not going to really matter uh which  model we pick among reasonable  deterministic models and so we're gonna  the one tape turing machine is a  reasonable choice  uh given that we defined time complexity  classes the time t of n classes  we defined the class p  which was invariant among all of those  different model deterministic models in  the sense that it didn't matter which  model we choose we're going to end up  with the same class p so that argues for  its naturalness  and we gave an example of this path  problem being in p and we kind of ended  that lecture uh before the midterm with  the discussion of this hamiltonian path  problem so we're going to come back to  that today  uh so today we're going to look at  non-deterministic complexity uh define  the  classes non-deterministic time or end  time  uh talk about the class np  the p versus np problem which one of the  you know very famous unsolved problems  in our field  and  uh look at dynamic programming one of  the most basic algorithm polynomial time  algorithms and polynomial time  reproducibility moving toward our  discussion of np completeness which we  will begin um  next lecture so with that uh let's move  into today's uh  content which is  well just quick review we  as i mentioned we defined the time  complexity class  this is a the time complexity class is a  collection of  languages  the languages that you can do  um  these are a collection of languages  all of the languages that you can solve  in  a certain amount of a certain time bound  within a certain amount of time so the  time  the time n squared for example is all of  the the pr all of the languages or all  of the problems that you can solve in n  squared times we're identifying problems  with languages here  and the class p  is the collection of all problems that  you can solve or languages that you can  solve in polynomial time so it's the  union over all time n to the k so n  squared and cubed and to the fifth power  and so on um union out of all that all  of those bounds um  the the associated language languages  that's the class p  and um we gave an example this path  problem we gave an algorithm for path  and then we introduced this hamiltonian  path problem  so  if you remember  instead of just asking  given a graph whether you can get from s  to t  now we want to know can i get from s of  t but visit every other node along the  way  so find a  a path that goes through everything else  and gets from s to t  um  and uh  i should say it's also it's a simple  path so you're only allowed to go  through every node just once  um  and now um  uh um  the question is for this problem is  that can we solve that problem in  polynomial time the  you know can we somehow modify the  algorithm for path to give us an  algorithm that solves hamiltonian path  in polynomial time of course we could  solve hamiltonian path with an  exponential algorithm by trying all  possible paths um  and that will give a correct  algorithm but  there are exponentially many different  paths and trying them all  will not give a polynomial time  algorithm so the interesting problem is  can we solve that without doing that  brute force searching through all  possible paths  um  and  that's a problem that no one knows the  answer to  um  despite lots of effort people have not  succeeded in finding an algorithm for  that but um on the other hand we don't  have any idea how to approve there is no  such algorithm  i mean it's conceivable that one could  prove such a thing but we just don't  know how to do it  and so um  that problem is an unsolved problem and  i just want this isn't really a note to  myself um  what's kind of amazing and this is what  we're going to be showing over the next  few lectures  that there are there would there would  be very surprising consequences  if you could find a way to solve  hamiltonian path in polynomial time  because what that would immediately  yield  is a polynomial time way of say  factoring large numbers or solving a  large number of other problems that we  don't don't know how to solve in  polynomial time so you know as we  mentioned you know factoring um isn't  problem that we only know at present  time itself with an exponential  algorithm  um and it doesn't seem to have anything  to do with the fact with the hamiltonian  path problem seemed very different  but yet  if you can solve hamiltonian path and  polynomial time then you can factor  numbers in polynomial time and so we'll  see how to make that connection um  that's what we're building toward with  the next uh few lectures  okay  um  so happy to take any comments on  comments and questions on that or we'll  just move on  um  if you have any questions on our little  review  well send questions along and we can  stop at the end of uh you know various  slides to to to try to answer them or  and of course write to the tas um who  can take your questions during during  while i'm lecturing  okay um  so to start this off we're going to have  to talk about  uh non-deterministic complexity as a  variation of deterministic complexity  so first of all when we have a  all of our all of the machines in this  part of the course and the languages  everything is going to be decidable and  all the machines are going to be  deciders so what do we mean when we have  a non-deterministic machine which a  decider is a decider  and that just simply means that  all of the branches  it's not just the machine holds on every  input but all of the branches hold on  every input  you know so the non-deterministic  machine is non-deterministic it has lots  of possible branches they all have to  halt  all of them on every input that's what  makes a non-deterministic machine a  decider and you can convert a  non-deterministic decider into a  deterministic decider  but the question is how much time would  that introduce how much extra time is  that going to cost and the only way that  people know at the present time  for  that conversion would be  to do an exponential increase um  basically to try all possible branches  and that's of course very slow  so um  let's first  let's understand what we mean by the  time used by a non-deterministic machine  and what we mean by the time used is  we're looking at the each individual  branch individually  separately  so a non-deterministic machine will say  runs in a certain amount of time  if all of the branches halt within that  amount of time  so you you know what we do  we we do not mean  that the total amount of usage the total  amount of effort by adding up all the  branches is at most t of n  it's just that each branch individually  uses at most the event that's just going  to be our definition and it's going to  turn out to be uh  the right way to look at this to get  something useful  um  so  um  if we have um  so now we're going to define the  analogous uh complexity class associated  to uh non-deterministic computation  which we'll call non-deterministic time  so non-deterministic time t of n  is the set of all languages that you can  do with a non-deterministic machine that  runs an order t of n time  um  just think back to the definition we had  for deterministic uh complexity the time  class or sometimes people call it d time  to emphasize the difference but let's  just say we're calling it in this course  time versus end time so time t of n is  all of the languages that you can do  with the one tape turing machine  that's deterministic um but this here is  a non-deterministic turing machine for  non-deterministic time um  so the picture that uh uh that  is good to have in your head here  um  would be  uh if you think of non-determinism in  terms of a computation tree thinking of  all the different branches of the  non-determinism  all of those branches have to halt  and they have to halt within the time  bound  so imagine here this is t of n time all  of the branches have to hold within t of  n steps for this  a non-deterministic turning machine to  be running in t of n time and to be  doing a language in the end time t of n  class  um  and by analogy with what we did before  the class np  is  the  um  uh collection of all languages that you  can do  non-deterministically in polynomial time  um  so it's the union over all the end time  classes  uh  where we the bound is polynomial  um  okay so a lot of this should look very  familiar but we've just added a bunch of  non-deterministics  and a bunch of n's  in in place but the definitions are very  similar  um  and one of the motivations we had for  looking at p the class p was that it did  not depend  um on the choice of model as long as the  model was deterministic and reasonable  and this is also the class np is also  going to not depend on the choice of  model as long as it's a reasonable  non-deterministic  model  so  it's again a very natural class to look  at from a mathematical standpoint  and it also captures something  uh interesting  kind of different from a practical  standpoint which we're going to talk  about over the next couple of live  slides which is that it captures the  problems where you can easily verify  when you're a member of the language  okay so we'll talk about that but  you know if you take for example the  hamiltonian path problem  when you find a member of the language  so that is a  graph that does have a hamiltonian path  from s to t  you can easily verify that's true by  simply exhibiting the path  not all problems can be solved can be  verified in that way  but the problems that are in np have  that special feature  that you when you have a member of the  language there's a way to verify that  you're a member so we're going to talk  about that um because that's really the  key  to understanding np  this notion of verification  okay so  let me go there was a good question here  let me just see if i want to answer that  um  um  yeah  mean  this is a little bit of a long longer  question that i i i want to fully  respond to but  you mean the the  well  let's turn to my next slide which maybe  sort of bring that out anyway um  actually it's a couple of slides from  now but i'll get to that point um  so let's look at hamiltonian the hand  path problem and what i'm what i'm going  to show is the hamiltonian path problem  is in np and i'm going to walk you  through this one kind of slowly  um so the hamiltonian path problem  remember we don't know if it's in p  but it is  in np  so it's in one of these you can solve  hamiltonian path in polynomial time if  you're a non-deterministic machine  um why is that well it's because of the  non-determinism  because of the parallelism of  non-determinism um  which allows you to kind of check all of  the paths  on different branches  so let me first describe how the  algorithm how i would just how i would  write down the algorithm and then we'll  kind of try to unpack that and  understand how that actually looks in  terms of  the turing machine  or the turing machine's computation  so first of all  so taking the hamiltonian path problem  you know you're given an input now which  is a graph  and the node's s and t where i'm trying  to figure out is the hamiltonian path  again which visits all the nodes  which takes you from s to t  and  we're trying to make now a  non-deterministic machine which is going  to  accept  all such inputs which have a path  so the way this non-deterministic  machine is going to work  is it's basically going to use its  non-determinism  to try all possible paths  on the different branches  and the way i'll specify that  is to say non-deterministically we're  going to write down  a candidate path  which is just going to be a sequence of  nodes sequence of m nodes where we'll  say that's the total number of nodes of  the graph remember a hamiltonian path  because it visits every node  is going to be a path with exactly m  nodes in it  so i'm going to write down a sequence of  nodes as a candidate path  and i'm not deterministically going to  choose every possible sequence  in this way  um  if you like to think of the guessing  metaphor for non-determine  non-determinism you can think of the  non-deterministic machine as guessing  the right path  which is going to be the hamiltonian  path from s to t but i think from for  this discussion it might be more helpful  to think about all of the different  branches of the non-determinism  um  because that's perhaps more useful when  we're thinking about it in terms of the  time you know i think you'll get used to  thinking about it you should be used to  thinking about it many in many of the  different ways but maybe the computation  tree of all branches might be the more  helpful one here  so now as after we write down a sequence  a candidate path sequence of nodes  now i have to check  that this really is a path  and the way i'm going to do that is to  say well now if i have just a sequence  of nodes written down what does it mean  for it to be a hamiltonian path from s  to t  well it better start with s  and end with t  first of all  and  we have to make sure  that every step of the way is actually  an edge  so each pair v i to v i plus 1  has to be an edge in the graph  otherwise that sequence of nodes is not  going to be a legitimate hamiltonian  path from s of t  and you could it has to be a simple pass  you can't be repeating notes  these four conditions together will  guarantee  that we have a hamiltonian path and once  we have written down a candidate  sequence we can just check that that  sequence actually works  um there's no at this  second stage of the algorithm  non-determinism is necessary this is  going to be a deterministic phase  but the  stage one of the algorithm is going to  be a non-deterministic phase where it's  writing down all possible paths  now i'm going to try to unpack that for  you so you can actually visualize how  the machine is doing this  um  and then of course you know so you're  gonna on each branch of the  non-determinism you're going to  check to see whether the conditions have  been satisfied and on that branch  if the conditions were not satisfied  that branch is going to reject of course  one of the other branches might yet  accept so  um  that's how non-determinism works  okay so i'd like to visualize this  um  uh  um  i'd like to visualize this  as a  uh  the tree  of  uh of the different branches of the  computation  of m on its input so here is the here is  our non-deterministic turing machine um  uh which this one um  and  you provided with the input uh  you know g s and t  and how does the machine actually  working  so when i say non-deterministically  write down a sequence of m nodes  you know  you know  this is getting into a little bit more  detail detail than i would normally  think about it uh because we try to tend  to think about things at a higher level  but just for just to get us started i  think it's good to think about this  with a bit more detail  so let's think of the nodes the m nodes  as being numbered having labels  numbered one through m  and i'm going to think about them being  labeled by their binary sequences  you know we're going to write down those  nodes that's how the you know the  machine is going to have to operate on  those numbers for the nodes we'll think  about them as being written in binary  and now as the machine is going to be  writing down let's say the node v1  so it's not deterministically picking  the first node of the sequence what does  that actually mean in terms of the um  the  step-by-step processing of the turing  machine m  well it's going to be  um  guessing via a sequence of  non-deterministic moves  the bits  that represent  the number of the node v for v1  you know for example v1 might be the  node number five  in the graph  um  of course you know non-deterministically  the machine is on different branches  picking all different possible can  choices for v1  those are going to be the different  branches here  but you know  one of the branches might be  and what i'm what i'm really  representing here these are  uh i probably could have written this  down on the slide here in in in tiny  font but these are like the zero one  choices  that's why it's sort of a binary tree  here for the  writing down the bits  of the uh of a v1 so here maybe this  could be one zero one  representing  uh the number five  which might be the very first node  that i'm writing down in my sequence  some other branch is going to write down  node number six some other branch is  going to write down node number two  because non-deterministically we're  making all possible choices for v1  that's what i'm trying to show in this  little  part of the computation  of m on this input  so then  after it's uh finished writing down the  description of the node uh  for v1 um its choice for v1 it goes down  to make choose what v2 is again  non-deterministically so there's going  to be more branches  you know  um for each  possible choice of v2  and so on node after node um  then it's going to finally get to the  last node vm is going to write down lots  of choices for vm  and at this point here we have completed  uh  the first stage of the algorithm now  there's some huge tree  of all of the possible choices for the  v's that have shown up at this point  okay  and  uh now we're going to move into the  second phase  so following this there's going to be  um  here  uh a bunch of uh deterministic  steps of the machine so no more no no  more branching no more branching is  needed uh because here  we've written down at this at this point  we've we've reached a point in each of  these um  at each  each of those locations where we've  chosen one of the candidates  one of the possible branches or one of  the possible paths through the machine  um one of the possible paths look  through the graph i'm sorry so we um you  know here we're guessing  uh potential paths in the graph  and now we're going to check that we  actually have picked a path that's a  hamiltonian path from s to p  as to t  okay so each each one of these branches  is now going to end up accepting or  rejecting and the whole overall  computation is going to accept if at  least one of them ended up accepting  which means you actually found a  hamiltonian path  okay so i don't know if that's helpful  to you or not but um  that is uh so we can just you know if  there's any questions on this let's see  um  question on you know is there something  um  uh  uh  you know  trying to draw a connection here between  this and and computation histories um  i mean  there is  a pattern here that does come up often  where you you you want to check some  things you know starts right ends right  and that all of the intermediates are  right so there is i think there is a  um  there is some deeper connection here  probably too hard to explain but  um  that does have something to do with this  hamiltonian path problem  um why are we using binary  representation well we're going to talk  about  um you know we  the algorithm would have worked equally  well if we used um  base three or base five or base you know  20 um  as a way of writing down our  labels for the nodes um  but in a sense it doesn't matter um  um the alphabet has to be finite so  that's that's true i mean that's why  you it's not just in a single step of  the turing machine  that you would pick  the  the node uh the true the choice for v1  you really have to go through a sequence  of steps because  each of the  branches of the machine only has a fixed  number of choices so you can't in a  single step of the turing machine  pick all the different possibilities for  v1 it has to go through a sequence  um  okay  um  now let me do a second example the the  problem for of composites  so the the  the language of all composites are all  of the non-primes  written as binary numbers again so we'll  talk about the base and the  representation in a second but just  imagine you know he you know these are  all of the numbers that are not prime  uh and that language is easily seen to  be a member of np  uh here is again the algorithm for that  um  given x  um we want to accept x if it's not a  prime number so it has some non-trivial  factor  so first the way the non-deterministic  machine is going to work is it's going  to guess that factor so it's not  deterministically it's going to try  every possible factor  what we're wrong y is going to be a  number between 1 and x but not including  one we you know that we have to be an  interesting factor so not including 1 in  the number itself so something strictly  in between  and we're going to then after we've  non-deterministically chosen y then  we're going to test to see if y  is really a factor  we'll so we'll see if it y divides  evenly into x  with a remainder of zero  you know if that branch successfully  picked the right y it's going to accept  and some other branch might have picked  the wrong y will not and if  x is really a composite number some  branch will find the factor  um  now the base doesn't matter could have  used base 10  because you can convert from base to  another um so this is really in terms of  our representation of the of the number  but i do want to make one point here  that changing  we don't want to write the number in  unary  um you know just as  writing the number k  as a sequence of k ones um that's not  really a base um that's just an  exponential representation for the  number and that changes the game because  if you make the input exponentially  larger  um  then  uh  it's going to change whether the  algorithm  relative to that exponentially larger  input is polynomial or not um so an  algorithm that might have been  exponential  originally  when the numbers written binary might  become polynomial if the number's  written in unary um  and i do want to mention as a side note  that the composites  language  uh or primes for that matter doesn't you  know both are in p  um  but we won't cover that  so  uh  whereas the hamiltonian path problem is  not known whether it's in p  the primes and composites problem are uh  np um so that was known there was  actually a very big result in the field  uh solved um  uh by folks in at one of the uh indian  institutes of technology uh back about  uh  you know almost 20 years ago now  um  okay um  [Music]  so let's turn here to trying to get an  intuitive feeling for pnnp and we'll  talk we'll return now to this notion of  np corresponding to easy verifiability  so  np are the languages where you can  easily verify membership quickly and  i'll try to explain what that means in  contrast p are the languages where you  can test membership quickly uh by  quickly i mean i'm using  polynomial time  um  that's going to be basically you know  for us that's what quickly means in this  course  so  in the case of the hamiltonian path  problem  the way you verify the membership  is you give the path  in the case of the composites the way  you verify the membership is you give  the factor  um  in those two cases  and in general um  when we have a problem that's in np  we think of this  verification  as having a giving we give it a special  name called a certificate or sometimes a  short certificate to emphasize the  polynomiality of the certificate  it's like a way of proving that you're a  member of the language  um  in the case of composites the proof is  the factor  in the case of ham path the proof is the  is the path the hamiltonian path um  contrast that for example if you had a  prime number  um  you know  proving a number is composite is easy  because you just exhibit the factor  how would you prove that a number is  prime  um what's what's the short certificate  of  um  proving that some number is it has no  factor that's not so obvious  in fact there are ways of doing it which  i'm not going to get into in the case of  prime  testing of numbers prime but and and now  it's even so known to be in p so that's  even better  but  there's no obvious way of proving that a  number is prime with a short certificate  um  and  so this concept of having  being able to verify when you're a  member of the language that's key to  understanding np  that's the intuition you need to develop  and hopefully take away from today's  lecture or at least you know by  thinking about it and reading the book  and so on  um  so if you compare these two classes p  and np  uh p first of all is  going to be a subset of np both in terms  of the way we defined it because  deterministic machines are a special  case of non-deterministic machines  but also if you want to think about  testing membership if you can test  membership easily then you can certainly  verify it in terms of the certificate  you don't even need the certificate is  irrelevant at that point because  whatever the certificate is you can  still  test yourself  whether the input is in the is in the  language or not um  the big question as i mentioned is  whether these two classes are the same  so does  uh being able to verify membership  quickly say with one of these  certificates allow you to dispense with  the certificate not even need a  certificate and just test it for  yourself whether you're in the language  um  and do that you know in polynomial time  uh that  that's the question  for a problem like hamiltonian path  uh do you need to search for the answer  um if you're doing it deterministically  or can you somehow uh not me you know  avoid that and just come up with the  answer directly uh with it with a with a  polynomial time solution  nobody knows the answer to that uh  and goes back at this point quite a long  time it's almost 60 years now um  uh  that  that problem has been around 60 years  oh that would be 50 years no 50 years  almost 50 years  um  so um  the uh most people believe that p is  different from np in other words that  there are problems in p that are in np  would turn out in p  um  the candidate would be the hamiltonian  path problem uh  but it seems to be very hard to prove  that um  and part of the reason is i mean how do  you prove that a problem like  hamiltonian path does not have a  polynomial time algorithm  um  it's very tricky to do that because the  class of polynomial time algorithms is a  very rich class polynomial time  algorithms are very powerful  and to try to prove there's no clever  way of solving the hamiltonian path  problems just seems to be beyond our  present-day mathematics  i believe some days somebody's going to  solve it but all right so far  no one has succeeded um  so what i thought we would do is i think  i have a check in here uh yes  and then we'll stop for a break  so let's look at the  the complementary problem hand path  complement  um  so that's you're in the language now if  you don't have a path  um so is that complementary problem in  np  okay so  for that to be the case  we would need to have short certificates  of  when a graph does not have  um a hamiltonian path  so  i leave it to you so there are three  choices  um  okay  i'm going to stop here so make sure you  get your participation credit here  um  end the polling now  interesting still the majority is wrong  well i know wrong we don't know uh  you know um  uh i i think the only fair answer to  this question is is c  um because we don't know  uh  whether or not we can give short  certificates for a graph not to have a  hamiltonian path  if if p equaled np  then you can test in polynomial time  whether a graph has a hamiltonian path  and then the computation itself would be  a certificate whether it has a path or  whether it doesn't have a path because  it would be something that you can check  easily  um  so  since we don't know uh  for sure that p is different from np um  you know p could be equal to np then  it's possible that  um  we can we could give a short certificate  namely the  computation of the polynomial algorithm  so the only really um  reasonable answer to this question is  that we don't know  um  so uh just uh ponder that i think the  the the thing that um you  those of you who answered yes  however  um need to go back  and and i ain't put this here explicitly  because i know this is a  th  this is a confusion for  well i can see for quite a few of you um  um  when we have non-deterministic  computation and you have a  non-deterministic machine you can't sim  simply  invert the answer and get back a  non-deterministic machine  non-determinism does not work that way  uh if you remember  you know the non-deter the complement of  a push-down automaton  um is not a push-down automaton  if you have a non-deterministic machine  and you invert all of the responses on  each of the branches  um it's not going to be  recognizing or deciding the  complementary language  so um  because  well i i think that this is something  you you if you answered yes  you need to  go back and make sure you understand why  yes  um is is not a is not a reasonable  answer to this question uh because  that's not how non-determinism works so  you have a  um  a not complete understanding of  non-determinism and that's going to be  really important for us going forward so  i i really urge you to figure out and  understand why yes is not a is not a  good answer to this uh to this check-in  okay so i think we will um we can talk  about that more over the over the break  um  and so uh we'll we'll return here in  um  in five minutes  somebody's asking about in  you know infinite uh  equal infinite sequences be generated by  the machine um  i you know when we're talking about  um  you know especially in the complexity  section of the course  all of the computations are going to be  bounded in time so we're not going to be  thinking about sort of infinite runs of  the machine that's not going to be  relevant for us so um let's not think  about that how does the turing machine  perform division  um  how does a turning machine perform  division well uh  how do you perform division  uh  the  long division is a is an operation that  can run in  you know the the long division procedure  that you you learn in a grade school can  you can implement that on a turing  machine um  so yes a turing machine can definitely  perform  do long division or division in one  integer by another in in polynomial time  okay another question can we generally  say  try dividing y by x or do we have to  enumerate a string of length y and cross  off every no i think that's the same  question  you know  i mean how would you know if you have  numbers written in binary how would you  do the division you're not going to uh  use long division  um  you know anything such as the the the  thing that's proposed here uh  by by the the questioner is going to be  an exponential algorithm so don't do it  that way  um  uh  why does primes in p not um composites  in p not implied primes in p it does  imply if  if composites are in p then primes is in  p as well because you can just you know  when you have a deterministic machine  you can flip the answer when you have a  non-deterministic machine  you may not be able to flip the answer  so  the deterministic machine just having a  single branch  um you can make another deterministic  machine that runs in the same amount of  time that does the complementary  language  um because  um for deterministic machines um just  like for deciders  uh  in the in the computability section you  can just invert the answer  uh there is an analogy here between  p  and decidability and np and  recognizability it's not an  airtight analogy here but there is some  relationship there um  what are the input like somebody's  asking me the implications of p equal to  np lots of implications um  too long to enumerate now but for  example  uh you would be able to break basically  all  cryptosystems um that i'm aware of if p  equaled np so we would have a lot of  consequences  um  so he's asking so composites  primality and compositeness testing is  solvable in polynomial time but  factoring interestingly enough is not  known to be solvable in polynomial time  uh so that i mean  so um  we may talk about this a little bit  toward the end of the term if we have  time  but  the algorithms for testing whether a  number is prime or composite in  polynomial time do not operate by  looking for factors  they operate in an entirely different  way  basically by showing that a number is  prime or composite by looking at certain  properties of that number but without  testing whether it has uh testing  but without finding a factor  um  uh  okay  another question here about asking um  the  uh  when we talk about encodings do we have  to say how we encode numbers  values no we don't have to we usually  don't get have to get into  spelling out encodings  as long as they're reasonable encodings  so you don't have to  usually  we're going to be talking about things  at a higher enough level that the  specific encodings are not going to  matter  um  okay let's let's return to our  uh  the rest of our lecture  when we talk about  say this p versus np problem  and  how do you show  that  uh  you know a problem  might not be solvable in p like the  hamiltonian path problem  um  you know many people  you know  who are  not uh practitioners in the field um you  know are know about the p versus no know  about the p versus np problems i i've  over the years i've got many many  emails and and and physical letters from  from people um  about that uh since people you know  since uh since i've spent some time  thinking i'm known as having spent some  time thinking about it  and um people claim to solve the problem  uh solve p is np  p the p versus np problem by basically  saying you know  problems like hamiltonian path  um  uh  you know or these or other similar  problems  basically there's clearly no way to  solve them without searching uh through  a lot of possibilities and then they go  through a big long analysis showing that  there are exponentially many uh  possibilities um  the  um  the  uh  you know  and a lot of the proofs that claim to  solve p versus np they all look like  that you only you only have to look some  somewhere in that paper there's going to  be a statement  uh along the lines  to solve this problem clearly you have  to do it this way  um  and  that's the flaw in the reasoning because  just like for the factoring problem  just like for the  uh compositeness testing problem you  don't necessarily have to solve it use  by by searching for factors there might  be some other way to do it you might be  able to solve a hamiltonian path  problem without searching for  hamiltonian paths there might be some  other process that you can use which  would uh give you the answer  um so i the class of polynomial time  algorithms is very rich can do many many  things and i and i i wanted to present  to you um  one of the most important polynomial  time algorithms in a sense it's kind of  the  you can make a certain argument that  this is sort of the the  the the in a sense the most fundamental  polynomial time algorithm  some people might argue with me on that  but  um and that's a process called dynamic  programming  which i'm sure some of you have seen  already in your algorithms classes  and some of you may not have but um  since you have a homework problem on it  um i i want to spend a little time  describing it to you  and that's useful for solving this acfg  problem um  which you may remember from the first  half of the course  involving testing  uh if a grammar generates a string  okay so remember this acfg problem  you're given a grammar  context free grammar  and a string and i want to know is it in  the language of the grammar  okay so that's going to turn out to be  solvable in polynomial time  but only with a kind of a clever  algorithm  remember it's decidable  we decided it by converting by making  sure that you are converting the grammar  into chance chomsky normal form then all  the derivations have a certain length  you just try all the possible  derivations of that length and you set  except if any of those derivations  generate w  okay  uh you may remember that um from the  first half of the course um  that immediately gives  an np type algorithm  for this language  because basically  you  non-deterministically  instead of trying the most sequentially  all of these derivations you try them in  parallel non-deterministically so  non-deterministically you pick some  derivation  of that length  and you accept it if it generates the  input  this fits this is  classically fits our model  of  of uh  of np  you can think of it as guessing the  derivation and checking that works or in  parallel writing down all possible  derivations um  but this acfg problem is  a  classically  uh an np problem  uh probably an in in np um  uh and if you just imagine  that  uh so and and then what's going to be  this the certificate if you found an  input that's in the language um that's  generated by the grammar the certificate  is the derivation  so if you look at it that way you might  think well that's the best you can do  this is going to be an np pro problem in  np and there's not going to be a way of  avoiding searching for the derivation  but that's not true there is a way of  avoiding searching for the derivation  you can kind of build up the derivation  um using dynamic program and so that's  what i wanted to kind of just describe  for you um how that works also partly  because it's a homework problem and i  think dynamic programming isn't is a  very important algorithm  so um  before we  um  uh  describe what dynamic programming is  which is very simple by the way um let's  try to work up to it by making an  attempt to solve this problem just using  ordinary recursion  um  so how would we solve the acfg problem  so you're given a grammar  you're given an input  let's assume the grammar's in conjunct  in chomsky normal form  so  that's going to be useful so it's a  chomsky normal form grammar and we want  to see how to  test if you can generate w  um  and it's going to be recursive algorithm  recursive algorithm is going to  actually sound something slightly more  general  i'm going to give you the grammar i'm  going to give you the string and i'm  also going to allow you to start at some  other variable variable besides the  start variable so i'm going to give you  a  some variable r and i know i want to  know can i generate w starting at r  okay so that's my slightly more general  problem which is going to be useful in  the recursion  okay so the input now to this this  algorithm is  the grammar the input and the starting  variable and now how is the algorithm  going to work it's going to try to test  can i get to you know is there some  derivation pictured here as the parse  tree  for w starting at r  that's what the algorithm is trying to  answer  can i get  w from r  the way it's going to do that  is  it's going to try to divide w  into  the two strings  in all possible ways  which sounds like it might be  exponential but it isn't  there's only a polynomial number of ways  to divide the string into two  substrings um just order n just  depending where you make that cut  so there's you know some  uh so that's not too bad there's a  polynomial there's only n ways of making  that division and also i'm going to try  every possible rule that comes from r  um that generates two  uh  um  that generates two variables so these  are  what's allowed in chomsky normal form r  goes to st  okay so i'm gonna for each possible way  of cutting w into x and x y and for each  possible rule r goes to st i'm gonna see  recursively can i get uh from s to x and  from t to y  so i'm going to use my recursion now now  that i have smaller  uh  um strings  instead of w  um i can apply my recursion and try to  answer it that way  and this algorithm will work  so if they if i found a way to cut w  into xy and i found a rule r goes to st  such that s generates x and t generates  y then i'm good  i know i can generate uh  w from r  okay and if there's no way of cutting w  up um to satisfy that or uh  you know uh if i can't find any way to  do  to divide w into x y and the rule r goes  to x t which makes this work  if all possible ways fail then you can't  get from r to w  okay  um  and then you can decide the original  acfg problem now by starting from the  start variable instead of just some any  old r you plug in the start variable far  okay so if this algorithm works  and  it  can be used to solve ac of g  but the question is is a polynomial  and it's not  because  every time you're doing the recursion  you're essentially adding another factor  of n  because here as we pointed out this is a  factor of n but that's happening every  time you're doing a recursive level  and you can imagine you know i'm just  doing a very crude analysis here  depending upon how you divide divide w  up but roughly speaking it's going to  get divided in half each time so there's  going to be log n levels  and so that means you're going to be  multiplying n by itself log n times or  get give you an n to the log n algorithm  that's not polynomial because  polynomials enter the constant  for some fixed constant n to the log n  is not going to be polynomial so this is  not a polynomial algorithm  so instead you're going to have to do  something just a little bit more clever  it's going to be the same basic idea  but just relying on one little  observation  and the little observation is  that  when  this  non-polynomial implementation that i  just described is actually pretty pretty  dumb  because it's doing a lot of  recomputation of things that it's  already solved why is that  because  if you look at the number of possible  different sub-problems here once i fix  once i give you g and and i give you w  um  how many  different sub-problems uh  g s and t are there  um  well the number of sub the number of uh  of strings here  all of those strings are going to be  substrings of w there's only  roughly n squared substrings of w i'm  always going to be generating  in a sub problem here some substring of  w from some starting variable um in the  grammar  so because there aren't that many  different substrings and not that many  different starting variables the number  the total number of possible problems  that this algorithm is going to be  called on to solve is going to be in  total a polynomial number of different  sub problems there aren't very many of  them it's only something like border n  squared  so if the algorithm is running for  exponentially long  long time it's solving the same sub  problem over and over again  that's dumb  why don't you just remember when you  solve the sub problem so you don't solve  it again  doing that  enhanced recursion where you remember  the problems you've already solved it's  called dynamic programming i don't know  why it has such a  a confusing name like that  actually it's called by several  different things but anyway  that's known as dynamic programming it's  a recursion plus the memory um  and here is just repeating myself um  there are  not very many different substrings um  so every time you're going to be in your  recursion somewhere you're going to be  working with a substring so there's not  that many different sub problems that  you can possibly solve and just remember  when you solve the sub problem  and not solve it again so  let me just show you that algorithm  again here with them with a little  modification  so first of all  let me give you  this is the same algorithm from the  previous slide i'm just repeating here  without all the other stuff so we can  just look at it directly right dividing  it  into x and y for each possible rule  and just and then recurse  now  i'm going to  add a little step 0 beforehand  um which says  if i have g w and r  let me just check first with i've  already solved that one before  so i have to keep track of the ones i've  already solved  that's not too bad because there's only  n squared order n squared possible  different ones that i could be called on  to solve  so i'm just going to have a little table  where i'm going to remember those  and then every time i get a new one i  get i get one to solve i'll check is it  on that table and what's the answer  so i won't have to rerun those  so now the total i'm going to be  basically pruning that tree  um so that it has only a polynomial  number of leaves and so the total size  of that tree now is going to be  polynomial um  uh and so that's going to yield a  polynomial running time this by the way  i only learned this myself i'm sure you  guys all know this who have taken this  as in the algorithms of course has a  special name called  memoization not memorization sort of  this came from the same root i think but  memoization which is somehow remembering  the results of a computation so you  don't have to repeat it  um  so the total number of calls is going to  be most n squared to this algorithm uh  because you're never going to be uh  redoing a work that you've done already  so and you know and when you actually  have to go through it  the the running time um  uh  um  you know so  it's it's the the total amount of time  that you're going to need is going to be  polynomial altogether um  so  let's here i don't remember what my  check-in is on this  um oh yeah so i mean this is somehow  related and feel free to ask questions  too  while you're thinking about uh this um  this check-in but the check-in says here  we've solved the acdfg problem in  polynomial time  does that tell us that every  context-free language itself  is also solvable in polynomial time  so just mull that over  and please give me an answer to it  i hope you do better on this check and  then you did on the last one um  but anyway why don't you go ahead and  think about that  and i can take some questions in the  meantime  someone is asking here  um actually i'm getting several  questions on this  why isn't it order n cubed or something  greater than order n squared because of  the variables  the variables are not don't don't depend  on n  you know when you're given  um oh well  actually that's not true  no  you you're you are right  um  uh because the grammar is part of the  input  so that you might have as many as n  different variables in the given grammar  so you you are right there is  potentially  um you know the grammar might be half  the size of the input  and the input to the grammar w might be  half the size of the input so i didn't  think about that but you're correct  there are uh potentially  uh  different numbers of variables in  different grammars so you have to add an  extra factor which would be at most the  size of the input because that's as many  variables as you could possibly have so  it really should be i think um order n  cubed um  to take that into account as well  plus all of the work that needs to  happen in terms of dividing things up  you know on a one tape turing machine  there's going to be some extra work uh  just to carry out some of these  individual steps um because with a  single tape things are sometimes a  little awkward i think the total running  time is going to end up being something  like enter the fourth or into the fifth  on a one tape turing machine  but  but that's a good point  so somebody's saying how can we be  storing n squared strings in finite time  i'm not saying what why finite time we  have polynomial time every every state  stage of this algorithm is allowed to  run for polynomially many steps as long  as it's clearly polynomial we can just  write that down as a single stage um  part two should say  oh  there's a typo here so use d  thank you that's that is a typo um  uh  i'm afraid if i change it on my original  slide here things will break in some  horrible way  let's just see that i completely wrecked  my slide  no that's good  yeah thank you good point  um  uh  oops  okay how's how's our check-in doing  okay i think you're just about all done  um oh that's still spent a lot of time  on this  and polling um  as you may remember from the first half  of the course  so the answer is is a indeed um  remember that we showed acfg is in  is decidable and therefore each context  free language itself is decidable just  because you can then plug you can plug  in the specific grammar into the acfg  problem  the very same reasoning works here  um you can for if if you have a  context-free  language it has a grammar you can plug  that grammar into the acfg problem  and then that's polynomial time you'll  get you're going to get a polynomial  time algorithm for that uh for that  language um so good to review that um  it's it's the same thing from same  argument we used before  um  okay  also i i  i want to spend a lot of time on this  there are there's another way of looking  at dynamic programming we'll talk about  this again um maybe in a lecture  probably next lecture just because i  know you have a homework problem on it  and um if if you've seen dynamic  programming before is going to be easy  if you haven't seen it before it's going  to be i think probably a little  challenging  but  another way of looking at dynamic  programming is the so-called bottom-up  version of dynamic programming and what  that would mean is you solve all of the  sub-problems first before you solve all  the smaller sub-problems before you  solve the larger sub-problems um let me  just  you know i  i it's here on the slide i'm not sure i  want to talk it through but basically  um  you solve  this the sub problems here  where um  the strings are start with strings of  length one  and then from that you build up to sub  problems where the substrings are of  length two  and then three and so on and each of  those only relies on the smaller  previously solved sub problems so you  can  kind of in a systematic way  solve all the larger and larger  subproblems uh you know for larger and  larger substrings  and  that gives a kind of a different  perspective on dynamic programming and  kind of for different problems sometimes  it's better to think about either the  sort of top-down recursion-based  process or the sort of the bottom-up uh  process that i'm describing here um  they're really completely equivalent um  but uh  you know  the version that's described for this  particular algorithm which appears in  the textbook is actually the bottom-up  algorithm um so you shouldn't be  confused if you see something there  which looks somewhat different  and that's often you see you basically  solve all possible sub problems  filling up basically filling out a table  um  let me not say it anymore  say anything more about that here since  we're running a little short on time um  but um  there are really two perspectives on  dynamic programming  okay so moving on from there um  let's let's shift gears  uh leave context free languages and uh  dynamic programming behind  um and start moving toward understanding  um  p and np  and for that we will  um  introduce a new problem called the  satisfiability problem and that's one  we're going to spend a lot of time on  so  important to  if you tuned out a little bit during the  dynamic programming  discussion  time to get back on board  so the satisfiability problem is going  to be a computational problem um  uh that  we're going to be working on and it has  to do with boolean formula  so these are like expressions like  arithmetical formula like  x plus y  times z  but instead of using um  numerical  variables we're going to be using  boolean variables that take on boolean  values true false or sometimes  represented by one and zero  and the operators that we're going to be  using are going to be the and or and  negation operations  and or not  okay um  i'm going to say such a very such a  formula such a boolean formula we're  going to call it satisfiable we'll do an  example in a second  if that formula value evaluates to true  um if you assign  make some assignment the values to its  variables  so just like arithmetic their formula  will have some value if you plug in  values for the uh  boolean formula is going to have some  value if you plug in boolean values for  its variables and i want to know is  there some way to plug in values which  makes the whole thing evaluate the true  the the formula itself is going to  evaluate to some either true or false  and i want it to evaluate to true  um  so  uh here is our example that let's take  the formula fee  which is x or y  and  x complement  you know or not x or not y  so the notation x  with a bar over it x  x complement is just x bar  not x  is just  the way if you're familiar with the  other notation  uh for the the not operation  we just inverts ones and zeros um  we we would write it we're going to  write it with a bar instead of the  negation symbol so i i'm assuming that  you've all seen boolean algebra boolean  arithmetic before you know where you  know the and operation is only true  if both inputs are true so these are  going to be binary and operations in  binary or operations  um or is going to be true if either  input is true and not as true if it's  single input is false  so it just flips the answer  okay so here i want to know for this  formula for this boolean formula here is  it satisfiable  is there some way to assign values to  the variables  to make this formula evaluate to true  so for example let's just try things  let's make x and y both true  so x is true and y is true  so x or y well that's good that's true  but now we have to do an and so we need  both sides to be true  so now now we have x complement well we  said we said x is true so x complement  is false y complement is false false or  false is false so now we have a true and  false that's going to be false  we did not find a satisfying assignment  but maybe there's another one and in  fact there is if you make x true and y  false  then both of these parts  will be evaluate to true and then you'll  have true and true so we found a  satisfying assignment to this formula it  is in fact  uh satisfiable so if you say x is 1 and  y 0 yes this is satisfiable  now the problem of testing for a boolean  formula if it is satisfiable is going to  be the sat language  it's a set it's a collection of  satisfiable boolean formula  and testing whether you're in sat or not  is going to be a  an important computational problem  and  there was an amazing  theorem  which really got this whole subject  going  uh discovered independently  by uh  steve cook  in north america and lane 11 in the in  the former soviet union  almost exactly at the same time  which made a connection between this  one problem and all of the problems in  np  so by solving this one  satisfiability problem  in polynomial time  you you there  it give it it allows you to solve all of  the problems in np in polynomial time  so if you could solve this problem sat  in in in p then hamiltonian path is also  solvable in p it's kind of  you know  step back and think about that it's kind  of amazing um  [Music]  and the method that we're going to  introduce is called polynomial time  reducibility  and let's do a quick checking on this  this should be an easy one um  i want to just think about is sat the  sat problem that we just described here  is that in np  three seconds  you all there  okay  ending polling  um  yeah so the a  hopefully you're getting the intuition  for np uh that  these are the problems to be an np means  that when you're a member of the  language  there's a short proof or a short  certificate  of membership in this case the short  certificate that the formula is  satisfiable is the assignment which  makes it true also called the satisfying  assignment  so yes this is an np language  language that's in np  um  uh so there are a lot of things that we  don't know in this subject but  this isn't one of them we do know that  sat is an np  so let's talk about our method um  for showing this uh remarkable fact that  if you can solve pollen if you can solve  if you can solve sat in polynomial time  then all of np is solvable in polynomial  time and it uses this notion of  polynomial time reducibility which is  just like mapping reducibility that i  hope you've all grown to know and love  in the first half of the course  but now the reduction has to operate in  polynomial time  so it's the same picture that we had  before  mapping a to b  transforming a questions to b questions  but now the transformation has to  operate quickly  and we get that  if a is polynomial time reducible to b  and b is polynomial time  then a is also polynomial time  same pattern as before  if a is reducible to b and b is easy  then a is easy um  and here is  kind of the essence of the idea  or at least the outline in a sense the  idea of of this cook and levin theorem  that if satisfiability is in p then  everything in np can be done in p  which is because we will show  that all problems in np are polynomial  time reducible to set  that's the amazing fact  so therefore if you can  bring sat down into p  by using this reduction it brings  everything else along with it because  everything is reducible to the set so we  just have to show how to do that  and there is an analogy that we had in  the first half of the course in one of  our homework problems if you may  remember  we showed that atm  has the very special property  that all touring recognizable languages  are mapping reducible to it  i think that was problem  2  on  2a  either in this problem set 3 or problem  set 2.  i think problem said three  um  that every  every entering recognizable language is  polynomial time reducible to atm  and so  very similar picture and there's the  a lot of analogies here that you can  draw between between  uh the computability section and the  complexity section  anyway  with that i know we're just about out of  time so let's quick review um  of what we've done um here  and um i will stick around for questions  for a while  is there a  okay that's a good question is there  kind of a you know a um  sort of a regular reduction analogy  version to mapping reducibility you know  we had that we had the general reduction  uh for the computability section  and we had the mapping reduction for the  computability section here  we're only going to be focusing  now on the mapping  reduction so polynomial time reduction  is  by assumption going to be a mapping  reduction yes there is a  general  polynomial time reduction notion as well  if you  you know this is not required but if you  are curious about the general reduction  and how to precisely formulate that it  actually appears in  uh chapter six under turing reducibility  um that's the general notion of  reducibility spelled out in a formal way  and there's polynomial time touring  reducibility as well we're not going to  talk about it this in this course  um  other questions  does np correspond exactly  to verification in polynomial time if  well we have to  for me to answer that as a precise  question we have to have a precise  definition of verification but with the  right  definition the answer is yes  um  so you can define a verifier  as a polynomial time algorithm  um that gives a certificate given that  takes a certificate and an input to the  language and will um  you know  accept if they're if that certificate is  a valid certificate for that input um  this is actually discussed in chapter i  think nine  um  of the text  uh but um  uh you  um  no i'm forgetting already what's where  in the book but yeah you can think of it  you can think of np in terms of  verification as a definition  uh  is proving people np the same as proving  that a problem you know actually i can  even make the  if you want you can  post public  comments too as well should have done  that in other cases  if is proving p equal np the same as  proving that a polynomial time  non-deterministic turing machine n  has a polynomial time deterministic  yeah so it  doesn't mean that  suppose we prove that p equals np  which is  the minority view i would say uh quite  the small minority view that that  there are some people who believe that  that  that that is uh entirely possible and  might even be the case but that's a very  small small group um  but yeah if you proved p equal np that's  the same as saying that every  non-deterministic polynomial time  turing machine is going to have a  companion  deterministic polynomial time turing  machine which does the same language  that's exactly what it  bye  means  you

2
00:00:26,550 --> 00:00:27,990
okay  hi everybody  let's get started  so  um  it's been a while since we uh  came together in a lecture last week we  had the holiday we had the midterm  um  so uh with that um  where what have we been doing um we  finished the first half of the course um  you know about two weeks ago  where we talked uh we were talking about  computability theory we have shifted  into the second half talking about  complexity theory um so  get your mind uh back to that  uh we um discussed the various different  models um  [Music]  and and and ways of measuring uh  complexity on different models um  at least in terms of the amount of time  that's used and in the end we settled on  the one tape turing machine which is the  same model we had been working with in  the first half of the course and argued  that um  though there  the measures of complexity are going to  differ somewhat from model to model  they're not going to matter  different by more than a polynomial  amount and so  since the kinds of questions we're going  to be asking  uh are going to be um basically whether  problems are polynomial or not uh it's  not going to really matter uh which  model we pick among reasonable  deterministic models and so we're gonna  the one tape turing machine is a  reasonable choice  uh given that we defined time complexity  classes the time t of n classes  we defined the class p  which was invariant among all of those  different model deterministic models in  the sense that it didn't matter which  model we choose we're going to end up  with the same class p so that argues for  its naturalness  and we gave an example of this path  problem being in p and we kind of ended  that lecture uh before the midterm with  the discussion of this hamiltonian path  problem so we're going to come back to  that today  uh so today we're going to look at  non-deterministic complexity uh define  the  classes non-deterministic time or end  time  uh talk about the class np  the p versus np problem which one of the  you know very famous unsolved problems  in our field  and  uh look at dynamic programming one of  the most basic algorithm polynomial time  algorithms and polynomial time  reproducibility moving toward our  discussion of np completeness which we  will begin um  next lecture so with that uh let's move  into today's uh  content which is  well just quick review we  as i mentioned we defined the time  complexity class  this is a the time complexity class is a  collection of  languages  the languages that you can do  um  these are a collection of languages  all of the languages that you can solve  in  a certain amount of a certain time bound  within a certain amount of time so the  time  the time n squared for example is all of  the the pr all of the languages or all  of the problems that you can solve in n  squared times we're identifying problems  with languages here  and the class p  is the collection of all problems that  you can solve or languages that you can  solve in polynomial time so it's the  union over all time n to the k so n  squared and cubed and to the fifth power  and so on um union out of all that all  of those bounds um  the the associated language languages  that's the class p  and um we gave an example this path  problem we gave an algorithm for path  and then we introduced this hamiltonian  path problem  so  if you remember  instead of just asking  given a graph whether you can get from s  to t  now we want to know can i get from s of  t but visit every other node along the  way  so find a  a path that goes through everything else  and gets from s to t  um  and uh  i should say it's also it's a simple  path so you're only allowed to go  through every node just once  um  and now um  uh um  the question is for this problem is  that can we solve that problem in  polynomial time the  you know can we somehow modify the  algorithm for path to give us an  algorithm that solves hamiltonian path  in polynomial time of course we could  solve hamiltonian path with an  exponential algorithm by trying all  possible paths um  and that will give a correct  algorithm but  there are exponentially many different  paths and trying them all  will not give a polynomial time  algorithm so the interesting problem is  can we solve that without doing that  brute force searching through all  possible paths  um  and  that's a problem that no one knows the  answer to  um  despite lots of effort people have not  succeeded in finding an algorithm for  that but um on the other hand we don't  have any idea how to approve there is no  such algorithm  i mean it's conceivable that one could  prove such a thing but we just don't  know how to do it  and so um  that problem is an unsolved problem and  i just want this isn't really a note to  myself um  what's kind of amazing and this is what  we're going to be showing over the next  few lectures  that there are there would there would  be very surprising consequences  if you could find a way to solve  hamiltonian path in polynomial time  because what that would immediately  yield  is a polynomial time way of say  factoring large numbers or solving a  large number of other problems that we  don't don't know how to solve in  polynomial time so you know as we  mentioned you know factoring um isn't  problem that we only know at present  time itself with an exponential  algorithm  um and it doesn't seem to have anything  to do with the fact with the hamiltonian  path problem seemed very different  but yet  if you can solve hamiltonian path and  polynomial time then you can factor  numbers in polynomial time and so we'll  see how to make that connection um  that's what we're building toward with  the next uh few lectures  okay  um  so happy to take any comments on  comments and questions on that or we'll  just move on  um  if you have any questions on our little  review  well send questions along and we can  stop at the end of uh you know various  slides to to to try to answer them or  and of course write to the tas um who  can take your questions during during  while i'm lecturing  okay um  so to start this off we're going to have  to talk about  uh non-deterministic complexity as a  variation of deterministic complexity  so first of all when we have a  all of our all of the machines in this  part of the course and the languages  everything is going to be decidable and  all the machines are going to be  deciders so what do we mean when we have  a non-deterministic machine which a  decider is a decider  and that just simply means that  all of the branches  it's not just the machine holds on every  input but all of the branches hold on  every input  you know so the non-deterministic  machine is non-deterministic it has lots  of possible branches they all have to  halt  all of them on every input that's what  makes a non-deterministic machine a  decider and you can convert a  non-deterministic decider into a  deterministic decider  but the question is how much time would  that introduce how much extra time is  that going to cost and the only way that  people know at the present time  for  that conversion would be  to do an exponential increase um  basically to try all possible branches  and that's of course very slow  so um  let's first  let's understand what we mean by the  time used by a non-deterministic machine  and what we mean by the time used is  we're looking at the each individual  branch individually  separately  so a non-deterministic machine will say  runs in a certain amount of time  if all of the branches halt within that  amount of time  so you you know what we do  we we do not mean  that the total amount of usage the total  amount of effort by adding up all the  branches is at most t of n  it's just that each branch individually  uses at most the event that's just going  to be our definition and it's going to  turn out to be uh  the right way to look at this to get  something useful  um  so  um  if we have um  so now we're going to define the  analogous uh complexity class associated  to uh non-deterministic computation  which we'll call non-deterministic time  so non-deterministic time t of n  is the set of all languages that you can  do with a non-deterministic machine that  runs an order t of n time  um  just think back to the definition we had  for deterministic uh complexity the time  class or sometimes people call it d time  to emphasize the difference but let's  just say we're calling it in this course  time versus end time so time t of n is  all of the languages that you can do  with the one tape turing machine  that's deterministic um but this here is  a non-deterministic turing machine for  non-deterministic time um  so the picture that uh uh that  is good to have in your head here  um  would be  uh if you think of non-determinism in  terms of a computation tree thinking of  all the different branches of the  non-determinism  all of those branches have to halt  and they have to halt within the time  bound  so imagine here this is t of n time all  of the branches have to hold within t of  n steps for this  a non-deterministic turning machine to  be running in t of n time and to be  doing a language in the end time t of n  class  um  and by analogy with what we did before  the class np  is  the  um  uh collection of all languages that you  can do  non-deterministically in polynomial time  um  so it's the union over all the end time  classes  uh  where we the bound is polynomial  um  okay so a lot of this should look very  familiar but we've just added a bunch of  non-deterministics  and a bunch of n's  in in place but the definitions are very  similar  um  and one of the motivations we had for  looking at p the class p was that it did  not depend  um on the choice of model as long as the  model was deterministic and reasonable  and this is also the class np is also  going to not depend on the choice of  model as long as it's a reasonable  non-deterministic  model  so  it's again a very natural class to look  at from a mathematical standpoint  and it also captures something  uh interesting  kind of different from a practical  standpoint which we're going to talk  about over the next couple of live  slides which is that it captures the  problems where you can easily verify  when you're a member of the language  okay so we'll talk about that but  you know if you take for example the  hamiltonian path problem  when you find a member of the language  so that is a  graph that does have a hamiltonian path  from s to t  you can easily verify that's true by  simply exhibiting the path  not all problems can be solved can be  verified in that way  but the problems that are in np have  that special feature  that you when you have a member of the  language there's a way to verify that  you're a member so we're going to talk  about that um because that's really the  key  to understanding np  this notion of verification  okay so  let me go there was a good question here  let me just see if i want to answer that  um  um  yeah  mean  this is a little bit of a long longer  question that i i i want to fully  respond to but  you mean the the  well  let's turn to my next slide which maybe  sort of bring that out anyway um  actually it's a couple of slides from  now but i'll get to that point um  so let's look at hamiltonian the hand  path problem and what i'm what i'm going  to show is the hamiltonian path problem  is in np and i'm going to walk you  through this one kind of slowly  um so the hamiltonian path problem  remember we don't know if it's in p  but it is  in np  so it's in one of these you can solve  hamiltonian path in polynomial time if  you're a non-deterministic machine  um why is that well it's because of the  non-determinism  because of the parallelism of  non-determinism um  which allows you to kind of check all of  the paths  on different branches  so let me first describe how the  algorithm how i would just how i would  write down the algorithm and then we'll  kind of try to unpack that and  understand how that actually looks in  terms of  the turing machine  or the turing machine's computation  so first of all  so taking the hamiltonian path problem  you know you're given an input now which  is a graph  and the node's s and t where i'm trying  to figure out is the hamiltonian path  again which visits all the nodes  which takes you from s to t  and  we're trying to make now a  non-deterministic machine which is going  to  accept  all such inputs which have a path  so the way this non-deterministic  machine is going to work  is it's basically going to use its  non-determinism  to try all possible paths  on the different branches  and the way i'll specify that  is to say non-deterministically we're  going to write down  a candidate path  which is just going to be a sequence of  nodes sequence of m nodes where we'll  say that's the total number of nodes of  the graph remember a hamiltonian path  because it visits every node  is going to be a path with exactly m  nodes in it  so i'm going to write down a sequence of  nodes as a candidate path  and i'm not deterministically going to  choose every possible sequence  in this way  um  if you like to think of the guessing  metaphor for non-determine  non-determinism you can think of the  non-deterministic machine as guessing  the right path  which is going to be the hamiltonian  path from s to t but i think from for  this discussion it might be more helpful  to think about all of the different  branches of the non-determinism  um  because that's perhaps more useful when  we're thinking about it in terms of the  time you know i think you'll get used to  thinking about it you should be used to  thinking about it many in many of the  different ways but maybe the computation  tree of all branches might be the more  helpful one here  so now as after we write down a sequence  a candidate path sequence of nodes  now i have to check  that this really is a path  and the way i'm going to do that is to  say well now if i have just a sequence  of nodes written down what does it mean  for it to be a hamiltonian path from s  to t  well it better start with s  and end with t  first of all  and  we have to make sure  that every step of the way is actually  an edge  so each pair v i to v i plus 1  has to be an edge in the graph  otherwise that sequence of nodes is not  going to be a legitimate hamiltonian  path from s of t  and you could it has to be a simple pass  you can't be repeating notes  these four conditions together will  guarantee  that we have a hamiltonian path and once  we have written down a candidate  sequence we can just check that that  sequence actually works  um there's no at this  second stage of the algorithm  non-determinism is necessary this is  going to be a deterministic phase  but the  stage one of the algorithm is going to  be a non-deterministic phase where it's  writing down all possible paths  now i'm going to try to unpack that for  you so you can actually visualize how  the machine is doing this  um  and then of course you know so you're  gonna on each branch of the  non-determinism you're going to  check to see whether the conditions have  been satisfied and on that branch  if the conditions were not satisfied  that branch is going to reject of course  one of the other branches might yet  accept so  um  that's how non-determinism works  okay so i'd like to visualize this  um  uh  um  i'd like to visualize this  as a  uh  the tree  of  uh of the different branches of the  computation  of m on its input so here is the here is  our non-deterministic turing machine um  uh which this one um  and  you provided with the input uh  you know g s and t  and how does the machine actually  working  so when i say non-deterministically  write down a sequence of m nodes  you know  you know  this is getting into a little bit more  detail detail than i would normally  think about it uh because we try to tend  to think about things at a higher level  but just for just to get us started i  think it's good to think about this  with a bit more detail  so let's think of the nodes the m nodes  as being numbered having labels  numbered one through m  and i'm going to think about them being  labeled by their binary sequences  you know we're going to write down those  nodes that's how the you know the  machine is going to have to operate on  those numbers for the nodes we'll think  about them as being written in binary  and now as the machine is going to be  writing down let's say the node v1  so it's not deterministically picking  the first node of the sequence what does  that actually mean in terms of the um  the  step-by-step processing of the turing  machine m  well it's going to be  um  guessing via a sequence of  non-deterministic moves  the bits  that represent  the number of the node v for v1  you know for example v1 might be the  node number five  in the graph  um  of course you know non-deterministically  the machine is on different branches  picking all different possible can  choices for v1  those are going to be the different  branches here  but you know  one of the branches might be  and what i'm what i'm really  representing here these are  uh i probably could have written this  down on the slide here in in in tiny  font but these are like the zero one  choices  that's why it's sort of a binary tree  here for the  writing down the bits  of the uh of a v1 so here maybe this  could be one zero one  representing  uh the number five  which might be the very first node  that i'm writing down in my sequence  some other branch is going to write down  node number six some other branch is  going to write down node number two  because non-deterministically we're  making all possible choices for v1  that's what i'm trying to show in this  little  part of the computation  of m on this input  so then  after it's uh finished writing down the  description of the node uh  for v1 um its choice for v1 it goes down  to make choose what v2 is again  non-deterministically so there's going  to be more branches  you know  um for each  possible choice of v2  and so on node after node um  then it's going to finally get to the  last node vm is going to write down lots  of choices for vm  and at this point here we have completed  uh  the first stage of the algorithm now  there's some huge tree  of all of the possible choices for the  v's that have shown up at this point  okay  and  uh now we're going to move into the  second phase  so following this there's going to be  um  here  uh a bunch of uh deterministic  steps of the machine so no more no no  more branching no more branching is  needed uh because here  we've written down at this at this point  we've we've reached a point in each of  these um  at each  each of those locations where we've  chosen one of the candidates  one of the possible branches or one of  the possible paths through the machine  um one of the possible paths look  through the graph i'm sorry so we um you  know here we're guessing  uh potential paths in the graph  and now we're going to check that we  actually have picked a path that's a  hamiltonian path from s to p  as to t  okay so each each one of these branches  is now going to end up accepting or  rejecting and the whole overall  computation is going to accept if at  least one of them ended up accepting  which means you actually found a  hamiltonian path  okay so i don't know if that's helpful  to you or not but um  that is uh so we can just you know if  there's any questions on this let's see  um  question on you know is there something  um  uh  uh  you know  trying to draw a connection here between  this and and computation histories um  i mean  there is  a pattern here that does come up often  where you you you want to check some  things you know starts right ends right  and that all of the intermediates are  right so there is i think there is a  um  there is some deeper connection here  probably too hard to explain but  um  that does have something to do with this  hamiltonian path problem  um why are we using binary  representation well we're going to talk  about  um you know we  the algorithm would have worked equally  well if we used um  base three or base five or base you know  20 um  as a way of writing down our  labels for the nodes um  but in a sense it doesn't matter um  um the alphabet has to be finite so  that's that's true i mean that's why  you it's not just in a single step of  the turing machine  that you would pick  the  the node uh the true the choice for v1  you really have to go through a sequence  of steps because  each of the  branches of the machine only has a fixed  number of choices so you can't in a  single step of the turing machine  pick all the different possibilities for  v1 it has to go through a sequence  um  okay  um  now let me do a second example the the  problem for of composites  so the the  the language of all composites are all  of the non-primes  written as binary numbers again so we'll  talk about the base and the  representation in a second but just  imagine you know he you know these are  all of the numbers that are not prime  uh and that language is easily seen to  be a member of np  uh here is again the algorithm for that  um  given x  um we want to accept x if it's not a  prime number so it has some non-trivial  factor  so first the way the non-deterministic  machine is going to work is it's going  to guess that factor so it's not  deterministically it's going to try  every possible factor  what we're wrong y is going to be a  number between 1 and x but not including  one we you know that we have to be an  interesting factor so not including 1 in  the number itself so something strictly  in between  and we're going to then after we've  non-deterministically chosen y then  we're going to test to see if y  is really a factor  we'll so we'll see if it y divides  evenly into x  with a remainder of zero  you know if that branch successfully  picked the right y it's going to accept  and some other branch might have picked  the wrong y will not and if  x is really a composite number some  branch will find the factor  um  now the base doesn't matter could have  used base 10  because you can convert from base to  another um so this is really in terms of  our representation of the of the number  but i do want to make one point here  that changing  we don't want to write the number in  unary  um you know just as  writing the number k  as a sequence of k ones um that's not  really a base um that's just an  exponential representation for the  number and that changes the game because  if you make the input exponentially  larger  um  then  uh  it's going to change whether the  algorithm  relative to that exponentially larger  input is polynomial or not um so an  algorithm that might have been  exponential  originally  when the numbers written binary might  become polynomial if the number's  written in unary um  and i do want to mention as a side note  that the composites  language  uh or primes for that matter doesn't you  know both are in p  um  but we won't cover that  so  uh  whereas the hamiltonian path problem is  not known whether it's in p  the primes and composites problem are uh  np um so that was known there was  actually a very big result in the field  uh solved um  uh by folks in at one of the uh indian  institutes of technology uh back about  uh  you know almost 20 years ago now  um  okay um  [Music]  so let's turn here to trying to get an  intuitive feeling for pnnp and we'll  talk we'll return now to this notion of  np corresponding to easy verifiability  so  np are the languages where you can  easily verify membership quickly and  i'll try to explain what that means in  contrast p are the languages where you  can test membership quickly uh by  quickly i mean i'm using  polynomial time  um  that's going to be basically you know  for us that's what quickly means in this  course  so  in the case of the hamiltonian path  problem  the way you verify the membership  is you give the path  in the case of the composites the way  you verify the membership is you give  the factor  um  in those two cases  and in general um  when we have a problem that's in np  we think of this  verification  as having a giving we give it a special  name called a certificate or sometimes a  short certificate to emphasize the  polynomiality of the certificate  it's like a way of proving that you're a  member of the language  um  in the case of composites the proof is  the factor  in the case of ham path the proof is the  is the path the hamiltonian path um  contrast that for example if you had a  prime number  um  you know  proving a number is composite is easy  because you just exhibit the factor  how would you prove that a number is  prime  um what's what's the short certificate  of  um  proving that some number is it has no  factor that's not so obvious  in fact there are ways of doing it which  i'm not going to get into in the case of  prime  testing of numbers prime but and and now  it's even so known to be in p so that's  even better  but  there's no obvious way of proving that a  number is prime with a short certificate  um  and  so this concept of having  being able to verify when you're a  member of the language that's key to  understanding np  that's the intuition you need to develop  and hopefully take away from today's  lecture or at least you know by  thinking about it and reading the book  and so on  um  so if you compare these two classes p  and np  uh p first of all is  going to be a subset of np both in terms  of the way we defined it because  deterministic machines are a special  case of non-deterministic machines  but also if you want to think about  testing membership if you can test  membership easily then you can certainly  verify it in terms of the certificate  you don't even need the certificate is  irrelevant at that point because  whatever the certificate is you can  still  test yourself  whether the input is in the is in the  language or not um  the big question as i mentioned is  whether these two classes are the same  so does  uh being able to verify membership  quickly say with one of these  certificates allow you to dispense with  the certificate not even need a  certificate and just test it for  yourself whether you're in the language  um  and do that you know in polynomial time  uh that  that's the question  for a problem like hamiltonian path  uh do you need to search for the answer  um if you're doing it deterministically  or can you somehow uh not me you know  avoid that and just come up with the  answer directly uh with it with a with a  polynomial time solution  nobody knows the answer to that uh  and goes back at this point quite a long  time it's almost 60 years now um  uh  that  that problem has been around 60 years  oh that would be 50 years no 50 years  almost 50 years  um  so um  the uh most people believe that p is  different from np in other words that  there are problems in p that are in np  would turn out in p  um  the candidate would be the hamiltonian  path problem uh  but it seems to be very hard to prove  that um  and part of the reason is i mean how do  you prove that a problem like  hamiltonian path does not have a  polynomial time algorithm  um  it's very tricky to do that because the  class of polynomial time algorithms is a  very rich class polynomial time  algorithms are very powerful  and to try to prove there's no clever  way of solving the hamiltonian path  problems just seems to be beyond our  present-day mathematics  i believe some days somebody's going to  solve it but all right so far  no one has succeeded um  so what i thought we would do is i think  i have a check in here uh yes  and then we'll stop for a break  so let's look at the  the complementary problem hand path  complement  um  so that's you're in the language now if  you don't have a path  um so is that complementary problem in  np  okay so  for that to be the case  we would need to have short certificates  of  when a graph does not have  um a hamiltonian path  so  i leave it to you so there are three  choices  um  okay  i'm going to stop here so make sure you  get your participation credit here  um  end the polling now  interesting still the majority is wrong  well i know wrong we don't know uh  you know um  uh i i think the only fair answer to  this question is is c  um because we don't know  uh  whether or not we can give short  certificates for a graph not to have a  hamiltonian path  if if p equaled np  then you can test in polynomial time  whether a graph has a hamiltonian path  and then the computation itself would be  a certificate whether it has a path or  whether it doesn't have a path because  it would be something that you can check  easily  um  so  since we don't know uh  for sure that p is different from np um  you know p could be equal to np then  it's possible that  um  we can we could give a short certificate  namely the  computation of the polynomial algorithm  so the only really um  reasonable answer to this question is  that we don't know  um  so uh just uh ponder that i think the  the the thing that um you  those of you who answered yes  however  um need to go back  and and i ain't put this here explicitly  because i know this is a  th  this is a confusion for  well i can see for quite a few of you um  um  when we have non-deterministic  computation and you have a  non-deterministic machine you can't sim  simply  invert the answer and get back a  non-deterministic machine  non-determinism does not work that way  uh if you remember  you know the non-deter the complement of  a push-down automaton  um is not a push-down automaton  if you have a non-deterministic machine  and you invert all of the responses on  each of the branches  um it's not going to be  recognizing or deciding the  complementary language  so um  because  well i i think that this is something  you you if you answered yes  you need to  go back and make sure you understand why  yes  um is is not a is not a reasonable  answer to this question uh because  that's not how non-determinism works so  you have a  um  a not complete understanding of  non-determinism and that's going to be  really important for us going forward so  i i really urge you to figure out and  understand why yes is not a is not a  good answer to this uh to this check-in  okay so i think we will um we can talk  about that more over the over the break  um  and so uh we'll we'll return here in  um  in five minutes  somebody's asking about in  you know infinite uh  equal infinite sequences be generated by  the machine um  i you know when we're talking about  um  you know especially in the complexity  section of the course  all of the computations are going to be  bounded in time so we're not going to be  thinking about sort of infinite runs of  the machine that's not going to be  relevant for us so um let's not think  about that how does the turing machine  perform division  um  how does a turning machine perform  division well uh  how do you perform division  uh  the  long division is a is an operation that  can run in  you know the the long division procedure  that you you learn in a grade school can  you can implement that on a turing  machine um  so yes a turing machine can definitely  perform  do long division or division in one  integer by another in in polynomial time  okay another question can we generally  say  try dividing y by x or do we have to  enumerate a string of length y and cross  off every no i think that's the same  question  you know  i mean how would you know if you have  numbers written in binary how would you  do the division you're not going to uh  use long division  um  you know anything such as the the the  thing that's proposed here uh  by by the the questioner is going to be  an exponential algorithm so don't do it  that way  um  uh  why does primes in p not um composites  in p not implied primes in p it does  imply if  if composites are in p then primes is in  p as well because you can just you know  when you have a deterministic machine  you can flip the answer when you have a  non-deterministic machine  you may not be able to flip the answer  so  the deterministic machine just having a  single branch  um you can make another deterministic  machine that runs in the same amount of  time that does the complementary  language  um because  um for deterministic machines um just  like for deciders  uh  in the in the computability section you  can just invert the answer  uh there is an analogy here between  p  and decidability and np and  recognizability it's not an  airtight analogy here but there is some  relationship there um  what are the input like somebody's  asking me the implications of p equal to  np lots of implications um  too long to enumerate now but for  example  uh you would be able to break basically  all  cryptosystems um that i'm aware of if p  equaled np so we would have a lot of  consequences  um  so he's asking so composites  primality and compositeness testing is  solvable in polynomial time but  factoring interestingly enough is not  known to be solvable in polynomial time  uh so that i mean  so um  we may talk about this a little bit  toward the end of the term if we have  time  but  the algorithms for testing whether a  number is prime or composite in  polynomial time do not operate by  looking for factors  they operate in an entirely different  way  basically by showing that a number is  prime or composite by looking at certain  properties of that number but without  testing whether it has uh testing  but without finding a factor  um  uh  okay  another question here about asking um  the  uh  when we talk about encodings do we have  to say how we encode numbers  values no we don't have to we usually  don't get have to get into  spelling out encodings  as long as they're reasonable encodings  so you don't have to  usually  we're going to be talking about things  at a higher enough level that the  specific encodings are not going to  matter  um  okay let's let's return to our  uh  the rest of our lecture  when we talk about  say this p versus np problem  and  how do you show  that  uh  you know a problem  might not be solvable in p like the  hamiltonian path problem  um  you know many people  you know  who are  not uh practitioners in the field um you  know are know about the p versus no know  about the p versus np problems i i've  over the years i've got many many  emails and and and physical letters from  from people um  about that uh since people you know  since uh since i've spent some time  thinking i'm known as having spent some  time thinking about it  and um people claim to solve the problem  uh solve p is np  p the p versus np problem by basically  saying you know  problems like hamiltonian path  um  uh  you know or these or other similar  problems  basically there's clearly no way to  solve them without searching uh through  a lot of possibilities and then they go  through a big long analysis showing that  there are exponentially many uh  possibilities um  the  um  the  uh  you know  and a lot of the proofs that claim to  solve p versus np they all look like  that you only you only have to look some  somewhere in that paper there's going to  be a statement  uh along the lines  to solve this problem clearly you have  to do it this way  um  and  that's the flaw in the reasoning because  just like for the factoring problem  just like for the  uh compositeness testing problem you  don't necessarily have to solve it use  by by searching for factors there might  be some other way to do it you might be  able to solve a hamiltonian path  problem without searching for  hamiltonian paths there might be some  other process that you can use which  would uh give you the answer  um so i the class of polynomial time  algorithms is very rich can do many many  things and i and i i wanted to present  to you um  one of the most important polynomial  time algorithms in a sense it's kind of  the  you can make a certain argument that  this is sort of the the  the the in a sense the most fundamental  polynomial time algorithm  some people might argue with me on that  but  um and that's a process called dynamic  programming  which i'm sure some of you have seen  already in your algorithms classes  and some of you may not have but um  since you have a homework problem on it  um i i want to spend a little time  describing it to you  and that's useful for solving this acfg  problem um  which you may remember from the first  half of the course  involving testing  uh if a grammar generates a string  okay so remember this acfg problem  you're given a grammar  context free grammar  and a string and i want to know is it in  the language of the grammar  okay so that's going to turn out to be  solvable in polynomial time  but only with a kind of a clever  algorithm  remember it's decidable  we decided it by converting by making  sure that you are converting the grammar  into chance chomsky normal form then all  the derivations have a certain length  you just try all the possible  derivations of that length and you set  except if any of those derivations  generate w  okay  uh you may remember that um from the  first half of the course um  that immediately gives  an np type algorithm  for this language  because basically  you  non-deterministically  instead of trying the most sequentially  all of these derivations you try them in  parallel non-deterministically so  non-deterministically you pick some  derivation  of that length  and you accept it if it generates the  input  this fits this is  classically fits our model  of  of uh  of np  you can think of it as guessing the  derivation and checking that works or in  parallel writing down all possible  derivations um  but this acfg problem is  a  classically  uh an np problem  uh probably an in in np um  uh and if you just imagine  that  uh so and and then what's going to be  this the certificate if you found an  input that's in the language um that's  generated by the grammar the certificate  is the derivation  so if you look at it that way you might  think well that's the best you can do  this is going to be an np pro problem in  np and there's not going to be a way of  avoiding searching for the derivation  but that's not true there is a way of  avoiding searching for the derivation  you can kind of build up the derivation  um using dynamic program and so that's  what i wanted to kind of just describe  for you um how that works also partly  because it's a homework problem and i  think dynamic programming isn't is a  very important algorithm  so um  before we  um  uh  describe what dynamic programming is  which is very simple by the way um let's  try to work up to it by making an  attempt to solve this problem just using  ordinary recursion  um  so how would we solve the acfg problem  so you're given a grammar  you're given an input  let's assume the grammar's in conjunct  in chomsky normal form  so  that's going to be useful so it's a  chomsky normal form grammar and we want  to see how to  test if you can generate w  um  and it's going to be recursive algorithm  recursive algorithm is going to  actually sound something slightly more  general  i'm going to give you the grammar i'm  going to give you the string and i'm  also going to allow you to start at some  other variable variable besides the  start variable so i'm going to give you  a  some variable r and i know i want to  know can i generate w starting at r  okay so that's my slightly more general  problem which is going to be useful in  the recursion  okay so the input now to this this  algorithm is  the grammar the input and the starting  variable and now how is the algorithm  going to work it's going to try to test  can i get to you know is there some  derivation pictured here as the parse  tree  for w starting at r  that's what the algorithm is trying to  answer  can i get  w from r  the way it's going to do that  is  it's going to try to divide w  into  the two strings  in all possible ways  which sounds like it might be  exponential but it isn't  there's only a polynomial number of ways  to divide the string into two  substrings um just order n just  depending where you make that cut  so there's you know some  uh so that's not too bad there's a  polynomial there's only n ways of making  that division and also i'm going to try  every possible rule that comes from r  um that generates two  uh  um  that generates two variables so these  are  what's allowed in chomsky normal form r  goes to st  okay so i'm gonna for each possible way  of cutting w into x and x y and for each  possible rule r goes to st i'm gonna see  recursively can i get uh from s to x and  from t to y  so i'm going to use my recursion now now  that i have smaller  uh  um strings  instead of w  um i can apply my recursion and try to  answer it that way  and this algorithm will work  so if they if i found a way to cut w  into xy and i found a rule r goes to st  such that s generates x and t generates  y then i'm good  i know i can generate uh  w from r  okay and if there's no way of cutting w  up um to satisfy that or uh  you know uh if i can't find any way to  do  to divide w into x y and the rule r goes  to x t which makes this work  if all possible ways fail then you can't  get from r to w  okay  um  and then you can decide the original  acfg problem now by starting from the  start variable instead of just some any  old r you plug in the start variable far  okay so if this algorithm works  and  it  can be used to solve ac of g  but the question is is a polynomial  and it's not  because  every time you're doing the recursion  you're essentially adding another factor  of n  because here as we pointed out this is a  factor of n but that's happening every  time you're doing a recursive level  and you can imagine you know i'm just  doing a very crude analysis here  depending upon how you divide divide w  up but roughly speaking it's going to  get divided in half each time so there's  going to be log n levels  and so that means you're going to be  multiplying n by itself log n times or  get give you an n to the log n algorithm  that's not polynomial because  polynomials enter the constant  for some fixed constant n to the log n  is not going to be polynomial so this is  not a polynomial algorithm  so instead you're going to have to do  something just a little bit more clever  it's going to be the same basic idea  but just relying on one little  observation  and the little observation is  that  when  this  non-polynomial implementation that i  just described is actually pretty pretty  dumb  because it's doing a lot of  recomputation of things that it's  already solved why is that  because  if you look at the number of possible  different sub-problems here once i fix  once i give you g and and i give you w  um  how many  different sub-problems uh  g s and t are there  um  well the number of sub the number of uh  of strings here  all of those strings are going to be  substrings of w there's only  roughly n squared substrings of w i'm  always going to be generating  in a sub problem here some substring of  w from some starting variable um in the  grammar  so because there aren't that many  different substrings and not that many  different starting variables the number  the total number of possible problems  that this algorithm is going to be  called on to solve is going to be in  total a polynomial number of different  sub problems there aren't very many of  them it's only something like border n  squared  so if the algorithm is running for  exponentially long  long time it's solving the same sub  problem over and over again  that's dumb  why don't you just remember when you  solve the sub problem so you don't solve  it again  doing that  enhanced recursion where you remember  the problems you've already solved it's  called dynamic programming i don't know  why it has such a  a confusing name like that  actually it's called by several  different things but anyway  that's known as dynamic programming it's  a recursion plus the memory um  and here is just repeating myself um  there are  not very many different substrings um  so every time you're going to be in your  recursion somewhere you're going to be  working with a substring so there's not  that many different sub problems that  you can possibly solve and just remember  when you solve the sub problem  and not solve it again so  let me just show you that algorithm  again here with them with a little  modification  so first of all  let me give you  this is the same algorithm from the  previous slide i'm just repeating here  without all the other stuff so we can  just look at it directly right dividing  it  into x and y for each possible rule  and just and then recurse  now  i'm going to  add a little step 0 beforehand  um which says  if i have g w and r  let me just check first with i've  already solved that one before  so i have to keep track of the ones i've  already solved  that's not too bad because there's only  n squared order n squared possible  different ones that i could be called on  to solve  so i'm just going to have a little table  where i'm going to remember those  and then every time i get a new one i  get i get one to solve i'll check is it  on that table and what's the answer  so i won't have to rerun those  so now the total i'm going to be  basically pruning that tree  um so that it has only a polynomial  number of leaves and so the total size  of that tree now is going to be  polynomial um  uh and so that's going to yield a  polynomial running time this by the way  i only learned this myself i'm sure you  guys all know this who have taken this  as in the algorithms of course has a  special name called  memoization not memorization sort of  this came from the same root i think but  memoization which is somehow remembering  the results of a computation so you  don't have to repeat it  um  so the total number of calls is going to  be most n squared to this algorithm uh  because you're never going to be uh  redoing a work that you've done already  so and you know and when you actually  have to go through it  the the running time um  uh  um  you know so  it's it's the the total amount of time  that you're going to need is going to be  polynomial altogether um  so  let's here i don't remember what my  check-in is on this  um oh yeah so i mean this is somehow  related and feel free to ask questions  too  while you're thinking about uh this um  this check-in but the check-in says here  we've solved the acdfg problem in  polynomial time  does that tell us that every  context-free language itself  is also solvable in polynomial time  so just mull that over  and please give me an answer to it  i hope you do better on this check and  then you did on the last one um  but anyway why don't you go ahead and  think about that  and i can take some questions in the  meantime  someone is asking here  um actually i'm getting several  questions on this  why isn't it order n cubed or something  greater than order n squared because of  the variables  the variables are not don't don't depend  on n  you know when you're given  um oh well  actually that's not true  no  you you're you are right  um  uh because the grammar is part of the  input  so that you might have as many as n  different variables in the given grammar  so you you are right there is  potentially  um you know the grammar might be half  the size of the input  and the input to the grammar w might be  half the size of the input so i didn't  think about that but you're correct  there are uh potentially  uh  different numbers of variables in  different grammars so you have to add an  extra factor which would be at most the  size of the input because that's as many  variables as you could possibly have so  it really should be i think um order n  cubed um  to take that into account as well  plus all of the work that needs to  happen in terms of dividing things up  you know on a one tape turing machine  there's going to be some extra work uh  just to carry out some of these  individual steps um because with a  single tape things are sometimes a  little awkward i think the total running  time is going to end up being something  like enter the fourth or into the fifth  on a one tape turing machine  but  but that's a good point  so somebody's saying how can we be  storing n squared strings in finite time  i'm not saying what why finite time we  have polynomial time every every state  stage of this algorithm is allowed to  run for polynomially many steps as long  as it's clearly polynomial we can just  write that down as a single stage um  part two should say  oh  there's a typo here so use d  thank you that's that is a typo um  uh  i'm afraid if i change it on my original  slide here things will break in some  horrible way  let's just see that i completely wrecked  my slide  no that's good  yeah thank you good point  um  uh  oops  okay how's how's our check-in doing  okay i think you're just about all done  um oh that's still spent a lot of time  on this  and polling um  as you may remember from the first half  of the course  so the answer is is a indeed um  remember that we showed acfg is in  is decidable and therefore each context  free language itself is decidable just  because you can then plug you can plug  in the specific grammar into the acfg  problem  the very same reasoning works here  um you can for if if you have a  context-free  language it has a grammar you can plug  that grammar into the acfg problem  and then that's polynomial time you'll  get you're going to get a polynomial  time algorithm for that uh for that  language um so good to review that um  it's it's the same thing from same  argument we used before  um  okay  also i i  i want to spend a lot of time on this  there are there's another way of looking  at dynamic programming we'll talk about  this again um maybe in a lecture  probably next lecture just because i  know you have a homework problem on it  and um if if you've seen dynamic  programming before is going to be easy  if you haven't seen it before it's going  to be i think probably a little  challenging  but  another way of looking at dynamic  programming is the so-called bottom-up  version of dynamic programming and what  that would mean is you solve all of the  sub-problems first before you solve all  the smaller sub-problems before you  solve the larger sub-problems um let me  just  you know i  i it's here on the slide i'm not sure i  want to talk it through but basically  um  you solve  this the sub problems here  where um  the strings are start with strings of  length one  and then from that you build up to sub  problems where the substrings are of  length two  and then three and so on and each of  those only relies on the smaller  previously solved sub problems so you  can  kind of in a systematic way  solve all the larger and larger  subproblems uh you know for larger and  larger substrings  and  that gives a kind of a different  perspective on dynamic programming and  kind of for different problems sometimes  it's better to think about either the  sort of top-down recursion-based  process or the sort of the bottom-up uh  process that i'm describing here um  they're really completely equivalent um  but uh  you know  the version that's described for this  particular algorithm which appears in  the textbook is actually the bottom-up  algorithm um so you shouldn't be  confused if you see something there  which looks somewhat different  and that's often you see you basically  solve all possible sub problems  filling up basically filling out a table  um  let me not say it anymore  say anything more about that here since  we're running a little short on time um  but um  there are really two perspectives on  dynamic programming  okay so moving on from there um  let's let's shift gears  uh leave context free languages and uh  dynamic programming behind  um and start moving toward understanding  um  p and np  and for that we will  um  introduce a new problem called the  satisfiability problem and that's one  we're going to spend a lot of time on  so  important to  if you tuned out a little bit during the  dynamic programming  discussion  time to get back on board  so the satisfiability problem is going  to be a computational problem um  uh that  we're going to be working on and it has  to do with boolean formula  so these are like expressions like  arithmetical formula like  x plus y  times z  but instead of using um  numerical  variables we're going to be using  boolean variables that take on boolean  values true false or sometimes  represented by one and zero  and the operators that we're going to be  using are going to be the and or and  negation operations  and or not  okay um  i'm going to say such a very such a  formula such a boolean formula we're  going to call it satisfiable we'll do an  example in a second  if that formula value evaluates to true  um if you assign  make some assignment the values to its  variables  so just like arithmetic their formula  will have some value if you plug in  values for the uh  boolean formula is going to have some  value if you plug in boolean values for  its variables and i want to know is  there some way to plug in values which  makes the whole thing evaluate the true  the the formula itself is going to  evaluate to some either true or false  and i want it to evaluate to true  um  so  uh here is our example that let's take  the formula fee  which is x or y  and  x complement  you know or not x or not y  so the notation x  with a bar over it x  x complement is just x bar  not x  is just  the way if you're familiar with the  other notation  uh for the the not operation  we just inverts ones and zeros um  we we would write it we're going to  write it with a bar instead of the  negation symbol so i i'm assuming that  you've all seen boolean algebra boolean  arithmetic before you know where you  know the and operation is only true  if both inputs are true so these are  going to be binary and operations in  binary or operations  um or is going to be true if either  input is true and not as true if it's  single input is false  so it just flips the answer  okay so here i want to know for this  formula for this boolean formula here is  it satisfiable  is there some way to assign values to  the variables  to make this formula evaluate to true  so for example let's just try things  let's make x and y both true  so x is true and y is true  so x or y well that's good that's true  but now we have to do an and so we need  both sides to be true  so now now we have x complement well we  said we said x is true so x complement  is false y complement is false false or  false is false so now we have a true and  false that's going to be false  we did not find a satisfying assignment  but maybe there's another one and in  fact there is if you make x true and y  false  then both of these parts  will be evaluate to true and then you'll  have true and true so we found a  satisfying assignment to this formula it  is in fact  uh satisfiable so if you say x is 1 and  y 0 yes this is satisfiable  now the problem of testing for a boolean  formula if it is satisfiable is going to  be the sat language  it's a set it's a collection of  satisfiable boolean formula  and testing whether you're in sat or not  is going to be a  an important computational problem  and  there was an amazing  theorem  which really got this whole subject  going  uh discovered independently  by uh  steve cook  in north america and lane 11 in the in  the former soviet union  almost exactly at the same time  which made a connection between this  one problem and all of the problems in  np  so by solving this one  satisfiability problem  in polynomial time  you you there  it give it it allows you to solve all of  the problems in np in polynomial time  so if you could solve this problem sat  in in in p then hamiltonian path is also  solvable in p it's kind of  you know  step back and think about that it's kind  of amazing um  [Music]  and the method that we're going to  introduce is called polynomial time  reducibility  and let's do a quick checking on this  this should be an easy one um  i want to just think about is sat the  sat problem that we just described here  is that in np  three seconds  you all there  okay  ending polling  um  yeah so the a  hopefully you're getting the intuition  for np uh that  these are the problems to be an np means  that when you're a member of the  language  there's a short proof or a short  certificate  of membership in this case the short  certificate that the formula is  satisfiable is the assignment which  makes it true also called the satisfying  assignment  so yes this is an np language  language that's in np  um  uh so there are a lot of things that we  don't know in this subject but  this isn't one of them we do know that  sat is an np  so let's talk about our method um  for showing this uh remarkable fact that  if you can solve pollen if you can solve  if you can solve sat in polynomial time  then all of np is solvable in polynomial  time and it uses this notion of  polynomial time reducibility which is  just like mapping reducibility that i  hope you've all grown to know and love  in the first half of the course  but now the reduction has to operate in  polynomial time  so it's the same picture that we had  before  mapping a to b  transforming a questions to b questions  but now the transformation has to  operate quickly  and we get that  if a is polynomial time reducible to b  and b is polynomial time  then a is also polynomial time  same pattern as before  if a is reducible to b and b is easy  then a is easy um  and here is  kind of the essence of the idea  or at least the outline in a sense the  idea of of this cook and levin theorem  that if satisfiability is in p then  everything in np can be done in p  which is because we will show  that all problems in np are polynomial  time reducible to set  that's the amazing fact  so therefore if you can  bring sat down into p  by using this reduction it brings  everything else along with it because  everything is reducible to the set so we  just have to show how to do that  and there is an analogy that we had in  the first half of the course in one of  our homework problems if you may  remember  we showed that atm  has the very special property  that all touring recognizable languages  are mapping reducible to it  i think that was problem  2  on  2a  either in this problem set 3 or problem  set 2.  i think problem said three  um  that every  every entering recognizable language is  polynomial time reducible to atm  and so  very similar picture and there's the  a lot of analogies here that you can  draw between between  uh the computability section and the  complexity section  anyway  with that i know we're just about out of  time so let's quick review um  of what we've done um here  and um i will stick around for questions  for a while  is there a  okay that's a good question is there  kind of a you know a um  sort of a regular reduction analogy  version to mapping reducibility you know  we had that we had the general reduction  uh for the computability section  and we had the mapping reduction for the  computability section here  we're only going to be focusing  now on the mapping  reduction so polynomial time reduction  is  by assumption going to be a mapping  reduction yes there is a  general  polynomial time reduction notion as well  if you  you know this is not required but if you  are curious about the general reduction  and how to precisely formulate that it  actually appears in  uh chapter six under turing reducibility  um that's the general notion of  reducibility spelled out in a formal way  and there's polynomial time touring  reducibility as well we're not going to  talk about it this in this course  um  other questions  does np correspond exactly  to verification in polynomial time if  well we have to  for me to answer that as a precise  question we have to have a precise  definition of verification but with the  right  definition the answer is yes  um  so you can define a verifier  as a polynomial time algorithm  um that gives a certificate given that  takes a certificate and an input to the  language and will um  you know  accept if they're if that certificate is  a valid certificate for that input um  this is actually discussed in chapter i  think nine  um  of the text  uh but um  uh you  um  no i'm forgetting already what's where  in the book but yeah you can think of it  you can think of np in terms of  verification as a definition  uh  is proving people np the same as proving  that a problem you know actually i can  even make the  if you want you can  post public  comments too as well should have done  that in other cases  if is proving p equal np the same as  proving that a polynomial time  non-deterministic turing machine n  has a polynomial time deterministic  yeah so it  doesn't mean that  suppose we prove that p equals np  which is  the minority view i would say uh quite  the small minority view that that  there are some people who believe that  that  that that is uh entirely possible and  might even be the case but that's a very  small small group um  but yeah if you proved p equal np that's  the same as saying that every  non-deterministic polynomial time  turing machine is going to have a  companion  deterministic polynomial time turing  machine which does the same language  that's exactly what it  bye  means  you
 

3
00:00:27,990 --> 00:00:31,750

 

4
00:00:31,750 --> 00:00:31,760

 

5
00:00:31,760 --> 00:00:32,630


6
00:00:32,630 --> 00:00:32,640

 

7
00:00:32,640 --> 00:00:34,229


8
00:00:34,229 --> 00:00:36,709

 

9
00:00:36,709 --> 00:00:38,630

 

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

 

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

 

12
00:00:41,040 --> 00:00:42,229


13
00:00:42,229 --> 00:00:45,350

 

14
00:00:45,350 --> 00:00:47,350

 

15
00:00:47,350 --> 00:00:50,229

 

16
00:00:50,229 --> 00:00:52,549

 

17
00:00:52,549 --> 00:00:54,709

 

18
00:00:54,709 --> 00:00:57,189

 

19
00:00:57,189 --> 00:00:58,950

 

20
00:00:58,950 --> 00:01:01,750

 

21
00:01:01,750 --> 00:01:04,469

 

22
00:01:04,469 --> 00:01:08,230

 

23
00:01:08,230 --> 00:01:09,540

 

24
00:01:09,540 --> 00:01:09,550

 

25
00:01:09,550 --> 00:01:11,030


26
00:01:11,030 --> 00:01:13,750

 

27
00:01:13,750 --> 00:01:16,310

 

28
00:01:16,310 --> 00:01:17,830

 

29
00:01:17,830 --> 00:01:20,390

 

30
00:01:20,390 --> 00:01:22,230

 

31
00:01:22,230 --> 00:01:23,990

 

32
00:01:23,990 --> 00:01:26,469

 

33
00:01:26,469 --> 00:01:28,230

 

34
00:01:28,230 --> 00:01:29,749

 

35
00:01:29,749 --> 00:01:31,670

 

36
00:01:31,670 --> 00:01:33,429

 

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

 

38
00:01:35,429 --> 00:01:37,270

 

39
00:01:37,270 --> 00:01:39,109

 

40
00:01:39,109 --> 00:01:40,469

 

41
00:01:40,469 --> 00:01:41,670

 

42
00:01:41,670 --> 00:01:44,950

 

43
00:01:44,950 --> 00:01:47,270

 

44
00:01:47,270 --> 00:01:48,950

 

45
00:01:48,950 --> 00:01:51,109

 

46
00:01:51,109 --> 00:01:53,749

 

47
00:01:53,749 --> 00:01:55,030

 

48
00:01:55,030 --> 00:01:57,429

 

49
00:01:57,429 --> 00:02:00,149

 

50
00:02:00,149 --> 00:02:02,789

 

51
00:02:02,789 --> 00:02:05,350

 

52
00:02:05,350 --> 00:02:07,830

 

53
00:02:07,830 --> 00:02:09,910

 

54
00:02:09,910 --> 00:02:11,350

 

55
00:02:11,350 --> 00:02:13,190

 

56
00:02:13,190 --> 00:02:15,750

 

57
00:02:15,750 --> 00:02:17,990

 

58
00:02:17,990 --> 00:02:19,830

 

59
00:02:19,830 --> 00:02:21,670

 

60
00:02:21,670 --> 00:02:24,150

 

61
00:02:24,150 --> 00:02:26,229

 

62
00:02:26,229 --> 00:02:27,430

 

63
00:02:27,430 --> 00:02:28,869

 

64
00:02:28,869 --> 00:02:30,309

 

65
00:02:30,309 --> 00:02:33,270

 

66
00:02:33,270 --> 00:02:33,280

 

67
00:02:33,280 --> 00:02:34,550


68
00:02:34,550 --> 00:02:37,030

 

69
00:02:37,030 --> 00:02:37,040

 

70
00:02:37,040 --> 00:02:37,990


71
00:02:37,990 --> 00:02:40,229

 

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

 

73
00:02:42,949 --> 00:02:44,869

 

74
00:02:44,869 --> 00:02:46,309

 

75
00:02:46,309 --> 00:02:46,319

 

76
00:02:46,319 --> 00:02:47,110


77
00:02:47,110 --> 00:02:49,350

 

78
00:02:49,350 --> 00:02:51,270

 

79
00:02:51,270 --> 00:02:52,790

 

80
00:02:52,790 --> 00:02:55,030

 

81
00:02:55,030 --> 00:02:57,509

 

82
00:02:57,509 --> 00:02:59,910

 

83
00:02:59,910 --> 00:03:02,790

 

84
00:03:02,790 --> 00:03:04,949

 

85
00:03:04,949 --> 00:03:07,430

 

86
00:03:07,430 --> 00:03:10,149

 

87
00:03:10,149 --> 00:03:11,990

 

88
00:03:11,990 --> 00:03:13,589

 

89
00:03:13,589 --> 00:03:16,149

 

90
00:03:16,149 --> 00:03:17,589

 

91
00:03:17,589 --> 00:03:17,599

 

92
00:03:17,599 --> 00:03:19,430


93
00:03:19,430 --> 00:03:22,149

 

94
00:03:22,149 --> 00:03:22,159

 

95
00:03:22,159 --> 00:03:23,110


96
00:03:23,110 --> 00:03:25,270

 

97
00:03:25,270 --> 00:03:27,430

 

98
00:03:27,430 --> 00:03:27,440

 

99
00:03:27,440 --> 00:03:28,229


100
00:03:28,229 --> 00:03:30,070

 

101
00:03:30,070 --> 00:03:32,789

 

102
00:03:32,789 --> 00:03:32,799

 

103
00:03:32,799 --> 00:03:33,589


104
00:03:33,589 --> 00:03:36,789

 

105
00:03:36,789 --> 00:03:38,789

 

106
00:03:38,789 --> 00:03:40,949

 

107
00:03:40,949 --> 00:03:43,430

 

108
00:03:43,430 --> 00:03:45,270

 

109
00:03:45,270 --> 00:03:47,030

 

110
00:03:47,030 --> 00:03:48,710

 

111
00:03:48,710 --> 00:03:50,550

 

112
00:03:50,550 --> 00:03:52,789

 

113
00:03:52,789 --> 00:03:55,990

 

114
00:03:55,990 --> 00:03:58,550

 

115
00:03:58,550 --> 00:04:02,229

 

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

 

117
00:04:04,149 --> 00:04:07,030

 

118
00:04:07,030 --> 00:04:08,789

 

119
00:04:08,789 --> 00:04:11,429

 

120
00:04:11,429 --> 00:04:14,550

 

121
00:04:14,550 --> 00:04:16,229

 

122
00:04:16,229 --> 00:04:18,710

 

123
00:04:18,710 --> 00:04:18,720

 

124
00:04:18,720 --> 00:04:20,310


125
00:04:20,310 --> 00:04:22,710

 

126
00:04:22,710 --> 00:04:24,390

 

127
00:04:24,390 --> 00:04:26,550

 

128
00:04:26,550 --> 00:04:27,510

 

129
00:04:27,510 --> 00:04:29,909

 

130
00:04:29,909 --> 00:04:32,150

 

131
00:04:32,150 --> 00:04:32,160

 

132
00:04:32,160 --> 00:04:33,909


133
00:04:33,909 --> 00:04:35,510

 

134
00:04:35,510 --> 00:04:38,550

 

135
00:04:38,550 --> 00:04:40,830

 

136
00:04:40,830 --> 00:04:40,840

 

137
00:04:40,840 --> 00:04:42,710


138
00:04:42,710 --> 00:04:44,230

 

139
00:04:44,230 --> 00:04:45,909

 

140
00:04:45,909 --> 00:04:47,749

 

141
00:04:47,749 --> 00:04:49,990

 

142
00:04:49,990 --> 00:04:50,000

 

143
00:04:50,000 --> 00:04:51,270


144
00:04:51,270 --> 00:04:54,830

 

145
00:04:54,830 --> 00:04:57,350

 

146
00:04:57,350 --> 00:04:59,909

 

147
00:04:59,909 --> 00:05:01,590

 

148
00:05:01,590 --> 00:05:03,749

 

149
00:05:03,749 --> 00:05:05,270

 

150
00:05:05,270 --> 00:05:07,350

 

151
00:05:07,350 --> 00:05:09,670

 

152
00:05:09,670 --> 00:05:13,029

 

153
00:05:13,029 --> 00:05:14,550

 

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

 

155
00:05:16,390 --> 00:05:18,550

 

156
00:05:18,550 --> 00:05:20,310

 

157
00:05:20,310 --> 00:05:22,629

 

158
00:05:22,629 --> 00:05:24,150

 

159
00:05:24,150 --> 00:05:25,990

 

160
00:05:25,990 --> 00:05:27,350

 

161
00:05:27,350 --> 00:05:29,510

 

162
00:05:29,510 --> 00:05:31,590

 

163
00:05:31,590 --> 00:05:33,350

 

164
00:05:33,350 --> 00:05:34,950

 

165
00:05:34,950 --> 00:05:34,960

 

166
00:05:34,960 --> 00:05:36,150


167
00:05:36,150 --> 00:05:36,160

 

168
00:05:36,160 --> 00:05:37,430


169
00:05:37,430 --> 00:05:38,790

 

170
00:05:38,790 --> 00:05:39,830

 

171
00:05:39,830 --> 00:05:39,840

 

172
00:05:39,840 --> 00:05:41,110


173
00:05:41,110 --> 00:05:42,950

 

174
00:05:42,950 --> 00:05:44,870

 

175
00:05:44,870 --> 00:05:47,670

 

176
00:05:47,670 --> 00:05:50,070

 

177
00:05:50,070 --> 00:05:51,670

 

178
00:05:51,670 --> 00:05:53,270

 

179
00:05:53,270 --> 00:05:54,550

 

180
00:05:54,550 --> 00:05:57,189

 

181
00:05:57,189 --> 00:06:00,950

 

182
00:06:00,950 --> 00:06:03,670

 

183
00:06:03,670 --> 00:06:05,110

 

184
00:06:05,110 --> 00:06:07,430

 

185
00:06:07,430 --> 00:06:09,350

 

186
00:06:09,350 --> 00:06:10,629

 

187
00:06:10,629 --> 00:06:11,909

 

188
00:06:11,909 --> 00:06:13,189

 

189
00:06:13,189 --> 00:06:15,430

 

190
00:06:15,430 --> 00:06:17,590

 

191
00:06:17,590 --> 00:06:20,870

 

192
00:06:20,870 --> 00:06:22,710

 

193
00:06:22,710 --> 00:06:22,720

 

194
00:06:22,720 --> 00:06:23,990


195
00:06:23,990 --> 00:06:26,469

 

196
00:06:26,469 --> 00:06:29,590

 

197
00:06:29,590 --> 00:06:31,270

 

198
00:06:31,270 --> 00:06:32,629

 

199
00:06:32,629 --> 00:06:35,350

 

200
00:06:35,350 --> 00:06:37,990

 

201
00:06:37,990 --> 00:06:40,469

 

202
00:06:40,469 --> 00:06:41,830

 

203
00:06:41,830 --> 00:06:41,840

 

204
00:06:41,840 --> 00:06:43,029


205
00:06:43,029 --> 00:06:44,870

 

206
00:06:44,870 --> 00:06:46,710

 

207
00:06:46,710 --> 00:06:49,110

 

208
00:06:49,110 --> 00:06:50,230

 

209
00:06:50,230 --> 00:06:52,070

 

210
00:06:52,070 --> 00:06:54,070

 

211
00:06:54,070 --> 00:06:56,390

 

212
00:06:56,390 --> 00:06:59,749

 

213
00:06:59,749 --> 00:07:01,749

 

214
00:07:01,749 --> 00:07:05,270

 

215
00:07:05,270 --> 00:07:05,280

 

216
00:07:05,280 --> 00:07:06,230


217
00:07:06,230 --> 00:07:06,240

 

218
00:07:06,240 --> 00:07:07,189


219
00:07:07,189 --> 00:07:09,990

 

220
00:07:09,990 --> 00:07:11,749

 

221
00:07:11,749 --> 00:07:13,029

 

222
00:07:13,029 --> 00:07:13,039

 

223
00:07:13,039 --> 00:07:13,990


224
00:07:13,990 --> 00:07:15,990

 

225
00:07:15,990 --> 00:07:16,000

 

226
00:07:16,000 --> 00:07:18,150


227
00:07:18,150 --> 00:07:20,230

 

228
00:07:20,230 --> 00:07:22,710

 

229
00:07:22,710 --> 00:07:25,029

 

230
00:07:25,029 --> 00:07:27,589

 

231
00:07:27,589 --> 00:07:30,230

 

232
00:07:30,230 --> 00:07:32,390

 

233
00:07:32,390 --> 00:07:34,390

 

234
00:07:34,390 --> 00:07:36,230

 

235
00:07:36,230 --> 00:07:37,430

 

236
00:07:37,430 --> 00:07:40,150

 

237
00:07:40,150 --> 00:07:43,749

 

238
00:07:43,749 --> 00:07:46,469

 

239
00:07:46,469 --> 00:07:48,790

 

240
00:07:48,790 --> 00:07:50,950

 

241
00:07:50,950 --> 00:07:52,790

 

242
00:07:52,790 --> 00:07:53,830

 

243
00:07:53,830 --> 00:07:55,510

 

244
00:07:55,510 --> 00:07:57,029

 

245
00:07:57,029 --> 00:07:59,029

 

246
00:07:59,029 --> 00:08:01,189

 

247
00:08:01,189 --> 00:08:03,110

 

248
00:08:03,110 --> 00:08:04,950

 

249
00:08:04,950 --> 00:08:07,830

 

250
00:08:07,830 --> 00:08:08,950

 

251
00:08:08,950 --> 00:08:10,309

 

252
00:08:10,309 --> 00:08:12,070

 

253
00:08:12,070 --> 00:08:14,710

 

254
00:08:14,710 --> 00:08:14,720

 

255
00:08:14,720 --> 00:08:15,670


256
00:08:15,670 --> 00:08:17,990

 

257
00:08:17,990 --> 00:08:19,589

 

258
00:08:19,589 --> 00:08:22,230

 

259
00:08:22,230 --> 00:08:24,309

 

260
00:08:24,309 --> 00:08:26,469

 

261
00:08:26,469 --> 00:08:28,710

 

262
00:08:28,710 --> 00:08:30,550

 

263
00:08:30,550 --> 00:08:32,630

 

264
00:08:32,630 --> 00:08:34,709

 

265
00:08:34,709 --> 00:08:34,719

 

266
00:08:34,719 --> 00:08:35,909


267
00:08:35,909 --> 00:08:38,469

 

268
00:08:38,469 --> 00:08:41,029

 

269
00:08:41,029 --> 00:08:43,190

 

270
00:08:43,190 --> 00:08:46,790

 

271
00:08:46,790 --> 00:08:48,310

 

272
00:08:48,310 --> 00:08:50,949

 

273
00:08:50,949 --> 00:08:52,870

 

274
00:08:52,870 --> 00:08:55,910

 

275
00:08:55,910 --> 00:08:59,509

 

276
00:08:59,509 --> 00:09:01,430

 

277
00:09:01,430 --> 00:09:03,990

 

278
00:09:03,990 --> 00:09:04,000

 

279
00:09:04,000 --> 00:09:05,590


280
00:09:05,590 --> 00:09:09,110

 

281
00:09:09,110 --> 00:09:11,509

 

282
00:09:11,509 --> 00:09:14,389

 

283
00:09:14,389 --> 00:09:16,790

 

284
00:09:16,790 --> 00:09:19,509

 

285
00:09:19,509 --> 00:09:21,350

 

286
00:09:21,350 --> 00:09:24,070

 

287
00:09:24,070 --> 00:09:26,230

 

288
00:09:26,230 --> 00:09:28,949

 

289
00:09:28,949 --> 00:09:31,430

 

290
00:09:31,430 --> 00:09:33,829

 

291
00:09:33,829 --> 00:09:35,590

 

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

 

293
00:09:37,590 --> 00:09:39,509

 

294
00:09:39,509 --> 00:09:41,030

 

295
00:09:41,030 --> 00:09:41,040

 

296
00:09:41,040 --> 00:09:46,070


297
00:09:46,070 --> 00:09:46,080

 

298
00:09:46,080 --> 00:09:46,949


299
00:09:46,949 --> 00:09:46,959

 

300
00:09:46,959 --> 00:09:51,509


301
00:09:51,509 --> 00:09:54,150

 

302
00:09:54,150 --> 00:09:55,670

 

303
00:09:55,670 --> 00:09:59,269

 

304
00:09:59,269 --> 00:10:01,750

 

305
00:10:01,750 --> 00:10:04,550

 

306
00:10:04,550 --> 00:10:07,910

 

307
00:10:07,910 --> 00:10:10,949

 

308
00:10:10,949 --> 00:10:13,509

 

309
00:10:13,509 --> 00:10:15,509

 

310
00:10:15,509 --> 00:10:15,519

 

311
00:10:15,519 --> 00:10:16,949


312
00:10:16,949 --> 00:10:20,150

 

313
00:10:20,150 --> 00:10:23,910

 

314
00:10:23,910 --> 00:10:25,990

 

315
00:10:25,990 --> 00:10:27,990

 

316
00:10:27,990 --> 00:10:30,150

 

317
00:10:30,150 --> 00:10:33,829

 

318
00:10:33,829 --> 00:10:35,509

 

319
00:10:35,509 --> 00:10:37,590

 

320
00:10:37,590 --> 00:10:40,550

 

321
00:10:40,550 --> 00:10:42,790

 

322
00:10:42,790 --> 00:10:46,230

 

323
00:10:46,230 --> 00:10:49,110

 

324
00:10:49,110 --> 00:10:51,030

 

325
00:10:51,030 --> 00:10:51,040

 

326
00:10:51,040 --> 00:10:52,230


327
00:10:52,230 --> 00:10:53,430

 

328
00:10:53,430 --> 00:10:55,670

 

329
00:10:55,670 --> 00:10:58,389

 

330
00:10:58,389 --> 00:10:59,910

 

331
00:10:59,910 --> 00:10:59,920

 

332
00:10:59,920 --> 00:11:02,710


333
00:11:02,710 --> 00:11:05,430

 

334
00:11:05,430 --> 00:11:07,269

 

335
00:11:07,269 --> 00:11:07,279

 

336
00:11:07,279 --> 00:11:09,030


337
00:11:09,030 --> 00:11:11,990

 

338
00:11:11,990 --> 00:11:13,670

 

339
00:11:13,670 --> 00:11:15,590

 

340
00:11:15,590 --> 00:11:17,670

 

341
00:11:17,670 --> 00:11:19,670

 

342
00:11:19,670 --> 00:11:22,230

 

343
00:11:22,230 --> 00:11:22,240

 

344
00:11:22,240 --> 00:11:23,910


345
00:11:23,910 --> 00:11:23,920

 

346
00:11:23,920 --> 00:11:25,110


347
00:11:25,110 --> 00:11:27,829

 

348
00:11:27,829 --> 00:11:29,910

 

349
00:11:29,910 --> 00:11:29,920

 

350
00:11:29,920 --> 00:11:31,829


351
00:11:31,829 --> 00:11:31,839

 

352
00:11:31,839 --> 00:11:32,710


353
00:11:32,710 --> 00:11:32,720

 

354
00:11:32,720 --> 00:11:34,389


355
00:11:34,389 --> 00:11:37,269

 

356
00:11:37,269 --> 00:11:38,110

 

357
00:11:38,110 --> 00:11:41,269

 

358
00:11:41,269 --> 00:11:41,279

 

359
00:11:41,279 --> 00:11:42,470


360
00:11:42,470 --> 00:11:44,470

 

361
00:11:44,470 --> 00:11:44,480

 

362
00:11:44,480 --> 00:11:45,590


363
00:11:45,590 --> 00:11:45,600

 

364
00:11:45,600 --> 00:11:46,630


365
00:11:46,630 --> 00:11:49,350

 

366
00:11:49,350 --> 00:11:49,360

 

367
00:11:49,360 --> 00:11:51,990


368
00:11:51,990 --> 00:11:54,870

 

369
00:11:54,870 --> 00:11:57,829

 

370
00:11:57,829 --> 00:11:57,839

 

371
00:11:57,839 --> 00:11:59,350


372
00:11:59,350 --> 00:12:01,110

 

373
00:12:01,110 --> 00:12:03,750

 

374
00:12:03,750 --> 00:12:03,760

 

375
00:12:03,760 --> 00:12:04,790


376
00:12:04,790 --> 00:12:04,800

 

377
00:12:04,800 --> 00:12:06,150


378
00:12:06,150 --> 00:12:08,389

 

379
00:12:08,389 --> 00:12:11,670

 

380
00:12:11,670 --> 00:12:12,949

 

381
00:12:12,949 --> 00:12:15,590

 

382
00:12:15,590 --> 00:12:18,069

 

383
00:12:18,069 --> 00:12:20,949

 

384
00:12:20,949 --> 00:12:23,269

 

385
00:12:23,269 --> 00:12:25,509

 

386
00:12:25,509 --> 00:12:25,519

 

387
00:12:25,519 --> 00:12:27,829


388
00:12:27,829 --> 00:12:27,839

 

389
00:12:27,839 --> 00:12:29,030


390
00:12:29,030 --> 00:12:29,040

 

391
00:12:29,040 --> 00:12:30,470


392
00:12:30,470 --> 00:12:32,870

 

393
00:12:32,870 --> 00:12:35,030

 

394
00:12:35,030 --> 00:12:37,350

 

395
00:12:37,350 --> 00:12:38,870

 

396
00:12:38,870 --> 00:12:40,310

 

397
00:12:40,310 --> 00:12:41,509

 

398
00:12:41,509 --> 00:12:43,190

 

399
00:12:43,190 --> 00:12:45,190

 

400
00:12:45,190 --> 00:12:48,949

 

401
00:12:48,949 --> 00:12:52,870

 

402
00:12:52,870 --> 00:12:55,829

 

403
00:12:55,829 --> 00:12:57,269

 

404
00:12:57,269 --> 00:12:59,670

 

405
00:12:59,670 --> 00:13:02,629

 

406
00:13:02,629 --> 00:13:04,150

 

407
00:13:04,150 --> 00:13:07,269

 

408
00:13:07,269 --> 00:13:09,350

 

409
00:13:09,350 --> 00:13:11,430

 

410
00:13:11,430 --> 00:13:14,310

 

411
00:13:14,310 --> 00:13:16,550

 

412
00:13:16,550 --> 00:13:18,310

 

413
00:13:18,310 --> 00:13:20,949

 

414
00:13:20,949 --> 00:13:22,629

 

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

 

416
00:13:24,310 --> 00:13:26,870

 

417
00:13:26,870 --> 00:13:28,069

 

418
00:13:28,069 --> 00:13:29,910

 

419
00:13:29,910 --> 00:13:29,920

 

420
00:13:29,920 --> 00:13:30,790


421
00:13:30,790 --> 00:13:32,550

 

422
00:13:32,550 --> 00:13:35,750

 

423
00:13:35,750 --> 00:13:37,509

 

424
00:13:37,509 --> 00:13:39,430

 

425
00:13:39,430 --> 00:13:41,189

 

426
00:13:41,189 --> 00:13:41,199

 

427
00:13:41,199 --> 00:13:42,389


428
00:13:42,389 --> 00:13:42,399

 

429
00:13:42,399 --> 00:13:44,230


430
00:13:44,230 --> 00:13:44,240

 

431
00:13:44,240 --> 00:13:45,030


432
00:13:45,030 --> 00:13:45,040

 

433
00:13:45,040 --> 00:13:46,150


434
00:13:46,150 --> 00:13:47,910

 

435
00:13:47,910 --> 00:13:49,750

 

436
00:13:49,750 --> 00:13:51,110

 

437
00:13:51,110 --> 00:13:52,629

 

438
00:13:52,629 --> 00:13:52,639

 

439
00:13:52,639 --> 00:13:53,350


440
00:13:53,350 --> 00:13:55,269

 

441
00:13:55,269 --> 00:13:58,710

 

442
00:13:58,710 --> 00:13:59,910

 

443
00:13:59,910 --> 00:14:04,150

 

444
00:14:04,150 --> 00:14:05,910

 

445
00:14:05,910 --> 00:14:08,230

 

446
00:14:08,230 --> 00:14:10,230

 

447
00:14:10,230 --> 00:14:12,470

 

448
00:14:12,470 --> 00:14:14,389

 

449
00:14:14,389 --> 00:14:15,990

 

450
00:14:15,990 --> 00:14:19,110

 

451
00:14:19,110 --> 00:14:20,870

 

452
00:14:20,870 --> 00:14:22,230

 

453
00:14:22,230 --> 00:14:24,310

 

454
00:14:24,310 --> 00:14:27,509

 

455
00:14:27,509 --> 00:14:31,430

 

456
00:14:31,430 --> 00:14:35,110

 

457
00:14:35,110 --> 00:14:35,120

 

458
00:14:35,120 --> 00:14:37,269


459
00:14:37,269 --> 00:14:39,269

 

460
00:14:39,269 --> 00:14:41,509

 

461
00:14:41,509 --> 00:14:43,350

 

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

 

463
00:14:44,550 --> 00:14:46,870

 

464
00:14:46,870 --> 00:14:49,110

 

465
00:14:49,110 --> 00:14:51,269

 

466
00:14:51,269 --> 00:14:52,870

 

467
00:14:52,870 --> 00:14:55,110

 

468
00:14:55,110 --> 00:14:57,990

 

469
00:14:57,990 --> 00:14:58,949

 

470
00:14:58,949 --> 00:15:00,550

 

471
00:15:00,550 --> 00:15:03,430

 

472
00:15:03,430 --> 00:15:05,829

 

473
00:15:05,829 --> 00:15:07,670

 

474
00:15:07,670 --> 00:15:09,509

 

475
00:15:09,509 --> 00:15:10,710

 

476
00:15:10,710 --> 00:15:13,110

 

477
00:15:13,110 --> 00:15:15,829

 

478
00:15:15,829 --> 00:15:18,150

 

479
00:15:18,150 --> 00:15:22,150

 

480
00:15:22,150 --> 00:15:22,160

 

481
00:15:22,160 --> 00:15:23,269


482
00:15:23,269 --> 00:15:24,150

 

483
00:15:24,150 --> 00:15:26,389

 

484
00:15:26,389 --> 00:15:26,399

 

485
00:15:26,399 --> 00:15:27,350


486
00:15:27,350 --> 00:15:27,360

 

487
00:15:27,360 --> 00:15:28,470


488
00:15:28,470 --> 00:15:33,670

 

489
00:15:33,670 --> 00:15:35,749

 

490
00:15:35,749 --> 00:15:37,509

 

491
00:15:37,509 --> 00:15:39,990

 

492
00:15:39,990 --> 00:15:40,000

 

493
00:15:40,000 --> 00:15:41,749


494
00:15:41,749 --> 00:15:44,470

 

495
00:15:44,470 --> 00:15:47,110

 

496
00:15:47,110 --> 00:15:49,590

 

497
00:15:49,590 --> 00:15:51,749

 

498
00:15:51,749 --> 00:15:53,509

 

499
00:15:53,509 --> 00:15:55,590

 

500
00:15:55,590 --> 00:15:57,670

 

501
00:15:57,670 --> 00:16:00,150

 

502
00:16:00,150 --> 00:16:01,829

 

503
00:16:01,829 --> 00:16:04,389

 

504
00:16:04,389 --> 00:16:06,389

 

505
00:16:06,389 --> 00:16:08,550

 

506
00:16:08,550 --> 00:16:11,829

 

507
00:16:11,829 --> 00:16:13,269

 

508
00:16:13,269 --> 00:16:16,069

 

509
00:16:16,069 --> 00:16:18,069

 

510
00:16:18,069 --> 00:16:21,430

 

511
00:16:21,430 --> 00:16:23,590

 

512
00:16:23,590 --> 00:16:23,600

 

513
00:16:23,600 --> 00:16:25,189


514
00:16:25,189 --> 00:16:26,710

 

515
00:16:26,710 --> 00:16:28,550

 

516
00:16:28,550 --> 00:16:30,069

 

517
00:16:30,069 --> 00:16:32,949

 

518
00:16:32,949 --> 00:16:34,310

 

519
00:16:34,310 --> 00:16:35,910

 

520
00:16:35,910 --> 00:16:38,230

 

521
00:16:38,230 --> 00:16:40,389

 

522
00:16:40,389 --> 00:16:42,310

 

523
00:16:42,310 --> 00:16:44,949

 

524
00:16:44,949 --> 00:16:44,959

 

525
00:16:44,959 --> 00:16:46,069


526
00:16:46,069 --> 00:16:47,670

 

527
00:16:47,670 --> 00:16:49,269

 

528
00:16:49,269 --> 00:16:51,670

 

529
00:16:51,670 --> 00:16:53,189

 

530
00:16:53,189 --> 00:16:54,870

 

531
00:16:54,870 --> 00:16:57,670

 

532
00:16:57,670 --> 00:16:59,509

 

533
00:16:59,509 --> 00:17:01,350

 

534
00:17:01,350 --> 00:17:03,829

 

535
00:17:03,829 --> 00:17:07,429

 

536
00:17:07,429 --> 00:17:09,189

 

537
00:17:09,189 --> 00:17:12,549

 

538
00:17:12,549 --> 00:17:14,309

 

539
00:17:14,309 --> 00:17:16,150

 

540
00:17:16,150 --> 00:17:18,150

 

541
00:17:18,150 --> 00:17:20,309

 

542
00:17:20,309 --> 00:17:21,350

 

543
00:17:21,350 --> 00:17:23,429

 

544
00:17:23,429 --> 00:17:25,110

 

545
00:17:25,110 --> 00:17:26,390

 

546
00:17:26,390 --> 00:17:26,400

 

547
00:17:26,400 --> 00:17:27,429


548
00:17:27,429 --> 00:17:28,950

 

549
00:17:28,950 --> 00:17:31,190

 

550
00:17:31,190 --> 00:17:33,350

 

551
00:17:33,350 --> 00:17:37,110

 

552
00:17:37,110 --> 00:17:38,950

 

553
00:17:38,950 --> 00:17:40,630

 

554
00:17:40,630 --> 00:17:42,630

 

555
00:17:42,630 --> 00:17:44,390

 

556
00:17:44,390 --> 00:17:46,630

 

557
00:17:46,630 --> 00:17:50,950

 

558
00:17:50,950 --> 00:17:52,870

 

559
00:17:52,870 --> 00:17:52,880

 

560
00:17:52,880 --> 00:17:54,310


561
00:17:54,310 --> 00:17:56,870

 

562
00:17:56,870 --> 00:18:00,549

 

563
00:18:00,549 --> 00:18:02,549

 

564
00:18:02,549 --> 00:18:04,789

 

565
00:18:04,789 --> 00:18:08,549

 

566
00:18:08,549 --> 00:18:11,750

 

567
00:18:11,750 --> 00:18:13,990

 

568
00:18:13,990 --> 00:18:16,230

 

569
00:18:16,230 --> 00:18:17,350

 

570
00:18:17,350 --> 00:18:19,270

 

571
00:18:19,270 --> 00:18:21,350

 

572
00:18:21,350 --> 00:18:23,830

 

573
00:18:23,830 --> 00:18:25,830

 

574
00:18:25,830 --> 00:18:28,470

 

575
00:18:28,470 --> 00:18:30,310

 

576
00:18:30,310 --> 00:18:30,320

 

577
00:18:30,320 --> 00:18:32,630


578
00:18:32,630 --> 00:18:33,990

 

579
00:18:33,990 --> 00:18:35,830

 

580
00:18:35,830 --> 00:18:38,470

 

581
00:18:38,470 --> 00:18:40,230

 

582
00:18:40,230 --> 00:18:43,430

 

583
00:18:43,430 --> 00:18:45,669

 

584
00:18:45,669 --> 00:18:47,909

 

585
00:18:47,909 --> 00:18:49,430

 

586
00:18:49,430 --> 00:18:50,549

 

587
00:18:50,549 --> 00:18:50,559

 

588
00:18:50,559 --> 00:18:51,590


589
00:18:51,590 --> 00:18:54,789

 

590
00:18:54,789 --> 00:18:58,630

 

591
00:18:58,630 --> 00:18:58,640

 

592
00:18:58,640 --> 00:19:00,870


593
00:19:00,870 --> 00:19:00,880

 

594
00:19:00,880 --> 00:19:03,830


595
00:19:03,830 --> 00:19:03,840

 

596
00:19:03,840 --> 00:19:05,029


597
00:19:05,029 --> 00:19:07,029

 

598
00:19:07,029 --> 00:19:09,669

 

599
00:19:09,669 --> 00:19:09,679

 

600
00:19:09,679 --> 00:19:10,390


601
00:19:10,390 --> 00:19:11,909

 

602
00:19:11,909 --> 00:19:11,919

 

603
00:19:11,919 --> 00:19:13,190


604
00:19:13,190 --> 00:19:15,270

 

605
00:19:15,270 --> 00:19:15,280

 

606
00:19:15,280 --> 00:19:16,870


607
00:19:16,870 --> 00:19:19,830

 

608
00:19:19,830 --> 00:19:23,029

 

609
00:19:23,029 --> 00:19:25,510

 

610
00:19:25,510 --> 00:19:25,520

 

611
00:19:25,520 --> 00:19:26,549


612
00:19:26,549 --> 00:19:29,190

 

613
00:19:29,190 --> 00:19:31,110

 

614
00:19:31,110 --> 00:19:33,350

 

615
00:19:33,350 --> 00:19:33,360

 

616
00:19:33,360 --> 00:19:34,549


617
00:19:34,549 --> 00:19:36,630

 

618
00:19:36,630 --> 00:19:39,510

 

619
00:19:39,510 --> 00:19:40,710

 

620
00:19:40,710 --> 00:19:41,510

 

621
00:19:41,510 --> 00:19:43,350

 

622
00:19:43,350 --> 00:19:45,270

 

623
00:19:45,270 --> 00:19:47,350

 

624
00:19:47,350 --> 00:19:49,270

 

625
00:19:49,270 --> 00:19:51,830

 

626
00:19:51,830 --> 00:19:53,909

 

627
00:19:53,909 --> 00:19:57,029

 

628
00:19:57,029 --> 00:19:59,830

 

629
00:19:59,830 --> 00:20:03,430

 

630
00:20:03,430 --> 00:20:05,590

 

631
00:20:05,590 --> 00:20:07,029

 

632
00:20:07,029 --> 00:20:09,590

 

633
00:20:09,590 --> 00:20:11,029

 

634
00:20:11,029 --> 00:20:13,029

 

635
00:20:13,029 --> 00:20:14,549

 

636
00:20:14,549 --> 00:20:17,430

 

637
00:20:17,430 --> 00:20:19,830

 

638
00:20:19,830 --> 00:20:21,750

 

639
00:20:21,750 --> 00:20:25,990

 

640
00:20:25,990 --> 00:20:28,149

 

641
00:20:28,149 --> 00:20:30,390

 

642
00:20:30,390 --> 00:20:35,510

 

643
00:20:35,510 --> 00:20:35,520

 

644
00:20:35,520 --> 00:20:36,549


645
00:20:36,549 --> 00:20:38,950

 

646
00:20:38,950 --> 00:20:41,029

 

647
00:20:41,029 --> 00:20:42,789

 

648
00:20:42,789 --> 00:20:42,799

 

649
00:20:42,799 --> 00:20:43,750


650
00:20:43,750 --> 00:20:45,590

 

651
00:20:45,590 --> 00:20:48,549

 

652
00:20:48,549 --> 00:20:50,390

 

653
00:20:50,390 --> 00:20:52,789

 

654
00:20:52,789 --> 00:20:57,190

 

655
00:20:57,190 --> 00:20:59,029

 

656
00:20:59,029 --> 00:21:00,710

 

657
00:21:00,710 --> 00:21:02,470

 

658
00:21:02,470 --> 00:21:02,480

 

659
00:21:02,480 --> 00:21:03,350


660
00:21:03,350 --> 00:21:05,270

 

661
00:21:05,270 --> 00:21:06,870

 

662
00:21:06,870 --> 00:21:08,710

 

663
00:21:08,710 --> 00:21:10,310

 

664
00:21:10,310 --> 00:21:11,430

 

665
00:21:11,430 --> 00:21:13,590

 

666
00:21:13,590 --> 00:21:15,350

 

667
00:21:15,350 --> 00:21:17,430

 

668
00:21:17,430 --> 00:21:18,710

 

669
00:21:18,710 --> 00:21:20,630

 

670
00:21:20,630 --> 00:21:22,310

 

671
00:21:22,310 --> 00:21:24,710

 

672
00:21:24,710 --> 00:21:27,190

 

673
00:21:27,190 --> 00:21:27,200

 

674
00:21:27,200 --> 00:21:28,230


675
00:21:28,230 --> 00:21:29,830

 

676
00:21:29,830 --> 00:21:31,909

 

677
00:21:31,909 --> 00:21:34,549

 

678
00:21:34,549 --> 00:21:38,630

 

679
00:21:38,630 --> 00:21:41,590

 

680
00:21:41,590 --> 00:21:41,600

 

681
00:21:41,600 --> 00:21:43,029


682
00:21:43,029 --> 00:21:44,950

 

683
00:21:44,950 --> 00:21:47,510

 

684
00:21:47,510 --> 00:21:49,990

 

685
00:21:49,990 --> 00:21:51,430

 

686
00:21:51,430 --> 00:21:53,110

 

687
00:21:53,110 --> 00:21:54,870

 

688
00:21:54,870 --> 00:21:56,230

 

689
00:21:56,230 --> 00:21:58,710

 

690
00:21:58,710 --> 00:22:00,310

 

691
00:22:00,310 --> 00:22:00,320

 

692
00:22:00,320 --> 00:22:01,350


693
00:22:01,350 --> 00:22:03,909

 

694
00:22:03,909 --> 00:22:06,710

 

695
00:22:06,710 --> 00:22:07,750

 

696
00:22:07,750 --> 00:22:11,669

 

697
00:22:11,669 --> 00:22:14,230

 

698
00:22:14,230 --> 00:22:18,230

 

699
00:22:18,230 --> 00:22:20,789

 

700
00:22:20,789 --> 00:22:22,230

 

701
00:22:22,230 --> 00:22:23,830

 

702
00:22:23,830 --> 00:22:24,830

 

703
00:22:24,830 --> 00:22:27,430

 

704
00:22:27,430 --> 00:22:30,310

 

705
00:22:30,310 --> 00:22:34,070

 

706
00:22:34,070 --> 00:22:35,669

 

707
00:22:35,669 --> 00:22:37,830

 

708
00:22:37,830 --> 00:22:39,750

 

709
00:22:39,750 --> 00:22:42,710

 

710
00:22:42,710 --> 00:22:42,720

 

711
00:22:42,720 --> 00:22:43,909


712
00:22:43,909 --> 00:22:45,750

 

713
00:22:45,750 --> 00:22:47,750

 

714
00:22:47,750 --> 00:22:50,070

 

715
00:22:50,070 --> 00:22:53,190

 

716
00:22:53,190 --> 00:22:53,200

 

717
00:22:53,200 --> 00:22:54,870


718
00:22:54,870 --> 00:22:54,880

 

719
00:22:54,880 --> 00:22:55,750


720
00:22:55,750 --> 00:22:57,350

 

721
00:22:57,350 --> 00:22:58,870

 

722
00:22:58,870 --> 00:23:01,990

 

723
00:23:01,990 --> 00:23:02,000

 

724
00:23:02,000 --> 00:23:03,110


725
00:23:03,110 --> 00:23:03,120

 

726
00:23:03,120 --> 00:23:06,950


727
00:23:06,950 --> 00:23:10,630

 

728
00:23:10,630 --> 00:23:12,870

 

729
00:23:12,870 --> 00:23:14,549

 

730
00:23:14,549 --> 00:23:17,190

 

731
00:23:17,190 --> 00:23:19,510

 

732
00:23:19,510 --> 00:23:21,590

 

733
00:23:21,590 --> 00:23:23,029

 

734
00:23:23,029 --> 00:23:23,909

 

735
00:23:23,909 --> 00:23:26,070

 

736
00:23:26,070 --> 00:23:28,549

 

737
00:23:28,549 --> 00:23:30,950

 

738
00:23:30,950 --> 00:23:33,590

 

739
00:23:33,590 --> 00:23:35,750

 

740
00:23:35,750 --> 00:23:39,029

 

741
00:23:39,029 --> 00:23:40,710

 

742
00:23:40,710 --> 00:23:43,830

 

743
00:23:43,830 --> 00:23:45,669

 

744
00:23:45,669 --> 00:23:48,310

 

745
00:23:48,310 --> 00:23:50,710

 

746
00:23:50,710 --> 00:23:52,149

 

747
00:23:52,149 --> 00:23:54,789

 

748
00:23:54,789 --> 00:23:56,070

 

749
00:23:56,070 --> 00:23:58,230

 

750
00:23:58,230 --> 00:24:00,470

 

751
00:24:00,470 --> 00:24:02,310

 

752
00:24:02,310 --> 00:24:04,070

 

753
00:24:04,070 --> 00:24:06,230

 

754
00:24:06,230 --> 00:24:07,590

 

755
00:24:07,590 --> 00:24:10,310

 

756
00:24:10,310 --> 00:24:12,470

 

757
00:24:12,470 --> 00:24:14,789

 

758
00:24:14,789 --> 00:24:14,799

 

759
00:24:14,799 --> 00:24:16,310


760
00:24:16,310 --> 00:24:18,390

 

761
00:24:18,390 --> 00:24:18,400

 

762
00:24:18,400 --> 00:24:20,870


763
00:24:20,870 --> 00:24:20,880

 

764
00:24:20,880 --> 00:24:21,669


765
00:24:21,669 --> 00:24:21,679

 

766
00:24:21,679 --> 00:24:23,510


767
00:24:23,510 --> 00:24:25,590

 

768
00:24:25,590 --> 00:24:27,110

 

769
00:24:27,110 --> 00:24:30,549

 

770
00:24:30,549 --> 00:24:31,590

 

771
00:24:31,590 --> 00:24:32,390

 

772
00:24:32,390 --> 00:24:34,149

 

773
00:24:34,149 --> 00:24:36,149

 

774
00:24:36,149 --> 00:24:38,630

 

775
00:24:38,630 --> 00:24:40,470

 

776
00:24:40,470 --> 00:24:43,590

 

777
00:24:43,590 --> 00:24:43,600

 

778
00:24:43,600 --> 00:24:45,029


779
00:24:45,029 --> 00:24:48,310

 

780
00:24:48,310 --> 00:24:50,630

 

781
00:24:50,630 --> 00:24:50,640

 

782
00:24:50,640 --> 00:24:51,669


783
00:24:51,669 --> 00:24:53,990

 

784
00:24:53,990 --> 00:24:57,269

 

785
00:24:57,269 --> 00:24:59,110

 

786
00:24:59,110 --> 00:25:01,350

 

787
00:25:01,350 --> 00:25:01,360

 

788
00:25:01,360 --> 00:25:02,470


789
00:25:02,470 --> 00:25:04,230

 

790
00:25:04,230 --> 00:25:05,750

 

791
00:25:05,750 --> 00:25:07,669

 

792
00:25:07,669 --> 00:25:10,149

 

793
00:25:10,149 --> 00:25:12,470

 

794
00:25:12,470 --> 00:25:15,110

 

795
00:25:15,110 --> 00:25:17,669

 

796
00:25:17,669 --> 00:25:20,789

 

797
00:25:20,789 --> 00:25:23,350

 

798
00:25:23,350 --> 00:25:25,909

 

799
00:25:25,909 --> 00:25:27,750

 

800
00:25:27,750 --> 00:25:29,269

 

801
00:25:29,269 --> 00:25:30,789

 

802
00:25:30,789 --> 00:25:30,799

 

803
00:25:30,799 --> 00:25:32,710


804
00:25:32,710 --> 00:25:35,510

 

805
00:25:35,510 --> 00:25:37,029

 

806
00:25:37,029 --> 00:25:38,870

 

807
00:25:38,870 --> 00:25:40,549

 

808
00:25:40,549 --> 00:25:42,789

 

809
00:25:42,789 --> 00:25:45,350

 

810
00:25:45,350 --> 00:25:47,430

 

811
00:25:47,430 --> 00:25:49,110

 

812
00:25:49,110 --> 00:25:51,990

 

813
00:25:51,990 --> 00:25:52,000

 

814
00:25:52,000 --> 00:25:54,149


815
00:25:54,149 --> 00:25:54,159

 

816
00:25:54,159 --> 00:25:54,950


817
00:25:54,950 --> 00:25:54,960

 

818
00:25:54,960 --> 00:25:58,870


819
00:25:58,870 --> 00:26:01,669

 

820
00:26:01,669 --> 00:26:03,669

 

821
00:26:03,669 --> 00:26:05,269

 

822
00:26:05,269 --> 00:26:07,190

 

823
00:26:07,190 --> 00:26:08,710

 

824
00:26:08,710 --> 00:26:10,870

 

825
00:26:10,870 --> 00:26:12,789

 

826
00:26:12,789 --> 00:26:15,269

 

827
00:26:15,269 --> 00:26:17,510

 

828
00:26:17,510 --> 00:26:19,909

 

829
00:26:19,909 --> 00:26:22,710

 

830
00:26:22,710 --> 00:26:26,390

 

831
00:26:26,390 --> 00:26:29,669

 

832
00:26:29,669 --> 00:26:29,679

 

833
00:26:29,679 --> 00:26:32,310


834
00:26:32,310 --> 00:26:34,549

 

835
00:26:34,549 --> 00:26:37,430

 

836
00:26:37,430 --> 00:26:39,909

 

837
00:26:39,909 --> 00:26:39,919

 

838
00:26:39,919 --> 00:26:44,950


839
00:26:44,950 --> 00:26:47,190

 

840
00:26:47,190 --> 00:26:48,549

 

841
00:26:48,549 --> 00:26:50,230

 

842
00:26:50,230 --> 00:26:51,909

 

843
00:26:51,909 --> 00:26:54,149

 

844
00:26:54,149 --> 00:26:56,070

 

845
00:26:56,070 --> 00:26:59,430

 

846
00:26:59,430 --> 00:27:01,510

 

847
00:27:01,510 --> 00:27:04,070

 

848
00:27:04,070 --> 00:27:05,750

 

849
00:27:05,750 --> 00:27:07,510

 

850
00:27:07,510 --> 00:27:09,909

 

851
00:27:09,909 --> 00:27:12,070

 

852
00:27:12,070 --> 00:27:15,430

 

853
00:27:15,430 --> 00:27:17,990

 

854
00:27:17,990 --> 00:27:19,510

 

855
00:27:19,510 --> 00:27:21,269

 

856
00:27:21,269 --> 00:27:23,750

 

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

 

858
00:27:25,510 --> 00:27:29,269

 

859
00:27:29,269 --> 00:27:31,830

 

860
00:27:31,830 --> 00:27:35,750

 

861
00:27:35,750 --> 00:27:37,990

 

862
00:27:37,990 --> 00:27:40,230

 

863
00:27:40,230 --> 00:27:40,240

 

864
00:27:40,240 --> 00:27:41,350


865
00:27:41,350 --> 00:27:43,430

 

866
00:27:43,430 --> 00:27:46,549

 

867
00:27:46,549 --> 00:27:48,149

 

868
00:27:48,149 --> 00:27:50,950

 

869
00:27:50,950 --> 00:27:54,230

 

870
00:27:54,230 --> 00:27:56,470

 

871
00:27:56,470 --> 00:27:58,310

 

872
00:27:58,310 --> 00:27:59,750

 

873
00:27:59,750 --> 00:27:59,760

 

874
00:27:59,760 --> 00:28:01,110


875
00:28:01,110 --> 00:28:03,269

 

876
00:28:03,269 --> 00:28:04,870

 

877
00:28:04,870 --> 00:28:07,830

 

878
00:28:07,830 --> 00:28:10,389

 

879
00:28:10,389 --> 00:28:11,909

 

880
00:28:11,909 --> 00:28:15,029

 

881
00:28:15,029 --> 00:28:18,070

 

882
00:28:18,070 --> 00:28:18,080

 

883
00:28:18,080 --> 00:28:19,269


884
00:28:19,269 --> 00:28:19,279

 

885
00:28:19,279 --> 00:28:20,389


886
00:28:20,389 --> 00:28:20,399

 

887
00:28:20,399 --> 00:28:21,510


888
00:28:21,510 --> 00:28:21,520

 

889
00:28:21,520 --> 00:28:22,230


890
00:28:22,230 --> 00:28:23,750

 

891
00:28:23,750 --> 00:28:23,760

 

892
00:28:23,760 --> 00:28:24,789


893
00:28:24,789 --> 00:28:26,710

 

894
00:28:26,710 --> 00:28:29,990

 

895
00:28:29,990 --> 00:28:31,430

 

896
00:28:31,430 --> 00:28:31,440

 

897
00:28:31,440 --> 00:28:32,870


898
00:28:32,870 --> 00:28:32,880

 

899
00:28:32,880 --> 00:28:34,950


900
00:28:34,950 --> 00:28:36,389

 

901
00:28:36,389 --> 00:28:37,990

 

902
00:28:37,990 --> 00:28:41,350

 

903
00:28:41,350 --> 00:28:43,590

 

904
00:28:43,590 --> 00:28:45,190

 

905
00:28:45,190 --> 00:28:45,200

 

906
00:28:45,200 --> 00:28:46,230


907
00:28:46,230 --> 00:28:48,710

 

908
00:28:48,710 --> 00:28:51,190

 

909
00:28:51,190 --> 00:28:51,200

 

910
00:28:51,200 --> 00:28:52,549


911
00:28:52,549 --> 00:28:54,230

 

912
00:28:54,230 --> 00:28:54,240

 

913
00:28:54,240 --> 00:28:54,950


914
00:28:54,950 --> 00:28:54,960

 

915
00:28:54,960 --> 00:28:55,990


916
00:28:55,990 --> 00:28:57,909

 

917
00:28:57,909 --> 00:29:00,070

 

918
00:29:00,070 --> 00:29:03,350

 

919
00:29:03,350 --> 00:29:05,269

 

920
00:29:05,269 --> 00:29:07,430

 

921
00:29:07,430 --> 00:29:09,590

 

922
00:29:09,590 --> 00:29:13,750

 

923
00:29:13,750 --> 00:29:16,630

 

924
00:29:16,630 --> 00:29:16,640

 

925
00:29:16,640 --> 00:29:17,510


926
00:29:17,510 --> 00:29:19,430

 

927
00:29:19,430 --> 00:29:19,440

 

928
00:29:19,440 --> 00:29:20,950


929
00:29:20,950 --> 00:29:22,220

 

930
00:29:22,220 --> 00:29:22,230

 

931
00:29:22,230 --> 00:29:23,350


932
00:29:23,350 --> 00:29:26,630

 

933
00:29:26,630 --> 00:29:28,950

 

934
00:29:28,950 --> 00:29:31,430

 

935
00:29:31,430 --> 00:29:36,149

 

936
00:29:36,149 --> 00:29:36,159

 

937
00:29:36,159 --> 00:29:38,710


938
00:29:38,710 --> 00:29:40,389

 

939
00:29:40,389 --> 00:29:43,510

 

940
00:29:43,510 --> 00:29:45,830

 

941
00:29:45,830 --> 00:29:48,470

 

942
00:29:48,470 --> 00:29:51,990

 

943
00:29:51,990 --> 00:29:54,389

 

944
00:29:54,389 --> 00:29:56,710

 

945
00:29:56,710 --> 00:29:56,720

 

946
00:29:56,720 --> 00:29:57,750


947
00:29:57,750 --> 00:29:59,590

 

948
00:29:59,590 --> 00:30:02,149

 

949
00:30:02,149 --> 00:30:02,159

 

950
00:30:02,159 --> 00:30:04,710


951
00:30:04,710 --> 00:30:04,720

 

952
00:30:04,720 --> 00:30:07,510


953
00:30:07,510 --> 00:30:09,590

 

954
00:30:09,590 --> 00:30:09,600

 

955
00:30:09,600 --> 00:30:11,669


956
00:30:11,669 --> 00:30:13,990

 

957
00:30:13,990 --> 00:30:16,389

 

958
00:30:16,389 --> 00:30:17,990

 

959
00:30:17,990 --> 00:30:19,750

 

960
00:30:19,750 --> 00:30:21,269

 

961
00:30:21,269 --> 00:30:21,279

 

962
00:30:21,279 --> 00:30:22,870


963
00:30:22,870 --> 00:30:24,870

 

964
00:30:24,870 --> 00:30:27,190

 

965
00:30:27,190 --> 00:30:29,909

 

966
00:30:29,909 --> 00:30:31,990

 

967
00:30:31,990 --> 00:30:32,000

 

968
00:30:32,000 --> 00:30:33,669


969
00:30:33,669 --> 00:30:36,070

 

970
00:30:36,070 --> 00:30:39,190

 

971
00:30:39,190 --> 00:30:41,190

 

972
00:30:41,190 --> 00:30:43,750

 

973
00:30:43,750 --> 00:30:46,549

 

974
00:30:46,549 --> 00:30:49,430

 

975
00:30:49,430 --> 00:30:49,440

 

976
00:30:49,440 --> 00:30:50,710


977
00:30:50,710 --> 00:30:53,110

 

978
00:30:53,110 --> 00:30:54,310

 

979
00:30:54,310 --> 00:30:56,710

 

980
00:30:56,710 --> 00:31:00,950

 

981
00:31:00,950 --> 00:31:03,350

 

982
00:31:03,350 --> 00:31:05,269

 

983
00:31:05,269 --> 00:31:05,279

 

984
00:31:05,279 --> 00:31:06,470


985
00:31:06,470 --> 00:31:07,430

 

986
00:31:07,430 --> 00:31:09,430

 

987
00:31:09,430 --> 00:31:11,830

 

988
00:31:11,830 --> 00:31:13,110

 

989
00:31:13,110 --> 00:31:13,120

 

990
00:31:13,120 --> 00:31:14,630


991
00:31:14,630 --> 00:31:17,669

 

992
00:31:17,669 --> 00:31:17,679

 

993
00:31:17,679 --> 00:31:18,549


994
00:31:18,549 --> 00:31:18,559

 

995
00:31:18,559 --> 00:31:19,669


996
00:31:19,669 --> 00:31:22,230

 

997
00:31:22,230 --> 00:31:25,269

 

998
00:31:25,269 --> 00:31:26,950

 

999
00:31:26,950 --> 00:31:28,549

 

1000
00:31:28,549 --> 00:31:28,559

 

1001
00:31:28,559 --> 00:31:29,350


1002
00:31:29,350 --> 00:31:32,470

 

1003
00:31:32,470 --> 00:31:35,269

 

1004
00:31:35,269 --> 00:31:36,470

 

1005
00:31:36,470 --> 00:31:36,480

 

1006
00:31:36,480 --> 00:31:37,830


1007
00:31:37,830 --> 00:31:39,830

 

1008
00:31:39,830 --> 00:31:42,310

 

1009
00:31:42,310 --> 00:31:42,320

 

1010
00:31:42,320 --> 00:31:43,590


1011
00:31:43,590 --> 00:31:43,600

 

1012
00:31:43,600 --> 00:31:44,630


1013
00:31:44,630 --> 00:31:47,430

 

1014
00:31:47,430 --> 00:31:49,350

 

1015
00:31:49,350 --> 00:31:51,909

 

1016
00:31:51,909 --> 00:31:54,630

 

1017
00:31:54,630 --> 00:31:57,269

 

1018
00:31:57,269 --> 00:31:58,950

 

1019
00:31:58,950 --> 00:32:01,430

 

1020
00:32:01,430 --> 00:32:02,789

 

1021
00:32:02,789 --> 00:32:04,070

 

1022
00:32:04,070 --> 00:32:04,080

 

1023
00:32:04,080 --> 00:32:06,549


1024
00:32:06,549 --> 00:32:09,669

 

1025
00:32:09,669 --> 00:32:11,110

 

1026
00:32:11,110 --> 00:32:13,350

 

1027
00:32:13,350 --> 00:32:15,750

 

1028
00:32:15,750 --> 00:32:17,750

 

1029
00:32:17,750 --> 00:32:19,430

 

1030
00:32:19,430 --> 00:32:22,470

 

1031
00:32:22,470 --> 00:32:24,149

 

1032
00:32:24,149 --> 00:32:26,230

 

1033
00:32:26,230 --> 00:32:29,110

 

1034
00:32:29,110 --> 00:32:31,190

 

1035
00:32:31,190 --> 00:32:32,470

 

1036
00:32:32,470 --> 00:32:34,389

 

1037
00:32:34,389 --> 00:32:35,990

 

1038
00:32:35,990 --> 00:32:36,000

 

1039
00:32:36,000 --> 00:32:37,350


1040
00:32:37,350 --> 00:32:39,029

 

1041
00:32:39,029 --> 00:32:40,950

 

1042
00:32:40,950 --> 00:32:46,789

 

1043
00:32:46,789 --> 00:32:48,549

 

1044
00:32:48,549 --> 00:32:51,509

 

1045
00:32:51,509 --> 00:32:53,110

 

1046
00:32:53,110 --> 00:32:55,830

 

1047
00:32:55,830 --> 00:32:57,350

 

1048
00:32:57,350 --> 00:32:59,830

 

1049
00:32:59,830 --> 00:33:01,509

 

1050
00:33:01,509 --> 00:33:02,950

 

1051
00:33:02,950 --> 00:33:05,269

 

1052
00:33:05,269 --> 00:33:05,279

 

1053
00:33:05,279 --> 00:33:06,149


1054
00:33:06,149 --> 00:33:08,789

 

1055
00:33:08,789 --> 00:33:10,389

 

1056
00:33:10,389 --> 00:33:12,149

 

1057
00:33:12,149 --> 00:33:15,909

 

1058
00:33:15,909 --> 00:33:18,549

 

1059
00:33:18,549 --> 00:33:20,870

 

1060
00:33:20,870 --> 00:33:25,430

 

1061
00:33:25,430 --> 00:33:26,950

 

1062
00:33:26,950 --> 00:33:29,830

 

1063
00:33:29,830 --> 00:33:32,630

 

1064
00:33:32,630 --> 00:33:35,190

 

1065
00:33:35,190 --> 00:33:37,110

 

1066
00:33:37,110 --> 00:33:40,310

 

1067
00:33:40,310 --> 00:33:40,320

 

1068
00:33:40,320 --> 00:33:41,190


1069
00:33:41,190 --> 00:33:41,200

 

1070
00:33:41,200 --> 00:33:42,870


1071
00:33:42,870 --> 00:33:46,470

 

1072
00:33:46,470 --> 00:33:48,789

 

1073
00:33:48,789 --> 00:33:51,509

 

1074
00:33:51,509 --> 00:33:51,519

 

1075
00:33:51,519 --> 00:33:52,950


1076
00:33:52,950 --> 00:33:55,269

 

1077
00:33:55,269 --> 00:33:57,830

 

1078
00:33:57,830 --> 00:33:59,590

 

1079
00:33:59,590 --> 00:34:01,669

 

1080
00:34:01,669 --> 00:34:03,110

 

1081
00:34:03,110 --> 00:34:03,120

 

1082
00:34:03,120 --> 00:34:04,070


1083
00:34:04,070 --> 00:34:05,909

 

1084
00:34:05,909 --> 00:34:07,990

 

1085
00:34:07,990 --> 00:34:09,669

 

1086
00:34:09,669 --> 00:34:11,990

 

1087
00:34:11,990 --> 00:34:13,669

 

1088
00:34:13,669 --> 00:34:16,149

 

1089
00:34:16,149 --> 00:34:18,790

 

1090
00:34:18,790 --> 00:34:20,389

 

1091
00:34:20,389 --> 00:34:20,399

 

1092
00:34:20,399 --> 00:34:21,589


1093
00:34:21,589 --> 00:34:23,349

 

1094
00:34:23,349 --> 00:34:25,349

 

1095
00:34:25,349 --> 00:34:27,030

 

1096
00:34:27,030 --> 00:34:29,829

 

1097
00:34:29,829 --> 00:34:31,909

 

1098
00:34:31,909 --> 00:34:34,790

 

1099
00:34:34,790 --> 00:34:36,230

 

1100
00:34:36,230 --> 00:34:38,550

 

1101
00:34:38,550 --> 00:34:39,909

 

1102
00:34:39,909 --> 00:34:42,790

 

1103
00:34:42,790 --> 00:34:45,510

 

1104
00:34:45,510 --> 00:34:47,990

 

1105
00:34:47,990 --> 00:34:50,710

 

1106
00:34:50,710 --> 00:34:54,389

 

1107
00:34:54,389 --> 00:34:56,710

 

1108
00:34:56,710 --> 00:34:58,470

 

1109
00:34:58,470 --> 00:34:58,480

 

1110
00:34:58,480 --> 00:35:00,829


1111
00:35:00,829 --> 00:35:00,839

 

1112
00:35:00,839 --> 00:35:02,630


1113
00:35:02,630 --> 00:35:04,870

 

1114
00:35:04,870 --> 00:35:07,510

 

1115
00:35:07,510 --> 00:35:09,990

 

1116
00:35:09,990 --> 00:35:10,000

 

1117
00:35:10,000 --> 00:35:14,150


1118
00:35:14,150 --> 00:35:15,349

 

1119
00:35:15,349 --> 00:35:16,950

 

1120
00:35:16,950 --> 00:35:19,670

 

1121
00:35:19,670 --> 00:35:19,680

 

1122
00:35:19,680 --> 00:35:20,710


1123
00:35:20,710 --> 00:35:23,910

 

1124
00:35:23,910 --> 00:35:26,950

 

1125
00:35:26,950 --> 00:35:26,960

 

1126
00:35:26,960 --> 00:35:29,270


1127
00:35:29,270 --> 00:35:30,950

 

1128
00:35:30,950 --> 00:35:30,960

 

1129
00:35:30,960 --> 00:35:32,390


1130
00:35:32,390 --> 00:35:32,400

 

1131
00:35:32,400 --> 00:35:34,150


1132
00:35:34,150 --> 00:35:34,160

 

1133
00:35:34,160 --> 00:35:36,230


1134
00:35:36,230 --> 00:35:38,069

 

1135
00:35:38,069 --> 00:35:40,710

 

1136
00:35:40,710 --> 00:35:40,720

 

1137
00:35:40,720 --> 00:35:43,190


1138
00:35:43,190 --> 00:35:46,310

 

1139
00:35:46,310 --> 00:35:48,870

 

1140
00:35:48,870 --> 00:35:52,390

 

1141
00:35:52,390 --> 00:35:55,670

 

1142
00:35:55,670 --> 00:35:58,150

 

1143
00:35:58,150 --> 00:36:00,310

 

1144
00:36:00,310 --> 00:36:02,470

 

1145
00:36:02,470 --> 00:36:02,480

 

1146
00:36:02,480 --> 00:36:03,349


1147
00:36:03,349 --> 00:36:04,950

 

1148
00:36:04,950 --> 00:36:06,870

 

1149
00:36:06,870 --> 00:36:08,550

 

1150
00:36:08,550 --> 00:36:11,589

 

1151
00:36:11,589 --> 00:36:15,030

 

1152
00:36:15,030 --> 00:36:17,990

 

1153
00:36:17,990 --> 00:36:19,670

 

1154
00:36:19,670 --> 00:36:22,069

 

1155
00:36:22,069 --> 00:36:23,750

 

1156
00:36:23,750 --> 00:36:25,510

 

1157
00:36:25,510 --> 00:36:25,520

 

1158
00:36:25,520 --> 00:36:26,630


1159
00:36:26,630 --> 00:36:26,640

 

1160
00:36:26,640 --> 00:36:27,910


1161
00:36:27,910 --> 00:36:27,920

 

1162
00:36:27,920 --> 00:36:28,790


1163
00:36:28,790 --> 00:36:31,589

 

1164
00:36:31,589 --> 00:36:35,190

 

1165
00:36:35,190 --> 00:36:37,349

 

1166
00:36:37,349 --> 00:36:38,829

 

1167
00:36:38,829 --> 00:36:38,839

 

1168
00:36:38,839 --> 00:36:40,790


1169
00:36:40,790 --> 00:36:43,349

 

1170
00:36:43,349 --> 00:36:44,710

 

1171
00:36:44,710 --> 00:36:47,589

 

1172
00:36:47,589 --> 00:36:52,710

 

1173
00:36:52,710 --> 00:36:54,790

 

1174
00:36:54,790 --> 00:36:56,390

 

1175
00:36:56,390 --> 00:36:56,400

 

1176
00:36:56,400 --> 00:36:57,910


1177
00:36:57,910 --> 00:37:01,030

 

1178
00:37:01,030 --> 00:37:03,829

 

1179
00:37:03,829 --> 00:37:05,750

 

1180
00:37:05,750 --> 00:37:05,760

 

1181
00:37:05,760 --> 00:37:06,790


1182
00:37:06,790 --> 00:37:08,870

 

1183
00:37:08,870 --> 00:37:11,829

 

1184
00:37:11,829 --> 00:37:13,990

 

1185
00:37:13,990 --> 00:37:14,000

 

1186
00:37:14,000 --> 00:37:15,589


1187
00:37:15,589 --> 00:37:17,510

 

1188
00:37:17,510 --> 00:37:21,349

 

1189
00:37:21,349 --> 00:37:21,359

 

1190
00:37:21,359 --> 00:37:25,109


1191
00:37:25,109 --> 00:37:26,630

 

1192
00:37:26,630 --> 00:37:28,310

 

1193
00:37:28,310 --> 00:37:31,109

 

1194
00:37:31,109 --> 00:37:31,119

 

1195
00:37:31,119 --> 00:37:32,230


1196
00:37:32,230 --> 00:37:34,310

 

1197
00:37:34,310 --> 00:37:35,750

 

1198
00:37:35,750 --> 00:37:38,150

 

1199
00:37:38,150 --> 00:37:40,710

 

1200
00:37:40,710 --> 00:37:42,630

 

1201
00:37:42,630 --> 00:37:44,710

 

1202
00:37:44,710 --> 00:37:49,829

 

1203
00:37:49,829 --> 00:37:51,829

 

1204
00:37:51,829 --> 00:37:54,230

 

1205
00:37:54,230 --> 00:37:55,829

 

1206
00:37:55,829 --> 00:37:58,230

 

1207
00:37:58,230 --> 00:37:59,829

 

1208
00:37:59,829 --> 00:38:02,829

 

1209
00:38:02,829 --> 00:38:05,109

 

1210
00:38:05,109 --> 00:38:05,119

 

1211
00:38:05,119 --> 00:38:06,470


1212
00:38:06,470 --> 00:38:08,230

 

1213
00:38:08,230 --> 00:38:10,710

 

1214
00:38:10,710 --> 00:38:12,150

 

1215
00:38:12,150 --> 00:38:14,230

 

1216
00:38:14,230 --> 00:38:14,240

 

1217
00:38:14,240 --> 00:38:15,030


1218
00:38:15,030 --> 00:38:17,990

 

1219
00:38:17,990 --> 00:38:19,910

 

1220
00:38:19,910 --> 00:38:22,230

 

1221
00:38:22,230 --> 00:38:23,829

 

1222
00:38:23,829 --> 00:38:23,839

 

1223
00:38:23,839 --> 00:38:25,190


1224
00:38:25,190 --> 00:38:26,550

 

1225
00:38:26,550 --> 00:38:28,069

 

1226
00:38:28,069 --> 00:38:30,710

 

1227
00:38:30,710 --> 00:38:33,829

 

1228
00:38:33,829 --> 00:38:35,670

 

1229
00:38:35,670 --> 00:38:38,550

 

1230
00:38:38,550 --> 00:38:41,109

 

1231
00:38:41,109 --> 00:38:44,150

 

1232
00:38:44,150 --> 00:38:44,160

 

1233
00:38:44,160 --> 00:38:45,270


1234
00:38:45,270 --> 00:38:48,870

 

1235
00:38:48,870 --> 00:38:48,880

 

1236
00:38:48,880 --> 00:38:50,310


1237
00:38:50,310 --> 00:38:55,190

 

1238
00:38:55,190 --> 00:38:57,030

 

1239
00:38:57,030 --> 00:38:59,670

 

1240
00:38:59,670 --> 00:39:02,069

 

1241
00:39:02,069 --> 00:39:04,630

 

1242
00:39:04,630 --> 00:39:07,510

 

1243
00:39:07,510 --> 00:39:07,520

 

1244
00:39:07,520 --> 00:39:09,349


1245
00:39:09,349 --> 00:39:11,190

 

1246
00:39:11,190 --> 00:39:12,710

 

1247
00:39:12,710 --> 00:39:15,910

 

1248
00:39:15,910 --> 00:39:17,750

 

1249
00:39:17,750 --> 00:39:19,190

 

1250
00:39:19,190 --> 00:39:20,230

 

1251
00:39:20,230 --> 00:39:23,589

 

1252
00:39:23,589 --> 00:39:25,030

 

1253
00:39:25,030 --> 00:39:26,870

 

1254
00:39:26,870 --> 00:39:26,880

 

1255
00:39:26,880 --> 00:39:28,710


1256
00:39:28,710 --> 00:39:30,310

 

1257
00:39:30,310 --> 00:39:33,109

 

1258
00:39:33,109 --> 00:39:35,510

 

1259
00:39:35,510 --> 00:39:35,520

 

1260
00:39:35,520 --> 00:39:36,550


1261
00:39:36,550 --> 00:39:36,560

 

1262
00:39:36,560 --> 00:39:37,270


1263
00:39:37,270 --> 00:39:39,910

 

1264
00:39:39,910 --> 00:39:41,349

 

1265
00:39:41,349 --> 00:39:43,910

 

1266
00:39:43,910 --> 00:39:46,630

 

1267
00:39:46,630 --> 00:39:47,750

 

1268
00:39:47,750 --> 00:39:49,349

 

1269
00:39:49,349 --> 00:39:51,430

 

1270
00:39:51,430 --> 00:39:51,440

 

1271
00:39:51,440 --> 00:39:52,470


1272
00:39:52,470 --> 00:39:54,230

 

1273
00:39:54,230 --> 00:40:03,270

 

1274
00:40:03,270 --> 00:40:05,670

 

1275
00:40:05,670 --> 00:40:05,680

 

1276
00:40:05,680 --> 00:40:06,470


1277
00:40:06,470 --> 00:40:09,349

 

1278
00:40:09,349 --> 00:40:11,750

 

1279
00:40:11,750 --> 00:40:13,430

 

1280
00:40:13,430 --> 00:40:13,440

 

1281
00:40:13,440 --> 00:40:14,870


1282
00:40:14,870 --> 00:40:18,150

 

1283
00:40:18,150 --> 00:40:19,589

 

1284
00:40:19,589 --> 00:40:21,109

 

1285
00:40:21,109 --> 00:40:24,710

 

1286
00:40:24,710 --> 00:40:26,150

 

1287
00:40:26,150 --> 00:40:26,160

 

1288
00:40:26,160 --> 00:40:27,030


1289
00:40:27,030 --> 00:40:29,670

 

1290
00:40:29,670 --> 00:40:31,829

 

1291
00:40:31,829 --> 00:40:35,030

 

1292
00:40:35,030 --> 00:40:37,030

 

1293
00:40:37,030 --> 00:40:38,550

 

1294
00:40:38,550 --> 00:40:38,560

 

1295
00:40:38,560 --> 00:40:41,829


1296
00:40:41,829 --> 00:40:41,839

 

1297
00:40:41,839 --> 00:40:46,550


1298
00:40:46,550 --> 00:40:49,270

 

1299
00:40:49,270 --> 00:40:51,829

 

1300
00:40:51,829 --> 00:40:53,430

 

1301
00:40:53,430 --> 00:40:55,670

 

1302
00:40:55,670 --> 00:40:58,230

 

1303
00:40:58,230 --> 00:41:00,470

 

1304
00:41:00,470 --> 00:41:02,550

 

1305
00:41:02,550 --> 00:41:04,309

 

1306
00:41:04,309 --> 00:41:06,230

 

1307
00:41:06,230 --> 00:41:06,240

 

1308
00:41:06,240 --> 00:41:06,950


1309
00:41:06,950 --> 00:41:08,630

 

1310
00:41:08,630 --> 00:41:10,309

 

1311
00:41:10,309 --> 00:41:12,069

 

1312
00:41:12,069 --> 00:41:13,589

 

1313
00:41:13,589 --> 00:41:15,349

 

1314
00:41:15,349 --> 00:41:15,359

 

1315
00:41:15,359 --> 00:41:16,309


1316
00:41:16,309 --> 00:41:17,829

 

1317
00:41:17,829 --> 00:41:21,190

 

1318
00:41:21,190 --> 00:41:22,950

 

1319
00:41:22,950 --> 00:41:22,960

 

1320
00:41:22,960 --> 00:41:23,750


1321
00:41:23,750 --> 00:41:25,670

 

1322
00:41:25,670 --> 00:41:27,589

 

1323
00:41:27,589 --> 00:41:31,109

 

1324
00:41:31,109 --> 00:41:31,119

 

1325
00:41:31,119 --> 00:41:32,069


1326
00:41:32,069 --> 00:41:34,309

 

1327
00:41:34,309 --> 00:41:36,710

 

1328
00:41:36,710 --> 00:41:39,430

 

1329
00:41:39,430 --> 00:41:43,190

 

1330
00:41:43,190 --> 00:41:44,790

 

1331
00:41:44,790 --> 00:41:47,030

 

1332
00:41:47,030 --> 00:41:50,470

 

1333
00:41:50,470 --> 00:41:52,550

 

1334
00:41:52,550 --> 00:41:52,560

 

1335
00:41:52,560 --> 00:41:53,670


1336
00:41:53,670 --> 00:41:55,990

 

1337
00:41:55,990 --> 00:41:56,000

 

1338
00:41:56,000 --> 00:41:57,430


1339
00:41:57,430 --> 00:42:00,550

 

1340
00:42:00,550 --> 00:42:01,910

 

1341
00:42:01,910 --> 00:42:01,920

 

1342
00:42:01,920 --> 00:42:03,190


1343
00:42:03,190 --> 00:42:03,200

 

1344
00:42:03,200 --> 00:42:05,109


1345
00:42:05,109 --> 00:42:08,069

 

1346
00:42:08,069 --> 00:42:09,990

 

1347
00:42:09,990 --> 00:42:12,309

 

1348
00:42:12,309 --> 00:42:14,790

 

1349
00:42:14,790 --> 00:42:17,190

 

1350
00:42:17,190 --> 00:42:20,230

 

1351
00:42:20,230 --> 00:42:22,150

 

1352
00:42:22,150 --> 00:42:23,510

 

1353
00:42:23,510 --> 00:42:24,950

 

1354
00:42:24,950 --> 00:42:24,960

 

1355
00:42:24,960 --> 00:42:25,829


1356
00:42:25,829 --> 00:42:25,839

 

1357
00:42:25,839 --> 00:42:28,710


1358
00:42:28,710 --> 00:42:31,430

 

1359
00:42:31,430 --> 00:42:33,750

 

1360
00:42:33,750 --> 00:42:36,230

 

1361
00:42:36,230 --> 00:42:37,750

 

1362
00:42:37,750 --> 00:42:39,510

 

1363
00:42:39,510 --> 00:42:39,520

 

1364
00:42:39,520 --> 00:42:40,710


1365
00:42:40,710 --> 00:42:44,309

 

1366
00:42:44,309 --> 00:42:47,109

 

1367
00:42:47,109 --> 00:42:49,349

 

1368
00:42:49,349 --> 00:42:52,470

 

1369
00:42:52,470 --> 00:42:54,950

 

1370
00:42:54,950 --> 00:42:54,960

 

1371
00:42:54,960 --> 00:42:58,309


1372
00:42:58,309 --> 00:42:58,319

 

1373
00:42:58,319 --> 00:43:02,470


1374
00:43:02,470 --> 00:43:02,480

 

1375
00:43:02,480 --> 00:43:03,670


1376
00:43:03,670 --> 00:43:07,670

 

1377
00:43:07,670 --> 00:43:07,680

 

1378
00:43:07,680 --> 00:43:08,390


1379
00:43:08,390 --> 00:43:08,400

 

1380
00:43:08,400 --> 00:43:09,270


1381
00:43:09,270 --> 00:43:11,190

 

1382
00:43:11,190 --> 00:43:13,670

 

1383
00:43:13,670 --> 00:43:15,349

 

1384
00:43:15,349 --> 00:43:17,349

 

1385
00:43:17,349 --> 00:43:19,510

 

1386
00:43:19,510 --> 00:43:21,910

 

1387
00:43:21,910 --> 00:43:23,910

 

1388
00:43:23,910 --> 00:43:23,920

 

1389
00:43:23,920 --> 00:43:25,190


1390
00:43:25,190 --> 00:43:26,390

 

1391
00:43:26,390 --> 00:43:27,750

 

1392
00:43:27,750 --> 00:43:29,109

 

1393
00:43:29,109 --> 00:43:29,119

 

1394
00:43:29,119 --> 00:43:30,309


1395
00:43:30,309 --> 00:43:30,319

 

1396
00:43:30,319 --> 00:43:31,190


1397
00:43:31,190 --> 00:43:34,790

 

1398
00:43:34,790 --> 00:43:34,800

 

1399
00:43:34,800 --> 00:43:35,750


1400
00:43:35,750 --> 00:43:37,589

 

1401
00:43:37,589 --> 00:43:43,349

 

1402
00:43:43,349 --> 00:43:46,390

 

1403
00:43:46,390 --> 00:43:46,400

 

1404
00:43:46,400 --> 00:43:47,670


1405
00:43:47,670 --> 00:43:49,349

 

1406
00:43:49,349 --> 00:43:49,359

 

1407
00:43:49,359 --> 00:43:50,230


1408
00:43:50,230 --> 00:43:50,240

 

1409
00:43:50,240 --> 00:43:51,270


1410
00:43:51,270 --> 00:43:52,710

 

1411
00:43:52,710 --> 00:43:54,630

 

1412
00:43:54,630 --> 00:43:56,710

 

1413
00:43:56,710 --> 00:43:56,720

 

1414
00:43:56,720 --> 00:43:57,990


1415
00:43:57,990 --> 00:44:00,390

 

1416
00:44:00,390 --> 00:44:01,270

 

1417
00:44:01,270 --> 00:44:02,630

 

1418
00:44:02,630 --> 00:44:06,230

 

1419
00:44:06,230 --> 00:44:08,870

 

1420
00:44:08,870 --> 00:44:11,270

 

1421
00:44:11,270 --> 00:44:13,910

 

1422
00:44:13,910 --> 00:44:17,030

 

1423
00:44:17,030 --> 00:44:18,630

 

1424
00:44:18,630 --> 00:44:21,829

 

1425
00:44:21,829 --> 00:44:23,829

 

1426
00:44:23,829 --> 00:44:25,750

 

1427
00:44:25,750 --> 00:44:27,270

 

1428
00:44:27,270 --> 00:44:30,950

 

1429
00:44:30,950 --> 00:44:33,190

 

1430
00:44:33,190 --> 00:44:36,550

 

1431
00:44:36,550 --> 00:44:38,710

 

1432
00:44:38,710 --> 00:44:41,030

 

1433
00:44:41,030 --> 00:44:41,040

 

1434
00:44:41,040 --> 00:44:42,710


1435
00:44:42,710 --> 00:44:42,720

 

1436
00:44:42,720 --> 00:44:44,390


1437
00:44:44,390 --> 00:44:46,550

 

1438
00:44:46,550 --> 00:44:46,560

 

1439
00:44:46,560 --> 00:44:48,069


1440
00:44:48,069 --> 00:44:50,150

 

1441
00:44:50,150 --> 00:44:52,309

 

1442
00:44:52,309 --> 00:44:53,829

 

1443
00:44:53,829 --> 00:44:55,750

 

1444
00:44:55,750 --> 00:44:57,829

 

1445
00:44:57,829 --> 00:45:01,270

 

1446
00:45:01,270 --> 00:45:01,280

 

1447
00:45:01,280 --> 00:45:02,230


1448
00:45:02,230 --> 00:45:02,240

 

1449
00:45:02,240 --> 00:45:03,670


1450
00:45:03,670 --> 00:45:03,680

 

1451
00:45:03,680 --> 00:45:04,390


1452
00:45:04,390 --> 00:45:04,400

 

1453
00:45:04,400 --> 00:45:05,589


1454
00:45:05,589 --> 00:45:07,670

 

1455
00:45:07,670 --> 00:45:09,349

 

1456
00:45:09,349 --> 00:45:11,430

 

1457
00:45:11,430 --> 00:45:13,349

 

1458
00:45:13,349 --> 00:45:15,190

 

1459
00:45:15,190 --> 00:45:17,109

 

1460
00:45:17,109 --> 00:45:19,510

 

1461
00:45:19,510 --> 00:45:22,230

 

1462
00:45:22,230 --> 00:45:24,710

 

1463
00:45:24,710 --> 00:45:24,720

 

1464
00:45:24,720 --> 00:45:25,910


1465
00:45:25,910 --> 00:45:25,920

 

1466
00:45:25,920 --> 00:45:26,790


1467
00:45:26,790 --> 00:45:29,750

 

1468
00:45:29,750 --> 00:45:32,790

 

1469
00:45:32,790 --> 00:45:34,069

 

1470
00:45:34,069 --> 00:45:36,710

 

1471
00:45:36,710 --> 00:45:38,390

 

1472
00:45:38,390 --> 00:45:40,069

 

1473
00:45:40,069 --> 00:45:41,910

 

1474
00:45:41,910 --> 00:45:44,309

 

1475
00:45:44,309 --> 00:45:45,349

 

1476
00:45:45,349 --> 00:45:47,190

 

1477
00:45:47,190 --> 00:45:49,190

 

1478
00:45:49,190 --> 00:45:51,109

 

1479
00:45:51,109 --> 00:45:53,670

 

1480
00:45:53,670 --> 00:45:55,910

 

1481
00:45:55,910 --> 00:45:58,790

 

1482
00:45:58,790 --> 00:46:01,349

 

1483
00:46:01,349 --> 00:46:03,030

 

1484
00:46:03,030 --> 00:46:04,950

 

1485
00:46:04,950 --> 00:46:04,960

 

1486
00:46:04,960 --> 00:46:05,829


1487
00:46:05,829 --> 00:46:07,190

 

1488
00:46:07,190 --> 00:46:09,670

 

1489
00:46:09,670 --> 00:46:11,829

 

1490
00:46:11,829 --> 00:46:13,670

 

1491
00:46:13,670 --> 00:46:15,430

 

1492
00:46:15,430 --> 00:46:15,440

 

1493
00:46:15,440 --> 00:46:16,150


1494
00:46:16,150 --> 00:46:18,550

 

1495
00:46:18,550 --> 00:46:18,560

 

1496
00:46:18,560 --> 00:46:20,390


1497
00:46:20,390 --> 00:46:22,069

 

1498
00:46:22,069 --> 00:46:24,470

 

1499
00:46:24,470 --> 00:46:27,990

 

1500
00:46:27,990 --> 00:46:29,670

 

1501
00:46:29,670 --> 00:46:32,309

 

1502
00:46:32,309 --> 00:46:33,750

 

1503
00:46:33,750 --> 00:46:37,030

 

1504
00:46:37,030 --> 00:46:38,790

 

1505
00:46:38,790 --> 00:46:40,309

 

1506
00:46:40,309 --> 00:46:41,829

 

1507
00:46:41,829 --> 00:46:43,510

 

1508
00:46:43,510 --> 00:46:47,589

 

1509
00:46:47,589 --> 00:46:49,990

 

1510
00:46:49,990 --> 00:46:51,430

 

1511
00:46:51,430 --> 00:46:53,589

 

1512
00:46:53,589 --> 00:46:56,069

 

1513
00:46:56,069 --> 00:46:57,910

 

1514
00:46:57,910 --> 00:46:59,990

 

1515
00:46:59,990 --> 00:47:02,309

 

1516
00:47:02,309 --> 00:47:03,990

 

1517
00:47:03,990 --> 00:47:04,000

 

1518
00:47:04,000 --> 00:47:08,870


1519
00:47:08,870 --> 00:47:12,150

 

1520
00:47:12,150 --> 00:47:14,710

 

1521
00:47:14,710 --> 00:47:16,150

 

1522
00:47:16,150 --> 00:47:19,030

 

1523
00:47:19,030 --> 00:47:21,430

 

1524
00:47:21,430 --> 00:47:22,870

 

1525
00:47:22,870 --> 00:47:25,030

 

1526
00:47:25,030 --> 00:47:26,630

 

1527
00:47:26,630 --> 00:47:28,630

 

1528
00:47:28,630 --> 00:47:28,640

 

1529
00:47:28,640 --> 00:47:30,790


1530
00:47:30,790 --> 00:47:33,589

 

1531
00:47:33,589 --> 00:47:37,349

 

1532
00:47:37,349 --> 00:47:39,670

 

1533
00:47:39,670 --> 00:47:42,549

 

1534
00:47:42,549 --> 00:47:44,150

 

1535
00:47:44,150 --> 00:47:45,990

 

1536
00:47:45,990 --> 00:47:46,000

 

1537
00:47:46,000 --> 00:47:46,870


1538
00:47:46,870 --> 00:47:46,880

 

1539
00:47:46,880 --> 00:47:49,190


1540
00:47:49,190 --> 00:47:50,710

 

1541
00:47:50,710 --> 00:47:52,549

 

1542
00:47:52,549 --> 00:47:55,030

 

1543
00:47:55,030 --> 00:47:56,549

 

1544
00:47:56,549 --> 00:47:56,559

 

1545
00:47:56,559 --> 00:47:58,150


1546
00:47:58,150 --> 00:47:59,829

 

1547
00:47:59,829 --> 00:48:01,190

 

1548
00:48:01,190 --> 00:48:01,200

 

1549
00:48:01,200 --> 00:48:02,470


1550
00:48:02,470 --> 00:48:03,990

 

1551
00:48:03,990 --> 00:48:06,710

 

1552
00:48:06,710 --> 00:48:06,720

 

1553
00:48:06,720 --> 00:48:08,950


1554
00:48:08,950 --> 00:48:10,230

 

1555
00:48:10,230 --> 00:48:11,990

 

1556
00:48:11,990 --> 00:48:13,190

 

1557
00:48:13,190 --> 00:48:15,589

 

1558
00:48:15,589 --> 00:48:17,109

 

1559
00:48:17,109 --> 00:48:19,190

 

1560
00:48:19,190 --> 00:48:22,790

 

1561
00:48:22,790 --> 00:48:22,800

 

1562
00:48:22,800 --> 00:48:23,510


1563
00:48:23,510 --> 00:48:23,520

 

1564
00:48:23,520 --> 00:48:25,270


1565
00:48:25,270 --> 00:48:27,430

 

1566
00:48:27,430 --> 00:48:32,150

 

1567
00:48:32,150 --> 00:48:34,390

 

1568
00:48:34,390 --> 00:48:34,400

 

1569
00:48:34,400 --> 00:48:35,190


1570
00:48:35,190 --> 00:48:37,030

 

1571
00:48:37,030 --> 00:48:39,510

 

1572
00:48:39,510 --> 00:48:41,670

 

1573
00:48:41,670 --> 00:48:43,589

 

1574
00:48:43,589 --> 00:48:45,349

 

1575
00:48:45,349 --> 00:48:46,950

 

1576
00:48:46,950 --> 00:48:49,190

 

1577
00:48:49,190 --> 00:48:51,190

 

1578
00:48:51,190 --> 00:48:53,190

 

1579
00:48:53,190 --> 00:48:55,109

 

1580
00:48:55,109 --> 00:48:57,109

 

1581
00:48:57,109 --> 00:48:58,870

 

1582
00:48:58,870 --> 00:49:01,109

 

1583
00:49:01,109 --> 00:49:03,750

 

1584
00:49:03,750 --> 00:49:05,589

 

1585
00:49:05,589 --> 00:49:08,630

 

1586
00:49:08,630 --> 00:49:09,910

 

1587
00:49:09,910 --> 00:49:12,150

 

1588
00:49:12,150 --> 00:49:16,230

 

1589
00:49:16,230 --> 00:49:17,990

 

1590
00:49:17,990 --> 00:49:19,910

 

1591
00:49:19,910 --> 00:49:19,920

 

1592
00:49:19,920 --> 00:49:22,309


1593
00:49:22,309 --> 00:49:22,319

 

1594
00:49:22,319 --> 00:49:23,349


1595
00:49:23,349 --> 00:49:25,750

 

1596
00:49:25,750 --> 00:49:28,950

 

1597
00:49:28,950 --> 00:49:30,630

 

1598
00:49:30,630 --> 00:49:33,190

 

1599
00:49:33,190 --> 00:49:35,670

 

1600
00:49:35,670 --> 00:49:35,680

 

1601
00:49:35,680 --> 00:49:36,630


1602
00:49:36,630 --> 00:49:39,750

 

1603
00:49:39,750 --> 00:49:41,589

 

1604
00:49:41,589 --> 00:49:43,430

 

1605
00:49:43,430 --> 00:49:45,349

 

1606
00:49:45,349 --> 00:49:47,910

 

1607
00:49:47,910 --> 00:49:47,920

 

1608
00:49:47,920 --> 00:49:49,430


1609
00:49:49,430 --> 00:49:51,349

 

1610
00:49:51,349 --> 00:49:53,670

 

1611
00:49:53,670 --> 00:49:55,990

 

1612
00:49:55,990 --> 00:49:58,790

 

1613
00:49:58,790 --> 00:49:58,800

 

1614
00:49:58,800 --> 00:49:59,670


1615
00:49:59,670 --> 00:50:01,190

 

1616
00:50:01,190 --> 00:50:04,150

 

1617
00:50:04,150 --> 00:50:06,230

 

1618
00:50:06,230 --> 00:50:06,240

 

1619
00:50:06,240 --> 00:50:07,270


1620
00:50:07,270 --> 00:50:08,950

 

1621
00:50:08,950 --> 00:50:10,630

 

1622
00:50:10,630 --> 00:50:13,109

 

1623
00:50:13,109 --> 00:50:15,109

 

1624
00:50:15,109 --> 00:50:17,270

 

1625
00:50:17,270 --> 00:50:17,280

 

1626
00:50:17,280 --> 00:50:17,990


1627
00:50:17,990 --> 00:50:20,230

 

1628
00:50:20,230 --> 00:50:26,390

 

1629
00:50:26,390 --> 00:50:28,150

 

1630
00:50:28,150 --> 00:50:29,670

 

1631
00:50:29,670 --> 00:50:33,270

 

1632
00:50:33,270 --> 00:50:35,990

 

1633
00:50:35,990 --> 00:50:38,630

 

1634
00:50:38,630 --> 00:50:40,630

 

1635
00:50:40,630 --> 00:50:42,150

 

1636
00:50:42,150 --> 00:50:44,549

 

1637
00:50:44,549 --> 00:50:47,030

 

1638
00:50:47,030 --> 00:50:49,270

 

1639
00:50:49,270 --> 00:50:49,280

 

1640
00:50:49,280 --> 00:50:50,150


1641
00:50:50,150 --> 00:50:52,790

 

1642
00:50:52,790 --> 00:50:54,470

 

1643
00:50:54,470 --> 00:50:54,480

 

1644
00:50:54,480 --> 00:50:55,750


1645
00:50:55,750 --> 00:50:56,870

 

1646
00:50:56,870 --> 00:50:58,549

 

1647
00:50:58,549 --> 00:51:01,190

 

1648
00:51:01,190 --> 00:51:01,200

 

1649
00:51:01,200 --> 00:51:02,069


1650
00:51:02,069 --> 00:51:04,470

 

1651
00:51:04,470 --> 00:51:04,480

 

1652
00:51:04,480 --> 00:51:05,430


1653
00:51:05,430 --> 00:51:07,030

 

1654
00:51:07,030 --> 00:51:10,710

 

1655
00:51:10,710 --> 00:51:11,910

 

1656
00:51:11,910 --> 00:51:15,109

 

1657
00:51:15,109 --> 00:51:17,990

 

1658
00:51:17,990 --> 00:51:20,710

 

1659
00:51:20,710 --> 00:51:23,990

 

1660
00:51:23,990 --> 00:51:26,230

 

1661
00:51:26,230 --> 00:51:28,630

 

1662
00:51:28,630 --> 00:51:30,630

 

1663
00:51:30,630 --> 00:51:32,790

 

1664
00:51:32,790 --> 00:51:35,190

 

1665
00:51:35,190 --> 00:51:38,390

 

1666
00:51:38,390 --> 00:51:41,990

 

1667
00:51:41,990 --> 00:51:42,000

 

1668
00:51:42,000 --> 00:51:43,430


1669
00:51:43,430 --> 00:51:43,440

 

1670
00:51:43,440 --> 00:51:44,230


1671
00:51:44,230 --> 00:51:46,069

 

1672
00:51:46,069 --> 00:51:46,079

 

1673
00:51:46,079 --> 00:51:47,109


1674
00:51:47,109 --> 00:51:49,430

 

1675
00:51:49,430 --> 00:51:51,750

 

1676
00:51:51,750 --> 00:51:54,230

 

1677
00:51:54,230 --> 00:51:57,829

 

1678
00:51:57,829 --> 00:52:00,950

 

1679
00:52:00,950 --> 00:52:05,510

 

1680
00:52:05,510 --> 00:52:08,470

 

1681
00:52:08,470 --> 00:52:10,549

 

1682
00:52:10,549 --> 00:52:12,390

 

1683
00:52:12,390 --> 00:52:12,400

 

1684
00:52:12,400 --> 00:52:13,270


1685
00:52:13,270 --> 00:52:15,109

 

1686
00:52:15,109 --> 00:52:16,470

 

1687
00:52:16,470 --> 00:52:19,109

 

1688
00:52:19,109 --> 00:52:21,270

 

1689
00:52:21,270 --> 00:52:23,349

 

1690
00:52:23,349 --> 00:52:26,549

 

1691
00:52:26,549 --> 00:52:29,750

 

1692
00:52:29,750 --> 00:52:32,549

 

1693
00:52:32,549 --> 00:52:34,470

 

1694
00:52:34,470 --> 00:52:37,270

 

1695
00:52:37,270 --> 00:52:39,190

 

1696
00:52:39,190 --> 00:52:41,510

 

1697
00:52:41,510 --> 00:52:45,270

 

1698
00:52:45,270 --> 00:52:47,990

 

1699
00:52:47,990 --> 00:52:48,000

 

1700
00:52:48,000 --> 00:52:48,710


1701
00:52:48,710 --> 00:52:52,230

 

1702
00:52:52,230 --> 00:52:54,309

 

1703
00:52:54,309 --> 00:52:56,950

 

1704
00:52:56,950 --> 00:52:59,670

 

1705
00:52:59,670 --> 00:52:59,680

 

1706
00:52:59,680 --> 00:53:00,470


1707
00:53:00,470 --> 00:53:00,480

 

1708
00:53:00,480 --> 00:53:01,910


1709
00:53:01,910 --> 00:53:03,270

 

1710
00:53:03,270 --> 00:53:06,150

 

1711
00:53:06,150 --> 00:53:08,069

 

1712
00:53:08,069 --> 00:53:10,870

 

1713
00:53:10,870 --> 00:53:14,790

 

1714
00:53:14,790 --> 00:53:14,800

 

1715
00:53:14,800 --> 00:53:15,670


1716
00:53:15,670 --> 00:53:15,680

 

1717
00:53:15,680 --> 00:53:16,630


1718
00:53:16,630 --> 00:53:19,430

 

1719
00:53:19,430 --> 00:53:22,230

 

1720
00:53:22,230 --> 00:53:24,790

 

1721
00:53:24,790 --> 00:53:24,800

 

1722
00:53:24,800 --> 00:53:27,030


1723
00:53:27,030 --> 00:53:29,910

 

1724
00:53:29,910 --> 00:53:32,309

 

1725
00:53:32,309 --> 00:53:33,670

 

1726
00:53:33,670 --> 00:53:35,750

 

1727
00:53:35,750 --> 00:53:37,589

 

1728
00:53:37,589 --> 00:53:39,990

 

1729
00:53:39,990 --> 00:53:42,390

 

1730
00:53:42,390 --> 00:53:44,150

 

1731
00:53:44,150 --> 00:53:46,630

 

1732
00:53:46,630 --> 00:53:48,630

 

1733
00:53:48,630 --> 00:53:50,950

 

1734
00:53:50,950 --> 00:53:52,790

 

1735
00:53:52,790 --> 00:53:54,870

 

1736
00:53:54,870 --> 00:53:57,670

 

1737
00:53:57,670 --> 00:54:01,829

 

1738
00:54:01,829 --> 00:54:03,430

 

1739
00:54:03,430 --> 00:54:05,670

 

1740
00:54:05,670 --> 00:54:07,829

 

1741
00:54:07,829 --> 00:54:09,910

 

1742
00:54:09,910 --> 00:54:13,270

 

1743
00:54:13,270 --> 00:54:15,510

 

1744
00:54:15,510 --> 00:54:19,990

 

1745
00:54:19,990 --> 00:54:22,630

 

1746
00:54:22,630 --> 00:54:24,630

 

1747
00:54:24,630 --> 00:54:24,640

 

1748
00:54:24,640 --> 00:54:26,069


1749
00:54:26,069 --> 00:54:28,710

 

1750
00:54:28,710 --> 00:54:28,720

 

1751
00:54:28,720 --> 00:54:30,950


1752
00:54:30,950 --> 00:54:30,960

 

1753
00:54:30,960 --> 00:54:32,390


1754
00:54:32,390 --> 00:54:32,400

 

1755
00:54:32,400 --> 00:54:33,309


1756
00:54:33,309 --> 00:54:35,670

 

1757
00:54:35,670 --> 00:54:38,630

 

1758
00:54:38,630 --> 00:54:38,640

 

1759
00:54:38,640 --> 00:54:40,789


1760
00:54:40,789 --> 00:54:41,910

 

1761
00:54:41,910 --> 00:54:43,990

 

1762
00:54:43,990 --> 00:54:47,589

 

1763
00:54:47,589 --> 00:54:47,599

 

1764
00:54:47,599 --> 00:54:50,549


1765
00:54:50,549 --> 00:54:52,710

 

1766
00:54:52,710 --> 00:54:56,150

 

1767
00:54:56,150 --> 00:55:00,630

 

1768
00:55:00,630 --> 00:55:00,640

 

1769
00:55:00,640 --> 00:55:02,069


1770
00:55:02,069 --> 00:55:03,109

 

1771
00:55:03,109 --> 00:55:06,630

 

1772
00:55:06,630 --> 00:55:09,589

 

1773
00:55:09,589 --> 00:55:09,599

 

1774
00:55:09,599 --> 00:55:10,870


1775
00:55:10,870 --> 00:55:13,109

 

1776
00:55:13,109 --> 00:55:15,030

 

1777
00:55:15,030 --> 00:55:16,230

 

1778
00:55:16,230 --> 00:55:19,589

 

1779
00:55:19,589 --> 00:55:22,470

 

1780
00:55:22,470 --> 00:55:24,150

 

1781
00:55:24,150 --> 00:55:26,309

 

1782
00:55:26,309 --> 00:55:29,670

 

1783
00:55:29,670 --> 00:55:29,680

 

1784
00:55:29,680 --> 00:55:31,190


1785
00:55:31,190 --> 00:55:32,470

 

1786
00:55:32,470 --> 00:55:34,549

 

1787
00:55:34,549 --> 00:55:36,789

 

1788
00:55:36,789 --> 00:55:39,589

 

1789
00:55:39,589 --> 00:55:41,030

 

1790
00:55:41,030 --> 00:55:42,870

 

1791
00:55:42,870 --> 00:55:44,950

 

1792
00:55:44,950 --> 00:55:46,390

 

1793
00:55:46,390 --> 00:55:47,589

 

1794
00:55:47,589 --> 00:55:47,599

 

1795
00:55:47,599 --> 00:55:49,670


1796
00:55:49,670 --> 00:55:51,190

 

1797
00:55:51,190 --> 00:55:52,950

 

1798
00:55:52,950 --> 00:55:55,190

 

1799
00:55:55,190 --> 00:55:57,750

 

1800
00:55:57,750 --> 00:56:00,630

 

1801
00:56:00,630 --> 00:56:02,630

 

1802
00:56:02,630 --> 00:56:04,549

 

1803
00:56:04,549 --> 00:56:08,309

 

1804
00:56:08,309 --> 00:56:10,309

 

1805
00:56:10,309 --> 00:56:14,069

 

1806
00:56:14,069 --> 00:56:16,230

 

1807
00:56:16,230 --> 00:56:17,589

 

1808
00:56:17,589 --> 00:56:19,109

 

1809
00:56:19,109 --> 00:56:22,309

 

1810
00:56:22,309 --> 00:56:23,430

 

1811
00:56:23,430 --> 00:56:25,990

 

1812
00:56:25,990 --> 00:56:28,630

 

1813
00:56:28,630 --> 00:56:32,230

 

1814
00:56:32,230 --> 00:56:35,670

 

1815
00:56:35,670 --> 00:56:37,109

 

1816
00:56:37,109 --> 00:56:39,910

 

1817
00:56:39,910 --> 00:56:41,990

 

1818
00:56:41,990 --> 00:56:43,190

 

1819
00:56:43,190 --> 00:56:45,349

 

1820
00:56:45,349 --> 00:56:46,630

 

1821
00:56:46,630 --> 00:56:49,349

 

1822
00:56:49,349 --> 00:56:51,510

 

1823
00:56:51,510 --> 00:56:53,589

 

1824
00:56:53,589 --> 00:56:56,390

 

1825
00:56:56,390 --> 00:56:58,390

 

1826
00:56:58,390 --> 00:56:58,400

 

1827
00:56:58,400 --> 00:56:59,829


1828
00:56:59,829 --> 00:57:02,150

 

1829
00:57:02,150 --> 00:57:03,670

 

1830
00:57:03,670 --> 00:57:04,870

 

1831
00:57:04,870 --> 00:57:06,710

 

1832
00:57:06,710 --> 00:57:08,150

 

1833
00:57:08,150 --> 00:57:10,789

 

1834
00:57:10,789 --> 00:57:10,799

 

1835
00:57:10,799 --> 00:57:11,510


1836
00:57:11,510 --> 00:57:14,710

 

1837
00:57:14,710 --> 00:57:17,030

 

1838
00:57:17,030 --> 00:57:17,040

 

1839
00:57:17,040 --> 00:57:18,470


1840
00:57:18,470 --> 00:57:20,230

 

1841
00:57:20,230 --> 00:57:24,950

 

1842
00:57:24,950 --> 00:57:27,109

 

1843
00:57:27,109 --> 00:57:30,470

 

1844
00:57:30,470 --> 00:57:31,910

 

1845
00:57:31,910 --> 00:57:34,150

 

1846
00:57:34,150 --> 00:57:35,910

 

1847
00:57:35,910 --> 00:57:37,430

 

1848
00:57:37,430 --> 00:57:39,750

 

1849
00:57:39,750 --> 00:57:41,910

 

1850
00:57:41,910 --> 00:57:43,270

 

1851
00:57:43,270 --> 00:57:44,630

 

1852
00:57:44,630 --> 00:57:45,990

 

1853
00:57:45,990 --> 00:57:47,910

 

1854
00:57:47,910 --> 00:57:49,990

 

1855
00:57:49,990 --> 00:57:51,910

 

1856
00:57:51,910 --> 00:57:54,390

 

1857
00:57:54,390 --> 00:57:56,390

 

1858
00:57:56,390 --> 00:57:57,829

 

1859
00:57:57,829 --> 00:58:00,789

 

1860
00:58:00,789 --> 00:58:02,870

 

1861
00:58:02,870 --> 00:58:04,950

 

1862
00:58:04,950 --> 00:58:06,069

 

1863
00:58:06,069 --> 00:58:09,190

 

1864
00:58:09,190 --> 00:58:10,789

 

1865
00:58:10,789 --> 00:58:12,789

 

1866
00:58:12,789 --> 00:58:14,309

 

1867
00:58:14,309 --> 00:58:15,750

 

1868
00:58:15,750 --> 00:58:17,990

 

1869
00:58:17,990 --> 00:58:19,470

 

1870
00:58:19,470 --> 00:58:22,390

 

1871
00:58:22,390 --> 00:58:24,950

 

1872
00:58:24,950 --> 00:58:27,750

 

1873
00:58:27,750 --> 00:58:29,990

 

1874
00:58:29,990 --> 00:58:32,150

 

1875
00:58:32,150 --> 00:58:32,160

 

1876
00:58:32,160 --> 00:58:34,549


1877
00:58:34,549 --> 00:58:36,069

 

1878
00:58:36,069 --> 00:58:38,710

 

1879
00:58:38,710 --> 00:58:40,630

 

1880
00:58:40,630 --> 00:58:43,190

 

1881
00:58:43,190 --> 00:58:45,910

 

1882
00:58:45,910 --> 00:58:47,510

 

1883
00:58:47,510 --> 00:58:51,910

 

1884
00:58:51,910 --> 00:58:51,920

 

1885
00:58:51,920 --> 00:58:53,190


1886
00:58:53,190 --> 00:58:53,200

 

1887
00:58:53,200 --> 00:58:54,150


1888
00:58:54,150 --> 00:58:55,829

 

1889
00:58:55,829 --> 00:58:58,069

 

1890
00:58:58,069 --> 00:58:59,270

 

1891
00:58:59,270 --> 00:59:02,549

 

1892
00:59:02,549 --> 00:59:02,559

 

1893
00:59:02,559 --> 00:59:03,430


1894
00:59:03,430 --> 00:59:05,190

 

1895
00:59:05,190 --> 00:59:07,750

 

1896
00:59:07,750 --> 00:59:09,750

 

1897
00:59:09,750 --> 00:59:11,829

 

1898
00:59:11,829 --> 00:59:11,839

 

1899
00:59:11,839 --> 00:59:12,630


1900
00:59:12,630 --> 00:59:15,349

 

1901
00:59:15,349 --> 00:59:18,710

 

1902
00:59:18,710 --> 00:59:20,950

 

1903
00:59:20,950 --> 00:59:22,710

 

1904
00:59:22,710 --> 00:59:25,349

 

1905
00:59:25,349 --> 00:59:28,630

 

1906
00:59:28,630 --> 00:59:31,510

 

1907
00:59:31,510 --> 00:59:34,309

 

1908
00:59:34,309 --> 00:59:36,950

 

1909
00:59:36,950 --> 00:59:38,549

 

1910
00:59:38,549 --> 00:59:41,589

 

1911
00:59:41,589 --> 00:59:43,910

 

1912
00:59:43,910 --> 00:59:45,190

 

1913
00:59:45,190 --> 00:59:46,870

 

1914
00:59:46,870 --> 00:59:46,880

 

1915
00:59:46,880 --> 00:59:51,589


1916
00:59:51,589 --> 00:59:54,950

 

1917
00:59:54,950 --> 00:59:56,870

 

1918
00:59:56,870 --> 00:59:59,190

 

1919
00:59:59,190 --> 01:00:02,150

 

1920
01:00:02,150 --> 01:00:05,030

 

1921
01:00:05,030 --> 01:00:06,710

 

1922
01:00:06,710 --> 01:00:08,950

 

1923
01:00:08,950 --> 01:00:09,990

 

1924
01:00:09,990 --> 01:00:12,829

 

1925
01:00:12,829 --> 01:00:15,510

 

1926
01:00:15,510 --> 01:00:18,069

 

1927
01:00:18,069 --> 01:00:18,079

 

1928
01:00:18,079 --> 01:00:19,430


1929
01:00:19,430 --> 01:00:21,910

 

1930
01:00:21,910 --> 01:00:21,920

 

1931
01:00:21,920 --> 01:00:23,430


1932
01:00:23,430 --> 01:00:26,069

 

1933
01:00:26,069 --> 01:00:26,079

 

1934
01:00:26,079 --> 01:00:27,990


1935
01:00:27,990 --> 01:00:30,230

 

1936
01:00:30,230 --> 01:00:33,109

 

1937
01:00:33,109 --> 01:00:36,549

 

1938
01:00:36,549 --> 01:00:36,559

 

1939
01:00:36,559 --> 01:00:38,069


1940
01:00:38,069 --> 01:00:40,630

 

1941
01:00:40,630 --> 01:00:42,390

 

1942
01:00:42,390 --> 01:00:44,150

 

1943
01:00:44,150 --> 01:00:45,990

 

1944
01:00:45,990 --> 01:00:47,589

 

1945
01:00:47,589 --> 01:00:50,549

 

1946
01:00:50,549 --> 01:00:50,559

 

1947
01:00:50,559 --> 01:00:51,270


1948
01:00:51,270 --> 01:00:52,789

 

1949
01:00:52,789 --> 01:00:55,109

 

1950
01:00:55,109 --> 01:00:57,910

 

1951
01:00:57,910 --> 01:00:59,670

 

1952
01:00:59,670 --> 01:01:01,750

 

1953
01:01:01,750 --> 01:01:05,030

 

1954
01:01:05,030 --> 01:01:08,150

 

1955
01:01:08,150 --> 01:01:10,390

 

1956
01:01:10,390 --> 01:01:11,910

 

1957
01:01:11,910 --> 01:01:14,309

 

1958
01:01:14,309 --> 01:01:15,589

 

1959
01:01:15,589 --> 01:01:17,670

 

1960
01:01:17,670 --> 01:01:19,030

 

1961
01:01:19,030 --> 01:01:21,589

 

1962
01:01:21,589 --> 01:01:23,030

 

1963
01:01:23,030 --> 01:01:24,710

 

1964
01:01:24,710 --> 01:01:25,910

 

1965
01:01:25,910 --> 01:01:27,589

 

1966
01:01:27,589 --> 01:01:31,109

 

1967
01:01:31,109 --> 01:01:31,119

 

1968
01:01:31,119 --> 01:01:32,470


1969
01:01:32,470 --> 01:01:37,589

 

1970
01:01:37,589 --> 01:01:39,270

 

1971
01:01:39,270 --> 01:01:42,390

 

1972
01:01:42,390 --> 01:01:44,069

 

1973
01:01:44,069 --> 01:01:47,030

 

1974
01:01:47,030 --> 01:01:48,870

 

1975
01:01:48,870 --> 01:01:50,470

 

1976
01:01:50,470 --> 01:01:52,630

 

1977
01:01:52,630 --> 01:01:59,270

 

1978
01:01:59,270 --> 01:02:01,349

 

1979
01:02:01,349 --> 01:02:01,359

 

1980
01:02:01,359 --> 01:02:02,789


1981
01:02:02,789 --> 01:02:05,029

 

1982
01:02:05,029 --> 01:02:08,789

 

1983
01:02:08,789 --> 01:02:08,799

 

1984
01:02:08,799 --> 01:02:13,670


1985
01:02:13,670 --> 01:02:15,430

 

1986
01:02:15,430 --> 01:02:17,109

 

1987
01:02:17,109 --> 01:02:18,390

 

1988
01:02:18,390 --> 01:02:20,390

 

1989
01:02:20,390 --> 01:02:22,069

 

1990
01:02:22,069 --> 01:02:24,309

 

1991
01:02:24,309 --> 01:02:26,549

 

1992
01:02:26,549 --> 01:02:26,559

 

1993
01:02:26,559 --> 01:02:29,190


1994
01:02:29,190 --> 01:02:29,200

 

1995
01:02:29,200 --> 01:02:32,870


1996
01:02:32,870 --> 01:02:32,880

 

1997
01:02:32,880 --> 01:02:34,870


1998
01:02:34,870 --> 01:02:38,390

 

1999
01:02:38,390 --> 01:02:40,630

 

2000
01:02:40,630 --> 01:02:43,270

 

2001
01:02:43,270 --> 01:02:44,069

 

2002
01:02:44,069 --> 01:02:51,270

 

2003
01:02:51,270 --> 01:02:53,349

 

2004
01:02:53,349 --> 01:02:54,710

 

2005
01:02:54,710 --> 01:02:57,589

 

2006
01:02:57,589 --> 01:03:00,549

 

2007
01:03:00,549 --> 01:03:02,950

 

2008
01:03:02,950 --> 01:03:05,430

 

2009
01:03:05,430 --> 01:03:07,270

 

2010
01:03:07,270 --> 01:03:10,309

 

2011
01:03:10,309 --> 01:03:10,319

 

2012
01:03:10,319 --> 01:03:11,270


2013
01:03:11,270 --> 01:03:13,430

 

2014
01:03:13,430 --> 01:03:15,910

 

2015
01:03:15,910 --> 01:03:15,920

 

2016
01:03:15,920 --> 01:03:17,270


2017
01:03:17,270 --> 01:03:19,349

 

2018
01:03:19,349 --> 01:03:22,150

 

2019
01:03:22,150 --> 01:03:24,150

 

2020
01:03:24,150 --> 01:03:25,510

 

2021
01:03:25,510 --> 01:03:28,390

 

2022
01:03:28,390 --> 01:03:32,150

 

2023
01:03:32,150 --> 01:03:34,150

 

2024
01:03:34,150 --> 01:03:37,829

 

2025
01:03:37,829 --> 01:03:37,839

 

2026
01:03:37,839 --> 01:03:39,029


2027
01:03:39,029 --> 01:03:39,039

 

2028
01:03:39,039 --> 01:03:40,630


2029
01:03:40,630 --> 01:03:42,230

 

2030
01:03:42,230 --> 01:03:43,910

 

2031
01:03:43,910 --> 01:03:45,670

 

2032
01:03:45,670 --> 01:03:47,190

 

2033
01:03:47,190 --> 01:03:50,069

 

2034
01:03:50,069 --> 01:03:52,150

 

2035
01:03:52,150 --> 01:03:53,670

 

2036
01:03:53,670 --> 01:03:56,390

 

2037
01:03:56,390 --> 01:03:58,150

 

2038
01:03:58,150 --> 01:03:59,750

 

2039
01:03:59,750 --> 01:04:01,430

 

2040
01:04:01,430 --> 01:04:01,440

 

2041
01:04:01,440 --> 01:04:05,029


2042
01:04:05,029 --> 01:04:05,039

 

2043
01:04:05,039 --> 01:04:06,150


2044
01:04:06,150 --> 01:04:07,990

 

2045
01:04:07,990 --> 01:04:09,829

 

2046
01:04:09,829 --> 01:04:12,470

 

2047
01:04:12,470 --> 01:04:15,109

 

2048
01:04:15,109 --> 01:04:17,430

 

2049
01:04:17,430 --> 01:04:19,349

 

2050
01:04:19,349 --> 01:04:22,230

 

2051
01:04:22,230 --> 01:04:22,240

 

2052
01:04:22,240 --> 01:04:23,029


2053
01:04:23,029 --> 01:04:24,630

 

2054
01:04:24,630 --> 01:04:26,870

 

2055
01:04:26,870 --> 01:04:29,190

 

2056
01:04:29,190 --> 01:04:29,200

 

2057
01:04:29,200 --> 01:04:30,309


2058
01:04:30,309 --> 01:04:31,510

 

2059
01:04:31,510 --> 01:04:33,910

 

2060
01:04:33,910 --> 01:04:36,309

 

2061
01:04:36,309 --> 01:04:38,309

 

2062
01:04:38,309 --> 01:04:39,670

 

2063
01:04:39,670 --> 01:04:41,829

 

2064
01:04:41,829 --> 01:04:43,270

 

2065
01:04:43,270 --> 01:04:44,549

 

2066
01:04:44,549 --> 01:04:46,710

 

2067
01:04:46,710 --> 01:04:49,270

 

2068
01:04:49,270 --> 01:04:51,990

 

2069
01:04:51,990 --> 01:04:52,000

 

2070
01:04:52,000 --> 01:04:52,789


2071
01:04:52,789 --> 01:04:54,870

 

2072
01:04:54,870 --> 01:04:56,789

 

2073
01:04:56,789 --> 01:04:59,190

 

2074
01:04:59,190 --> 01:05:01,029

 

2075
01:05:01,029 --> 01:05:01,039

 

2076
01:05:01,039 --> 01:05:02,230


2077
01:05:02,230 --> 01:05:03,510

 

2078
01:05:03,510 --> 01:05:06,150

 

2079
01:05:06,150 --> 01:05:07,910

 

2080
01:05:07,910 --> 01:05:10,230

 

2081
01:05:10,230 --> 01:05:12,710

 

2082
01:05:12,710 --> 01:05:15,670

 

2083
01:05:15,670 --> 01:05:18,309

 

2084
01:05:18,309 --> 01:05:20,829

 

2085
01:05:20,829 --> 01:05:23,510

 

2086
01:05:23,510 --> 01:05:24,309

 

2087
01:05:24,309 --> 01:05:26,390

 

2088
01:05:26,390 --> 01:05:28,069

 

2089
01:05:28,069 --> 01:05:30,150

 

2090
01:05:30,150 --> 01:05:31,910

 

2091
01:05:31,910 --> 01:05:33,750

 

2092
01:05:33,750 --> 01:05:36,710

 

2093
01:05:36,710 --> 01:05:39,510

 

2094
01:05:39,510 --> 01:05:42,549

 

2095
01:05:42,549 --> 01:05:44,870

 

2096
01:05:44,870 --> 01:05:44,880

 

2097
01:05:44,880 --> 01:05:45,750


2098
01:05:45,750 --> 01:05:47,829

 

2099
01:05:47,829 --> 01:05:49,910

 

2100
01:05:49,910 --> 01:05:52,230

 

2101
01:05:52,230 --> 01:05:54,390

 

2102
01:05:54,390 --> 01:05:55,829

 

2103
01:05:55,829 --> 01:05:58,549

 

2104
01:05:58,549 --> 01:06:02,549

 

2105
01:06:02,549 --> 01:06:06,230

 

2106
01:06:06,230 --> 01:06:09,109

 

2107
01:06:09,109 --> 01:06:11,430

 

2108
01:06:11,430 --> 01:06:14,950

 

2109
01:06:14,950 --> 01:06:14,960

 

2110
01:06:14,960 --> 01:06:15,750


2111
01:06:15,750 --> 01:06:18,390

 

2112
01:06:18,390 --> 01:06:20,470

 

2113
01:06:20,470 --> 01:06:20,480

 

2114
01:06:20,480 --> 01:06:21,829


2115
01:06:21,829 --> 01:06:23,750

 

2116
01:06:23,750 --> 01:06:25,589

 

2117
01:06:25,589 --> 01:06:27,670

 

2118
01:06:27,670 --> 01:06:27,680

 

2119
01:06:27,680 --> 01:06:28,390


2120
01:06:28,390 --> 01:06:29,670

 

2121
01:06:29,670 --> 01:06:32,390

 

2122
01:06:32,390 --> 01:06:33,990

 

2123
01:06:33,990 --> 01:06:34,000

 

2124
01:06:34,000 --> 01:06:36,230


2125
01:06:36,230 --> 01:06:41,589

 

2126
01:06:41,589 --> 01:06:44,150

 

2127
01:06:44,150 --> 01:06:47,029

 

2128
01:06:47,029 --> 01:06:50,230

 

2129
01:06:50,230 --> 01:06:52,150

 

2130
01:06:52,150 --> 01:06:54,710

 

2131
01:06:54,710 --> 01:06:57,029

 

2132
01:06:57,029 --> 01:06:59,270

 

2133
01:06:59,270 --> 01:07:01,029

 

2134
01:07:01,029 --> 01:07:02,230

 

2135
01:07:02,230 --> 01:07:05,109

 

2136
01:07:05,109 --> 01:07:05,119

 

2137
01:07:05,119 --> 01:07:06,390


2138
01:07:06,390 --> 01:07:07,589

 

2139
01:07:07,589 --> 01:07:10,230

 

2140
01:07:10,230 --> 01:07:12,470

 

2141
01:07:12,470 --> 01:07:18,069

 

2142
01:07:18,069 --> 01:07:19,829

 

2143
01:07:19,829 --> 01:07:22,150

 

2144
01:07:22,150 --> 01:07:23,990

 

2145
01:07:23,990 --> 01:07:26,470

 

2146
01:07:26,470 --> 01:07:28,390

 

2147
01:07:28,390 --> 01:07:30,710

 

2148
01:07:30,710 --> 01:07:33,190

 

2149
01:07:33,190 --> 01:07:35,029

 

2150
01:07:35,029 --> 01:07:36,870

 

2151
01:07:36,870 --> 01:07:41,349

 

2152
01:07:41,349 --> 01:07:43,910

 

2153
01:07:43,910 --> 01:07:46,069

 

2154
01:07:46,069 --> 01:07:46,079

 

2155
01:07:46,079 --> 01:07:47,430


2156
01:07:47,430 --> 01:07:50,470

 

2157
01:07:50,470 --> 01:07:52,710

 

2158
01:07:52,710 --> 01:07:55,829

 

2159
01:07:55,829 --> 01:07:57,510

 

2160
01:07:57,510 --> 01:07:59,990

 

2161
01:07:59,990 --> 01:08:01,990

 

2162
01:08:01,990 --> 01:08:04,069

 

2163
01:08:04,069 --> 01:08:06,390

 

2164
01:08:06,390 --> 01:08:08,390

 

2165
01:08:08,390 --> 01:08:10,470

 

2166
01:08:10,470 --> 01:08:12,950

 

2167
01:08:12,950 --> 01:08:12,960

 

2168
01:08:12,960 --> 01:08:15,670


2169
01:08:15,670 --> 01:08:15,680

 

2170
01:08:15,680 --> 01:08:17,349


2171
01:08:17,349 --> 01:08:19,430

 

2172
01:08:19,430 --> 01:08:21,990

 

2173
01:08:21,990 --> 01:08:24,789

 

2174
01:08:24,789 --> 01:08:24,799

 

2175
01:08:24,799 --> 01:08:25,829


2176
01:08:25,829 --> 01:08:27,349

 

2177
01:08:27,349 --> 01:08:30,229

 

2178
01:08:30,229 --> 01:08:32,229

 

2179
01:08:32,229 --> 01:08:34,149

 

2180
01:08:34,149 --> 01:08:37,749

 

2181
01:08:37,749 --> 01:08:39,590

 

2182
01:08:39,590 --> 01:08:40,550

 

2183
01:08:40,550 --> 01:08:42,550

 

2184
01:08:42,550 --> 01:08:43,910

 

2185
01:08:43,910 --> 01:08:46,709

 

2186
01:08:46,709 --> 01:08:50,390

 

2187
01:08:50,390 --> 01:08:52,470

 

2188
01:08:52,470 --> 01:08:54,470

 

2189
01:08:54,470 --> 01:08:57,349

 

2190
01:08:57,349 --> 01:08:59,349

 

2191
01:08:59,349 --> 01:09:01,910

 

2192
01:09:01,910 --> 01:09:05,430

 

2193
01:09:05,430 --> 01:09:07,669

 

2194
01:09:07,669 --> 01:09:09,349

 

2195
01:09:09,349 --> 01:09:11,269

 

2196
01:09:11,269 --> 01:09:13,749

 

2197
01:09:13,749 --> 01:09:16,709

 

2198
01:09:16,709 --> 01:09:18,950

 

2199
01:09:18,950 --> 01:09:21,349

 

2200
01:09:21,349 --> 01:09:23,829

 

2201
01:09:23,829 --> 01:09:26,229

 

2202
01:09:26,229 --> 01:09:28,229

 

2203
01:09:28,229 --> 01:09:30,789

 

2204
01:09:30,789 --> 01:09:32,550

 

2205
01:09:32,550 --> 01:09:37,189

 

2206
01:09:37,189 --> 01:09:39,430

 

2207
01:09:39,430 --> 01:09:41,829

 

2208
01:09:41,829 --> 01:09:44,550

 

2209
01:09:44,550 --> 01:09:47,829

 

2210
01:09:47,829 --> 01:09:49,669

 

2211
01:09:49,669 --> 01:09:51,829

 

2212
01:09:51,829 --> 01:09:54,390

 

2213
01:09:54,390 --> 01:09:56,470

 

2214
01:09:56,470 --> 01:09:59,510

 

2215
01:09:59,510 --> 01:10:02,229

 

2216
01:10:02,229 --> 01:10:04,550

 

2217
01:10:04,550 --> 01:10:06,470

 

2218
01:10:06,470 --> 01:10:07,990

 

2219
01:10:07,990 --> 01:10:10,310

 

2220
01:10:10,310 --> 01:10:10,320

 

2221
01:10:10,320 --> 01:10:11,270


2222
01:10:11,270 --> 01:10:13,510

 

2223
01:10:13,510 --> 01:10:15,669

 

2224
01:10:15,669 --> 01:10:17,510

 

2225
01:10:17,510 --> 01:10:19,430

 

2226
01:10:19,430 --> 01:10:20,709

 

2227
01:10:20,709 --> 01:10:23,750

 

2228
01:10:23,750 --> 01:10:28,310

 

2229
01:10:28,310 --> 01:10:30,310

 

2230
01:10:30,310 --> 01:10:32,870

 

2231
01:10:32,870 --> 01:10:34,709

 

2232
01:10:34,709 --> 01:10:36,229

 

2233
01:10:36,229 --> 01:10:39,510

 

2234
01:10:39,510 --> 01:10:41,910

 

2235
01:10:41,910 --> 01:10:44,630

 

2236
01:10:44,630 --> 01:10:47,830

 

2237
01:10:47,830 --> 01:10:47,840

 

2238
01:10:47,840 --> 01:10:49,430


2239
01:10:49,430 --> 01:10:53,189

 

2240
01:10:53,189 --> 01:10:53,199

 

2241
01:10:53,199 --> 01:10:56,550


2242
01:10:56,550 --> 01:10:57,990

 

2243
01:10:57,990 --> 01:10:58,000

 

2244
01:10:58,000 --> 01:10:59,189


2245
01:10:59,189 --> 01:11:01,750

 

2246
01:11:01,750 --> 01:11:03,189

 

2247
01:11:03,189 --> 01:11:04,550

 

2248
01:11:04,550 --> 01:11:07,430

 

2249
01:11:07,430 --> 01:11:09,590

 

2250
01:11:09,590 --> 01:11:11,750

 

2251
01:11:11,750 --> 01:11:14,310

 

2252
01:11:14,310 --> 01:11:17,270

 

2253
01:11:17,270 --> 01:11:17,280

 

2254
01:11:17,280 --> 01:11:18,310


2255
01:11:18,310 --> 01:11:20,550

 

2256
01:11:20,550 --> 01:11:22,470

 

2257
01:11:22,470 --> 01:11:24,870

 

2258
01:11:24,870 --> 01:11:26,390

 

2259
01:11:26,390 --> 01:11:29,189

 

2260
01:11:29,189 --> 01:11:32,709

 

2261
01:11:32,709 --> 01:11:34,390

 

2262
01:11:34,390 --> 01:11:37,990

 

2263
01:11:37,990 --> 01:11:40,790

 

2264
01:11:40,790 --> 01:11:42,390

 

2265
01:11:42,390 --> 01:11:43,750

 

2266
01:11:43,750 --> 01:11:45,080

 

2267
01:11:45,080 --> 01:11:45,090

 

2268
01:11:45,090 --> 01:11:46,630


2269
01:11:46,630 --> 01:11:48,070

 

2270
01:11:48,070 --> 01:11:50,310

 

2271
01:11:50,310 --> 01:11:50,320

 

2272
01:11:50,320 --> 01:11:52,149


2273
01:11:52,149 --> 01:11:54,550

 

2274
01:11:54,550 --> 01:11:57,270

 

2275
01:11:57,270 --> 01:11:59,669

 

2276
01:11:59,669 --> 01:12:01,430

 

2277
01:12:01,430 --> 01:12:06,630

 

2278
01:12:06,630 --> 01:12:10,630

 

2279
01:12:10,630 --> 01:12:12,390

 

2280
01:12:12,390 --> 01:12:12,400

 

2281
01:12:12,400 --> 01:12:13,350


2282
01:12:13,350 --> 01:12:16,149

 

2283
01:12:16,149 --> 01:12:16,159

 

2284
01:12:16,159 --> 01:12:17,189


2285
01:12:17,189 --> 01:12:21,110

 

2286
01:12:21,110 --> 01:12:22,790

 

2287
01:12:22,790 --> 01:12:25,669

 

2288
01:12:25,669 --> 01:12:28,070

 

2289
01:12:28,070 --> 01:12:29,590

 

2290
01:12:29,590 --> 01:12:29,600

 

2291
01:12:29,600 --> 01:12:30,630


2292
01:12:30,630 --> 01:12:31,990

 

2293
01:12:31,990 --> 01:12:32,000

 

2294
01:12:32,000 --> 01:12:33,510


2295
01:12:33,510 --> 01:12:35,430

 

2296
01:12:35,430 --> 01:12:36,950

 

2297
01:12:36,950 --> 01:12:39,270

 

2298
01:12:39,270 --> 01:12:41,750

 

2299
01:12:41,750 --> 01:12:41,760

 

2300
01:12:41,760 --> 01:12:43,590


2301
01:12:43,590 --> 01:12:45,910

 

2302
01:12:45,910 --> 01:12:48,830

 

2303
01:12:48,830 --> 01:12:48,840

 

2304
01:12:48,840 --> 01:12:50,550


2305
01:12:50,550 --> 01:12:52,709

 

2306
01:12:52,709 --> 01:12:54,709

 

2307
01:12:54,709 --> 01:12:56,630

 

2308
01:12:56,630 --> 01:12:58,950

 

2309
01:12:58,950 --> 01:13:01,669

 

2310
01:13:01,669 --> 01:13:04,550

 

2311
01:13:04,550 --> 01:13:11,669

 

2312
01:13:11,669 --> 01:13:14,550

 

2313
01:13:14,550 --> 01:13:16,790

 

2314
01:13:16,790 --> 01:13:19,270

 

2315
01:13:19,270 --> 01:13:21,830

 

2316
01:13:21,830 --> 01:13:24,070

 

2317
01:13:24,070 --> 01:13:26,790

 

2318
01:13:26,790 --> 01:13:28,550

 

2319
01:13:28,550 --> 01:13:30,390

 

2320
01:13:30,390 --> 01:13:32,709

 

2321
01:13:32,709 --> 01:13:34,229

 

2322
01:13:34,229 --> 01:13:34,239

 

2323
01:13:34,239 --> 01:13:35,910


2324
01:13:35,910 --> 01:13:38,149

 

2325
01:13:38,149 --> 01:13:40,070

 

2326
01:13:40,070 --> 01:13:42,070

 

2327
01:13:42,070 --> 01:13:44,149

 

2328
01:13:44,149 --> 01:13:46,709

 

2329
01:13:46,709 --> 01:13:49,430

 

2330
01:13:49,430 --> 01:13:51,430

 

2331
01:13:51,430 --> 01:13:53,830

 

2332
01:13:53,830 --> 01:13:55,669

 

2333
01:13:55,669 --> 01:13:57,990

 

2334
01:13:57,990 --> 01:14:00,950

 

2335
01:14:00,950 --> 01:14:02,950

 

2336
01:14:02,950 --> 01:14:05,990

 

2337
01:14:05,990 --> 01:14:08,310

 

2338
01:14:08,310 --> 01:14:12,149

 

2339
01:14:12,149 --> 01:14:14,470

 

2340
01:14:14,470 --> 01:14:17,110

 

2341
01:14:17,110 --> 01:14:19,669

 

2342
01:14:19,669 --> 01:14:22,790

 

2343
01:14:22,790 --> 01:14:26,390

 

2344
01:14:26,390 --> 01:14:28,470

 

2345
01:14:28,470 --> 01:14:30,630

 

2346
01:14:30,630 --> 01:14:33,030

 

2347
01:14:33,030 --> 01:14:34,709

 

2348
01:14:34,709 --> 01:14:36,470

 

2349
01:14:36,470 --> 01:14:38,630

 

2350
01:14:38,630 --> 01:14:40,950

 

2351
01:14:40,950 --> 01:14:43,590

 

2352
01:14:43,590 --> 01:14:44,950

 

2353
01:14:44,950 --> 01:14:46,149

 

2354
01:14:46,149 --> 01:14:46,159

 

2355
01:14:46,159 --> 01:14:47,510


2356
01:14:47,510 --> 01:14:51,030

 

2357
01:14:51,030 --> 01:14:53,590

 

2358
01:14:53,590 --> 01:14:56,310

 

2359
01:14:56,310 --> 01:14:59,110

 

2360
01:14:59,110 --> 01:15:02,070

 

2361
01:15:02,070 --> 01:15:02,080

 

2362
01:15:02,080 --> 01:15:03,590


2363
01:15:03,590 --> 01:15:03,600

 

2364
01:15:03,600 --> 01:15:04,550


2365
01:15:04,550 --> 01:15:04,560

 

2366
01:15:04,560 --> 01:15:05,590


2367
01:15:05,590 --> 01:15:08,149

 

2368
01:15:08,149 --> 01:15:09,430

 

2369
01:15:09,430 --> 01:15:11,030

 

2370
01:15:11,030 --> 01:15:11,040

 

2371
01:15:11,040 --> 01:15:12,149


2372
01:15:12,149 --> 01:15:13,270

 

2373
01:15:13,270 --> 01:15:15,270

 

2374
01:15:15,270 --> 01:15:17,590

 

2375
01:15:17,590 --> 01:15:19,430

 

2376
01:15:19,430 --> 01:15:21,270

 

2377
01:15:21,270 --> 01:15:22,709

 

2378
01:15:22,709 --> 01:15:24,630

 

2379
01:15:24,630 --> 01:15:27,110

 

2380
01:15:27,110 --> 01:15:28,709

 

2381
01:15:28,709 --> 01:15:28,719

 

2382
01:15:28,719 --> 01:15:29,669


2383
01:15:29,669 --> 01:15:31,750

 

2384
01:15:31,750 --> 01:15:34,310

 

2385
01:15:34,310 --> 01:15:37,030

 

2386
01:15:37,030 --> 01:15:40,550

 

2387
01:15:40,550 --> 01:15:42,470

 

2388
01:15:42,470 --> 01:15:45,430

 

2389
01:15:45,430 --> 01:15:46,790

 

2390
01:15:46,790 --> 01:15:49,669

 

2391
01:15:49,669 --> 01:15:51,750

 

2392
01:15:51,750 --> 01:15:54,149

 

2393
01:15:54,149 --> 01:15:57,590

 

2394
01:15:57,590 --> 01:16:00,390

 

2395
01:16:00,390 --> 01:16:02,229

 

2396
01:16:02,229 --> 01:16:04,229

 

2397
01:16:04,229 --> 01:16:06,470

 

2398
01:16:06,470 --> 01:16:08,070

 

2399
01:16:08,070 --> 01:16:10,070

 

2400
01:16:10,070 --> 01:16:10,080

 

2401
01:16:10,080 --> 01:16:11,270


2402
01:16:11,270 --> 01:16:12,709

 

2403
01:16:12,709 --> 01:16:15,270

 

2404
01:16:15,270 --> 01:16:15,280

 

2405
01:16:15,280 --> 01:16:17,030


2406
01:16:17,030 --> 01:16:21,350

 

2407
01:16:21,350 --> 01:16:22,149

 

2408
01:16:22,149 --> 01:16:24,070

 

2409
01:16:24,070 --> 01:16:27,350

 

2410
01:16:27,350 --> 01:16:29,669

 

2411
01:16:29,669 --> 01:16:31,110

 

2412
01:16:31,110 --> 01:16:34,229

 

2413
01:16:34,229 --> 01:16:35,750

 

2414
01:16:35,750 --> 01:16:38,550

 

2415
01:16:38,550 --> 01:16:40,390

 

2416
01:16:40,390 --> 01:16:43,270

 

2417
01:16:43,270 --> 01:16:46,229

 

2418
01:16:46,229 --> 01:16:46,239

 

2419
01:16:46,239 --> 01:16:49,110


2420
01:16:49,110 --> 01:16:52,070

 

2421
01:16:52,070 --> 01:16:55,510

 

2422
01:16:55,510 --> 01:16:57,750

 

2423
01:16:57,750 --> 01:16:59,990

 

2424
01:16:59,990 --> 01:17:01,590

 

2425
01:17:01,590 --> 01:17:03,430

 

2426
01:17:03,430 --> 01:17:06,550

 

2427
01:17:06,550 --> 01:17:06,560

 

2428
01:17:06,560 --> 01:17:07,510


2429
01:17:07,510 --> 01:17:10,070

 

2430
01:17:10,070 --> 01:17:10,080

 

2431
01:17:10,080 --> 01:17:11,350


2432
01:17:11,350 --> 01:17:14,550

 

2433
01:17:14,550 --> 01:17:16,790

 

2434
01:17:16,790 --> 01:17:20,470

 

2435
01:17:20,470 --> 01:17:22,229

 

2436
01:17:22,229 --> 01:17:25,270

 

2437
01:17:25,270 --> 01:17:28,070

 

2438
01:17:28,070 --> 01:17:30,709

 

2439
01:17:30,709 --> 01:17:33,510

 

2440
01:17:33,510 --> 01:17:35,990

 

2441
01:17:35,990 --> 01:17:38,470

 

2442
01:17:38,470 --> 01:17:38,480

 

2443
01:17:38,480 --> 01:17:39,350


2444
01:17:39,350 --> 01:17:40,630

 

2445
01:17:40,630 --> 01:17:43,350

 

2446
01:17:43,350 --> 01:17:46,550

 

2447
01:17:46,550 --> 01:17:46,560

 

2448
01:17:46,560 --> 01:17:47,750


2449
01:17:47,750 --> 01:17:49,590

 

2450
01:17:49,590 --> 01:17:51,750

 

2451
01:17:51,750 --> 01:17:53,110

 

2452
01:17:53,110 --> 01:17:57,270

 

2453
01:17:57,270 --> 01:17:57,280

 

2454
01:17:57,280 --> 01:17:59,669


2455
01:17:59,669 --> 01:18:02,630

 

2456
01:18:02,630 --> 01:18:04,709

 

2457
01:18:04,709 --> 01:18:06,310

 

2458
01:18:06,310 --> 01:18:08,070

 

2459
01:18:08,070 --> 01:18:10,470

 

2460
01:18:10,470 --> 01:18:12,070

 

2461
01:18:12,070 --> 01:18:13,510

 

2462
01:18:13,510 --> 01:18:16,229

 

2463
01:18:16,229 --> 01:18:18,229

 

2464
01:18:18,229 --> 01:18:20,870

 

2465
01:18:20,870 --> 01:18:26,149

 

2466
01:18:26,149 --> 01:18:27,910

 

2467
01:18:27,910 --> 01:18:29,430

 

2468
01:18:29,430 --> 01:18:32,229

 

2469
01:18:32,229 --> 01:18:35,030

 

2470
01:18:35,030 --> 01:18:38,310

 

2471
01:18:38,310 --> 01:18:40,790

 

2472
01:18:40,790 --> 01:18:41,990

 

2473
01:18:41,990 --> 01:18:42,000

 

2474
01:18:42,000 --> 01:18:43,030


2475
01:18:43,030 --> 01:18:45,350

 

2476
01:18:45,350 --> 01:18:47,669

 

2477
01:18:47,669 --> 01:18:50,070

 

2478
01:18:50,070 --> 01:18:52,870

 

2479
01:18:52,870 --> 01:18:54,870

 

2480
01:18:54,870 --> 01:18:57,270

 

2481
01:18:57,270 --> 01:18:59,270

 

2482
01:18:59,270 --> 01:18:59,280

 

2483
01:18:59,280 --> 01:19:00,510


2484
01:19:00,510 --> 01:19:02,870

 

2485
01:19:02,870 --> 01:19:04,790

 

2486
01:19:04,790 --> 01:19:07,110

 

2487
01:19:07,110 --> 01:19:07,120

 

2488
01:19:07,120 --> 01:19:22,070


2489
01:19:22,070 --> 01:19:22,080

 

2490
01:19:22,080 --> 01:19:24,159