1
00:00:03,120 --> 00:00:03,830

all right so  lecture seven was about uh many things  uh universal foldings by box pleading  maze folding and then lots of np  hardness  stuff so we're going to go through  things in that order  i thought i'd start by showing some  old history of box pleating where it  comes from the first design  is by this guy raymond maclean 1967  design called the  mooser train and you can see all the  creases are horizontal vertical and  diagonal 45 degrees  this is the original handwritten thing  and this is apparently before the time  of origami books  for the most part so people will just  photocopy this and hand it around and  just kind of distribute it out through  the origami community  and kind of spawned a revolution in  origami design because it was the first  it was the first model to make sort of a  very complicated  multi-object piece out of one piece of  paper happened to be a rectangle of  paper  but a pretty cool design and really got  people  thinking about and the basic original  principle in box pleating was to make  boxes and then find ways to attach them  together  and it's fairly powerful and believed to  be universal by origamis for a long time  and we proved it with that cube gadget  now the designs that come out of the  cube gadget are not especially efficient  i've got some ways to optimize it as you  saw but  at least it proves everything is  possible that you can make out of cubes  you can make out of  box pleating another kind of influential  design is this black forest cuckoo clock  for a long time one of the most  complicated origamis out there it's  designed by robert lang in the 80s  and there's a few of them in existence  and it has a lot of detail it has a  clock  that's correct twice a day and it's got  he was modeled after a real cuckoo clock  you  saw  in the black forest it's got a zillion  increases it starts from this long  rectangle of paper  and there's there's diagrams for it in  origami design secrets if you want to  make your own  and it's also based on this box pleading  idea and  sort of in the early days of the tree  theory and so on  uh so really before that kicked off box  pleating was around and people still do  basic box pleating although now there's  the fusion of the tree method with box  pleating there's a lot of designs based  on that  because they're easy to fold from a  angular perspective  easy to find where the creases are  anyway that's box bleeding  uh so next we go on to i think it's an  open problem yeah this is a cool open  problem  some reason never thought about it i've  sure briefly thought about it but never  worked on it  uh in the same way we get universal  hinge patterns box pleating can make any  polycube  what if you want to make out of this  simple cube gadget  can we design an analogous cube gadget  for tetrahedra  octahedra might be nice regular  octahedral tile space  out of something like a triangular grid  maybe with 30 degree  lines it's natural question open  maybe we'll work on it sometime but i  think it'd be neat you just need a  a nice gadget and then we know how to  compose them by induction  just like in lecture seven so it could  be a fun  fun thing to attack uh next we go to  maze folding so i thought i'd show  we've seen this maze fold the  6849 so this is folded by jenny and eli  based on the algorithm that you saw and  if  you might play with it on your problem  set three uh  design your own maze you can click any  pattern you want make whatever letters  you want  uh or any other cool orthogonal pattern  marty and i have made a bunch of  different print designs based around  this idea  taking not just the crease pattern you  get for folding here we're folding  the word yes in three dimensions but  we've shaded the original piece of paper  in this pattern so that it looks like  nothing up here but when you fold it  the shading comes together to spell no  it's kind of ambiguity  or the shadow of the yes is no and so on  and uh jenny and eli folded that as well  and here it is  the first folding um  but our idea is not necessarily two fold  them i mean it's cool that they can be  folded  and sneak conceptually but we also like  to design ones that really should not be  folded  so next one here is science and art  so you fold the science in three  dimensions and the art is in the  background lurking  there i imagine this will never be  folded  be rather painful here's another very  complicated one here we're playing  around with  putting little shaded regions in these  squares these are just the squares that  end up mapping to the flat parts  over here and so you get we took an  image and spliced it up into  thousands of pieces so you get this is a  photograph of martin gardner who  uh died a couple years ago  sadly we never met him but he was sort  of he was father of recreational  mathematics among other things also  magician  and lots of cool things so this is in  tribute to him  and this is our latest design in the  spirit we're trying to be a little more  artistic and just be about the crease  pattern not necessarily the folding  so the 3d thing that this folds into is  not shown here  and of course in theory all these lines  go off to infinity  but this spells the word glass we made  it when we were  at the pilchard last school this summer  uh and it's now on t-shirts of many  glass floors around the world  how many of them know exactly what it  folds into i don't know um  but it's pretty cool so we're working on  glass folding so that seemed like a  natural thing to do  so that is maze folding and see some  some designs how you can use it for cool  things  uh the next topic is  np hardness and that will be what we  spend most of today on  uh and so first kind of general question  is  what what does it all mean what does np  hardness really tell you are there  can you give me like a specific instance  that's hard  and this is more for people who haven't  seen mp hardness before  the answer is no np hardness is kind of  a  conceptual philosophical thing no  specific problem is ever np hard  it's all about whole families of  problems being hard  and really it's about measuring the  growth of problem complexity  with problem size so in this case it's  how much  running time do you need to do to solve  your problem  as a function of the problem size and  we're interested in whether that grows  only polynomially or  grows exponentially and np hardness  probably implies exponential growth  a nice example of this is chess so eight  by eight chess you know people have  spent many years  trying to solve it and and do it  perfectly and so play the be the best  player  but from a theoretical computer science  perspective chess in its original form  is trivial because it just has a  constant number of states you could just  enumerate them all  in constant time you know who wins in  chess  probably white but it's not very  satisfying  but the more interesting thing to say is  to study  chess as it grows and the natural way to  make it grow is with an end by end board  so an n by n board if i give you an  arrangement of chess pieces and i want  to know who wins  that you can prove is something even  stronger than np hardness called  x hardness so there you can actually  prove you need exponential time to solve  n by n chess  and that gives you a sense that chess  really is hard there's  there's not going to be a good algorithm  that magically will solve it for eight  by eight  because in general as support size  increases you know it has to grow  exponentially and probably eight by  eight is big enough  uh that there's no good algorithm to do  it  you can't prove that there's no good  algorithm to eight by eight but you can  prove there's no good algorithm to do n  by n  so that's the the limitation of  theoretical computer science and of np  hardness so  you take any particular crease pattern  you want to know whether it folds flat  there  you might be able to do that by  exhaustive search and exponential time  might be okay  but you know that as the crease patterns  get big you're totally screwed  so next question about hardness  is can we do it with a little less hand  waving so in a little bit more detail  because i covered a lot of proofs  so i'm going to look at two of them the  simple fold hardness  and the which is from partition and the  crease pattern flat foldability which is  from  not all equal sat and a three set and  that'll give some  some more details so let's start by  going through this proof so  remember in general with an empty  hardness reduction we want to take some  known hard problem  and convert it into our problem because  that proves that our problem is at least  as hard as the original one  so uh in this case the known hard  problem is i give you  n integers a1 a2 up to a n  and i want to know can i split them into  two groups so that  the two groups have equal sum and  here we're mapping that into the simple  fold problem  which was given a crease pattern can you  fold it can you fold all the creases  flat  by simple faults uh we're mapping it  into these  lengths these lengths are the ais  between the different legs of the  staircase and then there's this extra  stuff  this is a super long length length l and  this is a  doubly super long length 2l  and then there's this frame which has  height 2l and this part is aligned right  at the  midway and so the the idea was  if there's a partition uh  if there's a partition of the ai's into  two groups column group  group a and group b  then i'm going to fold some of the  creases  the ones between  between any two guys of different groups  because folding here corresponds to  switching directions  so whenever i fold i'm kind of switching  which group i'm in  and then group a will be all the up  directions and group b will be all the  down directions so maybe both of these  guys are in group b so they both go down  then this is a group a guy so we go up  and then down and then up  and if we get them a and b to be  balanced then we'll end up right where  we started  so we'll end up right at the middle  point here  and in that case there's these two more  folds this vertical fold  and that vertical fold and then where  you if you  sorry uh yeah i don't have it drawn here  when you do one more fold here this will  fall into the frame  and if you got this to stay if you got  this point basically to be aligned with  here then going up  l and then back down to l will not  collide with this box it just barely  fits  and so you fold that in then you fold  this vertical line  and you fold it back out okay so the  goal is just to get these two folds made  once they're made and it's back out here  you can finish all the folds that you  didn't fold before and what we're  checking here is that during all this  motion you don't get collision because  simple folds  are not allowed to collide during the  motion  so if this for example went too far down  or too far  up and it collided with the frame then  you wouldn't be able to make the second  vertical fold here because you'd have to  bring the frame with you and the frame's  not supposed to move  so in particular there's this question  uh  it seems like we're not making all the  folds and that's because i didn't say  the last part after you fold it in here  and avoid collision you fold it back out  with the second of these two folds then  you can finish all the folds  indeed the goal is to fold everything  but  in order to avoid collision when i fold  this this thing has to be nice and  compact and fit within this 2l boundary  then it goes through  so uh what we really need to show though  at a top level  is uh given any set of ai's  we can convert it into an equivalent  simple fold problem  there's actually two things we need to  check for equivalence we need to check  that  if there's a partition then there's a  way to fold it we also need to check the  reverse which is if there's a way to  fold it  then there's a partition but both of  these kind of follow from this argument  in order to when we make say this fold  this guy's got a or whichever of these  two is first they're kind of equivalent  uh if we collide we won't be able to  finish the folding  that's the claim um because you might  have done all the folds over here but  they'll be the second of these two  and so when you do the first you'll  either get stuck or you'll be able to  proceed if you were able to proceed you  can read off from the ups and downs here  what the partition was  so you can convert in either direction  using this reduction any more questions  about  the simple folds one it's of course one  of the easier  proofs the crease pattern flat  foldability is definitely on the  more complicated side and this was the  overview of the proof  uh basically there are lots of little  local gadgets  uh there's the wire which communicates  truth  truthiness or falsity as i like to say  or things like the main  gadget is the one at the top the not all  equal clause which forces  among the three wires coming in  they can't all have the same value so  they could be two true  one false or or two false one true  but not all true and not all false and  then we needed some auxiliary gadgets  for turning  duplicating and crossing over those were  fairly straightforward the heart is a  wire  and a not all equal clause and so the  idea was we  were given a formula in this case it's a  bunch of triples  and each of the triples should be not  all equal and there's like n variables  there's  a lot of different clauses on those  variables a lot of not all equal  constraints on those clauses we want to  represent that by the flat foldability  of a crease pattern so we are  given uh so we  basically make all the variables off the  left edge of the paper here  we make lots of copies of them by  zigzagging and then we make lots of  clauses at the top  we've only drawn two up there and then  in our input we're given a bunch of  triples of variables that should belong  to a common clause and we just  route these signals to go to that clause  and then the clauses constrain the  values of those variables  to be not all equal in the appropriate  triples  and the splitters down here enforce  all the different copies of that  variable to be the same  and so any flat folding will require  that  these guys are consistently assigned one  truth value throughout the construction  and those clauses will force not all  equal things to be  same in pairs so if there's a flat  folding of this you can read off from  the mountain valley assignment here  which one  you know based on which whether it's  left valley right mountain or left  mountain right valley  you can read off what the truth  assignment is that satisfies all the  clauses  so that was one direction from flat  foldability  to  to satisfiability of the not all equal  triples  in the reverse direction if there's a  not all equal assignment of triples  you need to verify that this thing  actually does fold flat  i did detail that but basically to do  that you have to prove that each of the  gadgets works  exactly as desired so you can really  fold it flat if  these have equal value for example and  this has a negated value  you can actually always fold the  non-equal clause when it's satisfied  and then once you know that each of  these gadgets because the gadgets are  very small  once you know that each of them folds  correctly and they have a sort of  compatible interface because these  things are just  extending through you can basically  paste glue together  all of those folded states so as long as  you verify the gadgets work  the whole thing will work provided there  is a satisfying assignment  so that's yeah question um can you  actually go in the other direction  properly in the sense  can you map any platform  okay can you map any flat foldability of  a crease pattern problem to  sat that doesn't follow from this proof  but i think it should  be true  let's see  i think so so if i give you a crease  pattern i want to know whether it folds  flat  as mentioned in lecture you can  determine where all the facets  lie in 2d and the challenge is the  stacking order  which implies the mountain valley  assignment so i think you could make a  variable and a sat  problem for you know this piece this  little polygon  lives in this stacking level you have to  figure out how many levels you need but  at most n of them i guess  and then write down the constraints  between uh  different polygons that there are no  crossings uh there's a paper by jacques  christine that does that explicitly  uh so that should give you a way to  reduce the sat which gives you an  algorithm  an exponential time algorithm to solve  it in general i'm pretty sure this  problem is nnp  which implies there's at least an  algorithm for it but  i think in particular you can reduce it  to satin  so that's a good question so pretty much  every problem we'll talk about at least  with origami has  a finite algorithm to solve it but it's  a very slow algorithm in general  of course there's a lot of good sat  solvers out there and uh i don't know if  people have actually tried to do that  i know there are some uh there's a  software called uh  oripa which in in japan which  some versions of try to find a valid  folding  valid folded state uh by some kind of  careful exhaustive search i don't think  they use sat solvers though you might  get more mileage out of sat solvers  other questions about this proof  there's one explicit question about the  reflector gadget this is probably worth  talking about because it  these arrows are maybe not so obvious  what they mean  so the question the question is what is  what is true and what is false that's  kind of  philosophy but in this case these arrows  are explicitly drawn  on this diagram if you look closely  there's an arrow this way and then this  way then this way  and that's defining what we mean by the  orientation of a wire  and then if it's a valley on the left  relative to the arrow  that's true if it's if it's mountain on  the left relative to the arrow  that's false and that's why this is  drawn this way assuming i got it right  here it's valley on the left relative to  the arrow here's mountain on the left  relative to the  arrow so notice these are pointing in  different directions  so i can get a little confusing but it's  kind of what we want in that proof  because we  really want to route the thing in this  direction we don't care about  what things look like relative to the  center here because the center  the gadget we are looking at keeps  changing  so we want to route this as a single  wire  and this one i already talked about you  need to prove both directions the flat  foldability implies not all equal  satisfiability  and the reverse  okay we move  on  so uh now we get to some new material  so i mentioned in the lecture that there  are two hardness proofs  the one we've been talking about is  given a crease pattern does it full flat  that's strongly empty hard  and the other is if i  give you something i might even tell you  it's flat foldable that's kind of not  too relevant  but i give you mountains and valleys and  i want to know  i want to find a valid folded state of  that  or i want to decide whether the mountain  valley pattern is valid  these are strongly and be hard and this  is a different proof it uses completely  different gadgets  so i thought i'd show you some of those  gadgets  uh the sort of the key ones so the first  part is the wire  and i think i made one of these oh maybe  i didn't  no wire uh well this is the end of a  watt  uh no that's not the end of a wire  here's an end of a wire so the idea here  is  uh we've got a fixed mountain valley  pattern now because we that's no longer  free for the folder to choose  and you've got two tabs and they can  stack one way or the other  in this case they can stack like this or  they can stack like that  so i've got a choice in stacking  that changes the folded state that's the  choice that the folder is going to make  but in either case the mountain valley  assignment is the same  so that's kind of how we're going to  communicate true and false and i haven't  provided orientation  should have drawn an arrow there uh  next gadget is this tab gadget and this  is just a tool  for building weird shapes and it's kind  of similar to some of the things we've  seen in the checkerboard folding  so crease pattern looks like this  and fold it flat  and oops there's two ways to fold it  actually a few different folded states  but in particular there's a state like  this  where there's this uh individually  manipulatable tab  and but it there's no crease here so it  can't go backwards the crease is in here  so it's gotta fall down like that  okay so that what we're gonna what this  reduction does  is ahead of time basically force a lot  of these foldings  and so we start with a square paper we  end up with a smaller square paper with  tabs sticking out in various directions  of various places so this is much  messier and be harder to draw the whole  diagram of what your crease planner  looks like but in theory you can do this  it's also kind of like the the box  bleeding method where you just  you make a cube ahead of time and it's  like you had a square originally there's  happens to be a cube sitting here  and then you do other folding and the  angles  in this crease pattern these are not 45  degrees they're at a bit of a weird  angle  to basically force this to happen first  it can't interact with any of the other  gadgets  that i show you because you've got to  get rid of those angles  in the beginning then the main gadget  here  is the nautil equal clause and that's  what i have folded here  so it's a little crazy but basically  you've got  three pleats uh three of these double  pleats coming together  these guys could stack on this one on  top this one on top  or the same for all three of them and  then you've got this little  twist like thing in the center and it's  really hard to draw what the folded  state looks like this is  what it looks like within shadow pattern  with transparency  here's the real thing and also there's  these yellow tabs  attached at very specific locations uh  and this is a little hard to imagine i  encourage you to fold one of these in  order to  really see what's going on but as  i said before you've got each of these  guys can be independently  stacked one way or the other says that  one  or this one can stack this way or that  way  for all three but we want to forbid the  case where it's where they're all  stacked the same way  and the arrows here are all pointing  towards the gadget so  we want to forbid the case when they're  all when it's rotationally symmetric  gadget is rotationally symmetric but if  you choose the layer order rotationally  symmetric you're in trouble  so let me make it rotationally symmetric  that would be like this so when it's  rotationally symmetric you see  basically all the panels you see there's  three panels  this one this one and this one each of  them has a tab sticking out  and basically the these tabs have to  also be cyclically ordered  but it's not possible this is hard to do  it's like this  you see they're kind of colliding here  because if you look at each of the tabs  in projection  it collides with where the tab is  attached  so you basically if you went  so someone has to be the lowest tab  and that tab will intersect uh one the  other two tabs actually  where uh that tab is attached so it'll  penetrate and  you can see they're not very happy to  stack here  but if i change the layer order in any  way  a lowest tab is actually happy to go  behind other layers  and then you can just kind of stack them  and they barely fit  so it's a little tricky to get all the  details here to work but i think this  particular geometry and the reason i  drew this in this exact way is to make  sure yeah  everything works you do not penetrate  here which would be a problem  you do not penetrate this crease which  would be a problem so the tab just fits  in between here and here  but it does cross if you look at this  tab  it's attached along this edge as drawn  up there  and this tab here will penetrate this  part of that edge  and it will penetrate this part of this  edge which is where this tab is attached  so  they cause trouble in the cyclic  situation but  when it's acyclic like in this picture  you can put that bottom tab  way down here and avoid any collision  then you can you basically break the  cyclic condition  and you get to stack them in some linear  order  so it's a little hard to see without  physically manipulating it feel free to  come and play with it after  that's their proof now there's also  splitters and  turn gadgets and crossovers but  i'll leave it at that there's those are  more similar  this is sort of the heart of what's  going on in this proof  so it's completely separate proof from  the one that we saw before  any questions about that  all right yes yeah  why how do the tabs fold no why do you  need it  and everything follows  so that the tabs are being used as a  device to build gadgets so the tabs  serve no purpose by themselves but  this gadget involves first folding three  tabs here  which are actually pointing uh they're  pointing in that direction i believe  then you add this crease pattern  afterwards  so originally there are tabs here which  means there's a bunch of creases  here after you fold them then you lay on  this crease pattern so if you unfolded  it you get some much more complicated  crease pattern which is when  when i made that i just taped the tabs  on but in reality first you fold the  tabs  so they exist there then you fold this  on top so the full crease founder would  be quite complicated  it's going to have tabs here tabs here  tabs there  and then this reflected a few times  and so then when you fold it the full  gadget is this thing with the tabs  the tabs are just like a stepping stone  toward making this gadget  the other gadgets use more tabs uh  obvious open problem here is to make a  simpler reduction  shouldn't have to be this complicated  and i've heard tom hall talk about  different approaches  for making simpler empty hardness proofs  but we're not there yet  other questions if these fruits don't  imply anything about the  rest of the platforming problem that  they could argue very easily  it's just this particular family of  platforming problems  uh so this proof implies that these  kinds of  tessellation style crease patterns are  hard to fold  which implies that in general crease  patterns are hard to fold  but you could look at some other  specific pattern for example that's the  next topic  you could look at map folding  where you have horizontal and vertical  creases  in a rectangular sheet of paper maybe  each of these squares is  each of these cells is a unit square  let's say  and i give you mountain valley  assignment on that some of these are  some of these are mountains some of them  are valleys  uh whatever and i want to know does this  fold flat  that we don't know the complexity of  could be  solvable by a polynomial time algorithm  could be np hard  this is actually mentioned in uh  lecture two notes but not actually  orally  uh and so i wanted to get back to this  so this is from lecture two notes  2d map folding jack edmonds pose this  problem can you characterize flat  foldable mountain valley patterns is  there an algorithm or is it np hard  and even the two by n problem was open  when i wrote these notes in 2010 but it  has since been solved  so i thought i'd tell you a little bit  about that solution  so yeah there can be special cases of  crease patterns that are easy to solve  we just know in general  they are hard so  2 by n this kind of picture so this is  what i call  two counting cells  this is uh  based on a class project in this class  from two years ago  by eric liu and tom morgan but the  paper got finished this year uh  so it's based on a series of reductions  on the one hand we're going to start  with something called okay so we have  let's say map folding on the left  we're going to convert map folding into  a different representation which is  news labeling  we're going to convert that into  something called a top edge view  we're going to convert that into ray  diagram  and the last part which i won't talk too  much about  is we convert that into something called  a hidden tree problem  each of these steps is fairly  straightforward but there are obviously  a lot of them  uh and but in the end you get  a polynomial time algorithm to solve  this which implies you get a polynomial  time algorithm to solve this  and i'll talk mostly about these  reductions it's the same idea in np  hardness we use reductions from a hard  problem  to our problem in this case we're  doing the reverse we're reducing our  problem to an easier problem  so that by the end we get something  that's so easy we know how to solve it  so reductions are useful both for  positive  results and negative results so let me  show you visually some  uh oh before we get to the proof i  wanted to mention  this puzzle which you probably folded in  problem set one  it's a math folding problem right you've  got it's a three by three map  and so we didn't have any good  algorithms to solve them  so we used a not so good algorithm  namely exhaustive enumeration we  enumerated all possible folded states of  a three 3x3 map  we drew them out graphically this is  there's a scroll bar here so you don't  see them all  but we put them in a giant i forget  there's uh there's 1 000  folded states or so so it's like 100 by  whatever uh 10 array  and for each of them so here's where  you're designing your pattern  so we would make you could make holes uh  you could put in patterns this is sort  of an early design where it would spell  mit  the whole would show the eye on another  side so it's equivalent to the  puzzle that you you solved and this is  what the top looks like this is what the  bottom looks like so you could  you could hover over these and change  the letters that were that appeared  and then it would show you what every  single state would look like and it  would color it in yellow if one side  looked like mit and would color it in  red if both sides looked like mit  and the point was to verify there was  exactly one solution  for that puzzle and so we we kept we  would fold things to make it a tricky  fold then we put it into the software  and you know label things accordingly  then put it into the software and see is  there unique folding and then we could  add in  extra sort of misleading clues  here and see did they accidentally make  an extra solution  so we could add in extra stuff to pack  in as much  irrelevant stuff as we could and still  make it unique so it's more challenging  that was a nice use of exponential  algorithms to design  puzzles all right but back to  this proof  so i have here a much simpler map than  this one  this is what we call the new map  n-e-w so the labeling here is very  simple if you look at this crease  pattern  by mayakawa there's got to be three of  one type and one  of the other type so just label  each vertex by which way is unique so  from here the north direction  is the uniquely label it's the mountain  among three valleys  and then this vertex the east label is  the mountain among three valleys and  then the next one is the west label  among three valleys of course it doesn't  have to be like that it could  for example you can have three mountains  at a vertex  but then the label of this guy is going  to be w it's going to be the one that's  unique among the other three  okay so if you fold this map it looks  like this  i have one here but uh a little hard to  see  we've got lots of back and forth on the  top edge  so i'm orienting it so that the  we've got two by end map so there's sort  of two critical features there's the  the center line i'll call that the spine  of the map there's the  the top side and the bottom side when  you fold that let me this is just a  sequence of simple folds  you see at this last fold the top side  and the bottom side come together  and the spine is stays together  so when i orient it like this as in the  picture that  the top side is where uh originally the  top and the bottom of the map all come  to here because of that  spine fold and the spine folds are all  down here  okay there are you can't see them here  but there's uh  see them at the bottom there there's  some kind of connections on the bottom  but there's this nice kind of relatively  one-dimensional picture  up here so we're going to draw that  this is the top edge view  got clipped a little bit but there's one  more segment at the top  so that is just this  see it now there's also these blue lines  the blue lines correspond  to what's going on at the bottom on from  the spine  because if you think about it you've got  you've got the  in a two by end map you've got the top  panels  and these edges making the top edge  you've also got the bottom panels and  these edges making the bottom edge they  come in pairs  these guys are paired up these guys are  paired up and so on  down the line because they are joined by  a spine edge  those spine edges correspond to the  things on the bottom of the folding  and they need to not cross each other  and that's what's illustrated by the  blue connections so  the very top edge is paired with the  very bottom edge  these two this panel here and the back  panel here  are connected on the bottom and that oh  sorry that's not true  this one is paired with this one the top  one is paired with the second one  so it's actually these two are connected  on the bottom that's  this little connection here and then  these guys  this wraps around everything that's that  connection  but what you can't see in this folding  because it's hidden inside  is that within this connection on the  bottom there's this connection on the  bottom and within that one  there's this connection now this is okay  might look like they're crossing because  they're overlapping  but as long as they're nested as long as  you don't like start from  inside here and go to outside that would  be a crossing  if you start inside you should end  inside like in all of these pictures  if you start outside you should end  outside so that's like these guys are  disjoint so that's okay  this is nested in that so it's okay kind  of like balanced parentheses  and so that's what it makes a top valid  top edge view what's nice about this is  it's a one-dimensional diagram  what's not nice is it has all these  crossings because there's the blue stuff  on top of the black stuff  so it's a little hard to find uh  we're trying to find a valley fold state  we're trying to find one of these  we're not restricting ourselves to  simple folds here yeah simple fold  simple map folding we already solved in  lecture two so this is all i should have  said  non-simple folds  that's what makes it hard and that's  what's still open for  three by end maps we don't know how to  do it but for two by end maps  so we've made two steps here we can we  have another view which is the ray  diagram  and this is really specific to two by n  and it lets us reduce to a kind of tree  problem  so uh before we get there  let's talk in general about the top edge  view you can actually  convert from the northeast west south  labeling to a top edge view in the  following way  uh whenever and you can kind of see  what's going on so first we have an  n so we've got these two guys which are  just paired together happily that's the  beginning of the map  then we turn left and we've got this guy  paired with this guy and so in general  whenever you have a north you turn left  with your two guys  all right so that's what happens then we  hit an east in the map  and what happens here is this guy turns  right but this one turns left  this is what you might call an inside  turn it's like an inside reverse fold in  origami  and in general whenever you have an east  you you turn inside like that so these  this guy is paired with that one and now  this guy's paired with that one they  both  turn in and then it's symmetric uh next  one is a w  which is the opposite of an e which  means you turn out  here and in general whenever you have a  west you turn out  and south you turn right so those are  the four possible things you can imagine  when you have a pair of things turning  and those exactly correspond to any w  and s  so it's clear what you need to do in  this situation  but there's still there's flexibility  right for example  this guy when you turn out here i turned  out to the very next layer but this  could have turned out to go  up here would that be okay  no if this one turned out to go up here  that edge up there would be paired with  this one down here  so there'd be a blue line going like  that and that would be a crossing  situation  because that blue line would cross this  one because it starts inside and it goes  to outside  so it's a little tricky this this  definitely gives you  some of the layer constraints but it  doesn't check for crossings  which is the big challenge in this  problem uh so we're going to simplify  this diagram  so just just think about top edge views  forget about mat folding now you can  forget about the previous layers and we  are now focusing on this reduction  so we've got top edge view converting to  array diagram as you can see it's much  simpler  this is the ray diagram of that picture  and essentially  there's two ways to think about what  we're doing instead of having two edges  and we track two edges turning  we just want one edge that's one thing  we're doing you can think of that  as tracking the spine  instead of the the top and the bottom  sides  but it's a little is the ray diagram is  going to get confusing i'll just  tell you that now um it every time i  look at it i  understand it a little bit more but it's  not going to be obvious that this is  equivalent to this  i'll just tell you here's an alternate  way to think about it  basically the vertical the y direction  here  is going to be nesting depth so whenever  we go  in like this we go deeper uh  so for whatever reason i've flipped the  labeling but it is indeed east when you  go  in you go down i should have just  moved these two figures so they  correspond but uh  when you go east you go down a layer  because  you're nesting deeper and when you go  west you're going out  so you go up a layer in this new weird  ray diagram view  and north and south turn out to not turn  around  in this view we're just going to fire a  ray  downward and there's either a north ray  a blue one or south ray a red one  and so if you follow this diagram it's  it's n-e-w  so first we have an n which means we  shoot a ray down  then we have an e which means we go turn  downwards and then we have a w which  means we turn to go up a layer  and i haven't told you what the  constraints are here but i claim this is  a valid folding just like that one  it's obviously a lot easier to draw it's  a much slower complexity  but the cool thing is you no longer have  these crossing parts  so let me show you first let me tell you  what the constraints are  so in general you're going to have lots  of downward rays this is a north this is  a south and north is south  so if you had like nsns in your pattern  just going to be a straight segment with  downward rays of different colors  first constrains whenever you have a an  n ray it ha  a north ray it has to hit another north  ray or just go off to infinity  and same south rays can only hit south  rays or go off to infinity  so they kind of line up in this way but  you can stretch the x  coordinate to do whatever you want this  corresponds to basically jumping over a  bunch of layers when you  turn in your folded state you can skip a  bunch of layers and just go up here  so that corresponds to jumping over a  bunch of folds here  but in particular we get these things  called constrained segments constrained  segments are  portions of this black spine between two  rays  that below it only see black  okay so for example this one is  unconstrained because below it you can  see off to infinity so that's  unconcerned we don't care about that one  but among constrained segments these are  two constraint segments  we want that all of the rays that they  see below them so here i see one red  right one blue ray  i want the number of reds and blues to  be equal so this is valid because  there's one of  one red one blue this one is invalid  because there's two blue  and one red this turns out to be the  right constraint  essentially this is saying however much  you spiral you should un-spiral  that's the intuition uh so here you're  spiraling twice unspiraling once so  you're  tuck you're trapped inside and so these  folds cannot actually come together  the rays coming together correspond to a  nice nesting between two  uh north folds  so this it's not obvious but this turns  out to be the only constraints you have  the black should not cross itself  constraint segments should be valid in  this way  and blue should hit blue and red should  hit red  so that's not obvious but it's true and  then you can  take very complicated diagrams like this  and simplify them into these nice  pictures  so uh this these are two different  foldings of the same  pattern which i guess is n  e n if i can see that easily here  you could also extract it from here um  there's two foldings because  these two layers could go here in the  middle or they could be pushed  up to fit in here and then we get this  picture  okay and in the ray diagram you can see  this pretty easily  either you have these n rays just both  go off to infinity  and this is an unconstrained segment so  we don't care about that there's only  one  north ray below or you can extend the x  because i can stretch the x parts  however i want  and make these blue segments align with  each other  and that corresponds to this folding so  really all folded states of the original  thing are represented by the ray diagram  of course if i had any w this would be  valid but this would  would not not be that sorry any s  blast from the past if i had an nes then  uh  you know this would be blue this would  be red and so this would be valid but  this would be invalid  and so on so it's obviously a lot easier  conceptually  but you can also here's a more  complicated algorithm take a really  crazy map  this notation by the way was introduced  by jacques justine in like  late 1980s you may remember his name  from kawasaki justine theorem  so at the same time he was looking at  matt folding and he came up with this  notation  the ray diagram was introduced in the  open problem session this class two  years ago  or actually five years ago if i recall  correctly  by david charlton and yo-yo zhao  and then it was picked up again two  years ago and finally  we took this ray diagram and came up  with an algorithm so how does the  algorithm work  here's a ray diagram the black and the  red and the the blue  we observe that the blank space  here between the spine stuff  between all the black is kind of a tree  structure  right you've got and that's what's drawn  in cyan with the red dots  so if you draw a node every time you  turn around  on the outside then you say well i can  get from this node to  this one so i'm going to draw a segment  there and i can get from this node to  this one without crossing any black so  i'll draw a segment there  that's sort of it on that side there's  nothing else down here that  sort of doesn't count but here is  another dot and i can get from this one  to there by going out here without  crossing black  here to here here to over here without  crossing black  so on so that cyan structure is a tree  has no cycles  which in general is good news for  algorithms trees  are relatively easy to find algorithms  for using dynamic programming  so if you've seen dynamic programming  for trees this is not like that it's a  little different because we don't know  what the tree is  we have to figure out what the tree is  but basically we can guess the tree  recursively  so you know there's some first node i  don't know maybe it's this one  just guess that not randomly but guess  means try all the options  so you guess some node and then okay  we've got maybe we've got  two subtrees maybe we've got three uh  i think that's about all there could be  uh  and so just guess that and then so we  recursively guess  a sub tree here and a sub tree here and  each of the sub trees corresponds to a  sub-segment  of this uh  of the original map of the spine roughly  speaking  and roughly speaking uh these these  portions do not  interact with each other there's this  issue of how the rays align  and that's sort of the challenge in  getting this algorithm to work but you  can essentially locally check whether  subtree is good enough  that it will interact okay with a  different subtree and just split this  problem up recursively guessing all the  way effectively trying all trees  but in polynomial time instead of  exponential time forget the running time  is something like n to the  10 or some some really big constant but  at least finally we know two by n  maps can be solved in polynomial time  with a given mountain valley assignment  we still don't know  about three by n that's the big open  question  and this these techniques unfortunately  don't seem to apply you definitely don't  get a tree anymore  you might get some nice structure that's  kind of vaguely tree-like but  this was already super complicated so  we've gotten stuck here any questions  all right that's it  you

