1
00:00:25,199 --> 00:00:26,470

hi folks  um why don't we get started  um  welcome back  good to see you  you all here  so um  i am going to  first  we'll  we'll recap what we did last time and  what we're going to do today i'll talk a  little bit about the problem set  and we'll also have a break as requested  halfway through  so why don't we jump in um what we did  last time um was we introduced finite  besides introduce introducing the course  we introduced finite automata and  regular languages which are the  languages that the finite automata can  recognize  we talked about these regular operations  um and the and then building um those  those allow us to build what we call our  regular expressions these are  ways of describing languages so find we  have finite automata can describe  languages and regular expressions can  describe languages and one of our goals  is to show that those two systems are  equivalent to one another even though  they look rather different um at first  glance  so um to  move in that direction we first  proved uh we're going to prove closure  properties for all of the  for the class of regular languages over  these regular operations so we'll show  that  well we already showed that any two  regular languages have their union also  being regular and we'll show that for  the other two operations as well so  let's just look ahead to what we're  going to do today  we're going to introduce an important  concept which is going to be a theme  throughout the course called  non-determinism  and we  uh  having that as a tool  that we can use will be able to show  closure under concatenation and star  finishing up what we started to do last  time  and then we'll use those closure  constructions to show how to convert  regular expressions to finite finite  automata  um and that's going to be halfway to our  goal of showing that the  two systems are equivalent to one one  another and the following lecture we  will show how to do the conversion in  the other direction  so i thought we would just jump in then  and look at um return to the material of  the course  um as you remember  we were  looking at the closure properties for  the class of regular languages  um we started doing that um and if you  recall hopefully uh we did closure under  union and then we tried to do closure  under concatenation um which i have  shown here  um on the slide um you know the what the  proof attempt  that we tried to do last time and let's  just review that quickly because i think  that's going to be uh helpful to see how  to fix the problem that came up um so if  you remember um we had a uh  you know we're given two regular  languages a1 and a2 and we're trying to  show that the concatenation language a1  a2 is also regular  and so the way we you know the way we go  about all of these things is you know we  assume that a1 and a2 are regular so  that means we have machines finite  automata for a1 and a2 we'll call them  m1 and m2  that recognize a1 and a2 respectively  and then what we need to do in order to  show that concatenation is  regular is to make a finite automaton  which recognizes the concat nation  and we tried to do that last time um  so uh if you remember that concatenation  machine m we're calling it  uh what is it supposed to do  it's supposed to accept its input if  it's in the concatenation language and  that means that the input can be split  into two parts x and y  where x is in the a language and y is in  the b line and in the end y is accepted  by m1 and x is accepted by m1 and y's  accepted by m2 sorry garbled that  uh so x should be in a1 and y should be  in a2  um if you can split w that way then m  should accept it so m has to make  figure out if there's some way to split  the input  so that the first machine accepts the  first part the second machine accepts  the second part  and  um the idea that we came up with for  doing that  was to  um  take these two machines  build them in to a a new machine m  and then connect the accepting states  for m to the start state  connect the the accepting states for m1  to the start state for m2  um because the idea would be that if m1  has accepted an initial part you want  then you want to pass control to m2 to  accept the rest  but as we observed that doesn't quite  work because  um the first place to split w  after you found an initial part that's  accepted by m1 may not be the right  place because the remainder may not be  accepted by m2 you might have been  better off waiting until you found  another place that m1 accepted later on  in the stream say over here  and then  uh by splitting it over there then maybe  you do get successfully find that the  remainder is accepted by m2 whereas if  you tried to split it  you know the first place the remainder  wouldn't have been accepted by m2 so all  you need to do you know m has to know is  there someplace to split the input so  that you know you can get both parts  accepted by the respective machines  the problem is is that m might need to  know the future in order to know where  to make the split  and it doesn't have access to the future  so what do we do  um so what we're going to do is  introduce a new concept  that will allow us to  uh basically get the effect of m1  in the sort of being able to see the  future  um and that new concept is going to be  very important for us throughout the  term it's called non-determinism and so  we're going to introduce a new kind of  finite automaton called a  non-deterministic finite automaton and  first we'll look at that and then we'll  see how that fits in with the previous  deterministic finite automaton that we  introduced last time  so here's an example we're always good  to start off with an example  um here is an a picture of a  non-deterministic fine art automaton  looks very similar at first glance to a  to the former kind the deterministic  finite automaton  but if you look a little carefully you  see that there are some key differences  um the most important difference  is that  um  [Music]  the in state q1 for example  whereas in the machines that we  introduced last time  there had to be exactly one way to go on  each possible input symbol so you knew  how to you know how to follow along  through the machine as its computing  here there are two ways to go  in q1 you can either stay in q1 or you  can go to q2  that's the essence of non-determinism  there could be many ways to proceed  um  and furthermore on q1 if you get a b  then there's nowhere to go  so  um that's uh also possible within  non-determinism there could be um so  let's let's just start looking at these  features  there are multiple paths forward but  multiple paths possible you might be  able to have uh one as we had before or  many ways to go at each step or maybe  zero ways to go at each step those are  all legitimate for a non-deterministic  machine which doing a non-deterministic  computation  another difference if you look carefully  is that we're allowing here the empty  string to appear on a transition  that's perhaps a little less uh  essential to the spirit of  non-determinism but it's going to turn  out to be a convenience when we actually  apply non-determinism to build machines  as you'll see very shortly  now if there are many different ways to  go  and  some of those ways to go might have  different outcomes  you know as we remember from before we  accepted the input if you end up in an  accept state  and we rejected the input if you end up  not in an except state in a  non-accepting state then you reject  but now there might be several different  ways to go  um  so and we'll do an example in a minute  but there might be several different  ways to go and they might disagree  some of them might accept other ones  might reject so then what do you do  well in that case  um acceptance always overrules rejection  that's the essence of non-determinism  the way we're def the way we're setting  it up  um you may ask why that is and you know  if um sort of the spirit of that will  become clear in due course but right now  just take it as a rule when we're having  a non-deterministic machine acceptance  overrules rejection  so as long as there is one accepting  copy  one one of the possible ways to go ends  up at an accept we say the whole thing  is accepted  um the only way could possibly reject if  all of the possible ways to go end up at  rejection end up at a non-accept state  so we'll see example we'll i think we're  going to do an example right now yeah so  we take for example um this machine n1  now on an input a b  and we're going to process the symbols  one by one just like we did before  but now to follow along there might be  several different ways to go  so if we take um  the  uh  the first  symbol a  and we run the machine so the machine is  starts at the start state um as before  but now an a comes in and there might be  two now there are two different ways to  go so we're going to keep track of both  of them  after the machine reads an a you can  think of it as think of it as being in  two states now simultaneously it can be  in state q one and it can be in state q  two so those are two different possible  places it could be at this moment  okay  now um now we read the next symbol  the b and from a b you take all of each  of the places where the machine could be  um at the end of the previous symbol  and you then apply  reading a b the next symbol to each of  those uh from each of those states where  the machine could be in uh from the  previous symbol  so the machine could be in q1 and q2  after reading an a now we apply a b well  q one on a b  goes nowhere  so  you think of that uh  a branch  if you will of the computation as just  dying off it has nowhere to go it just  vanishes  however when you're in the the other  possibility which was state q2 on a b  does allow does have a place to go so  that the machine is now going to go from  q2 to q3 um uh  when it re on that branch of the  computation which reading on reading a b  and then  it has  um  [Music]  uh  coming out of q3 there are two symbols  there's an a and an empty string symbol  now on an a the machine would have to  read  an a in order to transition along that  arrow  but on when there's an empty symbol on  the arrow that means the machine can go  along that arrow for free without even  reading anything  as long as it gets to q3 it can  automatically jump to q4  and so  once it has read a b and gone to q3  now  um it it can either stay in q3 or it can  re it can go along the empty transition  and go to q4 so again it is going to be  a non-deterministic step at this point  um  [Music]  the essence of having a empty transition  is that there's going to be  non-determinism that's why we didn't  introduce that  for deterministic automata because  um you don't have to transition along an  empty string transition you can stay  where you are or you can go along the  empty string transition without reading  any input and go over to the next state  which in this case is q4  so let's just see where we are after  reading an a we're in states q1 q2  but now after reading a b we're in  states q3 and q4 as possibilities and  then we and now we're at the end of the  input and we look and see what we got  if any one of the states as  possibilities that we are right now at  the end of the string is an accept state  then we say overall the machine has  accepted  so that corresponds to what we said over  here before accept the input if some  path leads to an accept  so if any way of proceeding  um through these you know  non-deterministic choices will lead you  to an accept then you will say we're  going to accept the input  okay so this input here is accepted  let's do another example suppose we have  the input a a  instead of a b  so a a  you know after the first a as before  we're in states q one and q two as  possibilities  now we read in a again  now the one that's on state q one that  possibility q one possibility after  reading an a it again branches to q1 and  q2  um  so when we know after reading the second  a we're going to be in at least q1 and  q2 now how about the  the state that had been you know on q2  on reading in a  the one from before after reading the  first day you were in q2 now reading the  second a there's nowhere to go so that  one just gets removed  so after reading a a  we remain in states q1 and q2 as  possibilities  neither of those are accept states  so therefore on input a a  the machine rejects  okay  let's just do a couple more and then  i'll ask you to do one  so  we have aba as an input let's see what  happens then so  um we have a  uh  remember after reading a b a b  the machine is in the two states q three  q four as possibilities that's what we  had from from um the first example  so after reading a b we're in states two  three q four now we read another a  the confu the q4  on an a has nowhere to go in fact it has  nowhere to go on any input so no matter  what comes in after you're in state q4  that branch dies  but on q3 which is another one of the  possibilities reading in a um it can  follow along just transition because  that's one of the labels on that  transition is a so you can follow along  just a transition reading in a which is  the last uh  symbol in the string and so now after  aba you are in only state q4  as a possibility but that happens to be  an accept state so the machine accepts  um  okay and now lastly what happens let's  take our final examples uh what happens  if we have a b b  so  you know as you remember before when we  um were after reading a b that was the  first example we were in states q3 q4 as  possibilities now we read a b  well neither of those states have  anywhere to go on a b  so now all  threads all branches of the computation  die off  and at this point the machine is totally  dead it has no no active possibilities  left  so certainly it's going to reject this  input because none of the active states  there are no active states are accepting  states and in fact if you looked at  anything that came later  they would anything that extended the  string a b b would also be rejected  because once the machine had all  all possibilities have died off there's  no way for them to uh come back to life  on any extensions  so with that um  oh here's an important point before i  i'm going to jump to a check-in on you  uh but um  uh i think what one thing that you know  might be on your mind about this  non-determinism is how does how do we  actually what is that how does that  correspond to reality  well it doesn't  um  we're not intending for non-determinism  as we're defining it to correspond to a  physical device  but nevertheless as you'll see it's a  very mathematically useful concept uh  this non-determinism and it's going to  be playing a big role throughout the  subject as will uh  as will experience it during the rest of  the term  so with that uh i'm going to have a  little check in it's going to give i'm  going to ask you to  uh consider what happens on one of the  inputs um so here we go what does it do  on input a a b  so here's the machine you can look at it  and i'm gonna i'm supposed to hopefully  there's a poll here for me to give to  you um  so you can  uh  give me your input  so what does the machine do on input a  a b  most of you have answered  again you're not going to be penalized  for getting the wrong answer  um but  uh  hopefully  you you'll get the right answer  anyway  let's just take a look here uh so time  is up  um let's end the polling  and share the results  so the majority of you majority have  gotten the correct answer which is a the  machine does accept a a b  uh because you know when you have  a  so if you if you like i'll show you the  path that corresponds to accepting you  go a  a  b  and then empty string  and so  that  uh  uh sequence of steps  is one of the non-deterministic  possibilities that the machine can  follow  and that shows that the machine does  accept the input a a b you know you  could think about it the way we did it  before um also you know if you read an a  it's in the two possibilities q one q  two you read a second a again in the  possibilities q one q two now you read a  b  it's into possibilities q three q four  and um that's it  a a b so now you read the b it's in  possibility q three q four q four is an  accepting state that overrules the  non-accepting state and so the machine  accepts  you have to understand this so if you  didn't get it right  go back and think about where you  slipped up  okay because this is um  you know the  you know  this is just getting we're just getting  warmed up  here it's going to get it's going to get  a lot harder  okay so stop sharing the results um  and  so let's continue  so now  we just as we did last time we can  formally uh define a fine  non-deterministic finite automata here's  the picture again um  okay uh so it looks a lot like the the  the case we had before the deterministic  finite automata or dfa as we'll call  them um it's a five tuple so i've sort  of  uh written down little reminders for  what those components of that five tuple  are that list of five uh  five components um  so they're all the same as before  states alphabet  transition function start state and  accepting states so that the formal  definition definition looks exactly the  same except the structure of the  transition function  so now before if you remember you had a  state and an input symbol and you got  back a state  uh now we have something more  complicated looking  we have a state and an input symbol  but it you know it's instead of just  sigma it's sigma sub epsilon and that  that's a shorthand for sigma union  epsilon  and that's a way my way of saying that  you're allowed to have on your  transition um arrows either an input  symbol or an empty string so the  transition function has to tell you what  to do when you have empty string coming  in as well um so that would be part of  your table for the transition function  now over here what's going on over here  well now  instead of just producing a single state  you know when you've read for example an  a  on from q1 there's a whole set of  possibilities  so here we have what's called the power  set  that's the set of  subsets  of the collection queue  so here we're going to produce an entire  subset of states instead of just one  state coming out there might be a subset  of possible states that you can go to  so the power set of q is the set of  subsets of um of q  so  that's what this notation means  um  again this is something that  i'm hopefully presenting to you as a bit  of a reminder you've seen this somewhere  else before but um please make sure you  understand the notation uh going forward  because  we'll we'll be doing less hand-holding  as we start moving forward  um  okay  so just let's take a look at the n1  example here  um just to illustrate the illustrate  what's going on when you're in state q1  reading an a  now you get a whole set of possibilities  which in this case is q1 and q2  um whereas if you're reading a b what  would be that set  coming out of q1 what's the set of  possible successor states  well there are none so it's the empty  set  okay so this is  hopefully your understanding no notation  here so now here's i think really  important  how do we understand non-determinism  intuitively speaking and there are  multiple different ways which each has  their value under different  circumstances  so one way  is  thinking about non-determinism as a kind  of parallelism  so every time the machine has a  non-deterministic choice to make where  there is more than one outcome you think  of the machine as um  [Music]  branching forking  new threads of the parallel computation  at that stage where it makes entire copy  of itself when there's a choice of  possibilities  and then each of those independently  proceeds to read the rest of the input  as separate threads of the computation  so if you're familiar with parallel  computing this should be reasonably  familiar to you the only key thing to  remember is that as this thing forks  number possibilities  the acceptance rule is that if any one  of those possibilities gets to an accept  at the end of the input it raises a flag  and says accept and that overrules  everybody else  so acceptance dominates  so another way of looking at it is the  mathematical view  where you can imagine and we're going to  use all these so it's you really need to  understand them all the mathematical  view  is if you can think of the computation  as kind of a tree of possibilities  so you start off at the very beginning  sort of at the root of the computation  which is that when it really begins but  every time there's a non-deterministic  branching that occurs  um the tree has  [Music]  that note of the tree has  uh multiple children coming out of that  node and so the different threads of the  computation correspond to different  branches of that tree  and now you're going to accept if any  one of those branches leads to an  accepting state  okay very obviously somewhat similar to  what we had before but it's i think it's  a little bit of a different perspective  on what not how to think about  non-determinism  and the last one is going to sound a  little weird  but actually i think  for people who are  in the business  it's the one they use the most  and that's the magical way of thinking  about non-determinism  and that is  um  when the machine has non-deterministic  choices to make  you think of the machine as magically  guessing the correct one at every stage  and the correct one being the one that  will eventually lead to accept  okay so you can think of the machine as  guessing  which is the right way to go  and if there is some way right way to go  it always guesses right of course if the  machine ends up rejecting because there  is no right way to go then it doesn't  matter there is no good guess  but if there is some good guess we'll  think of the machine as taking that good  guess and going that way  okay  so  um  now here is very important thing we  introduced this new model  uh the uh the non-deterministic  foundation nfa  it turns out to be  even though it looks more powerful  because has this non-determinism it  isn't any more powerful it can do  exactly the same class of languages the  regular languages and we'll show that  um with the theorem here that if an nfi  and  if an nfa recognizes a then a is regular  um  [Music]  so  um  we'll prove that by showing how to  convert an nfa to an equivalent dfa  which does the same language so we can  take an nfa that has a non-determinism  and find another dfa which doesn't have  non-determinism but does the same  language it accepts exactly the same  strengths  even though it lacks that  non-deterministic capability  it's this is going to be extremely  useful by the way and for example in  showing that closure under concatenation  okay  so  uh you know in this  presentation here i'm going to ignore  the epsilon transitions because once you  get the idea for how to do this you  could figure out how to incorporate them  they just make things a little more  complicated so let's just focus on the  key aspect of non-determinism which is  that the machine could have several ways  to go at any point in time  there could be several next states  on an input  okay  now the idea for the construction so  we're going to take we're going to start  with a non-deterministic machine m  and we're going to build a deterministic  machine m prime which does exactly the  same thing  and the way m prime works is it's going  to do what you would do  if you were simulating m  what would you do with me this is what  we were doing as we were as i was  explaining it to to you  if you are simulating m every time you  get an input symbol you just keep track  of what is the set of possible states at  that point in time  that's what the dfa is going to do  it's going to have  uh  it's going to have to keep track  of which possible set of states the nfa  could be in  at the  point on that input where we are right  now  and then  as you get the next symbol  the dfa is going to have to update  things to keep track of the next set of  states the nfa could be in at this point  just like you would do  okay and so  um  so here's a kind of a picture  um  and  how do we implement that in in so here's  the nfa that we're starting with m and  we're going to make here the dfa  but um  in order to remember  which set of states that dfa could be in  at a given point so maybe it's the set  of states that it that m could be in  did i say that wrong which set of states  the nfa could be at a given time so  maybe m the nfa could be in  at some point state q3 and q7  the way the dfa keeps track of that it's  going to have a state for every possible  subset of states  of the nfa  that's how it re remembers which subset  of states the nfa is in that's the way  dfas work they have a separate state for  each possibility that they need to keep  track of  and the possibilities here are the  different subsets of states that the nfa  could be in at a given point  okay so  corresponding to this subset to these  two possibilities q three q seven the  dfa is going to have the sub a state  with the subset q3 q7 and it's going to  for every possible subset here there's  going to be a different state of m prime  so n prime is going to be bigger  um  okay so  quickly the construction of m the states  of m prime now um q prime  are going to be the power set  the set of subsets of states  uh from the original machine m  um  and uh  the  uh now we have to look at how the  transition function of the dfa when you  make the primed machines are the dfas as  a dfa machine so these are the prime the  the deterministic component so  delta prime  um when it when it has a subset  that  you know  something like this  um has a has one of its states which  corresponds to a subset of states of m  and it reads an input symbol you just  have to do the updating the way you  would naturally do you're going to look  at every state in r  look at where that can go under a so  there's a bunch of sets there and look  at all the possible  states that could be in one of those  subsets and that's the set of states  that you you could be in that's going to  be the new set of states and that's  going to be the new state of m prime  okay so it's going to be the subset  corresponding to  all of the states that could be in  uh when you apply the transition  function of the non-deterministic  machine um to one of the states in that  in the subset of states that the not a  terminus machine could be in  okay  it's a little bit of a mouthful you know  you you could  i suggest you look at this if you didn't  quite get it after the fact  good to understand  the starting state for the nfa  for the dfa i'm sorry is going to be  which subset now we're going to start  off with it's going to be the subset  corresponding to just the start state  of um  uh of  of m  um  and the accepting states are going to be  uh of the deterministic machine are  going to be all of the subsets that have  at least one accepting state from the  nfa  so i hope you got that because i'm going  to be another little check in here um  which is i'm going to ask you how big is  m prime how many states does n prime  have uh i told you what those states are  so just go think about that um  so check in two if m has n states how  many states does m prime have by this  construction  okay so let's launch the next poll  um  okay  five seconds and i think we're almost  done here  good  all right share results  i know if sharing results is a good  thing i'm not trying to make you if you  didn't get the right answer um because  most of the people did get the right  answer we didn't get the right answer  trying to make you feel bad but i do  think you should it's a little bit of  suggestion you know that you you need to  review some basic concepts so the basic  concept here is if you have a collection  you have a set of states how many  subsets  are there and the number of subsets is  going to be exponential  so if you have a collection of n  elements the number of subsets of those  n elements is 2 to the n  um that's the fact we're using here and  that's why  m prime has two to the n states if m had  n states  um and that's you know you should make  sure you understand why that is  all right  so um with that um  as requested we're gonna have a little  break  um  and that break is going to last us  exactly  five minutes  so we'll we will return in five minutes  i'm going to be prompt so i give you a  little timer here so please  um  uh  i'm gonna  begin it write it right right when this  is over  okay  almost almost ready  i hope you're all refreshed  and ready for the second half  so now now that we have non-determinism  we're going to use uh that as a tool to  prove the uh closure properties that we  were aiming for for um starting from  last lecture  okay um  so remember  we  let's look at closure under a union now  we already did that  but i'm going to do it again  but this time using non-determinism and  you'll see how powerful  non-determinate non-determinism  now determinism is because it's going to  allow us to do it kind of  almost  with no effort  we'll start off the way we did before  i'm going to start off with two  dfas  but actually these could be um nfas even  but let's say we started with the two  dfas for the two languages a1 and a2 and  we're going to construct the nfa rec now  we're going to construct an nfa  recognizing the union  um and that's good enough because we  already know that we can convert nfas to  dfas and therefore they do they do  regulate languages too  um  okay  so now here are the two  dfas that do the languages a1 and a2  and what i'm going to do is i'm going to  put them together into a bag of states  um which is going to be m  the  nfa  that's going to do the union language so  remember what does what does  m supposed to do m is supposed to accept  its input if either m1 or m2 accept so  how is it going to do that what it's  going to do we're going to add a new  state  to m  which is going to branch under epsilon  transitions and now you can start to see  how useful these epsilon transitions are  going to be for us going to branch under  epsilon transitions to the two original  start states of m1 and m2 and we're done  y  well now  non-deterministically as we get an input  w coming in to m  um m at the very beginning even just  right after it gets going the very first  thing that happens is it's going to  branch to m1 and also branch to m2  non-deterministically as two  possibilities  and then inside m1 and m2 it's going to  actually start reading the input and  each one is going to be now following  along  as it would have originally  uh  the  states corresponding to um reading those  input symbols  um and  m  as a combination of m1 and m2 is going  to have a possibility for e for one  state in m1 and once one stated m2  um  and so m is going to have those combined  into one in  into one  um package and now if either at the end  of the input if either  um of these end up at an accepting state  then m  [Music]  um  is going to accept as a  non-deterministic fighter automaton  because that's how non-determinism works  you accept if either if any one of the  branches ended up accepting which is  just what you need for non-determinate  for union  so we're doing you and we want either  one of these to be accepting and then  the non-determinism just is built  conveniently to allow us to do the union  almost you know  for free  um  so you can again thinking about  non-determinism as terms of parallelism  you could think of it the  non-deterministic machine is running in  parallel m1 and m2 on the input  and if either one of them ends up  accepting m will accept  or you can think about it in terms of  that guessing that i referred to before  which means that  as m is getting when it's just about to  read these the first symbols of its  input it guesses  whether um that's going to be an input  accepted by m1 or an input accepted by  m2 and the magic of non-determinism is  that it always guesses right  so that input happens to be some an  input that's going to be wrecked you're  going to be accepted by m2  m is going to guess that  m2 is the right way to follow and it's  going to go in the m2 direction  um because non-determinism the magic is  you always guess right  wish that was true in real life  uh would make exams a lot easier um  anyway so  now let's see how we can use that to do  closure under concatenation  okay so now um we're gonna actually have  a picture very similar to the one we had  originally but now using non-determinism  we can make it work  so here we have the two machines doing  the two  languages a1 and a2  and we're going to combine them into one  bigger machine m  as shown  remember what m is supposed to do is  accept its input if there's some way of  splitting that input such that the first  half is accepted by the m1 and the  second part is accepted by m2  way we're going to get that effect  is by  um  putting in  a uh  transit empty  empty transitions epsilon transitions  going from the starts for the except  states of m1 to the start state of m2  just as i've shown here in this diagram  so these were the original accepting  states of m1  and now  um they're going to be declassified as  accepting states but they're going to  have new transitions empty transitions  um  attached to them which allow them to  branch to m2 without reading any input  and so intuitively speaking this is  going to do the right thing  because once m1 has accepted  some  part of w  then you can  non-deterministically  branch to  m2  and um  and you're going to be start processing  inside m2  and the the point is as i kind of uh  jumped ahead of myself um is that the  reason why it fixes the problem we had  before  is that the epsilon transitions are  don't machine does not have to take them  it can  stay where it is  as one non-deterministic option or it  can move along the epsilon transition  without reading any input as another  non-deterministic option  so it's using this non-determinism now  to both  stay in m1 to continue reading more of  the input and to jump into m2 to start  processing what might be the second half  or the second part of the input which m2  accepts  and you can think of it in terms of the  guessing is that the machine is guessing  where to make that split  once it found an initial part that's  accepted by m1 it guesses that this is  the right split point and that passes to  m2 but there might be other guesses that  it could make  you know corresponding to other  possibilities  and so  with non-determinism it always guesses  right if there is some way to split the  string into two parts  uh accepted by m1 and m2 the machine  will make that good guess  and  then  m1 will accept the first part and m2  will accept us with the second part and  we'll get m accepting that whole uh  string uh altogether and so that is the  uh solution um to our uh puzzle for how  do we do closure under concatenation  okay i hope that came through because  this is um this is you know we're just  getting going with non-determinism we're  going to be using non-determinism a lot  and you it's going to you're going to  need to get very comfortable with it  okay um  now let's do closure under star  um  and closure under star  works uh very similarly  but now we're just gonna have a single  language if a is regular so is a star so  they're not a pair of languages because  a star is a urinary operation  applying to just a single uh  language  so if we have a dfa recognizing a in  order to show that a star is regular we  have to construct a machine that  recognizes a star and a machine we're  going to construct is as before and then  an nfa  okay  so um  here is m  uh the dfa for a  and we're going to build an nfa m prime  that recognizes a star  and let's think now what does it mean to  recognize a star  so when should m you know if i'm going  to give you an input when is it in the  star language what does m prime have to  do  um so m remember what star is star means  you can take as many copies of you lot  as you like of strings in the original  language and that's in the star language  so to determine if something's in the  star language you have to see can i  break it up into pieces which are all in  the original language  um  [Music]  so  uh  um  so you want to see can i take my input  w and cut it up into a bunch of pieces  four in this case um where each of those  pieces are members of a they're members  of the original language so that's what  that's what m prime's job is  it's getting it has its input and wants  to know can i cut that input up into  pieces each of which are accepted by the  original machine  m  that's what m prime does  and if you think about it you know um  a little bit  really what's happening is that as soon  as  m  so you know m prime is going to be  simulating m that's why i like to think  about this as having m inside so you  know you're going to if you were going  to be doing this yourself you're going  to take w you're going to run it for a  while you'll see oh m is accepted  now i have to start m over again  to see if it accepts  uh on the next segment  so every time m accepts you're going to  restart m to see if it accepts another  segment and so you by doing that you're  going to be cutting w up into different  segments which are each of which is  accepted by m  of course  it's never totally clear  whether you should  and for any given segment you should cut  it there or you should wait a little  longer and find another play a later  place to cut but that's exactly the same  problem that we had before with  concatenation  and  we saw that using non-determinism and  we're going to solve it again using  non-determinism  so the way we're going to get that  effect of starting the machine over  again once once it's accepted is by  adding in  epsilon transitions that go from the  start states back to the  from the accept state back to the start  state  so now every time  m has accepted it has an option not not  a requirement but it has an option it  can either stay continuing to process  or it can restart  making a cut at that point and  trying to  see if there's a yet a different a  second another segment of the input  that's going to be ex that it's going to  accept  and this is basically the whole thing  with one little  um  problem  that we need to deal with  and that is  we need to make sure  um that m prime  accepts the empty string because  remember the x empty string is always a  member of the  starred language  and as it's as it's  written right now  we're going to be requiring there to be  at least one copy  of one at least one segment we're not  taking into account the possibility of  no segments which is the empty string  and the way we're going to get that  is well i mean  one thing  one way to get to it  so you know we're missing the empty  string right now so how do we fix it  basically you know we're just going to  take the construction we have  get uh you know on on the screen and  we're going to uh  adjust it to to add in the empty string  because it's possibly missing  one way to do that  which is tempting but  wrong  is to  make the start state of m an accepting  state for m prime  so we could have and we could have made  this an uh an accepting state too  and now m prime is also going to accept  the empty string that's the good news  the problem is that  the start state might be playing some  other role  in m besides just being the start there  might be times when m comes back to the  start state  you know later on  and if we make the start state the  accept and accept state it's going to  suddenly start accepting a bunch of  other things too which might not be  intended  so it's a bad idea to make the start  state and accept state  instead we'll take the simples uh  solution alternative of adding a new  start state  which will never be returned to under  any circumstances and make that a new  start and accept state as well so here  we'll have to make this additional  modification  so as i'm saying this is what we need to  do and we will do that  is by adding a new start state which is  also an accept state to make sure it  accepts the empty string  and then that also can branch  um to start off m  as before  um if the string that's input is not the  empty string and so then m you know we m  prime is actually going to have to do  some work to see if it can be cut up as  it was going as it was doing before  um so  that's  the proof of closure under star i'm not  going to do it anything beyond what i've  just described these proofs by picture  are convincing enough i hope um  and if not you know you should they are  explained in somewhat more detail  somewhat more formally in the textbook  but uh for the lecture this is where i'm  going to stop with these these two  arguments  um and so now uh oh yeah one uh quick  check in on this  so if m has n states  how many states does m prime have by  this construction  um so let's do  really these are  i'm not intending these to be very hard  more just to keep you awake  uh  so  how many  states does  m prime have  okay  maybe a little too easy even for a  check-in  yeah everybody's getting this one um  because all you did was we added one new  state um so the answer is as you have um  i think should pretty much everybody is  uh observing that it's just the um  it's number b um so i'm gonna end the  polling  i'm gonna share the results  and everybody got that one and so let's  continue on  um  and uh  so um  the very last thing we're going to do  today and show you how to convert  regular expressions  to nfas  thereby showing that every language that  you can describe with a regular  expression is a regular language  on tuesday we'll show how to do the  conversion in the other direction and  show thereby showing that these two  um  methods of describing languages are  equivalent to one another so here is our  theorem if r is or is a regular  expression and a is the language is  instead of strings that like that  regular expression describes then a is  regular  okay  um  so um we're going to show how to convert  [Music]  the the strategy is to convert r to an  equivalent nfam  and  so we have to think about remember these  regular expressions uh that we  introduced last time these are these  expressions that look like um you know a  b union b star something like that  um so built up out of the regular  operations from um  from the from the primitive regular  expressions that don't have any  operations that we're calling atomic  so if r is an atomic regular expression  it just looks like  either just a single symbol or an empty  string symbol or a  an empty language symbol  [Music]  or  r can be  a composite regular expression um  whoops  we're having a little  yeah so  so we have two possibilities here um r  is either atomic or composite  and so let's look at what the equivalent  expression is um in each case  so if r is just the single letter  regular expression that's a totally  legitimate regular expression just a  regular expression  one  so that just describes the language of  the string one  so we have to make a an nfa  which accepts which recognizes just that  language accepts only the string one  so it's a very simple nfa  it just starts uh in the start state and  on that single symbol it branches to an  accept state and there were no other  transitions allowed so if you get  anything else coming in besides that one  that that string which is just that one  symbol  the nfa is going to reject it  like if it goes if it's too long if if  you know if it gets a a coming in well  there's nowhere to go on from this um  accepting state on an a so the machine  is just going to die  it has to be in an accept state at the  end of the input  um how about you know why don't you  think for yourself for a minute how do  we make an nfa which  uh accepts only the empty string and no  other strings  you can do that with just one state with  an nfa  just this one here  um the machine is going to start off in  the start state which is also  immediately an accept state so it  accepts the empty string  but if anything else comes in there's  nowhere to go when the machine does  so this machine accepts just the empty  string or its language is the language  with one element the empty string  how about the empty language  well here's a here's an nfa which  has no accepting state so it can't be  accepting anything  now if we have a composite regular  expression  we're already finished because we showed  how to build up  we showed constructions which uh give us  closure under union  uh concatenation and star and those  constructions are going to enable us to  build up  uh the  nfas  that do  the language of these more complex  regular expressions built up out of the  anaphase that do the individual parts  so if we already have anaphase that do  r1 and r2  then  the closure under union construction  gives us an nfa that does  r1 union r2  as a language  so i'm going to do  i hope that's clear but i'm going to do  an example which will help hopefully  illustrate it and it's going to show you  you know basically what i'm giving you  is an automatic procedure for converting  a regular expression into an equivalent  nfa  so let's just see if  that that procedure in opera in action  which is really just following this  recipe that i described for you so here  is a regular expression a union a b  star  so this is a regular expression  it's some language whatever it is i  don't care  but i want to make an nfa which  recognizes that same language  and the way i'm going to do that is  first build nfa for the  [Music]  components um  the sub-expressions of this regular  expression  and then combine them using our closure  constructions  to be  um  to be anaphase for larger and larger  sub-expressions until i get the n of a  that's the equivalent of the entire  expression so let's just see how that  goes so the the very most primitive  parts the the the smallest  sub-expressions here are just the  expressions for a and for b  so here's the one for a just  just for a  so this is the nfa which um  recognizes the language which is just  the one string a  here's the nfa for the just whose  language is just the one string b  um  and now  i want an nfa which is  which accepts only the string a b  now of course you could just do that by  hand  um yourself it's simple enough but what  i'm arguing is that you we can do this  automatically  using the closure construction for  concatenation because really there's an  there's a hidden concatenate  concatenation symbol this is the the you  know a concatenate b  so now for a b  i'm going to take  um the the thing from a  and the part from b  so these these two things that i had  from before  and use the concatenation construction  to combine them  you see that so now i have automatically  a an nfa which does the language whose  string is just a b  th just the a b string  and  it's not the simplest nfa you can make a  simpler one but the virtue of this one  is that i got it automatically  just by following the closure  construction so now i'm going to do a  more complex one just the inside here a  union a b  um  so the way i'm going to build that is  from the two parts the a part and the a  b part  you know the a part and the a b part  so here is the a part  here's the a b part a b part i've  already got those from before it's  really kind of a proof by induction here  but you know i think it's simple enough  we don't have to use that language um  so we have  um  you know the a part the a b part and now  we are going to apply the  uh  the  closure under union construction to  combine those into one machine and  remember how that worked  we add a new symbol here which branches  under empty string to the previous  uh  i'm adding a new start state which  branches to the original start states  under empty empty transition and now  this is a an nfa for this language a  union a b  and lastly now we're one step away from  getting uh the star of this  and how we're going to do that  we're going to take this thing here and  apply the construction for the star  closure  and that's going to be an nfa which does  a union a b star which is what we wanted  in the first place  so  first we're going to  bring that one down because we've  already built that one and now remember  how we built um the  uh closure under star  we made this the accepting states return  back to the um the start state and we  added a new start state to make sure we  got the empty string in there  that transitioned to the original star  state under epsilon  okay so that's all  um i wanted to say for today's lecture  let's do a quick review  um  we  very important concept non-determinism  and and non-deterministic finite  automata we proved their equivalent in  power  uh  showed the class of regular languages  closed under concatenation and star we  showed how to do conversion of regular  expressions to nfas  so um i think that is it for  today's lecture and um  thank you all for being here  let me i'll try to answer a few of these  why does concatenation have order well  because it's an ordered construction  um  is there a simple way to prove closure  under concatenation without using  non-determinism no  um  why are the empty strings at the accept  state can't they be at any state  doesn't star make copies of any part of  the input no it's only you have to  you have to think about what's going on  having you you don't want to you have to  branch back to the beginning only on an  accept because that means you found a  piece that's in the original language um  is there an automaton that can add some  some or subtract  memory automata  well  depends on what you mean by all that but  um  certainly there are more powerful  machines that we're going to study than  find out automata um so  um  but yes there is um and even finite  automata can add and subtract if you  present the input in the right way i re  refer you to the first problem on the  homework um  so i think i'm gonna  uh check out then um  take care everybody bye  you

