1
00:00:24,800 --> 00:00:27,269

okay hello everybody  we'll get started  um  so  um  just recapping what we did  [Music]  a  in the last lecture on tuesday  we um  had a  it was kind of a two is the second part  of a two lecture sequence on the  hierarchy theorem  higher hierarchy theorems for time and  space  and using the hierarchy theorems to show  that there are that there is a problem  which is  intractable that's provably outside of  polynomial time  and that was this equivalence problem  for regular expressions with  exponentiation  and then we had a short discussion  about oracles  and the possibility that similar methods  might you might be used to show that  satisfiability is outside of p which  would then of course solve the p versus  mp problem and argued that um  it seems unlikely  um this kind of a meta theorem not not a  well uh  well-defined notion  but seems unlikely that the methods that  were used for proving  the um  uh  the intractability of um  equivalence of regular expressions with  exponentiation could be used to solve p  versus np at least um the the  diagonalization method kind of in a pure  form whatever that means uh that's not  going to be um enough  so today we're going to  shift gears again begin a somewhat  different topic which is really kind of  um going to be our uh  again a  few lectures on probabilistic  computation which is going to wrap round  out the semester for us  um and we're going to start by talking  about a different model of computation  which allows for uh probabilis  probabilism in the  measuring the amount of probabilism or  measuring the probability allowing for  probabilism in the computation  define an associated complexity class uh  this class bpp  and then start to start the discussion  of an example um  about something called branching  programs  okay um  so uh with that in mind um  uh  um  a  uh  so we're gonna start off by defining  the notion of a probabilistic  turing machine or ptm  um a probabilistic turing machine is a  lot like  the way we have thought about  non-deterministic touring machines  in that it's a kind of a machine that  can have multiple choices multiple ways  to go  in its computation so there's not just  going to be a fixed uh deterministic  path  um of its computation but there's going  to be a tree of possibilities um and for  our purposes we're going to limit the  branching in that tree to be either  um a step of the computation where  there's no branching where it's a  deterministic step  uh as shown over here um so every step  of the way leads uniquely to the next  step  or there might be some steps which have  a choice and we're only going to allow  for these purposes uh to keep life  simple  um having only uh a choice among two  possibilities  um  and we'll associate to that  uh  um  the notion of a  probability that each choice will have a  50 50 chance of getting taken  and this kind of corresponds with the  way some of us or some of you think  about non-determinism which is not  exactly right up and up until this point  is that the machine is kind of taking a  random branch it really we don't think  about it randomly until now now we're  going to think about the machine as  actually taking  sort of picking a random choice among  all the different branches that it could  make um and picking the choice kind of  uniformly by flipping a coin every time  it has an option of which way to go  uh  now you could  define i'm getting a question here uh  the uh a machine that has several  different ways to more than two ways to  go and then you would need to have a  three-way coin a four-way coin and so on  and you could define it all of that that  way  as well but it doesn't end up giving you  anything different or anything uh  interesting or new for uh for the kinds  of things we're going to be discussing  so and it's just going to be simpler to  keep the discussion limited to the case  where the machine can only have two  possibilities um if it's going to be  having a choice at all or or just one  possibility when there's no choice  okay so um so now we're going to have to  talk about the probability of a  the machine taking a sum branch of its  computation so you imagine here here is  the same computation tree that we've  seen before in the case of ordinary  non-deterministic machines where you  have m on w there could be several  different ways to go and there might be  some particular branch but now we want  to talk about the probability that the  machine actually ends up picking that  branch  and it's going to be  um  uh  you know when we talk about  uh  the machine having a choice of ways to  go we're going to associate that with a  coin flip so we're going to call that a  coin flip step when the machine has a  possibility of ways to go and so on a  particular branch  the probability of that branch occurring  is going to be one over two to the  number of coin flips  coin flip states on that branch  and the reason for i mean this is kind  of the the  the definition that makes sense um in  that if you imagine looking at the  computation tree here and here is the  branch that we're focusing on um of  interest  every time there's a coin flip on that  branch  there's a 50 50 chance of taking a  different branch or staying on that  branch  so the more coin flips there are on some  particular branch the less likely that  branch would be the one that the machine  actually actually ends up taking taking  and so it's going to be one over two to  the number of coin flips  and that's the way we're defining it  now once we have that notion  we can also talk about the probability  that the machine ends up accepting  because each as before each of these  branches is going to end up  at an accept state or reject state i'm  thinking about this only in terms of  deciders  and  the probability of  the machine accepting here is just going  to be the sum over all probabilities of  the branches that end up accepting  so just add up all of those  probabilities of a branch leading to an  accept and we'll call that the  probability that the machine accepts its  input  [Music]  and the probability that the machine  rejects is going to be one minus the  probability that it accepts  because it's going to the machine um on  every branch is either either going to  do one or the other  okay um  now if you're thinking about a  particular language  that the machine is trying to decide  this probabilistic machine now is trying  to decide  um you know  on on each input  some of the branches of the machine may  not may give the correct answer they're  going to accept when the input is in the  language other branches may give the  wrong answer they may reject when the  input is in the language and vice versa  so there's going to be a possibility of  error now in the machine in any  particular branch it might actually give  the wrong answer  and what we're going to say is bound  that error  over all possible inputs  um and so and uh  we'll say that the machine for any  epsilon greater than or equal to zero  um we will say that the machine decides  the language with error probability  epsilon  if that's the worst that can possibly  happen you know if every  um for every input the machine gives the  wrong answer  with probability at most epsilon  um equivalently if you like to spell it  out a little bit more  you know  a little differently  for  strings that are in the language the  probability that the machine rejects  that input is going to be at most  epsilon and for strings in the language  the probability of for strings not in  the language the probability that  accepts is a most epsilon  so again this is  the machine doing the the thing that  it's not supposed to be doing for things  in the language it should be rejecting  very rarely for things not in the  language it should be accepting very  rarely and that's what this bound is  doing for you  okay  um  [Music]  so let's just see uh  so we'll talk about so i'm getting some  questions here about um  um  so let me just look at these one second  here  the  yeah so  probability zero so there's a  possibility that the machine have might  have a probability zero say of accepting  that means there are no branches that  end up accepting or probability zero of  rejecting there were no rejecting  branches  um but i think we're going to talk in a  minute about the connection between this  and and the standard notion of np  um so just hold off on that for a second  uh  also about what what about the you know  the um the possibility that the machine  is you know  being a decider or running in a certain  amount of time um so we will look at  time-bounded machines  in a second um  on the next slide or two um talking  about machines that run in polynomial  time so that means all branches have to  halt within some polynomial number of  steps um so that's where we're going  but for the time being we're only  looking at the siders where the machine  has to hold on every branch  but some branches might run for a long  time but  for now we're not going to be thinking  about machines that have branches that  run um forever where all of our machines  are deciders so they they hold on every  branch  see there's anything else here no so why  don't i move on so let's define now  the class bpp  using this notion of a probabilistic  turing machine which is now going to be  running in polynomial time  so bpp is going to be another one of  these complexity classes a collection of  languages like p and np and p space and  so on and um but it's going to be now  associated with the capabilities of  these probabilistic machines the kinds  of languages that they can do  so we'll say the class bpp  is the set of languages a  such that there's some probabilistic  polynomial time  during machines so all branches have to  halt within you know to the k for some k  so some polynomial time  polynomial time probabilistic turing  machine decides a with error possibility  at most one-third  so in other words  when it's accepting  for some for strings in the language the  machine has to reject with at most  one-third so saying it equivalently for  strings in the language it has to accept  with two-thirds probability and for  strings not in the language it has to  reject what two-thirds probability at  least  in both cases  um  okay  somehow ended up with  didn't check my animation here but okay  that's fine so there is a um  uh  now if you look at the one-third here in  the definition  uh  you know it seems strange to define a  complexity class in terms of some  arbitrary constant like one-third why  didn't we use one-quarter  you know or uh  you know one-tenth in the definition of  bpp  and say the machine has to get have an  error with at most one tenth or one  hundredth uh  well it doesn't matter  and that's the point of this uh  next statement called the amplification  lemma  which says that  um  you can always if you have a machine  that's running in a certain  uh  a polynomial time that's running within  this with a certain error which it is  most one-half if you have an error  one-half it's not interesting because  the machine  could just flip a coin for every uh  input and it could get uh the right  answer with it with probability one-half  so probability one-half is not  interesting you have to have probability  strictly less than one-half for the  machine to actually be doing something  that's meaningful about that language  so  um  if you have a  probabilistic turing machine that has  error  let's say epsilon one which is at most  one half which is less than one half  then you can convert that to any  error probability you want  for some other  polynomial time probabilistic turing  machine so you can make that error which  maybe starts out as one-third and you  can drive that error down to one out of  one over or google  um  and seriously you can really make the  error extremely extremely small  using a very simple procedure  and and that's simply this  so if you're starting out with a machine  that has an error possibility of  one-third say so that means  two-thirds of the time it's going to get  the right answer and at most one-third  of the time at least two-thirds of the  time the right answer most one-third of  the time the the incorrect answer  whether that's accepting or rejecting  um and now you want to get that answer  down to be something much that error  down to something much smaller  um  the the idea is you just you're going to  take that machine  and you're  going to run it multiple times  it's kind of with independent runs if  that me if you want to think about it  you sort of more formally speaking but  it's sort of intuitive you're just going  to run the machine  uh tossing your coins  um  uh instead of just running it once  you're going to run the machine 100  times or or a million times but you can  do that so it's a constant factor  and even a thousand times is going to be  enough to increase your confidence in  the result tremendously because  if you run the machine a thousand times  and 600 of those times the mach the  machine accepts and 400 of the time the  machine rejects  um  uh  it's very powerful evidence that this  machine is biased toward accepting that  it's accepting most of the time  um so it's um was  uh  if it had an error  probability of most one-third um  uh  the the probability that you're  seeing it except  600 times when really two-thirds of the  time it's rejecting overall  is extremely unlikely  um and you can calculate that uh which  we're not going to bother to do but it's  a routine probability calculation uh to  show that the the probability that if  you run it a whole bunch of times and  you see the majority coming up  um which is not the  not the right answer that's extremely  the  the probability of that is extremely  small  um  so i'm not saying that very clearly but  um  the the the  the method here is you're going to  take your original machine  which has error probability one-third  or whatever it whatever it is some you  know you know maybe  has error probability 49  and you run it uh for a large number of  times and then you take the majority  vote  and  it you're kind of sampling the the  outcomes of this machine and if you take  enough samples it's overwhelmingly  likely since you're just doing them  uniformly you're taking those samples  uniformly it's overwhelmingly likely  that you're going to be seeing the  predominant one come up more often um  and exactly what that right value is  we're not going to bother to calculate  but that's something that  you know if you i will i'll refer you to  the textbook or you know that's the kind  of thing that comes up in any elementary  probability book and it's sort of very  intuitive so i don't want to spend the  time and do that calculation which is  not all that interesting  um  uh okay so just one quick question here  that i'm getting  what happens if you bound if the error  is greater than a half i don't think  that because we're bounding the error so  we're not saying the error actually is  one you know like sixty percent on  everything because then if you knew the  error was sixty percent  guaranteed you can always just flip the  flip your answer around and get your um  error to be 40  but you know i'm saying the error is  that most  whatever epsilon is and so um if it's  you're saying the error is at most 60  percent it doesn't tell you anything  um  okay um  [Music]  uh  another question is does the  amplification lemma also justify that  the choice of model with binary  branching choices is equivalent to any  other  perhaps you could say that um  because you can change those  you know if you had through a three-way  branching um you can simulate that with  two-way branching to any accuracy that  you want um  you know  not going to get it down to zero but  you're going to get it very close  um so it's  maybe it's the amplification level maybe  it's  yeah sort of all related um  okay let's move on um  so  the way that it's helpful to think about  this class let's let's contrast it with  the other model of non-deterministic  computation that we have is  non-determinism is np  uh so non-deterministic then the model  of non-deterministic polynomial time  computation was np um the other class  and um  so the way  it's i think one way to look at to think  about non-determinism in the case of np  is  for strings in the language for your np  turing machine  there's at least one accepting branch  so i'm indicating the accepting ones in  green and the non-accepting one the  rejecting branches in red  so you could have  almost all of the branches be rejecting  branches um  for strings in the language as long as  there is at least one accepting branch  that's just the way non-determinism  works the accepting branch overrules all  the all of the others it's only when  you're not in the language that you that  all of the branches turn out to have to  be rejecting that's when the rejecting  sort of  you know it's it has no accepting branch  to overroll it  um but the situation for bpp is a little  different it is is different um there  it's kind of majority majority rules  so um  in the case for strings in the language  you you need to have  a large or you know the the overwhelming  majority of the  branches have to be accepting and for  strings not in the language the  overwhelming majority have to be  rejecting  what you're not going to allow in the  case of  bpp is kind of you know  an in-between  uh  state where it's sort of 50-50  um or very very close to 50-50 um those  kinds of machines are not  don't qualify as  uh deciding a language in bpp they  always have to kind of lean one way or  lean the other way for every input  otherwise you won't be able to do the  amplification so need to have some bias  um away from in half in  in accepting or rejecting  um  so  let me so i was going to ask a check-in  i think at this point yes let's  so just thinking about bpp i hope i was  clear so if there's questions about that  i think i've  somehow didn't  i'm not sure i described it totally well  here um so i'm going to ask a few  questions about ppp but if you have any  questions for me first  go ahead  um  okay why don't we just run the check-in  um  let me launch this and then i can answer  questions as you're asking  did i start that yeah  okay so you have to um  check all of these that you think are  true  um  can you think of non-deterministic  turing machines as try all branches at  once  and get the right answer  um  and bp is guess only one or uh i guess  only one branch i don't know um  you know i would say a little  differently i would say i i would think  of non-determinism as you can still just  try one branch but you always guess the  right one  um  so there's some sort of a you know  magical power that allows you always to  guess the right answer if there's a  right guess uh if you're in the language  uh in the case of bpp  you're going to be um picking a random  branch no matter what  and you know that the random branch is  likely to give the right answer but not  guaranteed  and the implication the amplification  limit tells you you can arrange things  so that it's extremely likely  that the random branch is going to give  you the right answer  okay let's see how we doing on our uh  check-in here  um  got a lot of vote we've got a lot of  support for all candidates  um  and um  i'll give you give you another uh  a little bit of time here because  there's a bunch of questions almost like  four check-ins at once  um  but we have two more check real  check-ins coming  later um  okay so why don't we uh come and  let's uh give another 10 seconds and  then i'm going to stop  closing down  one two three  close  okay  so uh we've got a lot of support here uh  and in fact  that's good because all of them are true  um  some of them are easier to see than  others  so first of all c is very easy to see um  because that that's a going to be a  machine that has the correct answer all  of it all of the time so that's error  probability zero  um on both accepting and rejecting  um  this is a little harder d is a little  bit harder to see that's in p space but  you know you could  calculate for every branch  um what its probability is and you can  just go through all the branches and add  up all those probabilities in a p-space  machine  so um you have to think about a little  bit but d is not too hard to see either  closure under complement  if you just take your  your bpp machine and you flip the answer  on every branch  um that's typically doesn't work in  non-determined ordinary non-determinism  but it does work here  because it's going to change a bias  toward accepting into a bias toward  rejecting and vice versa so bpp is  closed under compliment  uh and closure under union it kind of  follows from the amplification level as  long as you can make the probability  extremely small  then you can just run the two different  machines  and  even though the they each might make a  mistake cumulatively the total  the probability that each one of them  that either of them will make a mistake  is still small and so you can just run  to the two machines and take the or of  the responses that they get and it's  still very likely to give the right  answer for the union  okay um  [Music]  let's continue  uh so what i'm going to do now  for the rest of the lecture uh is and  it's actually going to spill over into  the lecture after thanksgiving because  this is going to introduce an important  method for us  is to look at an example of a problem  that's in bpp  um i love to teach things by using  examples um and so this is a very good  example because it has a lot of meat to  it  and it's a very interesting example in  general proving things in bpp which are  not trivially there because they're  already in p they tend to be uh somewhat  more involved than um  uh some of the other algorithms we've  seen so there are no simple examples of  problems in bpp  which are not already in p  um  so this is uh  one example that we're going to go  through of a problem in bpp that's not  known to bnp  of course things could collapse down um  but uh uh  as star as far as we know  this is  um not this language is not in p so  let's let's see what the language is  has to do with these things called  branching programs the branching program  is a structure that looks like this  so let's understand what the pieces are  first of all it's a graph directed graph  and uh we're not we're not going to  allow and there is are no cycles allowed  in this graph it's a directed acyclic  graph  um  so you can no loops allowed  and  the nodes are in two categories  there are query nodes which are labeled  with a variable letter  and output nodes which are labeled  either zero or one  and lastly there is a one of the query  nodes is going to be or one of the nodes  is going to be designated as a start  okay  and so what you do  is  the way um  this is a model of computation um and  the way we actually use  a branching program  is we  have some assignment to the variables  that's going to be the input  so you take all of the the variables  there are three variables in this case  um x1 x2 and x3 you assign you give them  some truth assignment um so x let's  let's say zeros and one so x1 is zero x1  is one or whatever  and  once you have the truth assignment you  start  at the start variable  and you  and you look at its label  and you see what value the input has  assigned to that variable  so if x1 assigned  a one you're going to follow down the  one branch but assigned to zero you  follow you go down the zero branch and  then when you get down to the  next node  that's another  variable that you're going to have to  query depending upon what the input  assignment is  and you're just going to  continue that process  because there are no cycles  you're going to end up at one of the  output nodes because all of the variable  nodes all the all the query nodes  have  two outgoing edges one labeled zero one  labeled one  so you're gonna eventually end up at an  output node and that's going to be the  output of the branching program  so we'll do let's do a quick example  so if x1 is 1 x2 is 0 and x3 is 1.  so we again we start at the start  variable the start node that has the  indicated with the  arrow coming in from nowhere so you're  going to start at x1  uh  the node labeled x1 so you have to look  and see what is x1 in the input it's a  1. so you're going to follow down the  one branch  now you see the next node oh that's an  x3  see what's x3 in the input x3 is a 1.  so you go down to one branch again  now you have an x2 node take a look at  the input x2 is a zero you follow the  zero branch now you're at an output  branch output node so that's a zero and  that's the output of the of the of this  computation so  um writing it this way and thinking  about it as a boolean function which  maps you know strings of zeros and ones  we have f of one zero one representing  those that assign that assignment that  equals zero that was the output and  uh  that's the output of this computation  okay  um  so important to underst we're going to  spend a lot of time  you know talking about branching  programs so it's critical to understand  this model i think it's fairly simple  but if you didn't get it please ask  we can easily correct up any  misunderstanding at this point  it's not exactly the same as a dfa  dfas for one thing can take inputs of  any length  um  this  this has inputs of some particular  length  where the branching program has some  fixed number of variables  this one has three so this only takes  inputs of length three um so there's  maybe some connection to thinking these  estates and so on but it's a different  model  so now we'll say that two branching  programs  um  okay let me just ask one more question  not all nodes need to be used right  um  yeah  there's no requirement that all nodes  need to be used and that even could be  inaccessible nodes i'm not preventing  that uh that could be okay um so on the  particular branch certainly you're not  gonna you know when you're executing  this  branching program on an input obvious  certainly you're to have a path that's  going to only use some part of the  tree  part of the graph  but  there might be some  paths that can  can never occur  you know so if you went down x equal to  one here and then x three was zero  now you're re-reading x one so you'd  never you could you wouldn't go down  this branch  unless you  i think all of the branches in this  particular branching program could get  used but i didn't check that so maybe  i'm wrong um  okay so let's continue two branching  programs may may or may not compute the  same function  um we'll say they're equivalent if they  do  now  two  branching programs can be equivalent  even though they superficially look  different from one another  and we're interested in the  computational problem of given two of  these branching programs do they compute  the same function do they in other words  do they always give the same answer  um on the setting of the input uh  so we'll define the associated language  equivalence problem for branching  programs says that you're given two of  these branching programs and they're  equivalent to be in the language we're  going to sometimes write equivalence  using the mathematical notation of the  three lined equals equal sign  the equivalence sign  okay that means they compute the same  they always give the same answer  now that problem  turns out to be cohen p  complete i've asked you to show on your  homework i believe  um  this is not a super hard reduction um  it's the in comp complete by the way is  the complement of an mp complete problem  or equivalently it's a problem to which  all co np problems are polynomial time  reducible and it's in coin  [Music]  so  uh  this is coin p complete  and  that's for you to show um  but that has an important  significance for us right now  um because if you if  you know looking at the question of  whether this problem is in bpp  the fact that it's coin  co np complete suggests that the answer  is no  because  if  a co np complete or np complete problem  more in bpp  because everything else in np or cmp is  reducible to that problem then all of  those np or co-np problems would be in  bpp for the exactly the same reason that  we've seen before  um and that's not known to be the case  and not believed to be the case um  so  uh we don't expect that a co-mp complete  problem is going to be in bpp um that  would be you know an amazing uh and  surprising uh  uh result so um  because i i hope i made it clear in my  previous um you know in previous  discussion that  you know the bpp from a practical  standpoint is very close to being like p  um because you can make the error  probability of the machine so incredibly  low  um  that  you know it's a comparable  uh  you know if you run the machine and the  error probability is like one over  google um  then it's sort of  even greater than the probability that  some alpha particle came in and flipped  the value of what some internal uh  memory cell in your in your computation  so if you have an extremely low error  probability it's pretty good from a  practical standpoint um  so it would be amazing if np problems  were solvable in bpp um  so  this is not the language we're going to  use as our example we're going to look  at a related restricted version of this  problem about equivalence for branching  programs and that i'm going to introduce  right now  okay any questions here  don't see any questions  um  fading out  uh okay  um  so let's move on  so we're going to talk about branching  programs that are what are called read  once  read once branching programs  and those are simply branching programs  that are not allowed to re-read  an input that they've previously read  so for example  is this  branching program a read once branching  program  no  this branching program is not a read  once branching program because  um  you can  find a path that's going to cause you to  read the same variable more than once so  it's not going to be a read once  um so over here let's not read once  because there's two  occurrences of an x1 on the same branch  now you might ask why would anybody want  to do that because you've already read  the value of x1 well i mean in the case  of this particular branching program  there might be a value because you could  have got to this x x1 branch by going  this way or that way  um  but that's a separate question  if we restrict our attention  to read once branching programs then the  problem of testing equivalence becomes  uh  very different in character  and in fact we're going to give a  probabilistic algorithm uh  a bpp algorithm to solve that problem  so the equivalence problem for read once  branching programs which are not allowed  to re-read variables on any path  um that's interestingly going to be  solvable with a probabilistic  uh polynomial time algorithm you know  with a small error probability  um  so i'm going to run a check in now but  let's make sure we're all together on  this so i got a good question here can  every boolean function be described by a  branching program yes  that's an easy exercise but you can make  branch branching programs are um they  may be large  uh you can describe any boolean function  with some branching program  that's not hard to show  um  other questions are we all together on  understanding what read once means and  branching programs and all that stuff  this is a good time to ask if you're not  um  okay so let's do the check-in  so  as i pointed out we will show that the  equivalence for read once branching  programs is solvable in bpp  can we use that to solve the general  case for branching programs  by converting branch general branching  programs to read once branching programs  and then run running the read once test  so  what do you think  okay i'm seeing a lot of uh  correct answers here um so let's let's  wrap this one one up quickly  um  another 10 seconds please  okay  ready are we all ready  one two three closing  all right yes  most of you have  uh  answered correctly um  well answer a is not a very good answer  because we already commented on the  previous slide that we don't know how to  do  the general case in bpp so it would be  kind of surprising if right here i'm  saying yes we could do it  by using the restricted case so  you know i think a  better answer would be to one of the  no's but  as i did comment you can always convert  you can always do any uh boolean  function uh with a  well maybe i didn't say it for read once  branching programs but you even read  once branching programs can do any  compute any boolean function um so the  the conversion is possible but in  general will not be polynomial time and  you can if you imagine you've been  trying to do the conversion over here  you could convert this branching program  to read once um but you'd have to  basically separate the two  uh  um  you know instead of re-reading the x1  you could remember that x1 value but  then you would not be you couldn't  reconverge over here you'd have to keep  those two those two  threads of the those two branches of the  computation apart  those two paths apart from one another  and already the branching program would  start to increase in size by doing that  um  and um  so in general  conversion converting is possible but it  requires a big expansion a big  increase in the size  and then we will  not allow a polynomial time algorithm  anymore even in probabilistic in the  probabilistic case  um  okay um  so now let's start to look at the  possibility of showing that this  equivalence problem is solvable in bpp  and it's going to take us in kind of  a strange direction but let's let's try  to get our intuition going first by  doing something  which seems like the most obvious  obvious approach  um  so here  uh so we're gonna  give a  an algorithm now um  uh which is going to be an attempt  it's not going to work but nevertheless  it's going to have the germ of the right  idea or the or the  not the germ but the beginning of the  right way to think about it  so here are the two branching read once  branching programs are b1 and b2  and i want to see  do they compute the same function or not  um so one thing you might try  is just running them on a bunch of  randomly selected  assignments or inputs  all right so you're going to you can  just um  take two randomness input assignments  just take x1  flip a coin to say it's one of zero x do  the same for x two and so on  um then you get some input assignment  you run the two branching programs on  that assignment  and maybe that doesn't give you know  even if they agree it doesn't give you a  lot of confidence that you got the right  answer uh  that they're really equivalent so you do  it a hundred times whatever some some  number of times um  and  of course  if  they uh ever disagree  on some assignment on one of those  assignments then you know they're not  equivalent and you can immediately  reject  um  but  uh what i'd like to say is if they  agree  on those  you know hundred  tries those hundred assignments there  then  there then they are um  uh  at least i'll i haven't found a place  where they disagree so i'm gonna say  that they're equivalent  is that a reasonable thing uh to do  well it might be  uh it depends on k um  so the critical thing is what value of k  should you pick  which is going to be big enough to allow  us to draw the conclusion that if you  run it for k times and you never see a  difference  then you can  conclude  with good confidence that the two  branching programs are equivalent  because  you've tried to look for  a difference and you never found one  well the thing is is that  um  k is going to have to be pretty big  uh  so  looking at it this way if the two  branching programs were equivalent  then certainly they're always going to  give the same value  um  so the probability that the machine  accepts is going to be one and that's  good  because we want for  this is a case when we're in the  language we want the probability of  acceptance to be high and here the  probability of acceptance is actually  one  so it's always going to accept when the  two uh branching  programs were equivalent  but what happens when the branching  programs are not equivalent  now we want the probability of rejection  to be high the probability of acceptance  should be very low  um  right so if if they're not equivalent we  want the probability that the machine  rejects is going to be  high if they're not equivalent because  that that's what the correct answer is  well the only way the machine is going  to reject  if it finds  um a place  where the two branching programs  disagree  but but  those two branching programs even though  not equivalent  might disagree rarely  they might only disagree on one input  assignment out of the two to the end  possibilities  so these two inequivalent branching  programs might agree almost everywhere  just except at one place and then that's  enough for them not to be equivalent but  the problem is that if you're just going  to do random sampling  um the likelihood of finding that one  exceptional place where the two disagree  is very low you're going to have to do  an enormous number of samples before  you're likely to actually to to to find  that uh that point of difference um and  so  um  in order to be confident that you're  going to find that difference if there  is one you're going to have to do  exponentially many samples and you don't  have time to do that with a polynomial  time algorithm  um  you're just going to have to flip too  many coins you have to run too many  different  samples  different assignments through these two  machines  and um because they're almost  they're different but they're almost the  same  um  so we're going to need to find a  different method  and  um the the idea is we're going to run  these two  branching programs  in some crazy way  instead of running them on zeros and  ones that we've been we've been doing it  so far we're going to feed in  values for the variables  which are non-boolean  they are going to be going to set x1 to  2 x3 to 7  x  4 to 15.  of course that doesn't seem to make any  sense but it's nevertheless going to  turn out to be useful a useful thing to  do and it's going to give us some  insight into  the equivalence or equivalence of these  branching programs um  okay um  so let's just i think are we at the end  yeah we're at the break here so why  don't i i'm getting some questions  coming in which is great um i will  answer those questions but why don't i  start off our uh  break and then um  okay  okay so  there's a question about whether these  this machine runs deterministically or  not so which machine are we talking  about  so the branching programs themselves  that they'd run deterministically you  give them an assignment to the um to the  input variables  that's going to determine a path through  each branching program  which is eventually going to output a  zero or a one  and you want to know do those two  branching programs always give the same  value no matter what the input was  but the branching programs themselves  were deterministic  um now the machine that's trying to  make the determination of whether those  two branching programs are equivalent  that machine that we're going to be  arguing is going to be a probabilistic  machine so it's a kind of  non-deterministic machine that's going  to have different possible ways to go  depending upon the outcome if it's of  its coin tosses  so it you can think of as  non-determinist you know  non-determinism in the ordinary sense  about how like that it has a tree of  possibilities  but um now  you know the way we're thinking about  acceptance is different you know that  instead of accepting if there's just one  uh accept branch  the machine for it to accept um has to  have a majority of the branches be  accepting um  and uh  you know  so it's it's  there's some similarities but some  differences with the usual way we think  of non-determinism  so what's the motivation behind  introducing this type of turing machine  well i mean there's a lot  i guess there are two motivations  uh  probabilistic algorithms sometimes  called monte carlo algorithms um  uh turn out to be useful in practice for  a variety of things  and um  so that led to  um  people to think about them in the  context of complexity  um they're related in some ways to  quantum computers which are also  probabilistic in in a somewhat different  way um but they also have a very nice um  uh  um  uh  formulation in complexity theory  so complexity theorists like to think  about probabilistic computation because  i mean you can do interesting things  with probabilistic machines and the  complexity classes associated are also  interesting so as you'll see  it leads us in an interesting direction  uh to consider how to solve this problem  this read once branching program problem  equivalence  with a probabilistic machine it's just  just an interesting um algorithm that  we're going to come up with  um  so in our pro in our proof attempt where  did we use the probabilistic nature for  bpp because we're running the two  branching programs on a random input  um  i mean  so you know you have your two branching  programs you pick a random  input to run those two branching  programs and you see what they do  that's where that's why it's  probabilistic  when you're thinking about random  behavior of the machine  it's a um that's a probabilistic machine  so each branch of the machine  is going to be like the way we normally  think about non-determinism somebody's  asking whether  we think of the complexity of the  machine in terms of all of the branches  of the machine  or  um each branch separately it's we always  think about for non-deterministic  machines each branch separately  um i'm not totally sure i understand the  question there so are all the inputs  built in and we randomly choose one  through coin flips  not sure i understand that question  either we're given as input the two  branching programs  and then we flip coins you know kind of  using our non-determinism  you can think about it equivalent in  terms of coin flips to choose the values  of the variables so now we have a set of  variable  inputs to the  values of the variables  and we use that to  um as input to the branching programs to  see what whether they  to see what answers they give and we in  particular whether they give the same  answer on that randomly chosen uh input  let's move on um  all right  so now sort of moving us toward  um  the actual bpp algorithm for uh  um read once branching program  equivalence  testing um  we have to think about  a different way  to  um  we need an alternate way of thinking  about  the computation of a branching program  it's going to look very similar but it's  going to lead us in a direction that's  going to allow us to talk about this  um these non-boolean inputs that i refer  to um just kind of where we're going  we're going to be simulating branching  programs with polynomials  if that helps you sort of as an  overarching plan but we'll we'll get  there a little slowly  so okay here's a branching program  read once branching program um we're not  going to use the read once feature uh  just yet but we'll that'll come later  but anyway here's a branching program  um  and um  uh  oh here's my branch and i  put crashed here  start that again  um  okay so we take an input  um whatever it is um  and  thinking about the computation of the  branching process so we're not thinking  about the algorithm right now we're just  thinking about branching programs for  the minute we're going to get back to  the algorithm later  so the branching program follows a path  as i indicated when you have a  particular input your x1 is 0  x2 is 1  x3 is 1 so the output is going to be 1  in this case  okay  so  the way i want to think about this a  little differently  is i want to label all of the nodes and  all of the edges  uh with a value  that tells me whether or not this yellow  path went through that node or edge  it's going to be just a  doing the same but  you may think this is no difference at  all but i want to label all the all of  the things on the yellow path  i'm going to label them or the one  and all of the things that are not on  the yellow path  i'm going to label with a zero  so i'm keeping those trying to keep  those labels apart from the original  branching program  which are written in white these labels  are written yellow  but these labels have to do with the  execution of the branching program on an  input  so once i have an input that's going to  determine a one or a zero  label  for every node and edge  now  if we want to look at the output from  this branching program after we have  that labeling we only have to look at  the label of the one output node because  that's if that one has a one on it that  means that the path went through that  one and so therefore we should output  output output uh the output is one  um  uh  so  i'm going to give you another way of  assigning that instead of just coming  finding the path first and then coming  up with the labeling afterward i'm going  to give you a different way of coming up  with that labeling kind of building it  up inductively starting at the start  node and building up that labeling  you'll see what i mean  by my example  so if i have a label on this node  so i already know  whether or not the path went through  that node  you know label 1 means the path went  through it label 0 means the path  doesn't it does not go through it  [Music]  that's going to tell me how to label the  two outgoing edges  so if i'm if i've already labeled this  with a where a is a zero or one then  uh  what what expression should i use  um  to how do  under what circumstances will i label  what's what's the right label for this  one outgoing edge here  well if a is zero  that means the pair we know the path did  not go through this node so there's no  way it could go through that edge  similarly  if x i  is a zero  that means even if we did go through  that node  the path would go through the other edge  other outgoing edge and not to this one  so that tells us that the boolean  expression which describes the value the  label of this uh node in the execution  is going to be the and  of the  the value on the node and the um the  query variable of that node  now  think about what's the right way to  label the other edge  the the execution value of the other  edge  again you have to have go through this  node so a has to be one but now you want  x i to be 0 in order to go through that  edge so that means it's going to be a  and the complement of x i  okay so this is going to just tell me  this i'm writing a formula for how we're  labeling these uh these edges  based on the label of the of the parent  node  similarly if i have a bunch of edges  where i already know the values the  labels uh the execution levels there  let's say so i have a1 a2 and a3 what is  the right label to put on this node  um  well if any one of those is a one  that means the path went through that  edge and so therefore it's going to go  through that node  so that tells us that the label to put  on that node is the or  of the labels on the incoming edges  okay  questions on this  so now this is kind of setting the stage  for  starting to think about this  um  more toward polynomials instead instead  of using a boolean algebra  so um  quite i'm getting question how do we  know what the execution path is which  nodes to label we're going to be  labeling all of the nodes  so we start off with labeling the uh  did i say that here we should we start  up i didn't say but i should have we  label the the start node with one that  because the path always goes through the  start node so without even talking about  a path we just label the start node 1.  maybe we'll do an example of this also  but  now once we label this star this node 1  we have an expression  that tells us  how to label the two outgoing um the two  outgoing edges this edge and that edge  um  and i'm doing it without  knowing the values of the variables i'm  doing it kind of i'm just making an  expression uh which is going to describe  what those labels would be  once you tell me what the input  assignment is  okay so i'm just sort of it's almost  like a symbolic execution here i'm just  writing down the different expressions  for how to calculate what these things  should be  um  let's  let me um  maybe this will become clearer as we  continue  so the poll now this is the big idea of  this proof um  we're going to use something called  arithmetization  we're going to convert from thinking  about things in the boolean world to  thinking about things in the  arithmetical world where we you have  arithmetic  over integers let's say for now um  so instead of ands and ors we're going  to be talking about pluses and times  um  and uh  we're going to the way we're going to  make the bridge  is bishop by showing how to simulate the  ands and ors  the hand and or operations with the plus  and times operations  um  so um  assuming  one means true and zero means false  if you have  the expression a and b  as a boolean expression  we can represent that as a times b  using arithmetic  because  um it has it computes exactly the same  value  when we have um  the boolean  representation of true and false uh  being one and zero  so you know  one and one  is one  and one times one is one  and anything else you know one and zero  zero and one zero and zero  if you if you applied the times operator  you're going to get the same value so  times is very much like and in this  sense  okay we're going to write it as just a b  usually without the time symbol  so if we have a complement  how would we simulate that  with arithmetic  well  again  here we're just flipping one and zero  in using the complement operation that's  going to be the same as subtracting the  value from one that also flips it from  uh  between one and zero  um how about or if you have a or b  well um  it's slightly more complicated  because you use a plus b  um  but  you have to subtract off the product  because  what you want is this this  simulation should be  give you exactly the same value so what  if you have one or one  you want that to be a one a one answer  you don't want it to be a two  so you have to subtract off the product  um  uh  and the goal is is to have a faithful  simulation  of the and and or by using plus and  times so you get exactly the same  answers out  when you put in boolean values here  okay so  um  just to say where we're going  what this is going to  um  you know it sounds it's superficially we  haven't really done anything  um  this is  but um  what this is going to enable us to do is  plug in values which are not boolean  because you know it doesn't make sense  to talk about it makes sense to talk  about one and zero but it doesn't make  sense to talk about two and three  but it does talk it makes sense to talk  about two times three  and that's going to be  a useful  um okay so let's just see  um  remember  that that  that um  that inductive labeling procedure that i  described before  um where i labeled gave the execution  labels on the edges  depending upon the label of the parent  node and which node which variable is  being queried um so  if i know that this value is an a but  now the  uh  okay  so i'm just going to write this down  using uh arithmetic instead of using  boolean uh  operations  uh so before we have this was a an a and  x i if you remember from the previous  slide  um now what are we going to use instead  because we're going to use this  conversion here instead of and we're  going to use multiplication  that's just a times x i  what about on this side  here was  a and the complement of x i  now the complement of x i is one minus x  i  in the uh arithmetically so this becomes  a times one minus x i  okay um  similarly  here  we did the or  to get the label on the node from its  the labels of its incoming edges  now we're going to do something a little  strange um because we have a formula  here for or  but for technical reasons that will come  up later  this is not a convenient representation  for us  what i'm going to use instead of this  one i'm just going to simply say  just take the sum  why is that good enough  in this case this is still going to be a  faithful representation and give the  right answer all of the time  and that's because  for our  branching programs  read once or otherwise read once is not  coming in yet  for our branching programs  they're a cyclic  so they can never enter a node on two  different paths  there's at most one way to come into a  node uh um on a path through the on an  execution path through the branching  program if it comes in through uh  through to this edge  um  there's no way for it to for this edge  to also have a path because that means  you have to go out and come back  and and  have a cycle  in the branching program which is  disallowed so at most one of these edges  can have the path go through it  so at most one of these a's  can be a one the others are going to be  zero and therefore just taking the sum  is going to give us a value of either 0  or 1 but it's never going to give a  value higher and so you don't have to  subtract off these product terms  okay a little bit complicated here if  you didn't totally get that  um don't worry for now  you know we're um  you know more concerned that you get the  the big picture of what's going on  um  okay so um  i think we're almost  um  let me just see how far we are  yeah  so i'm just going to work through an  example and i think that'll bring us uh  let's just see any questions here  not seeing any  it means you're either all  totally understanding or or you're  totally lost i never can tell  um so feel free to ask a question if  you're even if you're confused um  you know i'll do my best  okay maybe this example might help  um  so now what we're going to do is using  this sort of arithmetical  view  of the way i  branching program's computation um you  know  is executed when when we're running it  uh um  you know an input through it um this is  going to allow us now to give a meaning  to running the branching program on  non-boolean inputs so maybe this example  will illustrate that  um  so let's just take this particular  branching program here  okay um  this branching program it's just on two  variables x1 and x2 and actually  computes a familiar function  this is the exclusive or function if you  look at it for a minute you'll see that  this is going to give you  x1 exclusive or x2  so it's going to be  one if either of the x1 or x2 are one  but it's going to be zero if they're  both one that's what this branching  program computes  now but let's take a  look um at running this branching  program instead of on the  usual boolean values let's run it on x1  equal to 2 and x2 equal to 3.  now  uh  um  you know a common confusion  might be that you're looking you know  when you do the x1 query you're looking  for  another  outgoing edge which is labeled two no  that's not what i'm doing what i'm doing  here is i'm somehow  uh through this execution  by assigning these other values i'm kind  of blending together the computation of  x x  uh 1 equal to 0 and x1 equal to 1  together  i don't know if that makes any sense but  let's look through the example  um so first of all these are the  labeling rules that i had from  uh the previous slide when i  used plus and times instead of and or  okay  now i'm going to show you how to use  that to label the nodes and edges of  this graph based on this input  and that'll determine an output  would be the value on the uh  the one node  okay so we always start out by labeling  the start node with one  that's just the rule  um  and  uh okay  sorry  let's let's think about it together  before i blurt out the answer  what's going to be the label on  this edge  so this is one of the outgoing edges uh  from a node that already has a label so  that's going to be this case here  and what we do is if we take we take the  label of that node  and since it's a one edge that's  outgoing  we multiply that label  by um the value  of uh that  uh  variable  of the the assignment to that variable  so x1 is two  so we take the the it's good this the a  here is one  x1 is a assigned to two so it's going to  be one times two  is going to be the value  the execution value we put on this edge  so it's going to be 2.  what's going to be the value we put on  the other edge the other edge the 0  outgoing edge from x1  so once you think about that for a  second  so now we're going to use this  expression  it's a times 1 minus x i  and so x i again is two so one minus x i  is one minus two  um  does that mean that's how complementary  but okay let's say that so it's one  minus 2 so that's minus 1 times the  label  1 here so you get minus 1 as the label  on this edge  now  keep in mind  that if i had plugged in and this is  very important if i had plugged in  boolean values here  i would be getting out the same boolean  values that you would get just by  following through the path  you know the things on the path would be  one the things off the path would be  zero  um  but uh  but with what's kind of uh what's  happening here is that  there's still a meaning  when the inputs are not boolean  so let's continue here how about what's  going to be the value on this node  so think with me i think it will help  you  so  now we're using this rule here we add up  all the values on the incoming edges  there's only one incoming edge which is  value two so that means this guy's going  to get a two and similar on this one  this guy's going to get a minus one  now let's take a look at this edge  so this is a the zero outgoing edge from  a node label two with with label x2  so this is the zero outgoing edge  the node the label is two so it's going  to be two times  one minus the x2 value x2 is 3 so 1  minus 3 is minus 2. it's going to be 2  times -2  which is minus 4.  so similarly you can get the value here  the value on the the  one outgoing edge is going to be  2 times  x the x2 value which is 3 so that's  going to be 6.  and these two here  uh um  so you know now we have a minus one  and the outgoing is a  it's a it's a zero edge so it's one  minus three  and here it's going to be one times  minus three  no  1 times 3 i'm sorry 1 times 3.  um  so you get the out the answer is minus  3. so now what's the label on the zero  output edge  so you have to add in add up the two  incoming edges here so we have  uh this  this edge here was a two  this edge coming in here is a six so  it's going to be two plus six  it's eight and what about this edge this  node here this is an important node  because this is going to be the output  so  it has  um  uh  you know minus three coming in  and a minus four coming in so you add  those together  you get a minus seven  i mean you may wonder  what  what the world is going on here um  just a lot of mumbo jumbo uh  but we're gonna make sense of all this  not today uh we're gonna have to argue  why this is  what the meaning that we're gonna get  out of this is gonna be  um but the point point is  that  this is going to lead to a new algorithm  for testing this is again getting back  to what we were  doing  this is  the equivalence problem for read once  branching programs so now what the new  algorithm is going to do is going to  pick a random non-boolean assignment  so it's going to randomly assign  values to the x's  and to some non-boolean values instead  of zeros and ones we're going to plug in  random  integer values we'll make that clear  next time what's what this what the  domain is going to be  um  [Music]  and then once we have that non-boolean  assignment we're going to value b1 and  b2  and if they disagree  out there in that extended  domain  then we have to show that they're not  equivalent and will reject  and we'll also show that  if they were equivalent  then even when we evaluate them  then we have to show that if if they're  not equivalent that they're very likely  to to have a difference in the  non-boolean uh domain and so um if they  agree it it  it gives you evidence that the two are  really equivalent  um so the completeness proof will come  after thanksgiving so with that um i'm  gonna wish you all a nice uh break um oh  we have a check in here sorry  oh yeah this is a good one  i don't know how if you're following me  uh but  um if i plug in one for x1  and y for x2  does it do the inputs in the assignment  need to be distinct no  it could be the same value  i could be  uh two and two here that's perfectly  valid  but here i'm going to plug in 1 for x1  i'm going to plug in a  variable for x2 y  and i'm going to do the whole  calculation that i just did and now  what's going to be the output  and i mean this looks like a pain to  figure out you could do it it looks like  a pain but let me give you a big hint  um  remember that this thing  is supposed to be calculating the  original branching program calculates  the exclusive or function  and that means when i plug in  um a boolean value  i should get the exclusive or value  coming out  so if i already know that x1 is one  which of these is consistent  with getting  a value  uh that the exclusive or function would  compute  so let me launch the poll on that  so we're at a time  so let's just let this run for another  10 seconds  okay  i'm going to close this  ready  um  yes indeed  a is the right answer because that's one  if i know that one variable is one then  the exclusive or  is going to be the complement of the  other variable  which is one minus y so that's what you  would get if you calculated this  um  because this is what we did today  and um  feel free to ask questions so let me  just so we're going to spend a good  chunk i'll review this  what we've done so far but then we're  going to carry it forward and spend a  good chunk of tuesday's lecture after  the  thanksgiving break uh proving that this  uh procedure that i just subscribed  worked and works and it's um  it's an interesting but somewhat  you know it's not such an easy proof uh  so we're going to spend the try to do it  slowly and clearly and then um but this  notion of arithmetization is going to be  this is this was  you know  it's it's an important notion in  complexity and so um we'll  we'll see it again coming up in another  proof afterwards  in about interactive proof systems  okay um  so please ask questions  so the output is the value of the one  output one state yes  that was a question i got  other questions  somebody's saying minus seven is not the  xor of two and three  what is the xor of two and three  so by the way i i should say we kind of  ran a little short on time i'm not  saying that we discovered some  fundamental new truth about xor here  um because that would be bizarre  it really depends on the arbitrary  decision that we made to say true is one  and false is zero  we could have come up with a different  representation for true and false and  then you would get a different value  for xor coming out of that you know from  the arithmetization that i just  described um  but uh for this particular way of  representing true and false that's how  xor and this particular branching  program that's how uh  what how xor evaluates  the the remainder of the proof so  somebody's asking which is it which is  true the fundamental theorem of algebra  which talks about polynomials and the  number of roots that you can have that's  going to be that's going to be critical  um  uh so the that is the fundamental  theorem of algebra that's where we're  going good good question  well you know so the  somebody's complaining that you know  we're not taking the  digit  binary representation of two and three  and taking the  bit by bit  um  xor well that's i'm not  you know  binary representation is not a part of  this  we're thinking of these as two elements  of a field  um of a finite field which we'll talk  about later  represent the binary representation is  isn't  is not is not entering into this  discussion  um  so talk about why just doing the sum is  enough  um  i think that was  so why is it i mean here it is why is  just doing the sum when i'm  looking at the um  the  how to describe the value of this node  based upon the values of all the  incoming nodes  and remember the point of the the  starting point of this is that we have  to faithfully represent the boolean  logic with the arithmetic  and then we're going to use that and  extend it to non-boolean values but as a  starting point we have to faithfully  represent the boolean values  now the boolean values  on the incoming edges at most one of  them can be  can be a one  because  the ones correspond to the  edges  of the execution path  and you can't make an execution path  um that's going to have two  branches  that's going to go through a node twice  because then you have a loop  and we don't have there's no cycles  allowed  okay  so i think where it's at four  um  i want to say farewell to all you all  have a great uh week and i'll see you  when you get back  you