2
00:00:03,830 --> 00:00:07,030
all right so  lecture seven was about uh many things  uh universal foldings by box pleading  maze folding and then lots of np  hardness  stuff so we're going to go through  things in that order  i thought i'd start by showing some  old history of box pleating where it  comes from the first design  is by this guy raymond maclean 1967  design called the  mooser train and you can see all the  creases are horizontal vertical and  diagonal 45 degrees  this is the original handwritten thing  and this is apparently before the time  of origami books  for the most part so people will just  photocopy this and hand it around and  just kind of distribute it out through  the origami community  and kind of spawned a revolution in  origami design because it was the first  it was the first model to make sort of a  very complicated  multi-object piece out of one piece of  paper happened to be a rectangle of  paper  but a pretty cool design and really got  people  thinking about and the basic original  principle in box pleating was to make  boxes and then find ways to attach them  together  and it's fairly powerful and believed to  be universal by origamis for a long time  and we proved it with that cube gadget  now the designs that come out of the  cube gadget are not especially efficient  i've got some ways to optimize it as you  saw but  at least it proves everything is  possible that you can make out of cubes  you can make out of  box pleating another kind of influential  design is this black forest cuckoo clock  for a long time one of the most  complicated origamis out there it's  designed by robert lang in the 80s  and there's a few of them in existence  and it has a lot of detail it has a  clock  that's correct twice a day and it's got  he was modeled after a real cuckoo clock  you  saw  in the black forest it's got a zillion  increases it starts from this long  rectangle of paper  and there's there's diagrams for it in  origami design secrets if you want to  make your own  and it's also based on this box pleading  idea and  sort of in the early days of the tree  theory and so on  uh so really before that kicked off box  pleating was around and people still do  basic box pleating although now there's  the fusion of the tree method with box  pleating there's a lot of designs based  on that  because they're easy to fold from a  angular perspective  easy to find where the creases are  anyway that's box bleeding  uh so next we go on to i think it's an  open problem yeah this is a cool open  problem  some reason never thought about it i've  sure briefly thought about it but never  worked on it  uh in the same way we get universal  hinge patterns box pleating can make any  polycube  what if you want to make out of this  simple cube gadget  can we design an analogous cube gadget  for tetrahedra  octahedra might be nice regular  octahedral tile space  out of something like a triangular grid  maybe with 30 degree  lines it's natural question open  maybe we'll work on it sometime but i  think it'd be neat you just need a  a nice gadget and then we know how to  compose them by induction  just like in lecture seven so it could  be a fun  fun thing to attack uh next we go to  maze folding so i thought i'd show  we've seen this maze fold the  6849 so this is folded by jenny and eli  based on the algorithm that you saw and  if  you might play with it on your problem  set three uh  design your own maze you can click any  pattern you want make whatever letters  you want  uh or any other cool orthogonal pattern  marty and i have made a bunch of  different print designs based around  this idea  taking not just the crease pattern you  get for folding here we're folding  the word yes in three dimensions but  we've shaded the original piece of paper  in this pattern so that it looks like  nothing up here but when you fold it  the shading comes together to spell no  it's kind of ambiguity  or the shadow of the yes is no and so on  and uh jenny and eli folded that as well  and here it is  the first folding um  but our idea is not necessarily two fold  them i mean it's cool that they can be  folded  and sneak conceptually but we also like  to design ones that really should not be  folded  so next one here is science and art  so you fold the science in three  dimensions and the art is in the  background lurking  there i imagine this will never be  folded  be rather painful here's another very  complicated one here we're playing  around with  putting little shaded regions in these  squares these are just the squares that  end up mapping to the flat parts  over here and so you get we took an  image and spliced it up into  thousands of pieces so you get this is a  photograph of martin gardner who  uh died a couple years ago  sadly we never met him but he was sort  of he was father of recreational  mathematics among other things also  magician  and lots of cool things so this is in  tribute to him  and this is our latest design in the  spirit we're trying to be a little more  artistic and just be about the crease  pattern not necessarily the folding  so the 3d thing that this folds into is  not shown here  and of course in theory all these lines  go off to infinity  but this spells the word glass we made  it when we were  at the pilchard last school this summer  uh and it's now on t-shirts of many  glass floors around the world  how many of them know exactly what it  folds into i don't know um  but it's pretty cool so we're working on  glass folding so that seemed like a  natural thing to do  so that is maze folding and see some  some designs how you can use it for cool  things  uh the next topic is  np hardness and that will be what we  spend most of today on  uh and so first kind of general question  is  what what does it all mean what does np  hardness really tell you are there  can you give me like a specific instance  that's hard  and this is more for people who haven't  seen mp hardness before  the answer is no np hardness is kind of  a  conceptual philosophical thing no  specific problem is ever np hard  it's all about whole families of  problems being hard  and really it's about measuring the  growth of problem complexity  with problem size so in this case it's  how much  running time do you need to do to solve  your problem  as a function of the problem size and  we're interested in whether that grows  only polynomially or  grows exponentially and np hardness  probably implies exponential growth  a nice example of this is chess so eight  by eight chess you know people have  spent many years  trying to solve it and and do it  perfectly and so play the be the best  player  but from a theoretical computer science  perspective chess in its original form  is trivial because it just has a  constant number of states you could just  enumerate them all  in constant time you know who wins in  chess  probably white but it's not very  satisfying  but the more interesting thing to say is  to study  chess as it grows and the natural way to  make it grow is with an end by end board  so an n by n board if i give you an  arrangement of chess pieces and i want  to know who wins  that you can prove is something even  stronger than np hardness called  x hardness so there you can actually  prove you need exponential time to solve  n by n chess  and that gives you a sense that chess  really is hard there's  there's not going to be a good algorithm  that magically will solve it for eight  by eight  because in general as support size  increases you know it has to grow  exponentially and probably eight by  eight is big enough  uh that there's no good algorithm to do  it  you can't prove that there's no good  algorithm to eight by eight but you can  prove there's no good algorithm to do n  by n  so that's the the limitation of  theoretical computer science and of np  hardness so  you take any particular crease pattern  you want to know whether it folds flat  there  you might be able to do that by  exhaustive search and exponential time  might be okay  but you know that as the crease patterns  get big you're totally screwed  so next question about hardness  is can we do it with a little less hand  waving so in a little bit more detail  because i covered a lot of proofs  so i'm going to look at two of them the  simple fold hardness  and the which is from partition and the  crease pattern flat foldability which is  from  not all equal sat and a three set and  that'll give some  some more details so let's start by  going through this proof so  remember in general with an empty  hardness reduction we want to take some  known hard problem  and convert it into our problem because  that proves that our problem is at least  as hard as the original one  so uh in this case the known hard  problem is i give you  n integers a1 a2 up to a n  and i want to know can i split them into  two groups so that  the two groups have equal sum and  here we're mapping that into the simple  fold problem  which was given a crease pattern can you  fold it can you fold all the creases  flat  by simple faults uh we're mapping it  into these  lengths these lengths are the ais  between the different legs of the  staircase and then there's this extra  stuff  this is a super long length length l and  this is a  doubly super long length 2l  and then there's this frame which has  height 2l and this part is aligned right  at the  midway and so the the idea was  if there's a partition uh  if there's a partition of the ai's into  two groups column group  group a and group b  then i'm going to fold some of the  creases  the ones between  between any two guys of different groups  because folding here corresponds to  switching directions  so whenever i fold i'm kind of switching  which group i'm in  and then group a will be all the up  directions and group b will be all the  down directions so maybe both of these  guys are in group b so they both go down  then this is a group a guy so we go up  and then down and then up  and if we get them a and b to be  balanced then we'll end up right where  we started  so we'll end up right at the middle  point here  and in that case there's these two more  folds this vertical fold  and that vertical fold and then where  you if you  sorry uh yeah i don't have it drawn here  when you do one more fold here this will  fall into the frame  and if you got this to stay if you got  this point basically to be aligned with  here then going up  l and then back down to l will not  collide with this box it just barely  fits  and so you fold that in then you fold  this vertical line  and you fold it back out okay so the  goal is just to get these two folds made  once they're made and it's back out here  you can finish all the folds that you  didn't fold before and what we're  checking here is that during all this  motion you don't get collision because  simple folds  are not allowed to collide during the  motion  so if this for example went too far down  or too far  up and it collided with the frame then  you wouldn't be able to make the second  vertical fold here because you'd have to  bring the frame with you and the frame's  not supposed to move  so in particular there's this question  uh  it seems like we're not making all the  folds and that's because i didn't say  the last part after you fold it in here  and avoid collision you fold it back out  with the second of these two folds then  you can finish all the folds  indeed the goal is to fold everything  but  in order to avoid collision when i fold  this this thing has to be nice and  compact and fit within this 2l boundary  then it goes through  so uh what we really need to show though  at a top level  is uh given any set of ai's  we can convert it into an equivalent  simple fold problem  there's actually two things we need to  check for equivalence we need to check  that  if there's a partition then there's a  way to fold it we also need to check the  reverse which is if there's a way to  fold it  then there's a partition but both of  these kind of follow from this argument  in order to when we make say this fold  this guy's got a or whichever of these  two is first they're kind of equivalent  uh if we collide we won't be able to  finish the folding  that's the claim um because you might  have done all the folds over here but  they'll be the second of these two  and so when you do the first you'll  either get stuck or you'll be able to  proceed if you were able to proceed you  can read off from the ups and downs here  what the partition was  so you can convert in either direction  using this reduction any more questions  about  the simple folds one it's of course one  of the easier  proofs the crease pattern flat  foldability is definitely on the  more complicated side and this was the  overview of the proof  uh basically there are lots of little  local gadgets  uh there's the wire which communicates  truth  truthiness or falsity as i like to say  or things like the main  gadget is the one at the top the not all  equal clause which forces  among the three wires coming in  they can't all have the same value so  they could be two true  one false or or two false one true  but not all true and not all false and  then we needed some auxiliary gadgets  for turning  duplicating and crossing over those were  fairly straightforward the heart is a  wire  and a not all equal clause and so the  idea was we  were given a formula in this case it's a  bunch of triples  and each of the triples should be not  all equal and there's like n variables  there's  a lot of different clauses on those  variables a lot of not all equal  constraints on those clauses we want to  represent that by the flat foldability  of a crease pattern so we are  given uh so we  basically make all the variables off the  left edge of the paper here  we make lots of copies of them by  zigzagging and then we make lots of  clauses at the top  we've only drawn two up there and then  in our input we're given a bunch of  triples of variables that should belong  to a common clause and we just  route these signals to go to that clause  and then the clauses constrain the  values of those variables  to be not all equal in the appropriate  triples  and the splitters down here enforce  all the different copies of that  variable to be the same  and so any flat folding will require  that  these guys are consistently assigned one  truth value throughout the construction  and those clauses will force not all  equal things to be  same in pairs so if there's a flat  folding of this you can read off from  the mountain valley assignment here  which one  you know based on which whether it's  left valley right mountain or left  mountain right valley  you can read off what the truth  assignment is that satisfies all the  clauses  so that was one direction from flat  foldability  to  to satisfiability of the not all equal  triples  in the reverse direction if there's a  not all equal assignment of triples  you need to verify that this thing  actually does fold flat  i did detail that but basically to do  that you have to prove that each of the  gadgets works  exactly as desired so you can really  fold it flat if  these have equal value for example and  this has a negated value  you can actually always fold the  non-equal clause when it's satisfied  and then once you know that each of  these gadgets because the gadgets are  very small  once you know that each of them folds  correctly and they have a sort of  compatible interface because these  things are just  extending through you can basically  paste glue together  all of those folded states so as long as  you verify the gadgets work  the whole thing will work provided there  is a satisfying assignment  so that's yeah question um can you  actually go in the other direction  properly in the sense  can you map any platform  okay can you map any flat foldability of  a crease pattern problem to  sat that doesn't follow from this proof  but i think it should  be true  let's see  i think so so if i give you a crease  pattern i want to know whether it folds  flat  as mentioned in lecture you can  determine where all the facets  lie in 2d and the challenge is the  stacking order  which implies the mountain valley  assignment so i think you could make a  variable and a sat  problem for you know this piece this  little polygon  lives in this stacking level you have to  figure out how many levels you need but  at most n of them i guess  and then write down the constraints  between uh  different polygons that there are no  crossings uh there's a paper by jacques  christine that does that explicitly  uh so that should give you a way to  reduce the sat which gives you an  algorithm  an exponential time algorithm to solve  it in general i'm pretty sure this  problem is nnp  which implies there's at least an  algorithm for it but  i think in particular you can reduce it  to satin  so that's a good question so pretty much  every problem we'll talk about at least  with origami has  a finite algorithm to solve it but it's  a very slow algorithm in general  of course there's a lot of good sat  solvers out there and uh i don't know if  people have actually tried to do that  i know there are some uh there's a  software called uh  oripa which in in japan which  some versions of try to find a valid  folding  valid folded state uh by some kind of  careful exhaustive search i don't think  they use sat solvers though you might  get more mileage out of sat solvers  other questions about this proof  there's one explicit question about the  reflector gadget this is probably worth  talking about because it  these arrows are maybe not so obvious  what they mean  so the question the question is what is  what is true and what is false that's  kind of  philosophy but in this case these arrows  are explicitly drawn  on this diagram if you look closely  there's an arrow this way and then this  way then this way  and that's defining what we mean by the  orientation of a wire  and then if it's a valley on the left  relative to the arrow  that's true if it's if it's mountain on  the left relative to the arrow  that's false and that's why this is  drawn this way assuming i got it right  here it's valley on the left relative to  the arrow here's mountain on the left  relative to the  arrow so notice these are pointing in  different directions  so i can get a little confusing but it's  kind of what we want in that proof  because we  really want to route the thing in this  direction we don't care about  what things look like relative to the  center here because the center  the gadget we are looking at keeps  changing  so we want to route this as a single  wire  and this one i already talked about you  need to prove both directions the flat  foldability implies not all equal  satisfiability  and the reverse  okay we move  on  so uh now we get to some new material  so i mentioned in the lecture that there  are two hardness proofs  the one we've been talking about is  given a crease pattern does it full flat  that's strongly empty hard  and the other is if i  give you something i might even tell you  it's flat foldable that's kind of not  too relevant  but i give you mountains and valleys and  i want to know  i want to find a valid folded state of  that  or i want to decide whether the mountain  valley pattern is valid  these are strongly and be hard and this  is a different proof it uses completely  different gadgets  so i thought i'd show you some of those  gadgets  uh the sort of the key ones so the first  part is the wire  and i think i made one of these oh maybe  i didn't  no wire uh well this is the end of a  watt  uh no that's not the end of a wire  here's an end of a wire so the idea here  is  uh we've got a fixed mountain valley  pattern now because we that's no longer  free for the folder to choose  and you've got two tabs and they can  stack one way or the other  in this case they can stack like this or  they can stack like that  so i've got a choice in stacking  that changes the folded state that's the  choice that the folder is going to make  but in either case the mountain valley  assignment is the same  so that's kind of how we're going to  communicate true and false and i haven't  provided orientation  should have drawn an arrow there uh  next gadget is this tab gadget and this  is just a tool  for building weird shapes and it's kind  of similar to some of the things we've  seen in the checkerboard folding  so crease pattern looks like this  and fold it flat  and oops there's two ways to fold it  actually a few different folded states  but in particular there's a state like  this  where there's this uh individually  manipulatable tab  and but it there's no crease here so it  can't go backwards the crease is in here  so it's gotta fall down like that  okay so that what we're gonna what this  reduction does  is ahead of time basically force a lot  of these foldings  and so we start with a square paper we  end up with a smaller square paper with  tabs sticking out in various directions  of various places so this is much  messier and be harder to draw the whole  diagram of what your crease planner  looks like but in theory you can do this  it's also kind of like the the box  bleeding method where you just  you make a cube ahead of time and it's  like you had a square originally there's  happens to be a cube sitting here  and then you do other folding and the  angles  in this crease pattern these are not 45  degrees they're at a bit of a weird  angle  to basically force this to happen first  it can't interact with any of the other  gadgets  that i show you because you've got to  get rid of those angles  in the beginning then the main gadget  here  is the nautil equal clause and that's  what i have folded here  so it's a little crazy but basically  you've got  three pleats uh three of these double  pleats coming together  these guys could stack on this one on  top this one on top  or the same for all three of them and  then you've got this little  twist like thing in the center and it's  really hard to draw what the folded  state looks like this is  what it looks like within shadow pattern  with transparency  here's the real thing and also there's  these yellow tabs  attached at very specific locations uh  and this is a little hard to imagine i  encourage you to fold one of these in  order to  really see what's going on but as  i said before you've got each of these  guys can be independently  stacked one way or the other says that  one  or this one can stack this way or that  way  for all three but we want to forbid the  case where it's where they're all  stacked the same way  and the arrows here are all pointing  towards the gadget so  we want to forbid the case when they're  all when it's rotationally symmetric  gadget is rotationally symmetric but if  you choose the layer order rotationally  symmetric you're in trouble  so let me make it rotationally symmetric  that would be like this so when it's  rotationally symmetric you see  basically all the panels you see there's  three panels  this one this one and this one each of  them has a tab sticking out  and basically the these tabs have to  also be cyclically ordered  but it's not possible this is hard to do  it's like this  you see they're kind of colliding here  because if you look at each of the tabs  in projection  it collides with where the tab is  attached  so you basically if you went  so someone has to be the lowest tab  and that tab will intersect uh one the  other two tabs actually  where uh that tab is attached so it'll  penetrate and  you can see they're not very happy to  stack here  but if i change the layer order in any  way  a lowest tab is actually happy to go  behind other layers  and then you can just kind of stack them  and they barely fit  so it's a little tricky to get all the  details here to work but i think this  particular geometry and the reason i  drew this in this exact way is to make  sure yeah  everything works you do not penetrate  here which would be a problem  you do not penetrate this crease which  would be a problem so the tab just fits  in between here and here  but it does cross if you look at this  tab  it's attached along this edge as drawn  up there  and this tab here will penetrate this  part of that edge  and it will penetrate this part of this  edge which is where this tab is attached  so  they cause trouble in the cyclic  situation but  when it's acyclic like in this picture  you can put that bottom tab  way down here and avoid any collision  then you can you basically break the  cyclic condition  and you get to stack them in some linear  order  so it's a little hard to see without  physically manipulating it feel free to  come and play with it after  that's their proof now there's also  splitters and  turn gadgets and crossovers but  i'll leave it at that there's those are  more similar  this is sort of the heart of what's  going on in this proof  so it's completely separate proof from  the one that we saw before  any questions about that  all right yes yeah  why how do the tabs fold no why do you  need it  and everything follows  so that the tabs are being used as a  device to build gadgets so the tabs  serve no purpose by themselves but  this gadget involves first folding three  tabs here  which are actually pointing uh they're  pointing in that direction i believe  then you add this crease pattern  afterwards  so originally there are tabs here which  means there's a bunch of creases  here after you fold them then you lay on  this crease pattern so if you unfolded  it you get some much more complicated  crease pattern which is when  when i made that i just taped the tabs  on but in reality first you fold the  tabs  so they exist there then you fold this  on top so the full crease founder would  be quite complicated  it's going to have tabs here tabs here  tabs there  and then this reflected a few times  and so then when you fold it the full  gadget is this thing with the tabs  the tabs are just like a stepping stone  toward making this gadget  the other gadgets use more tabs uh  obvious open problem here is to make a  simpler reduction  shouldn't have to be this complicated  and i've heard tom hall talk about  different approaches  for making simpler empty hardness proofs  but we're not there yet  other questions if these fruits don't  imply anything about the  rest of the platforming problem that  they could argue very easily  it's just this particular family of  platforming problems  uh so this proof implies that these  kinds of  tessellation style crease patterns are  hard to fold  which implies that in general crease  patterns are hard to fold  but you could look at some other  specific pattern for example that's the  next topic  you could look at map folding  where you have horizontal and vertical  creases  in a rectangular sheet of paper maybe  each of these squares is  each of these cells is a unit square  let's say  and i give you mountain valley  assignment on that some of these are  some of these are mountains some of them  are valleys  uh whatever and i want to know does this  fold flat  that we don't know the complexity of  could be  solvable by a polynomial time algorithm  could be np hard  this is actually mentioned in uh  lecture two notes but not actually  orally  uh and so i wanted to get back to this  so this is from lecture two notes  2d map folding jack edmonds pose this  problem can you characterize flat  foldable mountain valley patterns is  there an algorithm or is it np hard  and even the two by n problem was open  when i wrote these notes in 2010 but it  has since been solved  so i thought i'd tell you a little bit  about that solution  so yeah there can be special cases of  crease patterns that are easy to solve  we just know in general  they are hard so  2 by n this kind of picture so this is  what i call  two counting cells  this is uh  based on a class project in this class  from two years ago  by eric liu and tom morgan but the  paper got finished this year uh  so it's based on a series of reductions  on the one hand we're going to start  with something called okay so we have  let's say map folding on the left  we're going to convert map folding into  a different representation which is  news labeling  we're going to convert that into  something called a top edge view  we're going to convert that into ray  diagram  and the last part which i won't talk too  much about  is we convert that into something called  a hidden tree problem  each of these steps is fairly  straightforward but there are obviously  a lot of them  uh and but in the end you get  a polynomial time algorithm to solve  this which implies you get a polynomial  time algorithm to solve this  and i'll talk mostly about these  reductions it's the same idea in np  hardness we use reductions from a hard  problem  to our problem in this case we're  doing the reverse we're reducing our  problem to an easier problem  so that by the end we get something  that's so easy we know how to solve it  so reductions are useful both for  positive  results and negative results so let me  show you visually some  uh oh before we get to the proof i  wanted to mention  this puzzle which you probably folded in  problem set one  it's a math folding problem right you've  got it's a three by three map  and so we didn't have any good  algorithms to solve them  so we used a not so good algorithm  namely exhaustive enumeration we  enumerated all possible folded states of  a three 3x3 map  we drew them out graphically this is  there's a scroll bar here so you don't  see them all  but we put them in a giant i forget  there's uh there's 1 000  folded states or so so it's like 100 by  whatever uh 10 array  and for each of them so here's where  you're designing your pattern  so we would make you could make holes uh  you could put in patterns this is sort  of an early design where it would spell  mit  the whole would show the eye on another  side so it's equivalent to the  puzzle that you you solved and this is  what the top looks like this is what the  bottom looks like so you could  you could hover over these and change  the letters that were that appeared  and then it would show you what every  single state would look like and it  would color it in yellow if one side  looked like mit and would color it in  red if both sides looked like mit  and the point was to verify there was  exactly one solution  for that puzzle and so we we kept we  would fold things to make it a tricky  fold then we put it into the software  and you know label things accordingly  then put it into the software and see is  there unique folding and then we could  add in  extra sort of misleading clues  here and see did they accidentally make  an extra solution  so we could add in extra stuff to pack  in as much  irrelevant stuff as we could and still  make it unique so it's more challenging  that was a nice use of exponential  algorithms to design  puzzles all right but back to  this proof  so i have here a much simpler map than  this one  this is what we call the new map  n-e-w so the labeling here is very  simple if you look at this crease  pattern  by mayakawa there's got to be three of  one type and one  of the other type so just label  each vertex by which way is unique so  from here the north direction  is the uniquely label it's the mountain  among three valleys  and then this vertex the east label is  the mountain among three valleys and  then the next one is the west label  among three valleys of course it doesn't  have to be like that it could  for example you can have three mountains  at a vertex  but then the label of this guy is going  to be w it's going to be the one that's  unique among the other three  okay so if you fold this map it looks  like this  i have one here but uh a little hard to  see  we've got lots of back and forth on the  top edge  so i'm orienting it so that the  we've got two by end map so there's sort  of two critical features there's the  the center line i'll call that the spine  of the map there's the  the top side and the bottom side when  you fold that let me this is just a  sequence of simple folds  you see at this last fold the top side  and the bottom side come together  and the spine is stays together  so when i orient it like this as in the  picture that  the top side is where uh originally the  top and the bottom of the map all come  to here because of that  spine fold and the spine folds are all  down here  okay there are you can't see them here  but there's uh  see them at the bottom there there's  some kind of connections on the bottom  but there's this nice kind of relatively  one-dimensional picture  up here so we're going to draw that  this is the top edge view  got clipped a little bit but there's one  more segment at the top  so that is just this  see it now there's also these blue lines  the blue lines correspond  to what's going on at the bottom on from  the spine  because if you think about it you've got  you've got the  in a two by end map you've got the top  panels  and these edges making the top edge  you've also got the bottom panels and  these edges making the bottom edge they  come in pairs  these guys are paired up these guys are  paired up and so on  down the line because they are joined by  a spine edge  those spine edges correspond to the  things on the bottom of the folding  and they need to not cross each other  and that's what's illustrated by the  blue connections so  the very top edge is paired with the  very bottom edge  these two this panel here and the back  panel here  are connected on the bottom and that oh  sorry that's not true  this one is paired with this one the top  one is paired with the second one  so it's actually these two are connected  on the bottom that's  this little connection here and then  these guys  this wraps around everything that's that  connection  but what you can't see in this folding  because it's hidden inside  is that within this connection on the  bottom there's this connection on the  bottom and within that one  there's this connection now this is okay  might look like they're crossing because  they're overlapping  but as long as they're nested as long as  you don't like start from  inside here and go to outside that would  be a crossing  if you start inside you should end  inside like in all of these pictures  if you start outside you should end  outside so that's like these guys are  disjoint so that's okay  this is nested in that so it's okay kind  of like balanced parentheses  and so that's what it makes a top valid  top edge view what's nice about this is  it's a one-dimensional diagram  what's not nice is it has all these  crossings because there's the blue stuff  on top of the black stuff  so it's a little hard to find uh  we're trying to find a valley fold state  we're trying to find one of these  we're not restricting ourselves to  simple folds here yeah simple fold  simple map folding we already solved in  lecture two so this is all i should have  said  non-simple folds  that's what makes it hard and that's  what's still open for  three by end maps we don't know how to  do it but for two by end maps  so we've made two steps here we can we  have another view which is the ray  diagram  and this is really specific to two by n  and it lets us reduce to a kind of tree  problem  so uh before we get there  let's talk in general about the top edge  view you can actually  convert from the northeast west south  labeling to a top edge view in the  following way  uh whenever and you can kind of see  what's going on so first we have an  n so we've got these two guys which are  just paired together happily that's the  beginning of the map  then we turn left and we've got this guy  paired with this guy and so in general  whenever you have a north you turn left  with your two guys  all right so that's what happens then we  hit an east in the map  and what happens here is this guy turns  right but this one turns left  this is what you might call an inside  turn it's like an inside reverse fold in  origami  and in general whenever you have an east  you you turn inside like that so these  this guy is paired with that one and now  this guy's paired with that one they  both  turn in and then it's symmetric uh next  one is a w  which is the opposite of an e which  means you turn out  here and in general whenever you have a  west you turn out  and south you turn right so those are  the four possible things you can imagine  when you have a pair of things turning  and those exactly correspond to any w  and s  so it's clear what you need to do in  this situation  but there's still there's flexibility  right for example  this guy when you turn out here i turned  out to the very next layer but this  could have turned out to go  up here would that be okay  no if this one turned out to go up here  that edge up there would be paired with  this one down here  so there'd be a blue line going like  that and that would be a crossing  situation  because that blue line would cross this  one because it starts inside and it goes  to outside  so it's a little tricky this this  definitely gives you  some of the layer constraints but it  doesn't check for crossings  which is the big challenge in this  problem uh so we're going to simplify  this diagram  so just just think about top edge views  forget about mat folding now you can  forget about the previous layers and we  are now focusing on this reduction  so we've got top edge view converting to  array diagram as you can see it's much  simpler  this is the ray diagram of that picture  and essentially  there's two ways to think about what  we're doing instead of having two edges  and we track two edges turning  we just want one edge that's one thing  we're doing you can think of that  as tracking the spine  instead of the the top and the bottom  sides  but it's a little is the ray diagram is  going to get confusing i'll just  tell you that now um it every time i  look at it i  understand it a little bit more but it's  not going to be obvious that this is  equivalent to this  i'll just tell you here's an alternate  way to think about it  basically the vertical the y direction  here  is going to be nesting depth so whenever  we go  in like this we go deeper uh  so for whatever reason i've flipped the  labeling but it is indeed east when you  go  in you go down i should have just  moved these two figures so they  correspond but uh  when you go east you go down a layer  because  you're nesting deeper and when you go  west you're going out  so you go up a layer in this new weird  ray diagram view  and north and south turn out to not turn  around  in this view we're just going to fire a  ray  downward and there's either a north ray  a blue one or south ray a red one  and so if you follow this diagram it's  it's n-e-w  so first we have an n which means we  shoot a ray down  then we have an e which means we go turn  downwards and then we have a w which  means we turn to go up a layer  and i haven't told you what the  constraints are here but i claim this is  a valid folding just like that one  it's obviously a lot easier to draw it's  a much slower complexity  but the cool thing is you no longer have  these crossing parts  so let me show you first let me tell you  what the constraints are  so in general you're going to have lots  of downward rays this is a north this is  a south and north is south  so if you had like nsns in your pattern  just going to be a straight segment with  downward rays of different colors  first constrains whenever you have a an  n ray it ha  a north ray it has to hit another north  ray or just go off to infinity  and same south rays can only hit south  rays or go off to infinity  so they kind of line up in this way but  you can stretch the x  coordinate to do whatever you want this  corresponds to basically jumping over a  bunch of layers when you  turn in your folded state you can skip a  bunch of layers and just go up here  so that corresponds to jumping over a  bunch of folds here  but in particular we get these things  called constrained segments constrained  segments are  portions of this black spine between two  rays  that below it only see black  okay so for example this one is  unconstrained because below it you can  see off to infinity so that's  unconcerned we don't care about that one  but among constrained segments these are  two constraint segments  we want that all of the rays that they  see below them so here i see one red  right one blue ray  i want the number of reds and blues to  be equal so this is valid because  there's one of  one red one blue this one is invalid  because there's two blue  and one red this turns out to be the  right constraint  essentially this is saying however much  you spiral you should un-spiral  that's the intuition uh so here you're  spiraling twice unspiraling once so  you're  tuck you're trapped inside and so these  folds cannot actually come together  the rays coming together correspond to a  nice nesting between two  uh north folds  so this it's not obvious but this turns  out to be the only constraints you have  the black should not cross itself  constraint segments should be valid in  this way  and blue should hit blue and red should  hit red  so that's not obvious but it's true and  then you can  take very complicated diagrams like this  and simplify them into these nice  pictures  so uh this these are two different  foldings of the same  pattern which i guess is n  e n if i can see that easily here  you could also extract it from here um  there's two foldings because  these two layers could go here in the  middle or they could be pushed  up to fit in here and then we get this  picture  okay and in the ray diagram you can see  this pretty easily  either you have these n rays just both  go off to infinity  and this is an unconstrained segment so  we don't care about that there's only  one  north ray below or you can extend the x  because i can stretch the x parts  however i want  and make these blue segments align with  each other  and that corresponds to this folding so  really all folded states of the original  thing are represented by the ray diagram  of course if i had any w this would be  valid but this would  would not not be that sorry any s  blast from the past if i had an nes then  uh  you know this would be blue this would  be red and so this would be valid but  this would be invalid  and so on so it's obviously a lot easier  conceptually  but you can also here's a more  complicated algorithm take a really  crazy map  this notation by the way was introduced  by jacques justine in like  late 1980s you may remember his name  from kawasaki justine theorem  so at the same time he was looking at  matt folding and he came up with this  notation  the ray diagram was introduced in the  open problem session this class two  years ago  or actually five years ago if i recall  correctly  by david charlton and yo-yo zhao  and then it was picked up again two  years ago and finally  we took this ray diagram and came up  with an algorithm so how does the  algorithm work  here's a ray diagram the black and the  red and the the blue  we observe that the blank space  here between the spine stuff  between all the black is kind of a tree  structure  right you've got and that's what's drawn  in cyan with the red dots  so if you draw a node every time you  turn around  on the outside then you say well i can  get from this node to  this one so i'm going to draw a segment  there and i can get from this node to  this one without crossing any black so  i'll draw a segment there  that's sort of it on that side there's  nothing else down here that  sort of doesn't count but here is  another dot and i can get from this one  to there by going out here without  crossing black  here to here here to over here without  crossing black  so on so that cyan structure is a tree  has no cycles  which in general is good news for  algorithms trees  are relatively easy to find algorithms  for using dynamic programming  so if you've seen dynamic programming  for trees this is not like that it's a  little different because we don't know  what the tree is  we have to figure out what the tree is  but basically we can guess the tree  recursively  so you know there's some first node i  don't know maybe it's this one  just guess that not randomly but guess  means try all the options  so you guess some node and then okay  we've got maybe we've got  two subtrees maybe we've got three uh  i think that's about all there could be  uh  and so just guess that and then so we  recursively guess  a sub tree here and a sub tree here and  each of the sub trees corresponds to a  sub-segment  of this uh  of the original map of the spine roughly  speaking  and roughly speaking uh these these  portions do not  interact with each other there's this  issue of how the rays align  and that's sort of the challenge in  getting this algorithm to work but you  can essentially locally check whether  subtree is good enough  that it will interact okay with a  different subtree and just split this  problem up recursively guessing all the  way effectively trying all trees  but in polynomial time instead of  exponential time forget the running time  is something like n to the  10 or some some really big constant but  at least finally we know two by n  maps can be solved in polynomial time  with a given mountain valley assignment  we still don't know  about three by n that's the big open  question  and this these techniques unfortunately  don't seem to apply you definitely don't  get a tree anymore  you might get some nice structure that's  kind of vaguely tree-like but  this was already super complicated so  we've gotten stuck here any questions  all right that's it  you
 