2
00:00:26,470 --> 00:00:28,470
hi folks  um why don't we get started  um  welcome back  good to see you  you all here  so um  i am going to  first  we'll  we'll recap what we did last time and  what we're going to do today i'll talk a  little bit about the problem set  and we'll also have a break as requested  halfway through  so why don't we jump in um what we did  last time um was we introduced finite  besides introduce introducing the course  we introduced finite automata and  regular languages which are the  languages that the finite automata can  recognize  we talked about these regular operations  um and the and then building um those  those allow us to build what we call our  regular expressions these are  ways of describing languages so find we  have finite automata can describe  languages and regular expressions can  describe languages and one of our goals  is to show that those two systems are  equivalent to one another even though  they look rather different um at first  glance  so um to  move in that direction we first  proved uh we're going to prove closure  properties for all of the  for the class of regular languages over  these regular operations so we'll show  that  well we already showed that any two  regular languages have their union also  being regular and we'll show that for  the other two operations as well so  let's just look ahead to what we're  going to do today  we're going to introduce an important  concept which is going to be a theme  throughout the course called  non-determinism  and we  uh  having that as a tool  that we can use will be able to show  closure under concatenation and star  finishing up what we started to do last  time  and then we'll use those closure  constructions to show how to convert  regular expressions to finite finite  automata  um and that's going to be halfway to our  goal of showing that the  two systems are equivalent to one one  another and the following lecture we  will show how to do the conversion in  the other direction  so i thought we would just jump in then  and look at um return to the material of  the course  um as you remember  we were  looking at the closure properties for  the class of regular languages  um we started doing that um and if you  recall hopefully uh we did closure under  union and then we tried to do closure  under concatenation um which i have  shown here  um on the slide um you know the what the  proof attempt  that we tried to do last time and let's  just review that quickly because i think  that's going to be uh helpful to see how  to fix the problem that came up um so if  you remember um we had a uh  you know we're given two regular  languages a1 and a2 and we're trying to  show that the concatenation language a1  a2 is also regular  and so the way we you know the way we go  about all of these things is you know we  assume that a1 and a2 are regular so  that means we have machines finite  automata for a1 and a2 we'll call them  m1 and m2  that recognize a1 and a2 respectively  and then what we need to do in order to  show that concatenation is  regular is to make a finite automaton  which recognizes the concat nation  and we tried to do that last time um  so uh if you remember that concatenation  machine m we're calling it  uh what is it supposed to do  it's supposed to accept its input if  it's in the concatenation language and  that means that the input can be split  into two parts x and y  where x is in the a language and y is in  the b line and in the end y is accepted  by m1 and x is accepted by m1 and y's  accepted by m2 sorry garbled that  uh so x should be in a1 and y should be  in a2  um if you can split w that way then m  should accept it so m has to make  figure out if there's some way to split  the input  so that the first machine accepts the  first part the second machine accepts  the second part  and  um the idea that we came up with for  doing that  was to  um  take these two machines  build them in to a a new machine m  and then connect the accepting states  for m to the start state  connect the the accepting states for m1  to the start state for m2  um because the idea would be that if m1  has accepted an initial part you want  then you want to pass control to m2 to  accept the rest  but as we observed that doesn't quite  work because  um the first place to split w  after you found an initial part that's  accepted by m1 may not be the right  place because the remainder may not be  accepted by m2 you might have been  better off waiting until you found  another place that m1 accepted later on  in the stream say over here  and then  uh by splitting it over there then maybe  you do get successfully find that the  remainder is accepted by m2 whereas if  you tried to split it  you know the first place the remainder  wouldn't have been accepted by m2 so all  you need to do you know m has to know is  there someplace to split the input so  that you know you can get both parts  accepted by the respective machines  the problem is is that m might need to  know the future in order to know where  to make the split  and it doesn't have access to the future  so what do we do  um so what we're going to do is  introduce a new concept  that will allow us to  uh basically get the effect of m1  in the sort of being able to see the  future  um and that new concept is going to be  very important for us throughout the  term it's called non-determinism and so  we're going to introduce a new kind of  finite automaton called a  non-deterministic finite automaton and  first we'll look at that and then we'll  see how that fits in with the previous  deterministic finite automaton that we  introduced last time  so here's an example we're always good  to start off with an example  um here is an a picture of a  non-deterministic fine art automaton  looks very similar at first glance to a  to the former kind the deterministic  finite automaton  but if you look a little carefully you  see that there are some key differences  um the most important difference  is that  um  [Music]  the in state q1 for example  whereas in the machines that we  introduced last time  there had to be exactly one way to go on  each possible input symbol so you knew  how to you know how to follow along  through the machine as its computing  here there are two ways to go  in q1 you can either stay in q1 or you  can go to q2  that's the essence of non-determinism  there could be many ways to proceed  um  and furthermore on q1 if you get a b  then there's nowhere to go  so  um that's uh also possible within  non-determinism there could be um so  let's let's just start looking at these  features  there are multiple paths forward but  multiple paths possible you might be  able to have uh one as we had before or  many ways to go at each step or maybe  zero ways to go at each step those are  all legitimate for a non-deterministic  machine which doing a non-deterministic  computation  another difference if you look carefully  is that we're allowing here the empty  string to appear on a transition  that's perhaps a little less uh  essential to the spirit of  non-determinism but it's going to turn  out to be a convenience when we actually  apply non-determinism to build machines  as you'll see very shortly  now if there are many different ways to  go  and  some of those ways to go might have  different outcomes  you know as we remember from before we  accepted the input if you end up in an  accept state  and we rejected the input if you end up  not in an except state in a  non-accepting state then you reject  but now there might be several different  ways to go  um  so and we'll do an example in a minute  but there might be several different  ways to go and they might disagree  some of them might accept other ones  might reject so then what do you do  well in that case  um acceptance always overrules rejection  that's the essence of non-determinism  the way we're def the way we're setting  it up  um you may ask why that is and you know  if um sort of the spirit of that will  become clear in due course but right now  just take it as a rule when we're having  a non-deterministic machine acceptance  overrules rejection  so as long as there is one accepting  copy  one one of the possible ways to go ends  up at an accept we say the whole thing  is accepted  um the only way could possibly reject if  all of the possible ways to go end up at  rejection end up at a non-accept state  so we'll see example we'll i think we're  going to do an example right now yeah so  we take for example um this machine n1  now on an input a b  and we're going to process the symbols  one by one just like we did before  but now to follow along there might be  several different ways to go  so if we take um  the  uh  the first  symbol a  and we run the machine so the machine is  starts at the start state um as before  but now an a comes in and there might be  two now there are two different ways to  go so we're going to keep track of both  of them  after the machine reads an a you can  think of it as think of it as being in  two states now simultaneously it can be  in state q one and it can be in state q  two so those are two different possible  places it could be at this moment  okay  now um now we read the next symbol  the b and from a b you take all of each  of the places where the machine could be  um at the end of the previous symbol  and you then apply  reading a b the next symbol to each of  those uh from each of those states where  the machine could be in uh from the  previous symbol  so the machine could be in q1 and q2  after reading an a now we apply a b well  q one on a b  goes nowhere  so  you think of that uh  a branch  if you will of the computation as just  dying off it has nowhere to go it just  vanishes  however when you're in the the other  possibility which was state q2 on a b  does allow does have a place to go so  that the machine is now going to go from  q2 to q3 um uh  when it re on that branch of the  computation which reading on reading a b  and then  it has  um  [Music]  uh  coming out of q3 there are two symbols  there's an a and an empty string symbol  now on an a the machine would have to  read  an a in order to transition along that  arrow  but on when there's an empty symbol on  the arrow that means the machine can go  along that arrow for free without even  reading anything  as long as it gets to q3 it can  automatically jump to q4  and so  once it has read a b and gone to q3  now  um it it can either stay in q3 or it can  re it can go along the empty transition  and go to q4 so again it is going to be  a non-deterministic step at this point  um  [Music]  the essence of having a empty transition  is that there's going to be  non-determinism that's why we didn't  introduce that  for deterministic automata because  um you don't have to transition along an  empty string transition you can stay  where you are or you can go along the  empty string transition without reading  any input and go over to the next state  which in this case is q4  so let's just see where we are after  reading an a we're in states q1 q2  but now after reading a b we're in  states q3 and q4 as possibilities and  then we and now we're at the end of the  input and we look and see what we got  if any one of the states as  possibilities that we are right now at  the end of the string is an accept state  then we say overall the machine has  accepted  so that corresponds to what we said over  here before accept the input if some  path leads to an accept  so if any way of proceeding  um through these you know  non-deterministic choices will lead you  to an accept then you will say we're  going to accept the input  okay so this input here is accepted  let's do another example suppose we have  the input a a  instead of a b  so a a  you know after the first a as before  we're in states q one and q two as  possibilities  now we read in a again  now the one that's on state q one that  possibility q one possibility after  reading an a it again branches to q1 and  q2  um  so when we know after reading the second  a we're going to be in at least q1 and  q2 now how about the  the state that had been you know on q2  on reading in a  the one from before after reading the  first day you were in q2 now reading the  second a there's nowhere to go so that  one just gets removed  so after reading a a  we remain in states q1 and q2 as  possibilities  neither of those are accept states  so therefore on input a a  the machine rejects  okay  let's just do a couple more and then  i'll ask you to do one  so  we have aba as an input let's see what  happens then so  um we have a  uh  remember after reading a b a b  the machine is in the two states q three  q four as possibilities that's what we  had from from um the first example  so after reading a b we're in states two  three q four now we read another a  the confu the q4  on an a has nowhere to go in fact it has  nowhere to go on any input so no matter  what comes in after you're in state q4  that branch dies  but on q3 which is another one of the  possibilities reading in a um it can  follow along just transition because  that's one of the labels on that  transition is a so you can follow along  just a transition reading in a which is  the last uh  symbol in the string and so now after  aba you are in only state q4  as a possibility but that happens to be  an accept state so the machine accepts  um  okay and now lastly what happens let's  take our final examples uh what happens  if we have a b b  so  you know as you remember before when we  um were after reading a b that was the  first example we were in states q3 q4 as  possibilities now we read a b  well neither of those states have  anywhere to go on a b  so now all  threads all branches of the computation  die off  and at this point the machine is totally  dead it has no no active possibilities  left  so certainly it's going to reject this  input because none of the active states  there are no active states are accepting  states and in fact if you looked at  anything that came later  they would anything that extended the  string a b b would also be rejected  because once the machine had all  all possibilities have died off there's  no way for them to uh come back to life  on any extensions  so with that um  oh here's an important point before i  i'm going to jump to a check-in on you  uh but um  uh i think what one thing that you know  might be on your mind about this  non-determinism is how does how do we  actually what is that how does that  correspond to reality  well it doesn't  um  we're not intending for non-determinism  as we're defining it to correspond to a  physical device  but nevertheless as you'll see it's a  very mathematically useful concept uh  this non-determinism and it's going to  be playing a big role throughout the  subject as will uh  as will experience it during the rest of  the term  so with that uh i'm going to have a  little check in it's going to give i'm  going to ask you to  uh consider what happens on one of the  inputs um so here we go what does it do  on input a a b  so here's the machine you can look at it  and i'm gonna i'm supposed to hopefully  there's a poll here for me to give to  you um  so you can  uh  give me your input  so what does the machine do on input a  a b  most of you have answered  again you're not going to be penalized  for getting the wrong answer  um but  uh  hopefully  you you'll get the right answer  anyway  let's just take a look here uh so time  is up  um let's end the polling  and share the results  so the majority of you majority have  gotten the correct answer which is a the  machine does accept a a b  uh because you know when you have  a  so if you if you like i'll show you the  path that corresponds to accepting you  go a  a  b  and then empty string  and so  that  uh  uh sequence of steps  is one of the non-deterministic  possibilities that the machine can  follow  and that shows that the machine does  accept the input a a b you know you  could think about it the way we did it  before um also you know if you read an a  it's in the two possibilities q one q  two you read a second a again in the  possibilities q one q two now you read a  b  it's into possibilities q three q four  and um that's it  a a b so now you read the b it's in  possibility q three q four q four is an  accepting state that overrules the  non-accepting state and so the machine  accepts  you have to understand this so if you  didn't get it right  go back and think about where you  slipped up  okay because this is um  you know the  you know  this is just getting we're just getting  warmed up  here it's going to get it's going to get  a lot harder  okay so stop sharing the results um  and  so let's continue  so now  we just as we did last time we can  formally uh define a fine  non-deterministic finite automata here's  the picture again um  okay uh so it looks a lot like the the  the case we had before the deterministic  finite automata or dfa as we'll call  them um it's a five tuple so i've sort  of  uh written down little reminders for  what those components of that five tuple  are that list of five uh  five components um  so they're all the same as before  states alphabet  transition function start state and  accepting states so that the formal  definition definition looks exactly the  same except the structure of the  transition function  so now before if you remember you had a  state and an input symbol and you got  back a state  uh now we have something more  complicated looking  we have a state and an input symbol  but it you know it's instead of just  sigma it's sigma sub epsilon and that  that's a shorthand for sigma union  epsilon  and that's a way my way of saying that  you're allowed to have on your  transition um arrows either an input  symbol or an empty string so the  transition function has to tell you what  to do when you have empty string coming  in as well um so that would be part of  your table for the transition function  now over here what's going on over here  well now  instead of just producing a single state  you know when you've read for example an  a  on from q1 there's a whole set of  possibilities  so here we have what's called the power  set  that's the set of  subsets  of the collection queue  so here we're going to produce an entire  subset of states instead of just one  state coming out there might be a subset  of possible states that you can go to  so the power set of q is the set of  subsets of um of q  so  that's what this notation means  um  again this is something that  i'm hopefully presenting to you as a bit  of a reminder you've seen this somewhere  else before but um please make sure you  understand the notation uh going forward  because  we'll we'll be doing less hand-holding  as we start moving forward  um  okay  so just let's take a look at the n1  example here  um just to illustrate the illustrate  what's going on when you're in state q1  reading an a  now you get a whole set of possibilities  which in this case is q1 and q2  um whereas if you're reading a b what  would be that set  coming out of q1 what's the set of  possible successor states  well there are none so it's the empty  set  okay so this is  hopefully your understanding no notation  here so now here's i think really  important  how do we understand non-determinism  intuitively speaking and there are  multiple different ways which each has  their value under different  circumstances  so one way  is  thinking about non-determinism as a kind  of parallelism  so every time the machine has a  non-deterministic choice to make where  there is more than one outcome you think  of the machine as um  [Music]  branching forking  new threads of the parallel computation  at that stage where it makes entire copy  of itself when there's a choice of  possibilities  and then each of those independently  proceeds to read the rest of the input  as separate threads of the computation  so if you're familiar with parallel  computing this should be reasonably  familiar to you the only key thing to  remember is that as this thing forks  number possibilities  the acceptance rule is that if any one  of those possibilities gets to an accept  at the end of the input it raises a flag  and says accept and that overrules  everybody else  so acceptance dominates  so another way of looking at it is the  mathematical view  where you can imagine and we're going to  use all these so it's you really need to  understand them all the mathematical  view  is if you can think of the computation  as kind of a tree of possibilities  so you start off at the very beginning  sort of at the root of the computation  which is that when it really begins but  every time there's a non-deterministic  branching that occurs  um the tree has  [Music]  that note of the tree has  uh multiple children coming out of that  node and so the different threads of the  computation correspond to different  branches of that tree  and now you're going to accept if any  one of those branches leads to an  accepting state  okay very obviously somewhat similar to  what we had before but it's i think it's  a little bit of a different perspective  on what not how to think about  non-determinism  and the last one is going to sound a  little weird  but actually i think  for people who are  in the business  it's the one they use the most  and that's the magical way of thinking  about non-determinism  and that is  um  when the machine has non-deterministic  choices to make  you think of the machine as magically  guessing the correct one at every stage  and the correct one being the one that  will eventually lead to accept  okay so you can think of the machine as  guessing  which is the right way to go  and if there is some way right way to go  it always guesses right of course if the  machine ends up rejecting because there  is no right way to go then it doesn't  matter there is no good guess  but if there is some good guess we'll  think of the machine as taking that good  guess and going that way  okay  so  um  now here is very important thing we  introduced this new model  uh the uh the non-deterministic  foundation nfa  it turns out to be  even though it looks more powerful  because has this non-determinism it  isn't any more powerful it can do  exactly the same class of languages the  regular languages and we'll show that  um with the theorem here that if an nfi  and  if an nfa recognizes a then a is regular  um  [Music]  so  um  we'll prove that by showing how to  convert an nfa to an equivalent dfa  which does the same language so we can  take an nfa that has a non-determinism  and find another dfa which doesn't have  non-determinism but does the same  language it accepts exactly the same  strengths  even though it lacks that  non-deterministic capability  it's this is going to be extremely  useful by the way and for example in  showing that closure under concatenation  okay  so  uh you know in this  presentation here i'm going to ignore  the epsilon transitions because once you  get the idea for how to do this you  could figure out how to incorporate them  they just make things a little more  complicated so let's just focus on the  key aspect of non-determinism which is  that the machine could have several ways  to go at any point in time  there could be several next states  on an input  okay  now the idea for the construction so  we're going to take we're going to start  with a non-deterministic machine m  and we're going to build a deterministic  machine m prime which does exactly the  same thing  and the way m prime works is it's going  to do what you would do  if you were simulating m  what would you do with me this is what  we were doing as we were as i was  explaining it to to you  if you are simulating m every time you  get an input symbol you just keep track  of what is the set of possible states at  that point in time  that's what the dfa is going to do  it's going to have  uh  it's going to have to keep track  of which possible set of states the nfa  could be in  at the  point on that input where we are right  now  and then  as you get the next symbol  the dfa is going to have to update  things to keep track of the next set of  states the nfa could be in at this point  just like you would do  okay and so  um  so here's a kind of a picture  um  and  how do we implement that in in so here's  the nfa that we're starting with m and  we're going to make here the dfa  but um  in order to remember  which set of states that dfa could be in  at a given point so maybe it's the set  of states that it that m could be in  did i say that wrong which set of states  the nfa could be at a given time so  maybe m the nfa could be in  at some point state q3 and q7  the way the dfa keeps track of that it's  going to have a state for every possible  subset of states  of the nfa  that's how it re remembers which subset  of states the nfa is in that's the way  dfas work they have a separate state for  each possibility that they need to keep  track of  and the possibilities here are the  different subsets of states that the nfa  could be in at a given point  okay so  corresponding to this subset to these  two possibilities q three q seven the  dfa is going to have the sub a state  with the subset q3 q7 and it's going to  for every possible subset here there's  going to be a different state of m prime  so n prime is going to be bigger  um  okay so  quickly the construction of m the states  of m prime now um q prime  are going to be the power set  the set of subsets of states  uh from the original machine m  um  and uh  the  uh now we have to look at how the  transition function of the dfa when you  make the primed machines are the dfas as  a dfa machine so these are the prime the  the deterministic component so  delta prime  um when it when it has a subset  that  you know  something like this  um has a has one of its states which  corresponds to a subset of states of m  and it reads an input symbol you just  have to do the updating the way you  would naturally do you're going to look  at every state in r  look at where that can go under a so  there's a bunch of sets there and look  at all the possible  states that could be in one of those  subsets and that's the set of states  that you you could be in that's going to  be the new set of states and that's  going to be the new state of m prime  okay so it's going to be the subset  corresponding to  all of the states that could be in  uh when you apply the transition  function of the non-deterministic  machine um to one of the states in that  in the subset of states that the not a  terminus machine could be in  okay  it's a little bit of a mouthful you know  you you could  i suggest you look at this if you didn't  quite get it after the fact  good to understand  the starting state for the nfa  for the dfa i'm sorry is going to be  which subset now we're going to start  off with it's going to be the subset  corresponding to just the start state  of um  uh of  of m  um  and the accepting states are going to be  uh of the deterministic machine are  going to be all of the subsets that have  at least one accepting state from the  nfa  so i hope you got that because i'm going  to be another little check in here um  which is i'm going to ask you how big is  m prime how many states does n prime  have uh i told you what those states are  so just go think about that um  so check in two if m has n states how  many states does m prime have by this  construction  okay so let's launch the next poll  um  okay  five seconds and i think we're almost  done here  good  all right share results  i know if sharing results is a good  thing i'm not trying to make you if you  didn't get the right answer um because  most of the people did get the right  answer we didn't get the right answer  trying to make you feel bad but i do  think you should it's a little bit of  suggestion you know that you you need to  review some basic concepts so the basic  concept here is if you have a collection  you have a set of states how many  subsets  are there and the number of subsets is  going to be exponential  so if you have a collection of n  elements the number of subsets of those  n elements is 2 to the n  um that's the fact we're using here and  that's why  m prime has two to the n states if m had  n states  um and that's you know you should make  sure you understand why that is  all right  so um with that um  as requested we're gonna have a little  break  um  and that break is going to last us  exactly  five minutes  so we'll we will return in five minutes  i'm going to be prompt so i give you a  little timer here so please  um  uh  i'm gonna  begin it write it right right when this  is over  okay  almost almost ready  i hope you're all refreshed  and ready for the second half  so now now that we have non-determinism  we're going to use uh that as a tool to  prove the uh closure properties that we  were aiming for for um starting from  last lecture  okay um  so remember  we  let's look at closure under a union now  we already did that  but i'm going to do it again  but this time using non-determinism and  you'll see how powerful  non-determinate non-determinism  now determinism is because it's going to  allow us to do it kind of  almost  with no effort  we'll start off the way we did before  i'm going to start off with two  dfas  but actually these could be um nfas even  but let's say we started with the two  dfas for the two languages a1 and a2 and  we're going to construct the nfa rec now  we're going to construct an nfa  recognizing the union  um and that's good enough because we  already know that we can convert nfas to  dfas and therefore they do they do  regulate languages too  um  okay  so now here are the two  dfas that do the languages a1 and a2  and what i'm going to do is i'm going to  put them together into a bag of states  um which is going to be m  the  nfa  that's going to do the union language so  remember what does what does  m supposed to do m is supposed to accept  its input if either m1 or m2 accept so  how is it going to do that what it's  going to do we're going to add a new  state  to m  which is going to branch under epsilon  transitions and now you can start to see  how useful these epsilon transitions are  going to be for us going to branch under  epsilon transitions to the two original  start states of m1 and m2 and we're done  y  well now  non-deterministically as we get an input  w coming in to m  um m at the very beginning even just  right after it gets going the very first  thing that happens is it's going to  branch to m1 and also branch to m2  non-deterministically as two  possibilities  and then inside m1 and m2 it's going to  actually start reading the input and  each one is going to be now following  along  as it would have originally  uh  the  states corresponding to um reading those  input symbols  um and  m  as a combination of m1 and m2 is going  to have a possibility for e for one  state in m1 and once one stated m2  um  and so m is going to have those combined  into one in  into one  um package and now if either at the end  of the input if either  um of these end up at an accepting state  then m  [Music]  um  is going to accept as a  non-deterministic fighter automaton  because that's how non-determinism works  you accept if either if any one of the  branches ended up accepting which is  just what you need for non-determinate  for union  so we're doing you and we want either  one of these to be accepting and then  the non-determinism just is built  conveniently to allow us to do the union  almost you know  for free  um  so you can again thinking about  non-determinism as terms of parallelism  you could think of it the  non-deterministic machine is running in  parallel m1 and m2 on the input  and if either one of them ends up  accepting m will accept  or you can think about it in terms of  that guessing that i referred to before  which means that  as m is getting when it's just about to  read these the first symbols of its  input it guesses  whether um that's going to be an input  accepted by m1 or an input accepted by  m2 and the magic of non-determinism is  that it always guesses right  so that input happens to be some an  input that's going to be wrecked you're  going to be accepted by m2  m is going to guess that  m2 is the right way to follow and it's  going to go in the m2 direction  um because non-determinism the magic is  you always guess right  wish that was true in real life  uh would make exams a lot easier um  anyway so  now let's see how we can use that to do  closure under concatenation  okay so now um we're gonna actually have  a picture very similar to the one we had  originally but now using non-determinism  we can make it work  so here we have the two machines doing  the two  languages a1 and a2  and we're going to combine them into one  bigger machine m  as shown  remember what m is supposed to do is  accept its input if there's some way of  splitting that input such that the first  half is accepted by the m1 and the  second part is accepted by m2  way we're going to get that effect  is by  um  putting in  a uh  transit empty  empty transitions epsilon transitions  going from the starts for the except  states of m1 to the start state of m2  just as i've shown here in this diagram  so these were the original accepting  states of m1  and now  um they're going to be declassified as  accepting states but they're going to  have new transitions empty transitions  um  attached to them which allow them to  branch to m2 without reading any input  and so intuitively speaking this is  going to do the right thing  because once m1 has accepted  some  part of w  then you can  non-deterministically  branch to  m2  and um  and you're going to be start processing  inside m2  and the the point is as i kind of uh  jumped ahead of myself um is that the  reason why it fixes the problem we had  before  is that the epsilon transitions are  don't machine does not have to take them  it can  stay where it is  as one non-deterministic option or it  can move along the epsilon transition  without reading any input as another  non-deterministic option  so it's using this non-determinism now  to both  stay in m1 to continue reading more of  the input and to jump into m2 to start  processing what might be the second half  or the second part of the input which m2  accepts  and you can think of it in terms of the  guessing is that the machine is guessing  where to make that split  once it found an initial part that's  accepted by m1 it guesses that this is  the right split point and that passes to  m2 but there might be other guesses that  it could make  you know corresponding to other  possibilities  and so  with non-determinism it always guesses  right if there is some way to split the  string into two parts  uh accepted by m1 and m2 the machine  will make that good guess  and  then  m1 will accept the first part and m2  will accept us with the second part and  we'll get m accepting that whole uh  string uh altogether and so that is the  uh solution um to our uh puzzle for how  do we do closure under concatenation  okay i hope that came through because  this is um this is you know we're just  getting going with non-determinism we're  going to be using non-determinism a lot  and you it's going to you're going to  need to get very comfortable with it  okay um  now let's do closure under star  um  and closure under star  works uh very similarly  but now we're just gonna have a single  language if a is regular so is a star so  they're not a pair of languages because  a star is a urinary operation  applying to just a single uh  language  so if we have a dfa recognizing a in  order to show that a star is regular we  have to construct a machine that  recognizes a star and a machine we're  going to construct is as before and then  an nfa  okay  so um  here is m  uh the dfa for a  and we're going to build an nfa m prime  that recognizes a star  and let's think now what does it mean to  recognize a star  so when should m you know if i'm going  to give you an input when is it in the  star language what does m prime have to  do  um so m remember what star is star means  you can take as many copies of you lot  as you like of strings in the original  language and that's in the star language  so to determine if something's in the  star language you have to see can i  break it up into pieces which are all in  the original language  um  [Music]  so  uh  um  so you want to see can i take my input  w and cut it up into a bunch of pieces  four in this case um where each of those  pieces are members of a they're members  of the original language so that's what  that's what m prime's job is  it's getting it has its input and wants  to know can i cut that input up into  pieces each of which are accepted by the  original machine  m  that's what m prime does  and if you think about it you know um  a little bit  really what's happening is that as soon  as  m  so you know m prime is going to be  simulating m that's why i like to think  about this as having m inside so you  know you're going to if you were going  to be doing this yourself you're going  to take w you're going to run it for a  while you'll see oh m is accepted  now i have to start m over again  to see if it accepts  uh on the next segment  so every time m accepts you're going to  restart m to see if it accepts another  segment and so you by doing that you're  going to be cutting w up into different  segments which are each of which is  accepted by m  of course  it's never totally clear  whether you should  and for any given segment you should cut  it there or you should wait a little  longer and find another play a later  place to cut but that's exactly the same  problem that we had before with  concatenation  and  we saw that using non-determinism and  we're going to solve it again using  non-determinism  so the way we're going to get that  effect of starting the machine over  again once once it's accepted is by  adding in  epsilon transitions that go from the  start states back to the  from the accept state back to the start  state  so now every time  m has accepted it has an option not not  a requirement but it has an option it  can either stay continuing to process  or it can restart  making a cut at that point and  trying to  see if there's a yet a different a  second another segment of the input  that's going to be ex that it's going to  accept  and this is basically the whole thing  with one little  um  problem  that we need to deal with  and that is  we need to make sure  um that m prime  accepts the empty string because  remember the x empty string is always a  member of the  starred language  and as it's as it's  written right now  we're going to be requiring there to be  at least one copy  of one at least one segment we're not  taking into account the possibility of  no segments which is the empty string  and the way we're going to get that  is well i mean  one thing  one way to get to it  so you know we're missing the empty  string right now so how do we fix it  basically you know we're just going to  take the construction we have  get uh you know on on the screen and  we're going to uh  adjust it to to add in the empty string  because it's possibly missing  one way to do that  which is tempting but  wrong  is to  make the start state of m an accepting  state for m prime  so we could have and we could have made  this an uh an accepting state too  and now m prime is also going to accept  the empty string that's the good news  the problem is that  the start state might be playing some  other role  in m besides just being the start there  might be times when m comes back to the  start state  you know later on  and if we make the start state the  accept and accept state it's going to  suddenly start accepting a bunch of  other things too which might not be  intended  so it's a bad idea to make the start  state and accept state  instead we'll take the simples uh  solution alternative of adding a new  start state  which will never be returned to under  any circumstances and make that a new  start and accept state as well so here  we'll have to make this additional  modification  so as i'm saying this is what we need to  do and we will do that  is by adding a new start state which is  also an accept state to make sure it  accepts the empty string  and then that also can branch  um to start off m  as before  um if the string that's input is not the  empty string and so then m you know we m  prime is actually going to have to do  some work to see if it can be cut up as  it was going as it was doing before  um so  that's  the proof of closure under star i'm not  going to do it anything beyond what i've  just described these proofs by picture  are convincing enough i hope um  and if not you know you should they are  explained in somewhat more detail  somewhat more formally in the textbook  but uh for the lecture this is where i'm  going to stop with these these two  arguments  um and so now uh oh yeah one uh quick  check in on this  so if m has n states  how many states does m prime have by  this construction  um so let's do  really these are  i'm not intending these to be very hard  more just to keep you awake  uh  so  how many  states does  m prime have  okay  maybe a little too easy even for a  check-in  yeah everybody's getting this one um  because all you did was we added one new  state um so the answer is as you have um  i think should pretty much everybody is  uh observing that it's just the um  it's number b um so i'm gonna end the  polling  i'm gonna share the results  and everybody got that one and so let's  continue on  um  and uh  so um  the very last thing we're going to do  today and show you how to convert  regular expressions  to nfas  thereby showing that every language that  you can describe with a regular  expression is a regular language  on tuesday we'll show how to do the  conversion in the other direction and  show thereby showing that these two  um  methods of describing languages are  equivalent to one another so here is our  theorem if r is or is a regular  expression and a is the language is  instead of strings that like that  regular expression describes then a is  regular  okay  um  so um we're going to show how to convert  [Music]  the the strategy is to convert r to an  equivalent nfam  and  so we have to think about remember these  regular expressions uh that we  introduced last time these are these  expressions that look like um you know a  b union b star something like that  um so built up out of the regular  operations from um  from the from the primitive regular  expressions that don't have any  operations that we're calling atomic  so if r is an atomic regular expression  it just looks like  either just a single symbol or an empty  string symbol or a  an empty language symbol  [Music]  or  r can be  a composite regular expression um  whoops  we're having a little  yeah so  so we have two possibilities here um r  is either atomic or composite  and so let's look at what the equivalent  expression is um in each case  so if r is just the single letter  regular expression that's a totally  legitimate regular expression just a  regular expression  one  so that just describes the language of  the string one  so we have to make a an nfa  which accepts which recognizes just that  language accepts only the string one  so it's a very simple nfa  it just starts uh in the start state and  on that single symbol it branches to an  accept state and there were no other  transitions allowed so if you get  anything else coming in besides that one  that that string which is just that one  symbol  the nfa is going to reject it  like if it goes if it's too long if if  you know if it gets a a coming in well  there's nowhere to go on from this um  accepting state on an a so the machine  is just going to die  it has to be in an accept state at the  end of the input  um how about you know why don't you  think for yourself for a minute how do  we make an nfa which  uh accepts only the empty string and no  other strings  you can do that with just one state with  an nfa  just this one here  um the machine is going to start off in  the start state which is also  immediately an accept state so it  accepts the empty string  but if anything else comes in there's  nowhere to go when the machine does  so this machine accepts just the empty  string or its language is the language  with one element the empty string  how about the empty language  well here's a here's an nfa which  has no accepting state so it can't be  accepting anything  now if we have a composite regular  expression  we're already finished because we showed  how to build up  we showed constructions which uh give us  closure under union  uh concatenation and star and those  constructions are going to enable us to  build up  uh the  nfas  that do  the language of these more complex  regular expressions built up out of the  anaphase that do the individual parts  so if we already have anaphase that do  r1 and r2  then  the closure under union construction  gives us an nfa that does  r1 union r2  as a language  so i'm going to do  i hope that's clear but i'm going to do  an example which will help hopefully  illustrate it and it's going to show you  you know basically what i'm giving you  is an automatic procedure for converting  a regular expression into an equivalent  nfa  so let's just see if  that that procedure in opera in action  which is really just following this  recipe that i described for you so here  is a regular expression a union a b  star  so this is a regular expression  it's some language whatever it is i  don't care  but i want to make an nfa which  recognizes that same language  and the way i'm going to do that is  first build nfa for the  [Music]  components um  the sub-expressions of this regular  expression  and then combine them using our closure  constructions  to be  um  to be anaphase for larger and larger  sub-expressions until i get the n of a  that's the equivalent of the entire  expression so let's just see how that  goes so the the very most primitive  parts the the the smallest  sub-expressions here are just the  expressions for a and for b  so here's the one for a just  just for a  so this is the nfa which um  recognizes the language which is just  the one string a  here's the nfa for the just whose  language is just the one string b  um  and now  i want an nfa which is  which accepts only the string a b  now of course you could just do that by  hand  um yourself it's simple enough but what  i'm arguing is that you we can do this  automatically  using the closure construction for  concatenation because really there's an  there's a hidden concatenate  concatenation symbol this is the the you  know a concatenate b  so now for a b  i'm going to take  um the the thing from a  and the part from b  so these these two things that i had  from before  and use the concatenation construction  to combine them  you see that so now i have automatically  a an nfa which does the language whose  string is just a b  th just the a b string  and  it's not the simplest nfa you can make a  simpler one but the virtue of this one  is that i got it automatically  just by following the closure  construction so now i'm going to do a  more complex one just the inside here a  union a b  um  so the way i'm going to build that is  from the two parts the a part and the a  b part  you know the a part and the a b part  so here is the a part  here's the a b part a b part i've  already got those from before it's  really kind of a proof by induction here  but you know i think it's simple enough  we don't have to use that language um  so we have  um  you know the a part the a b part and now  we are going to apply the  uh  the  closure under union construction to  combine those into one machine and  remember how that worked  we add a new symbol here which branches  under empty string to the previous  uh  i'm adding a new start state which  branches to the original start states  under empty empty transition and now  this is a an nfa for this language a  union a b  and lastly now we're one step away from  getting uh the star of this  and how we're going to do that  we're going to take this thing here and  apply the construction for the star  closure  and that's going to be an nfa which does  a union a b star which is what we wanted  in the first place  so  first we're going to  bring that one down because we've  already built that one and now remember  how we built um the  uh closure under star  we made this the accepting states return  back to the um the start state and we  added a new start state to make sure we  got the empty string in there  that transitioned to the original star  state under epsilon  okay so that's all  um i wanted to say for today's lecture  let's do a quick review  um  we  very important concept non-determinism  and and non-deterministic finite  automata we proved their equivalent in  power  uh  showed the class of regular languages  closed under concatenation and star we  showed how to do conversion of regular  expressions to nfas  so um i think that is it for  today's lecture and um  thank you all for being here  let me i'll try to answer a few of these  why does concatenation have order well  because it's an ordered construction  um  is there a simple way to prove closure  under concatenation without using  non-determinism no  um  why are the empty strings at the accept  state can't they be at any state  doesn't star make copies of any part of  the input no it's only you have to  you have to think about what's going on  having you you don't want to you have to  branch back to the beginning only on an  accept because that means you found a  piece that's in the original language um  is there an automaton that can add some  some or subtract  memory automata  well  depends on what you mean by all that but  um  certainly there are more powerful  machines that we're going to study than  find out automata um so  um  but yes there is um and even finite  automata can add and subtract if you  present the input in the right way i re  refer you to the first problem on the  homework um  so i think i'm gonna  uh check out then um  take care everybody bye  you
 