2
00:00:27,269 --> 00:00:29,349
okay hello everybody  we'll get started  um  so  um  just recapping what we did  [Music]  a  in the last lecture on tuesday  we um  had a  it was kind of a two is the second part  of a two lecture sequence on the  hierarchy theorem  higher hierarchy theorems for time and  space  and using the hierarchy theorems to show  that there are that there is a problem  which is  intractable that's provably outside of  polynomial time  and that was this equivalence problem  for regular expressions with  exponentiation  and then we had a short discussion  about oracles  and the possibility that similar methods  might you might be used to show that  satisfiability is outside of p which  would then of course solve the p versus  mp problem and argued that um  it seems unlikely  um this kind of a meta theorem not not a  well uh  well-defined notion  but seems unlikely that the methods that  were used for proving  the um  uh  the intractability of um  equivalence of regular expressions with  exponentiation could be used to solve p  versus np at least um the the  diagonalization method kind of in a pure  form whatever that means uh that's not  going to be um enough  so today we're going to  shift gears again begin a somewhat  different topic which is really kind of  um going to be our uh  again a  few lectures on probabilistic  computation which is going to wrap round  out the semester for us  um and we're going to start by talking  about a different model of computation  which allows for uh probabilis  probabilism in the  measuring the amount of probabilism or  measuring the probability allowing for  probabilism in the computation  define an associated complexity class uh  this class bpp  and then start to start the discussion  of an example um  about something called branching  programs  okay um  so uh with that in mind um  uh  um  a  uh  so we're gonna start off by defining  the notion of a probabilistic  turing machine or ptm  um a probabilistic turing machine is a  lot like  the way we have thought about  non-deterministic touring machines  in that it's a kind of a machine that  can have multiple choices multiple ways  to go  in its computation so there's not just  going to be a fixed uh deterministic  path  um of its computation but there's going  to be a tree of possibilities um and for  our purposes we're going to limit the  branching in that tree to be either  um a step of the computation where  there's no branching where it's a  deterministic step  uh as shown over here um so every step  of the way leads uniquely to the next  step  or there might be some steps which have  a choice and we're only going to allow  for these purposes uh to keep life  simple  um having only uh a choice among two  possibilities  um  and we'll associate to that  uh  um  the notion of a  probability that each choice will have a  50 50 chance of getting taken  and this kind of corresponds with the  way some of us or some of you think  about non-determinism which is not  exactly right up and up until this point  is that the machine is kind of taking a  random branch it really we don't think  about it randomly until now now we're  going to think about the machine as  actually taking  sort of picking a random choice among  all the different branches that it could  make um and picking the choice kind of  uniformly by flipping a coin every time  it has an option of which way to go  uh  now you could  define i'm getting a question here uh  the uh a machine that has several  different ways to more than two ways to  go and then you would need to have a  three-way coin a four-way coin and so on  and you could define it all of that that  way  as well but it doesn't end up giving you  anything different or anything uh  interesting or new for uh for the kinds  of things we're going to be discussing  so and it's just going to be simpler to  keep the discussion limited to the case  where the machine can only have two  possibilities um if it's going to be  having a choice at all or or just one  possibility when there's no choice  okay so um so now we're going to have to  talk about the probability of a  the machine taking a sum branch of its  computation so you imagine here here is  the same computation tree that we've  seen before in the case of ordinary  non-deterministic machines where you  have m on w there could be several  different ways to go and there might be  some particular branch but now we want  to talk about the probability that the  machine actually ends up picking that  branch  and it's going to be  um  uh  you know when we talk about  uh  the machine having a choice of ways to  go we're going to associate that with a  coin flip so we're going to call that a  coin flip step when the machine has a  possibility of ways to go and so on a  particular branch  the probability of that branch occurring  is going to be one over two to the  number of coin flips  coin flip states on that branch  and the reason for i mean this is kind  of the the  the definition that makes sense um in  that if you imagine looking at the  computation tree here and here is the  branch that we're focusing on um of  interest  every time there's a coin flip on that  branch  there's a 50 50 chance of taking a  different branch or staying on that  branch  so the more coin flips there are on some  particular branch the less likely that  branch would be the one that the machine  actually actually ends up taking taking  and so it's going to be one over two to  the number of coin flips  and that's the way we're defining it  now once we have that notion  we can also talk about the probability  that the machine ends up accepting  because each as before each of these  branches is going to end up  at an accept state or reject state i'm  thinking about this only in terms of  deciders  and  the probability of  the machine accepting here is just going  to be the sum over all probabilities of  the branches that end up accepting  so just add up all of those  probabilities of a branch leading to an  accept and we'll call that the  probability that the machine accepts its  input  [Music]  and the probability that the machine  rejects is going to be one minus the  probability that it accepts  because it's going to the machine um on  every branch is either either going to  do one or the other  okay um  now if you're thinking about a  particular language  that the machine is trying to decide  this probabilistic machine now is trying  to decide  um you know  on on each input  some of the branches of the machine may  not may give the correct answer they're  going to accept when the input is in the  language other branches may give the  wrong answer they may reject when the  input is in the language and vice versa  so there's going to be a possibility of  error now in the machine in any  particular branch it might actually give  the wrong answer  and what we're going to say is bound  that error  over all possible inputs  um and so and uh  we'll say that the machine for any  epsilon greater than or equal to zero  um we will say that the machine decides  the language with error probability  epsilon  if that's the worst that can possibly  happen you know if every  um for every input the machine gives the  wrong answer  with probability at most epsilon  um equivalently if you like to spell it  out a little bit more  you know  a little differently  for  strings that are in the language the  probability that the machine rejects  that input is going to be at most  epsilon and for strings in the language  the probability of for strings not in  the language the probability that  accepts is a most epsilon  so again this is  the machine doing the the thing that  it's not supposed to be doing for things  in the language it should be rejecting  very rarely for things not in the  language it should be accepting very  rarely and that's what this bound is  doing for you  okay  um  [Music]  so let's just see uh  so we'll talk about so i'm getting some  questions here about um  um  so let me just look at these one second  here  the  yeah so  probability zero so there's a  possibility that the machine have might  have a probability zero say of accepting  that means there are no branches that  end up accepting or probability zero of  rejecting there were no rejecting  branches  um but i think we're going to talk in a  minute about the connection between this  and and the standard notion of np  um so just hold off on that for a second  uh  also about what what about the you know  the um the possibility that the machine  is you know  being a decider or running in a certain  amount of time um so we will look at  time-bounded machines  in a second um  on the next slide or two um talking  about machines that run in polynomial  time so that means all branches have to  halt within some polynomial number of  steps um so that's where we're going  but for the time being we're only  looking at the siders where the machine  has to hold on every branch  but some branches might run for a long  time but  for now we're not going to be thinking  about machines that have branches that  run um forever where all of our machines  are deciders so they they hold on every  branch  see there's anything else here no so why  don't i move on so let's define now  the class bpp  using this notion of a probabilistic  turing machine which is now going to be  running in polynomial time  so bpp is going to be another one of  these complexity classes a collection of  languages like p and np and p space and  so on and um but it's going to be now  associated with the capabilities of  these probabilistic machines the kinds  of languages that they can do  so we'll say the class bpp  is the set of languages a  such that there's some probabilistic  polynomial time  during machines so all branches have to  halt within you know to the k for some k  so some polynomial time  polynomial time probabilistic turing  machine decides a with error possibility  at most one-third  so in other words  when it's accepting  for some for strings in the language the  machine has to reject with at most  one-third so saying it equivalently for  strings in the language it has to accept  with two-thirds probability and for  strings not in the language it has to  reject what two-thirds probability at  least  in both cases  um  okay  somehow ended up with  didn't check my animation here but okay  that's fine so there is a um  uh  now if you look at the one-third here in  the definition  uh  you know it seems strange to define a  complexity class in terms of some  arbitrary constant like one-third why  didn't we use one-quarter  you know or uh  you know one-tenth in the definition of  bpp  and say the machine has to get have an  error with at most one tenth or one  hundredth uh  well it doesn't matter  and that's the point of this uh  next statement called the amplification  lemma  which says that  um  you can always if you have a machine  that's running in a certain  uh  a polynomial time that's running within  this with a certain error which it is  most one-half if you have an error  one-half it's not interesting because  the machine  could just flip a coin for every uh  input and it could get uh the right  answer with it with probability one-half  so probability one-half is not  interesting you have to have probability  strictly less than one-half for the  machine to actually be doing something  that's meaningful about that language  so  um  if you have a  probabilistic turing machine that has  error  let's say epsilon one which is at most  one half which is less than one half  then you can convert that to any  error probability you want  for some other  polynomial time probabilistic turing  machine so you can make that error which  maybe starts out as one-third and you  can drive that error down to one out of  one over or google  um  and seriously you can really make the  error extremely extremely small  using a very simple procedure  and and that's simply this  so if you're starting out with a machine  that has an error possibility of  one-third say so that means  two-thirds of the time it's going to get  the right answer and at most one-third  of the time at least two-thirds of the  time the right answer most one-third of  the time the the incorrect answer  whether that's accepting or rejecting  um and now you want to get that answer  down to be something much that error  down to something much smaller  um  the the idea is you just you're going to  take that machine  and you're  going to run it multiple times  it's kind of with independent runs if  that me if you want to think about it  you sort of more formally speaking but  it's sort of intuitive you're just going  to run the machine  uh tossing your coins  um  uh instead of just running it once  you're going to run the machine 100  times or or a million times but you can  do that so it's a constant factor  and even a thousand times is going to be  enough to increase your confidence in  the result tremendously because  if you run the machine a thousand times  and 600 of those times the mach the  machine accepts and 400 of the time the  machine rejects  um  uh  it's very powerful evidence that this  machine is biased toward accepting that  it's accepting most of the time  um so it's um was  uh  if it had an error  probability of most one-third um  uh  the the probability that you're  seeing it except  600 times when really two-thirds of the  time it's rejecting overall  is extremely unlikely  um and you can calculate that uh which  we're not going to bother to do but it's  a routine probability calculation uh to  show that the the probability that if  you run it a whole bunch of times and  you see the majority coming up  um which is not the  not the right answer that's extremely  the  the probability of that is extremely  small  um  so i'm not saying that very clearly but  um  the the the  the method here is you're going to  take your original machine  which has error probability one-third  or whatever it whatever it is some you  know you know maybe  has error probability 49  and you run it uh for a large number of  times and then you take the majority  vote  and  it you're kind of sampling the the  outcomes of this machine and if you take  enough samples it's overwhelmingly  likely since you're just doing them  uniformly you're taking those samples  uniformly it's overwhelmingly likely  that you're going to be seeing the  predominant one come up more often um  and exactly what that right value is  we're not going to bother to calculate  but that's something that  you know if you i will i'll refer you to  the textbook or you know that's the kind  of thing that comes up in any elementary  probability book and it's sort of very  intuitive so i don't want to spend the  time and do that calculation which is  not all that interesting  um  uh okay so just one quick question here  that i'm getting  what happens if you bound if the error  is greater than a half i don't think  that because we're bounding the error so  we're not saying the error actually is  one you know like sixty percent on  everything because then if you knew the  error was sixty percent  guaranteed you can always just flip the  flip your answer around and get your um  error to be 40  but you know i'm saying the error is  that most  whatever epsilon is and so um if it's  you're saying the error is at most 60  percent it doesn't tell you anything  um  okay um  [Music]  uh  another question is does the  amplification lemma also justify that  the choice of model with binary  branching choices is equivalent to any  other  perhaps you could say that um  because you can change those  you know if you had through a three-way  branching um you can simulate that with  two-way branching to any accuracy that  you want um  you know  not going to get it down to zero but  you're going to get it very close  um so it's  maybe it's the amplification level maybe  it's  yeah sort of all related um  okay let's move on um  so  the way that it's helpful to think about  this class let's let's contrast it with  the other model of non-deterministic  computation that we have is  non-determinism is np  uh so non-deterministic then the model  of non-deterministic polynomial time  computation was np um the other class  and um  so the way  it's i think one way to look at to think  about non-determinism in the case of np  is  for strings in the language for your np  turing machine  there's at least one accepting branch  so i'm indicating the accepting ones in  green and the non-accepting one the  rejecting branches in red  so you could have  almost all of the branches be rejecting  branches um  for strings in the language as long as  there is at least one accepting branch  that's just the way non-determinism  works the accepting branch overrules all  the all of the others it's only when  you're not in the language that you that  all of the branches turn out to have to  be rejecting that's when the rejecting  sort of  you know it's it has no accepting branch  to overroll it  um but the situation for bpp is a little  different it is is different um there  it's kind of majority majority rules  so um  in the case for strings in the language  you you need to have  a large or you know the the overwhelming  majority of the  branches have to be accepting and for  strings not in the language the  overwhelming majority have to be  rejecting  what you're not going to allow in the  case of  bpp is kind of you know  an in-between  uh  state where it's sort of 50-50  um or very very close to 50-50 um those  kinds of machines are not  don't qualify as  uh deciding a language in bpp they  always have to kind of lean one way or  lean the other way for every input  otherwise you won't be able to do the  amplification so need to have some bias  um away from in half in  in accepting or rejecting  um  so  let me so i was going to ask a check-in  i think at this point yes let's  so just thinking about bpp i hope i was  clear so if there's questions about that  i think i've  somehow didn't  i'm not sure i described it totally well  here um so i'm going to ask a few  questions about ppp but if you have any  questions for me first  go ahead  um  okay why don't we just run the check-in  um  let me launch this and then i can answer  questions as you're asking  did i start that yeah  okay so you have to um  check all of these that you think are  true  um  can you think of non-deterministic  turing machines as try all branches at  once  and get the right answer  um  and bp is guess only one or uh i guess  only one branch i don't know um  you know i would say a little  differently i would say i i would think  of non-determinism as you can still just  try one branch but you always guess the  right one  um  so there's some sort of a you know  magical power that allows you always to  guess the right answer if there's a  right guess uh if you're in the language  uh in the case of bpp  you're going to be um picking a random  branch no matter what  and you know that the random branch is  likely to give the right answer but not  guaranteed  and the implication the amplification  limit tells you you can arrange things  so that it's extremely likely  that the random branch is going to give  you the right answer  okay let's see how we doing on our uh  check-in here  um  got a lot of vote we've got a lot of  support for all candidates  um  and um  i'll give you give you another uh  a little bit of time here because  there's a bunch of questions almost like  four check-ins at once  um  but we have two more check real  check-ins coming  later um  okay so why don't we uh come and  let's uh give another 10 seconds and  then i'm going to stop  closing down  one two three  close  okay  so uh we've got a lot of support here uh  and in fact  that's good because all of them are true  um  some of them are easier to see than  others  so first of all c is very easy to see um  because that that's a going to be a  machine that has the correct answer all  of it all of the time so that's error  probability zero  um on both accepting and rejecting  um  this is a little harder d is a little  bit harder to see that's in p space but  you know you could  calculate for every branch  um what its probability is and you can  just go through all the branches and add  up all those probabilities in a p-space  machine  so um you have to think about a little  bit but d is not too hard to see either  closure under complement  if you just take your  your bpp machine and you flip the answer  on every branch  um that's typically doesn't work in  non-determined ordinary non-determinism  but it does work here  because it's going to change a bias  toward accepting into a bias toward  rejecting and vice versa so bpp is  closed under compliment  uh and closure under union it kind of  follows from the amplification level as  long as you can make the probability  extremely small  then you can just run the two different  machines  and  even though the they each might make a  mistake cumulatively the total  the probability that each one of them  that either of them will make a mistake  is still small and so you can just run  to the two machines and take the or of  the responses that they get and it's  still very likely to give the right  answer for the union  okay um  [Music]  let's continue  uh so what i'm going to do now  for the rest of the lecture uh is and  it's actually going to spill over into  the lecture after thanksgiving because  this is going to introduce an important  method for us  is to look at an example of a problem  that's in bpp  um i love to teach things by using  examples um and so this is a very good  example because it has a lot of meat to  it  and it's a very interesting example in  general proving things in bpp which are  not trivially there because they're  already in p they tend to be uh somewhat  more involved than um  uh some of the other algorithms we've  seen so there are no simple examples of  problems in bpp  which are not already in p  um  so this is uh  one example that we're going to go  through of a problem in bpp that's not  known to bnp  of course things could collapse down um  but uh uh  as star as far as we know  this is  um not this language is not in p so  let's let's see what the language is  has to do with these things called  branching programs the branching program  is a structure that looks like this  so let's understand what the pieces are  first of all it's a graph directed graph  and uh we're not we're not going to  allow and there is are no cycles allowed  in this graph it's a directed acyclic  graph  um  so you can no loops allowed  and  the nodes are in two categories  there are query nodes which are labeled  with a variable letter  and output nodes which are labeled  either zero or one  and lastly there is a one of the query  nodes is going to be or one of the nodes  is going to be designated as a start  okay  and so what you do  is  the way um  this is a model of computation um and  the way we actually use  a branching program  is we  have some assignment to the variables  that's going to be the input  so you take all of the the variables  there are three variables in this case  um x1 x2 and x3 you assign you give them  some truth assignment um so x let's  let's say zeros and one so x1 is zero x1  is one or whatever  and  once you have the truth assignment you  start  at the start variable  and you  and you look at its label  and you see what value the input has  assigned to that variable  so if x1 assigned  a one you're going to follow down the  one branch but assigned to zero you  follow you go down the zero branch and  then when you get down to the  next node  that's another  variable that you're going to have to  query depending upon what the input  assignment is  and you're just going to  continue that process  because there are no cycles  you're going to end up at one of the  output nodes because all of the variable  nodes all the all the query nodes  have  two outgoing edges one labeled zero one  labeled one  so you're gonna eventually end up at an  output node and that's going to be the  output of the branching program  so we'll do let's do a quick example  so if x1 is 1 x2 is 0 and x3 is 1.  so we again we start at the start  variable the start node that has the  indicated with the  arrow coming in from nowhere so you're  going to start at x1  uh  the node labeled x1 so you have to look  and see what is x1 in the input it's a  1. so you're going to follow down the  one branch  now you see the next node oh that's an  x3  see what's x3 in the input x3 is a 1.  so you go down to one branch again  now you have an x2 node take a look at  the input x2 is a zero you follow the  zero branch now you're at an output  branch output node so that's a zero and  that's the output of the of the of this  computation so  um writing it this way and thinking  about it as a boolean function which  maps you know strings of zeros and ones  we have f of one zero one representing  those that assign that assignment that  equals zero that was the output and  uh  that's the output of this computation  okay  um  so important to underst we're going to  spend a lot of time  you know talking about branching  programs so it's critical to understand  this model i think it's fairly simple  but if you didn't get it please ask  we can easily correct up any  misunderstanding at this point  it's not exactly the same as a dfa  dfas for one thing can take inputs of  any length  um  this  this has inputs of some particular  length  where the branching program has some  fixed number of variables  this one has three so this only takes  inputs of length three um so there's  maybe some connection to thinking these  estates and so on but it's a different  model  so now we'll say that two branching  programs  um  okay let me just ask one more question  not all nodes need to be used right  um  yeah  there's no requirement that all nodes  need to be used and that even could be  inaccessible nodes i'm not preventing  that uh that could be okay um so on the  particular branch certainly you're not  gonna you know when you're executing  this  branching program on an input obvious  certainly you're to have a path that's  going to only use some part of the  tree  part of the graph  but  there might be some  paths that can  can never occur  you know so if you went down x equal to  one here and then x three was zero  now you're re-reading x one so you'd  never you could you wouldn't go down  this branch  unless you  i think all of the branches in this  particular branching program could get  used but i didn't check that so maybe  i'm wrong um  okay so let's continue two branching  programs may may or may not compute the  same function  um we'll say they're equivalent if they  do  now  two  branching programs can be equivalent  even though they superficially look  different from one another  and we're interested in the  computational problem of given two of  these branching programs do they compute  the same function do they in other words  do they always give the same answer  um on the setting of the input uh  so we'll define the associated language  equivalence problem for branching  programs says that you're given two of  these branching programs and they're  equivalent to be in the language we're  going to sometimes write equivalence  using the mathematical notation of the  three lined equals equal sign  the equivalence sign  okay that means they compute the same  they always give the same answer  now that problem  turns out to be cohen p  complete i've asked you to show on your  homework i believe  um  this is not a super hard reduction um  it's the in comp complete by the way is  the complement of an mp complete problem  or equivalently it's a problem to which  all co np problems are polynomial time  reducible and it's in coin  [Music]  so  uh  this is coin p complete  and  that's for you to show um  but that has an important  significance for us right now  um because if you if  you know looking at the question of  whether this problem is in bpp  the fact that it's coin  co np complete suggests that the answer  is no  because  if  a co np complete or np complete problem  more in bpp  because everything else in np or cmp is  reducible to that problem then all of  those np or co-np problems would be in  bpp for the exactly the same reason that  we've seen before  um and that's not known to be the case  and not believed to be the case um  so  uh we don't expect that a co-mp complete  problem is going to be in bpp um that  would be you know an amazing uh and  surprising uh  uh result so um  because i i hope i made it clear in my  previous um you know in previous  discussion that  you know the bpp from a practical  standpoint is very close to being like p  um because you can make the error  probability of the machine so incredibly  low  um  that  you know it's a comparable  uh  you know if you run the machine and the  error probability is like one over  google um  then it's sort of  even greater than the probability that  some alpha particle came in and flipped  the value of what some internal uh  memory cell in your in your computation  so if you have an extremely low error  probability it's pretty good from a  practical standpoint um  so it would be amazing if np problems  were solvable in bpp um  so  this is not the language we're going to  use as our example we're going to look  at a related restricted version of this  problem about equivalence for branching  programs and that i'm going to introduce  right now  okay any questions here  don't see any questions  um  fading out  uh okay  um  so let's move on  so we're going to talk about branching  programs that are what are called read  once  read once branching programs  and those are simply branching programs  that are not allowed to re-read  an input that they've previously read  so for example  is this  branching program a read once branching  program  no  this branching program is not a read  once branching program because  um  you can  find a path that's going to cause you to  read the same variable more than once so  it's not going to be a read once  um so over here let's not read once  because there's two  occurrences of an x1 on the same branch  now you might ask why would anybody want  to do that because you've already read  the value of x1 well i mean in the case  of this particular branching program  there might be a value because you could  have got to this x x1 branch by going  this way or that way  um  but that's a separate question  if we restrict our attention  to read once branching programs then the  problem of testing equivalence becomes  uh  very different in character  and in fact we're going to give a  probabilistic algorithm uh  a bpp algorithm to solve that problem  so the equivalence problem for read once  branching programs which are not allowed  to re-read variables on any path  um that's interestingly going to be  solvable with a probabilistic  uh polynomial time algorithm you know  with a small error probability  um  so i'm going to run a check in now but  let's make sure we're all together on  this so i got a good question here can  every boolean function be described by a  branching program yes  that's an easy exercise but you can make  branch branching programs are um they  may be large  uh you can describe any boolean function  with some branching program  that's not hard to show  um  other questions are we all together on  understanding what read once means and  branching programs and all that stuff  this is a good time to ask if you're not  um  okay so let's do the check-in  so  as i pointed out we will show that the  equivalence for read once branching  programs is solvable in bpp  can we use that to solve the general  case for branching programs  by converting branch general branching  programs to read once branching programs  and then run running the read once test  so  what do you think  okay i'm seeing a lot of uh  correct answers here um so let's let's  wrap this one one up quickly  um  another 10 seconds please  okay  ready are we all ready  one two three closing  all right yes  most of you have  uh  answered correctly um  well answer a is not a very good answer  because we already commented on the  previous slide that we don't know how to  do  the general case in bpp so it would be  kind of surprising if right here i'm  saying yes we could do it  by using the restricted case so  you know i think a  better answer would be to one of the  no's but  as i did comment you can always convert  you can always do any uh boolean  function uh with a  well maybe i didn't say it for read once  branching programs but you even read  once branching programs can do any  compute any boolean function um so the  the conversion is possible but in  general will not be polynomial time and  you can if you imagine you've been  trying to do the conversion over here  you could convert this branching program  to read once um but you'd have to  basically separate the two  uh  um  you know instead of re-reading the x1  you could remember that x1 value but  then you would not be you couldn't  reconverge over here you'd have to keep  those two those two  threads of the those two branches of the  computation apart  those two paths apart from one another  and already the branching program would  start to increase in size by doing that  um  and um  so in general  conversion converting is possible but it  requires a big expansion a big  increase in the size  and then we will  not allow a polynomial time algorithm  anymore even in probabilistic in the  probabilistic case  um  okay um  so now let's start to look at the  possibility of showing that this  equivalence problem is solvable in bpp  and it's going to take us in kind of  a strange direction but let's let's try  to get our intuition going first by  doing something  which seems like the most obvious  obvious approach  um  so here  uh so we're gonna  give a  an algorithm now um  uh which is going to be an attempt  it's not going to work but nevertheless  it's going to have the germ of the right  idea or the or the  not the germ but the beginning of the  right way to think about it  so here are the two branching read once  branching programs are b1 and b2  and i want to see  do they compute the same function or not  um so one thing you might try  is just running them on a bunch of  randomly selected  assignments or inputs  all right so you're going to you can  just um  take two randomness input assignments  just take x1  flip a coin to say it's one of zero x do  the same for x two and so on  um then you get some input assignment  you run the two branching programs on  that assignment  and maybe that doesn't give you know  even if they agree it doesn't give you a  lot of confidence that you got the right  answer uh  that they're really equivalent so you do  it a hundred times whatever some some  number of times um  and  of course  if  they uh ever disagree  on some assignment on one of those  assignments then you know they're not  equivalent and you can immediately  reject  um  but  uh what i'd like to say is if they  agree  on those  you know hundred  tries those hundred assignments there  then  there then they are um  uh  at least i'll i haven't found a place  where they disagree so i'm gonna say  that they're equivalent  is that a reasonable thing uh to do  well it might be  uh it depends on k um  so the critical thing is what value of k  should you pick  which is going to be big enough to allow  us to draw the conclusion that if you  run it for k times and you never see a  difference  then you can  conclude  with good confidence that the two  branching programs are equivalent  because  you've tried to look for  a difference and you never found one  well the thing is is that  um  k is going to have to be pretty big  uh  so  looking at it this way if the two  branching programs were equivalent  then certainly they're always going to  give the same value  um  so the probability that the machine  accepts is going to be one and that's  good  because we want for  this is a case when we're in the  language we want the probability of  acceptance to be high and here the  probability of acceptance is actually  one  so it's always going to accept when the  two uh branching  programs were equivalent  but what happens when the branching  programs are not equivalent  now we want the probability of rejection  to be high the probability of acceptance  should be very low  um  right so if if they're not equivalent we  want the probability that the machine  rejects is going to be  high if they're not equivalent because  that that's what the correct answer is  well the only way the machine is going  to reject  if it finds  um a place  where the two branching programs  disagree  but but  those two branching programs even though  not equivalent  might disagree rarely  they might only disagree on one input  assignment out of the two to the end  possibilities  so these two inequivalent branching  programs might agree almost everywhere  just except at one place and then that's  enough for them not to be equivalent but  the problem is that if you're just going  to do random sampling  um the likelihood of finding that one  exceptional place where the two disagree  is very low you're going to have to do  an enormous number of samples before  you're likely to actually to to to find  that uh that point of difference um and  so  um  in order to be confident that you're  going to find that difference if there  is one you're going to have to do  exponentially many samples and you don't  have time to do that with a polynomial  time algorithm  um  you're just going to have to flip too  many coins you have to run too many  different  samples  different assignments through these two  machines  and um because they're almost  they're different but they're almost the  same  um  so we're going to need to find a  different method  and  um the the idea is we're going to run  these two  branching programs  in some crazy way  instead of running them on zeros and  ones that we've been we've been doing it  so far we're going to feed in  values for the variables  which are non-boolean  they are going to be going to set x1 to  2 x3 to 7  x  4 to 15.  of course that doesn't seem to make any  sense but it's nevertheless going to  turn out to be useful a useful thing to  do and it's going to give us some  insight into  the equivalence or equivalence of these  branching programs um  okay um  so let's just i think are we at the end  yeah we're at the break here so why  don't i i'm getting some questions  coming in which is great um i will  answer those questions but why don't i  start off our uh  break and then um  okay  okay so  there's a question about whether these  this machine runs deterministically or  not so which machine are we talking  about  so the branching programs themselves  that they'd run deterministically you  give them an assignment to the um to the  input variables  that's going to determine a path through  each branching program  which is eventually going to output a  zero or a one  and you want to know do those two  branching programs always give the same  value no matter what the input was  but the branching programs themselves  were deterministic  um now the machine that's trying to  make the determination of whether those  two branching programs are equivalent  that machine that we're going to be  arguing is going to be a probabilistic  machine so it's a kind of  non-deterministic machine that's going  to have different possible ways to go  depending upon the outcome if it's of  its coin tosses  so it you can think of as  non-determinist you know  non-determinism in the ordinary sense  about how like that it has a tree of  possibilities  but um now  you know the way we're thinking about  acceptance is different you know that  instead of accepting if there's just one  uh accept branch  the machine for it to accept um has to  have a majority of the branches be  accepting um  and uh  you know  so it's it's  there's some similarities but some  differences with the usual way we think  of non-determinism  so what's the motivation behind  introducing this type of turing machine  well i mean there's a lot  i guess there are two motivations  uh  probabilistic algorithms sometimes  called monte carlo algorithms um  uh turn out to be useful in practice for  a variety of things  and um  so that led to  um  people to think about them in the  context of complexity  um they're related in some ways to  quantum computers which are also  probabilistic in in a somewhat different  way um but they also have a very nice um  uh  um  uh  formulation in complexity theory  so complexity theorists like to think  about probabilistic computation because  i mean you can do interesting things  with probabilistic machines and the  complexity classes associated are also  interesting so as you'll see  it leads us in an interesting direction  uh to consider how to solve this problem  this read once branching program problem  equivalence  with a probabilistic machine it's just  just an interesting um algorithm that  we're going to come up with  um  so in our pro in our proof attempt where  did we use the probabilistic nature for  bpp because we're running the two  branching programs on a random input  um  i mean  so you know you have your two branching  programs you pick a random  input to run those two branching  programs and you see what they do  that's where that's why it's  probabilistic  when you're thinking about random  behavior of the machine  it's a um that's a probabilistic machine  so each branch of the machine  is going to be like the way we normally  think about non-determinism somebody's  asking whether  we think of the complexity of the  machine in terms of all of the branches  of the machine  or  um each branch separately it's we always  think about for non-deterministic  machines each branch separately  um i'm not totally sure i understand the  question there so are all the inputs  built in and we randomly choose one  through coin flips  not sure i understand that question  either we're given as input the two  branching programs  and then we flip coins you know kind of  using our non-determinism  you can think about it equivalent in  terms of coin flips to choose the values  of the variables so now we have a set of  variable  inputs to the  values of the variables  and we use that to  um as input to the branching programs to  see what whether they  to see what answers they give and we in  particular whether they give the same  answer on that randomly chosen uh input  let's move on um  all right  so now sort of moving us toward  um  the actual bpp algorithm for uh  um read once branching program  equivalence  testing um  we have to think about  a different way  to  um  we need an alternate way of thinking  about  the computation of a branching program  it's going to look very similar but it's  going to lead us in a direction that's  going to allow us to talk about this  um these non-boolean inputs that i refer  to um just kind of where we're going  we're going to be simulating branching  programs with polynomials  if that helps you sort of as an  overarching plan but we'll we'll get  there a little slowly  so okay here's a branching program  read once branching program um we're not  going to use the read once feature uh  just yet but we'll that'll come later  but anyway here's a branching program  um  and um  uh  oh here's my branch and i  put crashed here  start that again  um  okay so we take an input  um whatever it is um  and  thinking about the computation of the  branching process so we're not thinking  about the algorithm right now we're just  thinking about branching programs for  the minute we're going to get back to  the algorithm later  so the branching program follows a path  as i indicated when you have a  particular input your x1 is 0  x2 is 1  x3 is 1 so the output is going to be 1  in this case  okay  so  the way i want to think about this a  little differently  is i want to label all of the nodes and  all of the edges  uh with a value  that tells me whether or not this yellow  path went through that node or edge  it's going to be just a  doing the same but  you may think this is no difference at  all but i want to label all the all of  the things on the yellow path  i'm going to label them or the one  and all of the things that are not on  the yellow path  i'm going to label with a zero  so i'm keeping those trying to keep  those labels apart from the original  branching program  which are written in white these labels  are written yellow  but these labels have to do with the  execution of the branching program on an  input  so once i have an input that's going to  determine a one or a zero  label  for every node and edge  now  if we want to look at the output from  this branching program after we have  that labeling we only have to look at  the label of the one output node because  that's if that one has a one on it that  means that the path went through that  one and so therefore we should output  output output uh the output is one  um  uh  so  i'm going to give you another way of  assigning that instead of just coming  finding the path first and then coming  up with the labeling afterward i'm going  to give you a different way of coming up  with that labeling kind of building it  up inductively starting at the start  node and building up that labeling  you'll see what i mean  by my example  so if i have a label on this node  so i already know  whether or not the path went through  that node  you know label 1 means the path went  through it label 0 means the path  doesn't it does not go through it  [Music]  that's going to tell me how to label the  two outgoing edges  so if i'm if i've already labeled this  with a where a is a zero or one then  uh  what what expression should i use  um  to how do  under what circumstances will i label  what's what's the right label for this  one outgoing edge here  well if a is zero  that means the pair we know the path did  not go through this node so there's no  way it could go through that edge  similarly  if x i  is a zero  that means even if we did go through  that node  the path would go through the other edge  other outgoing edge and not to this one  so that tells us that the boolean  expression which describes the value the  label of this uh node in the execution  is going to be the and  of the  the value on the node and the um the  query variable of that node  now  think about what's the right way to  label the other edge  the the execution value of the other  edge  again you have to have go through this  node so a has to be one but now you want  x i to be 0 in order to go through that  edge so that means it's going to be a  and the complement of x i  okay so this is going to just tell me  this i'm writing a formula for how we're  labeling these uh these edges  based on the label of the of the parent  node  similarly if i have a bunch of edges  where i already know the values the  labels uh the execution levels there  let's say so i have a1 a2 and a3 what is  the right label to put on this node  um  well if any one of those is a one  that means the path went through that  edge and so therefore it's going to go  through that node  so that tells us that the label to put  on that node is the or  of the labels on the incoming edges  okay  questions on this  so now this is kind of setting the stage  for  starting to think about this  um  more toward polynomials instead instead  of using a boolean algebra  so um  quite i'm getting question how do we  know what the execution path is which  nodes to label we're going to be  labeling all of the nodes  so we start off with labeling the uh  did i say that here we should we start  up i didn't say but i should have we  label the the start node with one that  because the path always goes through the  start node so without even talking about  a path we just label the start node 1.  maybe we'll do an example of this also  but  now once we label this star this node 1  we have an expression  that tells us  how to label the two outgoing um the two  outgoing edges this edge and that edge  um  and i'm doing it without  knowing the values of the variables i'm  doing it kind of i'm just making an  expression uh which is going to describe  what those labels would be  once you tell me what the input  assignment is  okay so i'm just sort of it's almost  like a symbolic execution here i'm just  writing down the different expressions  for how to calculate what these things  should be  um  let's  let me um  maybe this will become clearer as we  continue  so the poll now this is the big idea of  this proof um  we're going to use something called  arithmetization  we're going to convert from thinking  about things in the boolean world to  thinking about things in the  arithmetical world where we you have  arithmetic  over integers let's say for now um  so instead of ands and ors we're going  to be talking about pluses and times  um  and uh  we're going to the way we're going to  make the bridge  is bishop by showing how to simulate the  ands and ors  the hand and or operations with the plus  and times operations  um  so um  assuming  one means true and zero means false  if you have  the expression a and b  as a boolean expression  we can represent that as a times b  using arithmetic  because  um it has it computes exactly the same  value  when we have um  the boolean  representation of true and false uh  being one and zero  so you know  one and one  is one  and one times one is one  and anything else you know one and zero  zero and one zero and zero  if you if you applied the times operator  you're going to get the same value so  times is very much like and in this  sense  okay we're going to write it as just a b  usually without the time symbol  so if we have a complement  how would we simulate that  with arithmetic  well  again  here we're just flipping one and zero  in using the complement operation that's  going to be the same as subtracting the  value from one that also flips it from  uh  between one and zero  um how about or if you have a or b  well um  it's slightly more complicated  because you use a plus b  um  but  you have to subtract off the product  because  what you want is this this  simulation should be  give you exactly the same value so what  if you have one or one  you want that to be a one a one answer  you don't want it to be a two  so you have to subtract off the product  um  uh  and the goal is is to have a faithful  simulation  of the and and or by using plus and  times so you get exactly the same  answers out  when you put in boolean values here  okay so  um  just to say where we're going  what this is going to  um  you know it sounds it's superficially we  haven't really done anything  um  this is  but um  what this is going to enable us to do is  plug in values which are not boolean  because you know it doesn't make sense  to talk about it makes sense to talk  about one and zero but it doesn't make  sense to talk about two and three  but it does talk it makes sense to talk  about two times three  and that's going to be  a useful  um okay so let's just see  um  remember  that that  that um  that inductive labeling procedure that i  described before  um where i labeled gave the execution  labels on the edges  depending upon the label of the parent  node and which node which variable is  being queried um so  if i know that this value is an a but  now the  uh  okay  so i'm just going to write this down  using uh arithmetic instead of using  boolean uh  operations  uh so before we have this was a an a and  x i if you remember from the previous  slide  um now what are we going to use instead  because we're going to use this  conversion here instead of and we're  going to use multiplication  that's just a times x i  what about on this side  here was  a and the complement of x i  now the complement of x i is one minus x  i  in the uh arithmetically so this becomes  a times one minus x i  okay um  similarly  here  we did the or  to get the label on the node from its  the labels of its incoming edges  now we're going to do something a little  strange um because we have a formula  here for or  but for technical reasons that will come  up later  this is not a convenient representation  for us  what i'm going to use instead of this  one i'm just going to simply say  just take the sum  why is that good enough  in this case this is still going to be a  faithful representation and give the  right answer all of the time  and that's because  for our  branching programs  read once or otherwise read once is not  coming in yet  for our branching programs  they're a cyclic  so they can never enter a node on two  different paths  there's at most one way to come into a  node uh um on a path through the on an  execution path through the branching  program if it comes in through uh  through to this edge  um  there's no way for it to for this edge  to also have a path because that means  you have to go out and come back  and and  have a cycle  in the branching program which is  disallowed so at most one of these edges  can have the path go through it  so at most one of these a's  can be a one the others are going to be  zero and therefore just taking the sum  is going to give us a value of either 0  or 1 but it's never going to give a  value higher and so you don't have to  subtract off these product terms  okay a little bit complicated here if  you didn't totally get that  um don't worry for now  you know we're um  you know more concerned that you get the  the big picture of what's going on  um  okay so um  i think we're almost  um  let me just see how far we are  yeah  so i'm just going to work through an  example and i think that'll bring us uh  let's just see any questions here  not seeing any  it means you're either all  totally understanding or or you're  totally lost i never can tell  um so feel free to ask a question if  you're even if you're confused um  you know i'll do my best  okay maybe this example might help  um  so now what we're going to do is using  this sort of arithmetical  view  of the way i  branching program's computation um you  know  is executed when when we're running it  uh um  you know an input through it um this is  going to allow us now to give a meaning  to running the branching program on  non-boolean inputs so maybe this example  will illustrate that  um  so let's just take this particular  branching program here  okay um  this branching program it's just on two  variables x1 and x2 and actually  computes a familiar function  this is the exclusive or function if you  look at it for a minute you'll see that  this is going to give you  x1 exclusive or x2  so it's going to be  one if either of the x1 or x2 are one  but it's going to be zero if they're  both one that's what this branching  program computes  now but let's take a  look um at running this branching  program instead of on the  usual boolean values let's run it on x1  equal to 2 and x2 equal to 3.  now  uh  um  you know a common confusion  might be that you're looking you know  when you do the x1 query you're looking  for  another  outgoing edge which is labeled two no  that's not what i'm doing what i'm doing  here is i'm somehow  uh through this execution  by assigning these other values i'm kind  of blending together the computation of  x x  uh 1 equal to 0 and x1 equal to 1  together  i don't know if that makes any sense but  let's look through the example  um so first of all these are the  labeling rules that i had from  uh the previous slide when i  used plus and times instead of and or  okay  now i'm going to show you how to use  that to label the nodes and edges of  this graph based on this input  and that'll determine an output  would be the value on the uh  the one node  okay so we always start out by labeling  the start node with one  that's just the rule  um  and  uh okay  sorry  let's let's think about it together  before i blurt out the answer  what's going to be the label on  this edge  so this is one of the outgoing edges uh  from a node that already has a label so  that's going to be this case here  and what we do is if we take we take the  label of that node  and since it's a one edge that's  outgoing  we multiply that label  by um the value  of uh that  uh  variable  of the the assignment to that variable  so x1 is two  so we take the the it's good this the a  here is one  x1 is a assigned to two so it's going to  be one times two  is going to be the value  the execution value we put on this edge  so it's going to be 2.  what's going to be the value we put on  the other edge the other edge the 0  outgoing edge from x1  so once you think about that for a  second  so now we're going to use this  expression  it's a times 1 minus x i  and so x i again is two so one minus x i  is one minus two  um  does that mean that's how complementary  but okay let's say that so it's one  minus 2 so that's minus 1 times the  label  1 here so you get minus 1 as the label  on this edge  now  keep in mind  that if i had plugged in and this is  very important if i had plugged in  boolean values here  i would be getting out the same boolean  values that you would get just by  following through the path  you know the things on the path would be  one the things off the path would be  zero  um  but uh  but with what's kind of uh what's  happening here is that  there's still a meaning  when the inputs are not boolean  so let's continue here how about what's  going to be the value on this node  so think with me i think it will help  you  so  now we're using this rule here we add up  all the values on the incoming edges  there's only one incoming edge which is  value two so that means this guy's going  to get a two and similar on this one  this guy's going to get a minus one  now let's take a look at this edge  so this is a the zero outgoing edge from  a node label two with with label x2  so this is the zero outgoing edge  the node the label is two so it's going  to be two times  one minus the x2 value x2 is 3 so 1  minus 3 is minus 2. it's going to be 2  times -2  which is minus 4.  so similarly you can get the value here  the value on the the  one outgoing edge is going to be  2 times  x the x2 value which is 3 so that's  going to be 6.  and these two here  uh um  so you know now we have a minus one  and the outgoing is a  it's a it's a zero edge so it's one  minus three  and here it's going to be one times  minus three  no  1 times 3 i'm sorry 1 times 3.  um  so you get the out the answer is minus  3. so now what's the label on the zero  output edge  so you have to add in add up the two  incoming edges here so we have  uh this  this edge here was a two  this edge coming in here is a six so  it's going to be two plus six  it's eight and what about this edge this  node here this is an important node  because this is going to be the output  so  it has  um  uh  you know minus three coming in  and a minus four coming in so you add  those together  you get a minus seven  i mean you may wonder  what  what the world is going on here um  just a lot of mumbo jumbo uh  but we're gonna make sense of all this  not today uh we're gonna have to argue  why this is  what the meaning that we're gonna get  out of this is gonna be  um but the point point is  that  this is going to lead to a new algorithm  for testing this is again getting back  to what we were  doing  this is  the equivalence problem for read once  branching programs so now what the new  algorithm is going to do is going to  pick a random non-boolean assignment  so it's going to randomly assign  values to the x's  and to some non-boolean values instead  of zeros and ones we're going to plug in  random  integer values we'll make that clear  next time what's what this what the  domain is going to be  um  [Music]  and then once we have that non-boolean  assignment we're going to value b1 and  b2  and if they disagree  out there in that extended  domain  then we have to show that they're not  equivalent and will reject  and we'll also show that  if they were equivalent  then even when we evaluate them  then we have to show that if if they're  not equivalent that they're very likely  to to have a difference in the  non-boolean uh domain and so um if they  agree it it  it gives you evidence that the two are  really equivalent  um so the completeness proof will come  after thanksgiving so with that um i'm  gonna wish you all a nice uh break um oh  we have a check in here sorry  oh yeah this is a good one  i don't know how if you're following me  uh but  um if i plug in one for x1  and y for x2  does it do the inputs in the assignment  need to be distinct no  it could be the same value  i could be  uh two and two here that's perfectly  valid  but here i'm going to plug in 1 for x1  i'm going to plug in a  variable for x2 y  and i'm going to do the whole  calculation that i just did and now  what's going to be the output  and i mean this looks like a pain to  figure out you could do it it looks like  a pain but let me give you a big hint  um  remember that this thing  is supposed to be calculating the  original branching program calculates  the exclusive or function  and that means when i plug in  um a boolean value  i should get the exclusive or value  coming out  so if i already know that x1 is one  which of these is consistent  with getting  a value  uh that the exclusive or function would  compute  so let me launch the poll on that  so we're at a time  so let's just let this run for another  10 seconds  okay  i'm going to close this  ready  um  yes indeed  a is the right answer because that's one  if i know that one variable is one then  the exclusive or  is going to be the complement of the  other variable  which is one minus y so that's what you  would get if you calculated this  um  because this is what we did today  and um  feel free to ask questions so let me  just so we're going to spend a good  chunk i'll review this  what we've done so far but then we're  going to carry it forward and spend a  good chunk of tuesday's lecture after  the  thanksgiving break uh proving that this  uh procedure that i just subscribed  worked and works and it's um  it's an interesting but somewhat  you know it's not such an easy proof uh  so we're going to spend the try to do it  slowly and clearly and then um but this  notion of arithmetization is going to be  this is this was  you know  it's it's an important notion in  complexity and so um we'll  we'll see it again coming up in another  proof afterwards  in about interactive proof systems  okay um  so please ask questions  so the output is the value of the one  output one state yes  that was a question i got  other questions  somebody's saying minus seven is not the  xor of two and three  what is the xor of two and three  so by the way i i should say we kind of  ran a little short on time i'm not  saying that we discovered some  fundamental new truth about xor here  um because that would be bizarre  it really depends on the arbitrary  decision that we made to say true is one  and false is zero  we could have come up with a different  representation for true and false and  then you would get a different value  for xor coming out of that you know from  the arithmetization that i just  described um  but uh for this particular way of  representing true and false that's how  xor and this particular branching  program that's how uh  what how xor evaluates  the the remainder of the proof so  somebody's asking which is it which is  true the fundamental theorem of algebra  which talks about polynomials and the  number of roots that you can have that's  going to be that's going to be critical  um  uh so the that is the fundamental  theorem of algebra that's where we're  going good good question  well you know so the  somebody's complaining that you know  we're not taking the  digit  binary representation of two and three  and taking the  bit by bit  um  xor well that's i'm not  you know  binary representation is not a part of  this  we're thinking of these as two elements  of a field  um of a finite field which we'll talk  about later  represent the binary representation is  isn't  is not is not entering into this  discussion  um  so talk about why just doing the sum is  enough  um  i think that was  so why is it i mean here it is why is  just doing the sum when i'm  looking at the um  the  how to describe the value of this node  based upon the values of all the  incoming nodes  and remember the point of the the  starting point of this is that we have  to faithfully represent the boolean  logic with the arithmetic  and then we're going to use that and  extend it to non-boolean values but as a  starting point we have to faithfully  represent the boolean values  now the boolean values  on the incoming edges at most one of  them can be  can be a one  because  the ones correspond to the  edges  of the execution path  and you can't make an execution path  um that's going to have two  branches  that's going to go through a node twice  because then you have a loop  and we don't have there's no cycles  allowed  okay  so i think where it's at four  um  i want to say farewell to all you all  have a great uh week and i'll see you  when you get back  you
 