3
00:00:07,030 --> 00:00:10,709

 

4
00:00:10,709 --> 00:00:13,190

 

5
00:00:13,190 --> 00:00:13,200

 

6
00:00:13,200 --> 00:00:13,990


7
00:00:13,990 --> 00:00:15,749

 

8
00:00:15,749 --> 00:00:17,349

 

9
00:00:17,349 --> 00:00:20,470

 

10
00:00:20,470 --> 00:00:22,070

 

11
00:00:22,070 --> 00:00:24,790

 

12
00:00:24,790 --> 00:00:27,750

 

13
00:00:27,750 --> 00:00:28,630

 

14
00:00:28,630 --> 00:00:31,269

 

15
00:00:31,269 --> 00:00:32,709

 

16
00:00:32,709 --> 00:00:34,630

 

17
00:00:34,630 --> 00:00:36,229

 

18
00:00:36,229 --> 00:00:37,990

 

19
00:00:37,990 --> 00:00:39,750

 

20
00:00:39,750 --> 00:00:41,910

 

21
00:00:41,910 --> 00:00:43,590

 

22
00:00:43,590 --> 00:00:45,190

 

23
00:00:45,190 --> 00:00:47,590

 

24
00:00:47,590 --> 00:00:50,150

 

25
00:00:50,150 --> 00:00:52,709

 