3
00:00:28,470 --> 00:00:28,480

 

4
00:00:28,480 --> 00:00:31,029


5
00:00:31,029 --> 00:00:33,430

 

6
00:00:33,430 --> 00:00:34,790

 

7
00:00:34,790 --> 00:00:37,030

 

8
00:00:37,030 --> 00:00:39,110

 

9
00:00:39,110 --> 00:00:40,869

 

10
00:00:40,869 --> 00:00:40,879

 

11
00:00:40,879 --> 00:00:44,069


12
00:00:44,069 --> 00:00:44,079

 

13
00:00:44,079 --> 00:00:44,869


14
00:00:44,869 --> 00:00:48,150

 

15
00:00:48,150 --> 00:00:50,150

 

16
00:00:50,150 --> 00:00:52,150

 

17
00:00:52,150 --> 00:00:54,470

 

18
00:00:54,470 --> 00:00:56,069

 

19
00:00:56,069 --> 00:00:59,029

 

20
00:00:59,029 --> 00:01:02,150

 

21
00:01:02,150 --> 00:01:04,869

 

22
00:01:04,869 --> 00:01:06,310

 

23
00:01:06,310 --> 00:01:07,670

 

24
00:01:07,670 --> 00:01:09,510

 

25
00:01:09,510 --> 00:01:09,520

 