3
00:00:29,349 --> 00:00:29,359

 

4
00:00:29,359 --> 00:00:31,669


5
00:00:31,669 --> 00:00:31,679

 

6
00:00:31,679 --> 00:00:32,950


7
00:00:32,950 --> 00:00:32,960

 

8
00:00:32,960 --> 00:00:34,470


9
00:00:34,470 --> 00:00:37,540

 

10
00:00:37,540 --> 00:00:37,550

 

11
00:00:37,550 --> 00:00:39,430


12
00:00:39,430 --> 00:00:39,440

 

13
00:00:39,440 --> 00:00:40,150


14
00:00:40,150 --> 00:00:42,630

 

15
00:00:42,630 --> 00:00:44,869

 

16
00:00:44,869 --> 00:00:46,630

 

17
00:00:46,630 --> 00:00:48,790

 

18
00:00:48,790 --> 00:00:52,150

 

19
00:00:52,150 --> 00:00:54,069

 

20
00:00:54,069 --> 00:00:56,069

 

21
00:00:56,069 --> 00:00:56,079

 

22
00:00:56,079 --> 00:00:57,350


23
00:00:57,350 --> 00:01:00,150

 

24
00:01:00,150 --> 00:01:02,310

 

25
00:01:02,310 --> 00:01:03,830

 