26
00:00:52,709 --> 00:00:54,389

 

27
00:00:54,389 --> 00:00:55,910

 

28
00:00:55,910 --> 00:00:59,270

 

29
00:00:59,270 --> 00:01:00,630

 

30
00:01:00,630 --> 00:01:00,640

 

31
00:01:00,640 --> 00:01:01,270


32
00:01:01,270 --> 00:01:04,630

 

33
00:01:04,630 --> 00:01:04,640

 

34
00:01:04,640 --> 00:01:05,030


35
00:01:05,030 --> 00:01:07,350

 

36
00:01:07,350 --> 00:01:08,789

 

37
00:01:08,789 --> 00:01:10,469

 

38
00:01:10,469 --> 00:01:10,479

 

39
00:01:10,479 --> 00:01:11,350


40
00:01:11,350 --> 00:01:13,510

 

41
00:01:13,510 --> 00:01:15,990

 

42
00:01:15,990 --> 00:01:17,510

 

43
00:01:17,510 --> 00:01:19,190

 

44
00:01:19,190 --> 00:01:21,590

 

45
00:01:21,590 --> 00:01:23,429

 

46
00:01:23,429 --> 00:01:25,109

 

47
00:01:25,109 --> 00:01:26,310

 

48
00:01:26,310 --> 00:01:28,789

 

49
00:01:28,789 --> 00:01:30,390

 

50
00:01:30,390 --> 00:01:33,749

 

51
00:01:33,749 --> 00:01:36,469

 

52
00:01:36,469 --> 00:01:37,670

 

53
00:01:37,670 --> 00:01:39,590

 

54
00:01:39,590 --> 00:01:41,749

 

55
00:01:41,749 --> 00:01:44,230

 

56
00:01:44,230 --> 00:01:46,230

 

57
00:01:46,230 --> 00:01:46,240

 

58
00:01:46,240 --> 00:01:47,030


59
00:01:47,030 --> 00:01:50,950

 

60
00:01:50,950 --> 00:01:53,670

 

61
00:01:53,670 --> 00:01:53,680

 

62
00:01:53,680 --> 00:01:54,069


63
00:01:54,069 --> 00:01:55,910

 

64
00:01:55,910 --> 00:01:57,190

 

65
00:01:57,190 --> 00:01:58,630

 

66
00:01:58,630 --> 00:02:00,789

 

67
00:02:00,789 --> 00:02:02,310

 

68
00:02:02,310 --> 00:02:03,749

 

69
00:02:03,749 --> 00:02:05,510

 

70
00:02:05,510 --> 00:02:07,109

 

71
00:02:07,109 --> 00:02:08,869

 

72
00:02:08,869 --> 00:02:10,229

 

73
00:02:10,229 --> 00:02:12,949

 

74
00:02:12,949 --> 00:02:14,470

 

75
00:02:14,470 --> 00:02:15,910

 

76
00:02:15,910 --> 00:02:17,510

 

77
00:02:17,510 --> 00:02:18,949

 

78
00:02:18,949 --> 00:02:19,589

 

79
00:02:19,589 --> 00:02:21,430

 

80
00:02:21,430 --> 00:02:22,949

 

81
00:02:22,949 --> 00:02:24,949

 

82
00:02:24,949 --> 00:02:27,030

 

83
00:02:27,030 --> 00:02:31,190

 

84
00:02:31,190 --> 00:02:33,190

 

85
00:02:33,190 --> 00:02:33,200

 

86
00:02:33,200 --> 00:02:34,070


87
00:02:34,070 --> 00:02:35,670

 

88
00:02:35,670 --> 00:02:37,670

 

89
00:02:37,670 --> 00:02:38,550

 

90
00:02:38,550 --> 00:02:40,470

 

91
00:02:40,470 --> 00:02:42,150

 

92
00:02:42,150 --> 00:02:42,160

 

93
00:02:42,160 --> 00:02:43,270


94
00:02:43,270 --> 00:02:44,949

 

95
00:02:44,949 --> 00:02:46,790

 

96
00:02:46,790 --> 00:02:48,710

 

97
00:02:48,710 --> 00:02:49,990

 

98
00:02:49,990 --> 00:02:51,509

 

99
00:02:51,509 --> 00:02:54,229

 

100
00:02:54,229 --> 00:02:56,150

 

101
00:02:56,150 --> 00:02:57,670

 

102
00:02:57,670 --> 00:03:01,030

 

103
00:03:01,030 --> 00:03:02,869

 

104
00:03:02,869 --> 00:03:04,390

 

105
00:03:04,390 --> 00:03:06,070

 

106
00:03:06,070 --> 00:03:07,670

 

107
00:03:07,670 --> 00:03:10,390

 

108
00:03:10,390 --> 00:03:12,470

 

109
00:03:12,470 --> 00:03:18,070

 

110
00:03:18,070 --> 00:03:22,229

 

111
00:03:22,229 --> 00:03:25,509

 

112
00:03:25,509 --> 00:03:29,350

 

113
00:03:29,350 --> 00:03:32,470

 

114
00:03:32,470 --> 00:03:32,480

 

115
00:03:32,480 --> 00:03:32,789


116
00:03:32,789 --> 00:03:34,229

 

117
00:03:34,229 --> 00:03:36,149

 

118
00:03:36,149 --> 00:03:38,550

 

119
00:03:38,550 --> 00:03:40,229

 

120
00:03:40,229 --> 00:03:41,190

 

121
00:03:41,190 --> 00:03:47,110

 

122
00:03:47,110 --> 00:03:49,270

 

123
00:03:49,270 --> 00:03:51,030

 

124
00:03:51,030 --> 00:03:52,149

 

125
00:03:52,149 --> 00:03:54,070

 

126
00:03:54,070 --> 00:03:56,229

 

127
00:03:56,229 --> 00:03:59,350

 

128
00:03:59,350 --> 00:04:02,390

 

129
00:04:02,390 --> 00:04:04,550

 

130
00:04:04,550 --> 00:04:06,229

 

131
00:04:06,229 --> 00:04:07,990

 

132
00:04:07,990 --> 00:04:09,589

 

133
00:04:09,589 --> 00:04:12,630

 

134
00:04:12,630 --> 00:04:15,350

 

135
00:04:15,350 --> 00:04:17,270

 

136
00:04:17,270 --> 00:04:21,189

 

137
00:04:21,189 --> 00:04:23,189

 

138
00:04:23,189 --> 00:04:24,629

 

139
00:04:24,629 --> 00:04:24,639

 

140
00:04:24,639 --> 00:04:25,430


141
00:04:25,430 --> 00:04:28,150

 

142
00:04:28,150 --> 00:04:29,990

 

143
00:04:29,990 --> 00:04:30,000

 

144
00:04:30,000 --> 00:04:30,870


145
00:04:30,870 --> 00:04:34,230

 

146
00:04:34,230 --> 00:04:35,749

 

147
00:04:35,749 --> 00:04:37,030

 

148
00:04:37,030 --> 00:04:38,710

 

149
00:04:38,710 --> 00:04:41,110

 

150
00:04:41,110 --> 00:04:41,120

 

151
00:04:41,120 --> 00:04:43,189


152
00:04:43,189 --> 00:04:45,990

 

153
00:04:45,990 --> 00:04:47,430

 

154
00:04:47,430 --> 00:04:48,469

 

155
00:04:48,469 --> 00:04:51,590

 

156
00:04:51,590 --> 00:04:52,950

 

157
00:04:52,950 --> 00:04:55,270

 

158
00:04:55,270 --> 00:04:57,110

 

159
00:04:57,110 --> 00:04:59,189

 

160
00:04:59,189 --> 00:05:01,510

 

161
00:05:01,510 --> 00:05:03,749

 

162
00:05:03,749 --> 00:05:07,270

 

163
00:05:07,270 --> 00:05:09,510

 

164
00:05:09,510 --> 00:05:10,950

 

165
00:05:10,950 --> 00:05:12,550

 

166
00:05:12,550 --> 00:05:12,560

 

167
00:05:12,560 --> 00:05:13,189


168
00:05:13,189 --> 00:05:16,230

 

169
00:05:16,230 --> 00:05:18,469

 

170
00:05:18,469 --> 00:05:20,150

 

171
00:05:20,150 --> 00:05:21,430

 

172
00:05:21,430 --> 00:05:23,430

 

173
00:05:23,430 --> 00:05:25,189

 

174
00:05:25,189 --> 00:05:27,110

 

175
00:05:27,110 --> 00:05:29,270

 

176
00:05:29,270 --> 00:05:30,790

 

177
00:05:30,790 --> 00:05:32,310

 

178
00:05:32,310 --> 00:05:35,510

 

179
00:05:35,510 --> 00:05:36,550

 

180
00:05:36,550 --> 00:05:39,670

 

181
00:05:39,670 --> 00:05:41,510

 

182
00:05:41,510 --> 00:05:43,749

 

183
00:05:43,749 --> 00:05:45,029

 

184
00:05:45,029 --> 00:05:47,270

 

185
00:05:47,270 --> 00:05:49,350

 

186
00:05:49,350 --> 00:05:50,790

 

187
00:05:50,790 --> 00:05:52,710

 