26
00:01:09,520 --> 00:01:11,030


27
00:01:11,030 --> 00:01:14,550

 

28
00:01:14,550 --> 00:01:17,830

 

29
00:01:17,830 --> 00:01:19,590

 

30
00:01:19,590 --> 00:01:22,310

 

31
00:01:22,310 --> 00:01:24,789

 

32
00:01:24,789 --> 00:01:26,789

 

33
00:01:26,789 --> 00:01:28,630

 

34
00:01:28,630 --> 00:01:31,030

 

35
00:01:31,030 --> 00:01:33,510

 

36
00:01:33,510 --> 00:01:34,950

 

37
00:01:34,950 --> 00:01:36,870

 

38
00:01:36,870 --> 00:01:36,880

 

39
00:01:36,880 --> 00:01:38,710


40
00:01:38,710 --> 00:01:42,310

 

41
00:01:42,310 --> 00:01:44,389

 

42
00:01:44,389 --> 00:01:46,230

 

43
00:01:46,230 --> 00:01:48,469

 

44
00:01:48,469 --> 00:01:50,230

 

45
00:01:50,230 --> 00:01:52,550

 

46
00:01:52,550 --> 00:01:52,560

 

47
00:01:52,560 --> 00:01:53,590


48
00:01:53,590 --> 00:01:55,190

 

49
00:01:55,190 --> 00:01:57,990

 

50
00:01:57,990 --> 00:01:59,590

 

51
00:01:59,590 --> 00:02:01,510

 

52
00:02:01,510 --> 00:02:03,190

 

53
00:02:03,190 --> 00:02:05,429

 

54
00:02:05,429 --> 00:02:06,870

 

55
00:02:06,870 --> 00:02:08,309

 

56
00:02:08,309 --> 00:02:09,350

 

57
00:02:09,350 --> 00:02:09,360

 

58
00:02:09,360 --> 00:02:11,110


59
00:02:11,110 --> 00:02:12,390

 

60
00:02:12,390 --> 00:02:12,400

 

61
00:02:12,400 --> 00:02:13,750


62
00:02:13,750 --> 00:02:16,229

 

63
00:02:16,229 --> 00:02:18,630

 

64
00:02:18,630 --> 00:02:22,390

 

65
00:02:22,390 --> 00:02:24,070

 

66
00:02:24,070 --> 00:02:24,080

 

67
00:02:24,080 --> 00:02:25,110


68
00:02:25,110 --> 00:02:28,150

 

69
00:02:28,150 --> 00:02:31,110

 

70
00:02:31,110 --> 00:02:33,830

 

71
00:02:33,830 --> 00:02:33,840

 

72
00:02:33,840 --> 00:02:35,589


73
00:02:35,589 --> 00:02:38,070

 

74
00:02:38,070 --> 00:02:40,550

 

75
00:02:40,550 --> 00:02:42,550

 

76
00:02:42,550 --> 00:02:44,470

 

77
00:02:44,470 --> 00:02:45,910

 

78
00:02:45,910 --> 00:02:48,309

 

79
00:02:48,309 --> 00:02:51,030

 

80
00:02:51,030 --> 00:02:54,150

 

81
00:02:54,150 --> 00:02:55,830

 

82
00:02:55,830 --> 00:02:57,589

 

83
00:02:57,589 --> 00:02:58,710

 

84
00:02:58,710 --> 00:03:00,470

 

85
00:03:00,470 --> 00:03:02,790

 

86
00:03:02,790 --> 00:03:05,830

 

87
00:03:05,830 --> 00:03:08,229

 

88
00:03:08,229 --> 00:03:10,550

 

89
00:03:10,550 --> 00:03:12,790

 

90
00:03:12,790 --> 00:03:14,149

 

91
00:03:14,149 --> 00:03:18,309

 

92
00:03:18,309 --> 00:03:19,750

 

93
00:03:19,750 --> 00:03:21,430

 

94
00:03:21,430 --> 00:03:23,190

 

95
00:03:23,190 --> 00:03:25,990

 

96
00:03:25,990 --> 00:03:29,110

 

97
00:03:29,110 --> 00:03:33,430

 

98
00:03:33,430 --> 00:03:34,710

 

99
00:03:34,710 --> 00:03:36,869

 

100
00:03:36,869 --> 00:03:39,350

 

101
00:03:39,350 --> 00:03:42,070

 

102
00:03:42,070 --> 00:03:44,149

 

103
00:03:44,149 --> 00:03:47,030

 

104
00:03:47,030 --> 00:03:49,190

 

105
00:03:49,190 --> 00:03:50,949

 

106
00:03:50,949 --> 00:03:53,190

 

107
00:03:53,190 --> 00:03:55,030

 

108
00:03:55,030 --> 00:03:59,030

 

109
00:03:59,030 --> 00:04:01,509

 

110
00:04:01,509 --> 00:04:03,990

 

111
00:04:03,990 --> 00:04:06,630

 

112
00:04:06,630 --> 00:04:09,110

 

113
00:04:09,110 --> 00:04:11,910

 

114
00:04:11,910 --> 00:04:16,629

 

115
00:04:16,629 --> 00:04:19,110

 

116
00:04:19,110 --> 00:04:21,349

 

117
00:04:21,349 --> 00:04:23,350

 

118
00:04:23,350 --> 00:04:25,270

 

119
00:04:25,270 --> 00:04:28,469

 

120
00:04:28,469 --> 00:04:30,710

 

121
00:04:30,710 --> 00:04:33,590

 

122
00:04:33,590 --> 00:04:36,469

 

123
00:04:36,469 --> 00:04:39,430

 

124
00:04:39,430 --> 00:04:41,670

 

125
00:04:41,670 --> 00:04:44,150

 

126
00:04:44,150 --> 00:04:45,430

 

127
00:04:45,430 --> 00:04:47,749

 

128
00:04:47,749 --> 00:04:50,150

 

129
00:04:50,150 --> 00:04:51,670

 

130
00:04:51,670 --> 00:04:53,030

 

131
00:04:53,030 --> 00:04:54,550

 

132
00:04:54,550 --> 00:04:56,070

 

133
00:04:56,070 --> 00:04:57,430

 

134
00:04:57,430 --> 00:04:57,440

 

135
00:04:57,440 --> 00:04:58,310


136
00:04:58,310 --> 00:05:00,870

 

137
00:05:00,870 --> 00:05:02,790

 

138
00:05:02,790 --> 00:05:03,990

 

139
00:05:03,990 --> 00:05:04,000

 

140
00:05:04,000 --> 00:05:05,510


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

 

142
00:05:07,990 --> 00:05:12,790

 

143
00:05:12,790 --> 00:05:15,590

 

144
00:05:15,590 --> 00:05:17,909

 

145
00:05:17,909 --> 00:05:19,830

 

146
00:05:19,830 --> 00:05:22,550

 

147
00:05:22,550 --> 00:05:26,070

 

148
00:05:26,070 --> 00:05:28,950

 

149
00:05:28,950 --> 00:05:31,990

 

150
00:05:31,990 --> 00:05:33,749

 

151
00:05:33,749 --> 00:05:35,909

 

152
00:05:35,909 --> 00:05:38,390

 

153
00:05:38,390 --> 00:05:41,510

 

154
00:05:41,510 --> 00:05:43,909

 

155
00:05:43,909 --> 00:05:46,390

 

156
00:05:46,390 --> 00:05:48,310

 

157
00:05:48,310 --> 00:05:50,310

 

158
00:05:50,310 --> 00:05:52,710

 

159
00:05:52,710 --> 00:05:55,670

 

160
00:05:55,670 --> 00:05:57,749

 

161
00:05:57,749 --> 00:05:58,790

 

162
00:05:58,790 --> 00:06:01,189

 

163
00:06:01,189 --> 00:06:03,110

 

164
00:06:03,110 --> 00:06:05,270

 

165
00:06:05,270 --> 00:06:06,629

 

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

 

167
00:06:08,309 --> 00:06:10,710

 

168
00:06:10,710 --> 00:06:12,629

 

169
00:06:12,629 --> 00:06:15,270

 

170
00:06:15,270 --> 00:06:17,430

 

171
00:06:17,430 --> 00:06:20,150

 

172
00:06:20,150 --> 00:06:22,790

 

173
00:06:22,790 --> 00:06:24,629

 

174
00:06:24,629 --> 00:06:26,150

 

175
00:06:26,150 --> 00:06:27,749

 

176
00:06:27,749 --> 00:06:29,350

 

177
00:06:29,350 --> 00:06:31,749

 

178
00:06:31,749 --> 00:06:33,510

 

179
00:06:33,510 --> 00:06:36,390

 

180
00:06:36,390 --> 00:06:39,990

 

181
00:06:39,990 --> 00:06:41,189

 

182
00:06:41,189 --> 00:06:41,199

 

183
00:06:41,199 --> 00:06:42,550


184
00:06:42,550 --> 00:06:44,469

 

185
00:06:44,469 --> 00:06:45,749

 

186
00:06:45,749 --> 00:06:48,469

 

187
00:06:48,469 --> 00:06:50,230

 

188
00:06:50,230 --> 00:06:51,909

 

189
00:06:51,909 --> 00:06:54,629

 

190
00:06:54,629 --> 00:06:56,150

 

191
00:06:56,150 --> 00:06:58,469

 

192
00:06:58,469 --> 00:07:01,029

 

193
00:07:01,029 --> 00:07:02,950

 

194
00:07:02,950 --> 00:07:04,790

 

195
00:07:04,790 --> 00:07:07,029

 

196
00:07:07,029 --> 00:07:09,270

 

197
00:07:09,270 --> 00:07:10,870

 

198
00:07:10,870 --> 00:07:13,990

 

199
00:07:13,990 --> 00:07:16,070

 

200
00:07:16,070 --> 00:07:17,830

 

201
00:07:17,830 --> 00:07:19,270

 

202
00:07:19,270 --> 00:07:21,749

 

203
00:07:21,749 --> 00:07:24,390

 

204
00:07:24,390 --> 00:07:25,749

 

205
00:07:25,749 --> 00:07:25,759

 

206
00:07:25,759 --> 00:07:26,100


207
00:07:26,100 --> 00:07:26,110

 

208
00:07:26,110 --> 00:07:27,830


209
00:07:27,830 --> 00:07:31,270

 

210
00:07:31,270 --> 00:07:33,189

 

211
00:07:33,189 --> 00:07:34,950

 

212
00:07:34,950 --> 00:07:37,589

 

213
00:07:37,589 --> 00:07:39,589

 

214
00:07:39,589 --> 00:07:41,589

 

215
00:07:41,589 --> 00:07:43,589

 

216
00:07:43,589 --> 00:07:45,589

 

217
00:07:45,589 --> 00:07:48,869

 

218
00:07:48,869 --> 00:07:50,390

 

219
00:07:50,390 --> 00:07:52,390

 

220
00:07:52,390 --> 00:07:54,869

 

221
00:07:54,869 --> 00:07:54,879

 

222
00:07:54,879 --> 00:07:55,749


223
00:07:55,749 --> 00:07:59,749

 

224
00:07:59,749 --> 00:08:02,230

 

225
00:08:02,230 --> 00:08:02,240

 

226
00:08:02,240 --> 00:08:03,749


227
00:08:03,749 --> 00:08:07,189

 

228
00:08:07,189 --> 00:08:09,589

 

229
00:08:09,589 --> 00:08:11,110

 

230
00:08:11,110 --> 00:08:11,120

 

231
00:08:11,120 --> 00:08:12,710


232
00:08:12,710 --> 00:08:15,110

 

233
00:08:15,110 --> 00:08:16,869

 

234
00:08:16,869 --> 00:08:20,790

 

235
00:08:20,790 --> 00:08:22,710

 

236
00:08:22,710 --> 00:08:24,790

 

237
00:08:24,790 --> 00:08:27,670

 

238
00:08:27,670 --> 00:08:29,589

 

239
00:08:29,589 --> 00:08:29,599

 

240
00:08:29,599 --> 00:08:31,909


241
00:08:31,909 --> 00:08:33,829

 

242
00:08:33,829 --> 00:08:36,310

 

243
00:08:36,310 --> 00:08:39,750

 

244
00:08:39,750 --> 00:08:41,909

 

245
00:08:41,909 --> 00:08:43,750

 

246
00:08:43,750 --> 00:08:45,509

 

247
00:08:45,509 --> 00:08:47,990

 

248
00:08:47,990 --> 00:08:51,430

 

249
00:08:51,430 --> 00:08:55,829

 

250
00:08:55,829 --> 00:08:58,150

 

251
00:08:58,150 --> 00:08:58,160

 

252
00:08:58,160 --> 00:08:59,990


253
00:08:59,990 --> 00:09:00,000

 

254
00:09:00,000 --> 00:09:00,949


255
00:09:00,949 --> 00:09:03,030

 

256
00:09:03,030 --> 00:09:04,389

 

257
00:09:04,389 --> 00:09:06,550

 

258
00:09:06,550 --> 00:09:08,389

 

259
00:09:08,389 --> 00:09:09,590

 

260
00:09:09,590 --> 00:09:12,070

 

261
00:09:12,070 --> 00:09:13,590

 

262
00:09:13,590 --> 00:09:15,829

 

263
00:09:15,829 --> 00:09:17,509

 

264
00:09:17,509 --> 00:09:19,910

 

265
00:09:19,910 --> 00:09:19,920

 

266
00:09:19,920 --> 00:09:20,829


267
00:09:20,829 --> 00:09:23,190

 

268
00:09:23,190 --> 00:09:24,230

 

269
00:09:24,230 --> 00:09:26,710

 

270
00:09:26,710 --> 00:09:28,630

 

271
00:09:28,630 --> 00:09:31,190

 

272
00:09:31,190 --> 00:09:33,190

 

273
00:09:33,190 --> 00:09:37,190

 

274
00:09:37,190 --> 00:09:39,430

 

275
00:09:39,430 --> 00:09:41,269

 

276
00:09:41,269 --> 00:09:42,389

 

277
00:09:42,389 --> 00:09:45,110

 

278
00:09:45,110 --> 00:09:47,590

 

279
00:09:47,590 --> 00:09:50,630

 

280
00:09:50,630 --> 00:09:53,110

 

281
00:09:53,110 --> 00:09:55,509

 

282
00:09:55,509 --> 00:09:57,269

 

283
00:09:57,269 --> 00:09:59,430

 

284
00:09:59,430 --> 00:09:59,440

 

285
00:09:59,440 --> 00:10:00,389


286
00:10:00,389 --> 00:10:02,790

 

287
00:10:02,790 --> 00:10:04,790

 

288
00:10:04,790 --> 00:10:06,069

 

289
00:10:06,069 --> 00:10:09,190

 

290
00:10:09,190 --> 00:10:11,110

 

291
00:10:11,110 --> 00:10:13,750

 

292
00:10:13,750 --> 00:10:15,750

 

293
00:10:15,750 --> 00:10:18,949

 

294
00:10:18,949 --> 00:10:22,470

 

295
00:10:22,470 --> 00:10:25,430

 

296
00:10:25,430 --> 00:10:26,949

 

297
00:10:26,949 --> 00:10:30,230

 

298
00:10:30,230 --> 00:10:33,110

 

299
00:10:33,110 --> 00:10:35,190

 

300
00:10:35,190 --> 00:10:37,670

 

301
00:10:37,670 --> 00:10:37,680

 

302
00:10:37,680 --> 00:10:39,430


303
00:10:39,430 --> 00:10:39,440

 

304
00:10:39,440 --> 00:10:40,310


305
00:10:40,310 --> 00:10:41,829

 

306
00:10:41,829 --> 00:10:43,430

 

307
00:10:43,430 --> 00:10:45,829

 

308
00:10:45,829 --> 00:10:48,949

 

309
00:10:48,949 --> 00:10:51,509

 

310
00:10:51,509 --> 00:10:53,030

 

311
00:10:53,030 --> 00:10:55,269

 

312
00:10:55,269 --> 00:10:56,230

 

313
00:10:56,230 --> 00:10:58,870

 

314
00:10:58,870 --> 00:11:01,110

 

315
00:11:01,110 --> 00:11:03,750

 

316
00:11:03,750 --> 00:11:05,990

 

317
00:11:05,990 --> 00:11:07,990

 

318
00:11:07,990 --> 00:11:11,430

 

319
00:11:11,430 --> 00:11:11,440

 

320
00:11:11,440 --> 00:11:12,550


321
00:11:12,550 --> 00:11:16,230

 

322
00:11:16,230 --> 00:11:19,670

 

323
00:11:19,670 --> 00:11:22,630

 

324
00:11:22,630 --> 00:11:26,069

 

325
00:11:26,069 --> 00:11:28,870

 

326
00:11:28,870 --> 00:11:31,590

 