26
00:01:03,830 --> 00:01:06,710

 

27
00:01:06,710 --> 00:01:08,630

 

28
00:01:08,630 --> 00:01:10,550

 

29
00:01:10,550 --> 00:01:11,990

 

30
00:01:11,990 --> 00:01:12,000

 

31
00:01:12,000 --> 00:01:13,750


32
00:01:13,750 --> 00:01:16,630

 

33
00:01:16,630 --> 00:01:18,149

 

34
00:01:18,149 --> 00:01:20,710

 

35
00:01:20,710 --> 00:01:23,270

 

36
00:01:23,270 --> 00:01:25,830

 

37
00:01:25,830 --> 00:01:27,590

 

38
00:01:27,590 --> 00:01:30,789

 

39
00:01:30,789 --> 00:01:32,390

 

40
00:01:32,390 --> 00:01:34,789

 

41
00:01:34,789 --> 00:01:36,230

 

42
00:01:36,230 --> 00:01:38,230

 

43
00:01:38,230 --> 00:01:40,390

 

44
00:01:40,390 --> 00:01:43,510

 

45
00:01:43,510 --> 00:01:45,510

 

46
00:01:45,510 --> 00:01:45,520

 

47
00:01:45,520 --> 00:01:46,469


48
00:01:46,469 --> 00:01:49,190

 

49
00:01:49,190 --> 00:01:51,109

 

50
00:01:51,109 --> 00:01:53,670

 

51
00:01:53,670 --> 00:01:56,389

 

52
00:01:56,389 --> 00:01:58,389

 

53
00:01:58,389 --> 00:02:01,270

 

54
00:02:01,270 --> 00:02:04,550

 

55
00:02:04,550 --> 00:02:07,030

 

56
00:02:07,030 --> 00:02:08,949

 

57
00:02:08,949 --> 00:02:11,430

 

58
00:02:11,430 --> 00:02:14,070

 

59
00:02:14,070 --> 00:02:16,070

 

60
00:02:16,070 --> 00:02:17,990

 

61
00:02:17,990 --> 00:02:20,390

 

62
00:02:20,390 --> 00:02:22,790

 

63
00:02:22,790 --> 00:02:24,630

 

64
00:02:24,630 --> 00:02:27,350

 

65
00:02:27,350 --> 00:02:29,750

 

66
00:02:29,750 --> 00:02:31,750

 

67
00:02:31,750 --> 00:02:33,509

 

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

 

69
00:02:35,030 --> 00:02:37,190

 

70
00:02:37,190 --> 00:02:39,509

 

71
00:02:39,509 --> 00:02:41,190

 

72
00:02:41,190 --> 00:02:43,190

 

73
00:02:43,190 --> 00:02:45,589

 

74
00:02:45,589 --> 00:02:46,790

 

75
00:02:46,790 --> 00:02:46,800

 

76
00:02:46,800 --> 00:02:48,229


77
00:02:48,229 --> 00:02:50,470

 

78
00:02:50,470 --> 00:02:54,790

 

79
00:02:54,790 --> 00:02:54,800

 

80
00:02:54,800 --> 00:02:56,630


81
00:02:56,630 --> 00:02:56,640

 

82
00:02:56,640 --> 00:02:58,149


83
00:02:58,149 --> 00:02:58,159

 

84
00:02:58,159 --> 00:02:59,910


85
00:02:59,910 --> 00:02:59,920

 

86
00:02:59,920 --> 00:03:01,589


87
00:03:01,589 --> 00:03:03,750

 

88
00:03:03,750 --> 00:03:06,390

 

89
00:03:06,390 --> 00:03:09,350

 

90
00:03:09,350 --> 00:03:11,830

 

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

 

92
00:03:12,949 --> 00:03:14,229

 

93
00:03:14,229 --> 00:03:16,630

 

94
00:03:16,630 --> 00:03:19,430

 

95
00:03:19,430 --> 00:03:22,070

 

96
00:03:22,070 --> 00:03:23,110

 

97
00:03:23,110 --> 00:03:24,789

 

98
00:03:24,789 --> 00:03:27,270

 

99
00:03:27,270 --> 00:03:27,280

 

100
00:03:27,280 --> 00:03:28,149


101
00:03:28,149 --> 00:03:29,910

 

102
00:03:29,910 --> 00:03:33,350

 

103
00:03:33,350 --> 00:03:35,350

 

104
00:03:35,350 --> 00:03:39,110

 

105
00:03:39,110 --> 00:03:41,190

 

106
00:03:41,190 --> 00:03:42,710

 

107
00:03:42,710 --> 00:03:44,229

 

108
00:03:44,229 --> 00:03:47,110

 

109
00:03:47,110 --> 00:03:49,589

 

110
00:03:49,589 --> 00:03:49,599

 

111
00:03:49,599 --> 00:03:50,390


112
00:03:50,390 --> 00:03:52,070

 

113
00:03:52,070 --> 00:03:54,789

 

114
00:03:54,789 --> 00:03:57,030

 

115
00:03:57,030 --> 00:03:57,040

 

116
00:03:57,040 --> 00:03:57,990


117
00:03:57,990 --> 00:04:01,429

 

118
00:04:01,429 --> 00:04:01,439

 

119
00:04:01,439 --> 00:04:02,789


120
00:04:02,789 --> 00:04:02,799

 

121
00:04:02,799 --> 00:04:03,670


122
00:04:03,670 --> 00:04:06,229

 

123
00:04:06,229 --> 00:04:06,239

 

124
00:04:06,239 --> 00:04:07,830


125
00:04:07,830 --> 00:04:07,840

 

126
00:04:07,840 --> 00:04:09,030


127
00:04:09,030 --> 00:04:12,229

 

128
00:04:12,229 --> 00:04:15,670

 

129
00:04:15,670 --> 00:04:18,310

 

130
00:04:18,310 --> 00:04:20,469

 

131
00:04:20,469 --> 00:04:23,189

 

132
00:04:23,189 --> 00:04:24,710

 

133
00:04:24,710 --> 00:04:27,110

 

134
00:04:27,110 --> 00:04:28,550

 

135
00:04:28,550 --> 00:04:30,629

 

136
00:04:30,629 --> 00:04:32,310

 

137
00:04:32,310 --> 00:04:33,830

 

138
00:04:33,830 --> 00:04:35,110

 

139
00:04:35,110 --> 00:04:37,510

 

140
00:04:37,510 --> 00:04:39,030

 

141
00:04:39,030 --> 00:04:42,070

 

142
00:04:42,070 --> 00:04:44,310

 

143
00:04:44,310 --> 00:04:46,629

 

144
00:04:46,629 --> 00:04:46,639

 

145
00:04:46,639 --> 00:04:47,590


146
00:04:47,590 --> 00:04:48,710

 

147
00:04:48,710 --> 00:04:51,430

 

148
00:04:51,430 --> 00:04:53,510

 

149
00:04:53,510 --> 00:04:55,510

 

150
00:04:55,510 --> 00:04:57,189

 

151
00:04:57,189 --> 00:04:59,510

 

152
00:04:59,510 --> 00:05:00,950

 

153
00:05:00,950 --> 00:05:00,960

 

154
00:05:00,960 --> 00:05:01,830


155
00:05:01,830 --> 00:05:03,990

 

156
00:05:03,990 --> 00:05:05,590

 

157
00:05:05,590 --> 00:05:08,469

 

158
00:05:08,469 --> 00:05:09,909

 

159
00:05:09,909 --> 00:05:11,350

 

160
00:05:11,350 --> 00:05:13,590

 

161
00:05:13,590 --> 00:05:15,110

 

162
00:05:15,110 --> 00:05:17,510

 

163
00:05:17,510 --> 00:05:19,590

 

164
00:05:19,590 --> 00:05:23,029

 

165
00:05:23,029 --> 00:05:25,670

 

166
00:05:25,670 --> 00:05:28,230

 

167
00:05:28,230 --> 00:05:30,390

 

168
00:05:30,390 --> 00:05:32,710

 

169
00:05:32,710 --> 00:05:35,270

 

170
00:05:35,270 --> 00:05:37,430

 

171
00:05:37,430 --> 00:05:39,830

 

172
00:05:39,830 --> 00:05:41,749

 

173
00:05:41,749 --> 00:05:43,590

 

174
00:05:43,590 --> 00:05:45,749

 

175
00:05:45,749 --> 00:05:47,590

 

176
00:05:47,590 --> 00:05:50,550

 

177
00:05:50,550 --> 00:05:50,560

 

178
00:05:50,560 --> 00:05:52,310


179
00:05:52,310 --> 00:05:53,590

 

180
00:05:53,590 --> 00:05:53,600

 

181
00:05:53,600 --> 00:05:54,469


182
00:05:54,469 --> 00:05:54,479

 

183
00:05:54,479 --> 00:05:55,670


184
00:05:55,670 --> 00:05:57,350

 

185
00:05:57,350 --> 00:05:57,360

 

186
00:05:57,360 --> 00:05:58,390


187
00:05:58,390 --> 00:06:00,309

 

188
00:06:00,309 --> 00:06:02,230

 

189
00:06:02,230 --> 00:06:03,909

 

190
00:06:03,909 --> 00:06:05,830

 

191
00:06:05,830 --> 00:06:08,870

 

192
00:06:08,870 --> 00:06:10,550

 

193
00:06:10,550 --> 00:06:12,469

 

194
00:06:12,469 --> 00:06:15,670

 

195
00:06:15,670 --> 00:06:18,230

 

196
00:06:18,230 --> 00:06:21,909

 

197
00:06:21,909 --> 00:06:23,909

 

198
00:06:23,909 --> 00:06:26,469

 

199
00:06:26,469 --> 00:06:29,350

 

200
00:06:29,350 --> 00:06:31,510

 

201
00:06:31,510 --> 00:06:33,430

 

202
00:06:33,430 --> 00:06:35,990

 

203
00:06:35,990 --> 00:06:36,000

 

204
00:06:36,000 --> 00:06:37,830


205
00:06:37,830 --> 00:06:40,070

 

206
00:06:40,070 --> 00:06:40,080

 

207
00:06:40,080 --> 00:06:41,029


208
00:06:41,029 --> 00:06:43,350

 

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

 

210
00:06:45,430 --> 00:06:45,440

 

211
00:06:45,440 --> 00:06:46,629


212
00:06:46,629 --> 00:06:49,029

 

213
00:06:49,029 --> 00:06:51,350

 

214
00:06:51,350 --> 00:06:52,870

 

215
00:06:52,870 --> 00:06:55,830

 

216
00:06:55,830 --> 00:06:57,430

 

217
00:06:57,430 --> 00:06:59,350

 

218
00:06:59,350 --> 00:07:02,550

 

219
00:07:02,550 --> 00:07:05,029

 

220
00:07:05,029 --> 00:07:07,270

 

221
00:07:07,270 --> 00:07:09,189

 

222
00:07:09,189 --> 00:07:11,589

 

223
00:07:11,589 --> 00:07:13,430

 

224
00:07:13,430 --> 00:07:15,909

 

225
00:07:15,909 --> 00:07:17,589

 

226
00:07:17,589 --> 00:07:17,599

 

227
00:07:17,599 --> 00:07:19,110


228
00:07:19,110 --> 00:07:19,120

 

229
00:07:19,120 --> 00:07:20,790


230
00:07:20,790 --> 00:07:23,270

 

231
00:07:23,270 --> 00:07:25,589

 

232
00:07:25,589 --> 00:07:28,390

 

233
00:07:28,390 --> 00:07:31,990

 

234
00:07:31,990 --> 00:07:33,270

 

235
00:07:33,270 --> 00:07:34,950

 

236
00:07:34,950 --> 00:07:36,950

 

237
00:07:36,950 --> 00:07:38,790

 

238
00:07:38,790 --> 00:07:38,800

 

239
00:07:38,800 --> 00:07:40,990


240
00:07:40,990 --> 00:07:41,000

 

241
00:07:41,000 --> 00:07:42,629


242
00:07:42,629 --> 00:07:45,350

 

243
00:07:45,350 --> 00:07:47,189

 

244
00:07:47,189 --> 00:07:49,270

 

245
00:07:49,270 --> 00:07:52,150

 

246
00:07:52,150 --> 00:07:53,749

 

247
00:07:53,749 --> 00:07:56,230

 

248
00:07:56,230 --> 00:07:59,189

 

249
00:07:59,189 --> 00:08:00,550

 

250
00:08:00,550 --> 00:08:02,469

 

251
00:08:02,469 --> 00:08:04,869

 

252
00:08:04,869 --> 00:08:06,869

 

253
00:08:06,869 --> 00:08:08,390

 

254
00:08:08,390 --> 00:08:11,589

 

255
00:08:11,589 --> 00:08:14,230

 

256
00:08:14,230 --> 00:08:15,830

 

257
00:08:15,830 --> 00:08:17,830

 

258
00:08:17,830 --> 00:08:19,670

 

259
00:08:19,670 --> 00:08:21,430

 

260
00:08:21,430 --> 00:08:23,110

 

261
00:08:23,110 --> 00:08:26,309

 

262
00:08:26,309 --> 00:08:28,150

 

263
00:08:28,150 --> 00:08:29,749

 

264
00:08:29,749 --> 00:08:31,589

 

265
00:08:31,589 --> 00:08:33,110

 

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

 

267
00:08:35,029 --> 00:08:36,310

 

268
00:08:36,310 --> 00:08:39,029

 

269
00:08:39,029 --> 00:08:42,070

 

270
00:08:42,070 --> 00:08:43,750

 

271
00:08:43,750 --> 00:08:46,230

 

272
00:08:46,230 --> 00:08:48,389

 

273
00:08:48,389 --> 00:08:50,630

 

274
00:08:50,630 --> 00:08:50,640

 

275
00:08:50,640 --> 00:08:52,550


276
00:08:52,550 --> 00:08:54,790

 

277
00:08:54,790 --> 00:08:56,710

 

278
00:08:56,710 --> 00:08:59,190

 

279
00:08:59,190 --> 00:09:01,190

 

280
00:09:01,190 --> 00:09:05,030

 

281
00:09:05,030 --> 00:09:07,190

 

282
00:09:07,190 --> 00:09:09,430

 

283
00:09:09,430 --> 00:09:12,550

 

284
00:09:12,550 --> 00:09:14,710

 

285
00:09:14,710 --> 00:09:14,720

 

286
00:09:14,720 --> 00:09:15,670


287
00:09:15,670 --> 00:09:17,670

 

288
00:09:17,670 --> 00:09:19,590

 

289
00:09:19,590 --> 00:09:21,430

 

290
00:09:21,430 --> 00:09:23,350

 

291
00:09:23,350 --> 00:09:25,350

 

292
00:09:25,350 --> 00:09:26,630

 

293
00:09:26,630 --> 00:09:29,670

 

294
00:09:29,670 --> 00:09:31,590

 

295
00:09:31,590 --> 00:09:33,670

 

296
00:09:33,670 --> 00:09:35,990

 

297
00:09:35,990 --> 00:09:38,150

 

298
00:09:38,150 --> 00:09:40,230

 

299
00:09:40,230 --> 00:09:41,590

 

300
00:09:41,590 --> 00:09:43,990

 

301
00:09:43,990 --> 00:09:45,670

 

302
00:09:45,670 --> 00:09:45,680

 

303
00:09:45,680 --> 00:09:46,470


304
00:09:46,470 --> 00:09:46,480

 

305
00:09:46,480 --> 00:09:46,850


306
00:09:46,850 --> 00:09:46,860

 

307
00:09:46,860 --> 00:09:48,310


308
00:09:48,310 --> 00:09:51,030

 

309
00:09:51,030 --> 00:09:52,790

 

310
00:09:52,790 --> 00:09:58,230

 

311
00:09:58,230 --> 00:09:58,240

 

312
00:09:58,240 --> 00:09:59,509


313
00:09:59,509 --> 00:10:01,430

 

314
00:10:01,430 --> 00:10:01,440

 

315
00:10:01,440 --> 00:10:03,670


316
00:10:03,670 --> 00:10:03,680

 

317
00:10:03,680 --> 00:10:11,350


318
00:10:11,350 --> 00:10:12,470

 

319
00:10:12,470 --> 00:10:15,110

 

320
00:10:15,110 --> 00:10:16,710

 

321
00:10:16,710 --> 00:10:20,069

 

322
00:10:20,069 --> 00:10:21,829

 

323
00:10:21,829 --> 00:10:23,750

 

324
00:10:23,750 --> 00:10:25,110

 

325
00:10:25,110 --> 00:10:25,120

 

326
00:10:25,120 --> 00:10:26,069


327
00:10:26,069 --> 00:10:28,230

 

328
00:10:28,230 --> 00:10:29,990

 

329
00:10:29,990 --> 00:10:32,389

 

330
00:10:32,389 --> 00:10:36,310

 

331
00:10:36,310 --> 00:10:36,320

 

332
00:10:36,320 --> 00:10:38,230


333
00:10:38,230 --> 00:10:40,150

 

334
00:10:40,150 --> 00:10:42,949

 

335
00:10:42,949 --> 00:10:44,949

 

336
00:10:44,949 --> 00:10:47,030

 

337
00:10:47,030 --> 00:10:49,990

 

338
00:10:49,990 --> 00:10:51,750

 

339
00:10:51,750 --> 00:10:53,590

 

340
00:10:53,590 --> 00:10:56,150

 

341
00:10:56,150 --> 00:10:57,829

 

342
00:10:57,829 --> 00:10:59,990

 

343
00:10:59,990 --> 00:11:02,310

 

344
00:11:02,310 --> 00:11:05,590

 

345
00:11:05,590 --> 00:11:07,590

 

346
00:11:07,590 --> 00:11:09,350

 

347
00:11:09,350 --> 00:11:12,230

 

348
00:11:12,230 --> 00:11:14,230

 

349
00:11:14,230 --> 00:11:15,430

 

350
00:11:15,430 --> 00:11:17,269

 

351
00:11:17,269 --> 00:11:19,590

 

352
00:11:19,590 --> 00:11:22,389

 

353
00:11:22,389 --> 00:11:24,389

 

354
00:11:24,389 --> 00:11:24,399

 

355
00:11:24,399 --> 00:11:26,389


356
00:11:26,389 --> 00:11:28,710

 

357
00:11:28,710 --> 00:11:31,350

 

358
00:11:31,350 --> 00:11:33,430

 

359
00:11:33,430 --> 00:11:36,310

 

360
00:11:36,310 --> 00:11:37,990

 

361
00:11:37,990 --> 00:11:39,990

 

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

 

363
00:11:41,509 --> 00:11:43,190

 

364
00:11:43,190 --> 00:11:46,069

 

365
00:11:46,069 --> 00:11:48,870

 

366
00:11:48,870 --> 00:11:50,790

 

367
00:11:50,790 --> 00:11:52,629

 

368
00:11:52,629 --> 00:11:55,590

 

369
00:11:55,590 --> 00:11:59,509

 

370
00:11:59,509 --> 00:12:01,990

 

371
00:12:01,990 --> 00:12:03,829

 

372
00:12:03,829 --> 00:12:06,150

 

373
00:12:06,150 --> 00:12:07,670

 

374
00:12:07,670 --> 00:12:11,269

 

375
00:12:11,269 --> 00:12:13,750

 

376
00:12:13,750 --> 00:12:15,190

 

377
00:12:15,190 --> 00:12:18,550

 

378
00:12:18,550 --> 00:12:22,230

 

379
00:12:22,230 --> 00:12:23,590

 

380
00:12:23,590 --> 00:12:25,590

 

381
00:12:25,590 --> 00:12:28,230

 

382
00:12:28,230 --> 00:12:30,310

 

383
00:12:30,310 --> 00:12:32,790

 

384
00:12:32,790 --> 00:12:35,190

 

385
00:12:35,190 --> 00:12:37,269

 

386
00:12:37,269 --> 00:12:38,870

 

387
00:12:38,870 --> 00:12:40,470

 

388
00:12:40,470 --> 00:12:40,480

 

389
00:12:40,480 --> 00:12:41,670


390
00:12:41,670 --> 00:12:44,550

 

391
00:12:44,550 --> 00:12:44,560

 

392
00:12:44,560 --> 00:12:45,750


393
00:12:45,750 --> 00:12:45,760

 

394
00:12:45,760 --> 00:12:48,310


395
00:12:48,310 --> 00:12:50,790

 

396
00:12:50,790 --> 00:12:52,230

 

397
00:12:52,230 --> 00:12:55,190

 

398
00:12:55,190 --> 00:12:55,200

 

399
00:12:55,200 --> 00:12:56,949


400
00:12:56,949 --> 00:12:59,110

 

401
00:12:59,110 --> 00:13:00,710

 

402
00:13:00,710 --> 00:13:00,720

 

403
00:13:00,720 --> 00:13:02,389


404
00:13:02,389 --> 00:13:04,870

 

405
00:13:04,870 --> 00:13:06,870

 

406
00:13:06,870 --> 00:13:08,710

 

407
00:13:08,710 --> 00:13:10,710

 

408
00:13:10,710 --> 00:13:13,350

 

409
00:13:13,350 --> 00:13:15,509

 

410
00:13:15,509 --> 00:13:15,519

 

411
00:13:15,519 --> 00:13:16,790


412
00:13:16,790 --> 00:13:19,190

 

413
00:13:19,190 --> 00:13:20,790

 

414
00:13:20,790 --> 00:13:22,550

 

415
00:13:22,550 --> 00:13:24,069

 

416
00:13:24,069 --> 00:13:27,030

 

417
00:13:27,030 --> 00:13:29,190

 

418
00:13:29,190 --> 00:13:29,200

 

419
00:13:29,200 --> 00:13:31,110


420
00:13:31,110 --> 00:13:32,389

 

421
00:13:32,389 --> 00:13:32,399

 

422
00:13:32,399 --> 00:13:33,590


423
00:13:33,590 --> 00:13:36,069

 

424
00:13:36,069 --> 00:13:38,230

 

425
00:13:38,230 --> 00:13:38,240

 

426
00:13:38,240 --> 00:13:39,110


427
00:13:39,110 --> 00:13:41,189

 

428
00:13:41,189 --> 00:13:43,750

 

429
00:13:43,750 --> 00:13:45,670

 

430
00:13:45,670 --> 00:13:47,509

 

431
00:13:47,509 --> 00:13:48,629

 

432
00:13:48,629 --> 00:13:50,949

 

433
00:13:50,949 --> 00:13:53,750

 

434
00:13:53,750 --> 00:13:55,750

 

435
00:13:55,750 --> 00:13:57,269

 

436
00:13:57,269 --> 00:13:59,350

 

437
00:13:59,350 --> 00:14:01,189

 

438
00:14:01,189 --> 00:14:03,590

 

439
00:14:03,590 --> 00:14:06,550

 

440
00:14:06,550 --> 00:14:06,560

 

441
00:14:06,560 --> 00:14:07,269


442
00:14:07,269 --> 00:14:07,279

 

443
00:14:07,279 --> 00:14:08,150


444
00:14:08,150 --> 00:14:09,829

 

445
00:14:09,829 --> 00:14:11,509

 

446
00:14:11,509 --> 00:14:11,519

 

447
00:14:11,519 --> 00:14:13,269


448
00:14:13,269 --> 00:14:15,030

 

449
00:14:15,030 --> 00:14:19,750

 

450
00:14:19,750 --> 00:14:22,710

 

451
00:14:22,710 --> 00:14:24,629

 

452
00:14:24,629 --> 00:14:27,030

 

453
00:14:27,030 --> 00:14:29,189

 

454
00:14:29,189 --> 00:14:31,189

 

455
00:14:31,189 --> 00:14:33,509

 

456
00:14:33,509 --> 00:14:35,509

 

457
00:14:35,509 --> 00:14:37,590

 

458
00:14:37,590 --> 00:14:37,600

 

459
00:14:37,600 --> 00:14:38,870


460
00:14:38,870 --> 00:14:40,389

 

461
00:14:40,389 --> 00:14:46,389

 

462
00:14:46,389 --> 00:14:48,790

 

463
00:14:48,790 --> 00:14:51,350

 

464
00:14:51,350 --> 00:14:52,949

 

465
00:14:52,949 --> 00:14:54,389

 

466
00:14:54,389 --> 00:14:56,870

 

467
00:14:56,870 --> 00:14:58,150

 

468
00:14:58,150 --> 00:15:00,069

 

469
00:15:00,069 --> 00:15:01,829

 

470
00:15:01,829 --> 00:15:03,350

 

471
00:15:03,350 --> 00:15:04,870

 

472
00:15:04,870 --> 00:15:07,430

 

473
00:15:07,430 --> 00:15:09,189

 

474
00:15:09,189 --> 00:15:11,110

 

475
00:15:11,110 --> 00:15:13,030

 

476
00:15:13,030 --> 00:15:13,040

 

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


478
00:15:13,829 --> 00:15:16,790

 

479
00:15:16,790 --> 00:15:19,269

 

480
00:15:19,269 --> 00:15:20,790

 

481
00:15:20,790 --> 00:15:23,910

 

482
00:15:23,910 --> 00:15:25,590

 

483
00:15:25,590 --> 00:15:27,110

 

484
00:15:27,110 --> 00:15:28,790

 

485
00:15:28,790 --> 00:15:30,150

 

486
00:15:30,150 --> 00:15:31,829

 

487
00:15:31,829 --> 00:15:33,910

 

488
00:15:33,910 --> 00:15:33,920

 

489
00:15:33,920 --> 00:15:34,949


490
00:15:34,949 --> 00:15:37,030

 

491
00:15:37,030 --> 00:15:38,230

 

492
00:15:38,230 --> 00:15:40,550

 

493
00:15:40,550 --> 00:15:42,870

 

494
00:15:42,870 --> 00:15:44,790

 

495
00:15:44,790 --> 00:15:46,949

 

496
00:15:46,949 --> 00:15:50,230

 

497
00:15:50,230 --> 00:15:53,590

 

498
00:15:53,590 --> 00:15:56,150

 

499
00:15:56,150 --> 00:15:58,550

 

500
00:15:58,550 --> 00:16:00,310

 

501
00:16:00,310 --> 00:16:00,320

 