188
00:05:52,710 --> 00:05:56,950

 

189
00:05:56,950 --> 00:05:58,629

 

190
00:05:58,629 --> 00:05:58,639

 

191
00:05:58,639 --> 00:06:00,150


192
00:06:00,150 --> 00:06:03,189

 

193
00:06:03,189 --> 00:06:05,110

 

194
00:06:05,110 --> 00:06:07,110

 

195
00:06:07,110 --> 00:06:10,070

 

196
00:06:10,070 --> 00:06:10,080

 

197
00:06:10,080 --> 00:06:11,749


198
00:06:11,749 --> 00:06:14,150

 

199
00:06:14,150 --> 00:06:16,150

 

200
00:06:16,150 --> 00:06:18,230

 

201
00:06:18,230 --> 00:06:19,510

 

202
00:06:19,510 --> 00:06:21,909

 

203
00:06:21,909 --> 00:06:23,510

 

204
00:06:23,510 --> 00:06:26,150

 

205
00:06:26,150 --> 00:06:26,160

 

206
00:06:26,160 --> 00:06:27,270


207
00:06:27,270 --> 00:06:29,270

 

208
00:06:29,270 --> 00:06:31,510

 

209
00:06:31,510 --> 00:06:33,590

 

210
00:06:33,590 --> 00:06:34,710

 

211
00:06:34,710 --> 00:06:36,950

 

212
00:06:36,950 --> 00:06:38,710

 

213
00:06:38,710 --> 00:06:41,350

 

214
00:06:41,350 --> 00:06:42,309

 

215
00:06:42,309 --> 00:06:44,950

 

216
00:06:44,950 --> 00:06:45,909

 

217
00:06:45,909 --> 00:06:47,990

 

218
00:06:47,990 --> 00:06:49,189

 

219
00:06:49,189 --> 00:06:50,710

 

220
00:06:50,710 --> 00:06:52,950

 

221
00:06:52,950 --> 00:06:56,070

 

222
00:06:56,070 --> 00:06:58,469

 

223
00:06:58,469 --> 00:06:59,749

 

224
00:06:59,749 --> 00:07:01,029

 

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

 

226
00:07:02,950 --> 00:07:04,870

 

227
00:07:04,870 --> 00:07:04,880

 

228
00:07:04,880 --> 00:07:05,430


229
00:07:05,430 --> 00:07:07,110

 

230
00:07:07,110 --> 00:07:09,510

 

231
00:07:09,510 --> 00:07:11,430

 

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

 

233
00:07:13,589 --> 00:07:14,629

 

234
00:07:14,629 --> 00:07:17,510

 

235
00:07:17,510 --> 00:07:17,520

 

236
00:07:17,520 --> 00:07:17,909


237
00:07:17,909 --> 00:07:21,589

 

238
00:07:21,589 --> 00:07:21,599

 

239
00:07:21,599 --> 00:07:22,550


240
00:07:22,550 --> 00:07:24,390

 

241
00:07:24,390 --> 00:07:25,589

 

242
00:07:25,589 --> 00:07:27,589

 

243
00:07:27,589 --> 00:07:29,430

 

244
00:07:29,430 --> 00:07:31,029

 

245
00:07:31,029 --> 00:07:32,469

 

246
00:07:32,469 --> 00:07:33,749

 

247
00:07:33,749 --> 00:07:35,510

 

248
00:07:35,510 --> 00:07:37,589

 

249
00:07:37,589 --> 00:07:39,909

 

250
00:07:39,909 --> 00:07:41,670

 

251
00:07:41,670 --> 00:07:42,870

 

252
00:07:42,870 --> 00:07:44,309

 

253
00:07:44,309 --> 00:07:46,070

 

254
00:07:46,070 --> 00:07:47,430

 

255
00:07:47,430 --> 00:07:48,950

 

256
00:07:48,950 --> 00:07:49,670

 

257
00:07:49,670 --> 00:07:52,150

 

258
00:07:52,150 --> 00:07:53,350

 

259
00:07:53,350 --> 00:07:54,869

 

260
00:07:54,869 --> 00:07:56,390

 

261
00:07:56,390 --> 00:07:58,230

 

262
00:07:58,230 --> 00:07:58,240

 

263
00:07:58,240 --> 00:07:59,510


264
00:07:59,510 --> 00:08:00,790

 

265
00:08:00,790 --> 00:08:02,070

 

266
00:08:02,070 --> 00:08:03,510

 

267
00:08:03,510 --> 00:08:04,230

 

268
00:08:04,230 --> 00:08:06,309

 

269
00:08:06,309 --> 00:08:07,909

 

270
00:08:07,909 --> 00:08:08,790

 

271
00:08:08,790 --> 00:08:10,230

 

272
00:08:10,230 --> 00:08:11,749

 

273
00:08:11,749 --> 00:08:11,759

 

274
00:08:11,759 --> 00:08:12,070


275
00:08:12,070 --> 00:08:13,350

 

276
00:08:13,350 --> 00:08:15,430

 

277
00:08:15,430 --> 00:08:16,469

 

278
00:08:16,469 --> 00:08:17,830

 

279
00:08:17,830 --> 00:08:21,830

 

280
00:08:21,830 --> 00:08:25,990

 

281
00:08:25,990 --> 00:08:28,869

 

282
00:08:28,869 --> 00:08:30,390

 

283
00:08:30,390 --> 00:08:31,990

 

284
00:08:31,990 --> 00:08:33,509

 

285
00:08:33,509 --> 00:08:35,029

 

286
00:08:35,029 --> 00:08:38,949

 

287
00:08:38,949 --> 00:08:41,430

 

288
00:08:41,430 --> 00:08:41,440

 

289
00:08:41,440 --> 00:08:42,709


290
00:08:42,709 --> 00:08:45,829

 

291
00:08:45,829 --> 00:08:47,509

 

292
00:08:47,509 --> 00:08:50,470

 

293
00:08:50,470 --> 00:08:52,790

 

294
00:08:52,790 --> 00:08:53,910

 

295
00:08:53,910 --> 00:08:55,670

 

296
00:08:55,670 --> 00:08:56,790

 

297
00:08:56,790 --> 00:08:58,870

 

298
00:08:58,870 --> 00:09:00,470

 

299
00:09:00,470 --> 00:09:02,710

 

300
00:09:02,710 --> 00:09:05,350

 

301
00:09:05,350 --> 00:09:06,470

 

302
00:09:06,470 --> 00:09:09,750

 

303
00:09:09,750 --> 00:09:11,590

 

304
00:09:11,590 --> 00:09:13,269

 

305
00:09:13,269 --> 00:09:16,790

 

306
00:09:16,790 --> 00:09:18,710

 

307
00:09:18,710 --> 00:09:20,070

 

308
00:09:20,070 --> 00:09:21,509

 

309
00:09:21,509 --> 00:09:23,190

 

310
00:09:23,190 --> 00:09:23,200

 

311
00:09:23,200 --> 00:09:23,829


312
00:09:23,829 --> 00:09:26,230

 

313
00:09:26,230 --> 00:09:27,269

 

314
00:09:27,269 --> 00:09:30,310

 

315
00:09:30,310 --> 00:09:31,990

 

316
00:09:31,990 --> 00:09:33,990

 

317
00:09:33,990 --> 00:09:34,000

 

318
00:09:34,000 --> 00:09:35,190


319
00:09:35,190 --> 00:09:37,829

 

320
00:09:37,829 --> 00:09:38,550

 

321
00:09:38,550 --> 00:09:41,750

 

322
00:09:41,750 --> 00:09:43,350

 

323
00:09:43,350 --> 00:09:46,230

 

324
00:09:46,230 --> 00:09:47,110

 

325
00:09:47,110 --> 00:09:50,230

 

326
00:09:50,230 --> 00:09:53,430

 

327
00:09:53,430 --> 00:09:56,150

 

328
00:09:56,150 --> 00:09:57,670

 

329
00:09:57,670 --> 00:10:00,870

 

330
00:10:00,870 --> 00:10:03,590

 

331
00:10:03,590 --> 00:10:03,600

 

332
00:10:03,600 --> 00:10:04,870


333
00:10:04,870 --> 00:10:08,230

 

334
00:10:08,230 --> 00:10:11,829

 

335
00:10:11,829 --> 00:10:13,670

 

336
00:10:13,670 --> 00:10:15,269

 

337
00:10:15,269 --> 00:10:17,190

 

338
00:10:17,190 --> 00:10:18,470

 

339
00:10:18,470 --> 00:10:20,710

 

340
00:10:20,710 --> 00:10:22,470

 

341
00:10:22,470 --> 00:10:24,389

 

342
00:10:24,389 --> 00:10:26,550

 

343
00:10:26,550 --> 00:10:28,389

 

344
00:10:28,389 --> 00:10:29,670

 

345
00:10:29,670 --> 00:10:31,750

 

346
00:10:31,750 --> 00:10:33,190

 

347
00:10:33,190 --> 00:10:34,550

 

348
00:10:34,550 --> 00:10:36,949

 

349
00:10:36,949 --> 00:10:39,590

 

350
00:10:39,590 --> 00:10:42,069

 

351
00:10:42,069 --> 00:10:43,829

 

352
00:10:43,829 --> 00:10:46,310

 

353
00:10:46,310 --> 00:10:47,350

 

354
00:10:47,350 --> 00:10:50,550

 

355
00:10:50,550 --> 00:10:52,790

 

356
00:10:52,790 --> 00:10:54,550

 

357
00:10:54,550 --> 00:10:57,990

 

358
00:10:57,990 --> 00:11:00,389

 

359
00:11:00,389 --> 00:11:01,670

 

360
00:11:01,670 --> 00:11:04,310

 

361
00:11:04,310 --> 00:11:06,230

 

362
00:11:06,230 --> 00:11:06,240

 

363
00:11:06,240 --> 00:11:07,750


364
00:11:07,750 --> 00:11:10,230

 

365
00:11:10,230 --> 00:11:11,269

 

366
00:11:11,269 --> 00:11:14,230

 

367
00:11:14,230 --> 00:11:16,470

 

368
00:11:16,470 --> 00:11:18,470

 

369
00:11:18,470 --> 00:11:20,310

 

370
00:11:20,310 --> 00:11:23,190

 

371
00:11:23,190 --> 00:11:24,470

 

372
00:11:24,470 --> 00:11:25,829

 

373
00:11:25,829 --> 00:11:26,949

 

374
00:11:26,949 --> 00:11:28,870

 

375
00:11:28,870 --> 00:11:28,880

 

376
00:11:28,880 --> 00:11:29,990


377
00:11:29,990 --> 00:11:32,550

 

378
00:11:32,550 --> 00:11:33,269

 

379
00:11:33,269 --> 00:11:35,829

 

380
00:11:35,829 --> 00:11:37,350

 

381
00:11:37,350 --> 00:11:38,949

 

382
00:11:38,949 --> 00:11:40,230

 

383
00:11:40,230 --> 00:11:42,790

 

384
00:11:42,790 --> 00:11:44,870

 

385
00:11:44,870 --> 00:11:44,880

 

386
00:11:44,880 --> 00:11:45,910


387
00:11:45,910 --> 00:11:47,190

 

388
00:11:47,190 --> 00:11:48,550

 

389
00:11:48,550 --> 00:11:50,710

 

390
00:11:50,710 --> 00:11:52,790

 

391
00:11:52,790 --> 00:11:55,030

 

392
00:11:55,030 --> 00:11:55,990

 

393
00:11:55,990 --> 00:11:58,629

 

394
00:11:58,629 --> 00:11:58,639

 

395
00:11:58,639 --> 00:11:59,110


396
00:11:59,110 --> 00:12:01,030

 

397
00:12:01,030 --> 00:12:02,790

 

398
00:12:02,790 --> 00:12:05,990

 

399
00:12:05,990 --> 00:12:09,509

 

400
00:12:09,509 --> 00:12:11,509

 

401
00:12:11,509 --> 00:12:12,790

 

402
00:12:12,790 --> 00:12:16,230

 

403
00:12:16,230 --> 00:12:18,389

 

404
00:12:18,389 --> 00:12:19,670

 

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

 

406
00:12:21,110 --> 00:12:22,790

 

407
00:12:22,790 --> 00:12:22,800

 

408
00:12:22,800 --> 00:12:23,269


409
00:12:23,269 --> 00:12:25,030

 

410
00:12:25,030 --> 00:12:26,550

 

411
00:12:26,550 --> 00:12:28,069

 

412
00:12:28,069 --> 00:12:28,790

 

413
00:12:28,790 --> 00:12:31,350

 

414
00:12:31,350 --> 00:12:33,590

 

415
00:12:33,590 --> 00:12:36,710

 

416
00:12:36,710 --> 00:12:38,470

 

417
00:12:38,470 --> 00:12:40,470

 

418
00:12:40,470 --> 00:12:43,350

 

419
00:12:43,350 --> 00:12:44,470

 

420
00:12:44,470 --> 00:12:47,190

 

421
00:12:47,190 --> 00:12:48,550

 

422
00:12:48,550 --> 00:12:50,870

 

423
00:12:50,870 --> 00:12:52,069

 

424
00:12:52,069 --> 00:12:53,829

 

425
00:12:53,829 --> 00:12:55,590

 

426
00:12:55,590 --> 00:12:57,430

 

427
00:12:57,430 --> 00:12:58,629

 

428
00:12:58,629 --> 00:13:01,750

 

429
00:13:01,750 --> 00:13:04,710

 

430
00:13:04,710 --> 00:13:04,720

 

431
00:13:04,720 --> 00:13:05,670


432
00:13:05,670 --> 00:13:08,150

 

433
00:13:08,150 --> 00:13:09,110

 

434
00:13:09,110 --> 00:13:11,030

 

435
00:13:11,030 --> 00:13:12,790

 

436
00:13:12,790 --> 00:13:15,269

 

437
00:13:15,269 --> 00:13:16,710

 

438
00:13:16,710 --> 00:13:18,550

 

439
00:13:18,550 --> 00:13:20,150

 

440
00:13:20,150 --> 00:13:22,790

 

441
00:13:22,790 --> 00:13:22,800

 

442
00:13:22,800 --> 00:13:23,829


443
00:13:23,829 --> 00:13:27,430

 

444
00:13:27,430 --> 00:13:31,190

 

445
00:13:31,190 --> 00:13:32,790

 

446
00:13:32,790 --> 00:13:34,470

 

447
00:13:34,470 --> 00:13:37,829

 

448
00:13:37,829 --> 00:13:39,990

 

449
00:13:39,990 --> 00:13:41,030

 

450
00:13:41,030 --> 00:13:44,389

 

451
00:13:44,389 --> 00:13:47,189

 

452
00:13:47,189 --> 00:13:48,790

 

453
00:13:48,790 --> 00:13:49,590

 

454
00:13:49,590 --> 00:13:52,790

 

455
00:13:52,790 --> 00:13:55,990

 

456
00:13:55,990 --> 00:13:56,000

 

457
00:13:56,000 --> 00:13:56,629


458
00:13:56,629 --> 00:13:59,189

 

459
00:13:59,189 --> 00:14:00,389

 

460
00:14:00,389 --> 00:14:02,790

 

461
00:14:02,790 --> 00:14:04,389

 

462
00:14:04,389 --> 00:14:05,910

 

463
00:14:05,910 --> 00:14:08,550

 

464
00:14:08,550 --> 00:14:08,560

 

465
00:14:08,560 --> 00:14:09,030


466
00:14:09,030 --> 00:14:10,870

 

467
00:14:10,870 --> 00:14:12,470

 

468
00:14:12,470 --> 00:14:14,310

 

469
00:14:14,310 --> 00:14:15,990

 

470
00:14:15,990 --> 00:14:19,350

 

471
00:14:19,350 --> 00:14:22,710

 

472
00:14:22,710 --> 00:14:24,470

 

473
00:14:24,470 --> 00:14:25,990

 

474
00:14:25,990 --> 00:14:27,590

 

475
00:14:27,590 --> 00:14:30,629

 

476
00:14:30,629 --> 00:14:32,470

 

477
00:14:32,470 --> 00:14:35,670

 

478
00:14:35,670 --> 00:14:37,110

 

479
00:14:37,110 --> 00:14:38,629

 

480
00:14:38,629 --> 00:14:39,990

 

481
00:14:39,990 --> 00:14:43,110

 

482
00:14:43,110 --> 00:14:44,949

 

483
00:14:44,949 --> 00:14:46,470

 

484
00:14:46,470 --> 00:14:48,550

 

485
00:14:48,550 --> 00:14:48,560

 

486
00:14:48,560 --> 00:14:50,470


487
00:14:50,470 --> 00:14:53,590

 

488
00:14:53,590 --> 00:14:54,870

 

489
00:14:54,870 --> 00:14:56,949

 

490
00:14:56,949 --> 00:14:59,990

 

491
00:14:59,990 --> 00:15:00,000

 

492
00:15:00,000 --> 00:15:00,389


493
00:15:00,389 --> 00:15:03,269

 

494
00:15:03,269 --> 00:15:05,670

 

495
00:15:05,670 --> 00:15:07,590

 

496
00:15:07,590 --> 00:15:08,790

 

497
00:15:08,790 --> 00:15:10,310

 

498
00:15:10,310 --> 00:15:12,069

 

499
00:15:12,069 --> 00:15:13,350

 

500
00:15:13,350 --> 00:15:14,710

 

501
00:15:14,710 --> 00:15:16,150

 

502
00:15:16,150 --> 00:15:18,550

 

503
00:15:18,550 --> 00:15:19,670

 

504
00:15:19,670 --> 00:15:20,870

 

505
00:15:20,870 --> 00:15:22,310

 

506
00:15:22,310 --> 00:15:22,320

 

507
00:15:22,320 --> 00:15:23,030


508
00:15:23,030 --> 00:15:24,829

 

509
00:15:24,829 --> 00:15:24,839

 

510
00:15:24,839 --> 00:15:26,230


511
00:15:26,230 --> 00:15:26,240

 

512
00:15:26,240 --> 00:15:30,150


513
00:15:30,150 --> 00:15:33,269

 

514
00:15:33,269 --> 00:15:33,279

 

515
00:15:33,279 --> 00:15:34,230


516
00:15:34,230 --> 00:15:35,590

 

517
00:15:35,590 --> 00:15:38,790

 

518
00:15:38,790 --> 00:15:40,710

 

519
00:15:40,710 --> 00:15:42,949

 

520
00:15:42,949 --> 00:15:45,430

 

521
00:15:45,430 --> 00:15:46,949

 

522
00:15:46,949 --> 00:15:47,910

 

523
00:15:47,910 --> 00:15:49,590

 

524
00:15:49,590 --> 00:15:51,189

 

525
00:15:51,189 --> 00:15:53,110

 

526
00:15:53,110 --> 00:15:54,710

 

527
00:15:54,710 --> 00:15:56,230

 

528
00:15:56,230 --> 00:15:58,949

 

529
00:15:58,949 --> 00:16:01,030

 

530
00:16:01,030 --> 00:16:02,470

 

531
00:16:02,470 --> 00:16:03,350

 

532
00:16:03,350 --> 00:16:05,030

 

533
00:16:05,030 --> 00:16:06,550

 

534
00:16:06,550 --> 00:16:07,910

 

535
00:16:07,910 --> 00:16:08,870

 

536
00:16:08,870 --> 00:16:10,790

 

537
00:16:10,790 --> 00:16:12,069

 

538
00:16:12,069 --> 00:16:14,389

 

539
00:16:14,389 --> 00:16:15,990

 

540
00:16:15,990 --> 00:16:17,509

 