327
00:11:31,590 --> 00:11:34,389

 

328
00:11:34,389 --> 00:11:35,910

 

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

 

330
00:11:37,269 --> 00:11:39,509

 

331
00:11:39,509 --> 00:11:42,550

 

332
00:11:42,550 --> 00:11:44,870

 

333
00:11:44,870 --> 00:11:46,550

 

334
00:11:46,550 --> 00:11:46,560

 

335
00:11:46,560 --> 00:11:47,829


336
00:11:47,829 --> 00:11:49,670

 

337
00:11:49,670 --> 00:11:50,949

 

338
00:11:50,949 --> 00:11:52,790

 

339
00:11:52,790 --> 00:11:55,190

 

340
00:11:55,190 --> 00:11:55,200

 

341
00:11:55,200 --> 00:11:57,269


342
00:11:57,269 --> 00:11:59,990

 

343
00:11:59,990 --> 00:12:03,190

 

344
00:12:03,190 --> 00:12:05,670

 

345
00:12:05,670 --> 00:12:07,430

 

346
00:12:07,430 --> 00:12:11,269

 

347
00:12:11,269 --> 00:12:12,949

 

348
00:12:12,949 --> 00:12:15,430

 

349
00:12:15,430 --> 00:12:17,190

 

350
00:12:17,190 --> 00:12:18,310

 

351
00:12:18,310 --> 00:12:18,320

 

352
00:12:18,320 --> 00:12:18,680


353
00:12:18,680 --> 00:12:18,690

 

354
00:12:18,690 --> 00:12:20,069


355
00:12:20,069 --> 00:12:20,079

 

356
00:12:20,079 --> 00:12:22,310


357
00:12:22,310 --> 00:12:25,190

 

358
00:12:25,190 --> 00:12:27,910

 

359
00:12:27,910 --> 00:12:29,509

 

360
00:12:29,509 --> 00:12:29,519

 

361
00:12:29,519 --> 00:12:30,470


362
00:12:30,470 --> 00:12:33,269

 

363
00:12:33,269 --> 00:12:33,279

 

364
00:12:33,279 --> 00:12:34,470


365
00:12:34,470 --> 00:12:36,550

 

366
00:12:36,550 --> 00:12:39,990

 

367
00:12:39,990 --> 00:12:42,550

 

368
00:12:42,550 --> 00:12:43,990

 

369
00:12:43,990 --> 00:12:46,470

 

370
00:12:46,470 --> 00:12:49,670

 

371
00:12:49,670 --> 00:12:51,350

 

372
00:12:51,350 --> 00:12:55,110

 

373
00:12:55,110 --> 00:12:55,120

 

374
00:12:55,120 --> 00:12:56,870


375
00:12:56,870 --> 00:13:02,550

 

376
00:13:02,550 --> 00:13:05,269

 

377
00:13:05,269 --> 00:13:07,430

 

378
00:13:07,430 --> 00:13:10,150

 

379
00:13:10,150 --> 00:13:10,160

 

380
00:13:10,160 --> 00:13:10,430


381
00:13:10,430 --> 00:13:10,440

 

382
00:13:10,440 --> 00:13:11,670


383
00:13:11,670 --> 00:13:14,949

 

384
00:13:14,949 --> 00:13:16,310

 

385
00:13:16,310 --> 00:13:18,389

 

386
00:13:18,389 --> 00:13:19,750

 

387
00:13:19,750 --> 00:13:22,710

 

388
00:13:22,710 --> 00:13:25,670

 

389
00:13:25,670 --> 00:13:27,750

 

390
00:13:27,750 --> 00:13:30,550

 

391
00:13:30,550 --> 00:13:32,389

 

392
00:13:32,389 --> 00:13:34,550

 

393
00:13:34,550 --> 00:13:36,949

 

394
00:13:36,949 --> 00:13:39,350

 

395
00:13:39,350 --> 00:13:42,550

 

396
00:13:42,550 --> 00:13:44,710

 

397
00:13:44,710 --> 00:13:47,670

 

398
00:13:47,670 --> 00:13:49,590

 

399
00:13:49,590 --> 00:13:53,829

 

400
00:13:53,829 --> 00:13:55,670

 

401
00:13:55,670 --> 00:13:57,509

 

402
00:13:57,509 --> 00:13:59,910

 

403
00:13:59,910 --> 00:14:02,069

 

404
00:14:02,069 --> 00:14:02,079

 

405
00:14:02,079 --> 00:14:04,150


406
00:14:04,150 --> 00:14:06,150

 

407
00:14:06,150 --> 00:14:08,629

 

408
00:14:08,629 --> 00:14:12,069

 

409
00:14:12,069 --> 00:14:14,470

 

410
00:14:14,470 --> 00:14:16,069

 

411
00:14:16,069 --> 00:14:18,150

 

412
00:14:18,150 --> 00:14:19,829

 

413
00:14:19,829 --> 00:14:21,750

 

414
00:14:21,750 --> 00:14:25,030

 

415
00:14:25,030 --> 00:14:26,870

 

416
00:14:26,870 --> 00:14:28,710

 

417
00:14:28,710 --> 00:14:30,949

 

418
00:14:30,949 --> 00:14:32,310

 

419
00:14:32,310 --> 00:14:33,990

 

420
00:14:33,990 --> 00:14:35,750

 

421
00:14:35,750 --> 00:14:35,760

 

422
00:14:35,760 --> 00:14:37,110


423
00:14:37,110 --> 00:14:39,030

 

424
00:14:39,030 --> 00:14:41,189

 

425
00:14:41,189 --> 00:14:43,670

 

426
00:14:43,670 --> 00:14:46,069

 

427
00:14:46,069 --> 00:14:46,079

 

428
00:14:46,079 --> 00:14:47,269


429
00:14:47,269 --> 00:14:47,279

 

430
00:14:47,279 --> 00:14:48,230


431
00:14:48,230 --> 00:14:49,910

 

432
00:14:49,910 --> 00:14:51,509

 

433
00:14:51,509 --> 00:14:53,670

 

434
00:14:53,670 --> 00:14:56,230

 

435
00:14:56,230 --> 00:14:58,389

 

436
00:14:58,389 --> 00:14:59,910

 

437
00:14:59,910 --> 00:15:02,069

 

438
00:15:02,069 --> 00:15:04,069

 

439
00:15:04,069 --> 00:15:06,470

 

440
00:15:06,470 --> 00:15:08,790

 

441
00:15:08,790 --> 00:15:11,189

 

442
00:15:11,189 --> 00:15:11,199

 

443
00:15:11,199 --> 00:15:14,629


444
00:15:14,629 --> 00:15:17,509

 

445
00:15:17,509 --> 00:15:20,629

 

446
00:15:20,629 --> 00:15:23,750

 

447
00:15:23,750 --> 00:15:23,760

 

448
00:15:23,760 --> 00:15:25,509


449
00:15:25,509 --> 00:15:27,110

 

450
00:15:27,110 --> 00:15:29,749

 

451
00:15:29,749 --> 00:15:29,759

 

452
00:15:29,759 --> 00:15:31,030


453
00:15:31,030 --> 00:15:33,509

 

454
00:15:33,509 --> 00:15:35,269

 

455
00:15:35,269 --> 00:15:37,350

 

456
00:15:37,350 --> 00:15:37,360

 

457
00:15:37,360 --> 00:15:38,230


458
00:15:38,230 --> 00:15:42,790

 

459
00:15:42,790 --> 00:15:45,829

 

460
00:15:45,829 --> 00:15:47,749

 

461
00:15:47,749 --> 00:15:51,110

 

462
00:15:51,110 --> 00:15:53,110

 

463
00:15:53,110 --> 00:15:55,990

 

464
00:15:55,990 --> 00:15:58,150

 

465
00:15:58,150 --> 00:16:00,230

 

466
00:16:00,230 --> 00:16:01,910

 

467
00:16:01,910 --> 00:16:04,629

 

468
00:16:04,629 --> 00:16:06,870

 

469
00:16:06,870 --> 00:16:09,670

 

470
00:16:09,670 --> 00:16:12,230

 

471
00:16:12,230 --> 00:16:13,829

 

472
00:16:13,829 --> 00:16:15,110

 

473
00:16:15,110 --> 00:16:17,430

 

474
00:16:17,430 --> 00:16:19,749

 

475
00:16:19,749 --> 00:16:21,189

 

476
00:16:21,189 --> 00:16:23,910

 

477
00:16:23,910 --> 00:16:27,430

 

478
00:16:27,430 --> 00:16:29,430

 

479
00:16:29,430 --> 00:16:34,829

 

480
00:16:34,829 --> 00:16:34,839

 

481
00:16:34,839 --> 00:16:36,629


482
00:16:36,629 --> 00:16:39,590

 

483
00:16:39,590 --> 00:16:42,310

 

484
00:16:42,310 --> 00:16:45,430

 

485
00:16:45,430 --> 00:16:45,440

 

486
00:16:45,440 --> 00:16:46,470


487
00:16:46,470 --> 00:16:49,189

 

488
00:16:49,189 --> 00:16:52,230

 

489
00:16:52,230 --> 00:16:55,030

 

490
00:16:55,030 --> 00:16:57,509

 

491
00:16:57,509 --> 00:16:58,870

 

492
00:16:58,870 --> 00:17:00,790

 

493
00:17:00,790 --> 00:17:02,550

 

494
00:17:02,550 --> 00:17:05,350

 

495
00:17:05,350 --> 00:17:07,669

 

496
00:17:07,669 --> 00:17:10,069

 

497
00:17:10,069 --> 00:17:13,110

 

498
00:17:13,110 --> 00:17:13,120

 

499
00:17:13,120 --> 00:17:13,990


500
00:17:13,990 --> 00:17:15,990

 

501
00:17:15,990 --> 00:17:17,990

 

502
00:17:17,990 --> 00:17:19,590

 

503
00:17:19,590 --> 00:17:21,750

 

504
00:17:21,750 --> 00:17:23,669

 

505
00:17:23,669 --> 00:17:25,510

 

506
00:17:25,510 --> 00:17:27,990

 

507
00:17:27,990 --> 00:17:30,390

 

508
00:17:30,390 --> 00:17:32,789

 

509
00:17:32,789 --> 00:17:35,270

 

510
00:17:35,270 --> 00:17:36,950

 

511
00:17:36,950 --> 00:17:39,110

 

512
00:17:39,110 --> 00:17:40,950

 

513
00:17:40,950 --> 00:17:43,190

 

514
00:17:43,190 --> 00:17:44,950

 

515
00:17:44,950 --> 00:17:46,870

 

516
00:17:46,870 --> 00:17:48,230

 

517
00:17:48,230 --> 00:17:50,230

 

518
00:17:50,230 --> 00:17:51,669

 

519
00:17:51,669 --> 00:17:53,590

 

520
00:17:53,590 --> 00:17:55,029

 

521
00:17:55,029 --> 00:17:55,039

 

522
00:17:55,039 --> 00:17:57,430


523
00:17:57,430 --> 00:17:59,750

 

524
00:17:59,750 --> 00:18:01,909

 

525
00:18:01,909 --> 00:18:03,830

 

526
00:18:03,830 --> 00:18:05,830

 

527
00:18:05,830 --> 00:18:08,310

 

528
00:18:08,310 --> 00:18:09,990

 

529
00:18:09,990 --> 00:18:11,830

 

530
00:18:11,830 --> 00:18:14,390

 

531
00:18:14,390 --> 00:18:16,630

 

532
00:18:16,630 --> 00:18:17,510

 

533
00:18:17,510 --> 00:18:19,270

 

534
00:18:19,270 --> 00:18:20,950

 

535
00:18:20,950 --> 00:18:22,230

 

536
00:18:22,230 --> 00:18:24,150

 

537
00:18:24,150 --> 00:18:26,789

 

538
00:18:26,789 --> 00:18:28,710

 

539
00:18:28,710 --> 00:18:30,310

 

540
00:18:30,310 --> 00:18:31,990

 

541
00:18:31,990 --> 00:18:34,230

 

542
00:18:34,230 --> 00:18:36,390

 

543
00:18:36,390 --> 00:18:37,830

 

544
00:18:37,830 --> 00:18:37,840

 

545
00:18:37,840 --> 00:18:38,870


546
00:18:38,870 --> 00:18:42,549

 

547
00:18:42,549 --> 00:18:45,909

 

548
00:18:45,909 --> 00:18:52,870

 

549
00:18:52,870 --> 00:18:57,190

 

550
00:18:57,190 --> 00:18:59,029

 

551
00:18:59,029 --> 00:19:00,549

 

552
00:19:00,549 --> 00:19:01,990

 

553
00:19:01,990 --> 00:19:02,000

 

554
00:19:02,000 --> 00:19:03,510


555
00:19:03,510 --> 00:19:03,520

 

556
00:19:03,520 --> 00:19:05,190


557
00:19:05,190 --> 00:19:07,110

 

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

 

559
00:19:07,120 --> 00:19:08,070


560
00:19:08,070 --> 00:19:10,310

 

561
00:19:10,310 --> 00:19:11,590

 

562
00:19:11,590 --> 00:19:13,750

 

563
00:19:13,750 --> 00:19:17,590

 

564
00:19:17,590 --> 00:19:19,830

 

565
00:19:19,830 --> 00:19:22,070

 

566
00:19:22,070 --> 00:19:25,110

 

567
00:19:25,110 --> 00:19:27,510

 

568
00:19:27,510 --> 00:19:27,520

 

569
00:19:27,520 --> 00:19:28,470


570
00:19:28,470 --> 00:19:30,950

 

571
00:19:30,950 --> 00:19:33,430

 

572
00:19:33,430 --> 00:19:35,350

 

573
00:19:35,350 --> 00:19:35,360

 

574
00:19:35,360 --> 00:19:36,549


575
00:19:36,549 --> 00:19:36,559

 

576
00:19:36,559 --> 00:19:37,669


577
00:19:37,669 --> 00:19:41,029

 

578
00:19:41,029 --> 00:19:42,549

 

579
00:19:42,549 --> 00:19:42,559

 

580
00:19:42,559 --> 00:19:44,070


581
00:19:44,070 --> 00:19:44,080

 

582
00:19:44,080 --> 00:19:45,750


583
00:19:45,750 --> 00:19:48,630

 

584
00:19:48,630 --> 00:19:50,150

 

585
00:19:50,150 --> 00:19:51,750

 

586
00:19:51,750 --> 00:19:51,760

 

587
00:19:51,760 --> 00:19:52,870


588
00:19:52,870 --> 00:19:54,870

 

589
00:19:54,870 --> 00:19:57,510

 

590
00:19:57,510 --> 00:19:59,430

 

591
00:19:59,430 --> 00:20:02,470

 

592
00:20:02,470 --> 00:20:04,310

 

593
00:20:04,310 --> 00:20:06,630

 

594
00:20:06,630 --> 00:20:09,190

 

595
00:20:09,190 --> 00:20:09,200

 

596
00:20:09,200 --> 00:20:09,830


597
00:20:09,830 --> 00:20:12,630

 

598
00:20:12,630 --> 00:20:14,950

 

599
00:20:14,950 --> 00:20:16,870

 

600
00:20:16,870 --> 00:20:19,029

 

601
00:20:19,029 --> 00:20:21,510

 

602
00:20:21,510 --> 00:20:23,830

 

603
00:20:23,830 --> 00:20:23,840

 

604
00:20:23,840 --> 00:20:25,270


605
00:20:25,270 --> 00:20:27,510

 

606
00:20:27,510 --> 00:20:29,270

 

607
00:20:29,270 --> 00:20:31,190

 

608
00:20:31,190 --> 00:20:32,390

 

609
00:20:32,390 --> 00:20:35,110

 

610
00:20:35,110 --> 00:20:35,990

 

611
00:20:35,990 --> 00:20:37,270

 

612
00:20:37,270 --> 00:20:39,750

 

613
00:20:39,750 --> 00:20:41,110

 

614
00:20:41,110 --> 00:20:42,870

 

615
00:20:42,870 --> 00:20:44,549

 

616
00:20:44,549 --> 00:20:48,390

 

617
00:20:48,390 --> 00:20:48,400

 

618
00:20:48,400 --> 00:20:49,190


619
00:20:49,190 --> 00:20:51,190

 

620
00:20:51,190 --> 00:20:52,710

 

621
00:20:52,710 --> 00:20:54,549

 

622
00:20:54,549 --> 00:20:57,029

 

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

 

624
00:20:59,190 --> 00:21:02,230

 

625
00:21:02,230 --> 00:21:05,430

 

626
00:21:05,430 --> 00:21:08,710

 

627
00:21:08,710 --> 00:21:11,110

 

628
00:21:11,110 --> 00:21:13,830

 

629
00:21:13,830 --> 00:21:13,840

 

630
00:21:13,840 --> 00:21:14,630


631
00:21:14,630 --> 00:21:17,190

 

632
00:21:17,190 --> 00:21:19,190

 

633
00:21:19,190 --> 00:21:21,830

 

634
00:21:21,830 --> 00:21:24,070

 

635
00:21:24,070 --> 00:21:26,470

 

636
00:21:26,470 --> 00:21:28,310

 

637
00:21:28,310 --> 00:21:30,470

 

638
00:21:30,470 --> 00:21:32,710

 

639
00:21:32,710 --> 00:21:34,950

 

640
00:21:34,950 --> 00:21:37,430

 

641
00:21:37,430 --> 00:21:40,070

 

642
00:21:40,070 --> 00:21:43,110

 

643
00:21:43,110 --> 00:21:45,350

 

644
00:21:45,350 --> 00:21:47,029

 

645
00:21:47,029 --> 00:21:48,390

 

646
00:21:48,390 --> 00:21:49,830

 

647
00:21:49,830 --> 00:21:52,870

 

648
00:21:52,870 --> 00:21:54,310

 

649
00:21:54,310 --> 00:21:56,630

 

650
00:21:56,630 --> 00:21:59,669

 

651
00:21:59,669 --> 00:21:59,679

 

652
00:21:59,679 --> 00:22:01,510


653
00:22:01,510 --> 00:22:04,390

 

654
00:22:04,390 --> 00:22:06,070

 

655
00:22:06,070 --> 00:22:09,510

 

656
00:22:09,510 --> 00:22:12,230

 

657
00:22:12,230 --> 00:22:14,149

 

658
00:22:14,149 --> 00:22:16,230

 

659
00:22:16,230 --> 00:22:18,390

 

660
00:22:18,390 --> 00:22:21,029

 

661
00:22:21,029 --> 00:22:23,270

 

662
00:22:23,270 --> 00:22:25,110

 

663
00:22:25,110 --> 00:22:27,909

 

664
00:22:27,909 --> 00:22:29,590

 

665
00:22:29,590 --> 00:22:29,600

 

666
00:22:29,600 --> 00:22:30,470


667
00:22:30,470 --> 00:22:32,950

 

668
00:22:32,950 --> 00:22:32,960

 

669
00:22:32,960 --> 00:22:34,549


670
00:22:34,549 --> 00:22:37,029

 

671
00:22:37,029 --> 00:22:37,039

 

672
00:22:37,039 --> 00:22:38,549


673
00:22:38,549 --> 00:22:40,870

 

674
00:22:40,870 --> 00:22:40,880

 

675
00:22:40,880 --> 00:22:42,390


676
00:22:42,390 --> 00:22:45,350

 

677
00:22:45,350 --> 00:22:47,909

 

678
00:22:47,909 --> 00:22:50,230

 

679
00:22:50,230 --> 00:22:52,630

 

680
00:22:52,630 --> 00:22:55,669

 

681
00:22:55,669 --> 00:22:57,669

 

682
00:22:57,669 --> 00:23:01,190

 

683
00:23:01,190 --> 00:23:01,200

 

684
00:23:01,200 --> 00:23:03,110


685
00:23:03,110 --> 00:23:05,270

 

686
00:23:05,270 --> 00:23:05,280

 

687
00:23:05,280 --> 00:23:06,230


688
00:23:06,230 --> 00:23:08,789

 

689
00:23:08,789 --> 00:23:11,270

 

690
00:23:11,270 --> 00:23:12,950

 

691
00:23:12,950 --> 00:23:15,830

 

692
00:23:15,830 --> 00:23:17,750

 

693
00:23:17,750 --> 00:23:17,760

 

694
00:23:17,760 --> 00:23:18,549


695
00:23:18,549 --> 00:23:20,390

 

696
00:23:20,390 --> 00:23:22,630

 

697
00:23:22,630 --> 00:23:22,640

 

698
00:23:22,640 --> 00:23:23,750


699
00:23:23,750 --> 00:23:23,760

 

700
00:23:23,760 --> 00:23:25,029


701
00:23:25,029 --> 00:23:26,870

 

702
00:23:26,870 --> 00:23:28,310

 

703
00:23:28,310 --> 00:23:30,149

 

704
00:23:30,149 --> 00:23:32,789

 

705
00:23:32,789 --> 00:23:34,630

 

706
00:23:34,630 --> 00:23:36,549

 

707
00:23:36,549 --> 00:23:39,590

 

708
00:23:39,590 --> 00:23:41,990

 

709
00:23:41,990 --> 00:23:45,269

 

710
00:23:45,269 --> 00:23:46,870

 

711
00:23:46,870 --> 00:23:49,510

 

712
00:23:49,510 --> 00:23:51,269

 

713
00:23:51,269 --> 00:23:51,279

 

714
00:23:51,279 --> 00:23:53,190


715
00:23:53,190 --> 00:23:54,549

 

716
00:23:54,549 --> 00:23:56,149

 

717
00:23:56,149 --> 00:23:58,630

 

718
00:23:58,630 --> 00:23:58,640

 

719
00:23:58,640 --> 00:24:00,310


720
00:24:00,310 --> 00:24:02,549

 

721
00:24:02,549 --> 00:24:04,789

 

722
00:24:04,789 --> 00:24:07,029

 

723
00:24:07,029 --> 00:24:08,390

 

724
00:24:08,390 --> 00:24:08,400

 

725
00:24:08,400 --> 00:24:11,350


726
00:24:11,350 --> 00:24:12,710

 

727
00:24:12,710 --> 00:24:12,720

 

728
00:24:12,720 --> 00:24:13,590


729
00:24:13,590 --> 00:24:15,430

 

730
00:24:15,430 --> 00:24:16,950

 

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

 

732
00:24:18,549 --> 00:24:20,310

 

733
00:24:20,310 --> 00:24:22,789

 

734
00:24:22,789 --> 00:24:25,100

 

735
00:24:25,100 --> 00:24:25,110

 

736
00:24:25,110 --> 00:24:26,390


737
00:24:26,390 --> 00:24:28,549

 

738
00:24:28,549 --> 00:24:31,590

 

739
00:24:31,590 --> 00:24:34,230

 

740
00:24:34,230 --> 00:24:36,390

 

741
00:24:36,390 --> 00:24:36,400

 

742
00:24:36,400 --> 00:24:37,830