502
00:16:00,320 --> 00:16:01,590


503
00:16:01,590 --> 00:16:01,600

 

504
00:16:01,600 --> 00:16:02,550


505
00:16:02,550 --> 00:16:05,110

 

506
00:16:05,110 --> 00:16:07,670

 

507
00:16:07,670 --> 00:16:09,749

 

508
00:16:09,749 --> 00:16:12,629

 

509
00:16:12,629 --> 00:16:12,639

 

510
00:16:12,639 --> 00:16:14,310


511
00:16:14,310 --> 00:16:15,670

 

512
00:16:15,670 --> 00:16:18,710

 

513
00:16:18,710 --> 00:16:18,720

 

514
00:16:18,720 --> 00:16:19,910


515
00:16:19,910 --> 00:16:23,110

 

516
00:16:23,110 --> 00:16:25,590

 

517
00:16:25,590 --> 00:16:27,910

 

518
00:16:27,910 --> 00:16:29,910

 

519
00:16:29,910 --> 00:16:31,749

 

520
00:16:31,749 --> 00:16:34,710

 

521
00:16:34,710 --> 00:16:36,150

 

522
00:16:36,150 --> 00:16:38,629

 

523
00:16:38,629 --> 00:16:41,030

 

524
00:16:41,030 --> 00:16:43,030

 

525
00:16:43,030 --> 00:16:45,590

 

526
00:16:45,590 --> 00:16:48,870

 

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

 

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

 

529
00:16:51,199 --> 00:16:51,910


530
00:16:51,910 --> 00:16:53,910

 

531
00:16:53,910 --> 00:16:53,920

 

532
00:16:53,920 --> 00:16:54,790


533
00:16:54,790 --> 00:16:54,800

 

534
00:16:54,800 --> 00:16:56,150


535
00:16:56,150 --> 00:16:58,550

 

536
00:16:58,550 --> 00:16:58,560

 

537
00:16:58,560 --> 00:16:59,990


538
00:16:59,990 --> 00:17:01,749

 

539
00:17:01,749 --> 00:17:04,549

 

540
00:17:04,549 --> 00:17:06,710

 

541
00:17:06,710 --> 00:17:10,549

 

542
00:17:10,549 --> 00:17:12,870

 

543
00:17:12,870 --> 00:17:14,549

 

544
00:17:14,549 --> 00:17:17,350

 

545
00:17:17,350 --> 00:17:19,990

 

546
00:17:19,990 --> 00:17:21,909

 

547
00:17:21,909 --> 00:17:21,919

 

548
00:17:21,919 --> 00:17:23,429


549
00:17:23,429 --> 00:17:23,439

 

550
00:17:23,439 --> 00:17:24,230


551
00:17:24,230 --> 00:17:26,789

 

552
00:17:26,789 --> 00:17:29,029

 

553
00:17:29,029 --> 00:17:31,350

 

554
00:17:31,350 --> 00:17:33,750

 

555
00:17:33,750 --> 00:17:35,990

 

556
00:17:35,990 --> 00:17:37,909

 

557
00:17:37,909 --> 00:17:40,470

 

558
00:17:40,470 --> 00:17:43,830

 

559
00:17:43,830 --> 00:17:45,990

 

560
00:17:45,990 --> 00:17:47,909

 

561
00:17:47,909 --> 00:17:49,990

 

562
00:17:49,990 --> 00:17:51,590

 

563
00:17:51,590 --> 00:17:53,590

 

564
00:17:53,590 --> 00:17:55,350

 

565
00:17:55,350 --> 00:17:56,710

 

566
00:17:56,710 --> 00:17:58,230

 

567
00:17:58,230 --> 00:17:59,750

 

568
00:17:59,750 --> 00:18:01,830

 

569
00:18:01,830 --> 00:18:01,840

 

570
00:18:01,840 --> 00:18:04,549


571
00:18:04,549 --> 00:18:07,909

 

572
00:18:07,909 --> 00:18:09,190

 

573
00:18:09,190 --> 00:18:11,270

 

574
00:18:11,270 --> 00:18:13,110

 

575
00:18:13,110 --> 00:18:16,390

 

576
00:18:16,390 --> 00:18:17,990

 

577
00:18:17,990 --> 00:18:19,990

 

578
00:18:19,990 --> 00:18:21,430

 

579
00:18:21,430 --> 00:18:23,430

 

580
00:18:23,430 --> 00:18:25,750

 

581
00:18:25,750 --> 00:18:28,470

 

582
00:18:28,470 --> 00:18:30,070

 

583
00:18:30,070 --> 00:18:31,430

 

584
00:18:31,430 --> 00:18:33,350

 

585
00:18:33,350 --> 00:18:37,029

 

586
00:18:37,029 --> 00:18:38,470

 

587
00:18:38,470 --> 00:18:41,110

 

588
00:18:41,110 --> 00:18:41,120

 

589
00:18:41,120 --> 00:18:43,190


590
00:18:43,190 --> 00:18:44,100

 

591
00:18:44,100 --> 00:18:44,110

 

592
00:18:44,110 --> 00:18:50,150


593
00:18:50,150 --> 00:18:50,160

 

594
00:18:50,160 --> 00:18:51,750


595
00:18:51,750 --> 00:18:52,950

 

596
00:18:52,950 --> 00:18:55,510

 

597
00:18:55,510 --> 00:18:57,750

 

598
00:18:57,750 --> 00:18:59,590

 

599
00:18:59,590 --> 00:18:59,600

 

600
00:18:59,600 --> 00:19:00,630


601
00:19:00,630 --> 00:19:03,190

 

602
00:19:03,190 --> 00:19:05,270

 

603
00:19:05,270 --> 00:19:07,270

 

604
00:19:07,270 --> 00:19:09,669

 

605
00:19:09,669 --> 00:19:12,310

 

606
00:19:12,310 --> 00:19:14,230

 

607
00:19:14,230 --> 00:19:15,110

 

608
00:19:15,110 --> 00:19:16,390

 

609
00:19:16,390 --> 00:19:17,990

 

610
00:19:17,990 --> 00:19:19,909

 

611
00:19:19,909 --> 00:19:21,430

 

612
00:19:21,430 --> 00:19:21,440

 

613
00:19:21,440 --> 00:19:22,150


614
00:19:22,150 --> 00:19:25,909

 

615
00:19:25,909 --> 00:19:28,789

 

616
00:19:28,789 --> 00:19:28,799

 

617
00:19:28,799 --> 00:19:32,070


618
00:19:32,070 --> 00:19:34,870

 

619
00:19:34,870 --> 00:19:38,710

 

620
00:19:38,710 --> 00:19:40,630

 

621
00:19:40,630 --> 00:19:41,830

 

622
00:19:41,830 --> 00:19:44,310

 

623
00:19:44,310 --> 00:19:46,630

 

624
00:19:46,630 --> 00:19:48,310

 

625
00:19:48,310 --> 00:19:52,230

 

626
00:19:52,230 --> 00:19:54,789

 

627
00:19:54,789 --> 00:19:56,630

 

628
00:19:56,630 --> 00:19:59,029

 

629
00:19:59,029 --> 00:20:01,909

 

630
00:20:01,909 --> 00:20:01,919

 

631
00:20:01,919 --> 00:20:02,950


632
00:20:02,950 --> 00:20:05,990

 

633
00:20:05,990 --> 00:20:08,149

 

634
00:20:08,149 --> 00:20:10,230

 

635
00:20:10,230 --> 00:20:12,230

 

636
00:20:12,230 --> 00:20:14,470

 

637
00:20:14,470 --> 00:20:16,950

 

638
00:20:16,950 --> 00:20:18,950

 

639
00:20:18,950 --> 00:20:21,909

 

640
00:20:21,909 --> 00:20:23,830

 

641
00:20:23,830 --> 00:20:25,830

 

642
00:20:25,830 --> 00:20:27,350

 

643
00:20:27,350 --> 00:20:28,789

 

644
00:20:28,789 --> 00:20:31,430

 

645
00:20:31,430 --> 00:20:33,350

 

646
00:20:33,350 --> 00:20:35,430

 

647
00:20:35,430 --> 00:20:36,950

 

648
00:20:36,950 --> 00:20:39,110

 

649
00:20:39,110 --> 00:20:40,070

 

650
00:20:40,070 --> 00:20:42,230

 

651
00:20:42,230 --> 00:20:43,669

 

652
00:20:43,669 --> 00:20:46,070

 

653
00:20:46,070 --> 00:20:48,950

 

654
00:20:48,950 --> 00:20:53,110

 

655
00:20:53,110 --> 00:20:54,950

 

656
00:20:54,950 --> 00:20:57,830

 

657
00:20:57,830 --> 00:20:59,750

 

658
00:20:59,750 --> 00:21:02,470

 

659
00:21:02,470 --> 00:21:05,190

 

660
00:21:05,190 --> 00:21:07,190

 

661
00:21:07,190 --> 00:21:08,630

 

662
00:21:08,630 --> 00:21:10,070

 

663
00:21:10,070 --> 00:21:10,080

 

664
00:21:10,080 --> 00:21:11,990


665
00:21:11,990 --> 00:21:13,350

 

666
00:21:13,350 --> 00:21:14,549

 

667
00:21:14,549 --> 00:21:17,190

 

668
00:21:17,190 --> 00:21:18,789

 

669
00:21:18,789 --> 00:21:18,799

 

670
00:21:18,799 --> 00:21:19,750


671
00:21:19,750 --> 00:21:22,870

 

672
00:21:22,870 --> 00:21:26,149

 

673
00:21:26,149 --> 00:21:28,230

 

674
00:21:28,230 --> 00:21:32,950

 

675
00:21:32,950 --> 00:21:35,430

 

676
00:21:35,430 --> 00:21:37,669

 

677
00:21:37,669 --> 00:21:41,110

 

678
00:21:41,110 --> 00:21:42,390

 

679
00:21:42,390 --> 00:21:45,190

 

680
00:21:45,190 --> 00:21:47,909

 

681
00:21:47,909 --> 00:21:50,870

 

682
00:21:50,870 --> 00:21:50,880

 

683
00:21:50,880 --> 00:21:51,909


684
00:21:51,909 --> 00:21:51,919

 

685
00:21:51,919 --> 00:21:52,870


686
00:21:52,870 --> 00:21:55,430

 

687
00:21:55,430 --> 00:21:57,669

 

688
00:21:57,669 --> 00:22:00,230

 

689
00:22:00,230 --> 00:22:02,549

 

690
00:22:02,549 --> 00:22:03,510

 

691
00:22:03,510 --> 00:22:07,029

 

692
00:22:07,029 --> 00:22:08,630

 

693
00:22:08,630 --> 00:22:11,029

 

694
00:22:11,029 --> 00:22:13,029

 

695
00:22:13,029 --> 00:22:14,870

 

696
00:22:14,870 --> 00:22:19,110

 

697
00:22:19,110 --> 00:22:19,120

 

698
00:22:19,120 --> 00:22:20,549


699
00:22:20,549 --> 00:22:29,669

 

700
00:22:29,669 --> 00:22:29,679

 

701
00:22:29,679 --> 00:22:31,510


702
00:22:31,510 --> 00:22:33,190

 

703
00:22:33,190 --> 00:22:36,230

 

704
00:22:36,230 --> 00:22:39,029

 

705
00:22:39,029 --> 00:22:42,549

 

706
00:22:42,549 --> 00:22:43,909

 

707
00:22:43,909 --> 00:22:43,919

 

708
00:22:43,919 --> 00:22:47,350


709
00:22:47,350 --> 00:22:47,360

 

710
00:22:47,360 --> 00:22:48,149


711
00:22:48,149 --> 00:22:49,430

 

712
00:22:49,430 --> 00:22:51,430

 

713
00:22:51,430 --> 00:22:51,440

 

714
00:22:51,440 --> 00:22:52,870


715
00:22:52,870 --> 00:22:56,950

 

716
00:22:56,950 --> 00:22:56,960

 

717
00:22:56,960 --> 00:22:59,029


718
00:22:59,029 --> 00:23:01,830

 

719
00:23:01,830 --> 00:23:05,990

 

720
00:23:05,990 --> 00:23:07,270

 

721
00:23:07,270 --> 00:23:09,350

 

722
00:23:09,350 --> 00:23:11,750

 

723
00:23:11,750 --> 00:23:13,510

 

724
00:23:13,510 --> 00:23:14,789

 

725
00:23:14,789 --> 00:23:14,799

 

726
00:23:14,799 --> 00:23:16,149


727
00:23:16,149 --> 00:23:19,110

 

728
00:23:19,110 --> 00:23:21,190

 

729
00:23:21,190 --> 00:23:22,470

 

730
00:23:22,470 --> 00:23:24,870

 

731
00:23:24,870 --> 00:23:27,110

 

732
00:23:27,110 --> 00:23:29,669

 

733
00:23:29,669 --> 00:23:31,830

 

734
00:23:31,830 --> 00:23:34,070

 

735
00:23:34,070 --> 00:23:35,909

 

736
00:23:35,909 --> 00:23:35,919

 

737
00:23:35,919 --> 00:23:37,669


738
00:23:37,669 --> 00:23:39,750

 

739
00:23:39,750 --> 00:23:41,990

 

740
00:23:41,990 --> 00:23:44,549

 

741
00:23:44,549 --> 00:23:46,630

 

742
00:23:46,630 --> 00:23:49,029

 

743
00:23:49,029 --> 00:23:51,110

 

744
00:23:51,110 --> 00:23:52,470

 

745
00:23:52,470 --> 00:23:52,480

 

746
00:23:52,480 --> 00:23:53,510


747
00:23:53,510 --> 00:23:55,669

 

748
00:23:55,669 --> 00:23:58,149

 

749
00:23:58,149 --> 00:23:58,159

 

750
00:23:58,159 --> 00:24:01,029


751
00:24:01,029 --> 00:24:04,789

 

752
00:24:04,789 --> 00:24:08,710

 

753
00:24:08,710 --> 00:24:10,390

 

754
00:24:10,390 --> 00:24:11,830

 

755
00:24:11,830 --> 00:24:13,669

 

756
00:24:13,669 --> 00:24:13,679

 

757
00:24:13,679 --> 00:24:14,710


758
00:24:14,710 --> 00:24:15,990

 

759
00:24:15,990 --> 00:24:17,350

 

760
00:24:17,350 --> 00:24:20,310

 

761
00:24:20,310 --> 00:24:24,310

 

762
00:24:24,310 --> 00:24:26,070

 

763
00:24:26,070 --> 00:24:31,029

 

764
00:24:31,029 --> 00:24:32,950

 

765
00:24:32,950 --> 00:24:35,029

 

766
00:24:35,029 --> 00:24:35,039

 

767
00:24:35,039 --> 00:24:38,310


768
00:24:38,310 --> 00:24:38,320

 

769
00:24:38,320 --> 00:24:39,190


770
00:24:39,190 --> 00:24:41,990

 

771
00:24:41,990 --> 00:24:43,110

 

772
00:24:43,110 --> 00:24:46,310

 

773
00:24:46,310 --> 00:24:46,320

 

774
00:24:46,320 --> 00:24:47,190


775
00:24:47,190 --> 00:24:48,630

 

776
00:24:48,630 --> 00:24:48,640

 

777
00:24:48,640 --> 00:24:49,909


778
00:24:49,909 --> 00:24:52,950

 

779
00:24:52,950 --> 00:24:54,789

 

780
00:24:54,789 --> 00:24:57,190

 

781
00:24:57,190 --> 00:24:59,350

 

782
00:24:59,350 --> 00:25:00,870

 

783
00:25:00,870 --> 00:25:04,870

 

784
00:25:04,870 --> 00:25:04,880

 

785
00:25:04,880 --> 00:25:06,470


786
00:25:06,470 --> 00:25:07,990

 

787
00:25:07,990 --> 00:25:10,470

 

788
00:25:10,470 --> 00:25:12,630

 

789
00:25:12,630 --> 00:25:14,630

 

790
00:25:14,630 --> 00:25:17,110

 

791
00:25:17,110 --> 00:25:18,870

 

792
00:25:18,870 --> 00:25:20,950

 

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

 

794
00:25:20,960 --> 00:25:21,909


795
00:25:21,909 --> 00:25:24,230

 

796
00:25:24,230 --> 00:25:28,149

 

797
00:25:28,149 --> 00:25:29,830

 

798
00:25:29,830 --> 00:25:31,669

 

799
00:25:31,669 --> 00:25:34,710

 

800
00:25:34,710 --> 00:25:36,710

 

801
00:25:36,710 --> 00:25:39,110

 

802
00:25:39,110 --> 00:25:40,950

 

803
00:25:40,950 --> 00:25:42,390

 

804
00:25:42,390 --> 00:25:43,990

 

805
00:25:43,990 --> 00:25:45,990

 

806
00:25:45,990 --> 00:25:48,710

 

807
00:25:48,710 --> 00:25:50,310

 

808
00:25:50,310 --> 00:25:52,630

 

809
00:25:52,630 --> 00:25:54,310

 

810
00:25:54,310 --> 00:25:56,470

 

811
00:25:56,470 --> 00:25:57,909

 

812
00:25:57,909 --> 00:25:59,510

 

813
00:25:59,510 --> 00:25:59,520

 

814
00:25:59,520 --> 00:26:00,789


815
00:26:00,789 --> 00:26:00,799

 

816
00:26:00,799 --> 00:26:01,590


817
00:26:01,590 --> 00:26:03,190

 

818
00:26:03,190 --> 00:26:06,070

 

819
00:26:06,070 --> 00:26:08,310

 

820
00:26:08,310 --> 00:26:09,830

 

821
00:26:09,830 --> 00:26:11,510

 

822
00:26:11,510 --> 00:26:13,909

 

823
00:26:13,909 --> 00:26:15,350

 

824
00:26:15,350 --> 00:26:16,630

 

825
00:26:16,630 --> 00:26:18,710

 

826
00:26:18,710 --> 00:26:19,920

 

827
00:26:19,920 --> 00:26:19,930

 

828
00:26:19,930 --> 00:26:21,350


829
00:26:21,350 --> 00:26:23,029

 

830
00:26:23,029 --> 00:26:26,070

 

831
00:26:26,070 --> 00:26:29,190

 

832
00:26:29,190 --> 00:26:30,630

 

833
00:26:30,630 --> 00:26:33,029

 

834
00:26:33,029 --> 00:26:34,390

 

835
00:26:34,390 --> 00:26:36,470

 

836
00:26:36,470 --> 00:26:39,269

 

837
00:26:39,269 --> 00:26:41,110

 

838
00:26:41,110 --> 00:26:43,750

 

839
00:26:43,750 --> 00:26:46,070

 

840
00:26:46,070 --> 00:26:47,990

 

841
00:26:47,990 --> 00:26:48,000

 

842
00:26:48,000 --> 00:26:49,830


843
00:26:49,830 --> 00:26:52,710

 

844
00:26:52,710 --> 00:26:55,669

 

845
00:26:55,669 --> 00:26:57,269

 

846
00:26:57,269 --> 00:26:59,830

 

847
00:26:59,830 --> 00:27:02,310

 

848
00:27:02,310 --> 00:27:04,070

 

849
00:27:04,070 --> 00:27:07,029

 

850
00:27:07,029 --> 00:27:09,110

 

851
00:27:09,110 --> 00:27:11,350

 

852
00:27:11,350 --> 00:27:11,360

 

853
00:27:11,360 --> 00:27:12,549


854
00:27:12,549 --> 00:27:15,669

 

855
00:27:15,669 --> 00:27:17,029

 

856
00:27:17,029 --> 00:27:19,430

 

857
00:27:19,430 --> 00:27:20,950

 

858
00:27:20,950 --> 00:27:23,110

 

859
00:27:23,110 --> 00:27:24,950

 

860
00:27:24,950 --> 00:27:26,789

 

861
00:27:26,789 --> 00:27:27,750

 

862
00:27:27,750 --> 00:27:29,990

 

863
00:27:29,990 --> 00:27:31,590

 

864
00:27:31,590 --> 00:27:32,710

 

865
00:27:32,710 --> 00:27:35,830

 

866
00:27:35,830 --> 00:27:37,750

 

867
00:27:37,750 --> 00:27:40,230

 

868
00:27:40,230 --> 00:27:46,310

 

869
00:27:46,310 --> 00:27:48,470

 

870
00:27:48,470 --> 00:27:51,110

 

871
00:27:51,110 --> 00:27:53,909

 

872
00:27:53,909 --> 00:27:53,919

 

873
00:27:53,919 --> 00:27:55,190


874
00:27:55,190 --> 00:27:55,200

 

875
00:27:55,200 --> 00:27:56,389


876
00:27:56,389 --> 00:27:58,630

 

877
00:27:58,630 --> 00:27:58,640

 

878
00:27:58,640 --> 00:27:59,909


879
00:27:59,909 --> 00:28:02,710

 

880
00:28:02,710 --> 00:28:05,430

 

881
00:28:05,430 --> 00:28:08,310

 

882
00:28:08,310 --> 00:28:10,549

 

883
00:28:10,549 --> 00:28:13,750

 

884
00:28:13,750 --> 00:28:16,149

 

885
00:28:16,149 --> 00:28:18,070

 

886
00:28:18,070 --> 00:28:22,389

 

887
00:28:22,389 --> 00:28:22,399

 

888
00:28:22,399 --> 00:28:23,269


889
00:28:23,269 --> 00:28:24,789

 

890
00:28:24,789 --> 00:28:24,799

 

891
00:28:24,799 --> 00:28:26,630


892
00:28:26,630 --> 00:28:29,269

 

893
00:28:29,269 --> 00:28:31,750

 

894
00:28:31,750 --> 00:28:33,590

 

895
00:28:33,590 --> 00:28:35,269

 

896
00:28:35,269 --> 00:28:39,350

 

897
00:28:39,350 --> 00:28:41,669

 

898
00:28:41,669 --> 00:28:43,350

 

899
00:28:43,350 --> 00:28:45,110

 

900
00:28:45,110 --> 00:28:46,870

 

901
00:28:46,870 --> 00:28:49,830

 

902
00:28:49,830 --> 00:28:52,470

 

903
00:28:52,470 --> 00:28:56,070

 

904
00:28:56,070 --> 00:28:57,430

 

905
00:28:57,430 --> 00:28:57,440

 

906
00:28:57,440 --> 00:28:59,269


907
00:28:59,269 --> 00:29:00,789

 

908
00:29:00,789 --> 00:29:00,799

 

909
00:29:00,799 --> 00:29:01,750


910
00:29:01,750 --> 00:29:05,510

 

911
00:29:05,510 --> 00:29:06,710

 

912
00:29:06,710 --> 00:29:10,789

 

913
00:29:10,789 --> 00:29:13,590

 

914
00:29:13,590 --> 00:29:15,590

 

915
00:29:15,590 --> 00:29:17,669

 

916
00:29:17,669 --> 00:29:19,269

 

917
00:29:19,269 --> 00:29:20,710

 

918
00:29:20,710 --> 00:29:23,029

 

919
00:29:23,029 --> 00:29:25,830

 

920
00:29:25,830 --> 00:29:27,430

 

921
00:29:27,430 --> 00:29:28,630

 

922
00:29:28,630 --> 00:29:30,230

 

923
00:29:30,230 --> 00:29:32,470

 

924
00:29:32,470 --> 00:29:33,830

 

925
00:29:33,830 --> 00:29:35,350

 

926
00:29:35,350 --> 00:29:37,510

 

927
00:29:37,510 --> 00:29:39,430

 

928
00:29:39,430 --> 00:29:40,870

 

929
00:29:40,870 --> 00:29:43,350

 

930
00:29:43,350 --> 00:29:45,590

 

931
00:29:45,590 --> 00:29:45,600

 

932
00:29:45,600 --> 00:29:46,710


933
00:29:46,710 --> 00:29:48,789

 

934
00:29:48,789 --> 00:29:50,710

 

935
00:29:50,710 --> 00:29:52,310

 

936
00:29:52,310 --> 00:29:53,909

 

937
00:29:53,909 --> 00:29:56,230

 

938
00:29:56,230 --> 00:29:59,990

 

939
00:29:59,990 --> 00:30:04,310

 

940
00:30:04,310 --> 00:30:06,789

 

941
00:30:06,789 --> 00:30:09,029

 

942
00:30:09,029 --> 00:30:10,710

 

943
00:30:10,710 --> 00:30:12,389

 

944
00:30:12,389 --> 00:30:14,230

 

945
00:30:14,230 --> 00:30:14,240

 

946
00:30:14,240 --> 00:30:18,149


947
00:30:18,149 --> 00:30:19,830

 

948
00:30:19,830 --> 00:30:21,909

 

949
00:30:21,909 --> 00:30:23,269

 

950
00:30:23,269 --> 00:30:24,630

 

951
00:30:24,630 --> 00:30:26,470

 

952
00:30:26,470 --> 00:30:26,480

 

953
00:30:26,480 --> 00:30:27,830


954
00:30:27,830 --> 00:30:30,950

 

955
00:30:30,950 --> 00:30:33,430

 

956
00:30:33,430 --> 00:30:35,909

 

957
00:30:35,909 --> 00:30:37,990

 

958
00:30:37,990 --> 00:30:39,990

 

959
00:30:39,990 --> 00:30:43,029

 

960
00:30:43,029 --> 00:30:45,269

 

961
00:30:45,269 --> 00:30:47,350

 

962
00:30:47,350 --> 00:30:49,269

 

963
00:30:49,269 --> 00:30:51,110

 

964
00:30:51,110 --> 00:30:53,510

 

965
00:30:53,510 --> 00:30:56,470

 

966
00:30:56,470 --> 00:30:58,549

 

967
00:30:58,549 --> 00:31:01,509

 

968
00:31:01,509 --> 00:31:01,519

 

969
00:31:01,519 --> 00:31:02,310


970
00:31:02,310 --> 00:31:04,549

 

971
00:31:04,549 --> 00:31:04,559

 

972
00:31:04,559 --> 00:31:05,430


973
00:31:05,430 --> 00:31:05,440

 

974
00:31:05,440 --> 00:31:06,630


975
00:31:06,630 --> 00:31:08,230

 

976
00:31:08,230 --> 00:31:10,230

 

977
00:31:10,230 --> 00:31:11,590

 

978
00:31:11,590 --> 00:31:13,590

 

979
00:31:13,590 --> 00:31:15,430

 

980
00:31:15,430 --> 00:31:20,149

 

981
00:31:20,149 --> 00:31:21,430

 

982
00:31:21,430 --> 00:31:28,630

 

983
00:31:28,630 --> 00:31:31,669

 

984
00:31:31,669 --> 00:31:33,590

 

985
00:31:33,590 --> 00:31:35,029

 

986
00:31:35,029 --> 00:31:35,039

 

987
00:31:35,039 --> 00:31:35,990


988
00:31:35,990 --> 00:31:36,000

 

989
00:31:36,000 --> 00:31:36,789


990
00:31:36,789 --> 00:31:38,710

 

991
00:31:38,710 --> 00:31:38,720

 

992
00:31:38,720 --> 00:31:40,470


993
00:31:40,470 --> 00:31:43,110

 

994
00:31:43,110 --> 00:31:44,950

 

995
00:31:44,950 --> 00:31:46,710

 

996
00:31:46,710 --> 00:31:49,750

 

997
00:31:49,750 --> 00:31:52,070

 

998
00:31:52,070 --> 00:31:53,830

 

999
00:31:53,830 --> 00:31:53,840

 

1000
00:31:53,840 --> 00:31:55,990


1001
00:31:55,990 --> 00:31:58,549

 

1002
00:31:58,549 --> 00:31:58,559

 

1003
00:31:58,559 --> 00:32:00,310


1004
00:32:00,310 --> 00:32:00,320

 

1005
00:32:00,320 --> 00:32:02,070


1006
00:32:02,070 --> 00:32:03,430

 

1007
00:32:03,430 --> 00:32:06,630

 

1008
00:32:06,630 --> 00:32:06,640

 

1009
00:32:06,640 --> 00:32:09,509


1010
00:32:09,509 --> 00:32:09,519

 

1011
00:32:09,519 --> 00:32:10,549


1012
00:32:10,549 --> 00:32:12,310

 

1013
00:32:12,310 --> 00:32:13,909

 

1014
00:32:13,909 --> 00:32:15,990

 

1015
00:32:15,990 --> 00:32:19,669

 

1016
00:32:19,669 --> 00:32:21,029

 

1017
00:32:21,029 --> 00:32:22,870

 

1018
00:32:22,870 --> 00:32:22,880

 

1019
00:32:22,880 --> 00:32:23,990


1020
00:32:23,990 --> 00:32:26,310

 

1021
00:32:26,310 --> 00:32:28,789

 

1022
00:32:28,789 --> 00:32:31,590

 

1023
00:32:31,590 --> 00:32:31,600

 

1024
00:32:31,600 --> 00:32:32,549


1025
00:32:32,549 --> 00:32:35,190

 

1026
00:32:35,190 --> 00:32:35,200

 

1027
00:32:35,200 --> 00:32:36,310


1028
00:32:36,310 --> 00:32:37,750

 

1029
00:32:37,750 --> 00:32:39,190

 

1030
00:32:39,190 --> 00:32:40,950

 

1031
00:32:40,950 --> 00:32:42,789

 

1032
00:32:42,789 --> 00:32:45,990

 

1033
00:32:45,990 --> 00:32:49,190

 

1034
00:32:49,190 --> 00:32:50,870

 

1035
00:32:50,870 --> 00:32:52,630

 

1036
00:32:52,630 --> 00:32:53,590

 

1037
00:32:53,590 --> 00:32:54,870

 

1038
00:32:54,870 --> 00:32:56,549

 

1039
00:32:56,549 --> 00:32:58,630

 

1040
00:32:58,630 --> 00:33:00,549

 

1041
00:33:00,549 --> 00:33:03,029

 

1042
00:33:03,029 --> 00:33:05,669

 

1043
00:33:05,669 --> 00:33:07,190

 

1044
00:33:07,190 --> 00:33:09,029

 

1045
00:33:09,029 --> 00:33:09,039

 

1046
00:33:09,039 --> 00:33:13,430


1047
00:33:13,430 --> 00:33:13,440

 

1048
00:33:13,440 --> 00:33:15,750


1049
00:33:15,750 --> 00:33:15,760

 

1050
00:33:15,760 --> 00:33:16,789


1051
00:33:16,789 --> 00:33:18,389

 

1052
00:33:18,389 --> 00:33:19,909

 

1053
00:33:19,909 --> 00:33:22,310

 

1054
00:33:22,310 --> 00:33:23,669

 

1055
00:33:23,669 --> 00:33:25,990

 

1056
00:33:25,990 --> 00:33:28,549

 

1057
00:33:28,549 --> 00:33:30,070

 