541
00:16:17,509 --> 00:16:19,590

 

542
00:16:19,590 --> 00:16:22,069

 

543
00:16:22,069 --> 00:16:23,350

 

544
00:16:23,350 --> 00:16:24,550

 

545
00:16:24,550 --> 00:16:28,790

 

546
00:16:28,790 --> 00:16:30,790

 

547
00:16:30,790 --> 00:16:32,150

 

548
00:16:32,150 --> 00:16:34,389

 

549
00:16:34,389 --> 00:16:35,509

 

550
00:16:35,509 --> 00:16:38,949

 

551
00:16:38,949 --> 00:16:49,670

 

552
00:16:49,670 --> 00:16:52,069

 

553
00:16:52,069 --> 00:16:53,350

 

554
00:16:53,350 --> 00:16:53,360

 

555
00:16:53,360 --> 00:16:54,150


556
00:16:54,150 --> 00:16:55,749

 

557
00:16:55,749 --> 00:16:57,829

 

558
00:16:57,829 --> 00:17:00,629

 

559
00:17:00,629 --> 00:17:01,990

 

560
00:17:01,990 --> 00:17:03,189

 

561
00:17:03,189 --> 00:17:04,949

 

562
00:17:04,949 --> 00:17:05,990

 

563
00:17:05,990 --> 00:17:09,029

 

564
00:17:09,029 --> 00:17:09,909

 

565
00:17:09,909 --> 00:17:12,870

 

566
00:17:12,870 --> 00:17:14,309

 

567
00:17:14,309 --> 00:17:16,230

 

568
00:17:16,230 --> 00:17:18,309

 

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

 

570
00:17:20,150 --> 00:17:21,510

 

571
00:17:21,510 --> 00:17:23,990

 

572
00:17:23,990 --> 00:17:28,069

 

573
00:17:28,069 --> 00:17:30,070

 

574
00:17:30,070 --> 00:17:31,430

 

575
00:17:31,430 --> 00:17:31,440

 

576
00:17:31,440 --> 00:17:32,150


577
00:17:32,150 --> 00:17:33,909

 

578
00:17:33,909 --> 00:17:36,070

 

579
00:17:36,070 --> 00:17:37,430

 

580
00:17:37,430 --> 00:17:38,789

 

581
00:17:38,789 --> 00:17:40,470

 

582
00:17:40,470 --> 00:17:41,990

 

583
00:17:41,990 --> 00:17:44,230

 

584
00:17:44,230 --> 00:17:47,350

 

585
00:17:47,350 --> 00:17:48,710

 

586
00:17:48,710 --> 00:17:50,870

 

587
00:17:50,870 --> 00:17:53,110

 

588
00:17:53,110 --> 00:17:55,110

 

589
00:17:55,110 --> 00:17:56,310

 

590
00:17:56,310 --> 00:17:58,470

 

591
00:17:58,470 --> 00:18:00,390

 

592
00:18:00,390 --> 00:18:02,549

 

593
00:18:02,549 --> 00:18:03,990

 

594
00:18:03,990 --> 00:18:07,110

 

595
00:18:07,110 --> 00:18:10,150

 

596
00:18:10,150 --> 00:18:10,160

 

597
00:18:10,160 --> 00:18:10,789


598
00:18:10,789 --> 00:18:13,110

 

599
00:18:13,110 --> 00:18:14,630

 

600
00:18:14,630 --> 00:18:16,070

 

601
00:18:16,070 --> 00:18:18,870

 

602
00:18:18,870 --> 00:18:23,430

 

603
00:18:23,430 --> 00:18:25,110

 

604
00:18:25,110 --> 00:18:27,270

 

605
00:18:27,270 --> 00:18:28,549

 

606
00:18:28,549 --> 00:18:30,150

 

607
00:18:30,150 --> 00:18:32,870

 

608
00:18:32,870 --> 00:18:35,190

 

609
00:18:35,190 --> 00:18:36,870

 

610
00:18:36,870 --> 00:18:37,510

 

611
00:18:37,510 --> 00:18:41,190

 

612
00:18:41,190 --> 00:18:43,110

 

613
00:18:43,110 --> 00:18:44,789

 

614
00:18:44,789 --> 00:18:46,150

 

615
00:18:46,150 --> 00:18:47,430

 

616
00:18:47,430 --> 00:18:49,350

 

617
00:18:49,350 --> 00:18:51,029

 

618
00:18:51,029 --> 00:18:53,750

 

619
00:18:53,750 --> 00:18:55,190

 

620
00:18:55,190 --> 00:18:57,270

 

621
00:18:57,270 --> 00:18:58,789

 

622
00:18:58,789 --> 00:19:01,270

 

623
00:19:01,270 --> 00:19:03,669

 

624
00:19:03,669 --> 00:19:05,350

 

625
00:19:05,350 --> 00:19:07,029

 

626
00:19:07,029 --> 00:19:08,070

 

627
00:19:08,070 --> 00:19:10,070

 

628
00:19:10,070 --> 00:19:11,430

 

629
00:19:11,430 --> 00:19:14,390

 

630
00:19:14,390 --> 00:19:16,230

 

631
00:19:16,230 --> 00:19:16,710

 

632
00:19:16,710 --> 00:19:18,789

 

633
00:19:18,789 --> 00:19:20,630

 

634
00:19:20,630 --> 00:19:22,789

 

635
00:19:22,789 --> 00:19:25,430

 

636
00:19:25,430 --> 00:19:27,350

 

637
00:19:27,350 --> 00:19:27,360

 

638
00:19:27,360 --> 00:19:28,470


639
00:19:28,470 --> 00:19:30,070

 

640
00:19:30,070 --> 00:19:30,080

 

641
00:19:30,080 --> 00:19:32,710


642
00:19:32,710 --> 00:19:34,549

 

643
00:19:34,549 --> 00:19:36,230

 

644
00:19:36,230 --> 00:19:37,750

 

645
00:19:37,750 --> 00:19:37,760

 

646
00:19:37,760 --> 00:19:38,950


647
00:19:38,950 --> 00:19:43,110

 

648
00:19:43,110 --> 00:19:50,830

 

649
00:19:50,830 --> 00:19:50,840

 

650
00:19:50,840 --> 00:19:54,950


651
00:19:54,950 --> 00:19:57,990

 

652
00:19:57,990 --> 00:20:00,789

 

653
00:20:00,789 --> 00:20:02,230

 

654
00:20:02,230 --> 00:20:03,750

 

655
00:20:03,750 --> 00:20:05,909

 

656
00:20:05,909 --> 00:20:07,669

 

657
00:20:07,669 --> 00:20:10,870

 

658
00:20:10,870 --> 00:20:12,870

 

659
00:20:12,870 --> 00:20:14,630

 

660
00:20:14,630 --> 00:20:15,430

 

661
00:20:15,430 --> 00:20:17,909

 

662
00:20:17,909 --> 00:20:19,990

 

663
00:20:19,990 --> 00:20:22,630

 

664
00:20:22,630 --> 00:20:22,640

 

665
00:20:22,640 --> 00:20:23,190


666
00:20:23,190 --> 00:20:24,789

 

667
00:20:24,789 --> 00:20:26,870

 

668
00:20:26,870 --> 00:20:28,390

 

669
00:20:28,390 --> 00:20:31,029

 

670
00:20:31,029 --> 00:20:32,870

 

671
00:20:32,870 --> 00:20:35,190

 

672
00:20:35,190 --> 00:20:35,200

 

673
00:20:35,200 --> 00:20:36,549


674
00:20:36,549 --> 00:20:39,029

 

675
00:20:39,029 --> 00:20:41,350

 

676
00:20:41,350 --> 00:20:44,070

 

677
00:20:44,070 --> 00:20:46,310

 

678
00:20:46,310 --> 00:20:49,990

 

679
00:20:49,990 --> 00:20:50,000

 

680
00:20:50,000 --> 00:20:50,310


681
00:20:50,310 --> 00:20:55,350

 

682
00:20:55,350 --> 00:20:58,390

 

683
00:20:58,390 --> 00:20:58,400

 

684
00:20:58,400 --> 00:20:59,750


685
00:20:59,750 --> 00:21:01,430

 

686
00:21:01,430 --> 00:21:03,190

 

687
00:21:03,190 --> 00:21:05,909

 

688
00:21:05,909 --> 00:21:07,430

 

689
00:21:07,430 --> 00:21:09,029

 

690
00:21:09,029 --> 00:21:11,990

 

691
00:21:11,990 --> 00:21:14,230

 

692
00:21:14,230 --> 00:21:17,270

 

693
00:21:17,270 --> 00:21:19,510

 

694
00:21:19,510 --> 00:21:21,430

 

695
00:21:21,430 --> 00:21:22,789

 

696
00:21:22,789 --> 00:21:25,510

 

697
00:21:25,510 --> 00:21:26,710

 

698
00:21:26,710 --> 00:21:28,870

 

699
00:21:28,870 --> 00:21:30,310

 

700
00:21:30,310 --> 00:21:34,149

 

701
00:21:34,149 --> 00:21:37,270

 

702
00:21:37,270 --> 00:21:38,710

 

703
00:21:38,710 --> 00:21:41,029

 

704
00:21:41,029 --> 00:21:42,310

 

705
00:21:42,310 --> 00:21:44,630

 

706
00:21:44,630 --> 00:21:47,669

 

707
00:21:47,669 --> 00:21:52,230

 

708
00:21:52,230 --> 00:21:57,029

 

709
00:21:57,029 --> 00:21:58,470

 

710
00:21:58,470 --> 00:22:00,390

 

711
00:22:00,390 --> 00:22:00,400

 

712
00:22:00,400 --> 00:22:01,110


713
00:22:01,110 --> 00:22:02,870

 

714
00:22:02,870 --> 00:22:05,110

 

715
00:22:05,110 --> 00:22:07,590

 

716
00:22:07,590 --> 00:22:09,830

 

717
00:22:09,830 --> 00:22:13,190

 

718
00:22:13,190 --> 00:22:15,590

 

719
00:22:15,590 --> 00:22:16,870

 

720
00:22:16,870 --> 00:22:19,029

 

721
00:22:19,029 --> 00:22:20,789

 

722
00:22:20,789 --> 00:22:22,310

 

723
00:22:22,310 --> 00:22:24,070

 

724
00:22:24,070 --> 00:22:25,990

 

725
00:22:25,990 --> 00:22:28,390

 

726
00:22:28,390 --> 00:22:30,310

 

727
00:22:30,310 --> 00:22:31,669

 

728
00:22:31,669 --> 00:22:33,990

 

729
00:22:33,990 --> 00:22:35,669

 

730
00:22:35,669 --> 00:22:37,190

 

731
00:22:37,190 --> 00:22:39,190

 

732
00:22:39,190 --> 00:22:40,549

 

733
00:22:40,549 --> 00:22:42,149

 

734
00:22:42,149 --> 00:22:45,029

 

735
00:22:45,029 --> 00:22:45,039

 

736
00:22:45,039 --> 00:22:45,669


737
00:22:45,669 --> 00:22:47,990

 

738
00:22:47,990 --> 00:22:49,270

 

739
00:22:49,270 --> 00:22:49,280

 

740
00:22:49,280 --> 00:22:50,549


741
00:22:50,549 --> 00:22:52,310

 

742
00:22:52,310 --> 00:22:53,590

 

743
00:22:53,590 --> 00:22:53,600

 

744
00:22:53,600 --> 00:22:54,070


745
00:22:54,070 --> 00:22:56,789

 

746
00:22:56,789 --> 00:22:57,909

 

747
00:22:57,909 --> 00:23:01,110

 

748
00:23:01,110 --> 00:23:01,120

 

749
00:23:01,120 --> 00:23:01,430


750
00:23:01,430 --> 00:23:03,270

 

751
00:23:03,270 --> 00:23:05,029

 

752
00:23:05,029 --> 00:23:07,909

 

753
00:23:07,909 --> 00:23:08,630

 

754
00:23:08,630 --> 00:23:10,870

 

755
00:23:10,870 --> 00:23:12,470

 

756
00:23:12,470 --> 00:23:14,549

 

757
00:23:14,549 --> 00:23:16,070

 

758
00:23:16,070 --> 00:23:18,710

 

759
00:23:18,710 --> 00:23:20,149

 

760
00:23:20,149 --> 00:23:22,549

 

761
00:23:22,549 --> 00:23:24,149

 

762
00:23:24,149 --> 00:23:25,430

 

763
00:23:25,430 --> 00:23:27,590

 

764
00:23:27,590 --> 00:23:29,590

 

765
00:23:29,590 --> 00:23:32,230

 

766
00:23:32,230 --> 00:23:34,310

 

767
00:23:34,310 --> 00:23:38,070

 

768
00:23:38,070 --> 00:23:41,669

 

769
00:23:41,669 --> 00:23:43,110

 

770
00:23:43,110 --> 00:23:44,149

 

771
00:23:44,149 --> 00:23:47,669

 

772
00:23:47,669 --> 00:23:49,350

 

773
00:23:49,350 --> 00:23:51,029

 

774
00:23:51,029 --> 00:23:53,029

 

775
00:23:53,029 --> 00:23:53,039

 

776
00:23:53,039 --> 00:23:54,230


777
00:23:54,230 --> 00:23:56,310

 

778
00:23:56,310 --> 00:23:56,320

 

779
00:23:56,320 --> 00:23:58,149


780
00:23:58,149 --> 00:23:59,750

 

781
00:23:59,750 --> 00:24:01,350

 

782
00:24:01,350 --> 00:24:02,549

 

783
00:24:02,549 --> 00:24:03,990

 

784
00:24:03,990 --> 00:24:05,590

 

785
00:24:05,590 --> 00:24:06,870

 

786
00:24:06,870 --> 00:24:09,830

 

787
00:24:09,830 --> 00:24:11,350

 

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

 

789
00:24:12,710 --> 00:24:14,549

 

790
00:24:14,549 --> 00:24:18,149

 

791
00:24:18,149 --> 00:24:21,029

 

792
00:24:21,029 --> 00:24:23,350

 

793
00:24:23,350 --> 00:24:25,029

 

794
00:24:25,029 --> 00:24:27,830

 

795
00:24:27,830 --> 00:24:29,669

 

796
00:24:29,669 --> 00:24:31,590

 

797
00:24:31,590 --> 00:24:35,029

 

798
00:24:35,029 --> 00:24:37,669

 

799
00:24:37,669 --> 00:24:40,710

 

800
00:24:40,710 --> 00:24:42,630

 

801
00:24:42,630 --> 00:24:45,430

 

802
00:24:45,430 --> 00:24:46,950

 

803
00:24:46,950 --> 00:24:48,070

 

804
00:24:48,070 --> 00:24:50,549

 

805
00:24:50,549 --> 00:24:50,559

 

806
00:24:50,559 --> 00:24:51,350


807
00:24:51,350 --> 00:24:54,549

 

808
00:24:54,549 --> 00:24:58,310

 

809
00:24:58,310 --> 00:25:01,430

 

810
00:25:01,430 --> 00:25:03,190

 

811
00:25:03,190 --> 00:25:05,350

 

812
00:25:05,350 --> 00:25:06,549

 

813
00:25:06,549 --> 00:25:08,070

 

814
00:25:08,070 --> 00:25:10,149

 

815
00:25:10,149 --> 00:25:12,830

 

816
00:25:12,830 --> 00:25:12,840

 

817
00:25:12,840 --> 00:25:14,470


818
00:25:14,470 --> 00:25:16,630

 

819
00:25:16,630 --> 00:25:18,390

 

820
00:25:18,390 --> 00:25:20,549

 

821
00:25:20,549 --> 00:25:23,430

 

822
00:25:23,430 --> 00:25:24,870

 

823
00:25:24,870 --> 00:25:27,350

 

824
00:25:27,350 --> 00:25:29,029

 

825
00:25:29,029 --> 00:25:31,430

 

826
00:25:31,430 --> 00:25:31,990

 

827
00:25:31,990 --> 00:25:33,990

 

828
00:25:33,990 --> 00:25:35,510

 

829
00:25:35,510 --> 00:25:37,909

 

830
00:25:37,909 --> 00:25:39,669

 

831
00:25:39,669 --> 00:25:41,990

 

832
00:25:41,990 --> 00:25:45,029

 

833
00:25:45,029 --> 00:25:45,039

 

834
00:25:45,039 --> 00:25:45,430


835
00:25:45,430 --> 00:25:48,310

 

836
00:25:48,310 --> 00:25:49,750

 

837
00:25:49,750 --> 00:25:52,549

 

838
00:25:52,549 --> 00:25:53,750

 

839
00:25:53,750 --> 00:25:55,590

 

840
00:25:55,590 --> 00:25:57,350

 

841
00:25:57,350 --> 00:25:57,360

 

842
00:25:57,360 --> 00:25:58,789


843
00:25:58,789 --> 00:26:01,029

 

844
00:26:01,029 --> 00:26:02,070

 

845
00:26:02,070 --> 00:26:05,430

 

846
00:26:05,430 --> 00:26:08,630

 

847
00:26:08,630 --> 00:26:12,070

 

848
00:26:12,070 --> 00:26:14,149

 

849
00:26:14,149 --> 00:26:15,510

 

850
00:26:15,510 --> 00:26:17,669

 

851
00:26:17,669 --> 00:26:17,679

 

852
00:26:17,679 --> 00:26:18,950


853
00:26:18,950 --> 00:26:21,909

 

854
00:26:21,909 --> 00:26:23,510

 

855
00:26:23,510 --> 00:26:26,630

 

856
00:26:26,630 --> 00:26:28,710

 

857
00:26:28,710 --> 00:26:31,190

 

858
00:26:31,190 --> 00:26:34,390

 

859
00:26:34,390 --> 00:26:36,549

 

860
00:26:36,549 --> 00:26:37,750

 

861
00:26:37,750 --> 00:26:39,590

 

862
00:26:39,590 --> 00:26:41,190

 

863
00:26:41,190 --> 00:26:42,870

 

864
00:26:42,870 --> 00:26:46,390

 

865
00:26:46,390 --> 00:26:50,870

 

866
00:26:50,870 --> 00:26:56,230

 

867
00:26:56,230 --> 00:26:59,190

 

868
00:26:59,190 --> 00:26:59,669

 

869
00:26:59,669 --> 00:27:03,110

 

870
00:27:03,110 --> 00:27:07,029

 

871
00:27:07,029 --> 00:27:09,830

 

872
00:27:09,830 --> 00:27:13,350

 

873
00:27:13,350 --> 00:27:15,830

 

874
00:27:15,830 --> 00:27:17,029

 

875
00:27:17,029 --> 00:27:19,750

 

876
00:27:19,750 --> 00:27:22,789

 

877
00:27:22,789 --> 00:27:24,549

 

878
00:27:24,549 --> 00:27:24,559

 

879
00:27:24,559 --> 00:27:26,710


880
00:27:26,710 --> 00:27:28,549

 

881
00:27:28,549 --> 00:27:30,070

 

882
00:27:30,070 --> 00:27:32,389

 

883
00:27:32,389 --> 00:27:34,789

 

884
00:27:34,789 --> 00:27:36,230

 

885
00:27:36,230 --> 00:27:37,269

 

886
00:27:37,269 --> 00:27:38,950

 

887
00:27:38,950 --> 00:27:40,630

 

888
00:27:40,630 --> 00:27:40,640

 

889
00:27:40,640 --> 00:27:41,190


890
00:27:41,190 --> 00:27:44,870

 

891
00:27:44,870 --> 00:27:46,710

 