743
00:24:37,830 --> 00:24:40,789

 

744
00:24:40,789 --> 00:24:42,630

 

745
00:24:42,630 --> 00:24:44,789

 

746
00:24:44,789 --> 00:24:46,149

 

747
00:24:46,149 --> 00:24:47,990

 

748
00:24:47,990 --> 00:24:50,149

 

749
00:24:50,149 --> 00:24:52,870

 

750
00:24:52,870 --> 00:24:55,430

 

751
00:24:55,430 --> 00:24:58,310

 

752
00:24:58,310 --> 00:25:00,470

 

753
00:25:00,470 --> 00:25:03,029

 

754
00:25:03,029 --> 00:25:05,190

 

755
00:25:05,190 --> 00:25:08,870

 

756
00:25:08,870 --> 00:25:12,470

 

757
00:25:12,470 --> 00:25:14,549

 

758
00:25:14,549 --> 00:25:16,630

 

759
00:25:16,630 --> 00:25:18,070

 

760
00:25:18,070 --> 00:25:20,310

 

761
00:25:20,310 --> 00:25:21,909

 

762
00:25:21,909 --> 00:25:21,919

 

763
00:25:21,919 --> 00:25:23,029


764
00:25:23,029 --> 00:25:25,510

 

765
00:25:25,510 --> 00:25:29,190

 

766
00:25:29,190 --> 00:25:30,789

 

767
00:25:30,789 --> 00:25:32,789

 

768
00:25:32,789 --> 00:25:35,029

 

769
00:25:35,029 --> 00:25:37,269

 

770
00:25:37,269 --> 00:25:38,870

 

771
00:25:38,870 --> 00:25:41,330

 

772
00:25:41,330 --> 00:25:41,340

 

773
00:25:41,340 --> 00:25:43,110


774
00:25:43,110 --> 00:25:45,909

 

775
00:25:45,909 --> 00:25:48,630

 

776
00:25:48,630 --> 00:25:50,789

 

777
00:25:50,789 --> 00:25:52,789

 

778
00:25:52,789 --> 00:25:55,750

 

779
00:25:55,750 --> 00:25:57,190

 

780
00:25:57,190 --> 00:25:58,549

 

781
00:25:58,549 --> 00:26:00,390

 

782
00:26:00,390 --> 00:26:03,029

 

783
00:26:03,029 --> 00:26:04,950

 

784
00:26:04,950 --> 00:26:07,430

 

785
00:26:07,430 --> 00:26:09,350

 

786
00:26:09,350 --> 00:26:09,360

 

787
00:26:09,360 --> 00:26:10,950


788
00:26:10,950 --> 00:26:12,310

 

789
00:26:12,310 --> 00:26:13,510

 

790
00:26:13,510 --> 00:26:15,190

 

791
00:26:15,190 --> 00:26:17,350

 

792
00:26:17,350 --> 00:26:18,789

 

793
00:26:18,789 --> 00:26:21,029

 

794
00:26:21,029 --> 00:26:23,350

 

795
00:26:23,350 --> 00:26:27,510

 

796
00:26:27,510 --> 00:26:29,350

 

797
00:26:29,350 --> 00:26:29,360

 

798
00:26:29,360 --> 00:26:30,230


799
00:26:30,230 --> 00:26:33,029

 

800
00:26:33,029 --> 00:26:34,870

 

801
00:26:34,870 --> 00:26:38,070

 

802
00:26:38,070 --> 00:26:41,350

 

803
00:26:41,350 --> 00:26:43,510

 

804
00:26:43,510 --> 00:26:47,590

 

805
00:26:47,590 --> 00:26:49,990

 

806
00:26:49,990 --> 00:26:50,000

 

807
00:26:50,000 --> 00:26:51,590


808
00:26:51,590 --> 00:26:54,310

 

809
00:26:54,310 --> 00:26:56,870

 

810
00:26:56,870 --> 00:26:58,470

 

811
00:26:58,470 --> 00:27:00,310

 

812
00:27:00,310 --> 00:27:01,669

 

813
00:27:01,669 --> 00:27:03,909

 

814
00:27:03,909 --> 00:27:05,750

 

815
00:27:05,750 --> 00:27:07,430

 

816
00:27:07,430 --> 00:27:09,590

 

817
00:27:09,590 --> 00:27:09,600

 

818
00:27:09,600 --> 00:27:10,950


819
00:27:10,950 --> 00:27:10,960

 

820
00:27:10,960 --> 00:27:11,750


821
00:27:11,750 --> 00:27:11,760

 

822
00:27:11,760 --> 00:27:12,789


823
00:27:12,789 --> 00:27:15,190

 

824
00:27:15,190 --> 00:27:17,029

 

825
00:27:17,029 --> 00:27:19,549

 

826
00:27:19,549 --> 00:27:22,310

 

827
00:27:22,310 --> 00:27:24,230

 

828
00:27:24,230 --> 00:27:25,590

 

829
00:27:25,590 --> 00:27:27,669

 

830
00:27:27,669 --> 00:27:29,110

 

831
00:27:29,110 --> 00:27:31,430

 

832
00:27:31,430 --> 00:27:35,029

 

833
00:27:35,029 --> 00:27:37,350

 

834
00:27:37,350 --> 00:27:37,360

 

835
00:27:37,360 --> 00:27:38,310


836
00:27:38,310 --> 00:27:41,669

 

837
00:27:41,669 --> 00:27:41,679

 

838
00:27:41,679 --> 00:27:42,120


839
00:27:42,120 --> 00:27:42,130

 

840
00:27:42,130 --> 00:27:43,510


841
00:27:43,510 --> 00:27:43,520

 

842
00:27:43,520 --> 00:27:44,310


843
00:27:44,310 --> 00:27:44,320

 

844
00:27:44,320 --> 00:27:45,350


845
00:27:45,350 --> 00:27:46,950

 

846
00:27:46,950 --> 00:27:50,710

 

847
00:27:50,710 --> 00:27:52,870

 

848
00:27:52,870 --> 00:27:55,350

 

849
00:27:55,350 --> 00:27:57,750

 

850
00:27:57,750 --> 00:27:59,350

 

851
00:27:59,350 --> 00:28:01,590

 

852
00:28:01,590 --> 00:28:01,600

 

853
00:28:01,600 --> 00:28:02,870


854
00:28:02,870 --> 00:28:03,909

 

855
00:28:03,909 --> 00:28:06,149

 

856
00:28:06,149 --> 00:28:07,590

 

857
00:28:07,590 --> 00:28:10,789

 

858
00:28:10,789 --> 00:28:13,830

 

859
00:28:13,830 --> 00:28:13,840

 

860
00:28:13,840 --> 00:28:14,830


861
00:28:14,830 --> 00:28:14,840

 

862
00:28:14,840 --> 00:28:16,630


863
00:28:16,630 --> 00:28:18,630

 

864
00:28:18,630 --> 00:28:20,470

 

865
00:28:20,470 --> 00:28:22,710

 

866
00:28:22,710 --> 00:28:24,149

 

867
00:28:24,149 --> 00:28:25,990

 

868
00:28:25,990 --> 00:28:27,269

 

869
00:28:27,269 --> 00:28:30,549

 

870
00:28:30,549 --> 00:28:33,110

 

871
00:28:33,110 --> 00:28:35,029

 

872
00:28:35,029 --> 00:28:37,190

 

873
00:28:37,190 --> 00:28:39,669

 

874
00:28:39,669 --> 00:28:41,909

 

875
00:28:41,909 --> 00:28:41,919

 

876
00:28:41,919 --> 00:28:42,789


877
00:28:42,789 --> 00:28:45,590

 

878
00:28:45,590 --> 00:28:47,110

 

879
00:28:47,110 --> 00:28:49,990

 

880
00:28:49,990 --> 00:28:51,830

 

881
00:28:51,830 --> 00:28:54,549

 

882
00:28:54,549 --> 00:28:55,830

 

883
00:28:55,830 --> 00:28:58,149

 

884
00:28:58,149 --> 00:29:00,470

 

885
00:29:00,470 --> 00:29:02,710

 

886
00:29:02,710 --> 00:29:04,470

 

887
00:29:04,470 --> 00:29:06,070

 

888
00:29:06,070 --> 00:29:07,990

 

889
00:29:07,990 --> 00:29:10,470

 

890
00:29:10,470 --> 00:29:12,630

 

891
00:29:12,630 --> 00:29:14,789

 

892
00:29:14,789 --> 00:29:16,630

 

893
00:29:16,630 --> 00:29:19,269

 

894
00:29:19,269 --> 00:29:20,549

 

895
00:29:20,549 --> 00:29:20,559

 

896
00:29:20,559 --> 00:29:21,669


897
00:29:21,669 --> 00:29:23,669

 

898
00:29:23,669 --> 00:29:27,909

 

899
00:29:27,909 --> 00:29:30,070

 

900
00:29:30,070 --> 00:29:31,190

 

901
00:29:31,190 --> 00:29:33,110

 

902
00:29:33,110 --> 00:29:33,120

 

903
00:29:33,120 --> 00:29:34,710


904
00:29:34,710 --> 00:29:37,510

 

905
00:29:37,510 --> 00:29:39,350

 

906
00:29:39,350 --> 00:29:41,269

 

907
00:29:41,269 --> 00:29:43,590

 

908
00:29:43,590 --> 00:29:47,029

 

909
00:29:47,029 --> 00:29:49,510

 

910
00:29:49,510 --> 00:29:51,029

 

911
00:29:51,029 --> 00:29:51,039

 

912
00:29:51,039 --> 00:29:52,470


913
00:29:52,470 --> 00:29:54,789

 

914
00:29:54,789 --> 00:29:54,799

 

915
00:29:54,799 --> 00:29:55,669


916
00:29:55,669 --> 00:29:55,679

 

917
00:29:55,679 --> 00:29:57,110


918
00:29:57,110 --> 00:30:00,070

 

919
00:30:00,070 --> 00:30:02,310

 

920
00:30:02,310 --> 00:30:04,950

 

921
00:30:04,950 --> 00:30:07,430

 

922
00:30:07,430 --> 00:30:09,190

 

923
00:30:09,190 --> 00:30:11,669

 

924
00:30:11,669 --> 00:30:13,750

 

925
00:30:13,750 --> 00:30:16,710

 

926
00:30:16,710 --> 00:30:18,230

 

927
00:30:18,230 --> 00:30:19,909

 

928
00:30:19,909 --> 00:30:22,470

 

929
00:30:22,470 --> 00:30:25,750

 

930
00:30:25,750 --> 00:30:27,909

 

931
00:30:27,909 --> 00:30:30,870

 

932
00:30:30,870 --> 00:30:32,630

 

933
00:30:32,630 --> 00:30:34,870

 

934
00:30:34,870 --> 00:30:38,149

 

935
00:30:38,149 --> 00:30:40,149

 

936
00:30:40,149 --> 00:30:43,110

 

937
00:30:43,110 --> 00:30:45,510

 

938
00:30:45,510 --> 00:30:46,470

 

939
00:30:46,470 --> 00:30:48,389

 

940
00:30:48,389 --> 00:30:51,269

 

941
00:30:51,269 --> 00:30:53,590

 

942
00:30:53,590 --> 00:30:54,950

 

943
00:30:54,950 --> 00:30:57,269

 

944
00:30:57,269 --> 00:30:59,990

 

945
00:30:59,990 --> 00:31:01,830

 

946
00:31:01,830 --> 00:31:04,710

 

947
00:31:04,710 --> 00:31:06,789

 

948
00:31:06,789 --> 00:31:09,110

 

949
00:31:09,110 --> 00:31:11,669

 

950
00:31:11,669 --> 00:31:11,679

 

951
00:31:11,679 --> 00:31:13,190


952
00:31:13,190 --> 00:31:15,029

 

953
00:31:15,029 --> 00:31:17,590

 

954
00:31:17,590 --> 00:31:21,110

 

955
00:31:21,110 --> 00:31:22,950

 

956
00:31:22,950 --> 00:31:25,669

 

957
00:31:25,669 --> 00:31:28,710

 

958
00:31:28,710 --> 00:31:28,720

 

959
00:31:28,720 --> 00:31:30,070


960
00:31:30,070 --> 00:31:32,789

 

961
00:31:32,789 --> 00:31:32,799

 

962
00:31:32,799 --> 00:31:35,750


963
00:31:35,750 --> 00:31:37,190

 

964
00:31:37,190 --> 00:31:40,149

 

965
00:31:40,149 --> 00:31:42,789

 

966
00:31:42,789 --> 00:31:44,950

 

967
00:31:44,950 --> 00:31:47,509

 

968
00:31:47,509 --> 00:31:49,269

 

969
00:31:49,269 --> 00:31:51,990

 

970
00:31:51,990 --> 00:31:52,000

 

971
00:31:52,000 --> 00:31:53,029


972
00:31:53,029 --> 00:31:54,549

 

973
00:31:54,549 --> 00:31:56,070

 

974
00:31:56,070 --> 00:31:58,230

 

975
00:31:58,230 --> 00:32:01,669

 

976
00:32:01,669 --> 00:32:03,430

 

977
00:32:03,430 --> 00:32:05,029

 

978
00:32:05,029 --> 00:32:06,470

 

979
00:32:06,470 --> 00:32:08,870

 

980
00:32:08,870 --> 00:32:11,190

 

981
00:32:11,190 --> 00:32:13,110

 

982
00:32:13,110 --> 00:32:15,029

 

983
00:32:15,029 --> 00:32:16,549

 

984
00:32:16,549 --> 00:32:19,190

 

985
00:32:19,190 --> 00:32:21,029

 

986
00:32:21,029 --> 00:32:22,310

 

987
00:32:22,310 --> 00:32:26,070

 

988
00:32:26,070 --> 00:32:28,070

 

989
00:32:28,070 --> 00:32:29,750

 

990
00:32:29,750 --> 00:32:33,350

 

991
00:32:33,350 --> 00:32:35,269

 

992
00:32:35,269 --> 00:32:37,509

 

993
00:32:37,509 --> 00:32:40,630

 

994
00:32:40,630 --> 00:32:42,870

 

995
00:32:42,870 --> 00:32:44,549

 

996
00:32:44,549 --> 00:32:44,559

 

997
00:32:44,559 --> 00:32:45,750


998
00:32:45,750 --> 00:32:47,430

 

999
00:32:47,430 --> 00:32:49,190

 

1000
00:32:49,190 --> 00:32:50,870

 

1001
00:32:50,870 --> 00:32:53,190

 

1002
00:32:53,190 --> 00:32:55,190

 

1003
00:32:55,190 --> 00:32:57,909

 

1004
00:32:57,909 --> 00:32:59,830

 

1005
00:32:59,830 --> 00:33:01,509

 

1006
00:33:01,509 --> 00:33:03,029

 

1007
00:33:03,029 --> 00:33:05,590

 

1008
00:33:05,590 --> 00:33:08,149

 

1009
00:33:08,149 --> 00:33:09,509

 

1010
00:33:09,509 --> 00:33:10,470

 

1011
00:33:10,470 --> 00:33:10,480

 

1012
00:33:10,480 --> 00:33:11,590


1013
00:33:11,590 --> 00:33:14,789

 

1014
00:33:14,789 --> 00:33:16,710

 

1015
00:33:16,710 --> 00:33:18,950

 

1016
00:33:18,950 --> 00:33:21,509

 

1017
00:33:21,509 --> 00:33:21,519

 

1018
00:33:21,519 --> 00:33:24,710


1019
00:33:24,710 --> 00:33:26,310

 

1020
00:33:26,310 --> 00:33:28,549

 

1021
00:33:28,549 --> 00:33:30,870

 

1022
00:33:30,870 --> 00:33:32,549

 

1023
00:33:32,549 --> 00:33:35,190

 

1024
00:33:35,190 --> 00:33:40,549

 

1025
00:33:40,549 --> 00:33:43,269

 

1026
00:33:43,269 --> 00:33:45,190

 

1027
00:33:45,190 --> 00:33:45,200

 

1028
00:33:45,200 --> 00:33:46,950


1029
00:33:46,950 --> 00:33:49,750

 

1030
00:33:49,750 --> 00:33:49,760

 

1031
00:33:49,760 --> 00:33:58,470


1032
00:33:58,470 --> 00:33:58,480

 

1033
00:33:58,480 --> 00:33:59,990


1034
00:33:59,990 --> 00:34:02,149

 

1035
00:34:02,149 --> 00:34:03,110

 

1036
00:34:03,110 --> 00:34:03,120

 

1037
00:34:03,120 --> 00:34:06,389


1038
00:34:06,389 --> 00:34:09,909

 

1039
00:34:09,909 --> 00:34:11,190

 

1040
00:34:11,190 --> 00:34:13,030

 

1041
00:34:13,030 --> 00:34:15,190

 

1042
00:34:15,190 --> 00:34:16,310

 

1043
00:34:16,310 --> 00:34:17,349

 

1044
00:34:17,349 --> 00:34:18,869

 

1045
00:34:18,869 --> 00:34:20,710

 

1046
00:34:20,710 --> 00:34:22,470

 

1047
00:34:22,470 --> 00:34:24,869

 

1048
00:34:24,869 --> 00:34:27,030

 

1049
00:34:27,030 --> 00:34:28,869

 

1050
00:34:28,869 --> 00:34:28,879

 

1051
00:34:28,879 --> 00:34:30,230


1052
00:34:30,230 --> 00:34:32,230

 

1053
00:34:32,230 --> 00:34:33,750

 

1054
00:34:33,750 --> 00:34:35,829

 

1055
00:34:35,829 --> 00:34:37,909

 

1056
00:34:37,909 --> 00:34:39,909

 

1057
00:34:39,909 --> 00:34:42,069

 

1058
00:34:42,069 --> 00:34:43,669

 

1059
00:34:43,669 --> 00:34:46,069

 

1060
00:34:46,069 --> 00:34:48,550

 

1061
00:34:48,550 --> 00:34:50,230

 

1062
00:34:50,230 --> 00:34:53,430

 

1063
00:34:53,430 --> 00:34:54,310

 

1064
00:34:54,310 --> 00:34:58,230

 

1065
00:34:58,230 --> 00:34:59,670

 

1066
00:34:59,670 --> 00:34:59,680

 

1067
00:34:59,680 --> 00:35:00,550


1068
00:35:00,550 --> 00:35:00,560

 

1069
00:35:00,560 --> 00:35:01,589


1070
00:35:01,589 --> 00:35:04,630

 

1071
00:35:04,630 --> 00:35:04,640

 

1072
00:35:04,640 --> 00:35:07,190


1073
00:35:07,190 --> 00:35:14,870

 

1074
00:35:14,870 --> 00:35:17,750

 

1075
00:35:17,750 --> 00:35:19,990

 

1076
00:35:19,990 --> 00:35:22,550

 

1077
00:35:22,550 --> 00:35:22,560

 

1078
00:35:22,560 --> 00:35:23,829


1079
00:35:23,829 --> 00:35:23,839

 

1080
00:35:23,839 --> 00:35:25,190


1081
00:35:25,190 --> 00:35:26,710

 

1082
00:35:26,710 --> 00:35:28,550

 

1083
00:35:28,550 --> 00:35:35,109

 

1084
00:35:35,109 --> 00:35:35,119

 

1085
00:35:35,119 --> 00:35:37,349


1086
00:35:37,349 --> 00:35:52,710

 

1087
00:35:52,710 --> 00:35:54,550

 

1088
00:35:54,550 --> 00:35:57,589

 

1089
00:35:57,589 --> 00:36:00,630

 

1090
00:36:00,630 --> 00:36:03,190

 

1091
00:36:03,190 --> 00:36:05,910

 

1092
00:36:05,910 --> 00:36:08,710

 

1093
00:36:08,710 --> 00:36:10,150

 

1094
00:36:10,150 --> 00:36:11,750

 

1095
00:36:11,750 --> 00:36:13,670

 

1096
00:36:13,670 --> 00:36:13,680

 

1097
00:36:13,680 --> 00:36:15,030


1098
00:36:15,030 --> 00:36:17,190

 

1099
00:36:17,190 --> 00:36:18,630

 

1100
00:36:18,630 --> 00:36:20,230

 

1101
00:36:20,230 --> 00:36:22,550

 

1102
00:36:22,550 --> 00:36:24,829

 

1103
00:36:24,829 --> 00:36:26,870

 

1104
00:36:26,870 --> 00:36:29,670

 

1105
00:36:29,670 --> 00:36:32,470

 

1106
00:36:32,470 --> 00:36:32,480

 

1107
00:36:32,480 --> 00:36:33,510


1108
00:36:33,510 --> 00:36:36,630

 

1109
00:36:36,630 --> 00:36:39,430

 

1110
00:36:39,430 --> 00:36:43,030

 

1111
00:36:43,030 --> 00:36:43,040

 

1112
00:36:43,040 --> 00:36:44,230


1113
00:36:44,230 --> 00:36:48,310

 

1114
00:36:48,310 --> 00:36:50,150

 

1115
00:36:50,150 --> 00:36:53,190

 

1116
00:36:53,190 --> 00:36:55,430

 

1117
00:36:55,430 --> 00:36:57,990

 

1118
00:36:57,990 --> 00:37:00,150

 

1119
00:37:00,150 --> 00:37:01,990

 

1120
00:37:01,990 --> 00:37:03,910

 

1121
00:37:03,910 --> 00:37:06,390

 

1122
00:37:06,390 --> 00:37:08,390

 

1123
00:37:08,390 --> 00:37:08,400

 

1124
00:37:08,400 --> 00:37:10,069


1125
00:37:10,069 --> 00:37:10,079

 

1126
00:37:10,079 --> 00:37:11,190


1127
00:37:11,190 --> 00:37:13,349

 

1128
00:37:13,349 --> 00:37:17,349

 

1129
00:37:17,349 --> 00:37:19,589

 

1130
00:37:19,589 --> 00:37:23,270

 

1131
00:37:23,270 --> 00:37:25,750

 

1132
00:37:25,750 --> 00:37:25,760

 

1133
00:37:25,760 --> 00:37:27,190


1134
00:37:27,190 --> 00:37:27,200

 

1135
00:37:27,200 --> 00:37:28,310


1136
00:37:28,310 --> 00:37:30,870

 

1137
00:37:30,870 --> 00:37:33,109

 

1138
00:37:33,109 --> 00:37:35,910

 

1139
00:37:35,910 --> 00:37:39,750

 

1140
00:37:39,750 --> 00:37:41,510

 

1141
00:37:41,510 --> 00:37:42,870

 

1142
00:37:42,870 --> 00:37:42,880

 

1143
00:37:42,880 --> 00:37:43,829


1144
00:37:43,829 --> 00:37:45,109

 

1145
00:37:45,109 --> 00:37:47,109

 

1146
00:37:47,109 --> 00:37:48,790

 

1147
00:37:48,790 --> 00:37:50,790

 

1148
00:37:50,790 --> 00:37:52,870

 