1058
00:33:30,070 --> 00:33:32,310

 

1059
00:33:32,310 --> 00:33:35,990

 

1060
00:33:35,990 --> 00:33:38,710

 

1061
00:33:38,710 --> 00:33:40,149

 

1062
00:33:40,149 --> 00:33:42,470

 

1063
00:33:42,470 --> 00:33:44,310

 

1064
00:33:44,310 --> 00:33:46,310

 

1065
00:33:46,310 --> 00:33:48,470

 

1066
00:33:48,470 --> 00:33:50,389

 

1067
00:33:50,389 --> 00:33:53,110

 

1068
00:33:53,110 --> 00:33:56,149

 

1069
00:33:56,149 --> 00:33:57,430

 

1070
00:33:57,430 --> 00:34:00,070

 

1071
00:34:00,070 --> 00:34:01,669

 

1072
00:34:01,669 --> 00:34:04,830

 

1073
00:34:04,830 --> 00:34:06,870

 

1074
00:34:06,870 --> 00:34:09,109

 

1075
00:34:09,109 --> 00:34:09,119

 

1076
00:34:09,119 --> 00:34:10,230


1077
00:34:10,230 --> 00:34:12,629

 

1078
00:34:12,629 --> 00:34:15,030

 

1079
00:34:15,030 --> 00:34:17,270

 

1080
00:34:17,270 --> 00:34:19,430

 

1081
00:34:19,430 --> 00:34:21,909

 

1082
00:34:21,909 --> 00:34:24,830

 

1083
00:34:24,830 --> 00:34:24,840

 

1084
00:34:24,840 --> 00:34:26,710


1085
00:34:26,710 --> 00:34:26,720

 

1086
00:34:26,720 --> 00:34:27,510


1087
00:34:27,510 --> 00:34:27,520

 

1088
00:34:27,520 --> 00:34:30,869


1089
00:34:30,869 --> 00:34:33,829

 

1090
00:34:33,829 --> 00:34:33,839

 

1091
00:34:33,839 --> 00:34:36,389


1092
00:34:36,389 --> 00:34:38,790

 

1093
00:34:38,790 --> 00:34:40,470

 

1094
00:34:40,470 --> 00:34:42,550

 

1095
00:34:42,550 --> 00:34:45,669

 

1096
00:34:45,669 --> 00:34:47,349

 

1097
00:34:47,349 --> 00:34:50,470

 

1098
00:34:50,470 --> 00:34:52,230

 

1099
00:34:52,230 --> 00:34:54,869

 

1100
00:34:54,869 --> 00:34:56,149

 

1101
00:34:56,149 --> 00:34:56,159

 

1102
00:34:56,159 --> 00:34:57,670


1103
00:34:57,670 --> 00:34:57,680

 

1104
00:34:57,680 --> 00:34:59,030


1105
00:34:59,030 --> 00:35:02,550

 

1106
00:35:02,550 --> 00:35:04,069

 

1107
00:35:04,069 --> 00:35:06,069

 

1108
00:35:06,069 --> 00:35:08,550

 

1109
00:35:08,550 --> 00:35:11,030

 

1110
00:35:11,030 --> 00:35:13,510

 

1111
00:35:13,510 --> 00:35:15,109

 

1112
00:35:15,109 --> 00:35:17,270

 

1113
00:35:17,270 --> 00:35:20,069

 

1114
00:35:20,069 --> 00:35:20,079

 

1115
00:35:20,079 --> 00:35:21,990


1116
00:35:21,990 --> 00:35:25,270

 

1117
00:35:25,270 --> 00:35:27,670

 

1118
00:35:27,670 --> 00:35:29,910

 

1119
00:35:29,910 --> 00:35:31,910

 

1120
00:35:31,910 --> 00:35:35,190

 

1121
00:35:35,190 --> 00:35:37,190

 

1122
00:35:37,190 --> 00:35:39,829

 

1123
00:35:39,829 --> 00:35:41,510

 

1124
00:35:41,510 --> 00:35:43,349

 

1125
00:35:43,349 --> 00:35:46,790

 

1126
00:35:46,790 --> 00:35:48,470

 

1127
00:35:48,470 --> 00:35:50,470

 

1128
00:35:50,470 --> 00:35:50,480

 

1129
00:35:50,480 --> 00:35:51,349


1130
00:35:51,349 --> 00:35:51,359

 

1131
00:35:51,359 --> 00:35:52,310


1132
00:35:52,310 --> 00:35:52,320

 

1133
00:35:52,320 --> 00:35:53,349


1134
00:35:53,349 --> 00:35:55,670

 

1135
00:35:55,670 --> 00:35:55,680

 

1136
00:35:55,680 --> 00:35:57,349


1137
00:35:57,349 --> 00:35:59,510

 

1138
00:35:59,510 --> 00:36:01,109

 

1139
00:36:01,109 --> 00:36:02,870

 

1140
00:36:02,870 --> 00:36:04,069

 

1141
00:36:04,069 --> 00:36:05,910

 

1142
00:36:05,910 --> 00:36:08,550

 

1143
00:36:08,550 --> 00:36:12,069

 

1144
00:36:12,069 --> 00:36:14,870

 

1145
00:36:14,870 --> 00:36:16,310

 

1146
00:36:16,310 --> 00:36:17,670

 

1147
00:36:17,670 --> 00:36:21,349

 

1148
00:36:21,349 --> 00:36:23,910

 

1149
00:36:23,910 --> 00:36:26,630

 

1150
00:36:26,630 --> 00:36:26,640

 

1151
00:36:26,640 --> 00:36:27,430


1152
00:36:27,430 --> 00:36:28,790

 

1153
00:36:28,790 --> 00:36:30,150

 

1154
00:36:30,150 --> 00:36:32,710

 

1155
00:36:32,710 --> 00:36:34,790

 

1156
00:36:34,790 --> 00:36:36,630

 

1157
00:36:36,630 --> 00:36:37,990

 

1158
00:36:37,990 --> 00:36:40,630

 

1159
00:36:40,630 --> 00:36:42,310

 

1160
00:36:42,310 --> 00:36:42,320

 

1161
00:36:42,320 --> 00:36:44,950


1162
00:36:44,950 --> 00:36:46,950

 

1163
00:36:46,950 --> 00:36:49,349

 

1164
00:36:49,349 --> 00:36:49,359

 

1165
00:36:49,359 --> 00:36:50,790


1166
00:36:50,790 --> 00:36:54,230

 

1167
00:36:54,230 --> 00:36:56,310

 

1168
00:36:56,310 --> 00:36:59,030

 

1169
00:36:59,030 --> 00:36:59,040

 

1170
00:36:59,040 --> 00:36:59,910


1171
00:36:59,910 --> 00:37:02,150

 

1172
00:37:02,150 --> 00:37:05,109

 

1173
00:37:05,109 --> 00:37:08,550

 

1174
00:37:08,550 --> 00:37:12,870

 

1175
00:37:12,870 --> 00:37:14,470

 

1176
00:37:14,470 --> 00:37:15,829

 

1177
00:37:15,829 --> 00:37:17,829

 

1178
00:37:17,829 --> 00:37:17,839

 

1179
00:37:17,839 --> 00:37:19,349


1180
00:37:19,349 --> 00:37:19,359

 

1181
00:37:19,359 --> 00:37:20,390


1182
00:37:20,390 --> 00:37:21,910

 

1183
00:37:21,910 --> 00:37:24,230

 

1184
00:37:24,230 --> 00:37:24,240

 

1185
00:37:24,240 --> 00:37:25,430


1186
00:37:25,430 --> 00:37:27,829

 

1187
00:37:27,829 --> 00:37:31,190

 

1188
00:37:31,190 --> 00:37:33,270

 

1189
00:37:33,270 --> 00:37:35,030

 

1190
00:37:35,030 --> 00:37:37,670

 

1191
00:37:37,670 --> 00:37:39,349

 

1192
00:37:39,349 --> 00:37:43,190

 

1193
00:37:43,190 --> 00:37:44,790

 

1194
00:37:44,790 --> 00:37:46,310

 

1195
00:37:46,310 --> 00:37:48,950

 

1196
00:37:48,950 --> 00:37:51,349

 

1197
00:37:51,349 --> 00:37:52,950

 

1198
00:37:52,950 --> 00:37:55,990

 

1199
00:37:55,990 --> 00:37:57,910

 

1200
00:37:57,910 --> 00:37:57,920

 

1201
00:37:57,920 --> 00:37:59,829


1202
00:37:59,829 --> 00:38:02,310

 

1203
00:38:02,310 --> 00:38:04,390

 

1204
00:38:04,390 --> 00:38:07,030

 

1205
00:38:07,030 --> 00:38:09,670

 

1206
00:38:09,670 --> 00:38:09,680

 

1207
00:38:09,680 --> 00:38:11,270


1208
00:38:11,270 --> 00:38:13,430

 

1209
00:38:13,430 --> 00:38:16,550

 

1210
00:38:16,550 --> 00:38:19,190

 

1211
00:38:19,190 --> 00:38:22,150

 

1212
00:38:22,150 --> 00:38:24,710

 

1213
00:38:24,710 --> 00:38:26,870

 

1214
00:38:26,870 --> 00:38:29,349

 

1215
00:38:29,349 --> 00:38:31,990

 

1216
00:38:31,990 --> 00:38:34,630

 

1217
00:38:34,630 --> 00:38:37,109

 

1218
00:38:37,109 --> 00:38:39,349

 

1219
00:38:39,349 --> 00:38:39,359

 

1220
00:38:39,359 --> 00:38:41,030


1221
00:38:41,030 --> 00:38:42,550

 

1222
00:38:42,550 --> 00:38:43,910

 

1223
00:38:43,910 --> 00:38:46,310

 

1224
00:38:46,310 --> 00:38:49,349

 

1225
00:38:49,349 --> 00:38:51,109

 

1226
00:38:51,109 --> 00:38:54,310

 

1227
00:38:54,310 --> 00:38:56,870

 

1228
00:38:56,870 --> 00:38:59,510

 

1229
00:38:59,510 --> 00:39:01,829

 

1230
00:39:01,829 --> 00:39:03,910

 

1231
00:39:03,910 --> 00:39:06,230

 

1232
00:39:06,230 --> 00:39:06,240

 

1233
00:39:06,240 --> 00:39:07,270


1234
00:39:07,270 --> 00:39:08,950

 

1235
00:39:08,950 --> 00:39:10,870

 

1236
00:39:10,870 --> 00:39:12,470

 

1237
00:39:12,470 --> 00:39:15,910

 

1238
00:39:15,910 --> 00:39:15,920

 

1239
00:39:15,920 --> 00:39:17,190


1240
00:39:17,190 --> 00:39:21,190

 

1241
00:39:21,190 --> 00:39:21,200

 

1242
00:39:21,200 --> 00:39:22,950


1243
00:39:22,950 --> 00:39:25,670

 

1244
00:39:25,670 --> 00:39:26,950

 

1245
00:39:26,950 --> 00:39:29,589

 

1246
00:39:29,589 --> 00:39:32,150

 

1247
00:39:32,150 --> 00:39:34,390

 

1248
00:39:34,390 --> 00:39:36,310

 

1249
00:39:36,310 --> 00:39:38,550

 

1250
00:39:38,550 --> 00:39:41,589

 

1251
00:39:41,589 --> 00:39:41,599

 

1252
00:39:41,599 --> 00:39:43,829


1253
00:39:43,829 --> 00:39:45,990

 

1254
00:39:45,990 --> 00:39:48,950

 

1255
00:39:48,950 --> 00:39:51,589

 

1256
00:39:51,589 --> 00:39:53,750

 

1257
00:39:53,750 --> 00:39:53,760

 

1258
00:39:53,760 --> 00:39:57,990


1259
00:39:57,990 --> 00:40:06,630

 

1260
00:40:06,630 --> 00:40:06,640

 

1261
00:40:06,640 --> 00:40:07,589


1262
00:40:07,589 --> 00:40:09,589

 

1263
00:40:09,589 --> 00:40:17,190

 

1264
00:40:17,190 --> 00:40:19,190

 

1265
00:40:19,190 --> 00:40:21,270

 

1266
00:40:21,270 --> 00:40:21,280

 

1267
00:40:21,280 --> 00:40:22,390


1268
00:40:22,390 --> 00:40:24,390

 

1269
00:40:24,390 --> 00:40:26,630

 

1270
00:40:26,630 --> 00:40:28,069

 

1271
00:40:28,069 --> 00:40:30,470

 

1272
00:40:30,470 --> 00:40:30,480

 

1273
00:40:30,480 --> 00:40:31,670


1274
00:40:31,670 --> 00:40:33,910

 

1275
00:40:33,910 --> 00:40:35,910

 

1276
00:40:35,910 --> 00:40:39,349

 

1277
00:40:39,349 --> 00:40:45,829

 

1278
00:40:45,829 --> 00:40:47,349

 

1279
00:40:47,349 --> 00:40:49,349

 

1280
00:40:49,349 --> 00:40:51,190

 

1281
00:40:51,190 --> 00:40:53,670

 

1282
00:40:53,670 --> 00:40:55,510

 

1283
00:40:55,510 --> 00:40:59,510

 

1284
00:40:59,510 --> 00:41:01,190

 

1285
00:41:01,190 --> 00:41:02,630

 

1286
00:41:02,630 --> 00:41:04,230

 

1287
00:41:04,230 --> 00:41:06,950

 

1288
00:41:06,950 --> 00:41:09,270

 

1289
00:41:09,270 --> 00:41:11,190

 

1290
00:41:11,190 --> 00:41:12,630

 

1291
00:41:12,630 --> 00:41:14,550

 

1292
00:41:14,550 --> 00:41:16,309

 

1293
00:41:16,309 --> 00:41:18,630

 

1294
00:41:18,630 --> 00:41:21,349

 

1295
00:41:21,349 --> 00:41:21,359

 

1296
00:41:21,359 --> 00:41:22,390


1297
00:41:22,390 --> 00:41:22,400

 

1298
00:41:22,400 --> 00:41:23,190


1299
00:41:23,190 --> 00:41:25,190

 

1300
00:41:25,190 --> 00:41:27,910

 

1301
00:41:27,910 --> 00:41:29,430

 

1302
00:41:29,430 --> 00:41:31,190

 

1303
00:41:31,190 --> 00:41:33,190

 

1304
00:41:33,190 --> 00:41:34,870

 

1305
00:41:34,870 --> 00:41:36,630

 

1306
00:41:36,630 --> 00:41:38,550

 

1307
00:41:38,550 --> 00:41:40,390

 

1308
00:41:40,390 --> 00:41:42,710

 

1309
00:41:42,710 --> 00:41:42,720

 

1310
00:41:42,720 --> 00:41:43,750


1311
00:41:43,750 --> 00:41:45,109

 

1312
00:41:45,109 --> 00:41:47,270

 

1313
00:41:47,270 --> 00:41:49,670

 

1314
00:41:49,670 --> 00:41:51,910

 

1315
00:41:51,910 --> 00:41:53,589

 

1316
00:41:53,589 --> 00:41:55,030

 

1317
00:41:55,030 --> 00:41:56,790

 

1318
00:41:56,790 --> 00:41:59,109

 

1319
00:41:59,109 --> 00:42:01,030

 

1320
00:42:01,030 --> 00:42:01,040

 

1321
00:42:01,040 --> 00:42:02,470


1322
00:42:02,470 --> 00:42:04,150

 

1323
00:42:04,150 --> 00:42:06,390

 

1324
00:42:06,390 --> 00:42:08,870

 

1325
00:42:08,870 --> 00:42:12,230

 

1326
00:42:12,230 --> 00:42:14,470

 

1327
00:42:14,470 --> 00:42:16,630

 

1328
00:42:16,630 --> 00:42:18,630

 

1329
00:42:18,630 --> 00:42:19,829

 

1330
00:42:19,829 --> 00:42:21,270

 

1331
00:42:21,270 --> 00:42:22,710

 

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

 

1333
00:42:22,720 --> 00:42:23,910


1334
00:42:23,910 --> 00:42:25,270

 

1335
00:42:25,270 --> 00:42:27,030

 

1336
00:42:27,030 --> 00:42:28,230

 

1337
00:42:28,230 --> 00:42:31,589

 

1338
00:42:31,589 --> 00:42:34,150

 

1339
00:42:34,150 --> 00:42:36,069

 

1340
00:42:36,069 --> 00:42:38,150

 

1341
00:42:38,150 --> 00:42:40,150

 

1342
00:42:40,150 --> 00:42:41,510

 

1343
00:42:41,510 --> 00:42:43,670

 

1344
00:42:43,670 --> 00:42:45,349

 

1345
00:42:45,349 --> 00:42:48,950

 

1346
00:42:48,950 --> 00:42:50,710

 

1347
00:42:50,710 --> 00:42:53,990

 

1348
00:42:53,990 --> 00:42:56,309

 

1349
00:42:56,309 --> 00:42:58,870

 

1350
00:42:58,870 --> 00:43:01,270

 

1351
00:43:01,270 --> 00:43:04,150

 

1352
00:43:04,150 --> 00:43:05,030

 

1353
00:43:05,030 --> 00:43:06,790

 

1354
00:43:06,790 --> 00:43:08,950

 

1355
00:43:08,950 --> 00:43:11,349

 

1356
00:43:11,349 --> 00:43:14,230

 

1357
00:43:14,230 --> 00:43:16,790

 

1358
00:43:16,790 --> 00:43:19,670

 

1359
00:43:19,670 --> 00:43:21,349

 

1360
00:43:21,349 --> 00:43:22,630

 

1361
00:43:22,630 --> 00:43:24,150

 

1362
00:43:24,150 --> 00:43:25,589

 

1363
00:43:25,589 --> 00:43:27,190

 

1364
00:43:27,190 --> 00:43:28,550

 

1365
00:43:28,550 --> 00:43:30,230

 

1366
00:43:30,230 --> 00:43:32,710

 

1367
00:43:32,710 --> 00:43:34,630

 

1368
00:43:34,630 --> 00:43:34,640

 

1369
00:43:34,640 --> 00:43:36,550


1370
00:43:36,550 --> 00:43:38,069

 

1371
00:43:38,069 --> 00:43:38,079

 

1372
00:43:38,079 --> 00:43:39,030


1373
00:43:39,030 --> 00:43:41,589

 

1374
00:43:41,589 --> 00:43:43,030

 

1375
00:43:43,030 --> 00:43:44,470

 

1376
00:43:44,470 --> 00:43:45,910

 

1377
00:43:45,910 --> 00:43:45,920

 

1378
00:43:45,920 --> 00:43:47,349


1379
00:43:47,349 --> 00:43:47,359

 

1380
00:43:47,359 --> 00:43:48,630


1381
00:43:48,630 --> 00:43:48,640

 

1382
00:43:48,640 --> 00:43:49,750


1383
00:43:49,750 --> 00:43:52,829

 

1384
00:43:52,829 --> 00:43:52,839

 

1385
00:43:52,839 --> 00:43:54,550


1386
00:43:54,550 --> 00:43:56,390

 

1387
00:43:56,390 --> 00:43:57,829

 

1388
00:43:57,829 --> 00:44:00,630

 

1389
00:44:00,630 --> 00:44:00,640

 

1390
00:44:00,640 --> 00:44:01,510


1391
00:44:01,510 --> 00:44:05,270

 

1392
00:44:05,270 --> 00:44:05,280

 

1393
00:44:05,280 --> 00:44:06,950


1394
00:44:06,950 --> 00:44:09,829

 

1395
00:44:09,829 --> 00:44:12,710

 

1396
00:44:12,710 --> 00:44:15,349

 

1397
00:44:15,349 --> 00:44:18,309

 

1398
00:44:18,309 --> 00:44:19,670

 

1399
00:44:19,670 --> 00:44:22,710

 

1400
00:44:22,710 --> 00:44:25,990

 

1401
00:44:25,990 --> 00:44:27,430

 

1402
00:44:27,430 --> 00:44:29,430

 

1403
00:44:29,430 --> 00:44:31,589

 

1404
00:44:31,589 --> 00:44:33,670

 

1405
00:44:33,670 --> 00:44:33,680

 

1406
00:44:33,680 --> 00:44:34,630


1407
00:44:34,630 --> 00:44:36,710

 

1408
00:44:36,710 --> 00:44:36,720

 

1409
00:44:36,720 --> 00:44:38,069


1410
00:44:38,069 --> 00:44:40,069

 

1411
00:44:40,069 --> 00:44:41,750

 

1412
00:44:41,750 --> 00:44:41,760

 

1413
00:44:41,760 --> 00:44:42,870


1414
00:44:42,870 --> 00:44:44,470

 

1415
00:44:44,470 --> 00:44:46,550

 

1416
00:44:46,550 --> 00:44:49,349

 

1417
00:44:49,349 --> 00:44:49,359

 

1418
00:44:49,359 --> 00:44:50,630


1419
00:44:50,630 --> 00:44:53,430

 

1420
00:44:53,430 --> 00:44:53,440

 

1421
00:44:53,440 --> 00:44:55,510


1422
00:44:55,510 --> 00:44:55,520

 

1423
00:44:55,520 --> 00:44:56,550


1424
00:44:56,550 --> 00:44:57,910

 

1425
00:44:57,910 --> 00:45:01,990

 

1426
00:45:01,990 --> 00:45:04,390

 

1427
00:45:04,390 --> 00:45:06,550

 

1428
00:45:06,550 --> 00:45:06,560

 

1429
00:45:06,560 --> 00:45:07,510


1430
00:45:07,510 --> 00:45:09,109

 

1431
00:45:09,109 --> 00:45:11,030

 

1432
00:45:11,030 --> 00:45:11,040

 

1433
00:45:11,040 --> 00:45:12,309


1434
00:45:12,309 --> 00:45:13,910

 

1435
00:45:13,910 --> 00:45:15,190

 

1436
00:45:15,190 --> 00:45:16,790

 

1437
00:45:16,790 --> 00:45:18,630

 

1438
00:45:18,630 --> 00:45:20,230

 

1439
00:45:20,230 --> 00:45:20,240

 

1440
00:45:20,240 --> 00:45:21,589


1441
00:45:21,589 --> 00:45:23,030

 

1442
00:45:23,030 --> 00:45:24,950

 

1443
00:45:24,950 --> 00:45:26,870

 

1444
00:45:26,870 --> 00:45:27,910

 

1445
00:45:27,910 --> 00:45:29,750

 

1446
00:45:29,750 --> 00:45:31,670

 

1447
00:45:31,670 --> 00:45:33,270

 

1448
00:45:33,270 --> 00:45:34,950

 

1449
00:45:34,950 --> 00:45:34,960

 

1450
00:45:34,960 --> 00:45:36,870


1451
00:45:36,870 --> 00:45:39,589

 

1452
00:45:39,589 --> 00:45:41,430

 

1453
00:45:41,430 --> 00:45:44,230

 

1454
00:45:44,230 --> 00:45:46,069

 

1455
00:45:46,069 --> 00:45:48,390

 

1456
00:45:48,390 --> 00:45:49,990

 

1457
00:45:49,990 --> 00:45:52,069

 

1458
00:45:52,069 --> 00:45:53,589

 

1459
00:45:53,589 --> 00:45:55,349

 

1460
00:45:55,349 --> 00:45:56,950

 

1461
00:45:56,950 --> 00:45:56,960

 

1462
00:45:56,960 --> 00:45:59,430


1463
00:45:59,430 --> 00:46:00,950

 

1464
00:46:00,950 --> 00:46:03,349

 

1465
00:46:03,349 --> 00:46:05,589

 

1466
00:46:05,589 --> 00:46:08,150

 

1467
00:46:08,150 --> 00:46:10,150

 

1468
00:46:10,150 --> 00:46:12,069

 

1469
00:46:12,069 --> 00:46:12,079

 

1470
00:46:12,079 --> 00:46:14,710


1471
00:46:14,710 --> 00:46:16,470

 

1472
00:46:16,470 --> 00:46:18,950

 

1473
00:46:18,950 --> 00:46:20,870

 

1474
00:46:20,870 --> 00:46:22,870

 

1475
00:46:22,870 --> 00:46:24,630

 

1476
00:46:24,630 --> 00:46:26,870

 

1477
00:46:26,870 --> 00:46:30,710

 

1478
00:46:30,710 --> 00:46:32,870

 

1479
00:46:32,870 --> 00:46:34,309

 

1480
00:46:34,309 --> 00:46:36,230

 

1481
00:46:36,230 --> 00:46:39,510

 

1482
00:46:39,510 --> 00:46:43,190

 

1483
00:46:43,190 --> 00:46:43,200

 

1484
00:46:43,200 --> 00:46:44,630


1485
00:46:44,630 --> 00:46:44,640

 

1486
00:46:44,640 --> 00:46:46,870


1487
00:46:46,870 --> 00:46:49,190

 

1488
00:46:49,190 --> 00:46:50,870

 

1489
00:46:50,870 --> 00:46:52,309

 

1490
00:46:52,309 --> 00:46:54,470

 

1491
00:46:54,470 --> 00:46:56,470

 

1492
00:46:56,470 --> 00:46:59,589

 

1493
00:46:59,589 --> 00:46:59,599

 

1494
00:46:59,599 --> 00:47:02,390


1495
00:47:02,390 --> 00:47:03,510

 

1496
00:47:03,510 --> 00:47:05,109

 

1497
00:47:05,109 --> 00:47:05,119

 

1498
00:47:05,119 --> 00:47:07,510


1499
00:47:07,510 --> 00:47:07,520

 

1500
00:47:07,520 --> 00:47:08,870


1501
00:47:08,870 --> 00:47:11,030

 

1502
00:47:11,030 --> 00:47:11,040

 

1503
00:47:11,040 --> 00:47:12,069


1504
00:47:12,069 --> 00:47:14,790

 

1505
00:47:14,790 --> 00:47:16,230

 

1506
00:47:16,230 --> 00:47:16,240

 

1507
00:47:16,240 --> 00:47:17,270


1508
00:47:17,270 --> 00:47:17,280

 

1509
00:47:17,280 --> 00:47:18,390


1510
00:47:18,390 --> 00:47:19,750

 

1511
00:47:19,750 --> 00:47:21,190

 

1512
00:47:21,190 --> 00:47:21,200

 

1513
00:47:21,200 --> 00:47:22,829


1514
00:47:22,829 --> 00:47:26,150

 

1515
00:47:26,150 --> 00:47:27,510

 

1516
00:47:27,510 --> 00:47:30,309

 

1517
00:47:30,309 --> 00:47:31,990

 

1518
00:47:31,990 --> 00:47:33,349

 

1519
00:47:33,349 --> 00:47:34,790

 

1520
00:47:34,790 --> 00:47:37,349

 

1521
00:47:37,349 --> 00:47:39,190

 

1522
00:47:39,190 --> 00:47:41,190

 

1523
00:47:41,190 --> 00:47:43,750

 

1524
00:47:43,750 --> 00:47:45,910

 

1525
00:47:45,910 --> 00:47:45,920

 

1526
00:47:45,920 --> 00:47:47,750


1527
00:47:47,750 --> 00:47:50,790

 

1528
00:47:50,790 --> 00:47:52,950

 

1529
00:47:52,950 --> 00:47:54,870

 

1530
00:47:54,870 --> 00:47:56,549

 

1531
00:47:56,549 --> 00:47:57,589

 

1532
00:47:57,589 --> 00:47:58,950

 

1533
00:47:58,950 --> 00:48:00,470

 

1534
00:48:00,470 --> 00:48:04,069

 

1535
00:48:04,069 --> 00:48:05,589

 

1536
00:48:05,589 --> 00:48:07,829

 

1537
00:48:07,829 --> 00:48:09,589

 

1538
00:48:09,589 --> 00:48:11,190

 

1539
00:48:11,190 --> 00:48:13,190

 

1540
00:48:13,190 --> 00:48:15,109

 

1541
00:48:15,109 --> 00:48:17,349

 

1542
00:48:17,349 --> 00:48:23,349

 

1543
00:48:23,349 --> 00:48:23,359

 

1544
00:48:23,359 --> 00:48:29,670


1545
00:48:29,670 --> 00:48:32,309

 

1546
00:48:32,309 --> 00:48:34,069

 

1547
00:48:34,069 --> 00:48:36,309

 

1548
00:48:36,309 --> 00:48:38,230

 

1549
00:48:38,230 --> 00:48:38,240

 

1550
00:48:38,240 --> 00:48:39,030


1551
00:48:39,030 --> 00:48:41,349

 

1552
00:48:41,349 --> 00:48:43,030

 

1553
00:48:43,030 --> 00:48:45,750

 

1554
00:48:45,750 --> 00:48:47,190

 

1555
00:48:47,190 --> 00:48:49,270

 

1556
00:48:49,270 --> 00:48:51,430

 

1557
00:48:51,430 --> 00:48:52,870

 

1558
00:48:52,870 --> 00:48:54,230

 

1559
00:48:54,230 --> 00:48:55,829

 

1560
00:48:55,829 --> 00:48:57,589

 

1561
00:48:57,589 --> 00:49:00,069

 

1562
00:49:00,069 --> 00:49:01,990

 

1563
00:49:01,990 --> 00:49:04,150

 

1564
00:49:04,150 --> 00:49:07,750

 

1565
00:49:07,750 --> 00:49:09,990

 

1566
00:49:09,990 --> 00:49:12,309

 

1567
00:49:12,309 --> 00:49:13,670

 

1568
00:49:13,670 --> 00:49:16,230

 

1569
00:49:16,230 --> 00:49:17,270

 

1570
00:49:17,270 --> 00:49:19,109

 

1571
00:49:19,109 --> 00:49:21,190

 

1572
00:49:21,190 --> 00:49:23,190

 

1573
00:49:23,190 --> 00:49:25,190

 

1574
00:49:25,190 --> 00:49:26,069

 

1575
00:49:26,069 --> 00:49:27,750

 

1576
00:49:27,750 --> 00:49:29,670

 

1577
00:49:29,670 --> 00:49:31,589

 

1578
00:49:31,589 --> 00:49:31,599

 

1579
00:49:31,599 --> 00:49:33,829


1580
00:49:33,829 --> 00:49:35,670

 

1581
00:49:35,670 --> 00:49:36,870

 

1582
00:49:36,870 --> 00:49:39,109

 

1583
00:49:39,109 --> 00:49:41,430

 

1584
00:49:41,430 --> 00:49:43,349

 

1585
00:49:43,349 --> 00:49:46,069

 

1586
00:49:46,069 --> 00:49:47,990

 

1587
00:49:47,990 --> 00:49:50,309

 

1588
00:49:50,309 --> 00:49:52,230

 

1589
00:49:52,230 --> 00:49:53,270

 

1590
00:49:53,270 --> 00:49:54,549

 

1591
00:49:54,549 --> 00:49:55,910

 