892
00:27:46,710 --> 00:27:48,070

 

893
00:27:48,070 --> 00:27:50,389

 

894
00:27:50,389 --> 00:27:51,350

 

895
00:27:51,350 --> 00:27:55,510

 

896
00:27:55,510 --> 00:27:57,190

 

897
00:27:57,190 --> 00:28:00,070

 

898
00:28:00,070 --> 00:28:01,750

 

899
00:28:01,750 --> 00:28:03,590

 

900
00:28:03,590 --> 00:28:06,630

 

901
00:28:06,630 --> 00:28:08,389

 

902
00:28:08,389 --> 00:28:09,990

 

903
00:28:09,990 --> 00:28:11,269

 

904
00:28:11,269 --> 00:28:12,630

 

905
00:28:12,630 --> 00:28:13,590

 

906
00:28:13,590 --> 00:28:16,710

 

907
00:28:16,710 --> 00:28:20,470

 

908
00:28:20,470 --> 00:28:24,149

 

909
00:28:24,149 --> 00:28:25,590

 

910
00:28:25,590 --> 00:28:27,029

 

911
00:28:27,029 --> 00:28:28,710

 

912
00:28:28,710 --> 00:28:30,950

 

913
00:28:30,950 --> 00:28:33,110

 

914
00:28:33,110 --> 00:28:35,830

 

915
00:28:35,830 --> 00:28:36,549

 

916
00:28:36,549 --> 00:28:38,710

 

917
00:28:38,710 --> 00:28:39,750

 

918
00:28:39,750 --> 00:28:41,350

 

919
00:28:41,350 --> 00:28:42,870

 

920
00:28:42,870 --> 00:28:44,070

 

921
00:28:44,070 --> 00:28:46,070

 

922
00:28:46,070 --> 00:28:47,269

 

923
00:28:47,269 --> 00:28:52,310

 

924
00:28:52,310 --> 00:28:54,470

 

925
00:28:54,470 --> 00:28:54,480

 

926
00:28:54,480 --> 00:28:55,830


927
00:28:55,830 --> 00:28:58,070

 

928
00:28:58,070 --> 00:28:59,350

 

929
00:28:59,350 --> 00:29:01,350

 

930
00:29:01,350 --> 00:29:02,710

 

931
00:29:02,710 --> 00:29:03,990

 

932
00:29:03,990 --> 00:29:06,789

 

933
00:29:06,789 --> 00:29:08,470

 

934
00:29:08,470 --> 00:29:10,830

 

935
00:29:10,830 --> 00:29:13,990

 

936
00:29:13,990 --> 00:29:15,110

 

937
00:29:15,110 --> 00:29:17,110

 

938
00:29:17,110 --> 00:29:18,310

 

939
00:29:18,310 --> 00:29:20,549

 

940
00:29:20,549 --> 00:29:21,909

 

941
00:29:21,909 --> 00:29:26,070

 

942
00:29:26,070 --> 00:29:28,630

 

943
00:29:28,630 --> 00:29:28,640

 

944
00:29:28,640 --> 00:29:29,430


945
00:29:29,430 --> 00:29:32,310

 

946
00:29:32,310 --> 00:29:34,710

 

947
00:29:34,710 --> 00:29:37,830

 

948
00:29:37,830 --> 00:29:39,669

 

949
00:29:39,669 --> 00:29:40,870

 

950
00:29:40,870 --> 00:29:43,350

 

951
00:29:43,350 --> 00:29:46,389

 

952
00:29:46,389 --> 00:29:48,389

 

953
00:29:48,389 --> 00:29:50,310

 

954
00:29:50,310 --> 00:29:51,510

 

955
00:29:51,510 --> 00:29:54,310

 

956
00:29:54,310 --> 00:29:56,470

 

957
00:29:56,470 --> 00:29:57,750

 

958
00:29:57,750 --> 00:29:59,029

 

959
00:29:59,029 --> 00:30:03,590

 

960
00:30:03,590 --> 00:30:07,029

 

961
00:30:07,029 --> 00:30:08,310

 

962
00:30:08,310 --> 00:30:16,149

 

963
00:30:16,149 --> 00:30:21,029

 

964
00:30:21,029 --> 00:30:23,430

 

965
00:30:23,430 --> 00:30:25,510

 

966
00:30:25,510 --> 00:30:30,389

 

967
00:30:30,389 --> 00:30:33,750

 

968
00:30:33,750 --> 00:30:38,230

 

969
00:30:38,230 --> 00:30:39,430

 

970
00:30:39,430 --> 00:30:42,230

 

971
00:30:42,230 --> 00:30:45,990

 

972
00:30:45,990 --> 00:30:48,630

 

973
00:30:48,630 --> 00:30:50,549

 

974
00:30:50,549 --> 00:30:54,630

 

975
00:30:54,630 --> 00:30:55,909

 

976
00:30:55,909 --> 00:31:01,590

 

977
00:31:01,590 --> 00:31:03,509

 

978
00:31:03,509 --> 00:31:03,519

 

979
00:31:03,519 --> 00:31:07,590


980
00:31:07,590 --> 00:31:09,590

 

981
00:31:09,590 --> 00:31:10,630

 

982
00:31:10,630 --> 00:31:12,549

 

983
00:31:12,549 --> 00:31:16,149

 

984
00:31:16,149 --> 00:31:17,350

 

985
00:31:17,350 --> 00:31:18,710

 

986
00:31:18,710 --> 00:31:19,830

 

987
00:31:19,830 --> 00:31:23,269

 

988
00:31:23,269 --> 00:31:24,950

 

989
00:31:24,950 --> 00:31:26,789

 

990
00:31:26,789 --> 00:31:29,029

 

991
00:31:29,029 --> 00:31:30,310

 

992
00:31:30,310 --> 00:31:32,389

 

993
00:31:32,389 --> 00:31:33,990

 

994
00:31:33,990 --> 00:31:34,000

 

995
00:31:34,000 --> 00:31:34,630


996
00:31:34,630 --> 00:31:37,750

 

997
00:31:37,750 --> 00:31:39,430

 

998
00:31:39,430 --> 00:31:41,430

 

999
00:31:41,430 --> 00:31:42,710

 

1000
00:31:42,710 --> 00:31:44,149

 

1001
00:31:44,149 --> 00:31:45,590

 

1002
00:31:45,590 --> 00:31:45,600

 

1003
00:31:45,600 --> 00:31:45,990


1004
00:31:45,990 --> 00:31:48,630

 

1005
00:31:48,630 --> 00:31:50,950

 

1006
00:31:50,950 --> 00:31:53,190

 

1007
00:31:53,190 --> 00:31:54,310

 

1008
00:31:54,310 --> 00:31:56,149

 

1009
00:31:56,149 --> 00:31:59,669

 

1010
00:31:59,669 --> 00:32:01,269

 

1011
00:32:01,269 --> 00:32:03,110

 

1012
00:32:03,110 --> 00:32:04,789

 

1013
00:32:04,789 --> 00:32:06,230

 

1014
00:32:06,230 --> 00:32:08,310

 

1015
00:32:08,310 --> 00:32:10,230

 

1016
00:32:10,230 --> 00:32:12,789

 

1017
00:32:12,789 --> 00:32:14,070

 

1018
00:32:14,070 --> 00:32:16,230

 

1019
00:32:16,230 --> 00:32:17,590

 

1020
00:32:17,590 --> 00:32:18,549

 

1021
00:32:18,549 --> 00:32:20,470

 

1022
00:32:20,470 --> 00:32:23,190

 

1023
00:32:23,190 --> 00:32:27,110

 

1024
00:32:27,110 --> 00:32:30,389

 

1025
00:32:30,389 --> 00:32:32,070

 

1026
00:32:32,070 --> 00:32:33,509

 

1027
00:32:33,509 --> 00:32:35,909

 

1028
00:32:35,909 --> 00:32:37,430

 

1029
00:32:37,430 --> 00:32:39,029

 

1030
00:32:39,029 --> 00:32:39,039

 

1031
00:32:39,039 --> 00:32:39,830


1032
00:32:39,830 --> 00:32:41,509

 

1033
00:32:41,509 --> 00:32:43,590

 

1034
00:32:43,590 --> 00:32:46,950

 

1035
00:32:46,950 --> 00:32:48,470

 

1036
00:32:48,470 --> 00:32:49,830

 

1037
00:32:49,830 --> 00:32:51,430

 

1038
00:32:51,430 --> 00:32:53,509

 

1039
00:32:53,509 --> 00:32:54,870

 

1040
00:32:54,870 --> 00:32:56,149

 

1041
00:32:56,149 --> 00:32:57,909

 

1042
00:32:57,909 --> 00:32:59,509

 

1043
00:32:59,509 --> 00:33:01,990

 

1044
00:33:01,990 --> 00:33:03,909

 

1045
00:33:03,909 --> 00:33:05,509

 

1046
00:33:05,509 --> 00:33:08,070

 

1047
00:33:08,070 --> 00:33:09,990

 

1048
00:33:09,990 --> 00:33:12,470

 

1049
00:33:12,470 --> 00:33:14,230

 

1050
00:33:14,230 --> 00:33:15,990

 

1051
00:33:15,990 --> 00:33:17,269

 

1052
00:33:17,269 --> 00:33:17,750

 

1053
00:33:17,750 --> 00:33:21,430

 

1054
00:33:21,430 --> 00:33:23,990

 

1055
00:33:23,990 --> 00:33:25,110

 

1056
00:33:25,110 --> 00:33:26,950

 

1057
00:33:26,950 --> 00:33:28,710

 

1058
00:33:28,710 --> 00:33:31,190

 

1059
00:33:31,190 --> 00:33:33,350

 

1060
00:33:33,350 --> 00:33:35,269

 

1061
00:33:35,269 --> 00:33:36,950

 

1062
00:33:36,950 --> 00:33:40,470

 

1063
00:33:40,470 --> 00:33:43,750

 

1064
00:33:43,750 --> 00:33:47,190

 

1065
00:33:47,190 --> 00:33:48,789

 

1066
00:33:48,789 --> 00:33:52,710

 

1067
00:33:52,710 --> 00:33:55,029

 

1068
00:33:55,029 --> 00:33:56,630

 

1069
00:33:56,630 --> 00:33:56,640

 

1070
00:33:56,640 --> 00:33:58,470


1071
00:33:58,470 --> 00:34:00,549

 

1072
00:34:00,549 --> 00:34:01,590

 

1073
00:34:01,590 --> 00:34:04,950

 

1074
00:34:04,950 --> 00:34:07,669

 

1075
00:34:07,669 --> 00:34:09,190

 

1076
00:34:09,190 --> 00:34:11,909

 

1077
00:34:11,909 --> 00:34:13,349

 

1078
00:34:13,349 --> 00:34:15,510

 

1079
00:34:15,510 --> 00:34:16,869

 

1080
00:34:16,869 --> 00:34:18,710

 

1081
00:34:18,710 --> 00:34:21,589

 

1082
00:34:21,589 --> 00:34:23,109

 

1083
00:34:23,109 --> 00:34:25,430

 

1084
00:34:25,430 --> 00:34:26,550

 

1085
00:34:26,550 --> 00:34:28,069

 

1086
00:34:28,069 --> 00:34:29,990

 

1087
00:34:29,990 --> 00:34:33,109

 

1088
00:34:33,109 --> 00:34:36,149

 

1089
00:34:36,149 --> 00:34:36,790

 

1090
00:34:36,790 --> 00:34:39,829

 

1091
00:34:39,829 --> 00:34:39,839

 

1092
00:34:39,839 --> 00:34:40,310


1093
00:34:40,310 --> 00:34:42,550

 

1094
00:34:42,550 --> 00:34:44,389

 

1095
00:34:44,389 --> 00:34:47,510

 

1096
00:34:47,510 --> 00:34:49,190

 

1097
00:34:49,190 --> 00:34:51,349

 

1098
00:34:51,349 --> 00:34:53,109

 

1099
00:34:53,109 --> 00:34:54,629

 

1100
00:34:54,629 --> 00:34:57,349

 

1101
00:34:57,349 --> 00:34:59,430

 

1102
00:34:59,430 --> 00:35:02,790

 

1103
00:35:02,790 --> 00:35:05,270

 

1104
00:35:05,270 --> 00:35:07,829

 

1105
00:35:07,829 --> 00:35:11,349

 

1106
00:35:11,349 --> 00:35:13,190

 

1107
00:35:13,190 --> 00:35:14,710

 

1108
00:35:14,710 --> 00:35:18,390

 

1109
00:35:18,390 --> 00:35:20,550

 

1110
00:35:20,550 --> 00:35:22,150

 

1111
00:35:22,150 --> 00:35:24,470

 

1112
00:35:24,470 --> 00:35:26,230

 

1113
00:35:26,230 --> 00:35:27,750

 

1114
00:35:27,750 --> 00:35:29,349

 

1115
00:35:29,349 --> 00:35:30,950

 

1116
00:35:30,950 --> 00:35:33,670

 

1117
00:35:33,670 --> 00:35:35,589

 

1118
00:35:35,589 --> 00:35:37,270

 

1119
00:35:37,270 --> 00:35:42,390

 

1120
00:35:42,390 --> 00:35:45,829

 

1121
00:35:45,829 --> 00:35:47,109

 

1122
00:35:47,109 --> 00:35:48,870

 

1123
00:35:48,870 --> 00:35:53,349

 

1124
00:35:53,349 --> 00:35:56,790

 

1125
00:35:56,790 --> 00:35:58,150

 

1126
00:35:58,150 --> 00:36:00,550

 

1127
00:36:00,550 --> 00:36:03,349

 

1128
00:36:03,349 --> 00:36:06,230

 

1129
00:36:06,230 --> 00:36:07,589

 

1130
00:36:07,589 --> 00:36:09,670

 

1131
00:36:09,670 --> 00:36:09,680

 

1132
00:36:09,680 --> 00:36:10,710


1133
00:36:10,710 --> 00:36:12,790

 

1134
00:36:12,790 --> 00:36:14,230

 

1135
00:36:14,230 --> 00:36:15,670

 

1136
00:36:15,670 --> 00:36:16,630

 

1137
00:36:16,630 --> 00:36:17,990

 

1138
00:36:17,990 --> 00:36:19,670

 

1139
00:36:19,670 --> 00:36:21,750

 

1140
00:36:21,750 --> 00:36:23,349

 

1141
00:36:23,349 --> 00:36:25,270

 

1142
00:36:25,270 --> 00:36:28,790

 

1143
00:36:28,790 --> 00:36:31,990

 

1144
00:36:31,990 --> 00:36:33,510

 

1145
00:36:33,510 --> 00:36:35,190

 

1146
00:36:35,190 --> 00:36:37,670

 

1147
00:36:37,670 --> 00:36:39,030

 

1148
00:36:39,030 --> 00:36:41,910

 

1149
00:36:41,910 --> 00:36:42,790

 

1150
00:36:42,790 --> 00:36:45,510

 

1151
00:36:45,510 --> 00:36:47,510

 

1152
00:36:47,510 --> 00:36:50,630

 

1153
00:36:50,630 --> 00:36:52,470

 

1154
00:36:52,470 --> 00:36:54,069

 

1155
00:36:54,069 --> 00:36:55,510

 

1156
00:36:55,510 --> 00:36:58,390

 

1157
00:36:58,390 --> 00:37:00,069

 

1158
00:37:00,069 --> 00:37:03,349

 

1159
00:37:03,349 --> 00:37:03,359

 

1160
00:37:03,359 --> 00:37:04,710


1161
00:37:04,710 --> 00:37:06,470

 

1162
00:37:06,470 --> 00:37:08,150

 

1163
00:37:08,150 --> 00:37:10,390

 

1164
00:37:10,390 --> 00:37:11,510

 

1165
00:37:11,510 --> 00:37:12,710

 

1166
00:37:12,710 --> 00:37:15,430

 

1167
00:37:15,430 --> 00:37:16,790

 

1168
00:37:16,790 --> 00:37:17,910

 

1169
00:37:17,910 --> 00:37:20,630

 

1170
00:37:20,630 --> 00:37:21,990

 

1171
00:37:21,990 --> 00:37:24,310

 

1172
00:37:24,310 --> 00:37:25,190

 

1173
00:37:25,190 --> 00:37:26,550

 

1174
00:37:26,550 --> 00:37:29,270

 

1175
00:37:29,270 --> 00:37:31,349

 

1176
00:37:31,349 --> 00:37:33,270

 

1177
00:37:33,270 --> 00:37:34,870

 

1178
00:37:34,870 --> 00:37:37,349

 

1179
00:37:37,349 --> 00:37:39,910

 

1180
00:37:39,910 --> 00:37:41,750

 

1181
00:37:41,750 --> 00:37:43,670

 

1182
00:37:43,670 --> 00:37:45,349

 

1183
00:37:45,349 --> 00:37:46,790

 

1184
00:37:46,790 --> 00:37:48,230

 

1185
00:37:48,230 --> 00:37:49,750

 

1186
00:37:49,750 --> 00:37:53,190

 

1187
00:37:53,190 --> 00:37:54,870

 

1188
00:37:54,870 --> 00:37:59,349

 

1189
00:37:59,349 --> 00:38:00,470

 

1190
00:38:00,470 --> 00:38:02,790

 

1191
00:38:02,790 --> 00:38:04,550

 

1192
00:38:04,550 --> 00:38:06,790

 

1193
00:38:06,790 --> 00:38:06,800

 

1194
00:38:06,800 --> 00:38:07,349


1195
00:38:07,349 --> 00:38:13,190

 

1196
00:38:13,190 --> 00:38:15,270

 

1197
00:38:15,270 --> 00:38:16,870

 

1198
00:38:16,870 --> 00:38:18,390

 

1199
00:38:18,390 --> 00:38:20,790

 

1200
00:38:20,790 --> 00:38:22,870

 

1201
00:38:22,870 --> 00:38:24,470

 

1202
00:38:24,470 --> 00:38:24,480

 

1203
00:38:24,480 --> 00:38:25,270


1204
00:38:25,270 --> 00:38:27,589

 

1205
00:38:27,589 --> 00:38:29,349

 

1206
00:38:29,349 --> 00:38:29,359

 

1207
00:38:29,359 --> 00:38:30,150


1208
00:38:30,150 --> 00:38:33,270

 

1209
00:38:33,270 --> 00:38:35,270

 

1210
00:38:35,270 --> 00:38:36,550

 

1211
00:38:36,550 --> 00:38:39,589

 

1212
00:38:39,589 --> 00:38:41,589

 

1213
00:38:41,589 --> 00:38:43,670

 

1214
00:38:43,670 --> 00:38:45,990

 

1215
00:38:45,990 --> 00:38:47,750

 

1216
00:38:47,750 --> 00:38:49,910

 

1217
00:38:49,910 --> 00:38:51,510

 

1218
00:38:51,510 --> 00:38:52,950

 

1219
00:38:52,950 --> 00:38:57,109

 

1220
00:38:57,109 --> 00:38:59,750

 

1221
00:38:59,750 --> 00:39:01,589

 

1222
00:39:01,589 --> 00:39:03,670

 

1223
00:39:03,670 --> 00:39:05,430

 

1224
00:39:05,430 --> 00:39:07,589

 

1225
00:39:07,589 --> 00:39:09,589

 

1226
00:39:09,589 --> 00:39:11,750

 

1227
00:39:11,750 --> 00:39:13,670

 

1228
00:39:13,670 --> 00:39:15,589

 

1229
00:39:15,589 --> 00:39:15,599

 

1230
00:39:15,599 --> 00:39:16,310