1149
00:37:52,870 --> 00:37:55,670

 

1150
00:37:55,670 --> 00:37:59,349

 

1151
00:37:59,349 --> 00:37:59,359

 

1152
00:37:59,359 --> 00:38:01,589


1153
00:38:01,589 --> 00:38:02,589

 

1154
00:38:02,589 --> 00:38:05,270

 

1155
00:38:05,270 --> 00:38:08,470

 

1156
00:38:08,470 --> 00:38:10,790

 

1157
00:38:10,790 --> 00:38:12,550

 

1158
00:38:12,550 --> 00:38:14,230

 

1159
00:38:14,230 --> 00:38:16,630

 

1160
00:38:16,630 --> 00:38:17,990

 

1161
00:38:17,990 --> 00:38:18,000

 

1162
00:38:18,000 --> 00:38:19,349


1163
00:38:19,349 --> 00:38:21,829

 

1164
00:38:21,829 --> 00:38:23,910

 

1165
00:38:23,910 --> 00:38:27,030

 

1166
00:38:27,030 --> 00:38:27,040

 

1167
00:38:27,040 --> 00:38:28,390


1168
00:38:28,390 --> 00:38:30,950

 

1169
00:38:30,950 --> 00:38:30,960

 

1170
00:38:30,960 --> 00:38:32,069


1171
00:38:32,069 --> 00:38:35,589

 

1172
00:38:35,589 --> 00:38:37,030

 

1173
00:38:37,030 --> 00:38:38,710

 

1174
00:38:38,710 --> 00:38:38,720

 

1175
00:38:38,720 --> 00:38:40,069


1176
00:38:40,069 --> 00:38:42,230

 

1177
00:38:42,230 --> 00:38:44,630

 

1178
00:38:44,630 --> 00:38:47,750

 

1179
00:38:47,750 --> 00:38:47,760

 

1180
00:38:47,760 --> 00:38:49,030


1181
00:38:49,030 --> 00:38:50,950

 

1182
00:38:50,950 --> 00:38:52,630

 

1183
00:38:52,630 --> 00:38:53,750

 

1184
00:38:53,750 --> 00:38:57,030

 

1185
00:38:57,030 --> 00:38:59,270

 

1186
00:38:59,270 --> 00:39:02,950

 

1187
00:39:02,950 --> 00:39:03,690

 

1188
00:39:03,690 --> 00:39:03,700

 

1189
00:39:03,700 --> 00:39:04,950


1190
00:39:04,950 --> 00:39:04,960

 

1191
00:39:04,960 --> 00:39:06,310


1192
00:39:06,310 --> 00:39:07,750

 

1193
00:39:07,750 --> 00:39:09,589

 

1194
00:39:09,589 --> 00:39:11,510

 

1195
00:39:11,510 --> 00:39:13,910

 

1196
00:39:13,910 --> 00:39:15,670

 

1197
00:39:15,670 --> 00:39:17,510

 

1198
00:39:17,510 --> 00:39:19,349

 

1199
00:39:19,349 --> 00:39:20,790

 

1200
00:39:20,790 --> 00:39:23,190

 

1201
00:39:23,190 --> 00:39:25,990

 

1202
00:39:25,990 --> 00:39:28,230

 

1203
00:39:28,230 --> 00:39:29,750

 

1204
00:39:29,750 --> 00:39:31,349

 

1205
00:39:31,349 --> 00:39:31,359

 

1206
00:39:31,359 --> 00:39:32,390


1207
00:39:32,390 --> 00:39:34,230

 

1208
00:39:34,230 --> 00:39:38,230

 

1209
00:39:38,230 --> 00:39:39,510

 

1210
00:39:39,510 --> 00:39:41,270

 

1211
00:39:41,270 --> 00:39:45,910

 

1212
00:39:45,910 --> 00:39:47,190

 

1213
00:39:47,190 --> 00:39:49,589

 

1214
00:39:49,589 --> 00:39:51,829

 

1215
00:39:51,829 --> 00:39:55,430

 

1216
00:39:55,430 --> 00:39:56,870

 

1217
00:39:56,870 --> 00:39:59,589

 

1218
00:39:59,589 --> 00:40:01,270

 

1219
00:40:01,270 --> 00:40:03,670

 

1220
00:40:03,670 --> 00:40:06,230

 

1221
00:40:06,230 --> 00:40:08,630

 

1222
00:40:08,630 --> 00:40:11,829

 

1223
00:40:11,829 --> 00:40:13,990

 

1224
00:40:13,990 --> 00:40:16,150

 

1225
00:40:16,150 --> 00:40:17,589

 

1226
00:40:17,589 --> 00:40:19,829

 

1227
00:40:19,829 --> 00:40:22,150

 

1228
00:40:22,150 --> 00:40:23,750

 

1229
00:40:23,750 --> 00:40:26,069

 

1230
00:40:26,069 --> 00:40:29,589

 

1231
00:40:29,589 --> 00:40:31,510

 

1232
00:40:31,510 --> 00:40:34,069

 

1233
00:40:34,069 --> 00:40:37,109

 

1234
00:40:37,109 --> 00:40:38,790

 

1235
00:40:38,790 --> 00:40:40,470

 

1236
00:40:40,470 --> 00:40:44,150

 

1237
00:40:44,150 --> 00:40:46,710

 

1238
00:40:46,710 --> 00:40:48,630

 

1239
00:40:48,630 --> 00:40:50,950

 

1240
00:40:50,950 --> 00:40:52,870

 

1241
00:40:52,870 --> 00:40:55,030

 

1242
00:40:55,030 --> 00:40:55,990

 

1243
00:40:55,990 --> 00:40:59,030

 

1244
00:40:59,030 --> 00:41:01,190

 

1245
00:41:01,190 --> 00:41:03,589

 

1246
00:41:03,589 --> 00:41:05,750

 

1247
00:41:05,750 --> 00:41:07,990

 

1248
00:41:07,990 --> 00:41:10,230

 

1249
00:41:10,230 --> 00:41:12,550

 

1250
00:41:12,550 --> 00:41:14,870

 

1251
00:41:14,870 --> 00:41:18,870

 

1252
00:41:18,870 --> 00:41:20,870

 

1253
00:41:20,870 --> 00:41:22,950

 

1254
00:41:22,950 --> 00:41:22,960

 

1255
00:41:22,960 --> 00:41:24,069


1256
00:41:24,069 --> 00:41:25,750

 

1257
00:41:25,750 --> 00:41:27,910

 

1258
00:41:27,910 --> 00:41:29,349

 

1259
00:41:29,349 --> 00:41:32,390

 

1260
00:41:32,390 --> 00:41:34,390

 

1261
00:41:34,390 --> 00:41:38,470

 

1262
00:41:38,470 --> 00:41:40,309

 

1263
00:41:40,309 --> 00:41:42,550

 

1264
00:41:42,550 --> 00:41:44,309

 

1265
00:41:44,309 --> 00:41:45,990

 

1266
00:41:45,990 --> 00:41:48,150

 

1267
00:41:48,150 --> 00:41:50,630

 

1268
00:41:50,630 --> 00:41:53,990

 

1269
00:41:53,990 --> 00:41:54,000

 

1270
00:41:54,000 --> 00:41:54,950


1271
00:41:54,950 --> 00:41:56,790

 

1272
00:41:56,790 --> 00:42:03,270

 

1273
00:42:03,270 --> 00:42:05,030

 

1274
00:42:05,030 --> 00:42:07,109

 

1275
00:42:07,109 --> 00:42:10,950

 

1276
00:42:10,950 --> 00:42:10,960

 

1277
00:42:10,960 --> 00:42:11,750


1278
00:42:11,750 --> 00:42:13,589

 

1279
00:42:13,589 --> 00:42:15,270

 

1280
00:42:15,270 --> 00:42:15,280

 

1281
00:42:15,280 --> 00:42:17,910


1282
00:42:17,910 --> 00:42:19,990

 

1283
00:42:19,990 --> 00:42:20,000

 

1284
00:42:20,000 --> 00:42:22,230


1285
00:42:22,230 --> 00:42:24,230

 

1286
00:42:24,230 --> 00:42:26,230

 

1287
00:42:26,230 --> 00:42:28,390

 

1288
00:42:28,390 --> 00:42:31,510

 

1289
00:42:31,510 --> 00:42:34,069

 

1290
00:42:34,069 --> 00:42:35,750

 

1291
00:42:35,750 --> 00:42:35,760

 

1292
00:42:35,760 --> 00:42:36,950


1293
00:42:36,950 --> 00:42:39,990

 

1294
00:42:39,990 --> 00:42:43,349

 

1295
00:42:43,349 --> 00:42:44,950

 

1296
00:42:44,950 --> 00:42:47,109

 

1297
00:42:47,109 --> 00:42:49,510

 

1298
00:42:49,510 --> 00:42:51,190

 

1299
00:42:51,190 --> 00:42:53,190

 

1300
00:42:53,190 --> 00:42:56,309

 

1301
00:42:56,309 --> 00:42:58,150

 

1302
00:42:58,150 --> 00:42:59,430

 

1303
00:42:59,430 --> 00:43:02,390

 

1304
00:43:02,390 --> 00:43:06,150

 

1305
00:43:06,150 --> 00:43:09,270

 

1306
00:43:09,270 --> 00:43:12,150

 

1307
00:43:12,150 --> 00:43:12,160

 

1308
00:43:12,160 --> 00:43:13,750


1309
00:43:13,750 --> 00:43:15,349

 

1310
00:43:15,349 --> 00:43:17,750

 

1311
00:43:17,750 --> 00:43:21,270

 

1312
00:43:21,270 --> 00:43:23,910

 

1313
00:43:23,910 --> 00:43:26,470

 

1314
00:43:26,470 --> 00:43:28,790

 

1315
00:43:28,790 --> 00:43:31,589

 

1316
00:43:31,589 --> 00:43:33,030

 

1317
00:43:33,030 --> 00:43:34,230

 

1318
00:43:34,230 --> 00:43:34,240

 

1319
00:43:34,240 --> 00:43:36,870


1320
00:43:36,870 --> 00:43:39,190

 

1321
00:43:39,190 --> 00:43:41,109

 

1322
00:43:41,109 --> 00:43:43,670

 

1323
00:43:43,670 --> 00:43:45,750

 

1324
00:43:45,750 --> 00:43:48,790

 

1325
00:43:48,790 --> 00:43:50,790

 

1326
00:43:50,790 --> 00:43:50,800

 

1327
00:43:50,800 --> 00:43:51,589


1328
00:43:51,589 --> 00:43:51,599

 

1329
00:43:51,599 --> 00:43:53,109


1330
00:43:53,109 --> 00:43:55,430

 

1331
00:43:55,430 --> 00:43:57,510

 

1332
00:43:57,510 --> 00:43:59,910

 

1333
00:43:59,910 --> 00:44:03,349

 

1334
00:44:03,349 --> 00:44:06,870

 

1335
00:44:06,870 --> 00:44:10,230

 

1336
00:44:10,230 --> 00:44:11,750

 

1337
00:44:11,750 --> 00:44:15,430

 

1338
00:44:15,430 --> 00:44:17,030

 

1339
00:44:17,030 --> 00:44:18,950

 

1340
00:44:18,950 --> 00:44:20,550

 

1341
00:44:20,550 --> 00:44:24,230

 

1342
00:44:24,230 --> 00:44:25,990

 

1343
00:44:25,990 --> 00:44:28,150

 

1344
00:44:28,150 --> 00:44:28,160

 

1345
00:44:28,160 --> 00:44:29,270


1346
00:44:29,270 --> 00:44:31,190

 

1347
00:44:31,190 --> 00:44:33,910

 

1348
00:44:33,910 --> 00:44:35,589

 

1349
00:44:35,589 --> 00:44:37,990

 

1350
00:44:37,990 --> 00:44:39,670

 

1351
00:44:39,670 --> 00:44:43,270

 

1352
00:44:43,270 --> 00:44:45,910

 

1353
00:44:45,910 --> 00:44:45,920

 

1354
00:44:45,920 --> 00:44:47,430


1355
00:44:47,430 --> 00:44:50,230

 

1356
00:44:50,230 --> 00:44:53,430

 

1357
00:44:53,430 --> 00:44:55,430

 

1358
00:44:55,430 --> 00:44:57,510

 

1359
00:44:57,510 --> 00:44:59,670

 

1360
00:44:59,670 --> 00:45:01,430

 

1361
00:45:01,430 --> 00:45:01,440

 

1362
00:45:01,440 --> 00:45:02,390


1363
00:45:02,390 --> 00:45:05,030

 

1364
00:45:05,030 --> 00:45:06,870

 

1365
00:45:06,870 --> 00:45:09,510

 

1366
00:45:09,510 --> 00:45:12,870

 

1367
00:45:12,870 --> 00:45:15,510

 

1368
00:45:15,510 --> 00:45:18,309

 

1369
00:45:18,309 --> 00:45:21,349

 

1370
00:45:21,349 --> 00:45:23,030

 

1371
00:45:23,030 --> 00:45:25,349

 

1372
00:45:25,349 --> 00:45:28,069

 

1373
00:45:28,069 --> 00:45:28,079

 

1374
00:45:28,079 --> 00:45:29,589


1375
00:45:29,589 --> 00:45:32,950

 

1376
00:45:32,950 --> 00:45:34,870

 

1377
00:45:34,870 --> 00:45:36,550

 

1378
00:45:36,550 --> 00:45:38,550

 

1379
00:45:38,550 --> 00:45:40,710

 

1380
00:45:40,710 --> 00:45:43,109

 

1381
00:45:43,109 --> 00:45:45,430

 

1382
00:45:45,430 --> 00:45:47,030

 

1383
00:45:47,030 --> 00:45:47,040

 

1384
00:45:47,040 --> 00:45:47,490


1385
00:45:47,490 --> 00:45:47,500

 

1386
00:45:47,500 --> 00:45:48,710


1387
00:45:48,710 --> 00:45:48,720

 

1388
00:45:48,720 --> 00:45:50,470


1389
00:45:50,470 --> 00:45:50,480

 

1390
00:45:50,480 --> 00:45:51,430


1391
00:45:51,430 --> 00:45:51,440

 

1392
00:45:51,440 --> 00:45:52,790


1393
00:45:52,790 --> 00:45:55,670

 

1394
00:45:55,670 --> 00:45:58,390

 

1395
00:45:58,390 --> 00:46:01,349

 

1396
00:46:01,349 --> 00:46:04,390

 

1397
00:46:04,390 --> 00:46:06,309

 

1398
00:46:06,309 --> 00:46:09,430

 

1399
00:46:09,430 --> 00:46:11,510

 

1400
00:46:11,510 --> 00:46:13,750

 

1401
00:46:13,750 --> 00:46:16,150

 

1402
00:46:16,150 --> 00:46:17,910

 

1403
00:46:17,910 --> 00:46:17,920

 

1404
00:46:17,920 --> 00:46:18,950


1405
00:46:18,950 --> 00:46:21,270

 

1406
00:46:21,270 --> 00:46:25,589

 

1407
00:46:25,589 --> 00:46:26,790

 

1408
00:46:26,790 --> 00:46:28,870

 

1409
00:46:28,870 --> 00:46:28,880

 

1410
00:46:28,880 --> 00:46:29,910


1411
00:46:29,910 --> 00:46:29,920

 

1412
00:46:29,920 --> 00:46:30,870


1413
00:46:30,870 --> 00:46:32,390

 

1414
00:46:32,390 --> 00:46:33,990

 

1415
00:46:33,990 --> 00:46:36,230

 

1416
00:46:36,230 --> 00:46:37,510

 

1417
00:46:37,510 --> 00:46:39,270

 

1418
00:46:39,270 --> 00:46:41,270

 

1419
00:46:41,270 --> 00:46:43,910

 

1420
00:46:43,910 --> 00:46:46,710

 

1421
00:46:46,710 --> 00:46:48,230

 

1422
00:46:48,230 --> 00:46:50,550

 

1423
00:46:50,550 --> 00:46:53,109

 

1424
00:46:53,109 --> 00:46:55,829

 

1425
00:46:55,829 --> 00:46:57,510

 

1426
00:46:57,510 --> 00:46:59,430

 

1427
00:46:59,430 --> 00:47:01,589

 

1428
00:47:01,589 --> 00:47:03,030

 

1429
00:47:03,030 --> 00:47:04,230

 

1430
00:47:04,230 --> 00:47:06,470

 

1431
00:47:06,470 --> 00:47:07,829

 

1432
00:47:07,829 --> 00:47:09,990

 

1433
00:47:09,990 --> 00:47:11,349

 

1434
00:47:11,349 --> 00:47:13,430

 

1435
00:47:13,430 --> 00:47:15,589

 

1436
00:47:15,589 --> 00:47:17,270

 

1437
00:47:17,270 --> 00:47:17,280

 

1438
00:47:17,280 --> 00:47:18,710


1439
00:47:18,710 --> 00:47:18,720

 

1440
00:47:18,720 --> 00:47:20,069


1441
00:47:20,069 --> 00:47:21,750

 

1442
00:47:21,750 --> 00:47:22,870

 

1443
00:47:22,870 --> 00:47:22,880

 

1444
00:47:22,880 --> 00:47:25,109


1445
00:47:25,109 --> 00:47:26,630

 

1446
00:47:26,630 --> 00:47:29,109

 

1447
00:47:29,109 --> 00:47:32,790

 

1448
00:47:32,790 --> 00:47:35,670

 

1449
00:47:35,670 --> 00:47:37,510

 

1450
00:47:37,510 --> 00:47:39,589

 

1451
00:47:39,589 --> 00:47:41,430

 

1452
00:47:41,430 --> 00:47:41,440

 

1453
00:47:41,440 --> 00:47:47,589


1454
00:47:47,589 --> 00:47:49,349

 

1455
00:47:49,349 --> 00:47:52,390

 

1456
00:47:52,390 --> 00:47:54,390

 

1457
00:47:54,390 --> 00:47:57,030

 

1458
00:47:57,030 --> 00:47:59,510

 

1459
00:47:59,510 --> 00:48:02,950

 

1460
00:48:02,950 --> 00:48:04,470

 

1461
00:48:04,470 --> 00:48:06,069

 

1462
00:48:06,069 --> 00:48:08,069

 

1463
00:48:08,069 --> 00:48:09,829

 

1464
00:48:09,829 --> 00:48:09,839

 

1465
00:48:09,839 --> 00:48:11,510


1466
00:48:11,510 --> 00:48:13,270

 

1467
00:48:13,270 --> 00:48:15,510

 

1468
00:48:15,510 --> 00:48:15,520

 

1469
00:48:15,520 --> 00:48:16,710


1470
00:48:16,710 --> 00:48:16,720

 

1471
00:48:16,720 --> 00:48:18,230


1472
00:48:18,230 --> 00:48:20,549

 

1473
00:48:20,549 --> 00:48:24,069

 

1474
00:48:24,069 --> 00:48:26,630

 

1475
00:48:26,630 --> 00:48:29,750

 

1476
00:48:29,750 --> 00:48:31,589

 

1477
00:48:31,589 --> 00:48:34,870

 

1478
00:48:34,870 --> 00:48:36,630

 

1479
00:48:36,630 --> 00:48:39,829

 

1480
00:48:39,829 --> 00:48:42,309

 

1481
00:48:42,309 --> 00:48:44,230

 

1482
00:48:44,230 --> 00:48:46,710

 

1483
00:48:46,710 --> 00:48:49,270

 

1484
00:48:49,270 --> 00:48:51,589

 

1485
00:48:51,589 --> 00:48:53,430

 

1486
00:48:53,430 --> 00:48:56,390

 

1487
00:48:56,390 --> 00:48:58,150

 

1488
00:48:58,150 --> 00:48:59,750

 

1489
00:48:59,750 --> 00:49:02,150

 

1490
00:49:02,150 --> 00:49:04,069

 

1491
00:49:04,069 --> 00:49:05,349

 

1492
00:49:05,349 --> 00:49:07,430

 

1493
00:49:07,430 --> 00:49:08,630

 

1494
00:49:08,630 --> 00:49:10,470

 

1495
00:49:10,470 --> 00:49:13,109

 

1496
00:49:13,109 --> 00:49:14,790

 

1497
00:49:14,790 --> 00:49:17,270

 

1498
00:49:17,270 --> 00:49:19,430

 

1499
00:49:19,430 --> 00:49:21,270

 

1500
00:49:21,270 --> 00:49:23,670

 

1501
00:49:23,670 --> 00:49:23,680

 

1502
00:49:23,680 --> 00:49:25,349


1503
00:49:25,349 --> 00:49:27,750

 

1504
00:49:27,750 --> 00:49:30,790

 

1505
00:49:30,790 --> 00:49:32,870

 

1506
00:49:32,870 --> 00:49:34,230

 

1507
00:49:34,230 --> 00:49:36,870

 

1508
00:49:36,870 --> 00:49:39,030

 

1509
00:49:39,030 --> 00:49:41,990

 

1510
00:49:41,990 --> 00:49:47,190

 

1511
00:49:47,190 --> 00:49:49,589

 

1512
00:49:49,589 --> 00:49:50,790

 

1513
00:49:50,790 --> 00:49:53,030

 

1514
00:49:53,030 --> 00:49:55,030

 

1515
00:49:55,030 --> 00:49:56,710

 

1516
00:49:56,710 --> 00:49:58,470

 

1517
00:49:58,470 --> 00:49:59,910

 

1518
00:49:59,910 --> 00:50:02,549

 

1519
00:50:02,549 --> 00:50:03,990

 

1520
00:50:03,990 --> 00:50:05,910

 

1521
00:50:05,910 --> 00:50:05,920

 

1522
00:50:05,920 --> 00:50:07,270


1523
00:50:07,270 --> 00:50:09,190

 

1524
00:50:09,190 --> 00:50:10,870

 

1525
00:50:10,870 --> 00:50:14,150

 

1526
00:50:14,150 --> 00:50:16,710

 

1527
00:50:16,710 --> 00:50:17,990

 

1528
00:50:17,990 --> 00:50:20,710

 

1529
00:50:20,710 --> 00:50:24,069

 

1530
00:50:24,069 --> 00:50:26,790

 

1531
00:50:26,790 --> 00:50:27,910

 

1532
00:50:27,910 --> 00:50:27,920

 

1533
00:50:27,920 --> 00:50:29,270


1534
00:50:29,270 --> 00:50:30,950

 

1535
00:50:30,950 --> 00:50:32,950

 

1536
00:50:32,950 --> 00:50:34,710

 

1537
00:50:34,710 --> 00:50:36,150

 

1538
00:50:36,150 --> 00:50:37,990

 

1539
00:50:37,990 --> 00:50:41,190

 

1540
00:50:41,190 --> 00:50:44,230

 

1541
00:50:44,230 --> 00:50:45,829

 

1542
00:50:45,829 --> 00:50:47,829

 