1592
00:49:55,910 --> 00:49:57,829

 

1593
00:49:57,829 --> 00:49:59,430

 

1594
00:49:59,430 --> 00:50:01,109

 

1595
00:50:01,109 --> 00:50:03,430

 

1596
00:50:03,430 --> 00:50:07,349

 

1597
00:50:07,349 --> 00:50:09,829

 

1598
00:50:09,829 --> 00:50:09,839

 

1599
00:50:09,839 --> 00:50:12,150


1600
00:50:12,150 --> 00:50:13,750

 

1601
00:50:13,750 --> 00:50:16,630

 

1602
00:50:16,630 --> 00:50:18,630

 

1603
00:50:18,630 --> 00:50:20,150

 

1604
00:50:20,150 --> 00:50:21,670

 

1605
00:50:21,670 --> 00:50:23,750

 

1606
00:50:23,750 --> 00:50:23,760

 

1607
00:50:23,760 --> 00:50:24,950


1608
00:50:24,950 --> 00:50:26,549

 

1609
00:50:26,549 --> 00:50:28,309

 

1610
00:50:28,309 --> 00:50:30,309

 

1611
00:50:30,309 --> 00:50:31,829

 

1612
00:50:31,829 --> 00:50:33,589

 

1613
00:50:33,589 --> 00:50:38,309

 

1614
00:50:38,309 --> 00:50:38,319

 

1615
00:50:38,319 --> 00:50:39,430


1616
00:50:39,430 --> 00:50:39,440

 

1617
00:50:39,440 --> 00:50:41,750


1618
00:50:41,750 --> 00:50:41,760

 

1619
00:50:41,760 --> 00:50:43,349


1620
00:50:43,349 --> 00:50:46,230

 

1621
00:50:46,230 --> 00:50:48,390

 

1622
00:50:48,390 --> 00:50:50,790

 

1623
00:50:50,790 --> 00:50:52,150

 

1624
00:50:52,150 --> 00:50:53,990

 

1625
00:50:53,990 --> 00:50:55,910

 

1626
00:50:55,910 --> 00:50:57,910

 

1627
00:50:57,910 --> 00:50:59,910

 

1628
00:50:59,910 --> 00:51:02,790

 

1629
00:51:02,790 --> 00:51:05,030

 

1630
00:51:05,030 --> 00:51:05,040

 

1631
00:51:05,040 --> 00:51:06,710


1632
00:51:06,710 --> 00:51:08,390

 

1633
00:51:08,390 --> 00:51:10,790

 

1634
00:51:10,790 --> 00:51:13,430

 

1635
00:51:13,430 --> 00:51:13,440

 

1636
00:51:13,440 --> 00:51:18,630


1637
00:51:18,630 --> 00:51:20,870

 

1638
00:51:20,870 --> 00:51:23,109

 

1639
00:51:23,109 --> 00:51:25,270

 

1640
00:51:25,270 --> 00:51:29,190

 

1641
00:51:29,190 --> 00:51:29,200

 

1642
00:51:29,200 --> 00:51:32,470


1643
00:51:32,470 --> 00:51:33,510

 

1644
00:51:33,510 --> 00:51:35,109

 

1645
00:51:35,109 --> 00:51:36,870

 

1646
00:51:36,870 --> 00:51:38,870

 

1647
00:51:38,870 --> 00:51:40,790

 

1648
00:51:40,790 --> 00:51:41,750

 

1649
00:51:41,750 --> 00:51:41,760

 

1650
00:51:41,760 --> 00:51:43,030


1651
00:51:43,030 --> 00:51:44,470

 

1652
00:51:44,470 --> 00:51:46,150

 

1653
00:51:46,150 --> 00:51:49,510

 

1654
00:51:49,510 --> 00:51:53,349

 

1655
00:51:53,349 --> 00:51:55,430

 

1656
00:51:55,430 --> 00:51:57,030

 

1657
00:51:57,030 --> 00:51:58,950

 

1658
00:51:58,950 --> 00:52:00,230

 

1659
00:52:00,230 --> 00:52:02,470

 

1660
00:52:02,470 --> 00:52:03,670

 

1661
00:52:03,670 --> 00:52:03,680

 

1662
00:52:03,680 --> 00:52:04,390


1663
00:52:04,390 --> 00:52:06,870

 

1664
00:52:06,870 --> 00:52:08,309

 

1665
00:52:08,309 --> 00:52:11,030

 

1666
00:52:11,030 --> 00:52:12,790

 

1667
00:52:12,790 --> 00:52:15,030

 

1668
00:52:15,030 --> 00:52:16,549

 

1669
00:52:16,549 --> 00:52:19,349

 

1670
00:52:19,349 --> 00:52:20,549

 

1671
00:52:20,549 --> 00:52:22,790

 

1672
00:52:22,790 --> 00:52:24,950

 

1673
00:52:24,950 --> 00:52:28,470

 

1674
00:52:28,470 --> 00:52:30,549

 

1675
00:52:30,549 --> 00:52:31,990

 

1676
00:52:31,990 --> 00:52:34,549

 

1677
00:52:34,549 --> 00:52:36,630

 

1678
00:52:36,630 --> 00:52:36,640

 

1679
00:52:36,640 --> 00:52:37,910


1680
00:52:37,910 --> 00:52:39,829

 

1681
00:52:39,829 --> 00:52:41,510

 

1682
00:52:41,510 --> 00:52:43,670

 

1683
00:52:43,670 --> 00:52:47,510

 

1684
00:52:47,510 --> 00:52:49,510

 

1685
00:52:49,510 --> 00:52:51,270

 

1686
00:52:51,270 --> 00:52:52,549

 

1687
00:52:52,549 --> 00:52:56,790

 

1688
00:52:56,790 --> 00:53:01,270

 

1689
00:53:01,270 --> 00:53:02,309

 

1690
00:53:02,309 --> 00:53:05,910

 

1691
00:53:05,910 --> 00:53:05,920

 

1692
00:53:05,920 --> 00:53:07,030


1693
00:53:07,030 --> 00:53:12,390

 

1694
00:53:12,390 --> 00:53:14,150

 

1695
00:53:14,150 --> 00:53:14,160

 

1696
00:53:14,160 --> 00:53:15,589


1697
00:53:15,589 --> 00:53:17,510

 

1698
00:53:17,510 --> 00:53:19,190

 

1699
00:53:19,190 --> 00:53:20,870

 

1700
00:53:20,870 --> 00:53:20,880

 

1701
00:53:20,880 --> 00:53:21,829


1702
00:53:21,829 --> 00:53:21,839

 

1703
00:53:21,839 --> 00:53:24,390


1704
00:53:24,390 --> 00:53:25,910

 

1705
00:53:25,910 --> 00:53:25,920

 

1706
00:53:25,920 --> 00:53:27,030


1707
00:53:27,030 --> 00:53:30,710

 

1708
00:53:30,710 --> 00:53:33,030

 

1709
00:53:33,030 --> 00:53:34,630

 

1710
00:53:34,630 --> 00:53:37,349

 

1711
00:53:37,349 --> 00:53:40,230

 

1712
00:53:40,230 --> 00:53:42,790

 

1713
00:53:42,790 --> 00:53:44,470

 

1714
00:53:44,470 --> 00:53:46,390

 

1715
00:53:46,390 --> 00:53:48,549

 

1716
00:53:48,549 --> 00:53:51,270

 

1717
00:53:51,270 --> 00:53:52,870

 

1718
00:53:52,870 --> 00:53:55,670

 

1719
00:53:55,670 --> 00:53:58,390

 

1720
00:53:58,390 --> 00:54:01,109

 

1721
00:54:01,109 --> 00:54:03,670

 

1722
00:54:03,670 --> 00:54:05,910

 

1723
00:54:05,910 --> 00:54:05,920

 

1724
00:54:05,920 --> 00:54:09,270


1725
00:54:09,270 --> 00:54:11,829

 

1726
00:54:11,829 --> 00:54:11,839

 

1727
00:54:11,839 --> 00:54:13,030


1728
00:54:13,030 --> 00:54:15,270

 

1729
00:54:15,270 --> 00:54:16,549

 

1730
00:54:16,549 --> 00:54:17,829

 

1731
00:54:17,829 --> 00:54:17,839

 

1732
00:54:17,839 --> 00:54:22,470


1733
00:54:22,470 --> 00:54:25,589

 

1734
00:54:25,589 --> 00:54:27,990

 

1735
00:54:27,990 --> 00:54:28,000

 

1736
00:54:28,000 --> 00:54:29,109


1737
00:54:29,109 --> 00:54:30,549

 

1738
00:54:30,549 --> 00:54:31,750

 

1739
00:54:31,750 --> 00:54:33,430

 

1740
00:54:33,430 --> 00:54:34,950

 

1741
00:54:34,950 --> 00:54:36,470

 

1742
00:54:36,470 --> 00:54:39,750

 

1743
00:54:39,750 --> 00:54:42,789

 

1744
00:54:42,789 --> 00:54:44,230

 

1745
00:54:44,230 --> 00:54:47,109

 

1746
00:54:47,109 --> 00:54:49,430

 

1747
00:54:49,430 --> 00:54:51,750

 

1748
00:54:51,750 --> 00:54:53,190

 

1749
00:54:53,190 --> 00:54:53,200

 

1750
00:54:53,200 --> 00:54:56,549


1751
00:54:56,549 --> 00:54:56,559

 

1752
00:54:56,559 --> 00:54:58,230


1753
00:54:58,230 --> 00:54:59,990

 

1754
00:54:59,990 --> 00:55:01,430

 

1755
00:55:01,430 --> 00:55:04,390

 

1756
00:55:04,390 --> 00:55:06,710

 

1757
00:55:06,710 --> 00:55:08,710

 

1758
00:55:08,710 --> 00:55:11,670

 

1759
00:55:11,670 --> 00:55:15,270

 

1760
00:55:15,270 --> 00:55:16,630

 

1761
00:55:16,630 --> 00:55:18,789

 

1762
00:55:18,789 --> 00:55:20,710

 

1763
00:55:20,710 --> 00:55:22,789

 

1764
00:55:22,789 --> 00:55:24,950

 

1765
00:55:24,950 --> 00:55:27,190

 

1766
00:55:27,190 --> 00:55:28,630

 

1767
00:55:28,630 --> 00:55:29,910

 

1768
00:55:29,910 --> 00:55:33,109

 

1769
00:55:33,109 --> 00:55:34,710

 

1770
00:55:34,710 --> 00:55:36,710

 

1771
00:55:36,710 --> 00:55:38,069

 

1772
00:55:38,069 --> 00:55:39,829

 

1773
00:55:39,829 --> 00:55:41,750

 

1774
00:55:41,750 --> 00:55:43,270

 

1775
00:55:43,270 --> 00:55:45,510

 

1776
00:55:45,510 --> 00:55:45,520

 

1777
00:55:45,520 --> 00:55:47,829


1778
00:55:47,829 --> 00:55:49,829

 

1779
00:55:49,829 --> 00:55:52,150

 

1780
00:55:52,150 --> 00:55:52,160

 

1781
00:55:52,160 --> 00:55:53,109


1782
00:55:53,109 --> 00:55:59,990

 

1783
00:55:59,990 --> 00:56:00,000

 

1784
00:56:00,000 --> 00:56:01,670


1785
00:56:01,670 --> 00:56:03,030

 

1786
00:56:03,030 --> 00:56:04,470

 

1787
00:56:04,470 --> 00:56:05,990

 

1788
00:56:05,990 --> 00:56:09,510

 

1789
00:56:09,510 --> 00:56:11,990

 

1790
00:56:11,990 --> 00:56:13,589

 

1791
00:56:13,589 --> 00:56:15,990

 

1792
00:56:15,990 --> 00:56:19,510

 

1793
00:56:19,510 --> 00:56:19,520

 

1794
00:56:19,520 --> 00:56:22,230


1795
00:56:22,230 --> 00:56:22,240

 

1796
00:56:22,240 --> 00:56:23,270


1797
00:56:23,270 --> 00:56:23,280

 

1798
00:56:23,280 --> 00:56:24,230


1799
00:56:24,230 --> 00:56:25,670

 

1800
00:56:25,670 --> 00:56:27,829

 

1801
00:56:27,829 --> 00:56:30,710

 

1802
00:56:30,710 --> 00:56:32,549

 

1803
00:56:32,549 --> 00:56:34,150

 

1804
00:56:34,150 --> 00:56:35,990

 

1805
00:56:35,990 --> 00:56:37,910

 

1806
00:56:37,910 --> 00:56:41,430

 

1807
00:56:41,430 --> 00:56:42,789

 

1808
00:56:42,789 --> 00:56:45,109

 

1809
00:56:45,109 --> 00:56:48,710

 

1810
00:56:48,710 --> 00:56:50,309

 

1811
00:56:50,309 --> 00:56:52,470

 

1812
00:56:52,470 --> 00:56:54,470

 

1813
00:56:54,470 --> 00:56:56,069

 

1814
00:56:56,069 --> 00:56:58,230

 

1815
00:56:58,230 --> 00:57:00,700

 

1816
00:57:00,700 --> 00:57:00,710

 

1817
00:57:00,710 --> 00:57:03,510


1818
00:57:03,510 --> 00:57:05,589

 

1819
00:57:05,589 --> 00:57:07,510

 

1820
00:57:07,510 --> 00:57:09,109

 

1821
00:57:09,109 --> 00:57:12,950

 

1822
00:57:12,950 --> 00:57:12,960

 

1823
00:57:12,960 --> 00:57:13,829


1824
00:57:13,829 --> 00:57:16,549

 

1825
00:57:16,549 --> 00:57:16,559

 

1826
00:57:16,559 --> 00:57:17,510


1827
00:57:17,510 --> 00:57:19,430

 

1828
00:57:19,430 --> 00:57:22,150

 

1829
00:57:22,150 --> 00:57:23,910

 

1830
00:57:23,910 --> 00:57:26,710

 

1831
00:57:26,710 --> 00:57:29,589

 

1832
00:57:29,589 --> 00:57:31,430

 

1833
00:57:31,430 --> 00:57:33,829

 

1834
00:57:33,829 --> 00:57:36,150

 

1835
00:57:36,150 --> 00:57:36,160

 

1836
00:57:36,160 --> 00:57:37,190


1837
00:57:37,190 --> 00:57:39,750

 

1838
00:57:39,750 --> 00:57:41,349

 

1839
00:57:41,349 --> 00:57:43,270

 

1840
00:57:43,270 --> 00:57:44,390

 

1841
00:57:44,390 --> 00:57:47,030

 

1842
00:57:47,030 --> 00:57:49,510

 

1843
00:57:49,510 --> 00:57:52,470

 

1844
00:57:52,470 --> 00:57:55,750

 

1845
00:57:55,750 --> 00:57:59,030

 

1846
00:57:59,030 --> 00:58:01,030

 

1847
00:58:01,030 --> 00:58:02,230

 

1848
00:58:02,230 --> 00:58:05,109

 

1849
00:58:05,109 --> 00:58:07,990

 

1850
00:58:07,990 --> 00:58:08,000

 

1851
00:58:08,000 --> 00:58:09,030


1852
00:58:09,030 --> 00:58:10,710

 

1853
00:58:10,710 --> 00:58:12,789

 

1854
00:58:12,789 --> 00:58:15,190

 

1855
00:58:15,190 --> 00:58:15,200

 

1856
00:58:15,200 --> 00:58:16,870


1857
00:58:16,870 --> 00:58:19,030

 

1858
00:58:19,030 --> 00:58:21,589

 

1859
00:58:21,589 --> 00:58:24,150

 

1860
00:58:24,150 --> 00:58:26,470

 

1861
00:58:26,470 --> 00:58:30,309

 

1862
00:58:30,309 --> 00:58:31,990

 

1863
00:58:31,990 --> 00:58:34,390

 

1864
00:58:34,390 --> 00:58:38,069

 

1865
00:58:38,069 --> 00:58:40,230

 

1866
00:58:40,230 --> 00:58:40,240

 

1867
00:58:40,240 --> 00:58:41,510


1868
00:58:41,510 --> 00:58:44,789

 

1869
00:58:44,789 --> 00:58:46,710

 

1870
00:58:46,710 --> 00:58:50,549

 

1871
00:58:50,549 --> 00:58:52,870

 

1872
00:58:52,870 --> 00:58:56,390

 

1873
00:58:56,390 --> 00:58:56,400

 

1874
00:58:56,400 --> 00:58:58,309


1875
00:58:58,309 --> 00:59:00,630

 

1876
00:59:00,630 --> 00:59:02,950

 

1877
00:59:02,950 --> 00:59:04,950

 

1878
00:59:04,950 --> 00:59:06,230

 

1879
00:59:06,230 --> 00:59:08,789

 

1880
00:59:08,789 --> 00:59:10,710

 

1881
00:59:10,710 --> 00:59:14,710

 

1882
00:59:14,710 --> 00:59:14,720

 

1883
00:59:14,720 --> 00:59:16,870


1884
00:59:16,870 --> 00:59:21,109

 

1885
00:59:21,109 --> 00:59:24,710

 

1886
00:59:24,710 --> 00:59:24,720

 

1887
00:59:24,720 --> 00:59:26,309


1888
00:59:26,309 --> 00:59:28,390

 

1889
00:59:28,390 --> 00:59:28,400

 

1890
00:59:28,400 --> 00:59:29,750


1891
00:59:29,750 --> 00:59:31,910

 

1892
00:59:31,910 --> 00:59:36,150

 

1893
00:59:36,150 --> 00:59:38,549

 

1894
00:59:38,549 --> 00:59:39,829

 

1895
00:59:39,829 --> 00:59:42,150

 

1896
00:59:42,150 --> 00:59:43,910

 

1897
00:59:43,910 --> 00:59:46,470

 

1898
00:59:46,470 --> 00:59:50,470

 

1899
00:59:50,470 --> 00:59:52,630

 

1900
00:59:52,630 --> 00:59:54,470

 

1901
00:59:54,470 --> 00:59:56,950

 

1902
00:59:56,950 --> 00:59:58,470

 

1903
00:59:58,470 --> 01:00:00,950

 

1904
01:00:00,950 --> 01:00:04,710

 

1905
01:00:04,710 --> 01:00:07,270

 

1906
01:00:07,270 --> 01:00:07,280

 

1907
01:00:07,280 --> 01:00:09,030


1908
01:00:09,030 --> 01:00:11,510

 

1909
01:00:11,510 --> 01:00:13,430

 

1910
01:00:13,430 --> 01:00:14,789

 

1911
01:00:14,789 --> 01:00:18,309

 

1912
01:00:18,309 --> 01:00:21,030

 

1913
01:00:21,030 --> 01:00:21,040

 

1914
01:00:21,040 --> 01:00:21,829


1915
01:00:21,829 --> 01:00:23,510

 

1916
01:00:23,510 --> 01:00:25,670

 

1917
01:00:25,670 --> 01:00:27,030

 

1918
01:00:27,030 --> 01:00:29,190

 

1919
01:00:29,190 --> 01:00:30,789

 

1920
01:00:30,789 --> 01:00:32,390

 

1921
01:00:32,390 --> 01:00:35,589

 

1922
01:00:35,589 --> 01:00:37,910

 

1923
01:00:37,910 --> 01:00:40,470

 

1924
01:00:40,470 --> 01:00:42,390

 

1925
01:00:42,390 --> 01:00:44,549

 

1926
01:00:44,549 --> 01:00:46,069

 

1927
01:00:46,069 --> 01:00:46,079

 

1928
01:00:46,079 --> 01:00:47,829


1929
01:00:47,829 --> 01:00:47,839

 

1930
01:00:47,839 --> 01:00:49,190


1931
01:00:49,190 --> 01:00:50,630

 

1932
01:00:50,630 --> 01:00:53,030

 

1933
01:00:53,030 --> 01:00:53,040

 

1934
01:00:53,040 --> 01:00:55,430


1935
01:00:55,430 --> 01:00:58,390

 

1936
01:00:58,390 --> 01:01:00,870

 

1937
01:01:00,870 --> 01:01:02,150

 

1938
01:01:02,150 --> 01:01:02,160

 

1939
01:01:02,160 --> 01:01:04,309


1940
01:01:04,309 --> 01:01:06,150

 

1941
01:01:06,150 --> 01:01:08,470

 

1942
01:01:08,470 --> 01:01:09,670

 

1943
01:01:09,670 --> 01:01:11,510

 

1944
01:01:11,510 --> 01:01:11,520

 

1945
01:01:11,520 --> 01:01:12,950


1946
01:01:12,950 --> 01:01:16,069

 

1947
01:01:16,069 --> 01:01:17,670

 

1948
01:01:17,670 --> 01:01:21,589

 

1949
01:01:21,589 --> 01:01:21,599

 

1950
01:01:21,599 --> 01:01:22,549


1951
01:01:22,549 --> 01:01:24,870

 

1952
01:01:24,870 --> 01:01:26,390

 

1953
01:01:26,390 --> 01:01:27,670

 

1954
01:01:27,670 --> 01:01:30,549

 

1955
01:01:30,549 --> 01:01:32,470

 

1956
01:01:32,470 --> 01:01:34,230

 

1957
01:01:34,230 --> 01:01:35,750

 

1958
01:01:35,750 --> 01:01:35,760

 

1959
01:01:35,760 --> 01:01:37,190


1960
01:01:37,190 --> 01:01:39,109

 

1961
01:01:39,109 --> 01:01:39,119

 

1962
01:01:39,119 --> 01:01:40,470


1963
01:01:40,470 --> 01:01:45,349

 

1964
01:01:45,349 --> 01:01:46,710

 

1965
01:01:46,710 --> 01:01:50,150

 

1966
01:01:50,150 --> 01:01:52,470

 

1967
01:01:52,470 --> 01:01:55,750

 

1968
01:01:55,750 --> 01:01:57,829

 

1969
01:01:57,829 --> 01:01:57,839

 

1970
01:01:57,839 --> 01:02:00,470


1971
01:02:00,470 --> 01:02:03,029

 

1972
01:02:03,029 --> 01:02:03,039

 

1973
01:02:03,039 --> 01:02:04,150


1974
01:02:04,150 --> 01:02:06,950

 

1975
01:02:06,950 --> 01:02:08,390

 

1976
01:02:08,390 --> 01:02:10,630

 

1977
01:02:10,630 --> 01:02:12,390

 

1978
01:02:12,390 --> 01:02:13,510

 

1979
01:02:13,510 --> 01:02:15,190

 

1980
01:02:15,190 --> 01:02:16,230

 

1981
01:02:16,230 --> 01:02:18,630

 

1982
01:02:18,630 --> 01:02:21,589

 

1983
01:02:21,589 --> 01:02:24,150

 

1984
01:02:24,150 --> 01:02:25,990

 

1985
01:02:25,990 --> 01:02:27,270

 

1986
01:02:27,270 --> 01:02:29,990

 

1987
01:02:29,990 --> 01:02:30,000

 

1988
01:02:30,000 --> 01:02:31,750


1989
01:02:31,750 --> 01:02:33,589

 

1990
01:02:33,589 --> 01:02:37,349

 

1991
01:02:37,349 --> 01:02:39,990

 

1992
01:02:39,990 --> 01:02:42,150

 

1993
01:02:42,150 --> 01:02:43,990

 

1994
01:02:43,990 --> 01:02:44,000

 

1995
01:02:44,000 --> 01:02:44,789


1996
01:02:44,789 --> 01:02:44,799

 

1997
01:02:44,799 --> 01:02:45,829


1998
01:02:45,829 --> 01:02:50,069

 

1999
01:02:50,069 --> 01:02:52,789

 

2000
01:02:52,789 --> 01:02:55,109

 

2001
01:02:55,109 --> 01:02:57,670

 

2002
01:02:57,670 --> 01:02:57,680

 

2003
01:02:57,680 --> 01:02:58,549


2004
01:02:58,549 --> 01:03:01,190

 

2005
01:03:01,190 --> 01:03:05,190

 

2006
01:03:05,190 --> 01:03:06,710

 

2007
01:03:06,710 --> 01:03:09,190

 

2008
01:03:09,190 --> 01:03:12,870

 

2009
01:03:12,870 --> 01:03:12,880

 

2010
01:03:12,880 --> 01:03:13,750


2011
01:03:13,750 --> 01:03:13,760

 

2012
01:03:13,760 --> 01:03:14,470


2013
01:03:14,470 --> 01:03:17,029

 

2014
01:03:17,029 --> 01:03:17,039

 

2015
01:03:17,039 --> 01:03:18,470


2016
01:03:18,470 --> 01:03:21,670

 

2017
01:03:21,670 --> 01:03:23,670

 

2018
01:03:23,670 --> 01:03:26,309

 

2019
01:03:26,309 --> 01:03:29,270

 

2020
01:03:29,270 --> 01:03:31,670

 

2021
01:03:31,670 --> 01:03:33,430

 

2022
01:03:33,430 --> 01:03:35,430

 

2023
01:03:35,430 --> 01:03:35,440

 

2024
01:03:35,440 --> 01:03:38,069


2025
01:03:38,069 --> 01:03:38,079

 

2026
01:03:38,079 --> 01:03:39,109


2027
01:03:39,109 --> 01:03:41,349

 

2028
01:03:41,349 --> 01:03:41,359

 

2029
01:03:41,359 --> 01:03:42,549


2030
01:03:42,549 --> 01:03:44,309

 

2031
01:03:44,309 --> 01:03:46,309

 

2032
01:03:46,309 --> 01:03:47,589

 

2033
01:03:47,589 --> 01:03:51,750

 

2034
01:03:51,750 --> 01:03:52,950

 

2035
01:03:52,950 --> 01:03:52,960

 

2036
01:03:52,960 --> 01:03:54,870


2037
01:03:54,870 --> 01:03:56,870

 

2038
01:03:56,870 --> 01:03:58,549

 

2039
01:03:58,549 --> 01:03:58,559

 

2040
01:03:58,559 --> 01:04:00,470


2041
01:04:00,470 --> 01:04:02,630

 

2042
01:04:02,630 --> 01:04:04,630

 

2043
01:04:04,630 --> 01:04:04,640

 

2044
01:04:04,640 --> 01:04:05,670


2045
01:04:05,670 --> 01:04:06,870

 

2046
01:04:06,870 --> 01:04:08,789

 

2047
01:04:08,789 --> 01:04:11,270

 

2048
01:04:11,270 --> 01:04:15,029

 

2049
01:04:15,029 --> 01:04:16,870

 

2050
01:04:16,870 --> 01:04:18,549

 

2051
01:04:18,549 --> 01:04:21,270

 

2052
01:04:21,270 --> 01:04:24,230

 

2053
01:04:24,230 --> 01:04:25,589

 

2054
01:04:25,589 --> 01:04:28,549

 

2055
01:04:28,549 --> 01:04:30,309

 

2056
01:04:30,309 --> 01:04:32,710

 

2057
01:04:32,710 --> 01:04:35,190

 

2058
01:04:35,190 --> 01:04:35,200

 

2059
01:04:35,200 --> 01:04:39,510


2060
01:04:39,510 --> 01:04:39,520

 

2061
01:04:39,520 --> 01:04:40,630


2062
01:04:40,630 --> 01:04:42,069

 

2063
01:04:42,069 --> 01:04:43,829

 

2064
01:04:43,829 --> 01:04:46,150

 

2065
01:04:46,150 --> 01:04:47,670

 

2066
01:04:47,670 --> 01:04:51,270

 

2067
01:04:51,270 --> 01:04:53,430

 

2068
01:04:53,430 --> 01:04:55,270

 

2069
01:04:55,270 --> 01:04:57,430

 

2070
01:04:57,430 --> 01:05:00,230

 

2071
01:05:00,230 --> 01:05:02,630

 

2072
01:05:02,630 --> 01:05:03,910

 

2073
01:05:03,910 --> 01:05:03,920

 

2074
01:05:03,920 --> 01:05:06,150


2075
01:05:06,150 --> 01:05:06,160

 

2076
01:05:06,160 --> 01:05:07,109


2077
01:05:07,109 --> 01:05:08,390

 

2078
01:05:08,390 --> 01:05:11,109

 

2079
01:05:11,109 --> 01:05:12,870

 

2080
01:05:12,870 --> 01:05:12,880

 

2081
01:05:12,880 --> 01:05:14,069


2082
01:05:14,069 --> 01:05:17,190

 

2083
01:05:17,190 --> 01:05:18,950

 

2084
01:05:18,950 --> 01:05:18,960

 

2085
01:05:18,960 --> 01:05:20,069


2086
01:05:20,069 --> 01:05:21,990

 

2087
01:05:21,990 --> 01:05:22,870

 

2088
01:05:22,870 --> 01:05:25,190

 

2089
01:05:25,190 --> 01:05:27,750

 

2090
01:05:27,750 --> 01:05:30,390

 

2091
01:05:30,390 --> 01:05:31,910

 

2092
01:05:31,910 --> 01:05:33,190

 

2093
01:05:33,190 --> 01:05:36,630

 

2094
01:05:36,630 --> 01:05:39,510

 

2095
01:05:39,510 --> 01:05:39,520

 

2096
01:05:39,520 --> 01:05:40,309


2097
01:05:40,309 --> 01:05:43,750

 

2098
01:05:43,750 --> 01:05:47,589

 

2099
01:05:47,589 --> 01:05:49,270

 

2100
01:05:49,270 --> 01:05:49,280

 

2101
01:05:49,280 --> 01:05:51,430


2102
01:05:51,430 --> 01:05:51,440

 

2103
01:05:51,440 --> 01:05:52,549


2104
01:05:52,549 --> 01:05:54,470

 

2105
01:05:54,470 --> 01:05:56,870

 

2106
01:05:56,870 --> 01:05:59,430

 

2107
01:05:59,430 --> 01:06:00,549

 

2108
01:06:00,549 --> 01:06:03,349

 

2109
01:06:03,349 --> 01:06:04,549

 

2110
01:06:04,549 --> 01:06:06,470

 

2111
01:06:06,470 --> 01:06:07,510

 

2112
01:06:07,510 --> 01:06:09,990

 

2113
01:06:09,990 --> 01:06:11,029

 

2114
01:06:11,029 --> 01:06:12,789

 

2115
01:06:12,789 --> 01:06:15,190

 

2116
01:06:15,190 --> 01:06:18,230

 

2117
01:06:18,230 --> 01:06:22,069

 

2118
01:06:22,069 --> 01:06:24,470

 

2119
01:06:24,470 --> 01:06:26,870

 

2120
01:06:26,870 --> 01:06:29,029

 

2121
01:06:29,029 --> 01:06:30,950

 

2122
01:06:30,950 --> 01:06:32,549

 

2123
01:06:32,549 --> 01:06:35,190

 

2124
01:06:35,190 --> 01:06:37,349

 

2125
01:06:37,349 --> 01:06:40,789

 