1231
00:39:16,310 --> 00:39:17,829

 

1232
00:39:17,829 --> 00:39:20,310

 

1233
00:39:20,310 --> 00:39:22,550

 

1234
00:39:22,550 --> 00:39:24,069

 

1235
00:39:24,069 --> 00:39:24,079

 

1236
00:39:24,079 --> 00:39:24,470


1237
00:39:24,470 --> 00:39:28,069

 

1238
00:39:28,069 --> 00:39:28,790

 

1239
00:39:28,790 --> 00:39:30,230

 

1240
00:39:30,230 --> 00:39:31,990

 

1241
00:39:31,990 --> 00:39:33,910

 

1242
00:39:33,910 --> 00:39:36,710

 

1243
00:39:36,710 --> 00:39:38,710

 

1244
00:39:38,710 --> 00:39:40,150

 

1245
00:39:40,150 --> 00:39:42,390

 

1246
00:39:42,390 --> 00:39:44,550

 

1247
00:39:44,550 --> 00:39:45,670

 

1248
00:39:45,670 --> 00:39:47,990

 

1249
00:39:47,990 --> 00:39:49,750

 

1250
00:39:49,750 --> 00:39:51,990

 

1251
00:39:51,990 --> 00:39:53,750

 

1252
00:39:53,750 --> 00:39:56,310

 

1253
00:39:56,310 --> 00:39:57,670

 

1254
00:39:57,670 --> 00:39:58,950

 

1255
00:39:58,950 --> 00:40:04,390

 

1256
00:40:04,390 --> 00:40:08,950

 

1257
00:40:08,950 --> 00:40:11,510

 

1258
00:40:11,510 --> 00:40:12,710

 

1259
00:40:12,710 --> 00:40:14,309

 

1260
00:40:14,309 --> 00:40:15,910

 

1261
00:40:15,910 --> 00:40:15,920

 

1262
00:40:15,920 --> 00:40:16,870


1263
00:40:16,870 --> 00:40:18,470

 

1264
00:40:18,470 --> 00:40:20,790

 

1265
00:40:20,790 --> 00:40:22,230

 

1266
00:40:22,230 --> 00:40:24,069

 

1267
00:40:24,069 --> 00:40:25,270

 

1268
00:40:25,270 --> 00:40:26,630

 

1269
00:40:26,630 --> 00:40:28,309

 

1270
00:40:28,309 --> 00:40:29,589

 

1271
00:40:29,589 --> 00:40:32,550

 

1272
00:40:32,550 --> 00:40:33,829

 

1273
00:40:33,829 --> 00:40:35,670

 

1274
00:40:35,670 --> 00:40:37,670

 

1275
00:40:37,670 --> 00:40:40,390

 

1276
00:40:40,390 --> 00:40:44,309

 

1277
00:40:44,309 --> 00:40:47,030

 

1278
00:40:47,030 --> 00:40:48,470

 

1279
00:40:48,470 --> 00:40:48,480

 

1280
00:40:48,480 --> 00:40:49,030


1281
00:40:49,030 --> 00:40:51,349

 

1282
00:40:51,349 --> 00:40:52,309

 

1283
00:40:52,309 --> 00:40:53,430

 

1284
00:40:53,430 --> 00:40:55,270

 

1285
00:40:55,270 --> 00:40:56,950

 

1286
00:40:56,950 --> 00:40:59,670

 

1287
00:40:59,670 --> 00:41:01,109

 

1288
00:41:01,109 --> 00:41:04,390

 

1289
00:41:04,390 --> 00:41:06,309

 

1290
00:41:06,309 --> 00:41:06,319

 

1291
00:41:06,319 --> 00:41:07,990


1292
00:41:07,990 --> 00:41:10,069

 

1293
00:41:10,069 --> 00:41:11,750

 

1294
00:41:11,750 --> 00:41:14,790

 

1295
00:41:14,790 --> 00:41:15,510

 

1296
00:41:15,510 --> 00:41:17,270

 

1297
00:41:17,270 --> 00:41:18,390

 

1298
00:41:18,390 --> 00:41:19,670

 

1299
00:41:19,670 --> 00:41:21,589

 

1300
00:41:21,589 --> 00:41:23,589

 

1301
00:41:23,589 --> 00:41:26,150

 

1302
00:41:26,150 --> 00:41:26,160

 

1303
00:41:26,160 --> 00:41:26,790


1304
00:41:26,790 --> 00:41:29,510

 

1305
00:41:29,510 --> 00:41:29,990

 

1306
00:41:29,990 --> 00:41:35,430

 

1307
00:41:35,430 --> 00:41:37,829

 

1308
00:41:37,829 --> 00:41:40,069

 

1309
00:41:40,069 --> 00:41:40,079

 

1310
00:41:40,079 --> 00:41:40,390


1311
00:41:40,390 --> 00:41:43,829

 

1312
00:41:43,829 --> 00:41:45,109

 

1313
00:41:45,109 --> 00:41:46,950

 

1314
00:41:46,950 --> 00:41:49,750

 

1315
00:41:49,750 --> 00:41:49,760

 

1316
00:41:49,760 --> 00:41:50,790


1317
00:41:50,790 --> 00:41:53,270

 

1318
00:41:53,270 --> 00:41:54,630

 

1319
00:41:54,630 --> 00:41:57,589

 

1320
00:41:57,589 --> 00:41:58,710

 

1321
00:41:58,710 --> 00:42:01,510

 

1322
00:42:01,510 --> 00:42:01,520

 

1323
00:42:01,520 --> 00:42:02,069


1324
00:42:02,069 --> 00:42:04,710

 

1325
00:42:04,710 --> 00:42:04,720

 

1326
00:42:04,720 --> 00:42:05,190


1327
00:42:05,190 --> 00:42:07,030

 

1328
00:42:07,030 --> 00:42:12,309

 

1329
00:42:12,309 --> 00:42:14,309

 

1330
00:42:14,309 --> 00:42:15,349

 

1331
00:42:15,349 --> 00:42:17,270

 

1332
00:42:17,270 --> 00:42:18,870

 

1333
00:42:18,870 --> 00:42:21,910

 

1334
00:42:21,910 --> 00:42:23,990

 

1335
00:42:23,990 --> 00:42:26,870

 

1336
00:42:26,870 --> 00:42:27,990

 

1337
00:42:27,990 --> 00:42:29,589

 

1338
00:42:29,589 --> 00:42:32,790

 

1339
00:42:32,790 --> 00:42:35,349

 

1340
00:42:35,349 --> 00:42:37,589

 

1341
00:42:37,589 --> 00:42:39,510

 

1342
00:42:39,510 --> 00:42:41,030

 

1343
00:42:41,030 --> 00:42:43,990

 

1344
00:42:43,990 --> 00:42:45,430

 

1345
00:42:45,430 --> 00:42:47,190

 

1346
00:42:47,190 --> 00:42:49,270

 

1347
00:42:49,270 --> 00:42:50,870

 

1348
00:42:50,870 --> 00:42:53,750

 

1349
00:42:53,750 --> 00:42:55,190

 

1350
00:42:55,190 --> 00:42:57,750

 

1351
00:42:57,750 --> 00:42:59,829

 

1352
00:42:59,829 --> 00:43:01,030

 

1353
00:43:01,030 --> 00:43:02,950

 

1354
00:43:02,950 --> 00:43:05,109

 

1355
00:43:05,109 --> 00:43:06,950

 

1356
00:43:06,950 --> 00:43:08,790

 

1357
00:43:08,790 --> 00:43:10,790

 

1358
00:43:10,790 --> 00:43:11,990

 

1359
00:43:11,990 --> 00:43:15,190

 

1360
00:43:15,190 --> 00:43:16,950

 

1361
00:43:16,950 --> 00:43:18,230

 

1362
00:43:18,230 --> 00:43:21,109

 

1363
00:43:21,109 --> 00:43:22,630

 

1364
00:43:22,630 --> 00:43:24,390

 

1365
00:43:24,390 --> 00:43:28,230

 

1366
00:43:28,230 --> 00:43:29,670

 

1367
00:43:29,670 --> 00:43:31,589

 

1368
00:43:31,589 --> 00:43:32,550

 

1369
00:43:32,550 --> 00:43:36,150

 

1370
00:43:36,150 --> 00:43:36,160

 

1371
00:43:36,160 --> 00:43:37,589


1372
00:43:37,589 --> 00:43:41,829

 

1373
00:43:41,829 --> 00:43:43,270

 

1374
00:43:43,270 --> 00:43:44,950

 

1375
00:43:44,950 --> 00:43:46,790

 

1376
00:43:46,790 --> 00:43:48,710

 

1377
00:43:48,710 --> 00:43:50,230

 

1378
00:43:50,230 --> 00:43:51,670

 

1379
00:43:51,670 --> 00:43:53,589

 

1380
00:43:53,589 --> 00:43:55,670

 

1381
00:43:55,670 --> 00:43:57,030

 

1382
00:43:57,030 --> 00:43:58,710

 

1383
00:43:58,710 --> 00:44:00,470

 

1384
00:44:00,470 --> 00:44:01,349

 

1385
00:44:01,349 --> 00:44:04,069

 

1386
00:44:04,069 --> 00:44:05,510

 

1387
00:44:05,510 --> 00:44:08,069

 

1388
00:44:08,069 --> 00:44:08,950

 

1389
00:44:08,950 --> 00:44:10,950

 

1390
00:44:10,950 --> 00:44:13,589

 

1391
00:44:13,589 --> 00:44:16,069

 

1392
00:44:16,069 --> 00:44:18,069

 

1393
00:44:18,069 --> 00:44:18,079

 

1394
00:44:18,079 --> 00:44:18,630


1395
00:44:18,630 --> 00:44:20,790

 

1396
00:44:20,790 --> 00:44:23,030

 

1397
00:44:23,030 --> 00:44:24,950

 

1398
00:44:24,950 --> 00:44:27,510

 

1399
00:44:27,510 --> 00:44:30,710

 

1400
00:44:30,710 --> 00:44:32,470

 

1401
00:44:32,470 --> 00:44:34,710

 

1402
00:44:34,710 --> 00:44:36,390

 

1403
00:44:36,390 --> 00:44:37,990

 

1404
00:44:37,990 --> 00:44:38,870

 

1405
00:44:38,870 --> 00:44:40,470

 

1406
00:44:40,470 --> 00:44:42,390

 

1407
00:44:42,390 --> 00:44:45,190

 

1408
00:44:45,190 --> 00:44:46,230

 

1409
00:44:46,230 --> 00:44:48,230

 

1410
00:44:48,230 --> 00:44:50,230

 

1411
00:44:50,230 --> 00:44:50,240

 

1412
00:44:50,240 --> 00:44:53,510


1413
00:44:53,510 --> 00:44:55,750

 

1414
00:44:55,750 --> 00:44:57,190

 

1415
00:44:57,190 --> 00:45:00,790

 

1416
00:45:00,790 --> 00:45:05,030

 

1417
00:45:05,030 --> 00:45:07,990

 

1418
00:45:07,990 --> 00:45:09,270

 

1419
00:45:09,270 --> 00:45:11,109

 

1420
00:45:11,109 --> 00:45:13,109

 

1421
00:45:13,109 --> 00:45:15,270

 

1422
00:45:15,270 --> 00:45:15,280

 

1423
00:45:15,280 --> 00:45:16,630


1424
00:45:16,630 --> 00:45:19,589

 

1425
00:45:19,589 --> 00:45:20,870

 

1426
00:45:20,870 --> 00:45:22,710

 

1427
00:45:22,710 --> 00:45:24,390

 

1428
00:45:24,390 --> 00:45:26,069

 

1429
00:45:26,069 --> 00:45:28,150

 

1430
00:45:28,150 --> 00:45:28,160

 

1431
00:45:28,160 --> 00:45:29,190


1432
00:45:29,190 --> 00:45:31,829

 

1433
00:45:31,829 --> 00:45:33,030

 

1434
00:45:33,030 --> 00:45:33,990

 

1435
00:45:33,990 --> 00:45:35,750

 

1436
00:45:35,750 --> 00:45:37,270

 

1437
00:45:37,270 --> 00:45:38,870

 

1438
00:45:38,870 --> 00:45:40,790

 

1439
00:45:40,790 --> 00:45:43,990

 

1440
00:45:43,990 --> 00:45:46,309

 

1441
00:45:46,309 --> 00:45:47,430

 

1442
00:45:47,430 --> 00:45:51,829

 

1443
00:45:51,829 --> 00:45:54,550

 

1444
00:45:54,550 --> 00:45:54,560

 

1445
00:45:54,560 --> 00:45:55,670


1446
00:45:55,670 --> 00:45:57,190

 

1447
00:45:57,190 --> 00:45:59,030

 

1448
00:45:59,030 --> 00:46:00,150

 

1449
00:46:00,150 --> 00:46:02,950

 

1450
00:46:02,950 --> 00:46:02,960

 

1451
00:46:02,960 --> 00:46:03,750


1452
00:46:03,750 --> 00:46:05,589

 

1453
00:46:05,589 --> 00:46:07,030

 

1454
00:46:07,030 --> 00:46:08,150

 

1455
00:46:08,150 --> 00:46:10,630

 

1456
00:46:10,630 --> 00:46:12,150

 

1457
00:46:12,150 --> 00:46:14,630

 

1458
00:46:14,630 --> 00:46:17,670

 

1459
00:46:17,670 --> 00:46:19,270

 

1460
00:46:19,270 --> 00:46:20,710

 

1461
00:46:20,710 --> 00:46:20,720

 

1462
00:46:20,720 --> 00:46:21,430


1463
00:46:21,430 --> 00:46:23,829

 

1464
00:46:23,829 --> 00:46:25,270

 

1465
00:46:25,270 --> 00:46:26,470

 

1466
00:46:26,470 --> 00:46:28,950

 

1467
00:46:28,950 --> 00:46:28,960

 

1468
00:46:28,960 --> 00:46:30,470


1469
00:46:30,470 --> 00:46:33,910

 

1470
00:46:33,910 --> 00:46:35,349

 

1471
00:46:35,349 --> 00:46:36,950

 

1472
00:46:36,950 --> 00:46:38,470

 

1473
00:46:38,470 --> 00:46:39,670

 

1474
00:46:39,670 --> 00:46:41,430

 

1475
00:46:41,430 --> 00:46:43,190

 

1476
00:46:43,190 --> 00:46:45,750

 

1477
00:46:45,750 --> 00:46:49,349

 

1478
00:46:49,349 --> 00:46:52,710

 

1479
00:46:52,710 --> 00:46:55,349

 

1480
00:46:55,349 --> 00:46:55,359

 

1481
00:46:55,359 --> 00:46:56,790


1482
00:46:56,790 --> 00:46:58,710

 

1483
00:46:58,710 --> 00:47:00,710

 

1484
00:47:00,710 --> 00:47:02,950

 

1485
00:47:02,950 --> 00:47:03,990

 

1486
00:47:03,990 --> 00:47:06,950

 

1487
00:47:06,950 --> 00:47:08,470

 

1488
00:47:08,470 --> 00:47:10,550

 

1489
00:47:10,550 --> 00:47:12,390

 

1490
00:47:12,390 --> 00:47:13,990

 

1491
00:47:13,990 --> 00:47:15,910

 

1492
00:47:15,910 --> 00:47:18,230

 

1493
00:47:18,230 --> 00:47:19,990

 

1494
00:47:19,990 --> 00:47:21,990

 

1495
00:47:21,990 --> 00:47:23,750

 

1496
00:47:23,750 --> 00:47:25,270

 

1497
00:47:25,270 --> 00:47:26,390

 

1498
00:47:26,390 --> 00:47:29,430

 

1499
00:47:29,430 --> 00:47:30,630

 

1500
00:47:30,630 --> 00:47:33,589

 

1501
00:47:33,589 --> 00:47:35,349

 

1502
00:47:35,349 --> 00:47:37,270

 

1503
00:47:37,270 --> 00:47:38,390

 

1504
00:47:38,390 --> 00:47:40,470

 

1505
00:47:40,470 --> 00:47:42,870

 

1506
00:47:42,870 --> 00:47:44,230

 

1507
00:47:44,230 --> 00:47:46,549

 

1508
00:47:46,549 --> 00:47:47,829

 

1509
00:47:47,829 --> 00:47:49,109

 

1510
00:47:49,109 --> 00:47:51,190

 

1511
00:47:51,190 --> 00:47:53,030

 

1512
00:47:53,030 --> 00:47:53,040

 

1513
00:47:53,040 --> 00:47:54,230


1514
00:47:54,230 --> 00:47:56,230

 

1515
00:47:56,230 --> 00:47:58,230

 

1516
00:47:58,230 --> 00:48:01,109

 

1517
00:48:01,109 --> 00:48:03,030

 

1518
00:48:03,030 --> 00:48:04,790

 

1519
00:48:04,790 --> 00:48:06,069

 

1520
00:48:06,069 --> 00:48:09,190

 

1521
00:48:09,190 --> 00:48:11,510

 

1522
00:48:11,510 --> 00:48:11,520

 

1523
00:48:11,520 --> 00:48:12,309


1524
00:48:12,309 --> 00:48:15,030

 

1525
00:48:15,030 --> 00:48:15,990

 

1526
00:48:15,990 --> 00:48:17,349

 

1527
00:48:17,349 --> 00:48:19,109

 

1528
00:48:19,109 --> 00:48:19,119

 

1529
00:48:19,119 --> 00:48:20,150


1530
00:48:20,150 --> 00:48:23,430

 

1531
00:48:23,430 --> 00:48:25,990

 

1532
00:48:25,990 --> 00:48:26,000

 

1533
00:48:26,000 --> 00:48:26,790


1534
00:48:26,790 --> 00:48:29,910

 

1535
00:48:29,910 --> 00:48:31,109

 

1536
00:48:31,109 --> 00:48:32,549

 

1537
00:48:32,549 --> 00:48:34,390

 

1538
00:48:34,390 --> 00:48:35,589

 

1539
00:48:35,589 --> 00:48:37,750

 

1540
00:48:37,750 --> 00:48:39,510

 

1541
00:48:39,510 --> 00:48:41,109

 

1542
00:48:41,109 --> 00:48:42,470

 

1543
00:48:42,470 --> 00:48:44,390

 

1544
00:48:44,390 --> 00:48:45,910

 

1545
00:48:45,910 --> 00:48:48,069

 

1546
00:48:48,069 --> 00:48:49,589

 

1547
00:48:49,589 --> 00:48:51,589

 

1548
00:48:51,589 --> 00:48:53,190

 

1549
00:48:53,190 --> 00:48:55,910

 

1550
00:48:55,910 --> 00:48:57,829

 

1551
00:48:57,829 --> 00:48:59,990

 

1552
00:48:59,990 --> 00:49:01,349

 

1553
00:49:01,349 --> 00:49:02,069

 

1554
00:49:02,069 --> 00:49:05,589

 

1555
00:49:05,589 --> 00:49:05,599

 

1556
00:49:05,599 --> 00:49:06,309


1557
00:49:06,309 --> 00:49:07,829

 

1558
00:49:07,829 --> 00:49:09,109

 

1559
00:49:09,109 --> 00:49:10,870

 

1560
00:49:10,870 --> 00:49:12,470

 

1561
00:49:12,470 --> 00:49:15,030

 

1562
00:49:15,030 --> 00:49:18,390

 

1563
00:49:18,390 --> 00:49:23,589

 

1564
00:49:23,589 --> 00:49:34,309

 

1565
00:49:34,309 --> 00:49:34,319

 

1566
00:49:34,319 --> 00:49:36,400