1543
00:50:47,829 --> 00:50:50,549

 

1544
00:50:50,549 --> 00:50:51,589

 

1545
00:50:51,589 --> 00:50:53,670

 

1546
00:50:53,670 --> 00:50:56,230

 

1547
00:50:56,230 --> 00:50:57,829

 

1548
00:50:57,829 --> 00:50:57,839

 

1549
00:50:57,839 --> 00:50:58,790


1550
00:50:58,790 --> 00:51:00,630

 

1551
00:51:00,630 --> 00:51:02,230

 

1552
00:51:02,230 --> 00:51:03,910

 

1553
00:51:03,910 --> 00:51:06,870

 

1554
00:51:06,870 --> 00:51:08,790

 

1555
00:51:08,790 --> 00:51:10,549

 

1556
00:51:10,549 --> 00:51:12,390

 

1557
00:51:12,390 --> 00:51:14,230

 

1558
00:51:14,230 --> 00:51:15,990

 

1559
00:51:15,990 --> 00:51:16,000

 

1560
00:51:16,000 --> 00:51:17,030


1561
00:51:17,030 --> 00:51:20,390

 

1562
00:51:20,390 --> 00:51:23,829

 

1563
00:51:23,829 --> 00:51:26,150

 

1564
00:51:26,150 --> 00:51:27,990

 

1565
00:51:27,990 --> 00:51:29,990

 

1566
00:51:29,990 --> 00:51:32,150

 

1567
00:51:32,150 --> 00:51:34,069

 

1568
00:51:34,069 --> 00:51:36,470

 

1569
00:51:36,470 --> 00:51:40,069

 

1570
00:51:40,069 --> 00:51:40,079

 

1571
00:51:40,079 --> 00:51:41,030


1572
00:51:41,030 --> 00:51:41,040

 

1573
00:51:41,040 --> 00:51:42,309


1574
00:51:42,309 --> 00:51:43,270

 

1575
00:51:43,270 --> 00:51:45,030

 

1576
00:51:45,030 --> 00:51:48,829

 

1577
00:51:48,829 --> 00:51:48,839

 

1578
00:51:48,839 --> 00:51:50,470


1579
00:51:50,470 --> 00:51:51,910

 

1580
00:51:51,910 --> 00:51:51,920

 

1581
00:51:51,920 --> 00:51:54,950


1582
00:51:54,950 --> 00:51:57,589

 

1583
00:51:57,589 --> 00:51:59,670

 

1584
00:51:59,670 --> 00:52:03,910

 

1585
00:52:03,910 --> 00:52:05,750

 

1586
00:52:05,750 --> 00:52:09,190

 

1587
00:52:09,190 --> 00:52:11,750

 

1588
00:52:11,750 --> 00:52:11,760

 

1589
00:52:11,760 --> 00:52:12,790


1590
00:52:12,790 --> 00:52:14,870

 

1591
00:52:14,870 --> 00:52:17,430

 

1592
00:52:17,430 --> 00:52:19,030

 

1593
00:52:19,030 --> 00:52:19,040

 

1594
00:52:19,040 --> 00:52:21,430


1595
00:52:21,430 --> 00:52:23,109

 

1596
00:52:23,109 --> 00:52:24,790

 

1597
00:52:24,790 --> 00:52:26,630

 

1598
00:52:26,630 --> 00:52:29,349

 

1599
00:52:29,349 --> 00:52:31,030

 

1600
00:52:31,030 --> 00:52:34,710

 

1601
00:52:34,710 --> 00:52:36,870

 

1602
00:52:36,870 --> 00:52:38,309

 

1603
00:52:38,309 --> 00:52:42,069

 

1604
00:52:42,069 --> 00:52:43,510

 

1605
00:52:43,510 --> 00:52:45,349

 

1606
00:52:45,349 --> 00:52:47,829

 

1607
00:52:47,829 --> 00:52:47,839

 

1608
00:52:47,839 --> 00:52:48,870


1609
00:52:48,870 --> 00:52:50,790

 

1610
00:52:50,790 --> 00:52:52,870

 

1611
00:52:52,870 --> 00:52:55,510

 

1612
00:52:55,510 --> 00:52:57,990

 

1613
00:52:57,990 --> 00:52:59,349

 

1614
00:52:59,349 --> 00:53:01,670

 

1615
00:53:01,670 --> 00:53:01,680

 

1616
00:53:01,680 --> 00:53:03,349


1617
00:53:03,349 --> 00:53:03,359

 

1618
00:53:03,359 --> 00:53:05,030


1619
00:53:05,030 --> 00:53:05,040

 

1620
00:53:05,040 --> 00:53:05,910


1621
00:53:05,910 --> 00:53:10,110

 

1622
00:53:10,110 --> 00:53:10,120

 

1623
00:53:10,120 --> 00:53:11,270


1624
00:53:11,270 --> 00:53:13,589

 

1625
00:53:13,589 --> 00:53:17,190

 

1626
00:53:17,190 --> 00:53:17,200

 

1627
00:53:17,200 --> 00:53:18,069


1628
00:53:18,069 --> 00:53:19,910

 

1629
00:53:19,910 --> 00:53:21,910

 

1630
00:53:21,910 --> 00:53:23,750

 

1631
00:53:23,750 --> 00:53:27,109

 

1632
00:53:27,109 --> 00:53:30,390

 

1633
00:53:30,390 --> 00:53:32,069

 

1634
00:53:32,069 --> 00:53:34,710

 

1635
00:53:34,710 --> 00:53:37,030

 

1636
00:53:37,030 --> 00:53:38,309

 

1637
00:53:38,309 --> 00:53:40,790

 

1638
00:53:40,790 --> 00:53:42,790

 

1639
00:53:42,790 --> 00:53:44,390

 

1640
00:53:44,390 --> 00:53:46,549

 

1641
00:53:46,549 --> 00:53:48,870

 

1642
00:53:48,870 --> 00:53:51,530

 

1643
00:53:51,530 --> 00:53:51,540

 

1644
00:53:51,540 --> 00:53:53,750


1645
00:53:53,750 --> 00:53:53,760

 

1646
00:53:53,760 --> 00:53:54,790


1647
00:53:54,790 --> 00:53:56,630

 

1648
00:53:56,630 --> 00:54:00,790

 

1649
00:54:00,790 --> 00:54:00,800

 

1650
00:54:00,800 --> 00:54:02,390


1651
00:54:02,390 --> 00:54:05,990

 

1652
00:54:05,990 --> 00:54:07,109

 

1653
00:54:07,109 --> 00:54:09,589

 

1654
00:54:09,589 --> 00:54:11,589

 

1655
00:54:11,589 --> 00:54:14,470

 

1656
00:54:14,470 --> 00:54:17,750

 

1657
00:54:17,750 --> 00:54:20,710

 

1658
00:54:20,710 --> 00:54:22,870

 

1659
00:54:22,870 --> 00:54:24,390

 

1660
00:54:24,390 --> 00:54:25,910

 

1661
00:54:25,910 --> 00:54:25,920

 

1662
00:54:25,920 --> 00:54:26,950


1663
00:54:26,950 --> 00:54:29,430

 

1664
00:54:29,430 --> 00:54:31,270

 

1665
00:54:31,270 --> 00:54:34,069

 

1666
00:54:34,069 --> 00:54:36,390

 

1667
00:54:36,390 --> 00:54:39,589

 

1668
00:54:39,589 --> 00:54:41,750

 

1669
00:54:41,750 --> 00:54:44,549

 

1670
00:54:44,549 --> 00:54:48,309

 

1671
00:54:48,309 --> 00:54:50,150

 

1672
00:54:50,150 --> 00:54:52,230

 

1673
00:54:52,230 --> 00:54:55,030

 

1674
00:54:55,030 --> 00:54:57,030

 

1675
00:54:57,030 --> 00:54:57,040

 

1676
00:54:57,040 --> 00:54:57,910


1677
00:54:57,910 --> 00:55:00,309

 

1678
00:55:00,309 --> 00:55:02,549

 

1679
00:55:02,549 --> 00:55:04,870

 

1680
00:55:04,870 --> 00:55:08,470

 

1681
00:55:08,470 --> 00:55:10,390

 

1682
00:55:10,390 --> 00:55:11,750

 

1683
00:55:11,750 --> 00:55:13,349

 

1684
00:55:13,349 --> 00:55:16,789

 

1685
00:55:16,789 --> 00:55:18,549

 

1686
00:55:18,549 --> 00:55:19,910

 

1687
00:55:19,910 --> 00:55:22,549

 

1688
00:55:22,549 --> 00:55:24,870

 

1689
00:55:24,870 --> 00:55:26,069

 

1690
00:55:26,069 --> 00:55:27,670

 

1691
00:55:27,670 --> 00:55:29,109

 

1692
00:55:29,109 --> 00:55:31,270

 

1693
00:55:31,270 --> 00:55:32,950

 

1694
00:55:32,950 --> 00:55:34,069

 

1695
00:55:34,069 --> 00:55:35,430

 

1696
00:55:35,430 --> 00:55:37,190

 

1697
00:55:37,190 --> 00:55:38,710

 

1698
00:55:38,710 --> 00:55:41,670

 

1699
00:55:41,670 --> 00:55:43,990

 

1700
00:55:43,990 --> 00:55:46,230

 

1701
00:55:46,230 --> 00:55:48,950

 

1702
00:55:48,950 --> 00:55:51,030

 

1703
00:55:51,030 --> 00:55:53,750

 

1704
00:55:53,750 --> 00:55:55,430

 

1705
00:55:55,430 --> 00:55:58,710

 

1706
00:55:58,710 --> 00:56:01,190

 

1707
00:56:01,190 --> 00:56:01,200

 

1708
00:56:01,200 --> 00:56:03,109


1709
00:56:03,109 --> 00:56:05,670

 

1710
00:56:05,670 --> 00:56:07,670

 

1711
00:56:07,670 --> 00:56:11,109

 

1712
00:56:11,109 --> 00:56:13,030

 

1713
00:56:13,030 --> 00:56:15,670

 

1714
00:56:15,670 --> 00:56:17,910

 

1715
00:56:17,910 --> 00:56:18,950

 

1716
00:56:18,950 --> 00:56:20,710

 

1717
00:56:20,710 --> 00:56:20,720

 

1718
00:56:20,720 --> 00:56:22,069


1719
00:56:22,069 --> 00:56:23,829

 

1720
00:56:23,829 --> 00:56:27,670

 

1721
00:56:27,670 --> 00:56:31,990

 

1722
00:56:31,990 --> 00:56:35,750

 

1723
00:56:35,750 --> 00:56:38,309

 

1724
00:56:38,309 --> 00:56:40,549

 

1725
00:56:40,549 --> 00:56:40,559

 

1726
00:56:40,559 --> 00:56:41,589


1727
00:56:41,589 --> 00:56:44,309

 

1728
00:56:44,309 --> 00:56:47,030

 

1729
00:56:47,030 --> 00:56:49,750

 

1730
00:56:49,750 --> 00:56:51,030

 

1731
00:56:51,030 --> 00:56:52,309

 

1732
00:56:52,309 --> 00:56:54,549

 

1733
00:56:54,549 --> 00:56:56,470

 

1734
00:56:56,470 --> 00:56:58,870

 

1735
00:56:58,870 --> 00:57:00,470

 

1736
00:57:00,470 --> 00:57:03,190

 

1737
00:57:03,190 --> 00:57:05,589

 

1738
00:57:05,589 --> 00:57:05,599

 

1739
00:57:05,599 --> 00:57:06,950


1740
00:57:06,950 --> 00:57:09,190

 

1741
00:57:09,190 --> 00:57:12,309

 

1742
00:57:12,309 --> 00:57:14,950

 

1743
00:57:14,950 --> 00:57:17,190

 

1744
00:57:17,190 --> 00:57:21,109

 

1745
00:57:21,109 --> 00:57:21,119

 

1746
00:57:21,119 --> 00:57:23,190


1747
00:57:23,190 --> 00:57:25,270

 

1748
00:57:25,270 --> 00:57:26,870

 

1749
00:57:26,870 --> 00:57:27,990

 

1750
00:57:27,990 --> 00:57:30,470

 

1751
00:57:30,470 --> 00:57:32,870

 

1752
00:57:32,870 --> 00:57:34,630

 

1753
00:57:34,630 --> 00:57:37,530

 

1754
00:57:37,530 --> 00:57:37,540

 

1755
00:57:37,540 --> 00:57:38,829


1756
00:57:38,829 --> 00:57:41,190

 

1757
00:57:41,190 --> 00:57:43,270

 

1758
00:57:43,270 --> 00:57:43,280

 

1759
00:57:43,280 --> 00:57:44,390


1760
00:57:44,390 --> 00:57:47,349

 

1761
00:57:47,349 --> 00:57:47,359

 

1762
00:57:47,359 --> 00:57:48,630


1763
00:57:48,630 --> 00:57:49,670

 

1764
00:57:49,670 --> 00:57:49,680

 

1765
00:57:49,680 --> 00:57:51,190


1766
00:57:51,190 --> 00:57:53,349

 

1767
00:57:53,349 --> 00:57:55,670

 

1768
00:57:55,670 --> 00:57:58,470

 

1769
00:57:58,470 --> 00:58:00,390

 

1770
00:58:00,390 --> 00:58:02,950

 

1771
00:58:02,950 --> 00:58:04,950

 

1772
00:58:04,950 --> 00:58:07,030

 

1773
00:58:07,030 --> 00:58:09,670

 

1774
00:58:09,670 --> 00:58:11,990

 

1775
00:58:11,990 --> 00:58:13,670

 

1776
00:58:13,670 --> 00:58:16,950

 

1777
00:58:16,950 --> 00:58:19,430

 

1778
00:58:19,430 --> 00:58:21,510

 

1779
00:58:21,510 --> 00:58:23,510

 

1780
00:58:23,510 --> 00:58:25,990

 

1781
00:58:25,990 --> 00:58:26,000

 

1782
00:58:26,000 --> 00:58:26,950


1783
00:58:26,950 --> 00:58:28,309

 

1784
00:58:28,309 --> 00:58:31,190

 

1785
00:58:31,190 --> 00:58:34,069

 

1786
00:58:34,069 --> 00:58:35,990

 

1787
00:58:35,990 --> 00:58:36,000

 

1788
00:58:36,000 --> 00:58:36,950


1789
00:58:36,950 --> 00:58:39,270

 

1790
00:58:39,270 --> 00:58:41,589

 

1791
00:58:41,589 --> 00:58:41,599

 

1792
00:58:41,599 --> 00:58:43,030


1793
00:58:43,030 --> 00:58:44,950

 

1794
00:58:44,950 --> 00:58:47,270

 

1795
00:58:47,270 --> 00:58:48,710

 

1796
00:58:48,710 --> 00:58:51,109

 

1797
00:58:51,109 --> 00:58:53,670

 

1798
00:58:53,670 --> 00:58:56,309

 

1799
00:58:56,309 --> 00:58:57,510

 

1800
00:58:57,510 --> 00:59:00,470

 

1801
00:59:00,470 --> 00:59:02,309

 

1802
00:59:02,309 --> 00:59:03,910

 

1803
00:59:03,910 --> 00:59:05,349

 

1804
00:59:05,349 --> 00:59:08,150

 

1805
00:59:08,150 --> 00:59:11,270

 

1806
00:59:11,270 --> 00:59:13,910

 

1807
00:59:13,910 --> 00:59:16,630

 

1808
00:59:16,630 --> 00:59:18,470

 

1809
00:59:18,470 --> 00:59:21,109

 

1810
00:59:21,109 --> 00:59:21,119

 

1811
00:59:21,119 --> 00:59:21,990


1812
00:59:21,990 --> 00:59:23,910

 

1813
00:59:23,910 --> 00:59:25,910

 

1814
00:59:25,910 --> 00:59:29,030

 

1815
00:59:29,030 --> 00:59:30,829

 

1816
00:59:30,829 --> 00:59:32,870

 

1817
00:59:32,870 --> 00:59:35,349

 

1818
00:59:35,349 --> 00:59:38,390

 

1819
00:59:38,390 --> 00:59:38,400

 

1820
00:59:38,400 --> 00:59:39,589


1821
00:59:39,589 --> 00:59:41,270

 

1822
00:59:41,270 --> 00:59:43,430

 

1823
00:59:43,430 --> 00:59:44,470

 

1824
00:59:44,470 --> 00:59:46,789

 

1825
00:59:46,789 --> 00:59:48,630

 

1826
00:59:48,630 --> 00:59:50,549

 

1827
00:59:50,549 --> 00:59:51,990

 

1828
00:59:51,990 --> 00:59:53,750

 

1829
00:59:53,750 --> 00:59:56,150

 

1830
00:59:56,150 --> 00:59:58,789

 

1831
00:59:58,789 --> 01:00:01,030

 

1832
01:00:01,030 --> 01:00:01,040

 

1833
01:00:01,040 --> 01:00:02,069


1834
01:00:02,069 --> 01:00:04,230

 

1835
01:00:04,230 --> 01:00:06,710

 

1836
01:00:06,710 --> 01:00:06,720

 

1837
01:00:06,720 --> 01:00:07,430


1838
01:00:07,430 --> 01:00:07,440

 

1839
01:00:07,440 --> 01:00:08,789


1840
01:00:08,789 --> 01:00:10,950

 

1841
01:00:10,950 --> 01:00:12,710

 

1842
01:00:12,710 --> 01:00:15,349

 

1843
01:00:15,349 --> 01:00:17,670

 

1844
01:00:17,670 --> 01:00:19,670

 

1845
01:00:19,670 --> 01:00:19,680

 

1846
01:00:19,680 --> 01:00:20,470


1847
01:00:20,470 --> 01:00:22,069

 

1848
01:00:22,069 --> 01:00:23,589

 

1849
01:00:23,589 --> 01:00:26,069

 

1850
01:00:26,069 --> 01:00:29,750

 

1851
01:00:29,750 --> 01:00:31,589

 

1852
01:00:31,589 --> 01:00:33,589

 

1853
01:00:33,589 --> 01:00:36,309

 

1854
01:00:36,309 --> 01:00:38,150

 

1855
01:00:38,150 --> 01:00:40,870

 

1856
01:00:40,870 --> 01:00:43,270

 

1857
01:00:43,270 --> 01:00:43,280

 

1858
01:00:43,280 --> 01:00:44,789


1859
01:00:44,789 --> 01:00:47,270

 

1860
01:00:47,270 --> 01:00:49,349

 

1861
01:00:49,349 --> 01:00:50,789

 

1862
01:00:50,789 --> 01:00:50,799

 

1863
01:00:50,799 --> 01:00:52,470


1864
01:00:52,470 --> 01:00:54,870

 

1865
01:00:54,870 --> 01:00:56,230

 

1866
01:00:56,230 --> 01:00:58,069

 

1867
01:00:58,069 --> 01:01:00,069

 

1868
01:01:00,069 --> 01:01:02,950

 

1869
01:01:02,950 --> 01:01:05,109

 

1870
01:01:05,109 --> 01:01:07,829

 

1871
01:01:07,829 --> 01:01:09,670

 

1872
01:01:09,670 --> 01:01:11,589

 

1873
01:01:11,589 --> 01:01:12,950

 

1874
01:01:12,950 --> 01:01:14,870

 

1875
01:01:14,870 --> 01:01:16,870

 

1876
01:01:16,870 --> 01:01:19,510

 

1877
01:01:19,510 --> 01:01:21,190

 

1878
01:01:21,190 --> 01:01:21,200

 

1879
01:01:21,200 --> 01:01:22,390


1880
01:01:22,390 --> 01:01:22,400

 

1881
01:01:22,400 --> 01:01:23,270


1882
01:01:23,270 --> 01:01:25,829

 

1883
01:01:25,829 --> 01:01:27,510

 

1884
01:01:27,510 --> 01:01:29,510

 

1885
01:01:29,510 --> 01:01:29,520

 

1886
01:01:29,520 --> 01:01:30,630


1887
01:01:30,630 --> 01:01:30,640

 

1888
01:01:30,640 --> 01:01:31,750


1889
01:01:31,750 --> 01:01:33,270

 

1890
01:01:33,270 --> 01:01:35,910

 

1891
01:01:35,910 --> 01:01:37,349

 

1892
01:01:37,349 --> 01:01:39,510

 

1893
01:01:39,510 --> 01:01:43,670

 

1894
01:01:43,670 --> 01:01:47,430

 

1895
01:01:47,430 --> 01:01:49,670

 

1896
01:01:49,670 --> 01:01:56,549

 

1897
01:01:56,549 --> 01:01:58,630

 

1898
01:01:58,630 --> 01:02:01,190

 

1899
01:02:01,190 --> 01:02:01,200

 

1900
01:02:01,200 --> 01:02:02,630


1901
01:02:02,630 --> 01:02:04,630

 

1902
01:02:04,630 --> 01:02:06,150

 

1903
01:02:06,150 --> 01:02:09,190

 

1904
01:02:09,190 --> 01:02:09,200

 

1905
01:02:09,200 --> 01:02:10,230


1906
01:02:10,230 --> 01:02:12,069

 

1907
01:02:12,069 --> 01:02:16,470

 

1908
01:02:16,470 --> 01:02:18,230

 

1909
01:02:18,230 --> 01:02:21,670

 

1910
01:02:21,670 --> 01:02:24,549

 

1911
01:02:24,549 --> 01:02:26,630

 

1912
01:02:26,630 --> 01:02:28,470

 

1913
01:02:28,470 --> 01:02:30,470

 

1914
01:02:30,470 --> 01:02:34,470

 

1915
01:02:34,470 --> 01:02:37,430

 

1916
01:02:37,430 --> 01:02:39,109

 

1917
01:02:39,109 --> 01:02:40,710

 

1918
01:02:40,710 --> 01:02:40,720

 

1919
01:02:40,720 --> 01:02:42,069


1920
01:02:42,069 --> 01:02:44,390

 

1921
01:02:44,390 --> 01:02:44,400

 

1922
01:02:44,400 --> 01:02:45,990


1923
01:02:45,990 --> 01:02:47,190

 

1924
01:02:47,190 --> 01:02:48,309

 

1925
01:02:48,309 --> 01:02:51,510

 

1926
01:02:51,510 --> 01:02:51,520

 

1927
01:02:51,520 --> 01:02:53,670


1928
01:02:53,670 --> 01:02:57,190

 

1929
01:02:57,190 --> 01:02:59,430

 

1930
01:02:59,430 --> 01:03:02,470

 

1931
01:03:02,470 --> 01:03:04,069

 

1932
01:03:04,069 --> 01:03:06,309

 

1933
01:03:06,309 --> 01:03:07,829

 

1934
01:03:07,829 --> 01:03:11,670

 

1935
01:03:11,670 --> 01:03:26,630

 

1936
01:03:26,630 --> 01:03:26,640

 

1937
01:03:26,640 --> 01:03:28,720