2126
01:06:40,789 --> 01:06:43,109

 

2127
01:06:43,109 --> 01:06:45,270

 

2128
01:06:45,270 --> 01:06:48,549

 

2129
01:06:48,549 --> 01:06:50,150

 

2130
01:06:50,150 --> 01:06:51,910

 

2131
01:06:51,910 --> 01:06:55,270

 

2132
01:06:55,270 --> 01:06:56,789

 

2133
01:06:56,789 --> 01:06:59,270

 

2134
01:06:59,270 --> 01:07:01,270

 

2135
01:07:01,270 --> 01:07:01,280

 

2136
01:07:01,280 --> 01:07:02,150


2137
01:07:02,150 --> 01:07:03,990

 

2138
01:07:03,990 --> 01:07:05,829

 

2139
01:07:05,829 --> 01:07:07,990

 

2140
01:07:07,990 --> 01:07:11,109

 

2141
01:07:11,109 --> 01:07:12,950

 

2142
01:07:12,950 --> 01:07:14,470

 

2143
01:07:14,470 --> 01:07:17,990

 

2144
01:07:17,990 --> 01:07:20,150

 

2145
01:07:20,150 --> 01:07:22,230

 

2146
01:07:22,230 --> 01:07:24,069

 

2147
01:07:24,069 --> 01:07:27,029

 

2148
01:07:27,029 --> 01:07:29,109

 

2149
01:07:29,109 --> 01:07:30,870

 

2150
01:07:30,870 --> 01:07:32,789

 

2151
01:07:32,789 --> 01:07:35,750

 

2152
01:07:35,750 --> 01:07:37,270

 

2153
01:07:37,270 --> 01:07:38,789

 

2154
01:07:38,789 --> 01:07:40,789

 

2155
01:07:40,789 --> 01:07:42,710

 

2156
01:07:42,710 --> 01:07:44,630

 

2157
01:07:44,630 --> 01:07:46,950

 

2158
01:07:46,950 --> 01:07:46,960

 

2159
01:07:46,960 --> 01:07:49,670


2160
01:07:49,670 --> 01:07:51,430

 

2161
01:07:51,430 --> 01:07:53,990

 

2162
01:07:53,990 --> 01:07:54,000

 

2163
01:07:54,000 --> 01:07:55,109


2164
01:07:55,109 --> 01:07:58,470

 

2165
01:07:58,470 --> 01:07:58,480

 

2166
01:07:58,480 --> 01:07:59,190


2167
01:07:59,190 --> 01:08:00,630

 

2168
01:08:00,630 --> 01:08:04,230

 

2169
01:08:04,230 --> 01:08:07,750

 

2170
01:08:07,750 --> 01:08:09,029

 

2171
01:08:09,029 --> 01:08:12,309

 

2172
01:08:12,309 --> 01:08:14,069

 

2173
01:08:14,069 --> 01:08:16,550

 

2174
01:08:16,550 --> 01:08:18,950

 

2175
01:08:18,950 --> 01:08:21,510

 

2176
01:08:21,510 --> 01:08:24,550

 

2177
01:08:24,550 --> 01:08:28,630

 

2178
01:08:28,630 --> 01:08:28,640

 

2179
01:08:28,640 --> 01:08:29,669


2180
01:08:29,669 --> 01:08:31,749

 

2181
01:08:31,749 --> 01:08:33,990

 

2182
01:08:33,990 --> 01:08:34,000

 

2183
01:08:34,000 --> 01:08:35,590


2184
01:08:35,590 --> 01:08:38,149

 

2185
01:08:38,149 --> 01:08:41,269

 

2186
01:08:41,269 --> 01:08:41,279

 

2187
01:08:41,279 --> 01:08:42,550


2188
01:08:42,550 --> 01:08:44,709

 

2189
01:08:44,709 --> 01:08:46,390

 

2190
01:08:46,390 --> 01:08:49,269

 

2191
01:08:49,269 --> 01:08:52,149

 

2192
01:08:52,149 --> 01:08:54,149

 

2193
01:08:54,149 --> 01:08:56,309

 

2194
01:08:56,309 --> 01:08:57,749

 

2195
01:08:57,749 --> 01:08:57,759

 

2196
01:08:57,759 --> 01:09:00,229


2197
01:09:00,229 --> 01:09:02,149

 

2198
01:09:02,149 --> 01:09:04,470

 

2199
01:09:04,470 --> 01:09:06,630

 

2200
01:09:06,630 --> 01:09:08,390

 

2201
01:09:08,390 --> 01:09:10,149

 

2202
01:09:10,149 --> 01:09:12,149

 

2203
01:09:12,149 --> 01:09:14,229

 

2204
01:09:14,229 --> 01:09:15,829

 

2205
01:09:15,829 --> 01:09:17,430

 

2206
01:09:17,430 --> 01:09:20,390

 

2207
01:09:20,390 --> 01:09:21,749

 

2208
01:09:21,749 --> 01:09:25,269

 

2209
01:09:25,269 --> 01:09:26,390

 

2210
01:09:26,390 --> 01:09:28,309

 

2211
01:09:28,309 --> 01:09:30,709

 

2212
01:09:30,709 --> 01:09:32,829

 

2213
01:09:32,829 --> 01:09:35,349

 

2214
01:09:35,349 --> 01:09:37,269

 

2215
01:09:37,269 --> 01:09:40,070

 

2216
01:09:40,070 --> 01:09:45,030

 

2217
01:09:45,030 --> 01:09:45,040

 

2218
01:09:45,040 --> 01:09:45,829


2219
01:09:45,829 --> 01:09:45,839

 

2220
01:09:45,839 --> 01:09:47,510


2221
01:09:47,510 --> 01:09:47,520

 

2222
01:09:47,520 --> 01:09:48,390


2223
01:09:48,390 --> 01:09:50,390

 

2224
01:09:50,390 --> 01:09:52,870

 

2225
01:09:52,870 --> 01:09:55,189

 

2226
01:09:55,189 --> 01:09:55,199

 

2227
01:09:55,199 --> 01:09:56,229


2228
01:09:56,229 --> 01:09:56,239

 

2229
01:09:56,239 --> 01:09:57,830


2230
01:09:57,830 --> 01:10:00,229

 

2231
01:10:00,229 --> 01:10:02,630

 

2232
01:10:02,630 --> 01:10:04,630

 

2233
01:10:04,630 --> 01:10:06,790

 

2234
01:10:06,790 --> 01:10:09,270

 

2235
01:10:09,270 --> 01:10:11,910

 

2236
01:10:11,910 --> 01:10:13,590

 

2237
01:10:13,590 --> 01:10:16,390

 

2238
01:10:16,390 --> 01:10:16,400

 

2239
01:10:16,400 --> 01:10:18,229


2240
01:10:18,229 --> 01:10:20,149

 

2241
01:10:20,149 --> 01:10:22,070

 

2242
01:10:22,070 --> 01:10:24,229

 

2243
01:10:24,229 --> 01:10:27,590

 

2244
01:10:27,590 --> 01:10:30,790

 

2245
01:10:30,790 --> 01:10:33,910

 

2246
01:10:33,910 --> 01:10:33,920

 

2247
01:10:33,920 --> 01:10:35,110


2248
01:10:35,110 --> 01:10:36,470

 

2249
01:10:36,470 --> 01:10:40,149

 

2250
01:10:40,149 --> 01:10:43,990

 

2251
01:10:43,990 --> 01:10:46,229

 

2252
01:10:46,229 --> 01:10:48,310

 

2253
01:10:48,310 --> 01:10:50,390

 

2254
01:10:50,390 --> 01:10:52,550

 

2255
01:10:52,550 --> 01:10:54,709

 

2256
01:10:54,709 --> 01:10:56,870

 

2257
01:10:56,870 --> 01:10:56,880

 

2258
01:10:56,880 --> 01:10:59,350


2259
01:10:59,350 --> 01:10:59,360

 

2260
01:10:59,360 --> 01:11:00,390


2261
01:11:00,390 --> 01:11:01,910

 

2262
01:11:01,910 --> 01:11:01,920

 

2263
01:11:01,920 --> 01:11:02,790


2264
01:11:02,790 --> 01:11:04,390

 

2265
01:11:04,390 --> 01:11:06,550

 

2266
01:11:06,550 --> 01:11:09,189

 

2267
01:11:09,189 --> 01:11:11,430

 

2268
01:11:11,430 --> 01:11:14,470

 

2269
01:11:14,470 --> 01:11:16,709

 

2270
01:11:16,709 --> 01:11:19,590

 

2271
01:11:19,590 --> 01:11:21,590

 

2272
01:11:21,590 --> 01:11:24,070

 

2273
01:11:24,070 --> 01:11:25,910

 

2274
01:11:25,910 --> 01:11:25,920

 

2275
01:11:25,920 --> 01:11:27,350


2276
01:11:27,350 --> 01:11:29,669

 

2277
01:11:29,669 --> 01:11:32,550

 

2278
01:11:32,550 --> 01:11:34,950

 

2279
01:11:34,950 --> 01:11:34,960

 

2280
01:11:34,960 --> 01:11:36,630


2281
01:11:36,630 --> 01:11:36,640

 

2282
01:11:36,640 --> 01:11:38,870


2283
01:11:38,870 --> 01:11:41,750

 

2284
01:11:41,750 --> 01:11:44,310

 

2285
01:11:44,310 --> 01:11:46,870

 

2286
01:11:46,870 --> 01:11:48,310

 

2287
01:11:48,310 --> 01:11:51,110

 

2288
01:11:51,110 --> 01:11:53,510

 

2289
01:11:53,510 --> 01:11:55,669

 

2290
01:11:55,669 --> 01:11:58,390

 

2291
01:11:58,390 --> 01:12:02,390

 

2292
01:12:02,390 --> 01:12:04,070

 

2293
01:12:04,070 --> 01:12:05,990

 

2294
01:12:05,990 --> 01:12:08,790

 

2295
01:12:08,790 --> 01:12:10,310

 

2296
01:12:10,310 --> 01:12:10,320

 

2297
01:12:10,320 --> 01:12:15,590


2298
01:12:15,590 --> 01:12:17,110

 

2299
01:12:17,110 --> 01:12:17,120

 

2300
01:12:17,120 --> 01:12:18,229


2301
01:12:18,229 --> 01:12:22,870

 

2302
01:12:22,870 --> 01:12:26,950

 

2303
01:12:26,950 --> 01:12:29,110

 

2304
01:12:29,110 --> 01:12:29,120

 

2305
01:12:29,120 --> 01:12:30,470


2306
01:12:30,470 --> 01:12:32,070

 

2307
01:12:32,070 --> 01:12:34,310

 

2308
01:12:34,310 --> 01:12:37,750

 

2309
01:12:37,750 --> 01:12:37,760

 

2310
01:12:37,760 --> 01:12:38,790


2311
01:12:38,790 --> 01:12:41,110

 

2312
01:12:41,110 --> 01:12:45,350

 

2313
01:12:45,350 --> 01:12:45,360

 

2314
01:12:45,360 --> 01:12:47,669


2315
01:12:47,669 --> 01:12:49,270

 

2316
01:12:49,270 --> 01:12:51,590

 

2317
01:12:51,590 --> 01:12:53,430

 

2318
01:12:53,430 --> 01:12:55,750

 

2319
01:12:55,750 --> 01:12:57,669

 

2320
01:12:57,669 --> 01:12:59,590

 

2321
01:12:59,590 --> 01:13:01,669

 

2322
01:13:01,669 --> 01:13:03,510

 

2323
01:13:03,510 --> 01:13:05,030

 

2324
01:13:05,030 --> 01:13:05,040

 

2325
01:13:05,040 --> 01:13:06,149


2326
01:13:06,149 --> 01:13:06,159

 

2327
01:13:06,159 --> 01:13:08,310


2328
01:13:08,310 --> 01:13:10,550

 

2329
01:13:10,550 --> 01:13:13,270

 

2330
01:13:13,270 --> 01:13:15,750

 

2331
01:13:15,750 --> 01:13:17,350

 

2332
01:13:17,350 --> 01:13:19,669

 

2333
01:13:19,669 --> 01:13:21,270

 

2334
01:13:21,270 --> 01:13:25,669

 

2335
01:13:25,669 --> 01:13:26,950

 

2336
01:13:26,950 --> 01:13:26,960

 

2337
01:13:26,960 --> 01:13:27,750


2338
01:13:27,750 --> 01:13:27,760

 

2339
01:13:27,760 --> 01:13:28,550


2340
01:13:28,550 --> 01:13:30,790

 

2341
01:13:30,790 --> 01:13:32,950

 

2342
01:13:32,950 --> 01:13:34,870

 

2343
01:13:34,870 --> 01:13:36,870

 

2344
01:13:36,870 --> 01:13:38,790

 

2345
01:13:38,790 --> 01:13:41,590

 

2346
01:13:41,590 --> 01:13:43,910

 

2347
01:13:43,910 --> 01:13:46,630

 

2348
01:13:46,630 --> 01:13:50,709

 

2349
01:13:50,709 --> 01:13:53,430

 

2350
01:13:53,430 --> 01:13:55,510

 

2351
01:13:55,510 --> 01:13:57,430

 

2352
01:13:57,430 --> 01:14:01,189

 

2353
01:14:01,189 --> 01:14:03,189

 

2354
01:14:03,189 --> 01:14:05,910

 

2355
01:14:05,910 --> 01:14:07,510

 

2356
01:14:07,510 --> 01:14:10,630

 

2357
01:14:10,630 --> 01:14:12,950

 

2358
01:14:12,950 --> 01:14:15,750

 

2359
01:14:15,750 --> 01:14:18,310

 

2360
01:14:18,310 --> 01:14:20,470

 

2361
01:14:20,470 --> 01:14:23,189

 

2362
01:14:23,189 --> 01:14:26,830

 

2363
01:14:26,830 --> 01:14:29,110

 

2364
01:14:29,110 --> 01:14:31,990

 

2365
01:14:31,990 --> 01:14:34,070

 

2366
01:14:34,070 --> 01:14:35,830

 

2367
01:14:35,830 --> 01:14:37,110

 

2368
01:14:37,110 --> 01:14:39,430

 

2369
01:14:39,430 --> 01:14:41,430

 

2370
01:14:41,430 --> 01:14:41,440

 

2371
01:14:41,440 --> 01:14:42,550


2372
01:14:42,550 --> 01:14:45,270

 

2373
01:14:45,270 --> 01:14:45,280

 

2374
01:14:45,280 --> 01:14:46,870


2375
01:14:46,870 --> 01:14:48,390

 

2376
01:14:48,390 --> 01:14:51,990

 

2377
01:14:51,990 --> 01:14:53,430

 

2378
01:14:53,430 --> 01:14:55,510

 

2379
01:14:55,510 --> 01:14:58,709

 

2380
01:14:58,709 --> 01:15:00,229

 

2381
01:15:00,229 --> 01:15:03,990

 

2382
01:15:03,990 --> 01:15:06,470

 

2383
01:15:06,470 --> 01:15:08,950

 

2384
01:15:08,950 --> 01:15:11,510

 

2385
01:15:11,510 --> 01:15:13,350

 

2386
01:15:13,350 --> 01:15:15,830

 

2387
01:15:15,830 --> 01:15:15,840

 

2388
01:15:15,840 --> 01:15:16,550


2389
01:15:16,550 --> 01:15:19,430

 

2390
01:15:19,430 --> 01:15:19,440

 

2391
01:15:19,440 --> 01:15:20,870


2392
01:15:20,870 --> 01:15:20,880

 

2393
01:15:20,880 --> 01:15:22,390


2394
01:15:22,390 --> 01:15:24,470

 

2395
01:15:24,470 --> 01:15:26,229

 

2396
01:15:26,229 --> 01:15:27,830

 

2397
01:15:27,830 --> 01:15:30,229

 

2398
01:15:30,229 --> 01:15:31,910

 

2399
01:15:31,910 --> 01:15:31,920

 

2400
01:15:31,920 --> 01:15:33,590


2401
01:15:33,590 --> 01:15:37,189

 

2402
01:15:37,189 --> 01:15:39,510

 

2403
01:15:39,510 --> 01:15:41,350

 

2404
01:15:41,350 --> 01:15:44,070

 

2405
01:15:44,070 --> 01:15:45,990

 

2406
01:15:45,990 --> 01:15:47,189

 

2407
01:15:47,189 --> 01:15:48,790

 

2408
01:15:48,790 --> 01:15:51,350

 

2409
01:15:51,350 --> 01:15:51,360

 

2410
01:15:51,360 --> 01:15:52,470


2411
01:15:52,470 --> 01:15:55,669

 

2412
01:15:55,669 --> 01:15:57,990

 

2413
01:15:57,990 --> 01:15:59,270

 

2414
01:15:59,270 --> 01:15:59,280

 

2415
01:15:59,280 --> 01:16:00,310


2416
01:16:00,310 --> 01:16:01,350

 

2417
01:16:01,350 --> 01:16:02,950

 

2418
01:16:02,950 --> 01:16:05,110

 

2419
01:16:05,110 --> 01:16:06,310

 

2420
01:16:06,310 --> 01:16:09,990

 

2421
01:16:09,990 --> 01:16:12,070

 

2422
01:16:12,070 --> 01:16:14,950

 

2423
01:16:14,950 --> 01:16:17,110

 

2424
01:16:17,110 --> 01:16:19,030

 

2425
01:16:19,030 --> 01:16:19,040

 

2426
01:16:19,040 --> 01:16:20,470


2427
01:16:20,470 --> 01:16:22,229

 

2428
01:16:22,229 --> 01:16:24,149

 

2429
01:16:24,149 --> 01:16:25,910

 

2430
01:16:25,910 --> 01:16:25,920

 

2431
01:16:25,920 --> 01:16:26,330


2432
01:16:26,330 --> 01:16:26,340

 

2433
01:16:26,340 --> 01:16:28,070


2434
01:16:28,070 --> 01:16:30,390

 

2435
01:16:30,390 --> 01:16:32,390

 

2436
01:16:32,390 --> 01:16:32,400

 

2437
01:16:32,400 --> 01:16:34,870


2438
01:16:34,870 --> 01:16:36,709

 

2439
01:16:36,709 --> 01:16:38,790

 

2440
01:16:38,790 --> 01:16:38,800

 

2441
01:16:38,800 --> 01:16:39,990


2442
01:16:39,990 --> 01:16:41,350

 

2443
01:16:41,350 --> 01:16:43,750

 

2444
01:16:43,750 --> 01:16:45,590

 

2445
01:16:45,590 --> 01:16:47,350

 

2446
01:16:47,350 --> 01:16:52,870

 

2447
01:16:52,870 --> 01:16:54,790

 

2448
01:16:54,790 --> 01:16:57,270

 

2449
01:16:57,270 --> 01:16:59,110

 

2450
01:16:59,110 --> 01:17:03,110

 

2451
01:17:03,110 --> 01:17:05,189

 

2452
01:17:05,189 --> 01:17:07,830

 

2453
01:17:07,830 --> 01:17:09,910

 

2454
01:17:09,910 --> 01:17:12,149

 

2455
01:17:12,149 --> 01:17:15,189

 

2456
01:17:15,189 --> 01:17:19,510

 

2457
01:17:19,510 --> 01:17:21,270

 

2458
01:17:21,270 --> 01:17:23,110

 

2459
01:17:23,110 --> 01:17:25,110

 

2460
01:17:25,110 --> 01:17:27,510

 

2461
01:17:27,510 --> 01:17:31,510

 

2462
01:17:31,510 --> 01:17:34,630

 

2463
01:17:34,630 --> 01:17:36,550

 

2464
01:17:36,550 --> 01:17:38,550

 

2465
01:17:38,550 --> 01:17:40,550

 

2466
01:17:40,550 --> 01:17:41,669

 

2467
01:17:41,669 --> 01:17:43,910

 

2468
01:17:43,910 --> 01:17:43,920

 

2469
01:17:43,920 --> 01:17:45,189


2470
01:17:45,189 --> 01:17:47,669

 

2471
01:17:47,669 --> 01:17:49,110

 

2472
01:17:49,110 --> 01:17:51,910

 

2473
01:17:51,910 --> 01:17:52,870

 

2474
01:17:52,870 --> 01:17:54,709

 

2475
01:17:54,709 --> 01:17:59,030

 

2476
01:17:59,030 --> 01:18:01,110

 

2477
01:18:01,110 --> 01:18:03,110

 

2478
01:18:03,110 --> 01:18:06,070

 

2479
01:18:06,070 --> 01:18:06,080

 

2480
01:18:06,080 --> 01:18:08,229


2481
01:18:08,229 --> 01:18:10,709

 

2482
01:18:10,709 --> 01:18:13,270

 

2483
01:18:13,270 --> 01:18:14,950

 

2484
01:18:14,950 --> 01:18:17,750

 

2485
01:18:17,750 --> 01:18:20,390

 

2486
01:18:20,390 --> 01:18:23,030

 

2487
01:18:23,030 --> 01:18:24,950

 

2488
01:18:24,950 --> 01:18:27,110

 

2489
01:18:27,110 --> 01:18:30,950

 

2490
01:18:30,950 --> 01:18:33,189

 

2491
01:18:33,189 --> 01:18:34,709

 

2492
01:18:34,709 --> 01:18:36,229

 

2493
01:18:36,229 --> 01:18:38,550

 

2494
01:18:38,550 --> 01:18:38,560

 

2495
01:18:38,560 --> 01:18:40,709


2496
01:18:40,709 --> 01:18:44,870

 

2497
01:18:44,870 --> 01:18:50,470

 

2498
01:18:50,470 --> 01:18:53,350

 

2499
01:18:53,350 --> 01:18:55,350

 

2500
01:18:55,350 --> 01:18:55,360

 

2501
01:18:55,360 --> 01:18:56,310


2502
01:18:56,310 --> 01:18:58,550

 

2503
01:18:58,550 --> 01:18:58,560

 

2504
01:18:58,560 --> 01:18:59,990


2505
01:18:59,990 --> 01:19:00,000

 

2506
01:19:00,000 --> 01:19:03,830


2507
01:19:03,830 --> 01:19:05,189

 

2508
01:19:05,189 --> 01:19:07,030

 

2509
01:19:07,030 --> 01:19:09,189

 

2510
01:19:09,189 --> 01:19:10,550

 

2511
01:19:10,550 --> 01:19:12,149

 

2512
01:19:12,149 --> 01:19:13,510

 

2513
01:19:13,510 --> 01:19:15,750

 

2514
01:19:15,750 --> 01:19:17,910

 

2515
01:19:17,910 --> 01:19:17,920

 

2516
01:19:17,920 --> 01:19:19,750


2517
01:19:19,750 --> 01:19:21,830

 

2518
01:19:21,830 --> 01:19:23,669

 

2519
01:19:23,669 --> 01:19:25,510

 

2520
01:19:25,510 --> 01:19:26,870

 

2521
01:19:26,870 --> 01:19:29,189

 

2522
01:19:29,189 --> 01:19:30,950

 

2523
01:19:30,950 --> 01:19:33,189

 

2524
01:19:33,189 --> 01:19:35,750

 

2525
01:19:35,750 --> 01:19:35,760

 

2526
01:19:35,760 --> 01:19:36,470


2527
01:19:36,470 --> 01:19:39,430

 

2528
01:19:39,430 --> 01:19:41,110

 

2529
01:19:41,110 --> 01:19:44,229

 

2530
01:19:44,229 --> 01:19:46,709

 

2531
01:19:46,709 --> 01:19:49,030

 

2532
01:19:49,030 --> 01:19:50,709

 

2533
01:19:50,709 --> 01:19:53,990

 

2534
01:19:53,990 --> 01:19:56,149

 

2535
01:19:56,149 --> 01:19:57,910

 

2536
01:19:57,910 --> 01:19:59,430

 

2537
01:19:59,430 --> 01:20:01,510

 

2538
01:20:01,510 --> 01:20:04,550

 

2539
01:20:04,550 --> 01:20:06,629

 

2540
01:20:06,629 --> 01:20:08,070

 

2541
01:20:08,070 --> 01:20:10,470

 

2542
01:20:10,470 --> 01:20:12,070

 

2543
01:20:12,070 --> 01:20:14,390

 

2544
01:20:14,390 --> 01:20:16,310

 

2545
01:20:16,310 --> 01:20:19,430

 

2546
01:20:19,430 --> 01:20:22,310

 

2547
01:20:22,310 --> 01:20:24,310

 

2548
01:20:24,310 --> 01:20:26,390

 

2549
01:20:26,390 --> 01:20:30,629

 

2550
01:20:30,629 --> 01:20:33,430

 

2551
01:20:33,430 --> 01:20:35,430

 

2552
01:20:35,430 --> 01:20:37,350

 

2553
01:20:37,350 --> 01:20:38,550

 

2554
01:20:38,550 --> 01:20:42,470

 

2555
01:20:42,470 --> 01:20:44,950

 

2556
01:20:44,950 --> 01:20:46,790

 

2557
01:20:46,790 --> 01:20:50,390

 

2558
01:20:50,390 --> 01:20:52,149

 

2559
01:20:52,149 --> 01:20:53,590

 

2560
01:20:53,590 --> 01:20:55,590

 

2561
01:20:55,590 --> 01:20:57,510

 

2562
01:20:57,510 --> 01:20:59,590

 

2563
01:20:59,590 --> 01:21:00,870

 

2564
01:21:00,870 --> 01:21:03,110

 

2565
01:21:03,110 --> 01:21:05,669

 

2566
01:21:05,669 --> 01:21:07,669

 

2567
01:21:07,669 --> 01:21:09,430

 

2568
01:21:09,430 --> 01:21:11,669

 

2569
01:21:11,669 --> 01:21:13,830

 

2570
01:21:13,830 --> 01:21:15,590

 

2571
01:21:15,590 --> 01:21:17,510

 

2572
01:21:17,510 --> 01:21:19,590

 

2573
01:21:19,590 --> 01:21:21,270

 

2574
01:21:21,270 --> 01:21:23,189

 

2575
01:21:23,189 --> 01:21:25,350

 

2576
01:21:25,350 --> 01:21:25,360

 

2577
01:21:25,360 --> 01:21:26,629


2578
01:21:26,629 --> 01:21:28,709

 

2579
01:21:28,709 --> 01:21:29,990

 

2580
01:21:29,990 --> 01:21:32,229

 

2581
01:21:32,229 --> 01:21:33,910

 

2582
01:21:33,910 --> 01:21:35,350

 

2583
01:21:35,350 --> 01:21:37,270

 

2584
01:21:37,270 --> 01:21:37,280

 

2585
01:21:37,280 --> 01:21:38,470


2586
01:21:38,470 --> 01:21:40,950

 

2587
01:21:40,950 --> 01:21:42,550

 

2588
01:21:42,550 --> 01:21:44,149

 

2589
01:21:44,149 --> 01:21:44,159

 

2590
01:21:44,159 --> 01:21:45,350


2591
01:21:45,350 --> 01:21:47,430

 

2592
01:21:47,430 --> 01:21:48,310

 

2593
01:21:48,310 --> 01:21:50,070

 

2594
01:21:50,070 --> 01:21:50,080

 

2595
01:21:50,080 --> 01:21:50,790


2596
01:21:50,790 --> 01:21:52,390

 

2597
01:21:52,390 --> 01:21:54,149

 

2598
01:21:54,149 --> 01:21:56,390

 

2599
01:21:56,390 --> 01:21:58,390

 

2600
01:21:58,390 --> 01:22:00,149

 

2601
01:22:00,149 --> 01:22:00,159

 

2602
01:22:00,159 --> 01:22:00,950


2603
01:22:00,950 --> 01:22:02,790

 

2604
01:22:02,790 --> 01:22:02,800

 

2605
01:22:02,800 --> 01:22:04,310


2606
01:22:04,310 --> 01:22:04,320

 

2607
01:22:04,320 --> 01:22:06,550


2608
01:22:06,550 --> 01:22:09,750

 

2609
01:22:09,750 --> 01:22:09,760

 

2610
01:22:09,760 --> 01:22:11,270


2611
01:22:11,270 --> 01:22:11,280

 

2612
01:22:11,280 --> 01:22:15,910


2613
01:22:15,910 --> 01:22:17,990

 

2614
01:22:17,990 --> 01:22:19,910

 

2615
01:22:19,910 --> 01:22:23,350

 

2616
01:22:23,350 --> 01:22:25,430

 

2617
01:22:25,430 --> 01:22:25,440

 

2618
01:22:25,440 --> 01:22:26,149


2619
01:22:26,149 --> 01:22:28,950

 

2620
01:22:28,950 --> 01:22:30,470

 

2621
01:22:30,470 --> 01:22:31,990

 

2622
01:22:31,990 --> 01:22:33,990

 

2623
01:22:33,990 --> 01:22:35,590

 

2624
01:22:35,590 --> 01:22:38,310

 

2625
01:22:38,310 --> 01:22:41,910

 

2626
01:22:41,910 --> 01:22:43,270

 

2627
01:22:43,270 --> 01:22:45,830

 

2628
01:22:45,830 --> 01:22:47,189

 

2629
01:22:47,189 --> 01:22:49,189

 

2630
01:22:49,189 --> 01:22:51,669

 

2631
01:22:51,669 --> 01:22:53,510

 

2632
01:22:53,510 --> 01:22:54,629

 

2633
01:22:54,629 --> 01:22:56,149

 

2634
01:22:56,149 --> 01:22:56,159

 

2635
01:22:56,159 --> 01:22:57,189


2636
01:22:57,189 --> 01:23:00,310

 

2637
01:23:00,310 --> 01:23:00,320

 

2638
01:23:00,320 --> 01:23:01,910


2639
01:23:01,910 --> 01:23:04,149

 

2640
01:23:04,149 --> 01:23:06,709

 

2641
01:23:06,709 --> 01:23:08,790

 

2642
01:23:08,790 --> 01:23:08,800

 

2643
01:23:08,800 --> 01:23:10,470


2644
01:23:10,470 --> 01:23:12,310

 

2645
01:23:12,310 --> 01:23:13,910

 

2646
01:23:13,910 --> 01:23:15,350

 

2647
01:23:15,350 --> 01:23:15,360

 

2648
01:23:15,360 --> 01:23:17,350


2649
01:23:17,350 --> 01:23:17,360

 

2650
01:23:17,360 --> 01:23:18,470


2651
01:23:18,470 --> 01:23:20,550

 

2652
01:23:20,550 --> 01:23:20,560

 

2653
01:23:20,560 --> 01:23:21,990


2654
01:23:21,990 --> 01:23:23,669

 

2655
01:23:23,669 --> 01:23:27,030

 

2656
01:23:27,030 --> 01:23:40,550

 

2657
01:23:40,550 --> 01:23:40,560

 

2658
01:23:40,560 --> 01:23:42,639